round - ¿Cómo redondear al 10(o 100 o X) más cercano?

numero de decimales en r

Question

Estoy escribiendo una función para trazar datos. Me gustaría especificar un buen número redondo para el max eje y que sea mayor que el máximo del conjunto de datos.

Específicamente, me gustaría una función foo que realice lo siguiente:

foo(4) == 5
foo(6.1) == 10 #maybe 7 would be better
foo(30.1) == 40
foo(100.1) == 110

He llegado tan lejos como

foo <- function(x) ceiling(max(x)/10)*10

para redondear al 10 más cercano, pero esto no funciona para los intervalos de redondeo arbitrarios.

¿Hay una mejor manera de hacer esto en R?

Answer 1

Redondee CUALQUIER número arriba / abajo a CUALQUIER intervalo

Puede redondear fácilmente los números a un intervalo específico utilizando el operador de módulo %% .

La función:

round.choose <- function(x, roundTo, dir = 1) {
if(dir == 1) { ##ROUND UP
x + (roundTo - x %% roundTo)
} else {
if(dir == 0) { ##ROUND DOWN
x - (x %% roundTo)
}
}
}

Ejemplos:

> round.choose(17,5,1) #round 17 UP to the next 5th
[1] 20
> round.choose(17,5,0) #round 17 DOWN to the next 5th
[1] 15
> round.choose(17,2,1) #round 17 UP to the next even number
[1] 18
> round.choose(17,2,0) #round 17 DOWN to the next even number
[1] 16

Cómo funciona:

El operador de módulo %% determina el resto de dividir el primer número entre el 2 °. Agregar o restar este intervalo a su número de interés puede esencialmente ''redondear'' el número a un intervalo de su elección.

> 7 + (5 - 7 %% 5) #round UP to the nearest 5
[1] 10
> 7 + (10 - 7 %% 10) #round UP to the nearest 10
[1] 10
> 7 + (2 - 7 %% 2) #round UP to the nearest even number
[1] 8
> 7 + (100 - 7 %% 100) #round UP to the nearest 100
[1] 100
> 7 + (4 - 7 %% 4) #round UP to the nearest interval of 4
[1] 8
> 7 + (4.5 - 7 %% 4.5) #round UP to the nearest interval of 4.5
[1] 9
> 7 - (7 %% 5) #round DOWN to the nearest 5
[1] 5
> 7 - (7 %% 10) #round DOWN to the nearest 10
[1] 0
> 7 - (7 %% 2) #round DOWN to the nearest even number
[1] 6

Actualizar:

La conveniente versión de 2 argumentos:

rounder <- function(x,y) {
if(y >= 0) { x + (y - x %% y)}
else { x - (x %% abs(y))}
}

Los valores positivos y roundUp , mientras que los valores negativos roundDown :

 # rounder(7, -4.5) = 4.5, while rounder(7, 4.5) = 9.

O....

Función que redondea automáticamente ARRIBA o ABAJO según las reglas estándar de redondeo:

Round <- function(x,y) {
if((y - x %% y) <= x %% y) { x + (y - x %% y)}
else { x - (x %% y)}
}

Se redondea automáticamente si el valor de x es > mitad de camino entre instancias posteriores del valor de redondeo y :

# Round(1.3,1) = 1 while Round(1.6,1) = 2
# Round(1.024,0.05) = 1 while Round(1.03,0.05) = 1.05

Answer 2

¡Intenté esto sin utilizar ninguna biblioteca externa o funciones crípticas y funciona!

Espero que ayude a alguien.

ceil <- function(val, multiple){
div = val/multiple
int_div = as.integer(div)
return (int_div * multiple + ceiling(div - int_div) * multiple)
}
> ceil(2.1, 2.2)
[1] 2.2
> ceil(3, 2.2)
[1] 4.4
> ceil(5, 10)
[1] 10
> ceil(0, 10)
[1] 0

Answer 3

Creo que tu código funciona muy bien con una pequeña modificación:

foo <- function(x, round=10) ceiling(max(x+10^-9)/round + 1/round)*round

Y tus ejemplos se ejecutan:

> foo(4, round=1) == 5
[1] TRUE
> foo(6.1) == 10 #maybe 7 would be better
[1] TRUE
> foo(6.1, round=1) == 7 # you got 7
[1] TRUE
> foo(30.1) == 40
[1] TRUE
> foo(100.1) == 110
[1] TRUE
> # ALL in one:
> foo(c(4, 6.1, 30.1, 100))
[1] 110
> foo(c(4, 6.1, 30.1, 100), round=10)
[1] 110
> foo(c(4, 6.1, 30.1, 100), round=2.3)
[1] 101.2

Alteré tu función de dos maneras:

• agregado segundo argumento (para su X especificada)
• agregó un valor pequeño ( =1e-09 , ¡siéntase libre de modificar!) al max(x) si quiere un número mayor

Answer 4

En cuanto al redondeo hasta la multiplicidad de un número arbitrario , por ejemplo, 10, aquí hay una alternativa simple a la respuesta de James.

Funciona para cualquier número real redondeado hacia arriba ( from ) y cualquier número positivo real redondeado a ( to ):

> RoundUp <- function(from,to) ceiling(from/to)*to

Ejemplo:

> RoundUp(-11,10)
[1] -10
> RoundUp(-0.1,10)
[1] 0
> RoundUp(0,10)
[1] 0
> RoundUp(8.9,10)
[1] 10
> RoundUp(135,10)
[1] 140
> RoundUp(from=c(1.3,2.4,5.6),to=1.1)
[1] 2.2 3.3 6.6

Answer 5

Encontrará una versión mejorada de la respuesta de Tommy que tiene en cuenta varios casos:

• Elegir entre límite inferior o superior
• Tomando en cuenta valores negativos y cero
• dos niveles de escala diferentes en caso de que quiera que la función redondee números pequeños y grandes de manera diferente. Ejemplo: 4 se redondearía a 0 mientras que 400 se redondearía a 400.

Debajo del código:

round.up.nice <- function(x, lower_bound = TRUE, nice_small=c(0,5,10), nice_big=c(1,2,3,4,5,6,7,8,9,10)) {
if (abs(x) > 100) {
nice = nice_big
} else {
nice = nice_small
}
if (lower_bound == TRUE) {
if (x > 0) {
return(10^floor(log10(x)) * nice[[max(which(x >= 10^floor(log10(x)) * nice))[[1]]]])
} else if (x < 0) {
return(- 10^floor(log10(-x)) * nice[[min(which(-x <= 10^floor(log10(-x)) * nice))[[1]]]])
} else {
return(0)
}
} else {
if (x > 0) {
return(10^floor(log10(x)) * nice[[min(which(x <= 10^floor(log10(x)) * nice))[[1]]]])
} else if (x < 0) {
return(- 10^floor(log10(-x)) * nice[[max(which(-x >= 10^floor(log10(-x)) * nice))[[1]]]])
} else {
return(0)
}
}
}

Answer 6

La biblioteca plyr tiene una función round_any que es bastante genérica para hacer todo tipo de redondeo. Por ejemplo

library(plyr)
round_any(132.1, 10) # returns 130
round_any(132.1, 10, f = ceiling) # returns 140
round_any(132.1, 5, f = ceiling) # returns 135

Answer 7

La función de redondeo en R asigna un significado especial al parámetro de dígitos si es negativo.

redondo (x, dígitos = 0)

Redondear a un número negativo de dígitos significa redondear a una potencia de diez, por lo que, por ejemplo, redondear (x, dígitos = -2) redondea a la centena más cercana.

Esto significa que una función como la siguiente se acerca mucho a lo que está pidiendo.

foo <- function(x)
{
round(x+5,-1)
}

La salida se parece a la siguiente

foo(4)
[1] 10
foo(6.1)
[1] 10
foo(30.1)
[1] 40
foo(100.1)
[1] 110

Answer 8

Qué tal si:

roundUp <- function(x,to=10)
{
to*(x%/%to + as.logical(x%%to))
}

Lo que da:

> roundUp(c(4,6.1,30.1,100.1))
[1] 10 10 40 110
> roundUp(4,5)
[1] 5
> roundUp(12,7)
[1] 14

Answer 9

Si agrega un número negativo a los dígitos-argumento de round (), R lo redondeará a los múltiplos de 10, 100, etc.

 round(9, digits = -1)
[1] 10
round(89, digits = -1)
[1] 90
round(89, digits = -2)
[1] 100

Answer 10

Si solo quieres redondear a la potencia más cercana a 10, simplemente define:

roundUp <- function(x) 10^ceiling(log10(x))

Esto en realidad también funciona cuando x es un vector:

> roundUp(c(0.0023, 3.99, 10, 1003))
[1] 1e-02 1e+01 1e+01 1e+04

..pero si quiere redondear a un número "bueno", primero necesita definir qué es un número "agradable". Lo siguiente nos permite definir "agradable" como un vector con buenos valores base de 1 a 10. El valor predeterminado se establece en los números pares más 5.

roundUpNice <- function(x, nice=c(1,2,4,5,6,8,10)) {
if(length(x) != 1) stop("''x'' must be of length 1")
10^floor(log10(x)) * nice[[which(x <= 10^floor(log10(x)) * nice)[[1]]]]
}

Lo anterior no funciona cuando x es un vector, demasiado tarde en la noche en este momento :)

> roundUpNice(0.0322)
[1] 0.04
> roundUpNice(3.22)
[1] 4
> roundUpNice(32.2)
[1] 40
> roundUpNice(42.2)
[1] 50
> roundUpNice(422.2)
[1] 500

[[EDITAR]]

Si la pregunta es cómo redondear a un valor más cercano específico (como 10 o 100), entonces la answer James parece más apropiada. Mi versión le permite tomar cualquier valor y redondearlo automáticamente a un valor razonablemente "bueno". Algunas otras buenas elecciones del vector "agradable" de arriba son: 1:10, c(1,5,10), seq(1, 10, 0.1)

Si tiene un rango de valores en su trazado, por ejemplo [3996.225, 40001.893] , el modo automático debe tener en cuenta tanto el tamaño del rango como la magnitud de los números. Y como señaló Hadley , la función pretty() podría ser lo que quieras.