Last updated: 2026-06-28

IEEE 754 Floating Point

Almost every number a computer stores is a floating-point number. The processor does not keep a list of all real numbers — instead it stores a sign, a scaled integer exponent, and a fixed-width fractional part, then combines them to approximate the value you want. IEEE 754, published in 1985 and revised in 2008, is the standard that defines exactly how to do this, and every mainstream language and processor follows it.

The bit layout

An IEEE 754 single-precision (32-bit) number is divided into three fields packed into one 32-bit word:

A double-precision (64-bit) number widens the exponent to 11 bits and the mantissa to 52 bits, keeping the sign at 1 bit.

The value of a normal number is reconstructed as:

where $S$ is the sign bit, $M$ is the stored mantissa fraction interpreted in binary, and bias is 127 for single or 1023 for double. The leading 1 in $1.M$ is implicit — it is not stored, which gives an extra free bit of precision.

Why 0.1 is not exact

Most familiar decimals do not terminate in binary. The fraction 0.1 is one-tenth, but in binary it expands as a repeating sequence:

Because the mantissa field has a finite width (23 bits for single, 52 for double) this sequence is rounded to the nearest representable value. For double precision that stored value is approximately 0.10000000000000000555, which is close but not equal to exactly 0.1. When two such rounded values are added, the errors combine:

This is not a bug — it is the predictable consequence of binary representation. The Stored Value field in the converter shows the exact decimal equivalent of the bit pattern so you can see the rounding with any number you choose.

Special values

IEEE 754 reserves two exponent patterns for special cases:

Subnormal numbers sacrifice the implicit leading 1 to represent values smaller than the smallest normal number, at the cost of reduced precision. ±Infinity arises from overflow or division by zero. NaN is produced by undefined operations such as 0 ÷ 0 or √−1.

Single versus double precision

Single precision fits in 32 bits and gives about 7 significant decimal digits, with values ranging from roughly ±1.2 × 10⁻³⁸ to ±3.4 × 10³⁸. Double precision uses 64 bits, gives 15 to 17 significant digits, and covers ±2.2 × 10⁻³⁰⁸ to ±1.8 × 10³⁰⁸.

Most general-purpose languages default to double precision for their floating-point type. Single precision is common in graphics pipelines, neural-network weights, and embedded firmware where throughput and memory bandwidth outweigh the loss of precision.

Reading the hex output

The hexadecimal field shows every bit in the number as a compact code. Each hex digit represents four bits, so a single-precision value fits in eight hex digits and a double in sixteen. Engineers use hex to compare floating-point values at the bit level, identify special patterns like infinity or NaN, and debug serialisation that should preserve exact bit patterns across platforms.

For example, the constant π stored as a single-precision float is 0x40490FDB, and as a double it is 0x400921FB54442D18. You can see the exponent and mantissa directly in the hex and verify that the double carries far more mantissa digits. To explore binary and hexadecimal arithmetic more broadly, see the Number Base Converter.