Общая (языковая независимость) причина
Поскольку не все числа могут быть точно представлены в арифметике 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 :
?.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