จะปัดเศษขึ้นเป็น 10 (หรือ 100 หรือ X) ที่ใกล้ที่สุดได้อย่างไร

ฉันกำลังเขียนฟังก์ชันเพื่อลงจุดข้อมูล ฉันต้องการระบุจำนวนรอบที่ดีสำหรับแกน 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 หรือไม่?

หากคุณต้องการปัดเศษขึ้นเป็นกำลัง 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) คำตอบของเจมส์จะเหมาะสมที่สุด เวอร์ชันของฉันช่วยให้คุณใช้ค่าใดก็ได้และปัดเศษให้เป็นค่าที่ "ดี" โดยอัตโนมัติ ตัวเลือกที่ดีอื่น ๆ ของเวกเตอร์ "nice" ด้านบน ได้แก่ :1:10, c(1,5,10), seq(1, 10, 0.1)

ตัวอย่างเช่นหากคุณมีช่วงของค่าในพล็อตของคุณ[3996.225, 40001.893]วิธีอัตโนมัติควรพิจารณาทั้งขนาดของช่วงและขนาดของตัวเลข และเป็นที่สังเกตจากฮัดลีย์ที่pretty()ฟังก์ชั่นอาจจะมีสิ่งที่คุณต้องการ

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

ฟังก์ชัน round ใน R กำหนดความหมายพิเศษให้กับพารามิเตอร์หลักหากเป็นค่าลบ

รอบ (x, หลัก = 0)

การปัดเศษเป็นจำนวนลบหมายถึงการปัดเศษเป็นเลขยกกำลังสิบตัวอย่างเช่นปัดเศษ (x, หลัก = -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

เกี่ยวกับ:

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

หากคุณเพิ่มจำนวนลบลงในอาร์กิวเมนต์หลักของ round () R จะปัดเศษเป็น 10, 100 เป็นต้น

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

ปัดเศษตัวเลขขึ้น / ลงเป็นช่วงเวลาใดก็ได้

คุณสามารถจำนวนรอบได้อย่างง่ายดายเพื่อช่วงเวลาที่เฉพาะเจาะจงโดยใช้ผู้ประกอบการโมดูโล %%

ฟังก์ชั่น:

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

เกี่ยวกับการปัดเศษขึ้นเป็นทวีคูณของจำนวนตามอำเภอใจเช่น 10 นี่เป็นทางเลือกง่ายๆสำหรับคำตอบของเจมส์

มันใช้ได้กับจำนวนจริงที่ปัดขึ้น ( 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

ฉันคิดว่าโค้ดของคุณใช้งานได้ดีกับการปรับเปลี่ยนเล็กน้อย:

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)หากคุณต้องการจำนวนที่มากขึ้น

หากคุณต้องการปัดเศษขึ้นเป็น 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

คุณจะพบคำตอบของ Tommyเวอร์ชันอัปเกรดซึ่งคำนึงถึงหลายกรณี:

• การเลือกระหว่างขอบเขตล่างหรือสูงกว่า
• คำนึงถึงค่าลบและศูนย์
• สเกลที่ดีสองแบบที่แตกต่างกันในกรณีที่คุณต้องการให้ฟังก์ชันปัดเศษตัวเลขเล็กและใหญ่ต่างกัน ตัวอย่าง: 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)
    }
  }
}

ฉันลองสิ่งนี้โดยไม่ใช้ไลบรารีภายนอกหรือคุณสมบัติที่เป็นความลับและใช้งานได้!

หวังว่ามันจะช่วยใครบางคน

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