如何舍入到最接近的10（或100或X）？

93

我正在写一个函数来绘制数据。我想为y轴指定一个不错的整数，该整数max大于数据集的最大值。

具体来说，我想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 
— 安倍
source
绘图时的R默认行为是将绘图限制设置为在每个方向上超出数据范围约4％。如果您不满意，也许只是写出更高或更低的百分比？
— joran 2011年
@joran感谢您提供信息，但是我想要多个都具有相同的轴限制和刻度的图，但我不确定这有什么帮助。
— 日安倍晋三
1
好吧，由于我不了解所有背景，我有点在黑暗中摸索。如果您仅添加另一个参数X并将X都替换为10，则您的foo将四舍五入到最接近的X。或者可以使用构面。
— joran 2011年
15
您在找?pretty吗？
— 哈德利2011年
为什么foo(4)==5不是10？
— 詹姆斯

Answers:

64

如果您只想舍入到最接近的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”数字，则首先需要定义“ nice”数字是什么。以下内容使我们将“ 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]则自动方式应同时考虑范围的大小和数字的大小。正如Hadley所指出的那样，该pretty()功能可能就是您想要的。

— 汤米
source
1
Vectorize(roundUpNice)相当快=）还是+1。
— mbq 2011年
我想知道如果原始值较低，是否可以将roundUp函数编辑为最终结果的一半？例如，介于101-500之间的数字将四舍五入为500，而数字501-999之间的数字将四舍五入为1000？而不是全部舍入到1000？
— helen.h
只需更改漂亮的矢量即可：roundUpNice(501, nice=c(5, 10)) # 1000
— Tommy
1
这只是一个警告，因为您在函数中使用了对数，所以我有2种情况，一种情况在放回去之前在日志中x < 0应用。对于以下情况，我还要添加一个例外- x-x = 0
— Yohan Obadia
漂亮的函数可以很好地满足我的需要（在图形的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
— 拉姆纳特
source
要进行dplyr替换，请参见：stackoverflow.com/a/46489816/435093
— slhck
46

如果R中的舍入函数为负，则它为digits参数赋予特殊含义。

舍入（x，数字= 0）

四舍五入为负数意味着四舍五入为十的幂，因此例如round（x，digits = -2）会四舍五入到最接近的百位数。

这意味着类似于以下功能的功能非常接近您的要求。

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
— 零
source
2
太棒了！您的答案应该标记为正确的答案！
— 亚历山德罗·贾科普森
+1。但是，@ Alessandro在我的答案中的功能更为通用：您可以将任何数字向上或向下舍入到任何间隔。
— theforestecologist
@theforestecologist谢谢您的提示！作为个人喜好，我通常更喜欢内置的语言解决方案，而不是自定义的解决方案。
— 亚历山德罗·贾科普森
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
— 詹姆士
source
1
@daroczig这个问题有点令人困惑，我写这篇文章的重点是“任意X”要求，但是显然“通过单次取整到最接近的X”解决方案无法产生所有期望值。看来OP希望为一个轴生成值，所以pretty可能是最好的选择。
— 詹姆斯
1
显然聚会晚了，但是会不会to * ceiling(x / to)更清洁？
— 贾里德
25

如果在round（）的数字参数中添加负数，R会将其四舍五入为10、100等的倍数。 

    round(9, digits = -1) 
    [1] 10    
    round(89, digits = -1) 
    [1] 90
    round(89, digits = -2) 
    [1] 100
— 阿纳斯塔西娅·普皮尼纳
source
17

将ANY数字向上/向下舍入到ANY间隔

您可以使用模运算符 轻松地将数字四舍五入到特定间隔%%。

功能：

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

这个怎么运作：

模运算符%%确定将第一个数字除以2的余数。在您感兴趣的数字上添加或减去此间隔实际上可以将数字“四舍五入”到您选择的间隔。

> 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
— 森林生态学家
source
有人问我如何转换Round到VBA在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自从我问了4年后发帖后，我不确定你是否说我的答案，但是我想你可能会觉得我的答案相当优雅，而且非常实用。希望能帮助到你！
— 森林生态学家
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
— 汉娜
source
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)
— 达罗齐格
source
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
— 史蒂夫·沃尔什
source
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)
    }
  }
}
— 尤汉·奥巴迪亚（Yohan Obadia）
source
默认输出为四舍五入：> 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
— 拉胡尔·乔瓦（Rahul Chawla）
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.