round - Redondea al múltiplo de cinco más cercano en PHP

redondear php hacia arriba

Question

Quiero una función php que devuelva 55 cuando la llame con 52.

Probé la función round() :

echo round(94, -1); // 90

Devuelve 90 pero quiero 95 .

Gracias.

Answer 1

1. Divide por 5
2. round() (o ceil() si quieres redondear siempre )
3. Multiplicar por 5.

El valor 5 (la resolución / granularidad) puede ser cualquier cosa, reemplazarlo en los pasos 1 y 3

Answer 2

Acabo de escribir esta función en 20 minutos, en base a muchos resultados que encontré aquí y allá, ¡no sé por qué funciona o cómo funciona! :RE

Estaba principalmente interesado en convertir los números de moneda de este 151431.1 LBP a 150000.0 LBP. (151431.1 LBP == ~ 100 USD) que funciona perfectamente hasta ahora, sin embargo intenté hacerlo de alguna manera compatible con otras monedas y números, ¡pero no estoy seguro si funciona bien!

/**
* Example:
* Input = 151431.1 >> return = 150000.0
* Input = 17204.13 >> return = 17000.0
* Input = 2358.533 >> return = 2350.0
* Input = 129.2421 >> return = 125.0
* Input = 12.16434 >> return = 10.0
*
* @param $value
* @param int $modBase
*
* @return float
*/
private function currenciesBeautifier($value, int $modBase = 5)
{
// round the value to the nearest
$roundedValue = round($value);
// count the number of digits before the dot
$count = strlen((int)str_replace(''.'', '''', $roundedValue));
// remove 3 to get how many zeros to add the mod base
$numberOfZeros = $count - 3;
// add the zeros to the mod base
$mod = str_pad($modBase, $numberOfZeros + 1, ''0'', STR_PAD_RIGHT);
// do the magic
return $roundedValue - ($roundedValue % $mod);
}

Siéntete libre de modificarlo y arreglarlo si hay algo mal

Answer 3

Aquí está mi versión de Musthafa''s función de Musthafa''s . Este es más complejo pero tiene soporte para números Float así como enteros. El número que se redondeará también puede estar en una cadena.

/**
* @desc This function will round up a number to the nearest rounding number specified.
* @param $n (Integer || Float) Required -> The original number. Ex. $n = 5.7;
* @param $x (Integer) Optional -> The nearest number to round up to. The default value is 5. Ex. $x = 3;
* @return (Integer) The original number rounded up to the nearest rounding number.
*/
function rounduptoany ($n, $x = 5) {
//If the original number is an integer and is a multiple of
//the "nearest rounding number", return it without change.
if ((intval($n) == $n) && (!is_float(intval($n) / $x))) {
return intval($n);
}
//If the original number is a float or if this integer is
//not a multiple of the "nearest rounding number", do the
//rounding up.
else {
return round(($n + $x / 2) / $x) * $x;
}
}

Musthafa''s las funciones de , Musthafa''s e incluso la sugerencia de Praesagus . No tienen soporte para los números de Float y las soluciones de Musthafa''s y Praesagus no funcionan correctamente en algunos números. Pruebe los siguientes números de prueba y haga la comparación usted mismo:

$x= 5;
$n= 200; // D = 200 K = 200 M = 200 P = 205
$n= 205; // D = 205 K = 205 M = 205 P = 210
$n= 200.50; // D = 205 K = 200 M = 200.5 P = 205.5
$n= ''210.50''; // D = 215 K = 210 M = 210.5 P = 215.5
$n= 201; // D = 205 K = 205 M = 200 P = 205
$n= 202; // D = 205 K = 205 M = 200 P = 205
$n= 203; // D = 205 K = 205 M = 205 P = 205
** D = DrupalFever K = Knight M = Musthafa P = Praesagus

Answer 4

De la biblioteca Gears

MathType::roundStep(50, 5); // 50
MathType::roundStep(52, 5); // 50
MathType::roundStep(53, 5); // 55
MathType::floorStep(50, 5); // 50
MathType::floorStep(52, 5); // 50
MathType::floorStep(53, 5); // 50
MathType::ceilStep(50, 5); // 50
MathType::ceilStep(52, 5); // 55
MathType::ceilStep(53, 5); // 55

Fuente:

public static function roundStep($value, int $step = 1)
{
return round($value / $step) * $step;
}
public static function floorStep($value, int $step = 1)
{
return floor($value / $step) * $step;
}
public static function ceilStep($value, int $step = 1)
{
return ceil($value / $step) * $step;
}

Answer 5

Esto se puede lograr de varias maneras, dependiendo de su convención de redondeo preferida:

1. Redondea al siguiente múltiplo de 5, excluye el número actual

Comportamiento: 50 salidas 55, 52 salidas 55

function roundUpToAny($n,$x=5) {
return round(($n+$x/2)/$x)*$x;
}

2. Redondea al múltiplo de 5 más cercano , incluye el número actual

Comportamiento: 50 salidas 50, 52 salidas 55, 50.25 salidas 50

function roundUpToAny($n,$x=5) {
return (round($n)%$x === 0) ? round($n) : round(($n+$x/2)/$x)*$x;
}

3. Redondea hasta un número entero, luego al múltiplo de 5 más cercano

Comportamiento: 50 salidas 50, 52 salidas 55, 50.25 salidas 55

function roundUpToAny($n,$x=5) {
return (ceil($n)%$x === 0) ? ceil($n) : round(($n+$x/2)/$x)*$x;
}

Answer 6

Lo hago así:

private function roundUpToAny(int $n, $x = 9)
{
return (floor($n / 10) * 10) + $x;
}

Pruebas:

assert($this->roundUpToAny(0, 9) == 9);
assert($this->roundUpToAny(1, 9) == 9);
assert($this->roundUpToAny(2, 9) == 9);
assert($this->roundUpToAny(3, 9) == 9);
assert($this->roundUpToAny(4, 9) == 9);
assert($this->roundUpToAny(5, 9) == 9);
assert($this->roundUpToAny(6, 9) == 9);
assert($this->roundUpToAny(7, 9) == 9);
assert($this->roundUpToAny(8, 9) == 9);
assert($this->roundUpToAny(9, 9) == 9);
assert($this->roundUpToAny(10, 9) == 19);
assert($this->roundUpToAny(11, 9) == 19);
assert($this->roundUpToAny(12, 9) == 19);
assert($this->roundUpToAny(13, 9) == 19);
assert($this->roundUpToAny(14, 9) == 19);
assert($this->roundUpToAny(15, 9) == 19);
assert($this->roundUpToAny(16, 9) == 19);
assert($this->roundUpToAny(17, 9) == 19);
assert($this->roundUpToAny(18, 9) == 19);
assert($this->roundUpToAny(19, 9) == 19);

Answer 7

Multiplica por 2, redondea a -1, divide por 2.

Answer 8

Prueba esta pequeña función que escribí.

function ceilFive($number) {
$div = floor($number / 5);
$mod = $number % 5;
If ($mod > 0) $add = 5;
Else $add = 0;
return $div * 5 + $add;
}
echo ceilFive(52);

Answer 9

Redondear a la baja:

$x = floor($x/5) * 5;

Redondeo:

$x = ceil($x/5) * 5;

Redondea al más cercano (arriba o abajo):

$x = round($x/5) * 5;

Answer 10

 echo $value - ($value % 5);

Sé que es una vieja pregunta, pero en mi humilde opinión, el uso del operador de módulo es la mejor manera, y mucho más elegante que la respuesta aceptada.

Answer 11

function round_up($n, $x = 5) {
$rem = $n % $x;
if ($rem < 3)
return $n - $rem;
else
return $n - $rem + $x;
}