Я пишу функцию для построения графика данных. Я хотел бы указать хорошее круглое число для 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?
Если вы просто хотите округлить до ближайшей степени 10, то просто определите:
roundUp <- function(x) 10^ceiling(log10(x))
Это на самом деле также работает, когда х является вектором:
> roundUp(c(0.0023, 3.99, 10, 1003))
[1] 1e-02 1e+01 1e+01 1e+04
... но если вы хотите округлить до "хорошего" числа, вам сначала нужно определить, что такое "хорошее" число. Следующее позволяет нам определить "хороший" как вектор с хорошими базовыми значениями от 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]]]]
}
Выше не работает, когда х является вектором - слишком поздно вечером прямо сейчас :)
> 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
Кругльная функция в R назначает особый смысл параметру цифр, если он отрицательный.
round (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
Как это устроено:
Оператор по модулю %% определяет остаток от деления первого числа на второе. Добавление или вычитание этого интервала к вашему количеству интересов может по существу "округлить" число до интервала по вашему выбору.
> 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
Я изменил вашу функцию двумя способами:
=1e-09, не стесняйтесь изменять!) до max(x), если вы хотите большее числоВы найдете обновленную версию ответа Tommy, в которой учитывается несколько случаев:
Ниже кода:
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
Если вы всегда хотите округлить число до ближайшего 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