Floating Point: float, double, and Why 0.1 Is Not 0.1

Maria's shop till adds three prices and prints a total that is one paisa short. She checks it on paper four times. The paper is right and the machine is right, and they disagree.

Nobody made a mistake. A decimal number does not fit in a binary box, any more than one third fits in a decimal one. This lesson is about living with that.

A decimal number in a binary box

Write one third in decimal and you get 0.333333, for as long as you are willing to keep writing. Stop anywhere and you have written something that is not one third.

A computer has the same problem, in base two. Its digits are halves, quarters, eighths and sixteenths, and no sum of those ever lands exactly on one tenth.

So when you write 0.1 in C, the machine stores the nearest value it can build. That value is close, and it is not 0.1.

#include <stdio.h>

int main(void)
{
    double a = 0.1;
    double b = 0.2;

    printf("0.1 is stored as : %.20f\n", a);
    printf("0.2 is stored as : %.20f\n", b);
    printf("0.3 is stored as : %.20f\n", 0.3);
    return 0;
}

0.1 is stored as : 0.10000000000000000555
0.2 is stored as : 0.20000000000000001110
0.3 is stored as : 0.29999999999999998890

%.20f asks for twenty places after the point, which is how you see what is really there. Every other program you have written printed six places and hid all of this.

So a decimal literal in your source is a request, and what you get is the nearest value the machine can build.

float and double: how many digits each one keeps

C gives you two sizes of decimal box that you will actually use.

"Digits it keeps correctly" is the number that matters, and you can watch it run out.

#include <stdio.h>

int main(void)
{
    float  as_float  = 3.141592653589793f;
    double as_double = 3.141592653589793;

    printf("float : %.15f\n", as_float);
    printf("double: %.15f\n", as_double);
    return 0;
}

float : 3.141592741012573
double: 3.141592653589793

Compare the two lines digit by digit. They agree for seven digits, and after that the float is inventing.

Use double by default. It is not slower on any processor you will use, and 4 saved bytes are never worth eight lost digits.

Notice the f on the end of the first literal. Without it the number is a double that then gets squeezed into a float, which is the same answer by a longer road.

The 0.1 plus 0.2 problem, printed to twenty places

This is the program every C learner should run exactly once, and then remember for ever.

#include <stdio.h>

int main(void)
{
    double a = 0.1;
    double b = 0.2;
    double sum = a + b;

    printf("0.1 + 0.2 = %.20f\n", sum);
    printf("0.3       = %.20f\n", 0.3);
    printf("are they the same? %d\n", sum == 0.3);
    return 0;
}

0.1 + 0.2 = 0.30000000000000004441
0.3       = 0.29999999999999998890
are they the same? 0

Two values that are near 0.3 were added, and the answer landed on a different fence post from the one that 0.3 itself lands on.

The last line shows something else worth having early. A comparison in C is an expression, and its value is 1 or 0. You can print it, exactly as we just did.

So == on two decimal numbers asks whether two fence posts are the same post. That is almost never the question you meant to ask.

Comparing with a tolerance

The question you meant was "are these close enough to be the same". So ask that.

fabs, from <math.h>, gives the size of a difference without its sign. Compare that size against a small number, often called epsilon.

#include <stdio.h>
#include <math.h>

int main(void)
{
    double sum = 0.1 + 0.2;
    double epsilon = 1e-9;

    printf("the difference  : %.20f\n", fabs(sum - 0.3));
    printf("close enough?   : %d\n", fabs(sum - 0.3) < epsilon);
    return 0;
}

the difference  : 0.00000000000000005551
close enough?   : 1

1e-9 is scientific notation for 0.000000001. It is a reasonable epsilon for ordinary numbers and a bad one for very large or very small ones.

Some systems need -lm on the command line to link the maths library. The Playground already passes it, so fabs works there with nothing added.

So the rule is: never == between two decimal numbers, always a difference against a tolerance you chose on purpose.

Integer division, and the trap in an average

Divide two whole numbers in C and you get a whole number. The fraction is not rounded; it is thrown away.

#include <stdio.h>

int main(void)
{
    int a = 7;
    int b = 2;

    printf("int / int         : %d\n", a / b);
    printf("stored in a double: %f\n", (double)(a / b));
    printf("done as decimals  : %f\n", a / (double)b);
    return 0;
}

int / int         : 3
stored in a double: 3.000000
done as decimals  : 3.500000

The middle line is the one that catches people. The variable is a double, and the value it holds was already ruined before it got there.

The fix goes on the division, not on the result. Make one side a decimal type and the whole division is done in decimals.

So (a + b + c) / 3 is a whole number, and (a + b + c) / 3.0 is not. One character.

Printing: %f, %.2f, %e and %g

A double has one value and many ways to show it.

double v = 1234.5678;

printf("%f",   v)      1234.567800     six places, always
printf("%.2f", v)      1234.57         two places, rounded
printf("%e",   v)      1.234568e+03    scientific notation
printf("%g",   v)      1234.57         short form, picks for you

Printing rounds the value that is stored, not the text you typed. That is why %.2f of 1.005 is 1.00, as the next example shows.

When not to use a decimal type at all

Money and counts are not decimal numbers. They are whole numbers of the smallest unit, and they should be stored that way.

A bank stores paisa, not taka. A shop stores paisa. An invoicing system stores cents. Every addition is then exact, and the decimal point is put back only when the number is printed.

So the rule that follows every professional programmer around: floating point is for measuring, integers are for counting. Money is counting.

#include <stdio.h>

int main(void)
{
    double third = 1.0 / 3.0;

    printf("six places   : %f\n", third);
    printf("twenty places: %.20f\n", third);
    return 0;
}

six places   : 0.333333
twenty places: 0.33333333333333331483

#include <stdio.h>
#include <math.h>

int main(void)
{
    double sum = 0.1 + 0.2;
    double target = 0.3;
    double epsilon = 1e-9;

    printf("with ==        : %d\n", sum == target);
    printf("with tolerance : %d\n", fabs(sum - target) < epsilon);
    printf("the difference : %.20f\n", fabs(sum - target));
    return 0;
}

with ==        : 0
with tolerance : 1
the difference : 0.00000000000000005551

#include <stdio.h>

int main(void)
{
    double taka = 2.675;
    long long paisa = 268;          /* the same price, rounded to paisa first */

    printf("as a double, 2 places : %.2f\n", taka);
    printf("as a double, 20 places: %.20f\n", taka);
    printf("as whole paisa        : %lld.%02lld\n", paisa / 100, paisa - (paisa / 100) * 100);
    return 0;
}

as a double, 2 places : 2.67
as a double, 20 places: 2.67499999999999982236
as whole paisa        : 2.68

double price = 3.5;
printf("%d\n", price);

double d = 0.0;
scanf("%f", &d);
printf("%f\n", d);

int total = 7;
int count = 2;
double average = total / count;
printf("%f\n", average);

double sum = 0.1 + 0.2;
printf("%d\n", sum == 0.3);

#include <stdio.h>

int main(void)
{
    float serial = 16777217.0f;

    printf("%f\n", serial);
    return 0;
}

#include <stdio.h>

int main(void)
{
    double r = 0.0;
    scanf("%lf", &r);

    /* One printf, with %.2f. */

    return 0;
}

#include <stdio.h>

int main(void)
{
    int a = 0;
    int b = 0;
    int c = 0;
    scanf("%d %d %d", &a, &b, &c);

    /* Change one character of (a + b + c) / 3 and it works. */
    printf("%.2f\n", 0.0);
    return 0;
}

#include <stdio.h>

int main(void)
{
    double c = 0.0;
    scanf("%lf", &c);

    /* Write 9.0 and 5.0, not 9 and 5, and say why to yourself. */
    printf("%.1f\n", 0.0);
    return 0;
}

#include <stdio.h>
#include <math.h>

int main(void)
{
    double a = 0.0;
    double b = 0.0;
    double c = 0.0;
    scanf("%lf %lf %lf", &a, &b, &c);

    /* One printf with %d. A comparison is already a 1 or a 0. */

    return 0;
}

Next are the two types that pretend not to be numbers, and the reason a comparison can be added to another comparison.