Search

2.5 — Floating point numbers


Integers are great for counting whole numbers, but sometimes we need to store very large numbers, or numbers with a fractional component. A floating point type variable is a variable that can hold a real number, such as 4320.0, -3.33, or 0.01226. The floating part of the name floating point refers to the fact that the decimal point can “float”; that is, it can support a variable number of digits before and after the decimal point.

There are three different floating point data types: float, double, and long double. As with integers, C++ does not define the size of these types. On modern architectures, floating point representation almost always follows IEEE 754 binary format. In this format, a float is 4 bytes, a double is 8, and a long double can be equivalent to a double (8 bytes), 80-bits (often padded to 12 bytes), or 16 bytes.

Floating point data types are always signed (can hold positive and negative values).

Category Type Minimum Size Typical Size
floating point float 4 bytes 4 bytes
double 4 bytes 8 bytes
long double 4 bytes 8, 12, or 16 bytes

Here are some definitions of floating point numbers:

When we assign literal numbers to floating point numbers, it is convention to use at least one decimal place. This helps distinguish floating point values from integer values.

Scientific notation

How floating point variables store information is beyond the scope of this tutorial, but it is very similar to how numbers are written in scientific notation. Scientific notation is a useful shorthand for writing lengthy numbers in a concise manner. And although scientific notation may seem foreign at first, understanding scientific notation will help you understand how floating point numbers work, and more importantly, what their limitations are.

Numbers in scientific notation take the following form: significand x 10exponent. For example, in the scientific notation 1.2 x 104, 1.2 is the significand and 4 is the exponent. This number evaluates to 12,000.

By convention, numbers in scientific notation are written with one digit before the decimal, and the rest of the digits afterward.

Consider the mass of the Earth. In decimal notation, we’d write this as 5973600000000000000000000 kg. That’s a really large number (too big to fit even in an 8 byte integer). It’s also hard to read (is that 19 or 20 zeros?). In scientific notation, this would be written as 5.9736 x 1024 kg, which is much easier to read. Scientific notation has the added benefit of making it easier to compare the magnitude of two really large or really small numbers simply by comparing the exponent.

Because it can be hard to type or display exponents in C++, we use the letter ‘e’ or ‘E’ to represent the “times 10 to the power of” part of the equation. For example, 1.2 x 104 would be written as 1.2e4, and 5.9736 x 1024 would be written as 5.9736e24.

For numbers smaller than 1, the exponent can be negative. The number 5e-2 is equivalent to 5 * 10-2, which is 5 / 102, or 0.05. The mass of an electron is 9.1093822e-31 kg.

In fact, we can use scientific notation to assign values to floating point variables.

How to convert numbers to scientific notation

Use the following procedure:

  • Your exponent starts at zero.
  • Slide the decimal so there is only one non-zero digit to the left of the decimal.
    • Each place you slide the decimal to the left increases the exponent by 1.
    • Each place you slide the decimal to the right decreases the exponent by 1.
  • Trim off any leading zeros (on the left end)
  • Trim off any trailing zeros (on the right end) if the original number had no decimal point. We’re assuming they’re not significant unless otherwise specified.

Here’s some examples:

Start with: 42030
Slide decimal left 5 spaces: 4.2030e4
No leading zeros to trim: 4.203e4
Trim trailing zeros: 4.203e4 (4 significant digits)
Start with: 0.0078900
Slide decimal right 3 spaces: 0007.8900e-3
Trim leading zeros: 7.8900e-3
Don't trim trailing zeros: 7.8900e-3 (5 significant digits)
Start with: 600.410
Slide decimal left 2 spaces: 6.00410e2
No leading zeros to trim: 6.00410e2
Don't trim trailing zeros: 6.00410e2 (6 significant digits)

Here’s the most important thing to understand: The digits in the significand (the part before the E) are called the significant digits. The number of significant digits defines a number’s precision. The more digits in the significand, the more precise a number is.

Precision and range

Consider the fraction 1/3. The decimal representation of this number is 0.33333333333333… with 3’s going out to infinity. An infinite length number would require infinite memory to store, and we typically only have 4 or 8 bytes. Floating point numbers can only store a certain number of significant digits, and the rest are lost. The precision of a floating point number defines how many significant digits it can represent without information loss.

When outputting floating point numbers, cout has a default precision of 6 -- that is, it assumes all variables are only significant to 6 digits, and hence it will truncate anything after that.

The following program shows cout truncating to 6 digits:

This program outputs:

9.87654
987.654
987654
9.87654e+006
9.87654e-005

Note that each of these is only 6 significant digits.

Also note that cout will switch to outputting numbers in scientific notation in some cases. Depending on the compiler, the exponent will typically be padded to a minimum number of digits. Fear not, 9.87654e+006 is the same as 9.87654e6, just with some padding 0’s. The minimum number of exponent digits displayed is compiler-specific (Visual Studio uses 3, some others use 2 as per the C99 standard).

However, we can override the default precision that cout shows by using the setprecision() function that is defined in a header file called iomanip.

Outputs:

3.333333253860474
3.333333333333334

Because we set the precision to 16 digits, each of the above numbers has 16 digits. But, as you can see, the numbers certainly aren’t precise to 16 digits!

Variables of type float typically have a precision of about 7 significant digits (which is why everything after that many digits in our answer above is junk). Variables of type double typically have a precision of about 16 significant digits. Long double can have a precision of about 16, 18, or 33 significant digits depending on how many bytes it occupies.

Precision issues don’t just impact fractional numbers, they impact any number with too many significant digits. Let’s consider a big number:

Output:

123456792

123456792 is greater than 123456789. The value 123456789.0 has 9 significant digits, but float only supports about 7 digits of precision. We lost some precision!

Consequently, one has to be careful when using floating point numbers that require more precision than the variables can hold.

Assuming IEEE 754 representation:

Size Range Precision
4 bytes ±1.18 x 10-38 to ±3.4 x 1038 7 significant digits
8 bytes ±2.23 x 10-308 to ±1.80 x 10308 15 significant digits
80-bits (12 bytes) ±3.65 x 10-4951 to ±1.18 x 104932 18 significant digits
16 bytes ±3.36 x 10-4932 to ±1.18 x 104932 34 significant digits

Rule: Favor double over float unless space is at a premium, as the lack of precision in a float will often lead to challenges.

Rounding errors

One of the reasons floating point numbers can be tricky is due to non-obvious differences between binary (how data is stored) and decimal (how we think) numbers. Consider the fraction 1/10. In decimal, this is easy represented as 0.1, and we are used to thinking of 0.1 as an easily representable number. However, in binary, 0.1 is represented by the infinite sequence: 0.00011001100110011… Because of this, when we assign 0.1 to a floating point number, we’ll run into precision problems.

You can see the effects of this in the following program:

This outputs:

0.1
0.10000000000000001

On the top line, cout prints 0.1, as we expect.

On the bottom line, where we have cout show us 17 digits of precision, we see that d is actually not quite 0.1! This is because the double had to truncate the approximation due to it’s limited memory, which resulted in a number that is not exactly 0.1. This is called a rounding error.

Rounding errors can have unexpected consequences:

1
0.99999999999999989

Although we might expect that d1 and d2 should be equal, we see that they are not. If we were to compare d1 and d2 in a program, the program would probably not perform as expected. We discuss this more in section 3.5 -- Relational operators (comparisons).

One last note on rounding errors: mathematical operations (such as addition and multiplication) tend to make rounding errors grow. So even though 0.1 has a rounding error in the 17th significant digit, when we add 0.1 ten times, the rounding error has crept into the 16th significant digit.

NaN and Inf

There are two special categories of floating point numbers. The first is Inf, which represents infinity. Inf can be positive or negative. The second is NaN, which stands for “Not a Number”. There are several different kinds of NaN (which we won’t discuss here).

Here’s a program showing all three:

And the results using Visual Studio 2008 on Windows:

1.#INF
-1.#INF
1.#IND

INF stands for infinity, and IND stands for indeterminate. Note that the results of printing Inf and NaN are platform specific, so your results may vary.

Conclusion

To summarize, the two things you should remember about floating point numbers:

1) Floating point numbers are great for storing very large or very small numbers, including those with fractional components, so long as they have a limited number of significant digits (precision).

2) Floating point numbers often have small rounding errors, even when the number has fewer significant digits than the precision. Many times these go unnoticed because they are so small, and because the numbers are truncated for output. Consequently, comparisons of floating point numbers may not give the expected results. Performing mathematical operations on these values will cause the rounding errors to grow larger.

Quiz

1) Convert the following numbers to C++ style scientific notation (using an e to represent the exponent) and determine how many significant digits each has:
a) 34.50
b) 0.004000
c) 123.005
d) 146000
e) 146000.001
f) 0.0000000008
f) 34500.0

Quiz Answers

1) Show Solution

2.6 -- Boolean Values
Index
2.4a -- Fixed-width integers

54 comments to 2.5 — Floating point numbers

  • C++ Student

    It is far less confusing after reading this. Thank you. In class we covered this in about ten minutes and moved on to the next thing.

    I’ve been to a few sites already trying to get a grasp on these (floats/doubles) and this summation really did the trick.

    Thanks!

  • Jefferson

    What do the f’s after some of the float and double values mean?

    • By default, if you type a floating point value into C++ it’s typed as a double. Consequently, if you do something like this:

      You’re assigning a double to a float, which loses precision, and the compiler will probably complain.

      Putting an “f” after the value means that you intend that value to be a float, not a double. Then when you do this:

      You’re assigning a float value to a float variable, which makes more sense.

  • Masss

    Is there something wrong with my code?

    The compiler brings up a problem with setprecision()..

    Thanks

  • Coming form a Java background, I wonder if anyone can advise me a C++ library with a similar function as Java’s BigDecimal.
    Preferably one that works on Linux with gcc(so not the decimal type from Visual C++)

  • So with all the rounding errors and precision problems, how do programmers deal with operations that need to display something that would end up with a precision or rounding error? Or am I just over-thinking things?

    • Most of the time it’s simply not necessary to display a number to the number of significant digits where precision/rounding errors creep in. Generally with floating point numbers, programs will truncate the display to 2-5 decimals.

  • iseneirik

    how can i make the value a user inputs into a float?

    then when i run the program from main() and i put in 2 values like eg. x = 10 y = 3 then the answer is 3 instead of 3.333333

    • You are already storing the user input values as a float. The problem is that your function is returning an integer, so it’s truncating the result of x/y. Change your function to return a float and you will be good.

  • Chris

    I set the precision level to 4, and added cout for the 2 values, fValue1 + fValue2.

    I got fValue1 IS actually rounded off to 1.345 and fValue2 IS actually 1.123, expecting now the get the result of 2.468, but still reports ‘fTotal is not 2.468′

    Why is that?

    Chris

    • Rounding error. The numbers printed on your screen by cout are rounded in this case, so you’re not seeing the full representation. However, when you do the comparison, it does so with the actual numbers, not the rounded ones, which can lead to rounding issues.

  • Vivek Hiremath

    How do I convert a Float say

    x = 1234.567890123456789

    to
    y = 1234.5678901234 (small float ..10 decimal places only)

    Something similar to setPrecision, to use NOT for display/Printing, but to use as a value for calculations / pass it on to a Database etc ?

    • I’m not sure what the best way to do this is. For small numbers, you can multiply by 10^x, cast to an integer to drop the remaining decimals, then divide by 10^x. However, if your number is too large you’ll overflow the int when you do the casting so I won’t say this is foolproof.

  • Noha

    Didn’t understand how 0.1 is represented in binary by 0.00011001100110011…

    • jeremy

      In decimal, .1 is tenths, .01 is hundredths, .001 is thousandths and so on. Likewise, in binary, .1 is halves, .01 is quarters, .001 is eights, and so on.
      0.000110011… would be equal to 1/16 + 1/32 + 1/256 + 1/512 + …

      • Kostas81

        Ok, so in binary, we have to approximate the 1 of decimal 0.1 with an infinite sum. What I still don’t understand is why we don’t use all the “weights”, that is, all the powers of 2, but only 1/16, 1/32, 1/256, 1/512 and so on, that is, the 4th position (2^4 = 16), the 5th, the 8th, the 9th, and so on. In other words, why don’t we have 0.011111111…….. which is equal to 1/2 + 1/4 + 1/8 + 1/16 + …? It also approaches 1! (I am referring of course to the decimal part of 0.1, that is, the 1.)

        • johnbobz

          That’s exactly why you can’t use every power of 1/2. The infinite sum would add up to 1, which is ten times the number we require. In order for the sum to add up to 0.1, you would need to add Sum[(1/2)^4n + (1/2)^(4n+1)], taking n from 1 to infinity. You can try it yourself if you want.

          • Kostas81

            Yes, you are right, this sum indeed converges to 0.1, whereas the sum I used converges to 1.0. Thank you for the clear and concise explanation!

            • Kostas81

              There is also a good explanation in Wikipedia (yes, sometimes -- not often though -- Wikipedia has good articles):

              “Fractions in binary

              Fractions in binary only terminate if the denominator has 2 as the only prime factor. As a result, 1/10 does not have a finite binary representation, and this causes 10 × 0.1 not to be precisely equal to 1 in floating point arithmetic. As an example, to interpret the binary expression for 1/3 = .010101…, this means: 1/3 = 0 × 2^(-1) + 1 × 2^(-2) + 0 × 2^(-3) + 1 × 2^(-4) + … = 0.3125 + … An exact value cannot be found with a sum of a finite number of inverse powers of two, and zeros and ones alternate forever.”

              Follows a table of the conversion (fractional approximations) for fractions from decimal to binary. For the ones who are interested:

              http://en.wikipedia.org/wiki/Binary_numeral_system

  • Stacey Brewer

    When I run the following code, the values seem really wrong when output. What is going wrong here?

    • sanjiv

      your C ++ compiler has a tendency to roundoff 8th precision onwards.
      For any value lesser then 8;
      It will display 1 lesser than called for.

  • mauriciotada

    Hi there! Congratulation, very good explanation!!! Just what I was looking for.

    Thank you.

  • jimboshack

    When I run this code, I get z = 0.333333 and q = 0

    float x = 1;
    float y = 3;
    float z = (x/y);
    float q = (1/3);

    Can someone explain why? I realize that if I write

    float q = (1.0/3.0);

    that this problem doesn’t occur, but I’m just wondering why I can’t use (1/3) since q is defined as a float. This page says it’s just a convention to have the decimal point.

    • lharriger

      Think it through as follows:

      float x = 1 reads “put INT 1 into FLOAT x.” This changes its type from int to float. The same is true for float y = 3.
      Thus float z = x/y divides two floats and returns a float.

      However for float q = (1/3), this is a two part statement.
      The first part (1/3) reads “divide INT 1 by INT 3″. Since this is division of two integers, this means it must return an integer (the floor), which in this case is 0.
      The second part is then q = 0, which reads “put INT 0 into float q.”

      An important thing to keep in mind is that division on a float is different than division on an integer. The literal 1 is read as an integer, however, the literal 1.0 is read as a float/double. This is why q = (1.0/3.0) is different than q = (1/3).

      Hope this helped.

  • Sergey

    This is a very good article on the floating-point computation issue: “Microsoft Visual C++ Floating-Point Optimization”, by Eric Fleegal, MSDN, 2004
    http://msdn.microsoft.com/en-us/library/aa289157(v=vs.71).aspx

  • mohibouki

    Hi people,
    I am new to C++ so please don’t flame me :)

    I wrote a simple prog. to test this course but something isn’t really working well and I can’t figure out why…


    #include<iostream>
    #include<string>
    #include <iomanip> // for setprecision()
    using namespace std;

    main()
    {
    cout<<setprecision(7); //7 decimals
    float v = 1;
    float j = 3;
    float cc;
    cc = v/j;

    //TEST with FLOAT NUMMERS
    float ff = 0.3333333; // 7 decimals as set in "setprecusion(7);"

    if(cc<ff) {
    cout<<"cc is smaller then ff"<<endl;
    }
    else if(cc>ff) {
    cout<<"cc is bigger then ff"<<endl;
    }
    else{
    cout<<"cc equals to ff"<<endl;
    }
    cout<<cc<<" = cc"<<endl;
    cout<<ff<<" = ff"<<endl;

    return 0;
    }

    The output gives me that cc is bigger than ff…
    I don’t understand why as I set precision to 7 and my var ff has also 7 decimals.
    They should both be equal.

    Any suggestions where I made an error?
    Thanks!!

    • sajibfinix

      I Have Tasted Your Code.
      No, You didn’t make any wrong.
      I think setprecision() function is only for setting the precision at time of showing your variable when you use cout.
      I mean setprecision() cant change your variable.Like in your code cc = v/j so cc is stored as 0.33333333333333333333333333………. & setprecision() cant change this.You stored ff as 0.3333333.
      0.3333333333333333…….. is greater than 0.3333333 isnt it?So your code show cc is bigger than ff.

      Read the “Comparison of floating point numbers” part of this tutorial.It dosent say that you can use setprecision() for Comparison of floating point numbers.
      Thank You

  • sajibfinix

    How to control the numbers after decimal point in C++?

    Like in C language if i take a floating variable f = 123.4567 and i want to show only 2 numbers after decimal point than i will use printf(“%0.2f”).Then it will show 123.45.

    In C++ i have to use setprecision().But It determines total numbers not just numbers after decimal point.So, it makes problem.Like if i dont know that what numbers my floating variable will contain after calculation it can contain 123.123 or 1234.123 so if i set precision to 5 for first case it will show 123.12 and for second case it will show 1234.1!But i always want to show 2 numbers after decimal points for every case.How can i do that in c++?

    • duyquyen1710

      i have same question like you

    • rameye

      Use the std::fixed stream manipulator and the member function std::precision.

      For example if you want to display with 2 decimal places:


      double pi=3.14159;
      std::cout.precision(2);
      std::cout << "Today's price for a slice of pi is $" << std::fixed << pi << std::endl;

      and it should print:

      Today's price for a slice of pi is $3.14

  • rameye

    Alex, the first example demonstrating setprecision() is missing the closing curly bracket for main()

  • noobcaxe

    I'm perplexed! I'm working through Bjarne S's book and have done one of the drills but I don't understand what's going on with varying results.

    Here's some output;

    9.99
    10
    smaller is a 9.99  the larger is b 10
    result 0.01
    they are almost equal

    99.99
    100
    smaller is a 99.99  the larger is b 100
    result 0.01

    199.99
    200
    smaller is a 199.99  the larger is b 200
    result 0.01
    they are almost equal

    Why doesn't entering 99.99 and 100 give the message "they are almost equal"?

    • Alex

      This is an interesting example of rounding errors.

      10 -- 9.99 = 0.01, but due to rounding error, C++ is representing this as 0.0099999999999997868
      100 -- 99.99 = 0.01, but due to rounding error, C++ is representing this as 0.0100000000000005116

      One of this is larger than 0.01, and one is smaller.

      • Noobcaxe

        Argggh! I almost went insane yesterday evening try to see where I'd gone wrong.
        How does one avoid rounding errors? I can think of any number of applications where rounding errors even at the level of precision in my example might be disastrous.

        • Alex

          There are a couple of ways to “avoid” rounding errors:
          1) Avoid use of floating point numbers altogether (sometimes this is possible, sometimes it isn’t).
          2) Don’t do raw comparisons like you’re doing. In section 3.5 -- Relational operators (comparisons), we discuss how to tell if floating point numbers are equal. These can be extended to handle less then/greater than cases. This would help avoid the case you see above.
          3) Ensure that when you use floating point numbers, you only treat them as accurate to a certain level of precision.

  • PixelHero

    Answer "a" should be 3.45e1, because we need to trim off any trailing zeros if it is a positive exponent. Am I right?

  • Kevin

    whats the difference between:

    cout<<precision(17)

    &

    cout.setprecision(17)

    • Alex

      With Visual Studio, cout << setprecision() calls cout.precision() internally. So they essentially do the same thing. Calling cout.precision() is probably slightly more efficient, but unless you’re calling it hundreds of times, it won’t really matter.

  • RAGHIB AHMAD

    SIR PLZ TEL ME HOW TO PRINT ON OUTPUT SCREEN 14 ND 0.5 IF THE GIVEN VALUE IS 14.5 BASICALLY I WANT TO PRINT IT SEPARATELY ON OT PUT SCREEN BY FLOAT ND INT DATA TYPE

    • Alex

      Casting your float to an int via static_cast will drop the remainder, allowing you to print the integer. You can then subtract the integer from the floating point value to get just the remainder.

  • Tim

    Hello, I’m not sure if you’ll read this but I’m confused about some of the outputs:
    9.87654e+006
    9.87654e-005

    Why is 006 and 005 after the e?
    How does that make sense?
    I don’t get what 9.87654e+006 means… I thought you could only have numbers like 6 or -3 and stuff after the e not numbers like 006.
    I’m confused now… Shouldn’t it just be 9.87654321e6 ? Why is it 006 ?

    PS: I noticed your site is built on WordPress and I think it would be really helpful if you got a plugin that would email commenters when someone replies, would save me a lot of time, lol.

    Anyway, thanks a lot, I’m finding this site really helpful :)

  • Metereo_Rex

    So… Just to clarify, the varying results seen in the above examples are caused by varying error(s) in rounding?

    Eg, each time you round to the hundreds/hundredths place, it will be different from rounding to the tens/tenths place. And with that, the higher you the place you round to, the more accurate the answer will be (As with standard math). Is this correct?

    Also, I’m getting slightly different results than what’s presented above. For instance, what’s 3.333333333333334 to you is 3.333333333333333 on my machine, despite rounding to the same place. Just thinking about that makes me uncomfortable!

    Edit: it’s also worth noting that despite the fact that the comment box says we can use certain HTML tags, it automatically encodes the brackets.

    • Alex

      I’m not sure which examples you’re referring to. But generally speaking, the fact that floating point numbers have limited precision leads to rounding errors, especially in cases where a number is represented as an infinite sequence in binary (like 0.1).

      re: The HTML tags issue, I used to allow HTML on the site, but I’ve installed a plugin to treat all text literally so that people who post code snippets won’t have lines such as “#include ” treated as invalid HTML. I’ll see if I can remove/disable the misleading text.

Leave a Comment

  

  

  

five × two =

Put C++ code inside [code][/code] brackets to use the syntax highlighter