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

Я часто опиняюся в ситуаціях, коли потрібно перевірити, чи отримана різниця вище машинної точності. Схоже , що для цієї мети 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 макет має ряд відповідників з плаваючою комою для порівняння подвійної точності, включаючи 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 23 , 1 (1991-03), 5-48 дой> 10.1145 / 103162.103163 ( також доступна редакція )
  • Посібник з плаваючою комою - що повинен знати кожен програміст про арифметику з плаваючою комою
  • 0.30000000000000004.com порівнює арифметику з плаваючою комою в різних мовах програмування
• Канонічний дублікат для "плаваючої точки неточний" (мета-дискусія про канонічну відповідь на це питання)
• Кілька питань щодо переповнення стека, зокрема
  • Чому десяткові числа не можуть бути представлені точно у двійковій формі?
  • Чому числа з плаваючою комою є неточними?
  • Чи порушена математика з плаваючою комою?
• Математичні трюки, які пояснив Артур Т. Бенджамін

. dplyr::near()є ще одним варіантом тестування, якщо два вектори чисел з плаваючою точкою рівні.

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