Como arredondar para o 10 mais próximo (ou 100 ou X)?

Estou escrevendo uma função para plotar dados. Gostaria de especificar um bom número redondo para o eixo y maxque seja maior que o máximo do conjunto de dados.

Especificamente, gostaria de uma função fooque execute o seguinte:

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

Eu cheguei tão longe quanto

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

para arredondamento para os 10 mais próximos, mas isso não funciona para intervalos de arredondamento arbitrários.

Existe uma maneira melhor de fazer isso no R?

Se você deseja arredondar para cima para a potência de 10 mais próxima, basta definir:

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

Na verdade, isso também funciona quando x é um vetor:

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

..mas se você quiser arredondar para um número "legal", primeiro você precisa definir o que é um número "legal". O seguinte nos permite definir "nice" como um vetor com bons valores de base de 1 a 10. O padrão é definido para os números pares mais 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]]]]
}

O acima não funciona quando x é um vetor - tarde da noite agora :)

> 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]]

Se a questão for como arredondar para um valor mais próximo especificado (como 10 ou 100), a resposta de James parece mais apropriada. Minha versão permite que você pegue qualquer valor e o arredonde automaticamente para um valor razoavelmente "bom". Algumas outras boas escolhas do vetor "legal" acima são:1:10, c(1,5,10), seq(1, 10, 0.1)

Se você tiver uma faixa de valores em seu gráfico, por exemplo [3996.225, 40001.893], a forma automática deve levar em consideração o tamanho da faixa e a magnitude dos números. E, conforme observado por Hadley , a pretty()função pode ser o que você deseja.

A plyrbiblioteca tem uma função round_anybastante genérica para fazer todos os tipos de arredondamento. Por exemplo

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

A função de arredondamento em R atribui um significado especial ao parâmetro de dígitos se for negativo.

redondo (x, dígitos = 0)

Arredondar para um número negativo de dígitos significa arredondar para uma potência de dez; por exemplo, arredondar (x, dígitos = -2) arredondar para a centena mais próxima.

Isso significa que uma função como a seguinte chega muito perto do que você está pedindo.

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

O resultado é semelhante ao seguinte

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

E se:

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

Que dá:

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

Se você adicionar um número negativo ao argumento de dígitos de round (), R o arredondará para múltiplos de 10, 100 etc.

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

Arredonde QUALQUER número para cima / baixo para QUALQUER intervalo

Você pode facilmente arredondar os números para um intervalo específico usando o operador de módulo %% .

A função:

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)
    }
  }
}

Exemplos:

> 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

Como funciona:

O operador de módulo %%determina o resto da divisão do primeiro número pelo segundo. Adicionar ou subtrair este intervalo ao seu número de interesse pode essencialmente 'arredondar' o número para um intervalo de sua escolha.

> 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

Atualizar:

A versão conveniente de 2 argumentos:

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

yValores positivos roundUp, enquanto yvalores negativosroundDown :

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

Ou....

Função que arredonda automaticamente PARA CIMA ou PARA BAIXO base nas regras de arredondamento padrão:

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

Arredonda automaticamente se o xvalor estiver na >metade do caminho entre as instâncias subsequentes do valor de arredondamento 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

A respeito de arredondamento para a multiplicidade de um número arbitrário , por exemplo, 10, aqui está uma alternativa simples para a resposta de James.

Funciona para qualquer número real arredondado para cima ( from) e qualquer número real positivo arredondado para ( to):

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

Exemplo:

> 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

Acho que seu código funciona bem com uma pequena modificação:

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

E seus exemplos são:

> 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

Alterei sua função de duas maneiras:

• adicionado segundo argumento (para o seu X especificado )
• adicionou um pequeno valor ( =1e-09sinta-se à vontade para modificar!) ao max(x)se você quiser um número maior

Se você sempre quer arredondar um número até ao X mais próximo, você pode usar a ceilingfunção:

#Round 354 up to the nearest 100:
> X=100
> ceiling(354/X)*X
[1] 400

#Round 47 up to the nearest 30:
> Y=30
> ceiling(47/Y)*Y
[1] 60

Da mesma forma, se você quiser sempre arredondar para baixo , use a floorfunção. Se você quiser simplesmente arredondar para cima ou para baixo até o Z mais próximo, use round.

> Z=5
> round(367.8/Z)*Z
[1] 370
> round(367.2/Z)*Z
[1] 365

Você encontrará uma versão atualizada da resposta de Tommy que leva em consideração vários casos:

• Escolher entre limite inferior ou superior
• Levando em consideração valores negativos e zero
• duas escalas agradáveis ​​diferentes, caso você queira que a função arredonde números pequenos e grandes de forma diferente. Exemplo: 4 seria arredondado para 0, enquanto 400 seria arredondado para 400.

Abaixo do 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)
    }
  }
}

Tentei fazer isso sem usar nenhuma biblioteca externa ou recursos criptográficos e funcionou!

Espero que ajude alguém.

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