Search
   >> Home >> Resources & support >> FAQs >> The accuracy of the float data type

How many significant digits are there in a float?

Title   The accuracy of the float data type
Author William Gould, StataCorp
Date May 2001

float is a storage format used by Stata, not a computation format. When you have a number stored as a float and you make a calculation, such as

        . gen newvar = sqrt(oldvar)/sqrt(2)

oldvar is retrieved and is promoted to a double. The entire computation is then made in double precision, and that result is rounded to a float.

Floats have 7.22 digits of precision, but there is an argument for saying 7.5 digits because it all depends on how you count partial digits.

The way computers store floating point (not to be confused with float, because double is also an example of floating point) is

        z = a * 2p	-2 < a < 2

Here are some examples of how numbers are stored:

         z       a          p
      ------------------------
         1       1          0
         1.5     1.5        0
         2       1          1
         3       1.5        1     (i.e., 1.5*2^1 = 3)
      ------------------------

In float, 24 bits are allocated for a. Thus the largest integer that can be exactly stored is 2^0 + 2^1 + ... + 2^23 = (2^24)−1 = 16,777,215. Well, actually, 2^24 = 16,777,216 is also precisely stored because it is even, but 16,777,217 cannot be precisely stored. Using Stata, we can demonstrate these factors using Stata's float() function, which rounds to float precision:

        . display float(16777216)
        16777216

        . display float(16777217)
        16777216

Good; Stata works just as theory would suggest.

Now how accurate is float? Well, for numbers like 16,777,217, the absolute error is 1, so the relative error is

        1/16,777,217 = 5.960e-08

Generally, when you store a number z as float, what is stored is z', and you can be assured that

        z * (1 - 5.960e-08)  <=  z'  <=  z * (1 + 5.960e-08)

How many digits of accuracy is that? I can tell you exactly in binary: 24 binary digits, but how do you count in binary digits in base 10? (By the way, thinking in binary is not difficult here: 24 binary digits means the smallest number is 2^(−24) = 5.96e−08, and there is the same relative accuracy we received above.)

Returning to decimal, you might start by observing that 16,777,216 has 8 digits, but no 8-digit number can be stored, so we don't want to claim 8.

One way to get a base-10 representation would be to take log10(16,777,216) = 7.2247199. That is the way most numerical analysts would convert digit accuracy between bases, so we could claim 7.22 decimal digits of accuracy.

The .22 part of 7.2 is subject to misinterpretation because what we just called .22 would, by some, be called one-half. Consider 16,777,216 and some too-big numbers after that:

        true number           stored if float
        ----------------------------------------
        16,777,216            16,777,216
        16,777,217            16,777,216
        16,777,218            16,777,218
        16,777,219            16,777,220    [sic]
        16,777,220            16,777,220
        16,777,221            16,777,220
        16,777,222            16,777,222
        16,777,223            16,777,224    [sic]
        16,777,224            16,777,224
        16,777,225            16,777,224
        ----------------------------------------

Basically, odd numbers are being rounded to even numbers. A lot of people would call this the loss of half the digits in the last place, and we could develop a different formula that would label that difference 7.5. Sometimes in computer documentation, you will see the statement that float has 7.5 digits of accuracy. They say that and not 7.22 because the authors worry that you might misinterpret what 7.22 means.

Label the difference how you wish; there are 24 binary digits, and the relative accuracy is +/− 2^(−24) = 5.960e−08.

Note: The [sic]s in the above have to do with how numbers ending in exactly “half” (5 in decimal) are rounded; this is the same problem as rounding 1.5 and 2.5 to one digit in decimal.

The Stata Blog: Not Elsewhere Classified Find us on Facebook Follow us on Twitter LinkedIn Google+ Watch us on YouTube