Rounding Errors & Error Accumulation

[EXEC: MICRO_CORE]

✖️ 1. Differentiating exact arithmetic from numerical approximation and measurement error

🎯 Exact vs. Approximate Numbers

Exact numbers come from counting or definitions (no rounding needed).
Approximations come from measurements or rounding (always have some error).
Calculators and computers use approximations for most decimals.
$\pi = 3.14159...$ is exact as a symbol, but $3.14$ is an approximation.
Measurement tools (rulers, scales) always give approximate values.

If you count 7 apples, that's exact. If you measure 7.2 cm with a ruler, that's approximate.

💡 Counted = exact, measured = approximate!

[EXEC: DEEP_COMPUTE]

1. Differentiating exact arithmetic from numerical approximation and measurement error

Exact Arithmetic vs. Numerical Approximation

Exact arithmetic operates on values with infinite precision (e.g., $\frac{1}{3}$ , $\sqrt{2}$ , $\pi$ ), yielding results that are mathematically perfect. Numerical approximation represents these values with finite precision (e.g., $\pi \approx 3.14159$ ), introducing rounding error—the difference between the true value and its representation.

Intuition: Real-world computations and measurements cannot store infinite digits, so we truncate or round, creating small discrepancies.

Core distinctions:

Exact: $2 + 2 = 4$ (no error)
Approximation: $\sqrt{2} \approx 1.414$ (error $\approx 0.000214$ )
Measurement error arises from instrument limitations (e.g., ruler precision to nearest mm)
Rounding error arises from finite digit representation

Consequence: Even simple operations accumulate error when repeated, diverging from exact results.

Example: Exact $\frac{1}{3} + \frac{1}{3} + \frac{1}{3} = 1$ . Using $0.333 + 0.333 + 0.333 = 0.999$ , error is $0.001$ .

EXECUTION_BLOCK

TASK_1[0 / 3]

LVL_2

RSN: DEBUG

A computer program needs to add the exact fraction $1/5$ three times. Instead of exact arithmetic, it uses the numerical approximation $0.19$ for each fraction. What is the total rounding error of this sum compared to the exact mathematical result?

DEEP_COMPUTE

ULTRA

[EXEC: MICRO_CORE]

✖️ 2. Absolute vs. relative error and understanding significant figures limits

📏 Absolute vs. Relative Error

Absolute error = $|\text{true value} - \text{approximate value}|$ (same units as measurement).
Relative error = $\frac{\text{absolute error}}{|\text{true value}|}$ (unitless, often a percentage).
Significant figures show how many digits are trustworthy in a number.
More significant figures = smaller relative error.
A 1 cm error is huge for measuring a phone but tiny for measuring a building.

True length = 100 cm, measured = 98 cm. Absolute error = 2 cm, relative error = 0.02 or 2 percent.

💡 Relative error tells you if the mistake matters for the scale!

[EXEC: DEEP_COMPUTE]

2. Absolute vs. relative error and understanding significant figures limits

Absolute vs. Relative Error and Significant Figures

Absolute error is the magnitude of difference between approximate value $a$ and true value $x$ : $|a - x|$ . Relative error is the ratio $\frac{|a - x|}{|x|}$ (for $x \neq 0$ ), expressing error as a fraction of the true value.

Intuition: Absolute error measures raw discrepancy; relative error measures proportional accuracy, crucial when comparing scales.

Core rules:

Absolute error: $E_{\text{abs}} = |a - x|$
Relative error: $E_{\text{rel}} = \frac{|a - x|}{|x|}$ (often expressed as percentage)
Significant figures indicate precision: $3.14$ has 3 sig figs; $0.00314$ also has 3
Trailing zeros after decimal count; leading zeros do not

Consequence: Small absolute errors can be large relative errors for tiny values, and vice versa.

Example: True value $x = 1000$ , approximation $a = 1001$ . $E_{\text{abs}} = 1$ , $E_{\text{rel}} = 0.001 = 0.1\%$ . For $x = 0.01$ , $a = 0.02$ : $E_{\text{abs}} = 0.01$ , $E_{\text{rel}} = 1 = 100\%$ .

EXECUTION_BLOCK

TASK_1[0 / 3]

LVL_3

MOD: SANITY_CHECK

A sensor measures a temperature. The true value is $x = 200$ degrees and the approximation is $a = 195$ degrees.

Calculate the absolute error of this measurement.

DEEP_COMPUTE

ULTRA

[EXEC: MICRO_CORE]

✖️ 3. Light error propagation formulas and error bounds in sums/products

➕✖️ Error Propagation Rules

When you add or subtract, absolute errors add up.
When you multiply or divide, relative errors add up.
Error bound = worst-case total error after operations.
If $x \approx 5 \pm 0.1$ and $y \approx 3 \pm 0.2$ , then $x + y \approx 8 \pm 0.3$ .
Multiplying many approximate numbers makes relative error grow fast.

Add $2.0 \pm 0.1$ and $3.0 \pm 0.1$ : result is $5.0 \pm 0.2$ (errors add).

💡 Addition stacks absolute errors, multiplication stacks relative errors!

[EXEC: DEEP_COMPUTE]

3. Light error propagation formulas and error bounds in sums/products

Error Propagation in Sums and Products

Error propagation quantifies how input errors affect computed results. For sums, absolute errors add; for products, relative errors approximately add.

Intuition: Combining approximate values compounds their individual uncertainties according to the operation type.

Core formulas:

Sum/Difference: If $a \pm \Delta a$ and $b \pm \Delta b$ , then $(a + b) \pm (\Delta a + \Delta b)$
Product: If relative errors are $\epsilon_a$ , $\epsilon_b$ , then $ab$ has relative error $\approx \epsilon_a + \epsilon_b$ (for small errors)
Quotient: $\frac{a}{b}$ has relative error $\approx \epsilon_a + \epsilon_b$
Absolute error bound for sum: $|E_{a+b}| \leq |E_a| + |E_b|$

Consequence: Errors accumulate predictably; $n$ additions of values with error $\epsilon$ yield total error $\approx n\epsilon$ .

Example: $a = 5.0 \pm 0.1$ , $b = 3.0 \pm 0.2$ . Sum: $8.0 \pm 0.3$ . Product: $15.0$ with relative error $\frac{0.1}{5} + \frac{0.2}{3} \approx 0.087 = 8.7\%$ , so $15.0 \pm 1.3$ .

EXECUTION_BLOCK

TASK_1[0 / 3]

LVL_3

MOD: SANITY_CHECK

Two measurements are given as $x = 12.0 \pm 0.4$ and $y = 8.0 \pm 0.5$ .

What is the maximum absolute error of the sum $x + y$ ?

DEEP_COMPUTE

ULTRA

[EXEC: MICRO_CORE]

✖️ 4. Catastrophic cancellation when subtracting close approximations

💥 Catastrophic Cancellation

Subtracting two nearly equal approximate numbers destroys accuracy.
The result has far fewer significant figures than the original numbers.
Happens because small rounding errors become huge relative to the tiny difference.
Avoid by rewriting formulas (e.g., use conjugates or factoring).
Computers suffer this badly in floating-point subtraction.

Subtract $1.2345 - 1.2340 = 0.0005$ . If each had error $\pm 0.0001$ , the answer could be off by 40 percent!

💡 Never subtract twins—they cancel the good digits and leave the junk!

[EXEC: DEEP_COMPUTE]

4. Catastrophic cancellation when subtracting close approximations

Catastrophic Cancellation

Catastrophic cancellation occurs when subtracting two nearly equal approximate numbers, causing significant digits to cancel and magnifying relative error drastically.

Intuition: If $a \approx b$ , then $a - b$ is tiny, but rounding errors in $a$ and $b$ become large relative to the small result.

Core characteristics:

Loss of precision: Subtracting $a = 1.2345$ and $b = 1.2340$ (each rounded) yields $0.0005$ , but errors dominate
Relative error explosion: If $a, b$ have error $\epsilon$ , result $(a - b)$ can have relative error $\gg \epsilon$
Avoid by reformulation: Use algebraic identities (e.g., rationalize denominators)
Critical in numerical algorithms: Quadratic formula, derivative approximations

Consequence: Catastrophic cancellation renders results unreliable despite input precision.

Example: Compute $\sqrt{10001} - 100$ with 4-digit precision. $\sqrt{10001} \approx 100.0$ , so $100.0 - 100 = 0$ (wrong). Exact: $\approx 0.005$ . Reformulate: $\frac{(\sqrt{10001})^2 - 100^2}{\sqrt{10001} + 100} = \frac{1}{200.0} = 0.005$ .

EXECUTION_BLOCK

TASK_1[0 / 3]

LVL_2

RSN: DEBUG

Based on the theory, which of the following operations is most likely to cause catastrophic cancellation if the numbers are approximations?

DEEP_COMPUTE

ULTRA

[EXEC: MICRO_CORE]

✖️ 5. Applications: Floating-point arithmetic errors in computer science and trajectory deviations

💻🚀 Real-World Error Disasters

Floating-point arithmetic in computers rounds every calculation slightly.
Millions of tiny errors can accumulate into huge mistakes over time.
The Patriot missile failure (1991) was caused by time-rounding errors after 100 hours.
Spacecraft trajectories drift if position errors compound over billions of calculations.
Financial software must use exact decimal types to avoid cent-rounding bugs.

A rocket calculates position 1000 times per second. Even 0.000001 error per step becomes meters after an hour.

💡 Tiny errors × many steps = mission failure!

[EXEC: DEEP_COMPUTE]

5. Applications: Floating-point arithmetic errors in computer science and trajectory deviations

Applications of Rounding Error Accumulation

Floating-point arithmetic in computers represents real numbers with finite bits (e.g., IEEE 754 standard), causing rounding at each operation. Trajectory deviations occur in simulations when iterative calculations accumulate errors, diverging from true paths.

Intuition: Repeated computations magnify small errors, leading to significant discrepancies in long-running processes.

Key applications:

Floating-point: $0.1 + 0.2 \neq 0.3$ in binary (yields $\approx 0.30000000000000004$ )
Iterative algorithms: Numerical integration, differential equations accumulate error per step
Trajectory simulation: Spacecraft navigation errors compound over millions of calculations
Financial systems: Rounding cents over billions of transactions creates discrepancies

Consequence: Critical systems require error analysis, higher precision (e.g., double vs. single), or compensated summation algorithms (e.g., Kahan summation).

Example: Summing $0.1$ ten thousand times in floating-point yields $\approx 1000.0000000001$ instead of exactly $1000$ , with error $\approx 10^{-10}$ .

EXECUTION_BLOCK

TASK_1[0 / 3]

LVL_2

RSN: DEBUG

A programmer writes a simple script to add $0.1$ and $0.2$ . According to the theory of floating-point arithmetic, what is the expected output?

DEEP_COMPUTE

ULTRA

Rounding errors and their accumulation

✖️ 1. Differentiating exact arithmetic from numerical approximation and measurement error

🎯 Exact vs. Approximate Numbers

1. Differentiating exact arithmetic from numerical approximation and measurement error

Exact Arithmetic vs. Numerical Approximation

✖️ 2. Absolute vs. relative error and understanding significant figures limits

📏 Absolute vs. Relative Error

2. Absolute vs. relative error and understanding significant figures limits

Absolute vs. Relative Error and Significant Figures

✖️ 3. Light error propagation formulas and error bounds in sums/products

➕✖️ Error Propagation Rules

3. Light error propagation formulas and error bounds in sums/products

Error Propagation in Sums and Products

✖️ 4. Catastrophic cancellation when subtracting close approximations

💥 Catastrophic Cancellation

4. Catastrophic cancellation when subtracting close approximations

Catastrophic Cancellation

✖️ 5. Applications: Floating-point arithmetic errors in computer science and trajectory deviations

💻🚀 Real-World Error Disasters

5. Applications: Floating-point arithmetic errors in computer science and trajectory deviations

Applications of Rounding Error Accumulation

AWAITING_CONFIRMATION