最も近い10（または100またはX）に切り上げる方法は？

93

データをプロットする関数を書いています。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情報に感謝しますが、すべて同じ軸制限と目盛りを持つ複数のプロットが必要です。これがどのように役立つかわかりません。
— 安部
1
ええと、私はここで暗闇の中で手探りしています。背景がすべてわからないからです。別のパラメーターXを追加し、両方の10をXで置き換える場合、fooは最も近いXに切り上げられます。または、ファセットを使用することもできます。
— joran
15
お探し?prettyですか？
— ハドリー
なぜfoo(4)==5ありませんか10？
— ジェームズ

回答:

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」を1〜10のniceベース値を持つベクトルとして定義します。デフォルトは、偶数に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の回答が最も適切と思われます。私のバージョンでは、任意の値を取得して、それを合理的に「適切な」値に自動的に丸めることができます。上記の「素敵な」ベクトルの他の良い選択肢は次のとおりです。1:10, c(1,5,10), seq(1, 10, 0.1)

たとえば、プロットに値の範囲がある場合[3996.225, 40001.893]、自動方法では、範囲のサイズと数値の大きさの両方を考慮する必要があります。そしてHadleyが指摘したように、pretty()関数はあなたが望むものかもしれません。

— トミー
ソース
1
Vectorize(roundUpNice)かなり高速です=）+1とにかく。
— mbq 2011年
元の値が低い場合に、roundUp関数を最終結果の半分に編集する方法があるかどうか疑問に思っていましたか？たとえば、101-500の数値は500に切り上げられ、501-999の数値は1000に切り上げられますか？すべてを1000に丸める代わりに？
— helen.h 2016年
ただ、素敵なベクトルを変更：roundUpNice(501, nice=c(5, 10)) # 1000
— トミー
1
関数で対数を使用しているので、ただの警告ですが、私は2つのケースがx < 0あり- xました-。また、次のような場合にも例外を追加しますx = 0
— Yohan Obadia
かなり機能は、（グラフのX軸上かなりの制限を設定するには）私のニーズのために本当によく働いた
— ジュン
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
— ラムナス
ソース
dplyr代替品については、stackoverflow.com
— a / 46489816/435093
46

Rの丸め関数は、digitsパラメーターが負の場合に特別な意味を割り当てます。

丸め（x、桁= 0）

負の桁数に丸めることは、10の累乗に丸めることを意味します。たとえば、round（x、digits = -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
驚くばかり！あなたの答えは正しいものとしてマークされるべきです！
— アレッサンドロジャコプソン2017年
+1。しかし、私の中@Alessandro機能答えははるかに汎用性があります：あなたは丸めることができ、いかなる数アップORまでをANY間隔。
— 森林生態学者
@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
— ジェームズ
ソース
1
@daroczig質問は少し混乱しますが、「任意のX」要件に焦点を当ててこれを書きましたが、「最も近いXへの単一の切り上げ」ソリューションではすべての期待値を生成できないことは明らかです。OPは軸の値を生成する必要があるため、prettyおそらくこれが最良のオプションです。
— ジェームズ
1
明らかにこのパーティーには遅れto * ceiling(x / to)ますが、もっときれいになりませんか？
— 2019年
25

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

使い方：

モジュロ演算子%%は、最初の数値を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.

または...。

機能自動的に切り上げまたは DOWNを標準丸めルールに基づいて：

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
@阿部質問してから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
— ハンナ
ソース
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

私はあなたの機能を2つの方法で変更しました：

  • 2番目の引数を追加（指定したXの場合）
  • （小さな値を追加=1e-09、変更すること自由に感じ、！）にmax(x)あなたがより大きな数をしたい場合
— ダロチク
ソース
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

あなたはいくつかのケースを考慮したトミーの答えのアップグレードされたバージョンを見つけるでしょう：

  • 下限または上限の選択
  • 負の値とゼロの値を考慮する
  • 関数で小さい数値と大きい数値を別々に丸める場合の2つの異なる適切なスケール。例：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
— ジェシー
問題の一部は、nice_bigおよびnice_smallが逆に定義されている（関数でそれらを反転すると、にround.up.nice(4.5)なる4）ことですが、それでも切り捨てられます。
— jessi 2017
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.