Genel (dil agnostik) nedeni
Tüm sayılar tam olarak IEEE kayan nokta aritmetiğinde temsil edilemediğinden (neredeyse tüm bilgisayarların ondalık sayıları temsil etmek ve onlarla matematik yapmak için kullandığı standart), her zaman beklediğiniz şeyi elde edemezsiniz. Bu özellikle doğrudur, çünkü basit, sonlu ondalık sayılar (0.1 ve 0.05 gibi) tam olarak bilgisayarda temsil edilmez ve bu nedenle üzerlerindeki aritmetik sonuçlar, " bilinen cevap.
Bu, bilgisayar aritmetiğinin iyi bilinen bir sınırlamasıdır ve birkaç yerde tartışılmaktadır:
Skalerlerin karşılaştırılması
Bunun standart çözümü Rkullanmak ==değil, all.equalişlevdir. Ya da daha doğrusu, all.equaleğer varsa, farklılıklar hakkında çok fazla ayrıntı verdiğinden isTRUE(all.equal(...)),.
if(isTRUE(all.equal(i,0.15))) cat("i equals 0.15") else cat("i does not equal 0.15")
verim
i equals 0.15
all.equalBunun yerine kullanmaya ilişkin bazı örnekler ==(son örnekte bunun farklılıklar doğru gösterileceği gösterilmektedir).
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
Benzer bir sorunun cevabından doğrudan kopyalanan biraz daha detay :
Karşılaştığınız sorun, kayan noktanın ondalık kesirleri çoğu durumda tam olarak temsil edememesidir, yani tam eşleşmelerin başarısız olduğunu sık sık bulacaksınız.
R dediğinde R hafifçe yatar:
1.1-0.2
#[1] 0.9
0.9
#[1] 0.9
Ondalık olarak gerçekten ne düşündüğünü öğrenebilirsiniz:
sprintf("%.54f",1.1-0.2)
#[1] "0.900000000000000133226762955018784850835800170898437500"
sprintf("%.54f",0.9)
#[1] "0.900000000000000022204460492503130808472633361816406250"
Bu sayıların farklı olduğunu görebilirsiniz, ancak gösterim biraz hantal. Onlara ikili olarak bakarsak (iyi, onaltılık, eşdeğer) daha net bir resim elde ederiz:
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"
2^-53Farklı olduklarını görebilirsiniz , bu önemlidir çünkü bu sayı, değeri 1'e yakın olan iki sayı arasındaki en küçük temsil edilebilir farktır.
Herhangi bir bilgisayar için, R'nin makine alanına bakarak bu en küçük temsil edilebilir numaranın ne olduğunu bulabiliriz :
?.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"
Bu gerçeği, farkın kayan noktadaki en küçük temsil edilebilir sayıya yakın olduğunu kontrol eden 'neredeyse eşittir' işlevi oluşturmak için kullanabilirsiniz. Aslında bu zaten var: 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, ...)
#....
All.equal işlevi aslında sayılar arasındaki farkın iki mantis arasındaki en küçük farkın kare kökü olduğunu kontrol etmektir.
Bu algoritma denormals denilen son derece küçük sayıların yakınında biraz komik oluyor, ancak bunun için endişelenmenize gerek yok.
Vektörleri karşılaştırma
Yukarıdaki tartışma iki tek değerin karşılaştırılmasını varsaymıştır. R'de skaler yoktur, sadece vektörler ve örtük vektörleşme dilin gücüdür. Vektörlerin değerini element açısından karşılaştırmak için önceki ilkeler geçerlidir, ancak uygulama biraz farklıdır. tüm vektörleri tek bir varlık olarak karşılaştırırken ==, vektörize edilir (eleman bazında bir karşılaştırma yapar) all.equal.
Önceki örnekleri kullanma
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)
=="beklenen" sonucu all.equalvermez ve öğe bazında çalışmaz
a==b
#[1] FALSE FALSE FALSE FALSE
all.equal(a,b)
#[1] "Mean relative difference: 0.01234568"
isTRUE(all.equal(a,b))
#[1] FALSE
Aksine, iki vektörün üzerinden geçen bir versiyon kullanılmalıdır.
mapply(function(x, y) {isTRUE(all.equal(x, y))}, a, b)
#[1] TRUE TRUE TRUE FALSE
Bunun işlevsel bir versiyonu isteniyorsa, yazılabilir
elementwise.all.equal <- Vectorize(function(x, y) {isTRUE(all.equal(x, y))})
ki bu sadece
elementwise.all.equal(a, b)
#[1] TRUE TRUE TRUE FALSE
Alternatif olarak, all.equaldaha fazla işlev çağrısını sarmak yerine, yalnızca ilgili all.equal.numericiçleri çoğaltabilir ve örtük vektörleştirmeyi kullanabilirsiniz:
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
Bu, dplyr::nearkendini şu şekilde belgeleyen yaklaşımdır .
Kayan nokta sayılarının iki vektörünün (çift olarak) eşit olup olmadığını karşılaştırmanın güvenli bir yoludur. Kullanmaktan daha güvenlidir ==, çünkü yerleşik bir toleransı vardır
dplyr::near(a, b)
#[1] TRUE TRUE TRUE FALSE