Wie kann überprüft werden, ob der Unterschied kleiner als die Maschinengenauigkeit ist?

Ich lande oft in Situationen, in denen überprüft werden muss, ob der ermittelte Unterschied über der Maschinengenauigkeit liegt. Scheint für diesen Zweck R hat eine handliche Variable:.Machine$double.eps . Wenn ich mich jedoch an den R-Quellcode wende, um Richtlinien zur Verwendung dieses Werts zu erhalten, werden mehrere unterschiedliche Muster angezeigt.

Beispiele

Hier einige Beispiele aus stats Bibliothek:

t.test.R

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

chisq.test.R

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

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

usw.

Fragen

1. Wie kann man die Gründe für all diese verschiedenen verstehen 10 *, 100 *, 50 *und sqrt()Modifikatoren?
2. Gibt es Richtlinien .Machine$double.epszur Anpassung von Unterschieden aufgrund von Präzisionsproblemen?

Die Maschinengenauigkeit für doublehängt von ihrem aktuellen Wert ab. .Machine$double.epsGibt die Genauigkeit an, wenn die Werte 1 sind. Mit der C-Funktion können nextAfterSie die Maschinengenauigkeit für andere Werte ermitteln.

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

Das Hinzufügen von Wert azu Wert bändert sich nicht, bwenn adie <= Hälfte der Maschinengenauigkeit erreicht ist. Es wird geprüft, ob der Unterschied geringer ist als die Maschinengenauigkeit< . Die Modifikatoren können typische Fälle berücksichtigen, in denen eine Addition keine Änderung zeigte.

In R kann die Maschinengenauigkeit geschätzt werden mit:

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

Jeder doubleWert repräsentiert einen Bereich. Für eine einfache Addition hängt der Bereich des Ergebnisses von der Neuausrichtung jedes Summanden und auch vom Bereich ihrer Summe ab.

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

Für eine höhere Präzision Rmpfrkönnte verwendet werden.

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

Falls es in eine Ganzzahl konvertiert werden gmpkönnte, könnte es verwendet werden (was in Rmpfr ist).

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

Definition einer machine.eps: Dies ist der niedrigste Wert,   für den dies   nicht der Fall ist eps1+eps1

Als Faustregel (unter der Annahme einer Gleitkommadarstellung mit Basis 2):
Dies epsmacht den Unterschied für den Bereich 1 .. 2,
für den Bereich 2 .. 4 ist die Genauigkeit2*eps
und so weiter.

Leider gibt es hier keine gute Faustregel. Es wird ganz von den Bedürfnissen Ihres Programms bestimmt.

In R haben wir all.equal als eingebauten Weg, um die ungefähre Gleichheit zu testen. Also könntest du vielleicht so etwas gebrauchen (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 verfügt über eine Reihe von Gleitkomma-Matchern für Vergleiche mit doppelter Genauigkeit, einschließlich DoubleEqund DoubleNear. Sie können sie in einem Array-Matcher wie folgt verwenden:

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

Aktualisieren:

Numerische Rezepte liefern eine Ableitung, um zu demonstrieren, dass unter Verwendung eines einseitigen Differenzquotienten sqrt eine gute Wahl der Schrittgröße für endliche Differenznäherungen von Derivaten ist.

Die Wikipedia-Artikelseite Numerical Recipes, 3. Auflage, Abschnitt 5.7, Seiten 229-230 (eine begrenzte Anzahl von Seitenaufrufen ist unter http://www.nrbook.com/empanel/ verfügbar ).

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

Diese IEEE-Gleitkomma-Arithmetik ist eine bekannte Einschränkung der Computer-Arithmetik und wird an mehreren Stellen diskutiert:

• Der FAQ in R ist eine ganze Frage gewidmet: R FAQ 7.31
  • Das R-Inferno von Patrick Burns widmete diesem Problem den ersten "Kreis" (ab Seite 9)
  • Arithmetisches Summenbeweisproblem in Math Meta gestellt
  • David Goldberg, "Was jeder Informatiker über Gleitkomma-Arithmetik wissen sollte", ACM Computing Surveys 23 , 1 (1991-03), 5-48 doi> 10.1145 / 103162.103163 ( Revision ebenfalls verfügbar) )
  • Der Gleitkomma-Leitfaden - Was jeder Programmierer über Gleitkomma-Arithmetik wissen sollte
  • 0.30000000000000004.com vergleicht Gleitkomma-Arithmetik zwischen Programmiersprachen
• Kanonisches Duplikat für "Gleitkomma ist ungenau" (eine Metadiskussion über eine kanonische Antwort auf dieses Problem)
• Mehrere Fragen zum Stapelüberlauf, einschließlich
  • Warum können Dezimalzahlen nicht exakt binär dargestellt werden?
  • Warum sind Gleitkommazahlen ungenau?
  • Ist die Gleitkomma-Mathematik kaputt?
• Math Tricks Erklärt von Arthur T. Benjamin

. dplyr::near()ist eine weitere Option zum Testen, ob zwei Vektoren von Gleitkommazahlen gleich sind.

Die Funktion verfügt über einen eingebauten Toleranzparameter tol = .Machine$double.eps^0.5, der angepasst werden kann. Der Standardparameter ist der gleiche wie der Standardparameter für all.equal().