Motivo generale (agnostico della lingua)
Poiché non tutti i numeri possono essere rappresentati esattamente nell'aritmetica IEEE in virgola mobile (lo standard che quasi tutti i computer usano per rappresentare i numeri decimali e fare matematica con essi), non otterrai sempre ciò che ti aspettavi. Ciò è particolarmente vero perché alcuni valori che sono decimali semplici e finiti (come 0,1 e 0,05) non sono rappresentati esattamente nel computer e quindi i risultati dell'aritmetica su di essi potrebbero non dare un risultato identico a una rappresentazione diretta del " nota "risposta.
Questa è una limitazione ben nota dell'aritmetica del computer ed è discussa in diversi punti:
Confronto tra scalari
La soluzione standard Rnon è usare ==, ma piuttosto la all.equalfunzione. O meglio, dal momento che all.equaldà un sacco di dettagli sulle differenze se ce ne sono, isTRUE(all.equal(...)).
if(isTRUE(all.equal(i,0.15))) cat("i equals 0.15") else cat("i does not equal 0.15")
i rendimenti
i equals 0.15
Altri esempi di utilizzo all.equalanziché ==(l'ultimo esempio dovrebbe mostrare che questo mostrerà correttamente le differenze).
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
Qualche dettaglio in più, copiato direttamente da una risposta a una domanda simile :
Il problema che hai riscontrato è che il virgola mobile non può rappresentare esattamente le frazioni decimali nella maggior parte dei casi, il che significa che spesso troverai che le corrispondenze esatte falliscono.
mentre R si trova leggermente quando dici:
1.1-0.2
#[1] 0.9
0.9
#[1] 0.9
Puoi scoprire cosa pensa veramente in decimale:
sprintf("%.54f",1.1-0.2)
#[1] "0.900000000000000133226762955018784850835800170898437500"
sprintf("%.54f",0.9)
#[1] "0.900000000000000022204460492503130808472633361816406250"
Puoi vedere che questi numeri sono diversi, ma la rappresentazione è un po 'ingombrante. Se li guardiamo in binario (beh, hex, che è equivalente) otteniamo un'immagine più chiara:
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"
Puoi vedere che differiscono per 2^-53, il che è importante perché questo numero è la differenza rappresentabile più piccola tra due numeri il cui valore è vicino a 1, così come è.
Possiamo scoprire per ogni dato computer quale sia il numero più piccolo rappresentabile guardando nel campo macchina di R :
?.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"
È possibile utilizzare questo fatto per creare una funzione "quasi uguale" che verifica che la differenza sia vicina al numero rappresentabile più piccolo in virgola mobile. In realtà questo è già esistente: 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, ...)
#....
Quindi la funzione all.equal sta effettivamente controllando che la differenza tra i numeri sia la radice quadrata della più piccola differenza tra due mantisse.
Questo algoritmo va un po 'divertente vicino a numeri estremamente piccoli chiamati denormali, ma non devi preoccuparti di questo.
Confronto di vettori
La discussione di cui sopra presupponeva un confronto tra due valori singoli. In R non ci sono scalari, solo vettori e la vettorializzazione implicita è un punto di forza del linguaggio. Per confrontare il valore dei vettori in termini di elementi, valgono i principi precedenti, ma l'implementazione è leggermente diversa. ==è vettorializzato (fa un confronto saggio elemento) mentre all.equalconfronta i vettori interi come un'unica entità.
Utilizzando gli esempi precedenti
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)
==non fornisce il risultato "previsto" e all.equalnon esegue gli elementi
a==b
#[1] FALSE FALSE FALSE FALSE
all.equal(a,b)
#[1] "Mean relative difference: 0.01234568"
isTRUE(all.equal(a,b))
#[1] FALSE
Piuttosto, deve essere utilizzata una versione che circola sui due vettori
mapply(function(x, y) {isTRUE(all.equal(x, y))}, a, b)
#[1] TRUE TRUE TRUE FALSE
Se si desidera una versione funzionale di questo, può essere scritta
elementwise.all.equal <- Vectorize(function(x, y) {isTRUE(all.equal(x, y))})
che può essere chiamato solo
elementwise.all.equal(a, b)
#[1] TRUE TRUE TRUE FALSE
In alternativa, invece di racchiudere all.equalin ancora più chiamate di funzione, puoi semplicemente replicare i relativi interni all.equal.numerice utilizzare la vettorializzazione implicita:
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
Questo è l'approccio adottato dplyr::near, che si documenta come
Questo è un modo sicuro per confrontare se due vettori di numeri in virgola mobile sono (a coppie) uguali. Questo è più sicuro dell'uso ==, perché ha una tolleranza integrata
dplyr::near(a, b)
#[1] TRUE TRUE TRUE FALSE