Floating-Point Numbers (IEEE 754)

Integers cannot hold 0.375 or 6.02 × 10²³. Fixed-point numbers put the binary point at a fixed position (for example 8 integer bits and 8 fraction bits), which is simple but has a small range. Floating-point numbers store a significand and an exponent, like scientific notation, trading exact spacing for a huge range.

The IEEE 754 formats

A floating-point number is (−1)^S × 1.M × 2^{E − bias}:

• The exponent is stored biased (E = true exponent + bias), so it is always non-negative and floats compare like integers. For a k-bit exponent the bias is 2^k−1 − 1.
• A normalised significand always starts with 1, so that 1 is not stored (the hidden bit), giving one free bit of precision.

Converting a decimal number to IEEE single

Example: 5.75.

1. Binary: 5.75 = 101.11₂.
2. Normalise: 101.11 = 1.0111 × 2².
3. Sign 0; exponent 2 + 127 = 129 = 1000 0001; mantissa 0111 followed by 19 zeros.
4. Bits: 0 10000001 01110000000000000000000 = 0x40B80000.

Example: −0.15625 = −0.00101₂ = −1.01 × 2⁻³. Sign 1, exponent −3 + 127 = 124 = 0111 1100, mantissa 01000…: 0xBE200000.

Going back: 0xC1480000 = 1 10000010 1001000…: sign −, exponent 130 − 127 = 3, significand 1.1001₂ = 1.5625, value −1.5625 × 8 = −12.5.

Python's struct module shows the real bit patterns:

import struct

def float_bits(x):
    raw = struct.unpack(">I", struct.pack(">f", x))[0]
    b = format(raw, "032b")
    return f"{b[0]} {b[1:9]} {b[9:]}", hex(raw)

def decode(hex_string):
    raw = int(hex_string, 16)
    s, e, m = raw >> 31, (raw >> 23) & 0xFF, raw & 0x7FFFFF
    value = (-1) ** s * (1 + m / 2 ** 23) * 2.0 ** (e - 127)
    return s, e, value

for x in [5.75, -0.15625, 0.1]:
    bits, h = float_bits(x)
    print(f"{x:9}: {bits}  {h}")
print("0xC1480000 -> sign, exponent, value:", decode("C1480000"))
print("0.1 as stored:", f"{struct.unpack('>f', struct.pack('>f', 0.1))[0]:.12f}")

     5.75: 0 10000001 01110000000000000000000  0x40b80000
 -0.15625: 1 01111100 01000000000000000000000  0xbe200000
      0.1: 0 01111011 10011001100110011001101  0x3dcccccd
0xC1480000 -> sign, exponent, value: (1, 130, -12.5)
0.1 as stored: 0.100000001490

0.1 has an infinite binary expansion, so the stored value is only the nearest representable float: 0.100000001490116…. This is why 0.1 + 0.2 == 0.3 is false in most programming languages.

Special values

The exponent fields of all 0s and all 1s are reserved:

Denormalised numbers fill the gap between 0 and the smallest normalised number, giving gradual underflow.

Precision and rounding

Floats are not evenly spaced: between consecutive powers of 2 there are always 2²³ single-precision values, so the gap between neighbours doubles with every power of 2. Above 2²⁴ = 16,777,216, a float can no longer represent every integer. Results are rounded (by default to the nearest value, ties to even), so floating-point addition is not associative: (a + b) + c may differ from a + (b + c).

Practice questions

import struct
print(hex(struct.unpack(">I", struct.pack(">f", -2.5))[0]).upper().replace("0X", "0x"))