提问人：dplanet 提问时间：3/1/2012 最后编辑：Jaapdplanet 更新时间：9/6/2023 访问量：66833
为什么这些数字不相等？
Why are these numbers not equal?
问：
下面的代码显然是错误的。怎么了？
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
答：
411赞
16 revs, 7 users 64%Brian Diggs
#1
一般（与语言无关）原因
由于并非所有数字都可以用IEEE浮点运算（几乎所有计算机都用来表示十进制数并用它们进行数学运算的标准）精确表示，因此您并不总是能得到预期的结果。尤其如此，因为一些简单的有限小数值（例如 0.1 和 0.05）在计算机中并不精确表示，因此对它们的算术结果可能不会给出与“已知”答案的直接表示相同的结果。
这是计算机算术的一个众所周知的局限性，在几个地方进行了讨论：
- R FAQ 有专门针对它的问题：R FAQ 7.31
- 帕特里克·伯恩斯 （Patrick Burns） 的 R Inferno 将第一个“圆圈”用于解决这个问题（从第 9 页开始）
- David Goldberg，“每个计算机科学家都应该知道的浮点算术知识”，ACM Computing Surveys 23， 1 （1991-03）， 5-48 doi>10.1145/103162.103163 （修订版也可用）)
- 浮点指南 - 每个程序员都应该了解的浮点运算知识
- 0.30000000000000004.com 比较了不同编程语言的浮点运算
- 几个 Stack Overflow 问题，包括
- 为什么浮点数不准确？
- 为什么十进制数不能用二进制精确表示？
- 浮点数学坏了吗？
- “浮点不准确”的规范副本（关于此问题的规范答案的元讨论）
比较标量
对此的标准解决方案不是使用 ==，而是使用 all.equal 函数。或者更确切地说，由于提供了有关差异（如果有）的大量详细信息，.Rall.equalisTRUE(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
更多细节，直接从类似问题的答案中复制：
您遇到的问题是，在大多数情况下，浮点数无法精确表示小数，这意味着您经常会发现精确匹配失败。
而 R 在你说的时候略微撒谎：
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"
您可以看到它们相差 ，这很重要，因为这个数字是两个值接近 1 的数字之间最小的可表示差，因为这是。2^-53
对于任何给定的计算机，我们都可以通过查看 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"
您可以使用这一事实创建一个“几乎相等”函数，该函数检查差值是否接近浮点数中的最小可表示数。事实上，这已经存在了：.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)
==不给出“预期”结果，也不按元素执行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.equalall.equal.numeric
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
这是 所采用的方法，它将自己记录为dplyr::near
这是比较两个浮点数向量是否（成对）相等的安全方法。这比使用 更安全，因为它具有内置的公差
==
dplyr::near(a, b)
#[1] TRUE TRUE TRUE FALSE
测试向量中值的出现
如果将标准 R 函数应用于浮点值，也可能会遇到同样的问题。例如：%in%
x = seq(0.85, 0.95, 0.01)
# [1] 0.85 0.86 0.87 0.88 0.89 0.90 0.91 0.92 0.93 0.94 0.95
0.92 %in% x
# [1] FALSE
我们可以定义一个新的中缀运算符，以允许在比较中出现容差，如下所示：
`%.in%` = function(a, b, eps = sqrt(.Machine$double.eps)) {
any(abs(b-a) <= eps)
}
0.92 %.in% x
# [1] TRUE
dplyr::nearWrapped in 也可用于矢量化检查any
any(dplyr::near(0.92, x))
# [1] TRUE
46赞
Tyler Rinker
3/1/2012
#2
除了 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
根据 Joshua 的警告，这里是更新的代码（感谢 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
评论
20赞
Joshua Ulrich
3/1/2012
all.equal当存在差异时不会返回，因此在语句中使用它时需要将其包装起来。FALSEisTRUEif
0赞
Yacine Hajji
7/20/2023
R 没有更新以使 dplanet 代码正常工作是有原因的吗？也遇到了同样的问题==
14赞
Hillary Sanders
9/7/2013
#3
这很骇人听闻，但很快：
if(round(i, 10)==0.15) cat("i equals 0.15") else cat("i does not equal 0.15")
评论
3赞
smci
5/28/2018
但您可以使用该参数。 是真的。all.equal(... tolerance)all.equal(0.147, 0.15, tolerance=0.05)
15赞
sbha
11/9/2018
#4
dplyr::near()是用于测试浮点数的两个向量是否相等的选项。这是文档中的示例：
sqrt(2) ^ 2 == 2
#> [1] FALSE
library(dplyr)
near(sqrt(2) ^ 2, 2)
#> [1] TRUE
该函数有一个内置的公差参数：可以调整。缺省参数与 的缺省参数相同。tol = .Machine$double.eps^0.5all.equal()
0赞
Estatistics
2/23/2019
#5
我也有类似的问题。我使用了以下解决方案。
@我发现这个关于不相等切割间隔的解决方案。A ( 在 R 中使用了 round 函数。通过将选项设置为 2 位数字，确实做到了 没有解决问题。
options(digits = 2)
cbind(
seq( from = 1, to = 9, by = 1 ),
cut( seq( from = 1, to = 9, by = 1), c( 0, 3, 6, 9 ) ),
seq( from = 0.1, to = 0.9, by = 0.1 ),
cut( seq( from = 0.1, to = 0.9, by = 0.1), c( 0, 0.3, 0.6, 0.9 )),
seq( from = 0.01, to = 0.09, by = 0.01 ),
cut( seq( from = 0.01, to = 0.09, by = 0.01), c( 0, 0.03, 0.06, 0.09 ))
)
基于选项（数字 = 2）的不相等切割间隔的输出：
[,1] [,2] [,3] [,4] [,5] [,6]
[1,] 1 1 0.1 1 0.01 1
[2,] 2 1 0.2 1 0.02 1
[3,] 3 1 0.3 2 0.03 1
[4,] 4 2 0.4 2 0.04 2
[5,] 5 2 0.5 2 0.05 2
[6,] 6 2 0.6 2 0.06 3
[7,] 7 3 0.7 3 0.07 3
[8,] 8 3 0.8 3 0.08 3
[9,] 9 3 0.9 3 0.09 3
options(digits = 200)
cbind(
seq( from = 1, to = 9, by = 1 ),
cut( round(seq( from = 1, to = 9, by = 1), 2), c( 0, 3, 6, 9 ) ),
seq( from = 0.1, to = 0.9, by = 0.1 ),
cut( round(seq( from = 0.1, to = 0.9, by = 0.1), 2), c( 0, 0.3, 0.6, 0.9 )),
seq( from = 0.01, to = 0.09, by = 0.01 ),
cut( round(seq( from = 0.01, to = 0.09, by = 0.01), 2), c( 0, 0.03, 0.06, 0.09 ))
)
基于四舍五入函数的等切割间隔输出：
[,1] [,2] [,3] [,4] [,5] [,6]
[1,] 1 1 0.1 1 0.01 1
[2,] 2 1 0.2 1 0.02 1
[3,] 3 1 0.3 1 0.03 1
[4,] 4 2 0.4 2 0.04 2
[5,] 5 2 0.5 2 0.05 2
[6,] 6 2 0.6 2 0.06 2
[7,] 7 3 0.7 3 0.07 3
[8,] 8 3 0.8 3 0.08 3
[9,] 9 3 0.9 3 0.09 3
3赞
Erdogan CEVHER
5/26/2019
#6
双精度算术中的广义比较（“<=”、“>=”、“=”）：
比较 a <= b：
IsSmallerOrEqual <- function(a,b) {
# Control the existence of "Mean relative difference..." in all.equal;
# if exists, it results in character, not logical:
if ( class(all.equal(a, b)) == "logical" && (a<b | all.equal(a, b))) { return(TRUE)
} else if (a < b) { return(TRUE)
} else { return(FALSE) }
}
IsSmallerOrEqual(abs(-2-(-2.2)), 0.2) # TRUE
IsSmallerOrEqual(abs(-2-(-2.2)), 0.3) # TRUE
IsSmallerOrEqual(abs(-2-(-2.2)), 0.1) # FALSE
IsSmallerOrEqual(3,3); IsSmallerOrEqual(3,4); IsSmallerOrEqual(4,3)
# TRUE; TRUE; FALSE
比较 >= b：
IsBiggerOrEqual <- function(a,b) {
# Control the existence of "Mean relative difference..." in all.equal;
# if exists, it results in character, not logical:
if ( class(all.equal(a, b)) == "logical" && (a>b | all.equal(a, b))) { return(TRUE)
} else if (a > b) { return(TRUE)
} else { return(FALSE) }
}
IsBiggerOrEqual(3,3); IsBiggerOrEqual(4,3); IsBiggerOrEqual(3,4)
# TRUE; TRUE; FALSE
比较 a = b：
IsEqual <- function(a,b) {
# Control the existence of "Mean relative difference..." in all.equal;
# if exists, it results in character, not logical:
if ( class(all.equal(a, b)) == "logical" ) { return(TRUE)
} else { return(FALSE) }
}
IsEqual(0.1+0.05,0.15) # TRUE
评论