Floating Point Arithmetic and IEEE 754

⚡ Key Takeaways

Floating point arithmetic represents real numbers in a finite computer word using a sign, a scaled significand, and an exponent — trading exact representation for enormous dynamic range. The IEEE 754 standard (1985, revised 2008/2019) fixes the bit layouts, rounding rules, and special values (±0, ±∞, NaN) used by essentially every modern processor. It applies everywhere numbers are computed: graphics, simulation, finance, machine learning, embedded control. Key fact: most decimal fractions (even 0.1) are not exactly representable in binary floating point.

💡 The Core Insight

Floating point keeps a constant number of significant digits, not a constant absolute precision. Because the exponent slides the binary point, the spacing between representable numbers grows with magnitude — the gaps double each time you cross a power of two. The fundamental guarantee is therefore not "small absolute error" but "small relative error": every real number in range is approximated to within a fixed fraction $u$ (the unit roundoff). All of numerical analysis flows from this single bound.

DefinitionNormalized Floating Point Number

A floating point number system $F(\beta, p, e_{\min}, e_{\max})$ consists of numbers of the form

1

\quad x = (-1)^s \times \left( d_0 . d_1 d_2 \cdots d_{p-1} \right)_\beta \times \beta^{e}

where:

$s \in \{0,1\}$ is the sign bit,
$\beta$ is the radix (base), $\beta = 2$ in IEEE 754,
$p$ is the precision (number of significand digits $d_i$ , with $0 \le d_i < \beta$ ),
$e$ is the exponent, $e_{\min} \le e \le e_{\max}$ ,
the value is normalized when $d_0 \ne 0$ (for $\beta=2$ , this forces $d_0 = 1$ ).

Derivation hint: the significand $1.d_1\cdots d_{p-1}$ lies in $[1,2)$ ; multiplying by $2^e$ rescales it to any binade.

DefinitionIEEE 754 Bit Encoding

A binary IEEE 754 value packs three fields into a word: sign $S$ (1 bit), biased exponent $E$ (width $w$ bits), and trailing significand $T$ (width $t = p-1$ bits). The stored exponent is biased: $E = e + \text{bias}$ , with $\text{bias} = 2^{w-1}-1$ . The decoded value for a normal number is

2

\quad x = (-1)^S \times \left(1 + T \cdot 2^{-t}\right) \times 2^{\,E - \text{bias}}

The leading 1 is the hidden bit — not stored, recovered for free in binary. Derivation hint: $T$ is the integer formed by the fraction bits; dividing by $2^t$ places the binary point just after the implicit leading 1.

Format	total bits	$w$ (exp)	$t$ (frac)	$p$	bias	$u = 2^{-p}$
binary16 (half)	16	5	10	11	15	$2^{-11}$
binary32 (single)	32	8	23	24	127	$2^{-24}$
binary64 (double)	64	11	52	53	1023	$2^{-53}$
binary128 (quad)	128	15	112	113	16383	$2^{-113}$

DefinitionSpecial Encodings

The extreme exponent fields are reserved:

$E = 0$ , $T = 0$ → signed zero $\pm 0$ .
$E = 0$ , $T \ne 0$ → subnormal (denormal): value $(-1)^S (0 + T 2^{-t}) 2^{1-\text{bias}}$ , with implicit leading 0, filling the gap around zero (gradual underflow).
$E = 2^w - 1$ , $T = 0$ → infinity $\pm\infty$ .
$E = 2^w - 1$ , $T \ne 0$ → NaN (Not a Number); quiet vs. signaling distinguished by the top fraction bit.

TheoremRounding Error Bound

Let $\mathrm{fl}(x)$ denote the correctly rounded value of a real $x$ in the normal range of $F$ . Then there exists $\delta$ with

3

\quad \mathrm{fl}(x) = x(1 + \delta), \qquad |\delta| \le u = \tfrac{1}{2}\beta^{1-p} = 2^{-p}

where $u$ is the unit roundoff. Moreover, for any IEEE 754 basic operation $\mathrm{op} \in \{+,-,\times,\div,\sqrt{\ }\}$ ,

4

\quad \mathrm{fl}(a \mathbin{\mathrm{op}} b) = (a \mathbin{\mathrm{op}} b)(1+\delta), \qquad |\delta| \le u

Derivation hint: round-to-nearest selects the closest grid point; the worst case is the midpoint, half a unit in the last place (ulp) away — divide that gap by the magnitude $\ge \beta^{e}$ .

ProofOf the relative error bound (3)

Step 1. Fix $x \ne 0$ in the normal range. Write $|x| = m \cdot \beta^{e}$ with $m \in [1, \beta)$ . The representable numbers in this binade are spaced exactly $\beta^{e-(p-1)}$ apart; this spacing is one ulp.

Step 2. Round-to-nearest maps $x$ to the closest grid point, so the absolute error satisfies

|\mathrm{fl}(x) - x| \le \tfrac{1}{2}\,\text{ulp} = \tfrac{1}{2}\beta^{e-(p-1)} = \tfrac{1}{2}\beta^{e}\beta^{1-p}.

Step 3. Since the significand $m \ge 1$ , we have $|x| = m\beta^e \ge \beta^{e}$ . Divide:

\frac{|\mathrm{fl}(x) - x|}{|x|} \le \frac{\tfrac{1}{2}\beta^{e}\beta^{1-p}}{\beta^{e}} = \tfrac{1}{2}\beta^{1-p} = u.

Step 4. Define $\delta = (\mathrm{fl}(x)-x)/x$ ; then $|\delta| \le u$ and $\mathrm{fl}(x) = x(1+\delta)$ . For $\beta = 2$ , $u = 2^{-p}$ .

Step 5. Equation (4) follows from the IEEE 754 mandate that each basic operation behave as if computed to infinite precision and then rounded once. Applying (3) to the exact result $a\mathbin{\mathrm{op}}b$ gives the bound. $\blacksquare$

∎

Figure

The uneven grid of floating point: spacing doubles at each power of two

WK

William Kahan

b. 1933

Often called "the Father of Floating Point," Kahan led the design of the Intel 8087 math coprocessor arithmetic that became the template for IEEE 754. A Berkeley numerical analyst, he championed correct rounding, gradual underflow (subnormals), and the principled handling of exceptions — features that vendors initially resisted as too costly. His compensated summation algorithm and tireless advocacy for reproducible arithmetic earned him the 1989 Turing Award. Kahan's enduring lesson: the hard part of floating point is not the average case but the adversarial corner cases that silently corrupt results.

🧠 Intuition

Think of floating point as scientific notation with a fixed budget of significant figures. You always carry, say, 16 decimal digits — whether the number is $6.022\times10^{23}$ or $1.602\times10^{-19}$ . The exponent is "free" range; the significand is where precision lives. So the number line is not a smooth continuum but a logarithmically-zoned ruler: fine ticks near zero, coarsening as you go out. Two consequences become obvious. First, adding a tiny number to a huge one can do nothing — the tiny one falls below the local tick spacing and rounds away. Second, subtracting two nearly-equal numbers wipes out leading digits, leaving noise (catastrophic cancellation). The constant-relative-error picture is the master key: it tells you errors compound multiplicatively, and that you should fear differences, not sums.

ExampleEncoding 0.1 in binary64 — why it's inexact

Given: Decimal $0.1$ . Find its binary64 representation and the rounding error.

Step 1. In binary, $0.1 = 0.0001100110011\ldots_2$ , a repeating fraction (period "0011"). It is not a finite binary fraction, so it cannot be exact.

Step 2. Normalize: $0.1 = 1.100110011\ldots_2 \times 2^{-4}$ , so $e = -4$ , biased $E = -4 + 1023 = 1019 = \texttt{01111111011}_2$ .

Step 3. The 52-bit fraction is the repeating pattern truncated and rounded-to-nearest:

T \cdot 2^{-52} = 0.1001100110011\ldots(\text{rounded}).

The stored value is the nearest double:

\mathrm{fl}(0.1) = 0.1000000000000000055511151231257827021181583404541015625.

Step 4. The error is

\mathrm{fl}(0.1) - 0.1 \approx +5.55\times10^{-18}, \qquad \frac{|\delta|}{0.1}\approx 5.6\times10^{-17} < u = 2^{-53}\approx1.1\times10^{-16}.

\boxed{\mathrm{fl}(0.1) \approx 0.1 + 5.55\times10^{-18},\quad |\delta| \le 2^{-53}}

This is exactly why `0.1 + 0.2 != 0.3` in most languages.

ExampleCatastrophic cancellation in a quadratic root

Given: Solve $x^2 - 200000x + 1 = 0$ in binary64 using the textbook formula. Here $a=1$ , $b=-200000$ , $c=1$ .

Step 1. Discriminant: $\Delta = b^2 - 4ac = 4\times10^{10} - 4 = 39999999996$ . Then $\sqrt\Delta \approx 199999.99999000$ .

Step 2. The "stable" root: $x_1 = \dfrac{-b+\sqrt\Delta}{2} = \dfrac{200000 + 199999.99999}{2} \approx 199999.999995$ . Fine.

Step 3. The "naive" small root:

x_2 = \frac{-b - \sqrt\Delta}{2} = \frac{200000 - 199999.99999000}{2}.

Here two ~ $2\times10^5$ numbers nearly cancel: about 11 leading digits agree and vanish, leaving only a few accurate digits.

Step 4. Stable alternative via $x_1 x_2 = c/a = 1$ :

x_2 = \frac{c}{a\,x_1} = \frac{1}{199999.999995} = 5.0000000125\times10^{-6}.

\boxed{x_2 \approx 5.0000000125\times10^{-6}\ \text{(via } c/(a x_1)\text{), accurate to full precision}}

The subtraction form loses ~11 significant digits; the product form keeps all of them.

⚠️ Common mistake

Floating point is not "approximate real arithmetic with random noise." It is deterministic and fully specified: every IEEE 754 operation produces a unique, correctly rounded result, identical across conforming hardware. The "errors" are not noise — they are exact, reproducible consequences of rounding. Two further traps:

Associativity fails: $(a+b)+c \ne a+(b+c)$ in general, so compilers may not freely reorder sums, and parallel reductions can give different (still valid) answers.
Equality testing is dangerous: never write `if (x == 0.1)` after computing `x`; compare with a tolerance instead.

CounterexampleAddition is not associative

In binary64, let $a = 10^{16}$ , $b = 1$ , $c = -10^{16}$ . Compute left-to-right: $(a + b) + c$ . Since $1 < \text{ulp}(10^{16}) = 2$ , the sum $a+b$ rounds back to $10^{16}$ ; then $+c$ gives $\boxed{0}$ . Compute right-grouped: $a + (b + c) = 10^{16} + (1 - 10^{16}) = 10^{16} + (-9999999999999999) = \boxed{1}$ . Same three numbers, two different answers — associativity, an axiom of real arithmetic, simply does not hold.

connection

Floating point sits at the crossroads of pure and applied mathematics. The error bound (3) is the entry point to Numerical Stability and Conditioning, where the condition number measures sensitivity of a problem and backward error measures the quality of an algorithm. The base- $\beta$ positional encoding generalizes Positional Number Systems and connects to Binary Representation of Integers for the exponent and significand fields. Rounding analysis underpins Numerical Linear Algebra (e.g., the stability of Gaussian elimination) and Numerical Solution of ODEs. The logarithmic spacing of the grid is essentially a discretized Logarithm, which is why relative error, not absolute error, is the natural metric.

🔬 Where this appears

⏳ History

- 1914 — Leonardo Torres y Quevedo describes floating point in an electromechanical computing essay.

- 1941 — Konrad Zuse's Z3 uses a binary floating point format with exponent and significand — arguably the first working implementation.

- 1950s–1970s — Every vendor (IBM 360 hex floats, CDC, Cray, DEC) invents its own format; precision, rounding, and range all differ, making portable numerics nearly impossible.

- 1976 — Intel begins the 8087 coprocessor project; Kahan and students are hired to design its arithmetic.

- 1977–1985 — A fierce standards committee (the "KCS" draft by Kahan, Coonen, Stone) debates gradual underflow, NaNs, and directed rounding.

- 1985 — IEEE 754-1985 is ratified: formats, rounding modes, exceptions, and special values become law.

- 1987 — IEEE 854 generalizes to any radix (covering decimal).

- 2008 — IEEE 754-2008 merges 754/854, adds `binary16`, decimal formats, and the fused multiply-add (FMA).

- 2019 — IEEE 754-2019 refines recommended functions, augmented operations, and minimum/maximum semantics.

open-problem

Several deep difficulties remain practical headaches rather than solved theory:

The Table-Maker's Dilemma: correctly rounding transcendental functions ( $\sin$ , $\exp$ , $\log$ ) requires knowing how many extra digits suffice to decide the rounding direction — and no general bound is known. Implementations use heuristics (Ziv's strategy), so correctly rounded libm functions are still not universal.
Reproducibility vs. performance: FMA, vectorization, and parallel reductions all change rounding; bit-reproducible parallel summation is an active research and engineering area.
Low-precision proliferation: `float8`, `bfloat16`, and posit/unum alternatives challenge IEEE 754's dominance; whether a successor standard should replace fixed-exponent floats with tapered precision is genuinely open.
Verified numerics: automatically proving tight error bounds for whole programs (not single operations) — interval and affine arithmetic help but remain conservative.

Floating Point Arithmetic and IEEE 754

Formal Statement

Why It Holds / Derivation

Building Intuition

Worked Examples

Common Misconceptions

Connections

Real-World Applications

Historical Development

Subtleties & Limits

See Also