Какой правильный / стандартный способ проверить, меньше ли разница, чем точность станка?

Я часто оказываюсь в ситуациях, когда необходимо проверить, превышает ли полученная разница точность станка. Похоже , что для этой цели R имеет удобную переменную: .Machine$double.eps. Однако, когда я обращаюсь к исходному коду R за рекомендациями по использованию этого значения, я вижу несколько разных шаблонов.

Примеры

Вот несколько примеров из statsбиблиотеки:

t.test.R

if(stderr < 10 *.Machine$double.eps * abs(mx))

chisq.test.R

if(abs(sum(p)-1) > sqrt(.Machine$double.eps))

integrate.R

rel.tol < max(50*.Machine$double.eps, 0.5e-28)

lm.influence.R

e[abs(e) < 100 * .Machine$double.eps * median(abs(e))] <- 0

princomp.R

if (any(ev[neg] < - 9 * .Machine$double.eps * ev[1L]))

и т.п.

Вопросов

1. Как можно понять рассуждение за все эти разные 10 *, 100 *, 50 *и sqrt()модификаторы?
2. Существуют ли рекомендации по использованию .Machine$double.epsдля корректировки различий из-за проблем с точностью?

Точность станка doubleзависит от его текущего значения. .Machine$double.epsдает точность, когда значения равны 1. Вы можете использовать функцию C, nextAfterчтобы получить точность станка для других значений.

library(Rcpp)
cppFunction("double getPrec(double x) {
  return nextafter(x, std::numeric_limits<double>::infinity()) - x;}")

(pr <- getPrec(1))
#[1] 2.220446e-16
1 + pr == 1
#[1] FALSE
1 + pr/2 == 1
#[1] TRUE
1 + (pr/2 + getPrec(pr/2)) == 1
#[1] FALSE
1 + pr/2 + pr/2 == 1
#[1] TRUE
pr/2 + pr/2 + 1 == 1
#[1] FALSE

Прибавление значения aк значению bне изменится, bесли оно aбудет <= вдвое меньше точности станка. Проверка, является ли разница меньше точности станка, сделана с <. Модификаторы могут учитывать типичные случаи, когда часто дополнение не показывало изменения.

В R точность станка можно оценить с помощью:

getPrecR <- function(x) {
  y <- log2(pmax(.Machine$double.xmin, abs(x)))
  ifelse(x < 0 & floor(y) == y, 2^(y-1), 2^floor(y)) * .Machine$double.eps
}
getPrecR(1)
#[1] 2.220446e-16

Каждое doubleзначение представляет диапазон. Для простого сложения диапазон результата зависит от диапазона каждого слагаемого, а также диапазона их суммы.

library(Rcpp)
cppFunction("std::vector<double> getRange(double x) {return std::vector<double>{
   (nextafter(x, -std::numeric_limits<double>::infinity()) - x)/2.
 , (nextafter(x, std::numeric_limits<double>::infinity()) - x)/2.};}")

x <- 2^54 - 2
getRange(x)
#[1] -1  1
y <- 4.1
getRange(y)
#[1] -4.440892e-16  4.440892e-16
z <- x + y
getRange(z)
#[1] -2  2
z - x - y #Should be 0
#[1] 1.9

2^54 - 2.9 + 4.1 - (2^54 + 5.9) #Should be -4.7
#[1] 0
2^54 - 2.9 == 2^54 - 2      #Gain 0.9
2^54 - 2 + 4.1 == 2^54 + 4  #Gain 1.9
2^54 + 5.9 == 2^54 + 4      #Gain 1.9

Для более высокой точности Rmpfrможно использовать.

library(Rmpfr)
mpfr("2", 1024L)^54 - 2.9 + 4.1 - (mpfr("2", 1024L)^54 + 5.9)
#[1] -4.700000000000000621724893790087662637233734130859375

В случае, если это может быть преобразовано в целое число gmpможет быть использовано (что находится в Rmpfr).

library(gmp)
as.bigz("2")^54 * 10 - 29 + 41 - (as.bigz("2")^54 * 10 + 59)
#[1] -47

Определение machine.eps: это самое низкое значение,  eps для которого  1+eps нет 1

Как правило (предполагая представление с плавающей запятой с основанием 2):
это epsсоставляет разницу для диапазона 1 .. 2,
для диапазона 2 .. 4 точность 2*eps
и т. Д.

К сожалению, здесь нет хорошего эмпирического правила. Это полностью определяется потребностями вашей программы.

В R мы имеем all.equal как встроенный способ проверки приближенного равенства. Таким образом, вы могли бы использовать что-то вроде (x<y) | all.equal(x,y)

i <- 0.1
 i <- i + 0.05
 i
if(isTRUE(all.equal(i, .15))) { #code was getting sloppy &went to multiple lines
    cat("i equals 0.15\n") 
} else {
    cat("i does not equal 0.15\n")
}
#i equals 0.15

В Google mock есть несколько средств сравнения с плавающей запятой для сравнений с двойной точностью, включая DoubleEqи DoubleNear. Вы можете использовать их в сопоставлении массива следующим образом:

ASSERT_THAT(vec, ElementsAre(DoubleEq(0.1), DoubleEq(0.2)));

Обновить:

Численные рецепты обеспечивают вывод, чтобы продемонстрировать, что использование одностороннего разностного коэффициента sqrtявляется хорошим выбором размера шага для конечно-разностных аппроксимаций производных.

Сайт статьи Википедии «Числовые рецепты», 3-е издание, раздел 5.7, страницы 229-230 (ограниченное количество просмотров страниц доступно по адресу http://www.nrbook.com/empanel/ ).

all.equal(target, current,
           tolerance = .Machine$double.eps ^ 0.5, scale = NULL,
           ..., check.attributes = TRUE)

Эта арифметика с плавающей точкой IEEE является хорошо известным ограничением компьютерной арифметики и обсуждается в нескольких местах:

• FAQ в R имеет целый вопрос, посвященный этому: R FAQ 7.31
  • R Inferno Патрика Бернса посвятил этой проблеме первый «Круг» (стр. 9 и далее)
  • Задача доказательства арифметической суммы задается в Math Meta
  • Дэвид Голдберг, «Что должен знать каждый компьютерщик об арифметике с плавающей точкой», ACM Computing Surveys 23 , 1 (1991-03), 5-48 doi> 10.1145 / 103162.103163 ( также доступна редакция )
  • Руководство с плавающей точкой - Что должен знать каждый программист об арифметике с плавающей точкой
  • 0.30000000000000004.com сравнивает арифметику с плавающей запятой для разных языков программирования
• Канонический дубликат для «с плавающей точкой неточен» (мета-обсуждение канонического ответа на этот вопрос)
• Несколько вопросов о переполнении стека, включая
  • Почему десятичные числа не могут быть представлены точно в двоичном формате?
  • Почему числа с плавающей запятой неточные?
  • Математика с плавающей точкой нарушена?
• Математические хитрости, объясненные Артуром Т. Бенджамином

, dplyr::near()еще один вариант проверки, если два вектора чисел с плавающей точкой равны.

Функция имеет встроенный параметр допуска: tol = .Machine$double.eps^0.5его можно настроить. Параметр по умолчанию совпадает с параметром по умолчанию для all.equal().