Farkın makine hassasiyetinden daha küçük olup olmadığını kontrol etmenin doğru / standart yolu nedir?

Sıklıkla, elde edilen farkın makine hassasiyetinin üzerinde olup olmadığını kontrol etmek gerektiğinde ortaya çıkar. Bu amaçla Ar kullanışlı değişkeni için gibi görünüyor: .Machine$double.eps. Ancak bu değeri kullanma yönergeleri için R kaynak koduna döndüğümde birden çok farklı desen görüyorum.

Örnekler

statsKitaplıktan birkaç örnek :

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]))

vb.

Sorular

1. İnsan nasıl bu farklı tüm arkasındaki mantık anlayabilir 10 *, 100 *, 50 *ve sqrt()değiştiricileri?
2. .Machine$double.epsKesinlik sorunlarından kaynaklanan farklılıkları ayarlamak için kullanma hakkında yönergeler var mı?

Makine hassasiyeti doublemevcut değerine bağlıdır. .Machine$double.epsdeğerler 1 olduğunda kesinlik verir. nextAfterMakinenin hassasiyetini diğer değerler için almak üzere C işlevini kullanabilirsiniz .

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

Değer ekleme adeğere bdeğişmeyecek bzaman aolduğu <= 's makine hassas yarısı. Farkın makine hassasiyetinden daha küçük olup olmadığını kontrol etmek ile yapılır <. Değiştiriciler, bir eklemenin ne sıklıkta değişiklik göstermediğini tipik durumlar olarak değerlendirebilir.

İçinde R makine hassasiyeti ile tahmin edilebilir:

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

Her doubledeğer bir aralığı temsil eder. Basit bir ekleme için, sonuç aralığı, her bir summandın yeniden canlandırılmasına ve aynı zamanda toplamlarının aralığına bağlıdır.

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

Daha yüksek hassasiyet Rmpfriçin kullanılabilir.

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

gmpTamsayıya dönüştürülebilmesi durumunda kullanılabilir (Rmpfr'de ne var).

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

Bir machine.eps tanımı: en düşük değerdir  eps için  1+eps değil 1

Genel bir kural olarak (taban 2 ile bir kayan nokta temsili varsayarak):
Bu eps, 1 .. 2 aralığı için fark yaratır,
2 .. 4 aralığı için hassasiyet 2*eps
vb.

Ne yazık ki, burada iyi bir kural yoktur. Tamamen programınızın ihtiyaçlarına göre belirlenir.

R'de yaklaşık olarak eşitliği test etmek için yerleşik bir all olarak eşitiz. Yani belki şöyle bir şey kullanabilirsiniz(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 sahte, ve dahil olmak üzere çift kesinlikli karşılaştırmalar için bir dizi kayan nokta eşleştiriciye sahiptir . Bunları aşağıdaki gibi bir dizi eşleştiricide kullanabilirsiniz:DoubleEqDoubleNear

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

Güncelleme:

Sayısal Tarifler, tek taraflı bir fark katsayısının kullanıldığını, sqrt türevlerin sonlu fark yaklaşımları için adım boyutu için iyi bir seçim olduğunu göstermek için bir türev sağlar.

Sayfa 229-230 olan Wikipedia makale sitesi Sayısal Tarifler, 3. baskı, Bölüm 5.7 (sınırlı sayıda sayfa görüntüleme http://www.nrbook.com/empanel/ adresinde bulunabilir ).

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

Bu IEEE kayan noktalı aritmetik , bilgisayar aritmetiğinin iyi bilinen bir sınırlamasıdır ve birkaç yerde tartışılmaktadır:

• R'deki SSS'nin kendisine özel bir sorusu var: R SSS 7.31
  • Patrick Burns'ün R Inferno'su bu soruna ilk "Çemberi" ayırdı (sayfa 9'dan itibaren)
  • Math Meta'da Aritmetik Toplam Kanıtı Sorunu Soruldu
  • David Goldberg, "Her Bilgisayar Bilimcisi Kayan Nokta Aritmetiği Hakkında Bilmeleri Gerekenler," ACM Bilişim Anketleri 23 , 1 (1991-03), 5-48 doi> 10.1145 / 103162.103163 ( revizyon da mevcuttur) )
  • Kayan Nokta Kılavuzu - Her Programcının Kayan Nokta Aritmetiği Hakkında Bilmesi Gerekenler
  • 0.30000000000000004.com kayan noktalı aritmetiği programlama dilleri arasında karşılaştırır
• "Kayan nokta yanlış" için kanonik kopya (bu sorun için kanonik bir cevap hakkında meta tartışma)
• Aşağıdakiler de dahil olmak üzere çeşitli Yığın Taşması soruları
  • Ondalık sayılar neden tam olarak ikili olarak temsil edilemiyor?
  • Kayan nokta sayıları neden yanlış?
  • Kayan nokta matematiği kırık mı?
• Arthur T. Benjamin Tarafından Açıklanan Matematik Püf Noktaları

. dplyr::near()kayan nokta sayılarının iki vektörünün eşit olup olmadığını test etmek için başka bir seçenektir.

Fonksiyonun yerleşik bir tolerans parametresi vardır: tol = .Machine$double.eps^0.5ayarlanabilir. Varsayılan parametre, için varsayılanla aynıdır all.equal().