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


93

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?


O comportamento padrão do R durante a plotagem é definir os limites do gráfico ~ 4% além do intervalo dos dados em cada direção. Se isso não for satisfatório para você, talvez apenas escreva algo que saia por um% maior ou menor?
joran

@joran obrigado pela informação, mas quero vários gráficos que tenham os mesmos limites de eixo e marcações e não tenho certeza de como isso ajuda.
Abe

1
Bem, estou meio que tateando no escuro aqui, já que não conheço todo o pano de fundo. Seu foo arredondará para o X mais próximo se você apenas adicionar outro parâmetro X e substituir os dois 10 por X. Ou você pode usar facetação.
joran

15
Você está procurando ?pretty?
hadley

Por que é foo(4)==5e não é 10?
James

Respostas:


64

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.


1
Vectorize(roundUpNice)é bastante rápido =) +1 De qualquer forma.
mbq

Eu queria saber se existe uma maneira de editar a função roundUp para a metade do resultado final se o valor original for menor. por exemplo, um número entre 101-500 seria arredondado para 500 e os números 501-999 arredondaria para cima para 1000? em vez de arredondar para 1000?
helen.h

Basta alterar o vetor legal:roundUpNice(501, nice=c(5, 10)) # 1000
Tommy

1
Só um aviso já que você trabalha com logaritmos em sua função, eu teria 2 casos, um onde x < 0e aplico - xno log antes de colocar as -costas. Eu também adicionaria uma exceção para a situação em quex = 0
Yohan Obadia

A função bonita funcionou muito bem para minhas necessidades (para definir um limite bonito no eixo X de um gráfico)
Joon

132

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

Para obter uma dplyrsubstituição, consulte: stackoverflow.com/a/46489816/435093
slhck

46

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

2
Impressionante! Sua resposta deve ser marcada como a correta!
Alessandro Jacopson

+1. No entanto, @Alessandro as funções em minha resposta são muito mais versáteis: você pode arredondar QUALQUER número para cima OU para baixo para QUALQUER intervalo.
theforestecologist de

@theforestecologist obrigado pela dica! Como gosto pessoal, geralmente prefiro uma solução de linguagem integrada em vez de uma personalizada.
Alessandro Jacopson

27

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

1
@daroczig A questão é um pouco confusa, eu escrevi isso focando no requisito de "X arbitrário", mas claramente todos os valores esperados não poderiam ser produzidos por "um único arredondamento até a solução X mais próxima". Parece que o OP deseja produzir valores para um eixo, então prettyé provavelmente a melhor opção.
James

1
Obviamente atrasado para esta festa, mas não to * ceiling(x / to)estaria mais limpo?
jared

25

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

17

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

Perguntaram-me como converter Roundpara VBA no Excel:Function ROUND(x,y) 'Function that automatically rounds UP or DOWN based on standard rounding rules. 'Automatically rounds up if the "x" value is > halfway between subsequent instances of the rounding value "y": If (y - (Evaluate("Mod(" & x & "," & y & ")"))) <= (Evaluate("Mod(" & x & "," & y & ")")) Then Ans = x + (y - (Evaluate("Mod(" & x & "," & y & ")"))) Else Ans = x - (Evaluate("Mod(" & x & "," & y & ")")) End If ROUND = Ans End Function
theforestecologist

@Abe eu não tinha certeza se você disse minha resposta ou não desde que postei 4 anos depois que você perguntou, mas acho que você pode achar minha resposta bastante elegante e muito VERSÁTIL. Espero que ajude!
theforestecologist

7

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

2

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

1

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

0

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

A saída padrão disso é um arredondamento para baixo:> round.up.nice(.01) [1] 0 > round.up.nice(4.5) [1] 0 > round.up.nice(56) [1] 50
jessi

Acho que parte do problema é que nice_bige nice_smallsão definidos ao contrário (se os invertermos na função, round.up.nice(4.5)tornam-se 4), mas ainda assim arredondam para baixo.
Jessi

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
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.