round - ¿Cómo redondear al 10(o 100 o X) más cercano?
numero de decimales en r (10)
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
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?
¡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
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!) almax(x)si quiere un número mayor
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
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)
}
}
}
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
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
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
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
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.