Ответ 1
Общая (независимая от языка) причина
Поскольку не все числа могут быть точно представлены в арифметике с плавающей точкой IEEE (стандарт, который почти все компьютеры используют для представления десятичных чисел и выполнения математических операций с ними), вы не всегда получите то, что ожидали. Это особенно верно, потому что некоторые значения, которые являются простыми, конечными десятичными знаками (такими как 0,1 и 0,05), не представлены точно в компьютере, и поэтому результаты арифметики на них могут не дать результат, который идентичен прямому представлению " известный "ответ.
Это хорошо известное ограничение компьютерной арифметики, которое обсуждается в нескольких местах:
- В R FAQ есть вопрос, посвященный этому: R FAQ 7.31
- The R Inferno Патрика Бернса посвящает первый "круг" этой проблеме (начиная со страницы 9)
- Дэвид Голдберг, "Что должен знать каждый компьютерный ученый об арифметике с плавающей точкой", ACM Computing Surveys 23, 1 (1991-03), 5-48 doi> 10.1145/103162.103163 (также доступна ревизия)
- Руководство с плавающей точкой - Что должен знать каждый программист об арифметике с плавающей точкой
- 0.30000000000000004.com сравнивает арифметику с плавающей запятой для разных языков программирования
- Несколько вопросов Кару, включая
- Почему числа с плавающей запятой неточные?
- Почему десятичные числа не могут быть представлены точно в двоичном виде?
- Математика с плавающей точкой нарушена?
- Канонический дубликат для "с плавающей запятой является неточным" (мета-обсуждение канонического ответа на этот вопрос)
Сравнение скаляров
Стандартное решение этой проблемы в 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
Это подход, принятый dplyr::near, который документирует себя как
Это безопасный способ сравнения, если два вектора чисел с плавающей запятой (попарно) равны. Это безопаснее, чем использовать
==, потому что он имеет встроенный допуск
dplyr::near(a, b)
#[1] TRUE TRUE TRUE FALSE