Question

我正在编写一个绘制数据的函数。我想为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中有更好的方法吗？

Answer 1

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

Answer 2

如果您只想要舍入到最接近的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 answer似乎是最合适的。我的版本允许您获取任何值并自动将其舍入为合理的“好”值。上面“漂亮”矢量的其他一些好的选择是：1:10, c(1,5,10), seq(1, 10, 0.1)

如果您的绘图中有一系列值，例如[3996.225, 40001.893]，则自动方式应考虑范围的大小和数字的大小。作为noted by Hadley，pretty()函数可能就是您想要的。

Answer 3

R中的round函数如果为负数则赋予digits参数特殊含义。

round（x，digits = 0）

舍入为负数位意味着舍入为10的幂，因此例如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

Answer 4

怎么样：

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

Answer 5

如果在round（）的digits-argument中添加一个负数，R会将其四舍五入为10,100等的倍数。

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

Answer 6

关于四舍五入到任意数的多重性，例如10，这是詹姆斯答案的简单替代方案。

适用于任何真实数字向上舍入（from）和任何真实正面数字向上舍入到（to）：< / p>

> 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

Answer 7

我认为您的代码只需稍加修改就能很好用：

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)，随意修改！）

Answer 8

如果您始终想将数字向上舍入到最接近的X，则可以使用--- - hosts: all tasks: - debug: msg: 'executing on {{ inventory_hostname }}'函数：

Posts:{postID(key), posterID, description}

类似地，如果您始终想将舍入，请使用ceiling函数。如果您只想向上或向下舍入到最接近的Z，请使用#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

Answer 9

您会发现Tommy's answer的升级版本会考虑以下几种情况：

选择较低或较高的
考虑负值和零值
两个不同的好比例，以防你希望函数绕不同的小数字和大数字。示例：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)
    }
  }
}

Answer 10

我在没有使用任何外部库或神秘功能的情况下尝试了这一点，它确实有用！

希望它有所帮助。

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

Answer 11

当第二个参数为正时，此函数将指定为第一个参数的数字向上舍入为指定为第二个参数的数字的最接近整数倍，当第二个参数为负时向下舍入：

rom=function(x,y)x+(y-x%%y)%%y
rom(8.69,.1) # 8.7
rom(8.69,-.1) # 8.6
rom(8.69,.25) # 8.75
rom(8.69,-.25) # 8.5
rom(-8.69,.25) # -8.5

这四舍五入到最接近的倍数，例如 round_any (https://github.com/hadley/plyr/blob/34188a04f0e33c4115304cbcf40e5b1c7b85fedf/R/round-any.r) 中的 plyr：

rnm=function(x,y)round(x/y)*y
rnm(8.69,.25) # 8.75
plyr::round_any(8.69,.25) # 8.75

round_any 也可以给定 ceiling 作为第三个参数来始终向上取整或 floor 始终向下取整：

plyr::round_any(8.51,.25,ceiling) # 8.75
plyr::round_any(8.69,.25,floor) # 8.5

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

11 个答案: