Rounding Errors Have Crashed Rockets and Cost Banks Millions

A Quarter-Second Error. Twenty-Eight Deaths.

On February 25, 1991, a Patriot missile battery near Dhahran, Saudi Arabia failed to intercept an incoming Iraqi Scud. The Scud hit a U.S. Army barracks, killing 28 soldiers and wounding 99 more.

The cause, as documented in a U.S. General Accounting Office report, was a rounding error. The system tracked time in tenths of a second using a 24-bit binary register. The value 0.1 cannot be represented exactly in binary — the computer stored a truncated approximation. The discrepancy was 0.0000000095 seconds per tick.

After the battery had been running for 100 hours, those tiny errors had accumulated to a 0.34-second drift. A Scud travels roughly 1,676 meters per second. The system looked for the missile 570 meters from where it actually was. It declared no target detected and stood down.

A number smaller than one hundredth of a decimal place. Multiplied by time.

Truncation Is Not Rounding — and That Distinction Cost a Stock Exchange 1,000 Points

Most people treat "rounding" and "truncation" as synonyms. They're not.

Rounding looks at the digit being dropped and adjusts: 2.75 rounds to 2.8 (if keeping one decimal), because the dropped digit (5) rounds up.

Truncation simply cuts: 2.75 becomes 2.7 regardless of what follows. 2.99 becomes 2.9. The number always moves down.

In 1982, the Vancouver Stock Exchange launched with an index value of 1,000.000. By November 1983, the index stood at 524.881 — even though based on actual stock prices it should have been approximately 1,098. The exchange had been recalculating the index over 3,000 times a day using truncation instead of rounding. Each recalculation chopped off value. After more than 2.8 million calculations, the accumulated downward bias eroded nearly half the index.

The fix took one afternoon. They recalculated the correct value, reset the index, and switched to rounding. Total investigation time: a few hours. Total damage: 22 months of meaningless data.

How Accumulated Error Works

Every time a calculation truncates or rounds, it introduces a small error $\epsilon$. Over $n$ calculations, if those errors don't cancel out — particularly if they're systematically biased in one direction, like truncation always biasing downward — the accumulated error grows:

Where $\bar{\epsilon}$ is the average per-step error. Random errors (sometimes positive, sometimes negative) tend to cancel — accumulated error grows as $\sqrt{n}$. Systematic errors don't cancel — accumulated error grows linearly with $n$.

The Patriot system and the Vancouver exchange both suffered from systematic error: the same direction, every time, compounding without cancellation.

Ariane 5 Flight 501: $370 Million in 40 Seconds

On June 4, 1996, the Ariane 5 rocket self-destructed 37 seconds after launch. The cause was a software module originally written for the Ariane 4 — which had a narrower velocity range. When reused on Ariane 5, which flew faster, a 64-bit floating-point number was converted to a 16-bit signed integer. The value was too large for the 16-bit container. Overflow. The inertial reference system shut down. The backup system — running identical code — also failed. The rocket received nonsensical steering commands and broke apart.

This is a different class of numerical error from rounding — it's overflow, not accumulated drift — but the underlying lesson is the same: the assumption that numbers will behave the way you expect becomes a liability the moment the inputs change.

Banker's Rounding: The Rule Designed to Prevent Bias

Standard rounding says: when a number is exactly halfway (like 2.5), round up. Always.

That creates a systematic upward bias in large datasets. Half the values that fall exactly on the midpoint always get rounded the same way.

Banker's rounding — also called round-half-to-even or statistical rounding — eliminates this bias by rounding to the nearest even number when a value is exactly at the midpoint:

Python 3, the IEEE 754 floating-point standard, and many financial systems use banker's rounding precisely to avoid the accumulated bias that plagued the Vancouver exchange. The next time Python tells you that round(2.5) is 2, you'll know why.

Significant figures — covered in detail in our sig figs article — are related to this: they're a discipline for communicating how precise your numbers actually are, which determines when rounding errors become meaningful.

Quick Questions