Floating-point numbers

Why 0.1 + 0.2 doesn't quite equal 0.3 on a computer

Computers store most non-whole numbers as floating-point numbers: a fixed number of binary digits plus a power of two that says where the binary point sits. It works like scientific notation (3.1 × 10⁵), but in base 2.

A float has three parts: a sign bit for plus or minus, exponent bits that pick the power of two, and fraction bits (the mantissa) that hold the digits. A 32-bit float uses 1, 8 and 23 bits for these.

In binary, 0.1 is 0.000110011… with the pattern repeating forever, much as 1/3 repeats in decimal. The computer has to cut it off and round, so 0.1 is stored as a value very slightly off.

Floating-point numbers

Type 0.1 + 0.2 into a browser console and get 0.30000000000000004

JavaScript stores every number as a 64-bit float. Both 0.1 and 0.2 are stored slightly off, and the rounded sum lands on the float just above 0.3, so the console prints 0.30000000000000004. You can try it in any browser's developer tools.

This is why money software often counts in whole cents, and why programmers compare floats with a small tolerance instead of ==. Big numbers are hit too: a 32-bit float stores 16,777,217 as 16,777,216, because only 24 significant bits fit.

Floating-point numbers

The point floats, so one format covers atoms and galaxies

A float keeps the same number of significant digits at every scale, so its error is relative to the number's size. A 32-bit float spans about 10⁻³⁸ to 10³⁸, always to roughly 7 decimal digits.

The cost is that the gaps between floats grow with size. The FP8 format used in AI chips (E4M3) has 4 exponent and 3 fraction bits. Numbers between 1 and 2 are 0.125 apart, and between 2 and 4 they are 0.25 apart.

AI models can live with that roughness, and each FP8 number takes a quarter of the memory of a 32-bit float. So four times as many numbers fit in fast memory and move through the chip.