How floating point variables

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 4.0, 2.5, 3.33, or 0.1226. There are three different floating point data types:float, double, and long double. A float is usually 4 bytes and a double 8 bytes, but these are not strict requirements, so sizes may vary. Long doubles were added to the language after it’s release for architectures that support even larger floating point numbers. But typically, they are also 8 bytes, equivalent to a double. Floating point data types are always signed (can hold positive and negative values).

Here are some declarations of floating point numbers:

1

2

3

floatfValue;

doubledValue;

longdouble dValue2;

The floating part of the name floating point refers to the fact that a floating point number can have a variable number of decimal places. For example, 2.5 has 1 decimal place, whereas 0.1226 has 4 decimal places.

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

1

2

intnValue = 5; // 5 means integer

floatfValue = 5.0; // 5.0 means floating point

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. In scientific notation, a number has two parts: the significand, and a power of 10 called an exponent. The letter ‘e’ or ‘E’ is used to separate the two parts. Thus, a number such as 5e2 is equivalent to 5 * 10^2, or 500. The number 5e-2 is equivalent to 5 * 10^-2, or 0.05.

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

1

2

3

4

5

doubledValue1 = 500.0;

doubledValue2 = 5e2; // another way to assign 500

 

doubledValue3 = 0.05;

doubledValue4 = 5e-2; // another way to assign 0.05

Furthermore, if we output a number that is large enough, or has enough decimal places, it will be printed in scientific notation:

1

2

3

4

5

6

7

8

9

10

11

#include <iostream>

intmain()

{

    usingnamespace std;

 

    doubledValue = 1000000.0;

    cout << dValue << endl;

    dValue = 0.00001;

    cout << dValue << endl;

    return0;

}

Outputs:

1e+0061e-005

Precision

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, and we typically only have 4 or 8 bytes. Floating point numbers can only store a certain number of digits, and the rest are lost. The precision of a floating point number is how many 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:

1

2

3

4

5

6

7

8

9

10

11

12

#include <iostream>

intmain()

{

    usingnamespace std;

    floatfValue;

    fValue = 1.222222222222222f;

    cout << fValue << endl;

    fValue = 111.22222222222222f;

    cout << fValue << endl;

    fValue = 111111.222222222222f;

    cout << fValue << endl;

}

This program outputs:

1.22222111.222111111

Note that each of these is only 6 digits.

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

1

2

3

4

5

6

7

8

9

10

11

#include <iostream>

#include <iomanip> // for setprecision()

intmain()

{

    usingnamespace std;

 

    cout << setprecision(16); // show 16 digits

    floatfValue = 3.33333333333333333333333333333333333333f;

    cout << fValue << endl;

    doubledValue = 3.3333333333333333333333333333333333333;

    cout << dValue << endl;

Outputs:

3.3333332538604743.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. Variables of type double are named so because they offer approximately double the precision of a float.

Now let’s consider a really big number:

1

2

3

4

5

6

7

8

9

#include <iostream>

 

intmain()

{

    usingnamespace std;

    floatfValue = 123456789.0f;

    cout << fValue << endl;

    return0;

}

Output:

1.23457e+008

1.23457e+008 is 1.23457 * 10^8, which is 123457000. Note that we have lost precision here too!

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

Rounding errors

One of the reasons floating point numbers can be tricky is due to non-obvious differences between binary and decimal (base 10) numbers. In normal decimal numbers, the fraction 1/3rd is the infinite decimal sequence: 0.333333333… Similarly, 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…

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

1

2

3

4

5

6

7

8

#include <iomanip>

intmain()

{

    usingnamespace std;

    cout << setprecision(17);

    doubledValue = 0.1;

    cout << dValue << endl;

}

This outputs:

0.10000000000000001

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 play havoc with math-intense programs, as mathematical operations can compound the error. In the following program, we use 9 addition operations.

1

2

3

4

5

6

7

8

9

10

#include <iostream>

#include <iomanip>

intmain()

{

    usingnamespace std;

    cout << setprecision(17);

    doubledValue;

    dValue = 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1;

    cout << dValue << endl;

}

This program should output 1, but it actually outputs:

0.99999999999999989

Note that the error is no longer in the last column like in the previous example! It has propagated to the second to last column. As you continue to do mathematical operations, this error can propagate further, causing the actual number to drift farther and farther from the number the user would expect.

Comparison of floating point numbers

One of the things that programmers like to do with numbers and variables is see whether two numbers or variables are equal to each other. C++ provides an operator called the equality operator (==) precisely for this purpose. For example, we could write a code snippet like this:

1

2

3

4

5

intx = 5; // integers have no precision issues

if(x==5)

    cout << "x is 5" << endl;

else

    cout << "x is not 5" << endl;

This program would print “x is 5″.

However, when using floating point numbers, you can get some unexpected results if the two numbers being compared are very close. Consider:

1

2

3

4

5

6

7

8

floatfValue1 = 1.345f;

floatfValue2 = 1.123f;

floatfTotal = fValue1 + fValue2; // should be 2.468

 

if(fTotal == 2.468)

    cout << "fTotal is 2.468";

else

    cout << "fTotal is not 2.468";