首页 文章

为什么这些数字不相等？

提问于
浏览 次
231

以下代码显然是错误的 . 有什么问题？

i <- 0.1
i <- i + 0.05
i
## [1] 0.15
if(i==0.15) cat("i equals 0.15") else cat("i does not equal 0.15")
## i does not equal 0.15
r floating-point floating-accuracy r-faq

4 回答

  • 306

    一般（语言不可知）的原因

    由于并非所有数字都可以在IEEE floating point arithmetic（几乎所有计算机用于表示十进制数字并使用它们进行数学运算的标准）中准确表示，因此您并不总是得到您期望的结果 . 这尤其正确，因为一些简单的有限小数（例如0.1和0.05）的值在计算机中没有完全表示，因此对它们的算术结果可能不会给出与"known"的直接表示相同的结果 . 回答 .

    这是众所周知的计算机算术限制，并在以下几个地方进行了讨论：

    比较标量

    R 中的标准解决方案不是使用==，而是使用all.equal函数 . 或者更确切地说，因为 all.equal 提供了很多有关差异的细节，如果有的话， isTRUE(all.equal(...)) .

    if(isTRUE(all.equal(i,0.15))) cat("i equals 0.15") else cat("i does not equal 0.15")

    产量

    i equals 0.15

    使用 all.equal 而不是 == 的更多示例（最后一个示例应该表明这将正确显示差异） .

    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

    更多细节，直接从answer to a similar question复制：

    您遇到的问题是浮点在大多数情况下不能完全表示小数分数，这意味着您经常会发现完全匹配失败 .

    当你说：当你说：

    1.1-0.2
#[1] 0.9
0.9
#[1] 0.9

    您可以通过十进制找出它的真实想法：

    sprintf("%.54f",1.1-0.2)
#[1] "0.900000000000000133226762955018784850835800170898437500"
sprintf("%.54f",0.9)
#[1] "0.900000000000000022204460492503130808472633361816406250"

    您可以看到这些数字不同，但表示有点笨拙 . 如果我们用二进制（嗯，十六进制，等价）来看它们，我们会得到更清晰的图像：

    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^-53 ，这很重要，因为这个数字是两个数值之间的最小可表示差异，其值接近1，因为这是 .

    我们可以通过查看R的machine字段，找出任何给定计算机的最小可表示数字：

    ?.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"

    您可以使用此事实创建'nearly equals'函数，该函数检查差异是否接近浮点中的最小可表示数字 . 实际上这已经存在： 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函数实际上是检查数字之间的差异是两个尾数之间最小差异的平方根 .

    这个算法在称为非正规数的极小数字附近有点滑稽，但你不必担心这一点 .

    比较矢量

    上面的讨论假设了两个单值的比较 . 在R中，没有标量，只是向量和隐式向量化是语言的强项 . 为了比较矢量元素的值，先前的原则成立，但实现略有不同 . == 是矢量化的（进行逐元素比较），而 all.equal 将整个矢量作为单个实体进行比较 .

    使用前面的例子

    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)

    == 未给出"expected"结果且 all.equal 不执行元素方式

    a==b
#[1] FALSE FALSE FALSE FALSE
all.equal(a,b)
#[1] "Mean relative difference: 0.01234568"
isTRUE(all.equal(a,b))
#[1] FALSE

    相反，必须使用在两个向量上循环的版本

    mapply(function(x, y) {isTRUE(all.equal(x, y))}, a, b)
#[1]  TRUE  TRUE  TRUE FALSE

    如果需要它的功能版本，可以编写它

    elementwise.all.equal <- Vectorize(function(x, y) {isTRUE(all.equal(x, y))})

    这可以称为公正

    elementwise.all.equal(a, b)
#[1]  TRUE  TRUE  TRUE FALSE

    或者，您可以只复制 all.equal.numeric 的相关内部并使用隐式向量化，而不是将 all.equal 包装在更多函数调用中：

    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
    回复于
  • 36

    添加到Brian的评论（这是原因）你可以通过使用 all.equal 代替：

    # i <- 0.1
# i <- i + 0.05
# i
#if(all.equal(i, .15)) cat("i equals 0.15\n") else cat("i does not equal 0.15\n")
#i equals 0.15

    Per Joshua's warning here is the updated code (Thanks Joshua):

    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
    回复于
  • 9

    这是hackish，但很快：

    if(round(i, 10)==0.15) cat("i equals 0.15") else cat("i does not equal 0.15")
    回复于
  • 1

    dplyr::near() 是测试两个浮点数向量是否相等的选项 . 这是docs中的示例：

    sqrt(2) ^ 2 == 2
#> [1] FALSE
library(dplyr)
near(sqrt(2) ^ 2, 2)
#> [1] TRUE

    该功能具有内置公差参数： tol = .Machine$double.eps^0.5 可以调整 . 默认参数与 all.equal() 的默认参数相同 .

    回复于

相关问题