52847

Why are these numbers not equal?

Question:

The following code is obviously wrong. What's the problem?

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

Answer1:

General (language agnostic) reason

Since not all numbers can be represented exactly in <a href="http://en.wikipedia.org/wiki/IEEE_floating_point" rel="nofollow">IEEE floating point arithmetic</a> (the standard that almost all computers use to represent decimal numbers and do math with them), you will not always get what you expected. This is especially true because some values which are simple, finite decimals (such as 0.1 and 0.05) are not represented exactly in the computer and so the results of arithmetic on them may not give a result that is identical to a direct representation of the "known" answer.

This is a well known limitation of computer arithmetic and is discussed in several places:

<ul><li>The R FAQ has question devoted to it: <a href="http://cran.r-project.org/doc/FAQ/R-FAQ.html#Why-doesn_0027t-R-think-these-numbers-are-equal_003f" rel="nofollow">R FAQ 7.31</a></li> <li><a href="http://www.burns-stat.com/pages/Tutor/R_inferno.pdf" rel="nofollow">The R Inferno by Patrick Burns</a> devotes the first "Circle" to this problem (starting on page 9)</li> <li>David Goldberg, "What Every Computer Scientist Should Know About Floating-point Arithmetic," <em>ACM Computing Surveys</em> <strong>23</strong>, 1 (1991-03), 5-48 <a href="http://dx.doi.org/10.1145/103162.103163" rel="nofollow">doi>10.1145/103162.103163</a> (<a href="http://www.validlab.com/goldberg/paper.pdf" rel="nofollow">revision also available</a>)</li> <li><a href="http://floating-point-gui.de/" rel="nofollow">The Floating-Point Guide - What Every Programmer Should Know About Floating-Point Arithmetic</a></li> <li><a href="http://0.30000000000000004.com" rel="noreferrer">0.30000000000000004.com</a> compares floating point arithmetic across programming languages</li> <li>Several Stack Overflow questions including <ul><li><a href="https://stackoverflow.com/q/21895756/892313" rel="nofollow">Why Are Floating Point Numbers Inaccurate?</a></li> <li><a href="https://stackoverflow.com/q/1089018/892313" rel="nofollow">Why can't decimal numbers be represented exactly in binary?</a></li> <li><a href="https://stackoverflow.com/q/588004/892313" rel="nofollow">Is floating point math broken?</a></li> <li><a href="https://meta.stackoverflow.com/q/260130/892313" rel="nofollow">Canonical duplicate for "floating point is inaccurate"</a> (a meta discussion about a canonical answer for this issue)</li> </ul></li> </ul>

Comparing scalars

The standard solution to this in R is not to use <a href="https://www.rdocumentation.org/packages/base/topics/Comparison" rel="nofollow">==</a>, but rather the <a href="https://www.rdocumentation.org/packages/base/topics/all.equal" rel="nofollow">all.equal</a> function. Or rather, since all.equal gives lots of detail about the differences if there are any, isTRUE(all.equal(...)).

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

yields

i equals 0.15

Some more examples of using all.equal instead of == (the last example is supposed to show that this will correctly show differences).

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

Some more detail, directly copied from an <a href="https://stackoverflow.com/a/2228139/892313" rel="nofollow">answer to a similar question</a>:

The problem you have encountered is that floating point cannot represent decimal fractions exactly in most cases, which means you will frequently find that exact matches fail.

while R lies slightly when you say:

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

You can find out what it really thinks in decimal:

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

You can see these numbers are different, but the representation is a bit unwieldy. If we look at them in binary (well, hex, which is equivalent) we get a clearer picture:

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"

You can see that they differ by 2^-53, which is important because this number is the smallest representable difference between two numbers whose value is close to 1, as this is.

We can find out for any given computer what this smallest representable number is by looking in R's <a href="https://www.rdocumentation.org/packages/base/topics/.Machine" rel="nofollow">machine</a> field:

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

You can use this fact to create a 'nearly equals' function which checks that the difference is close to the smallest representable number in floating point. In fact this already exists: 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, ...) #....

So the all.equal function is actually checking that the difference between the numbers is the square root of the smallest difference between two mantissas.

This algorithm goes a bit funny near extremely small numbers called denormals, but you don't need to worry about that.

Comparing vectors

The above discussion assumed a comparison of two single values. In R, there are no scalars, just vectors and implicit vectorization is a strength of the language. For comparing the value of vectors element-wise, the previous principles hold, but the implementation is slightly different. == is vectorized (does an element-wise comparison) while all.equal compares the whole vectors as a single entity.

Using the previous examples

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)

== does not give the "expected" result and all.equal does not perform element-wise

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

Rather, a version which loops over the two vectors must be used

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

If a functional version of this is desired, it can be written

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

which can be called as just

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

Alternatively, instead of wrapping all.equal in even more function calls, you can just replicate the relevant internals of all.equal.numeric and use implicit vectorization:

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

Answer2:

Adding to Brian's comment (which is the reason) you can over come this by using all.equal instead:

# 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

<strong>Per Joshua's warning here is the updated code (Thanks Joshua):</strong>

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

Answer3:

This is hackish, but quick:

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

Answer4:

dplyr::near() is an option for testing if two vectors of floating point numbers are equal. This is the example from the <a href="https://dplyr.tidyverse.org/reference/near.html" rel="nofollow">docs</a>:

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

The function has a built in tolerance parameter: tol = .Machine$double.eps^0.5 that can be adjusted. The default parameter is the same as the default for all.equal().

Recommend

  • NUTS Regions to UK Postcodes
  • How do I draw a rectangle from one render target onto another without losing data?
  • How to get the distance to an object and size of the object using the camera (Android device)?
  • Get a Facebook Page's public posts without an auth token
  • list tables and fields of OpenBSD databases/sqlports sqlite3 database
  • Scheme prime numbers
  • Invoke the editor in the interactive mode
  • Is there any way to convert json to xml in PHP?
  • Python: Mapping between two arrays with an index array
  • Implementation of Thread-local storage (TLS) in C/C++ (multithreading)
  • how to compile code from svn into jar file?
  • What is the difference between Google Developers Console project and a Google **Play** Developers Co
  • Best style for iterating over a small number of items in Python?
  • Set audio input level using portaudio
  • how do you read the ramda docs?
  • Change behaviour of Print button in ReportViewer C#
  • wxWidgets: Detecting click event on custom controls
  • CSS - how to trim text output?
  • How do I include screenshots of the full page in my serenity report (and not only of the viewport) u
  • ASP.NET, C# How to Pass a StringQuery to a custom SQL Command
  • Bootstrap collapse within a foreach loop
  • Merge list of objects into consistent list based on common matching attribute in Python
  • Is it possible to send skype chat messages from a linux server without X?
  • jinja2 template not found and internal server error
  • Custom Nav Title offset ios 11
  • Insert records if not exist SQL Server 2005
  • How secure are apple APNS push notifications?
  • Backward compatibility of Python 3.5 for external modules
  • Why does the font in these TD elements render at different sizes?
  • Unique Permutations - with exceptions
  • Can you pass an array from javascript to asp.net mvc controller action without using a form?
  • Cloud Code function running twice
  • Hibernate to update table schema
  • Abort upload large uploads after reading headers
  • Functions in global context
  • Jquery UI tool tip close icon
  • Update CALayer sublayers immediately
  • How do you troubleshoot character encoding problems?
  • XCode 8, some methods disappeared ? ex: layoutAttributesClass() -> AnyClass
  • Checking variable from a different class in C#