Общая (языковая независимость) причина
Поскольку не все числа могут быть представлены точно в арифметике IEEE с плавающей точкой (стандарт, который почти все компьютеры используют для представления десятичных чисел и выполнения с ними математических операций ), вы не всегда получите то, что ожидали. Это особенно верно, потому что некоторые значения, которые являются простыми конечными десятичными знаками (такими как 0,1 и 0,05), не представлены точно в компьютере, и поэтому результаты арифметики на них могут не дать результат, который идентичен прямому представлению " известный "ответ.
Это хорошо известное ограничение компьютерной арифметики, которое обсуждается в нескольких местах:
Сравнение скаляров
Стандартным решением этой проблемы Rявляется не использование ==, а all.equalфункция. Или , вернее, так как all.equalдает много деталей о различиях , если таковые имеются, isTRUE(all.equal(...)).
if(isTRUE(all.equal(i,0.15))) cat("i equals 0.15") else cat("i does not equal 0.15")
доходность
i equals 0.15
Еще несколько примеров использования all.equalвместо ==(последний пример должен показать, что это правильно покажет различия).
0.1+0.05==0.15
#[1] FALSE
isTRUE(all.equal(0.1+0.05, 0.15))
#[1] TRUE
1-0.1-0.1-0.1==0.7
#[1] FALSE
isTRUE(all.equal(1-0.1-0.1-0.1, 0.7))
#[1] TRUE
0.3/0.1 == 3
#[1] FALSE
isTRUE(all.equal(0.3/0.1, 3))
#[1] TRUE
0.1+0.1==0.15
#[1] FALSE
isTRUE(all.equal(0.1+0.1, 0.15))
#[1] FALSE
Еще несколько подробностей, прямо скопированных из ответа на аналогичный вопрос :
Проблема, с которой вы столкнулись, заключается в том, что в большинстве случаев с плавающей запятой невозможно точно представить десятичные дроби, что означает, что вы часто обнаружите, что точное совпадение не удается.
в то время как R слегка врет, когда вы говорите:
1.1-0.2
#[1] 0.9
0.9
#[1] 0.9
Вы можете узнать, что он действительно думает в десятичном виде:
sprintf("%.54f",1.1-0.2)
#[1] "0.900000000000000133226762955018784850835800170898437500"
sprintf("%.54f",0.9)
#[1] "0.900000000000000022204460492503130808472633361816406250"
Вы можете видеть, что эти цифры разные, но представление немного громоздкое. Если мы посмотрим на них в двоичном (ну, в шестнадцатеричном, что эквивалентно), мы получим более четкую картину:
sprintf("%a",0.9)
#[1] "0x1.ccccccccccccdp-1"
sprintf("%a",1.1-0.2)
#[1] "0x1.ccccccccccccep-1"
sprintf("%a",1.1-0.2-0.9)
#[1] "0x1p-53"
Вы можете видеть, что они отличаются на 2^-53, что важно, потому что это число является наименьшей представимой разницей между двумя числами, значение которых близко к 1, как это.
Мы можем узнать для любого данного компьютера, что это наименьшее представимое число, посмотрев в поле машины R :
?.Machine
#....
#double.eps the smallest positive floating-point number x
#such that 1 + x != 1. It equals base^ulp.digits if either
#base is 2 or rounding is 0; otherwise, it is
#(base^ulp.digits) / 2. Normally 2.220446e-16.
#....
.Machine$double.eps
#[1] 2.220446e-16
sprintf("%a",.Machine$double.eps)
#[1] "0x1p-52"
Вы можете использовать этот факт для создания функции «почти равно», которая проверяет, что разница близка к наименьшему представимому числу в плавающей точке. На самом деле это уже существует all.equal.
?all.equal
#....
#all.equal(x,y) is a utility to compare R objects x and y testing ‘near equality’.
#....
#all.equal(target, current,
# tolerance = .Machine$double.eps ^ 0.5,
# scale = NULL, check.attributes = TRUE, ...)
#....
Таким образом, функция all.equal фактически проверяет, что разница между числами является квадратным корнем наименьшего различия между двумя мантиссами.
Этот алгоритм выглядит немного смешно рядом с очень маленькими числами, называемыми денормальными, но вам не нужно об этом беспокоиться.
Сравнение векторов
Приведенное выше обсуждение предполагает сравнение двух отдельных значений. В R нет скаляров, только векторы, и неявная векторизация является сильной стороной языка. Для сравнения значения векторов по элементам, предыдущие принципы верны, но реализация немного отличается. ==векторизован (выполняет поэлементное сравнение), в то время all.equalкак целые векторы сравниваются как единое целое.
Используя предыдущие примеры
a <- c(0.1+0.05, 1-0.1-0.1-0.1, 0.3/0.1, 0.1+0.1)
b <- c(0.15, 0.7, 3, 0.15)
==не дает "ожидаемого" результата и all.equalне выполняет поэлементно
a==b
#[1] FALSE FALSE FALSE FALSE
all.equal(a,b)
#[1] "Mean relative difference: 0.01234568"
isTRUE(all.equal(a,b))
#[1] FALSE
Скорее версия, которая зацикливается на двух векторах, должна использоваться
mapply(function(x, y) {isTRUE(all.equal(x, y))}, a, b)
#[1] TRUE TRUE TRUE FALSE
Если функциональная версия этого желательна, она может быть написана
elementwise.all.equal <- Vectorize(function(x, y) {isTRUE(all.equal(x, y))})
который можно назвать просто
elementwise.all.equal(a, b)
#[1] TRUE TRUE TRUE FALSE
В качестве альтернативы, вместо того, чтобы включать all.equalеще больше вызовов функций, вы можете просто скопировать соответствующие внутренние компоненты all.equal.numericи использовать неявную векторизацию:
tolerance = .Machine$double.eps^0.5
# this is the default tolerance used in all.equal,
# but you can pick a different tolerance to match your needs
abs(a - b) < tolerance
#[1] TRUE TRUE TRUE FALSE
Это подход dplyr::near, который документирует себя как
Это безопасный способ сравнения, если два вектора чисел с плавающей запятой (попарно) равны. Это безопаснее, чем использовать ==, потому что он имеет встроенный допуск
dplyr::near(a, b)
#[1] TRUE TRUE TRUE FALSE