왜 이 숫자들은 같지 않습니까?

왜 이 숫자들은 같지 않습니까?

다음 코드는 명백히 잘못된 것입니다.문제가 뭐죠?

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
• 패트릭 번즈의 R Inferno는 이 문제에 첫 번째 "원"을 바칩니다(9페이지부터 시작).
• David Goldberg, "부동점 산술에 대해 모든 컴퓨터 과학자가 알아야 할 것", ACM 컴퓨팅 조사 23, 1(1991-03), 5-48 doi>10.1145/103162.103163(개정판도 이용 가능)
• 부동소수점 안내서 - 부동소수점 연산에 대해 모든 프로그래머가 알아야 할 사항
• 0.30000000000000004.com 은 프로그래밍 언어 간 부동소수점 산술을 비교합니다.
• 다음을 포함한 몇 가지 스택 오버플로 질문
  • 부동 소수점 번호가 부정확한 이유는 무엇입니까?
  • 왜 십진수는 이진법으로 정확하게 표현할 수 없습니까?
  • 부동 소수점 수학이 깨졌습니까?
  • 부동 소수점이 부정확합니다.(이 문제에 대한 표준 답변에 대한 메타 토론)

스칼라 비교

은 이에대표은해에 .R사용하는 것이 아니라 기능을 사용하는 것입니다.아니 오히려, 그 이후로.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
 #....
 #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 함수는 실제로 숫자 사이의 차이가 두 개의 만티사 사이의 가장 작은 차이의 제곱근인지 확인하는 것입니다.

이 알고리즘은 데노멀(denormal)이라고 불리는 아주 작은 숫자에 가까운 약간의 재미를 줍니다. 하지만 여러분은 걱정할 필요가 없습니다.

벡터 비교

위의 논의에서는 두 개의 단일 값을 비교한다고 가정했습니다.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

벡터 내에서 값의 발생 여부 검사

표준 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

다음과 같이 새로운 infix 연산자를 정의하여 비교에서 허용 오차를 허용할 수 있습니다.

`%.in%` = function(a, b, eps = sqrt(.Machine$double.eps)) {
  any(abs(b-a) <= eps)
}

0.92 %.in% x
# [1] TRUE

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

이것은 진부하지만, 빠릅니다.

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

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

이중 정밀도 산술에서 일반화된 비교("<=", ">=", "="):

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

저도 비슷한 문제가 있었습니다.저는 다음과 같은 용액을 사용했습니다.

저는 불평등한 절단 간격에 대한 해결책에 대한 이 작업을 발견했습니다.저는 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

언급URL : https://stackoverflow.com/questions/9508518/why-are-these-numbers-not-equal