On the Computation of Correctly Rounded Sums

Abstract

Abstract-This paper presents a study of some basic blocks needed in the design of floating-point summation algorithms. In particular, in radix-2 floating-point arithmetic, we show that among the set of the algorithms with no comparisons performing only floatingpoint additions/subtractions, the 2Sum algorithm introduced by Knuth is minimal, both in terms of number of operations and depth of the dependency graph. We investigate the possible use of another algorithm, Dekker's Fast2Sum algorithm, in radix-10 arithmetic. We give methods for computing, in radix 10, the floating-point number nearest the average value of two floating-point numbers. We also prove that under reasonable conditions, an algorithm performing only round-to-nearest additions/subtractions cannot compute the round-to-nearest sum of at least three floating-point numbers. Starting from an algorithm due to Boldo and Melquiond, we also present new results about the computation of the correctly-rounded sum of three floating-point numbers. For a few of our algorithms, we assume new operations defined by the recent IEEE 754-2008 Standard are available.

Arithmetic Algorithms for Extended Precision Using Floating-Point Expansions

“…Algorithm 2Sum (Algorithm 1) computes the exact sum of two FP numbers a and b and returns the result under the form s+e, where s is the result rounded to nearest and e is the rounding error. It requires only 6 native FP operations (flops), which it was proven to be optimal in [15], if we have no information on the ordering of a and b.…”

Accurate Parallel Floating-Point Accumulation

“…Most of the accurate accumulation software algorithms such as [5]- [7] rely on the same basic building block that is studied in detail by Kornerup et al [8], a floating-point adder with residue (FPAR), which computes:…”

“…The FPAR building block can be implemented on a standard IEEE-754 FP unit. Kornerup et al [8] show that the algorithm introduced by Knuth [10] is minimal, both in terms of number of operations (six) and depth of the dependency graph (five). Furthermore, they argue that algorithms with fewer floating-point operations that also require branching are inferior (e.g., [9]), due to possible drastic performance losses after a wrong branch prediction causing the instruction pipeline to drain.…”

“…In fact, this handling of a Big Tie deals with the case that Kornerup et al use to prove the impossibility of correctly rounding the sum of three or more FP numbers using a "Round to nearest tie to even" approach with depth less than 1939 double-precision IEEE-754 operations [8]. We are able to cover such a depth with limited resources because repeated iterations allow us to dynamically increase the DAG depth until termination, exceeding 1939 if needed.…”

SIPE: Small Integer Plus Exponent

“…Most of the code of SIPE was written in April/May 2008. Some functions were added in November 2009 in the context of [6] (though MPFR was initially used for the tests performed for this article), and several bugs were fixed in 2011 (in addition to minor changes).…”