(PHP 4, PHP 5, PHP 7, PHP 8)
round — Arrondit un nombre à virgule flottante
$num, int $precision = 0, int|RoundingMode $mode = RoundingMode::HalfAwayFromZero): float
Retourne la valeur arrondie de num
à la précision precision (nombre de
chiffres après la virgule). Le paramètre precision
peut être négatif ou null : c'est sa valeur par défaut.
numLa valeur à arrondir.
precisionLe nombre optionnel de décimales à arrondir.
Si le paramètre precision est positif,
num sera arrondi en utilisant le paramètre
precision pour définir le nombre significatif
de chiffres après le point décimal.
Si le paramètre precision est négatif,
num arrondi en utilisant le paramètre
precision pour définir le nombre significatif
de chiffres avant le point décimal, i.e. le multiple le plus proche
de pow(10, -$precision), i.e. pour une
precision de -1, num
sera arrondi à 10, pour une precision de -2 à 100, etc.
modeUtilisez RoundingMode ou l'une des constantes suivantes pour spécifier la méthode d'arrondi.
| Constantes | Description |
|---|---|
PHP_ROUND_HALF_UP |
Arrondit num en s'éloignant de zéro lorsqu'il
est à mi-chemin, arrondissant ainsi 1.5 à 2, et -1.5 à -2.
|
PHP_ROUND_HALF_DOWN |
Arrondit num en se rapprochant de zéro lorsqu'il
est à mi-chemin, arrondissant ainsi 1.5 à 1, et -1.5 à -1.
|
PHP_ROUND_HALF_EVEN |
Arrondit num à la valeur paire la plus proche
lorsqu'il est à mi-chemin, arrondissant ainsi 1.5 et 2.5 à 2.
|
PHP_ROUND_HALF_ODD |
Arrondit num à la valeur impaire la plus proche
lorsqu'il est à mi-chemin, arrondissant ainsi 1.5 à 1 et 2.5 à 3.
|
La valeur arrondie à la precision donnée en tant que nombre décimal.
La fonction lance une ValueError si mode est invalide.
Antérieur à PHP 8.4.0, un mode invalide était silencieusement convertie en PHP_ROUND_HALF_UP.
| Version | Description |
|---|---|
| 8.4.0 | Quatre nouvelles méthodes d'arrondi ont été ajoutés. |
| 8.4.0 |
Lance désormais une ValueError si
mode est invalide.
|
| 8.0.0 |
num n'accepte plus les objets internes qui supporte
les conversions numériques.
|
Exemple #1 Exemple avec round()
<?php
var_dump(round(3.4));
var_dump(round(3.5));
var_dump(round(3.6));
var_dump(round(3.6, 0));
var_dump(round(5.045, 2));
var_dump(round(5.055, 2));
var_dump(round(345, -2));
var_dump(round(345, -3));
var_dump(round(678, -2));
var_dump(round(678, -3));
?>L'exemple ci-dessus va afficher :
float(3) float(4) float(4) float(4) float(5.05) float(5.06) float(300) float(0) float(700) float(1000)
Exemple #2 Comment precision affecte un flottant
<?php
$number = 135.79;
var_dump(round($number, 3));
var_dump(round($number, 2));
var_dump(round($number, 1));
var_dump(round($number, 0));
var_dump(round($number, -1));
var_dump(round($number, -2));
var_dump(round($number, -3));
?>L'exemple ci-dessus va afficher :
float(135.79) float(135.79) float(135.8) float(136) float(140) float(100) float(0)
Exemple #3 Exemple avec mode
<?php
echo "Méthode d'arrondi avec 9.5" . PHP_EOL;
var_dump(round(9.5, 0, PHP_ROUND_HALF_UP));
var_dump(round(9.5, 0, PHP_ROUND_HALF_DOWN));
var_dump(round(9.5, 0, PHP_ROUND_HALF_EVEN));
var_dump(round(9.5, 0, PHP_ROUND_HALF_ODD));
echo PHP_EOL;
echo "Méthode d'arrondi avec 8.5" . PHP_EOL;
var_dump(round(8.5, 0, PHP_ROUND_HALF_UP));
var_dump(round(8.5, 0, PHP_ROUND_HALF_DOWN));
var_dump(round(8.5, 0, PHP_ROUND_HALF_EVEN));
var_dump(round(8.5, 0, PHP_ROUND_HALF_ODD));
?>L'exemple ci-dessus va afficher :
Méthode d'arrondi avec 9.5 float(10) float(9) float(10) float(9) Méthode d'arrondi avec 8.5 float(9) float(8) float(8) float(9)
Exemple #4 Exemple avec mode et precision
<?php
echo "Utilisation de PHP_ROUND_HALF_UP avec une précision d'une décimale" . PHP_EOL;
var_dump(round( 1.55, 1, PHP_ROUND_HALF_UP));
var_dump(round(-1.55, 1, PHP_ROUND_HALF_UP));
echo PHP_EOL;
echo "Utilisation de PHP_ROUND_HALF_DOWN avec une précision d'une décimale" . PHP_EOL;
var_dump(round( 1.55, 1, PHP_ROUND_HALF_DOWN));
var_dump(round(-1.55, 1, PHP_ROUND_HALF_DOWN));
echo PHP_EOL;
echo "Utilisation de PHP_ROUND_HALF_EVEN avec une précision d'une décimale" . PHP_EOL;
var_dump(round( 1.55, 1, PHP_ROUND_HALF_EVEN));
var_dump(round(-1.55, 1, PHP_ROUND_HALF_EVEN));
echo PHP_EOL;
echo "Utilisation de PHP_ROUND_HALF_ODD avec une précision d'une décimale" . PHP_EOL;
var_dump(round( 1.55, 1, PHP_ROUND_HALF_ODD));
var_dump(round(-1.55, 1, PHP_ROUND_HALF_ODD));
?>L'exemple ci-dessus va afficher :
Utilisation de PHP_ROUND_HALF_UP avec une précision d'une décimale float(1.6) float(-1.6) Utilisation de PHP_ROUND_HALF_DOWN avec une précision d'une décimale float(1.5) float(-1.5) Utilisation de PHP_ROUND_HALF_EVEN avec une précision d'une décimale float(1.6) float(-1.6) Utilisation de PHP_ROUND_HALF_ODD avec une précision d'une décimale float(1.5) float(-1.5)
Exemple #5 Exemple d'utilisation de RoundingMode
<?php
foreach (RoundingMode::cases() as $mode) {
foreach ([
8.5,
9.5,
-3.5,
] as $number) {
printf("%-17s: %+.17g -> %+.17g\n", $mode->name, $number, round($number, 0, $mode));
}
echo "\n";
}
?>L'exemple ci-dessus va afficher :
HalfAwayFromZero : +8.5 -> +9 HalfAwayFromZero : +9.5 -> +10 HalfAwayFromZero : -3.5 -> -4 HalfTowardsZero : +8.5 -> +8 HalfTowardsZero : +9.5 -> +9 HalfTowardsZero : -3.5 -> -3 HalfEven : +8.5 -> +8 HalfEven : +9.5 -> +10 HalfEven : -3.5 -> -4 HalfOdd : +8.5 -> +9 HalfOdd : +9.5 -> +9 HalfOdd : -3.5 -> -3 TowardsZero : +8.5 -> +8 TowardsZero : +9.5 -> +9 TowardsZero : -3.5 -> -3 AwayFromZero : +8.5 -> +9 AwayFromZero : +9.5 -> +10 AwayFromZero : -3.5 -> -4 NegativeInfinity : +8.5 -> +8 NegativeInfinity : +9.5 -> +9 NegativeInfinity : -3.5 -> -4 PositiveInfinity : +8.5 -> +9 PositiveInfinity : +9.5 -> +10 PositiveInfinity : -3.5 -> -3
In my opinion this function lacks two flags:
- PHP_ROUND_UP - Always round up.
- PHP_ROUND_DOWN - Always round down.
In accounting, it's often necessary to always round up, or down to a precision of thousandths.
<?php
function round_up($number, $precision = 2)
{
$fig = (int) str_pad('1', $precision, '0');
return (ceil($number * $fig) / $fig);
}
function round_down($number, $precision = 2)
{
$fig = (int) str_pad('1', $precision, '0');
return (floor($number * $fig) / $fig);
}
?>As PHP doesn't have a a native number truncate function, this is my solution - a function that can be usefull if you need truncate instead round a number.
<?php
/**
* Truncate a float number, example: <code>truncate(-1.49999, 2); // returns -1.49
* truncate(.49999, 3); // returns 0.499
* </code>
* @param float $val Float number to be truncate
* @param int f Number of precision
* @return float
*/
function truncate($val, $f="0")
{
if(($p = strpos($val, '.')) !== false) {
$val = floatval(substr($val, 0, $p + 1 + $f));
}
return $val;
}
?>
Originally posted in http://stackoverflow.com/a/12710283/1596489If you have negative zero and you need return positive number simple add +0:
$number = -2.38419e-07;
var_dump(round($number,1));//float(-0)
var_dump(round($number,1) + 0);//float(0)I discovered that under some conditions you can get rounding errors with round when converting the number to a string afterwards.
To fix this I swapped round() for number_format().
Unfortunately i cant give an example (because the number cant be represented as a string !)
essentially I had round(0.688888889,2);
which would stay as 0.68888889 when printed as a string.
But using number_format it correctly became 0.69.Unexpected result or misunderstanding (php v5.5.9)
<?php
echo round(1.55, 1, PHP_ROUND_HALF_DOWN); // 1.5
echo round(1.551, 1, PHP_ROUND_HALF_DOWN); //1.6
?>function mround($val, $f=2, $d=6){
return sprintf("%".$d.".".$f."f", $val);
}
echo mround(34.89999); //34.90If you'd only want to round for displaying variables (not for calculating on the rounded result) then you should use printf with the float:
<?php printf ("%6.2f",3.39532); ?>
This returns: 3.40 .Here is function that rounds to a specified increment, but always up. I had to use it for price adjustment that always went up to $5 increments.
<?php
function roundUpTo($number, $increments) {
$increments = 1 / $increments;
return (ceil($number * $increments) / $increments);
}
?>this function (as all mathematical operators) takes care of the setlocale setting, resulting in some weirdness when using the result where the english math notation is expected, as the printout of the result in a width: style attribute!
<?php
$a=3/4;
echo round($a, 2); // 0.75
setlocale(LC_ALL, 'it_IT@euro', 'it_IT', 'it');
$b=3/4;
echo round($b,2); // 0,75
?>This function will let you round to an arbitrary non-zero number. Zero of course causes a division by zero.
<?php
function roundTo($number, $to){
return round($number/$to, 0)* $to;
}
echo roundTo(87.23, 20); //80
echo roundTo(-87.23, 20); //-80
echo roundTo(87.23, .25); //87.25
echo roundTo(.23, .25); //.25
?>/**
* Round to first significant digit
* +N to +infinity
* -N to -infinity
*
*/
function round1stSignificant ( $N ) {
if ( $N === 0 ) {
return 0;
}
$x = floor ( log10 ( abs( $N ) ) );
return ( $N > 0 )
? ceil( $N * pow ( 10, $x * -1 ) ) * pow( 10, $x )
: floor( $N * pow ( 10, $x * -1 ) ) * pow( 10, $x );
}
echo round1stSignificant( 39144818 ) . PHP_EOL;
echo round1stSignificant( 124818 ) . PHP_EOL;
echo round1stSignificant( 0.07468 ) . PHP_EOL;
echo round1stSignificant( 0 ) . PHP_EOL;
echo round1stSignificant( -0.07468 ) . PHP_EOL;
/**
* Output
*
* 40000000
* 200000
* 0.08
* 0
* -0.08
*
*/Here's a function to round to an arbitary number of significant digits. Don't confuse it with rounding to a negative precision - that counts back from the decimal point, this function counts forward from the Most Significant Digit.
ex:
<?php
round(1241757, -3); // 1242000
RoundSigDigs(1241757, 3); // 1240000
?>
Works on negative numbers too. $sigdigs should be >= 0
<?php
function RoundSigDigs($number, $sigdigs) {
$multiplier = 1;
while ($number < 0.1) {
$number *= 10;
$multiplier /= 10;
}
while ($number >= 1) {
$number /= 10;
$multiplier *= 10;
}
return round($number, $sigdigs) * $multiplier;
}
?>round() will sometimes return E notation when rounding a float when the amount is small enough - see https://bugs.php.net/bug.php?id=44223 . Apparently it's a feature.
To work around this "feature" when converting to a string, surround your round statement with an sprintf:
sprintf("%.10f", round( $amountToBeRounded, 10));