About

Floating-point arithmetic introduces rounding errors that accumulate across operations. Summing 0.1 + 0.2 in IEEE 754 yields 0.30000000000000004, not 0.3. For financial ledgers, scientific datasets, or engineering tallies with dozens of addends, that drift compounds silently. This calculator implements the Kahan compensated summation algorithm, which tracks a running compensation variable c to recover lost low-order bits. The result matches the precision you actually entered, not what binary approximation decided for you.

The tool accepts unlimited rows of signed decimal numbers. Each row can carry an optional label for bookkeeping. Negative values are handled natively - no separate subtraction mode is needed. Inputs are validated against the pattern −?\d*\.?\d+ before parsing. Note: this calculator operates on finite real numbers only. Inputs of NaN or Infinity are rejected. Pro tip: when reconciling bank statements, paste values row-by-row and label each with the transaction reference to create an auditable trail.

Formulas

Standard addition of n real numbers:

S = n∑i=1 a_i

Kahan compensated summation reduces floating-point accumulation error from O(n ⋅ ε) to O(ε):

sum = 0 , c = 0
for each a_i :
y = a_i − c
t = sum + y
c = (t − sum) − y
sum = t

Where S = total sum, a_i = each addend, n = count of addends, c = compensation for lost low-order bits, y = compensated next term, t = temporary working sum, ε = machine epsilon (≈ 2.22 × 10⁻¹⁶ for 64-bit floats).

Reference Data

Addend Count	Naïve Sum Error Bound	Kahan Sum Error Bound	Use Case
2	1 ulp	1 ulp	Simple pair addition
10	9 ulp	2 ulp	Weekly expense totals
100	99 ulp	2 ulp	Monthly transaction reconciliation
1,000	999 ulp	2 ulp	Large dataset aggregation
10,000	9,999 ulp	2 ulp	Scientific measurement series
100,000	99,999 ulp	2 ulp	Sensor telemetry batch
1,000,000	999,999 ulp	2 ulp	Big data pipeline partial sums
ulp = unit in the last place (machine epsilon relative error)

Frequently Asked Questions

IEEE 754 double-precision stores numbers in binary. The decimal fraction 0.1 becomes an infinitely repeating binary sequence, truncated to 53 significant bits. This truncation introduces a rounding error of approximately 5.55 × 10⁻¹⁸. When two such approximations are added, the errors combine, producing 0.30000000000000004. This calculator uses Kahan summation and intelligent decimal-place detection to display a result consistent with the precision you entered.

Naive summation accumulates error proportional to the number of addends: up to n ⋅ ε. Kahan summation maintains a separate compensation variable c that captures the low-order bits lost during each addition. The error bound drops to approximately 2ε regardless of how many addends exist. For 1,000 numbers, that is a ~500× improvement in worst-case accuracy.

Yes. Subtraction is addition with a negated operand. Enter negative values with a leading minus sign (e.g., −42.5). The summation algorithm treats positive and negative values identically. The result correctly reflects the net total.

There is no hard-coded limit. The calculator dynamically creates rows in the DOM. Performance remains smooth up to several thousand rows on modern devices. At 10,000 rows the Kahan summation loop itself completes in under 1 ms. The DOM rendering is the bottleneck, not the arithmetic.

The calculator inspects every valid input and records the maximum number of decimal places entered. The final sum is displayed with that same precision using toFixed(maxDecimals). For example, if your most precise input is 3.1415 (4 decimal places), the result renders to 4 decimal places. If all inputs are integers, the result is displayed as an integer.

Yes. Both the current input rows and the last 50 calculation results are stored in localStorage. Reloading or closing the browser preserves your data. Use the clear button to explicitly wipe history. Private/incognito browsing modes will discard data when the window closes.