Почему эти цифры не равны?

Следующий код явно ошибочен. В чем проблема?

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

ОТВЕТЫ

Ответ 1

Общая (независимая от языка) причина

Поскольку не все числа могут быть точно представлены в арифметике с плавающей точкой IEEE (стандарт, который почти все компьютеры используют для представления десятичных чисел и выполнения математических операций с ними), вы не всегда получите то, что ожидали. Это особенно верно, потому что некоторые значения, которые являются простыми, конечными десятичными знаками (такими как 0,1 и 0,05), не представлены точно в компьютере, и поэтому результаты арифметики на них могут не дать результат, который идентичен прямому представлению " известный "ответ.

Это хорошо известное ограничение компьютерной арифметики, которое обсуждается в нескольких местах:

Сравнение скаляров

Стандартное решение этой проблемы в 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

Еще несколько подробностей, скопировано непосредственно из ответа на аналогичный вопрос:

Проблема, с которой вы столкнулись, заключается в том, что в большинстве случаев с плавающей запятой невозможно точно представить десятичные дроби, а это означает, что вы часто обнаружите, что точное совпадение не удается.

в то время как 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"

Вы можете видеть, что они отличаются на 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"

Вы можете использовать этот факт для создания функции "почти равных", которая проверяет, что разница близка к наименьшему представимому числу в плавающей запятой. На самом деле это уже существует: 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

Ответ 2

Добавляя к комментарию Брайана (что является причиной), вы можете это сделать, используя 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 здесь приведен обновленный код (спасибо Джошуа):

 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

Ответ 3

Это хаки, но быстро:

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

Ответ 4

dplyr::near() - это опция для тестирования, если два вектора чисел с плавающей точкой равны. Это пример из документов:

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

Функция имеет встроенный параметр допуска: tol =.Machine$double.eps^0.5 который можно настроить. Параметр по умолчанию такой же, как по умолчанию для all.equal().

Ответ 5

используйте метод all.equal() для сравнения двух значений в R.

all.equal(x, y) - это утилита для сравнения R объектов x и y, тестирующих "почти равенство". Если они различаются, сравнение все равно выполняется до некоторой степени, и возвращается отчет о различиях. Не используйте all.equal напрямую в выражениях if --- используйте isTRUE (all.equal(....)) или идентичные, если это необходимо.

Например:

all.equal(pi, 355/113)
# not precise enough (default tol) > relative error

d45 <- pi*(1/4 + 1:10)
stopifnot(
all.equal(tan(d45), rep(1, 10)))          # TRUE, but
all      (tan(d45) == rep(1, 10))         # FALSE, since not exactly
all.equal(tan(d45), rep(1, 10), tolerance = 0)  # to see difference

## advanced: equality of environments
ae <- all.equal(as.environment("package:stats"),
                asNamespace("stats"))
stopifnot(is.character(ae), length(ae) > 10,
          ## were incorrectly "considered equal" in R <= 3.1.1
          all.equal(asNamespace("stats"), asNamespace("stats")))

Ответ 6

У меня была похожая проблема. Я использовал следующее решение.

@Я нашел решение для неравных интервалов резки. @Я использовал функцию округления в 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

Ответ 7

Обобщенные сравнения ("<=", "> =", "=") в двойной арифметике

Сравнивая <= 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

Сравнивая а = б:

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