@article{higham:1993a,

doi = {10.1137/0914050},

@article{ogita:2005a,

abstract = {Algorithms for summation and dot product of floating-point numbers are presented which are fast in terms of measured computing time. We show that the computed results are as accurate as if computed in twice or K-fold working precision, $K\ge 3$. For twice the working precision our algorithms for summation and dot product are some 40% faster than the corresponding XBLAS routines while sharing similar error estimates. Our algorithms are widely applicable because they require only addition, subtraction, and multiplication of floating-point numbers in the same working precision as the given data. Higher precision is unnecessary, algorithms are straight loops without branch, and no access to mantissa or exponent is necessary.},

author = {Takeshi Ogita and Siegfried M Rump and Shin'ichi Oishi},

doi = {10.1137/030601818},

journal = {SIAM Journal on Scientific Computing},

keywords = {summation, numerical analysis, algorithms, math, precision, floating-point arithmetic, dot product},

month = {},

number = {6},

pages = {1955--1988},

title = {{Accurate Sum and Dot Product}},

url = {https://doi.org/10.1137/030601818},

volume = {26},

year = {2005},

}

@article{rump:2009a,

abstract = {We present two new algorithms FastAccSum and FastPrecSum, one to compute a faithful rounding of the sum of floating-point numbers and the other for a result “as if” computed in K-fold precision. Faithful rounding means the computed result either is one of the immediate floating-point neighbors of the exact result or is equal to the exact sum if this is a floating-point number. The algorithms are based on our previous algorithms AccSum and PrecSum and improve them by up to 25%. The first algorithm adapts to the condition number of the sum; i.e., the computing time is proportional to the difficulty of the problem. The second algorithm does not need extra memory, and the computing time depends only on the number of summands and K. Both algorithms are the fastest known in terms of flops. They allow good instruction-level parallelism so that they are also fast in terms of measured computing time. The algorithms require only standard floating-point addition, subtraction, and multiplication in one working precision, for example, double precision.},

author = {Siegfried M Rump},

doi = {10.1137/080738490},

journal = {SIAM Journal on Scientific Computing},

keywords = {summation, numerical analysis, algorithms, math, precision, floating-point arithmetic},

month = {},

number = {5},

pages = {3466--3502},

title = {{Ultimately Fast Accurate Summation}},

url = {https://doi.org/10.1137/080738490},

volume = {31},

year = {2009},

}

@article{zhu:2010a,

abstract = {We present a novel, online algorithm for exact summation of a stream of floating-point numbers. By “online” we mean that the algorithm needs to see only one input at a time, and can take an arbitrary length input stream of such inputs while requiring only constant memory. By “exact” we mean that the sum of the internal array of our algorithm is exactly equal to the sum of all the inputs, and the returned result is the correctly-rounded sum. The proof of correctness is valid for all inputs (including nonnormalized numbers but modulo intermediate overflow), and is independent of the number of summands or the condition number of the sum. The algorithm asymptotically needs only 5 FLOPs per summand, and due to instruction-level parallelism runs only about 2--3 times slower than the obvious, fast-but-dumb “ordinary recursive summation” loop when the number of summands is greater than 10,000. Thus, to our knowledge, it is the fastest, most accurate, and most memory efficient among known algorithms. Indeed, it is difficult to see how a faster algorithm or one requiring significantly fewer FLOPs could exist without hardware improvements. An application for a large number of summands is provided.},

author = {Yong-Kang Zhu and Wayne B Hayes},

doi = {10.1145/1824801.1824815},

journal = {ACM Transactions on Mathematical Software},

keywords = {summation, numerical analysis, algorithms, math, precision, floating-point arithmetic},

month = {sep},

number = {3},

pages = {1--13},

title = {{Algorithm 908: Online Exact Summation of Floating-Point Streams}},

url = {https://doi.org/10.1145/1824801.1824815},

volume = {37},

year = {2010},

}

@article{rump:2008a,

abstract = {Given a vector of floating-point numbers with exact sum s, we present an algorithm for calculating a faithful rounding of s, i.e., the result is one of the immediate floating-point neighbors of s. If the sum s is a floating-point number, we prove that this is the result of our algorithm. The algorithm adapts to the condition number of the sum, i.e., it is fast for mildly conditioned sums with slowly increasing computing time proportional to the logarithm of the condition number. All statements are also true in the presence of underflow. The algorithm does not depend on the exponent range. Our algorithm is fast in terms of measured computing time because it allows good instruction-level parallelism, it neither requires special operations such as access to mantissa or exponent, it contains no branch in the inner loop, nor does it require some extra precision: The only operations used are standard floating-point addition, subtraction, and multiplication in one working precision, for example, double precision. Certain constants used in the algorithm are proved to be optimal.},

author = {Siegfried M Rump and Takeshi Ogita and Shin'ichi Oishi},

doi = {10.1137/050645671},

journal = {SIAM Journal on Scientific Computing},

keywords = {summation, numerical analysis, algorithms, math, precision, floating-point arithmetic},

month = {},

number = {1},

pages = {189–-224},

title = {{Accurate Floating-Point Summation Part I: Faithful Rounding}},

url = {https://doi.org/10.1137/050645671},

volume = {31},

year = {2008},

}

@article{rump:2008a,

abstract = {In Part II of this paper we first refine the analysis of error-free vector transformations presented in Part I. Based on that we present an algorithm for calculating the rounded-to-nearest result of $s:=\sum p_i$ for a given vector of floating-point numbers $p_i$, as well as algorithms for directed rounding. A special algorithm for computing the sign of s is given, also working for huge dimensions. Assume a floating-point working precision with relative rounding error unit eps. We define and investigate a K-fold faithful rounding of a real number r. Basically the result is stored in a vector $\mathtt{Res}_{\nu}$ of K nonoverlapping floating-point numbers such that $\sum\mathtt{Res}_{\nu}$ approximates r with relative accuracy $\mathtt{eps}^K$, and replacing $\mathtt{Res}_K$ by its floating-point neighbors in $\sum\mathtt{Res}_{\nu}$ forms a lower and upper bound for r. For a given vector of floating-point numbers with exact sum s, we present an algorithm for calculating a K-fold faithful rounding of s using solely the working precision. Furthermore, an algorithm for calculating a faithfully rounded result of the sum of a vector of huge dimension is presented. Our algorithms are fast in terms of measured computing time because they allow good instruction-level parallelism, they neither require special operations such as access to mantissa or exponent, they contain no branch in the inner loop, nor do they require some extra precision. The only operations used are standard floating-point addition, subtraction, and multiplication in one working precision, for example, double precision. Certain constants used in the algorithms are proved to be optimal.},

author = {Siegfried M Rump and Takeshi Ogita and Shin'ichi Oishi},

doi = {10.1137/07068816X},

journal = {SIAM Journal on Scientific Computing},

keywords = {summation, numerical analysis, algorithms, math, precision, floating-point arithmetic},

month = {},

number = {2},

pages = {1269--1302},

title = {{Accurate Floating-Point Summation Part II: Sign, K-Fold Faithful and Rounding to Nearest}},

url = {https://doi.org/10.1137/07068816X},

volume = {31},

year = {2008},

}