가장 가까운 10 (또는 100 또는 X)으로 반올림하는 방법은 무엇입니까?

95

데이터를 그리는 함수를 작성 중입니다. max데이터 세트의 최대 값보다 큰 y 축에 멋진 반올림 번호를 지정하고 싶습니다 .

특히 foo다음을 수행 하는 기능 을 원합니다 .

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

나는

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

가장 가까운 10으로 반올림하지만 임의의 반올림 간격에는 작동하지 않습니다.

R에서이 작업을 수행하는 더 좋은 방법이 있습니까?

r  rounding 
— 아베
소스
플로팅시 R 기본 동작은 각 방향의 데이터 범위를 넘어서 ~ 4 %까지 플롯 제한을 설정하는 것입니다. 이것이 당신에게 만족스럽지 않다면 더 높거나 낮은 %만큼 나가는 것을 작성하십시오.
— joran
@joran 정보에 대해 감사하지만 모두 동일한 축 제한과 눈금이있는 여러 플롯을 원하며 이것이 어떻게 도움이되는지 잘 모르겠습니다.
— Abe
1
글쎄, 나는 모든 배경을 알지 못하기 때문에 어둠 속에서 좀 더듬고 있습니다. 다른 매개 변수 X를 추가하고 10을 모두 X로 바꾸면 가장 가까운 X로 반올림됩니다. 또는 패싯을 사용할 수 있습니다.
— joran
15
찾고 ?pretty계십니까?
— hadley 2011-06-24
왜 foo(4)==5그렇지 10않습니까?
— James

답변:

65

가장 가까운 10의 거듭 제곱으로 반올림하려면 다음을 정의하십시오.

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

이것은 실제로 x가 벡터 일 때도 작동합니다.

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

.. 그러나 "좋은"숫자로 반올림하려면 먼저 "좋은"숫자가 무엇인지 정의해야합니다. 다음은 "nice"를 1부터 10까지의 좋은 기본 값을 가진 벡터로 정의 할 수있게합니다. 기본값은 짝수에 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]]]]
}

x가 벡터 일 때는 위의 내용이 작동하지 않습니다. 지금은 너무 늦은 저녁입니다. :)

> 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

[[편집하다]]

질문이 지정된 가장 가까운 값 (예 : 10 또는 100)으로 반올림하는 방법이라면 James 대답 이 가장 적절 해 보입니다. 내 버전을 사용하면 어떤 값이든 합리적으로 "좋은"값으로 자동 반올림 할 수 있습니다. 위의 "nice"벡터의 다른 좋은 선택은 다음과 같습니다.1:10, c(1,5,10), seq(1, 10, 0.1)

예를 들어 플롯에 값 범위가있는 경우 [3996.225, 40001.893]자동 방법은 범위의 크기와 숫자의 크기를 모두 고려해야합니다. 로 그리고 해들리에 의해 지적 의 pretty()기능은 당신이 원하는 수 있습니다.

— 나사 돌리개
소스
1
Vectorize(roundUpNice)꽤 빠르다 =) +1 어쨌든.
— MBq의
원래 값이 더 낮 으면 최종 결과의 절반으로 반올림 기능을 편집하는 방법이 있는지 궁금합니다. 예를 들어 101-500 사이의 숫자는 500으로 반올림되고 501-999는 1000으로 반올림됩니까? 모두 1000으로 반올림하는 대신?
— helen.h 2011 년
그냥 좋은 벡터를 변경 :roundUpNice(501, nice=c(5, 10)) # 1000
— 토미
1
함수에서 로그로 작업하기 때문에 경고 일뿐입니다. 두 가지 경우가있었습니다. 하나 는 로그에 x < 0적용 - x하고 -다시 넣기 전에 적용합니다 . 나는 또한 상황에 대한 예외를 추가 할 것입니다x = 0
— Yohan Obadia 2016 년
pretty 함수는 내 필요에 따라 매우 잘 작동했습니다 (그래프의 X 축에 꽤 제한을 설정하기 위해)
— Joon
132

plyr라이브러리 함수가 round_any반올림의 모든 종류를 할 매우 일반적이다. 예를 들면

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
— Ramnath
소스
A의 dplyr교체, 참조 : stackoverflow.com/a/46489816/435093
— slhck
46

R의 round 함수는 숫자 매개 변수가 음수 인 경우 특별한 의미를 할당합니다.

round (x, 숫자 = 0)

음의 자릿수로 반올림한다는 것은 10의 거듭 제곱으로 반올림하는 것을 의미하므로 예를 들어 round (x, numbers = -2)는 가장 가까운 100으로 반올림합니다.

이것은 다음과 같은 기능이 당신이 요구하는 것에 매우 가깝다 는 것을 의미합니다.

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

출력은 다음과 같습니다.

foo(4)
[1] 10
foo(6.1)
[1] 10
foo(30.1)
[1] 40
foo(100.1)
[1] 110
— 제로
소스
2
대박! 귀하의 답변이 올바른 것으로 표시되어야합니다!
— Alessandro Jacopson
+1. 그러나 @Alessandro 내에서 기능 대답은 훨씬 더 다양한 위치 : 반올림 할 수 있습니다 어떤 수를 또는 아래로 어떤 간격.
— theforestecologist
@theforestecologist 힌트 주셔서 감사합니다! 개인적 취향으로는 일반적으로 맞춤형 솔루션보다는 언어 내장 솔루션을 선호합니다.
— Alessandro Jacopson
27

어때 :

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

다음을 제공합니다.

> 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 질문은 약간 혼란 스럽습니다. 저는 "임의의 X"요구 사항에 초점을 맞춰이 글을 썼지 만 "가장 가까운 X에 대한 단일 반올림"솔루션으로는 모든 예상 값을 생성 할 수 없습니다. OP가 축에 대한 값을 생성하려는 것 같으므로 pretty아마도 가장 좋은 옵션 일 것입니다.
— James
1
분명히이 파티에 늦었지만 to * ceiling(x / to)깨끗 하지 않을까요?
— jared 2010 년
27

round ()의 자릿수 인수에 음수를 추가하면 R은 10, 100 등의 배수로 반올림합니다. 

    round(9, digits = -1) 
    [1] 10    
    round(89, digits = -1) 
    [1] 90
    round(89, digits = -2) 
    [1] 100
— 아나스타샤 푸 피니 나
소스
17

모든 숫자를 임의의 간격으로 올림 / 내림

모듈로 연산자를 사용하여 숫자를 특정 간격으로 쉽게 반올림 할 수 있습니다 %%.

함수:

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

예 :

> 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

작동 원리 :

모듈로 연산자 %%는 첫 번째 숫자를 두 번째로 나눈 나머지를 결정합니다. 이 간격을 관심있는 수에 더하거나 빼면 기본적으로 선택한 간격으로 숫자를 '반올림'할 수 있습니다.

> 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

최신 정보:

편리한 2- 인수 버전 :

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

양수 y값 roundUp, 음수 y값 roundDown:

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

또는....

표준 반올림 규칙에 따라 자동으로 올림 또는 내림 하는 기능 :

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

x값이 >반올림 값의 후속 인스턴스 사이의 중간에 있으면 자동으로 반올림합니다 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
— 산림 학자
소스
나는 변환하는 방법에 대해 질문을 받았다 RoundExcel에서 VBA로 :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 질문 한 지 4 년 만에 게시 한 이후로 제 답변을 말했는지 아닌지 확신 할 수 없었지만 제 답변은 상당히 우아하고 매우 다재다능하다고 생각합니다. 도움이 되었기를 바랍니다.
— theforestecologist
7

임의의 숫자 , 예를 들어 10 의 다중성으로 반올림하는 것과 관련하여 James의 대답에 대한 간단한 대안이 있습니다.

모든 것이 작동 실제 수 (반올림되고 from) 및 실제 양의 수 (반올림 to)

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

예:

> 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

나는 당신의 코드가 약간의 수정으로 잘 작동한다고 생각합니다.

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

그리고 귀하의 예제는 다음과 같이 실행됩니다.

> 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

두 가지 방법으로 기능을 변경했습니다.

  • 두 번째 인수 추가 (지정된 X에 대해 )
  • 더 큰 숫자를 원한다면에 작은 값 ( =1e-09, 자유롭게 수정하십시오!)을 추가했습니다 .max(x)
— Daroczig
소스
1

당신은 항상 숫자를 반올림하려면 까지 가장 가까운 X에, 당신은 사용할 수있는 ceiling기능 :

#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

당신은 항상 라운드 원한다면 마찬가지로, 아래로 , 사용 floor기능. 가장 가까운 Z로 반올림하거나 내림하려면 round대신 사용하십시오.

> Z=5
> round(367.8/Z)*Z
[1] 370
> round(367.2/Z)*Z
[1] 365
— 스티브 월시
소스
0

몇 가지 경우를 고려한 업그레이드 된 버전의 Tommy 답변 을 찾을 수 있습니다.

  • 하한 또는 상한 중에서 선택
  • 음수 및 0 값 고려
  • 작은 숫자와 큰 숫자를 다르게 반올림하려는 경우 두 개의 다른 멋진 스케일. 예 : 4는 0에서 반올림되고 400은 400에서 반올림됩니다.

코드 아래 :

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)
    }
  }
}
— 요한 오바 디아
소스
이것의 기본 출력은 반올림입니다.> round.up.nice(.01) [1] 0 > round.up.nice(4.5) [1] 0 > round.up.nice(56) [1] 50
— jessi
나는 문제의 한 부분이 있다고 생각 nice_big하고 nice_small, 뒤쪽으로 정의된다 (우리가 함수를 뒤집어 경우 round.up.nice(4.5)가된다 4)하지만 여전히 아래로 반올림합니다.
— jessi
0

나는 외부 라이브러리 또는 비밀 기능을 사용하지 않고 이것을 시도했으며 작동합니다!

누군가에게 도움이되기를 바랍니다.

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
— 라훌 차 울라
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.