Floating-Point Arithmetic

Floating-point addition and multiplication operate on IEEE encodings by aligning exponents, combining significands, normalizing, and rounding. Hardware implementations (add pipelines, fused multiply-add) belong more to Computer Organization; this note stays with the arithmetic rules.

GATE asks for the step sequence, the result of a small addition or multiplication in a given format (including the rounding and any renormalization), the biased-exponent arithmetic in a multiply, the special-case results involving zeros, infinities and NaNs, and examples of non-associativity, absorption and cancellation.

For two normals with exponents $e_1\ge e_2$ and significands $m_1,m_2$ (including hidden bits):

Two normalization cases arise. After exponent alignment, a same-sign significand sum lies in $[1,4)$; when the exponents are equal it lies in $[2,4)$, so at most one right shift (exponent $+1$). A subtraction can cancel many leading bits, needing several left shifts (exponent decreases by the shift count). Rounding can also carry out of the significand ($1.111\cdots1$ rounding up to $10.000\cdots0$) and force one more right shift.

Biased exponents. With stored fields $E_1$ and $E_2$, the product's field is $E_1 + E_2 - \textit{bias}$ before normalization: adding the fields counts the bias twice. The significand product of two values in $[1, 2)$ lies in $[1, 4)$, so normalization needs at most one right shift. Division subtracts the fields and adds the bias back: $E_1 - E_2 + \textit{bias}$.

Related material. Implementations keep extra bits during alignment so that rounding matches infinite-precision round-to-nearest even. The guard bit is the first bit below the kept LSB, the round bit the next, and the sticky bit is the OR of everything below that. Three bits suffice: the guard bit says whether the discarded part is at least half an ulp, and round and sticky together say whether it is exactly half or more.

IEEE 754 requires round-to-nearest-ties-to-even as default, plus directed modes (toward $+\infty$, toward $-\infty$, toward zero). This note assumes round-to-nearest unless stated. Under ties-to-even, a value exactly halfway between two neighbours goes to the one whose last kept bit is 0.

Every basic operation ($+, -, \times, \div, \sqrt{\ }$) is correctly rounded: the result equals the exact real result rounded once in the current mode. In round-to-nearest the error is at most half an ulp, a relative error of at most $2^{-24}$ for binary32 and $2^{-53}$ for binary64 only for a nonzero exact result in the normal range without underflow or overflow. For gradual underflow, use an absolute bound of half the minimum subnormal spacing: $2^{-150}$ for binary32 and $2^{-1075}$ for binary64. Relative-error ratios exclude exact zero and special results.

Signed zeros follow sign rules: $(+0) + (-0) = +0$ in round-to-nearest (it is $-0$ only when rounding toward $-\infty$), and $(-0) \times 5 = -0$. Where a question gives its own table, use it.

Add $1.00\times 10^{2}$ and $3.00\times 10^{0}$: align to $1.00\times 10^{2} + 0.03\times 10^{2} = 1.03\times 10^{2}$. Already normalized; no round needed.

Binary example: $1.0\cdot 2^{3} + 1.0\cdot 2^{1} = 1000_2 + 0010_2 = 1010_2 = 1.010\cdot 2^{3}$ after interpreting with a 4-bit significand toy format.

Keep 3 fraction bits. The exact significand $1.000\,1001$ has kept part $1.000$, guard 1, round 0, sticky 1 (from the final 1). Guard 1 with a nonzero round or sticky means more than half an ulp, so round up to $1.001$. A design that dropped the sticky bit would see guard 1, round 0 and treat it as an exact tie, then round to even and return $1.000$, which is wrong.

Subtracting nearly equal values cancels leading significand bits and can strip precision (catastrophic cancellation). The result is exact for the rounded inputs but may have few meaningful digits relative to the original problem.

For a finite $x$ with finite representable neighbours $x_-<x<x_+$, the exact sum rounds to $x$ when it lies strictly between $(x_-+x)/2$ and $(x+x_+)/2$; at a midpoint, apply ties-to-even. Neighbour spacing can differ across a binade boundary, so an undirected half-ulp rule is unsafe. In binary32 the ulp at $2^{24}$ is 2, so $2^{24} + 1 = 2^{24}$.

Values are decoded to (sign, exponent, significand); ulp refers to the target format. FP-MUL is a finite, nonzero, normal-input outline, not a complete IEEE implementation. Before entering it, handle NaNs (including signalling/invalid behaviour as required), $0\times\infty$ as invalid NaN, other infinity products as signed infinity, and finite zero products as signed zero, with the XOR sign. Subnormal inputs are outside this outline; an extension must decode them with effective exponent $1-\textit{bias}$ and normalize their $0.f$ significands, not use $E-\textit{bias}$ at $E=0$. Subnormal outputs below are rounded directly from the exact product, avoiding double rounding.

FP-ADD's alignment shift can be capped at $p + 3$ positions: anything further only affects the sticky bit. FP-MUL multiplies two $(p+1)$-bit significands, a $2p + 2$-bit product before rounding.

Cost model. Fix the target format (both fraction and exponent widths), and use a constant number of sufficiently wide fixed-size registers for its operands, product and guard/round/sticky information. Assume constant-time field tests, bounded-width arithmetic, multiplication, shifts and packing; ROUND-NEAREST-EVEN receives only the bounded intermediate values of these outlines, not an unrestricted exact real. Alignment/normalization work is bounded by the fixed format. FP-ADD, FP-MUL-NORMAL-INPUTS and ROUND-NEAREST-EVEN then take $\Theta(1)$ time and $O(1)$ auxiliary fixed-size registers in best, average and worst cases, excluding fixed-size inputs/output. No variable-precision bit bound or hardware gate-delay bound follows from this unit-cost classification.

Floating addition is not associative: $(a+b)+c$ may differ from $a+(b+c)$ after rounding. Multiplication distributes over addition only approximately. Error analysis uses ulps; a single correctly rounded basic operation errs by at most 0.5 ulp in round-to-nearest.

Model of one operation. For $\circ \in \{+, -, \times, \div\}$ without overflow or underflow, $\mathrm{fl}(a \circ b) = (a \circ b)(1 + \delta)$ with $|\delta| \le u$, where the unit roundoff $u$ is $2^{-24}$ (binary32) or $2^{-53}$ (binary64). Two operations in sequence can each contribute an error, and the errors depend on the order, which is why the order of a sum matters.

Exact cases. Multiplying by a power of two is exact (barring overflow or underflow), because only the exponent changes. The difference of two values within a factor of 2 of each other is exact (Sterbenz's lemma, Related material): cancellation exposes earlier errors but adds none itself.

Toy format with 1 hidden bit and 3 fraction bits: $x=1.000\cdot 2^{5} = 32$, $y=1.100\cdot 2^{2} = 6$. Shift $y$ right by 3: $0.0011\cdot 2^{5}$. The exact sum is $1.0011 \cdot 2^5 = 38$. Keeping 3 fraction bits, the discarded part is exactly half an ulp (guard 1, nothing below), a tie. The kept LSB of $1.001$ is 1 (odd), so round to even gives $1.010 \cdot 2^5 = 40$. The neighbours were 36 and 40, both at distance 2.

binary32: multiply $2.0$ (0x40000000) by $0.5$ (0x3F000000) yields $1.0$ (0x3F800000). Unbiased exponents $1 + (-1) = 0$; significands $1\cdot 1=1$. In fields: $128 + 126 - 127 = 127$.

A binary32 multiply that produces exponent above 127 packs to $\pm\infty$ with the XOR sign. For $2^{100} \times 2^{100}$: fields $227 + 227 - 127 = 327 > 254$, so the result is $+\infty$.

$\infty-\infty$ is NaN; $1/0$ is $\infty$; $0/0$ is NaN; $0 \times \infty$ is NaN; $\infty + 5 = \infty$.

$1.5 \times 1.5$ in binary32 (0x3FC00000 twice). Fields $127 + 127 - 127 = 127$; significands $1.1_2 \times 1.1_2 = 10.01_2$. Normalize: $1.001_2 \times 2^1$, field 128. Result $2.25$ = 0x40100000. By contrast $1.5 \times 2.5$: $1.1_2 \times 1.01_2 = 1.111_2$, no shift, field $127 + 128 - 127 = 128$, result $3.75$ = 0x40700000.

Toy format with 3 fraction bits: $x = 1.101 \times 2^4 = 26$, $y = 1.010 \times 2^2 = 5$. Align: $y = 0.01010 \times 2^4$. Sum $1.11110 \times 2^4 = 31$. Rounding to 3 fraction bits: kept $1.111$, discarded $10$, an exact tie with an odd LSB, so round up to $10.000 \times 2^4$. FP-ADD step 9 renormalizes the rounded significand: $s=10.000_2=2$ becomes $s=1.000_2$, and the exponent increments from 4 to 5. Pack $1.000\times2^5=32$; rounding without that exponent increment would be wrong.

Toy format: $1.000 \times 2^1 - 1.111 \times 2^0$. Align: $1.000 - 0.1111 = 0.0001$ at exponent 1. Normalize with 4 left shifts: $1.000 \times 2^{-3} = 0.125$. The result is exact ($2 - 1.875$), but three of its four significand bits are zeros created by the shift, not information.

Let $a = 10^8$, $b = -10^8$, $c = 1$ (all exact in binary32; the ulp at $10^8$ is 8). Then $(a + b) + c = 0 + 1 = 1$, but $a + (b + c) = 10^8 + (-10^8) = 0$, because $b + c = -99{,}999{,}999$ rounds back to $-10^8$. In binary64, $0.1 + 0.2 \ne 0.3$: the sum is $0.30000000000000004$.

Round the toy value $1.0011_2$ (exact $1.1875$) to 3 fraction bits. Nearest-even gives $1.010$ (1.25), toward zero and toward $-\infty$ give $1.001$ (1.125), toward $+\infty$ gives $1.010$. For $-1.0011_2$, toward $-\infty$ gives $-1.010$ and toward $+\infty$ gives $-1.001$.

Common misconceptions.