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

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

一般（与语言无关）原因

由于并非所有数字都可以用IEEE浮点算术（几乎所有计算机都用来表示十进制数字并对其进行数学运算的标准）来精确表示，因此您将无法始终获得期望的结果。尤其如此，因为某些简单的有限十进制值（例如0.1和0.05）无法在计算机中准确表示，因此对它们的算术结果可能不会得出与“”的直接表示相同的结果。已知”的答案。

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

• R FAQ有一个专门的问题：R FAQ 7.31
• 帕特里克·伯恩斯（Patrick Burns）创作的R Inferno致力于解决这个问题的第一个“圆圈”（从第9页开始）
• 大卫·戈德堡，“什么每台计算机科学家应该知道浮点运算，” ACM计算概观 23，1（1991至1903年），5-48 DOI> 10.1145 / 103162.103163（修订版也可）
• 浮点指南-每个程序员应了解的浮点算法
• 0.30000000000000004.com比较各种编程语言中的浮点算法
• 几个堆栈溢出问题，包括
  • 为什么浮点数不正确？
  • 为什么十进制数字不能完全用二进制表示？
  • 浮点数学运算是否被破坏？
  • “浮点数不正确”的规范重复（有关此问题的规范答案的元讨论）

标量比较

此中的标准解决方案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

直接从类似问题的答案中复制的更多细节：

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

而当您说：

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
 #....
 #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.equal除了包装更多的函数调用外，您还可以复制的相关内部信息all.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

在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的警告是更新的代码（谢谢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

这有点骇人听闻，但是很快：

if(round(i, 10)==0.15) cat("i equals 0.15") else cat("i does not equal 0.15")

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()。

我有一个类似的问题。我使用以下解决方案。

@我发现此解决方案适用于有关不相等的切割间隔的解决方案。@我在R中使用了舍入功能。通过将选项设置为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

双精度算术中的广义比较（“ <=”，“> =”，“ =”）：

比较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

比较a> = 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