Kahan summation algorithm

In pseudocode, the algorithm will be:

function KahanSum(input)
    var sum = 0.0                    // Prepare the accumulator.
    var c = 0.0                      // A running compensation for lost low-order bits.

    for i = 1 to input.length do     // The array input has elements indexed input[1] to input[input.length].
        var y = input[i] - c         // c is zero the first time around.
        var t = sum + y              // Alas, sum is big, y small, so low-order digits of y are lost.
        c = (t - sum) - y            // (t - sum) cancels the high-order part of y; subtracting y recovers negative (low part of y)
        sum = t                      // Algebraically, c should always be zero. Beware overly-aggressive optimizing compilers!
    next i                           // Next time around, the lost low part will be added to y in a fresh attempt.

    return sum

This algorithm can also be rewritten to use the Fast2Sum algorithm:[7]

function KahanSum2(input)
    var sum = 0.0                    // Prepare the accumulator.
    var c = 0.0                      // A running compensation for lost low-order bits.

    for i = 1 to input.length do     // The array input has elements indexed input[1] to input[input.length].
        var y = input[i] + c         // c is zero the first time around.
        (sum,c) = Fast2Sum(sum,y)    // sum + c is an approximation to the exact sum.
    next i                           // Next time around, the lost low part will be added to y in a fresh attempt.

    return sum

  y = 3.14159 - 0.00000             y = input[i] - c
  t = 10000.0 + 3.14159
    = 10003.14159                   But only six digits are retained.
    = 10003.1                       Many digits have been lost!
  c = (10003.1 - 10000.0) - 3.14159 This must be evaluated as written! 
    = 3.10000 - 3.14159             The assimilated part of y recovered, vs. the original full y.
    = -0.0415900                    Trailing zeros shown because this is six-digit arithmetic.
sum = 10003.1                       Thus, few digits from input(i) met those of sum.

  y = 2.71828 - (-0.0415900)        The shortfall from the previous stage gets included.
    = 2.75987                       It is of a size similar to y: most digits meet.
  t = 10003.1 + 2.75987             But few meet the digits of sum.
    = 10005.85987                   And the result is rounded
    = 10005.9                       to six digits.
  c = (10005.9 - 10003.1) - 2.75987 This extracts whatever went in.
    = 2.80000 - 2.75987             In this case, too much.
    = 0.040130                      But no matter, the excess would be subtracted off next time.
sum = 10005.9                       Exact result is 10005.85987, this is correctly rounded to 6 digits.

A careful analysis of the errors in compensated summation is needed to appreciate its accuracy characteristics. While it is more accurate than naive summation, it can still give large relative errors for ill-conditioned sums.

Suppose that one is summing ${\displaystyle n}$ values ${\displaystyle x_{i}}$, for ${\displaystyle i=1,\,\ldots ,\,n}$. The exact sum is

${\displaystyle S_{n}=\sum _{i=1}^{n}x_{i}}$ (computed with infinite precision).

With compensated summation, one instead obtains ${\displaystyle S_{n}+E_{n}}$, where the error ${\displaystyle E_{n}}$ is bounded by[2]

${\displaystyle |E_{n}|\leq {\big [}2\varepsilon +O(n\varepsilon ^{2}){\big ]}\sum _{i=1}^{n}|x_{i}|,}$

where ${\displaystyle \varepsilon }$ is the machine precision of the arithmetic being employed (e.g. ${\displaystyle \varepsilon \approx 10^{-16}}$ for IEEE standard double-precision floating point). Usually, the quantity of interest is the relative error ${\displaystyle |E_{n}|/|S_{n}|}$, which is therefore bounded above by

${\displaystyle {\frac {|E_{n}|}{|S_{n}|}}\leq {\big [}2\varepsilon +O(n\varepsilon ^{2}){\big ]}{\frac {\sum \limits _{i=1}^{n}|x_{i}|}{\left|\sum \limits _{i=1}^{n}x_{i}\right|}}.}$

In the expression for the relative error bound, the fraction ${\displaystyle \Sigma |x_{i}|/|\Sigma x_{i}|}$ is the condition number of the summation problem. Essentially, the condition number represents the intrinsic sensitivity of the summation problem to errors, regardless of how it is computed.[8] The relative error bound of every (backwards stable) summation method by a fixed algorithm in fixed precision (i.e. not those that use arbitrary-precision arithmetic, nor algorithms whose memory and time requirements change based on the data), is proportional to this condition number.[2] An ill-conditioned summation problem is one in which this ratio is large, and in this case even compensated summation can have a large relative error. For example, if the summands ${\displaystyle x_{i}}$ are uncorrelated random numbers with zero mean, the sum is a random walk, and the condition number will grow proportional to ${\displaystyle {\sqrt {n}}}$. On the other hand, for random inputs with nonzero mean the condition number asymptotes to a finite constant as ${\displaystyle n\to \infty }$. If the inputs are all non-negative, then the condition number is 1.

Given a condition number, the relative error of compensated summation is effectively independent of ${\displaystyle n}$. In principle, there is the ${\displaystyle O(n\varepsilon ^{2})}$ that grows linearly with ${\displaystyle n}$, but in practice this term is effectively zero: since the final result is rounded to a precision ${\displaystyle \varepsilon }$, the ${\displaystyle n\varepsilon ^{2}}$ term rounds to zero, unless ${\displaystyle n}$ is roughly ${\displaystyle 1/\varepsilon }$ or larger.[2] In double precision, this corresponds to an ${\displaystyle n}$ of roughly ${\displaystyle 10^{16}}$, much larger than most sums. So, for a fixed condition number, the errors of compensated summation are effectively ${\displaystyle O(\varepsilon )}$, independent of ${\displaystyle n}$.

In comparison, the relative error bound for naive summation (simply adding the numbers in sequence, rounding at each step) grows as ${\displaystyle O(\varepsilon n)}$ multiplied by the condition number.[2] This worst-case error is rarely observed in practice, however, because it only occurs if the rounding errors are all in the same direction. In practice, it is much more likely that the rounding errors have a random sign, with zero mean, so that they form a random walk; in this case, naive summation has a root mean square relative error that grows as ${\displaystyle O\left(\varepsilon {\sqrt {n}}\right)}$ multiplied by the condition number.[9] This is still much worse than compensated summation, however. However, if the sum can be performed in twice the precision, then ${\displaystyle \varepsilon }$ is replaced by ${\displaystyle \varepsilon ^{2}}$, and naive summation has a worst-case error comparable to the ${\displaystyle O(n\varepsilon ^{2})}$ term in compensated summation at the original precision.

By the same token, the ${\displaystyle \Sigma |x_{i}|}$ that appears in ${\displaystyle E_{n}}$ above is a worst-case bound that occurs only if all the rounding errors have the same sign (and are of maximal possible magnitude).[2] In practice, it is more likely that the errors have random sign, in which case terms in ${\displaystyle \Sigma |x_{i}|}$ are replaced by a random walk, in which case, even for random inputs with zero mean, the error ${\displaystyle E_{n}}$ grows only as ${\displaystyle O\left(\varepsilon {\sqrt {n}}\right)}$ (ignoring the ${\displaystyle n\varepsilon ^{2}}$ term), the same rate the sum ${\displaystyle S_{n}}$ grows, canceling the ${\displaystyle {\sqrt {n}}}$ factors when the relative error is computed. So, even for asymptotically ill-conditioned sums, the relative error for compensated summation can often be much smaller than a worst-case analysis might suggest.

Neumaier[10] introduced an improved version of Kahan algorithm, which he calls an "improved Kahan–Babuška algorithm", which also covers the case when the next term to be added is larger in absolute value than the running sum, effectively swapping the role of what is large and what is small. In pseudocode, the algorithm is:

function KahanBabushkaNeumaierSum(input)
    var sum = 0.0
    var c = 0.0                       // A running compensation for lost low-order bits.

    for i = 1 to input.length do
        var t = sum + input[i]
        if |sum| >= |input[i]| then
            c += (sum - t) + input[i] // If sum is bigger, low-order digits of input[i] are lost.
        else
            c += (input[i] - t) + sum // Else low-order digits of sum are lost.
        endif
        sum = t
    next i

    return sum + c                    // Correction only applied once in the very end.

This enhancement is similar to the replacement of Fast2Sum by 2Sum in Kahan's algorithm rewritten with Fast2Sum.

For many sequences of numbers, both algorithms agree, but a simple example due to Peters[11] shows how they can differ. For summing ${\displaystyle [1.0,+10^{100},1.0,-10^{100}]}$ in double precision, Kahan's algorithm yields 0.0, whereas Neumaier's algorithm yields the correct value 2.0.

Higher-order modifications of better accuracy are also possible. For example, a variant suggested by Klein,[12] which he called a second-order "iterative Kahan–Babuška algorithm". In pseudocode, the algorithm is:

function KahanBabushkaKleinSum(input)
    var sum = 0.0
    var cs  = 0.0
    var ccs = 0.0
    var c   = 0.0
    var cc  = 0.0

    for i = 1 to input.length do
        var t = sum + input[i]
        if |sum| >= |input[i]| then
            c = (sum - t) + input[i]
        else
            c = (input[i] - t) + sum
        endif
        sum = t
        t = cs + c
        if |cs| >= |c| then
            cc = (cs - t) + c
        else
            cc = (c - t) + cs
        endif
        cs = t
        ccs = ccs + cc
    end loop 

    return sum + cs + ccs

Although Kahan's algorithm achieves ${\displaystyle O(1)}$ error growth for summing n numbers, only slightly worse ${\displaystyle O(\log n)}$ growth can be achieved by pairwise summation: one recursively divides the set of numbers into two halves, sums each half, and then adds the two sums.[2] This has the advantage of requiring the same number of arithmetic operations as the naive summation (unlike Kahan's algorithm, which requires four times the arithmetic and has a latency of four times a simple summation) and can be calculated in parallel. The base case of the recursion could in principle be the sum of only one (or zero) numbers, but to amortize the overhead of recursion, one would normally use a larger base case. The equivalent of pairwise summation is used in many fast Fourier transform (FFT) algorithms and is responsible for the logarithmic growth of roundoff errors in those FFTs.[13] In practice, with roundoff errors of random signs, the root mean square errors of pairwise summation actually grow as ${\displaystyle O\left({\sqrt {\log n}}\right)}$.[9]

Another alternative is to use arbitrary-precision arithmetic, which in principle need no rounding at all with a cost of much greater computational effort. A way of performing correctly rounded sums using arbitrary precision is to extend adaptively using multiple floating-point components. This will minimize computational cost in common cases where high precision is not needed.[14][11] Another method that uses only integer arithmetic, but a large accumulator, was described by Kirchner and Kulisch; [15] a hardware implementation was described by Müller, Rüb and Rülling.[16]

In principle, a sufficiently aggressive optimizing compiler could destroy the effectiveness of Kahan summation: for example, if the compiler simplified expressions according to the associativity rules of real arithmetic, it might "simplify" the second step in the sequence

t = sum + y;

c = (t - sum) - y;

to

c = ((sum + y) - sum) - y;

and then to

c = 0;

thus eliminating the error compensation.[17] In practice, many compilers do not use associativity rules (which are only approximate in floating-point arithmetic) in simplifications, unless explicitly directed to do so by compiler options enabling "unsafe" optimizations,[18][19][20][21] although the Intel C++ Compiler is one example that allows associativity-based transformations by default.[22] The original K&R C version of the C programming language allowed the compiler to re-order floating-point expressions according to real-arithmetic associativity rules, but the subsequent ANSI C standard prohibited re-ordering in order to make C better suited for numerical applications (and more similar to Fortran, which also prohibits re-ordering),[23] although in practice compiler options can re-enable re-ordering, as mentioned above.

A portable way to inhibit such optimizations locally is to break one of the lines in the original formulation into two statements, and make two of the intermediate products volatile:

function KahanSum(input)
    var sum = 0.0
    var c = 0.0

    for i = 1 to input.length do
        var y = input[i] - c
        volatile var t = sum + y
        volatile var z = t - sum
        c = z - y
        sum = t
    next i

    return sum

In general, built-in "sum" functions in computer languages typically provide no guarantees that a particular summation algorithm will be employed, much less Kahan summation. The BLAS standard for linear algebra subroutines explicitly avoids mandating any particular computational order of operations for performance reasons,[24] and BLAS implementations typically do not use Kahan summation.

The standard library of the Python computer language specifies an fsum function for accurate summation. Starting with Python 3.12, the built-in "sum()" function uses the Neumaier summation.[25]

In the Julia language, the default implementation of the sum function does pairwise summation for high accuracy with good performance,[26] but an external library provides an implementation of Neumaier's variant named sum_kbn for the cases when higher accuracy is needed.[27]

In the C# language, HPCsharp nuget package implements the Neumaier variant and pairwise summation: both as scalar, data-parallel using SIMD processor instructions, and parallel multi-core.[28]

• Algorithms for calculating variance, which includes stable summation

• Floating-point Summation, Dr. Dobb's Journal September, 1996