Question bank — Floating point gotchas — catastrophic cancellation, associativity failure

True. The machine computes $\text{fl}(a+b)$ — round the exact sum — and $a+b=b+a$ before rounding, so both orders snap to the identical dot.

False. Each + applies $\text{fl}$ to its intermediate result at a spacing set by that partial sum's magnitude, so a different grouping rounds at a different place — e.g. $1+10^{16}-10^{16}$ gives $0$ one way and $1$ the other.

False. By Sterbenz's lemma the subtraction of near-equal values is computed exactly (no rounding at all); the large relative error was already baked into the two stored operands — subtraction merely reveals it.

False. It is the gap between $1.0$ and the next double (${\epsilon }_{\text{mach}}=2^{-52}$). The smallest positive subnormal double is vastly smaller ($\sim 5\times 10^{-324}$); these are entirely different quantities.

False. $u=\frac{1}{2}{\epsilon }_{\text{mach}}$. Machine epsilon is the full step between adjacent doubles near $1$; round-to-nearest can only miss by half a step, so the error bound uses $u$, not ${\epsilon }_{\text{mach}}$.

False. It uses round half to even: it picks the neighbour with a $0$ final mantissa bit, so ties don't systematically bias long computations upward.

False. Algebraic identity does not survive rounding: a mathematically exact formula (e.g. $\frac{1-\cos x}{x^2}$) can lose all accuracy through Catastrophic cancellation even though the symbols are perfect.

False. None of $0.1,0.2,0.3$ is exactly representable in binary; $\text{fl}(0.1)+\text{fl}(0.2)$ differs from $\text{fl}(0.3)$ by about $10^{-17}$, so == returns False.

False. Higher precision only delays catastrophe by a few digits; if the expression is ill-conditioned, the amplification factor $\frac{|a|+|b|}{|a-b|}$ still blows up. You must reformulate, not just widen the type.

False. The bound is relative: $|\text{fl}(x)-x|\le u|x|$ (with $u=\frac{1}{2}{\epsilon }_{\text{mach}}$), so the absolute error grows with the number's magnitude. That relativity is exactly why big-minus-big is dangerous.

False. Between the smallest normal and true zero lie the subnormals (gradual underflow): the leading mantissa bit becomes $0$, trading precision for reach so tiny results degrade smoothly instead of snapping to $0$. Only below the smallest subnormal do you truly underflow to $0$.

False. It reduces the total error to $\sim u$ (roughly independent of $n$) by carrying the lost low-order bits, but each individual add still applies $\text{fl}$ — it compensates, it does not eliminate.

False. It is usually the worst order: small terms get absorbed under the huge running sum. Adding smallest magnitudes first (or using Kahan compensated summation) is safer.

The variance computed as $\overline{x^2}-{\bar{x}}^2$ can round to a tiny negative or tiny positive number via cancellation, so == 0.0 both misses true zeros and mis-fires. Test variance <= tol with tol an absolute threshold scaled to the data, e.g. tol = 1e-12 * mean_x**2 (relative to the numbers' size, since variance has units of value²).

For big $x$ the two roots are nearly equal, so their difference suffers catastrophic cancellation. Rewrite as $\frac{1}{\sqrt{x+1}+\sqrt{x}}$ — here the two roots are added; since both are positive there is no near-total cancellation in the denominator, so relative error stays $\sim u$.

With $b<0$, $-b$ and $\sqrt{\dots }$ are both $\approx 200000$ and nearly equal, so the subtraction is catastrophic. Compute the same-sign root $x_{+}$ first, then get $x_{-}=c/(a{x}_{+})$ — see Quadratic formula numerical issues.

$f(x+h)-f(x)$ then subtracts near-equals, so cancellation dominates and accuracy collapses. There is an optimal $h\approx \sqrt{u}\approx 10^{-8}$ balancing truncation vs round-off error.

Naive summation lets each small price be absorbed by the large running total, so cents silently vanish (absorption). Sum small-to-large, or use Kahan; see Round-off error propagation.

$\text{fl}(1+x)$ rounds the tiny x away (absorption), so the log of it is $0$ instead of $\approx x$. Use math.log1p(x), which is built to avoid the addition to $1$.

Floating error rarely reaches exactly $0$; it wobbles near round-off level forever, so the loop may never stop. Use while error > tol:, choosing tol as atol + rtol*scale (an absolute floor plus a relative part) rather than a lone magic number.

The alternating terms grow enormous then cancel down to a tiny result — catastrophic cancellation across the sum. Compute $e^x$ (all-positive terms) and take its reciprocal — but only for moderate $x$: for large $x$, $e^x$ overflows to inf and $1/\text{inf}=0$ swallows the answer, so use math.exp(-x) (or range-reduction) directly instead.

Both operands carry an absolute error $\sim u|a|$; the true difference is tiny, so dividing those fixed absolute errors by a near-zero result makes the relative error, $\frac{|a|+|b|}{|a-b|}u$, explode. No new bits are lost — the small answer just can't hide the old error.

For $a+b$ with $a,b>0$ the result $\approx 2a$ is as big as the inputs, so the fixed absolute errors $\sim u|a|$ stay small relative to it — the amplifier $\frac{|a|+|b|}{|a+b|}\approx 1$. Subtraction shrinks the result toward $0$ while the errors stay put, so the same errors become huge relative to the answer.

In $x=a\cdot b$ the relative errors merely add (${\delta }_a+{\delta }_b\lesssim 2u$) and never divide by anything near zero, so the amplification factor stays $\sim 1$. Subtraction can divide by a near-zero difference, making the factor unbounded.

Near magnitude $10^{16}$ the spacing between representable doubles is about $2$, which is larger than $1$; the added $1$ falls below one gap, so $\text{fl}(1+10^{16})$ snaps back to $10^{16}$ — it is absorbed.

Small values accumulated together first grow into a magnitude comparable to the larger terms, so when they finally meet a big number they occupy representable bits instead of falling below its gap — fewer of them get absorbed.

(t - s) is the part of y that actually landed in the sum after rounding; subtracting the full y isolates the negated dropped part, which is then fed back next iteration so no bits are permanently lost.

Always-up would add a tiny upward bias every time a tie occurs, and over a long sum those biases accumulate into a systematic drift. Round-to-even splits ties evenly so they cancel on average, keeping the $|\delta |\le u$ bound unbiased.

The two are equal in exact arithmetic but have different conditioning: one may route the computation around a subtraction of near-equals while the other walks straight into it. Reformulating changes error behaviour, not the math — see Numerical stability and conditioning.

Floating point spaces numbers logarithmically — the gap scales with magnitude — so a bound that scales with $|x|$ (relative) is the honest, magnitude-independent description of accuracy.

Tolerance abs(x-y) <= atol + rtol*max(|x|,|y|) respects the relative nature of float error and adapts to magnitude, whereas fixed-digit rounding either over-rejects large numbers or over-accepts small ones.

It is $\frac{2|a|}{0}$ — formally infinite — but if $a$ and $b$ are the same stored value, the result is exactly $0$ with zero relative error. The blow-up applies when they are nearly but not identically equal.

One root is exactly $0$; then $x_{-}=0/(a{x}_{+})=0$ correctly, but you must also guard against $x_{+}=0$ (both roots zero, i.e. $b=c=0$) to avoid a division by zero.

For $x$ around $10^{-8}$, $\cos x$ rounds to exactly $1$, so $1-\cos x=0$ and the ratio is $0$ — a total loss versus the true limit $\frac{1}{2}$. The identity $1-\cos x=2{\sin }^2(x/2)$ restores it.

No — it is a worst case. For same-sign well-scaled data actual error is far smaller; for badly ordered or cancelling data it can approach the bound. It signals that error grows with $n$, which is what Kahan removes.

It is True — positive and negative zero compare equal — yet they can behave differently downstream (e.g. 1/0.0 gives $+\infty$, 1/-0.0 gives $-\infty$), so the sign of zero is a real edge case in division and branch cuts.

Results below the smallest normal double keep going as subnormals (gradual underflow) — you don't jump straight to $0$ — but each subnormal has fewer mantissa bits, so relative precision degrades and, on some hardware, subnormal arithmetic runs much slower (or traps). Below the smallest subnormal you underflow to $0$ outright.

It is a rounding artifact, not a real negative; clamp it to $0$ (max(v, 0.0)) before feeding it to sqrt, otherwise sqrt returns nan and poisons everything after it.