<caption>**Algorithm 20** Kahan–Babuška($x_1, \dots, x_n$)</caption>

1: $s \leftarrow x_1$
2: $c \leftarrow 0$
3: **for** $i = 2$ **to** $n$ **do**
4: &nbsp;&nbsp;&nbsp;&nbsp; $y \leftarrow R_D^U(x_i + c)$
5: &nbsp;&nbsp;&nbsp;&nbsp; $t \leftarrow R_D^U(s + y)$
6: &nbsp;&nbsp;&nbsp;&nbsp; $c \leftarrow R_D^U(y - R_D^U(t - s))$
7: &nbsp;&nbsp;&nbsp;&nbsp; $s \leftarrow t$
8: **end for**
9: **return** $s$

Lines 5 and 6 of Algorithm 20 are simply Fast2Sum($s, y$) (Algorithm 1). Note, however, that the conditions that guarantee $t + c = s + y$ may not be satisfied. Indeed, the rounding function is not necessarily RN, and $|y|$ is not necessarily less than or equal to $|s|$, so the correcting term $c$ used to update the next $x_i$ may be only an approximation to the error of $t$. And yet the algorithm already enjoys an error bound better than (4.8): if each floating-point operation has relative error at most $v$ then, as shown by Hallman and Ipsen (2022), the final value of $s$ satisfies

$$ \left| s - \sum_{i=1}^{n} x_i \right| \le (3\mathbf{v} + O(n\mathbf{v}^2)) \cdot \sum_{i=1}^{n} |x_i|; $$

here, $\mathbf{v} = \mathbf{u}$ when all computations are done using round-to-nearest, while $\mathbf{v} = 2\mathbf{u}$ when resorting to some generic rounding function $R_D^U$.

Later on, Pichat (1972) and Neumaier (1974) independently suggested a more accurate variant of Algorithm 20 where, instead of immediately adding at step $i$ the previously computed value of the error term $c$ (let us call it $c_{i-1}$), it accumulates these values $c_i$ and adds their computed sum to $s$ at the end of the calculation. They also performed tests to use Algorithm Fast2Sum in its domain of validity. Priest (1992) also gave a doubly compensated summation algorithm, which guarantees high relative accuracy provided the summands $x_i$ have first been sorted into decreasing order of magnitude.

To avoid tests, Ogita et al. (2005) replaced the use of Fast2Sum and a test in the Pichat–Neumaier algorithm by a 2Sum (Algorithm 2), and considered a generalization (Algorithm 21), where the sum of the error terms is computed again with the same algorithm (which was already suggested by Pichat). Then, calling Algorithm 21 repeatedly, this gives the K-fold algorithm (Algorithm 22).

Rump et al. (2008) showed that the final value of variable $c$ satisfies

$$ \left| c - \sum_{i=1}^{n} x_i \right| \le (\mathbf{u} + \gamma_{n-1}^2) \cdot \left| \sum_{i=1}^{n} x_i \right| + \gamma_{2n-2}^K \cdot \sum_{i=1}^{n} |x_i|, $$

where $\gamma_n := nu/(1-nu)$.
**Algorithm 21** VecSum($x_1, \dots, x_n$)

$p \leftarrow x$

for $i = 2$ to $n$ do

($p_i, p_{i-1}) \leftarrow 2\text{Sum}(p_i, p_{i-1})$

end for

return $p$

**Algorithm 22** K-fold($x_1, \dots, x_n$)

for $k = 1$ to $K - 1$ do

$x \leftarrow \text{VecSum}(x)$

end for

$c \leftarrow x_1$

for $i = 2$ to $n$ do

$c \leftarrow c + x_i$

end for

return $c$

Another, very different, way of using EFTs to perform accurate summation is the following. Malcolm (1971), starting from ideas expressed by Wolfe (1964), splits the range of floating-point exponents into *bins* of a fixed width $W < p$ (which depends on the number of terms to be added). Then, using a splitting algorithm similar to Algorithm 6, each input number $x_i$ is decomposed as the sum of a small number of lower-precision FP numbers, called *slices* by Demmel et al. (2016), such that the weights of the significand bits of a slice all belong to the same bin. If $W$ is well chosen, then all the elements of a bin can be accumulated without error. There remains to add the non-zero terms accumulated in the bins. Malcolm suggests doing that most significant bin first. The *reproducible summation algorithm* of Demmel et al. (2016) builds on this method. Another algorithm based on judicious splittings of the operands is the *Accsum* algorithm by Rump et al. (2008), which guarantees faithful rounding of a sum.

## 5.4. Extended precision software

As seen in Section 5.1, we may rely on the available processor FP operations to build extended precision arithmetic, for instance using double-word algorithms, that roughly double the available precision. Triple-word (Fabiano, Muller and Picot 2019) and quad-word algorithms (Hida et al. 2001) are available as well.

When additional precision is needed, even more than four FP numbers may be used, and a number may be represented by the unevaluated sum of an arbitrary number of floating-point numbers, with some conditions to avoid having too much *overlapping* between them. Such sums are called *floating-point expansions* (Priest 1991, Shewchuk 1997, Daumas 1999, Popescu 2017).
Software libraries exist based on these ideas. Double-word and quad-word arith-
metics are available in QD.<fnref n="38" /> CAMPARY<fnref n="39" /> provides the double-word algorithms
formally proved by Muller and Rideau (2022) as well as arbitrary-precision com-
putations based on floating-point expansions.

When the desired precision becomes very large, methods based on floating-point
expansions are no longer efficient, and one needs to switch to another solution that
consists in representing a number by an arbitrary-precision significand with a
large enough exponent. The pioneering work was done by Brent (1978) with his
MP multiple-precision package. GMP<fnref n="40" /> is known for its very efficient arbitrary-
precision integers, but it also provides rational numbers and floating-point num-
bers. GNU MPFR<fnref n="41" /> is a C library based on GMP that provides multiple-precision
floating-point arithmetic with correct rounding (Fousse et al. 2007). Pari/GP<fnref n="42" />
provides fast multiple-precision arithmetic, either based on GMP or on its own
native kernel (usually slower); it is mainly targeted at number theorists. MP-
FUN2020³⁸ is a Fortran package for multiple-precision arithmetic with special
care taken to be thread-safe; it includes two versions, one based on MPFR.

Another way to ensure the correctness is to provide some enclosing of the
exact result. This may be done by interval arithmetic as explained in Section 4.1.
MPFI<sup>43</sup> is a C library for arbitrary-precision interval arithmetic, where intervals
are represented by their endpoints; it is based on MPFR for the implementation
of the endpoints (Revol and Rouillier 2005). Arb<sup>44</sup> is a C library for arbitrary-
precision ball arithmetic (a form of interval arithmetic that uses a midpoint-radius
representation of real and complex numbers); it includes an impressive library of
special functions (Johansson 2013).

Extended precision may also be hidden to the user. For instance, computer
algebra software systems as Maple,<fnref n="45" /> Sage,<fnref n="46" /> or Mathemagix<fnref n="47" /> provide extended-
precision floating-point numbers (based on GMP for Sage, and on MPFR for
Mathemagix).

<footnote n="38">³⁸ https://www.davidhbailey.com/dhbsoftware/</footnote>

<footnote n="39">³⁹ https://homepages.laas.fr/mmjoldes/campary/</footnote>

<footnote n="40">⁴⁰ https://gmplib.org/</footnote>

<footnote n="41">⁴¹ https://mpfr.loria.fr/</footnote>

<footnote n="42">⁴² http://pari.math.u-bordeaux.fr/</footnote>

<footnote n="43">⁴³ https://gitlab.inria.fr/mpfi/mpfi/</footnote>

<footnote n="44">⁴⁴ https://arblib.org/</footnote>

<footnote n="45">⁴⁵ https://www.maplesoft.com/products/Maple/</footnote>

<footnote n="46">⁴⁶ https://www.sagemath.org/</footnote>

<footnote n="47">⁴⁷ http://www.mathemagix.org/</footnote>
# 6. Conclusion

This conclusion focuses on the evolution of floating-point arithmetic and its links to other domains. Section 6.1 is about useful operators that could spread and be standardized in the future. Section 6.2 describes some recent alternative arithmetics. Section 6.3 presents some fruitful links of floating-point arithmetic to formal proof and computer algebra.

## 6.1. *Implemented but not (yet?) standard operators and rounding functions*

We have presented many arithmetic operators and rounding functions, the basic ones in Section 2 (including some more exotic ones in Section 2.12) and a few others added by the last revision of the Standard in Section 4.2.3. Nevertheless, some other features might be useful, whether they are rounding functions or operators.

An old rounding function is *round-to-odd*, which was first considered by von Neumann when designing the arithmetic unit of the EDVAC, and later used by Goldberg for converting FP numbers to decimal representation. It was used by GCC for the reverse conversion, and formally studied by Boldo and Melquiond (2008). Its main property related to double rounding is explained in Section 2.10.2.

As far as operators are concerned, we may desire that the augmented operations presented in Section 4.2.3 should also be available in round-to-nearest, ties-to-even. All EFTs (see Section 4.2) would greatly benefit from an efficient hardware implementation of such operations.

Another possibility is to have more complex FP operators. As the FMA instruction can replace and generalize floating-point addition and multiplication, the FDMDA<fnref n="48" /> (fused dual multiply dual add) instruction, which computes

$$ab + cd + e,$$

could replace and generalize the FMA. The question of the specification of such an operator is then crucial, in particular whether it is correctly rounded (meaning as if there were a single rounding at the end of the four operations). This may be available in the next generations of processors, due to its usefulness. More than solving the difficult problem of the correctly rounded sum of three numbers (Kornerup et al. 2012) and making most EFT computations trivial, it would greatly simplify and make more accurate double-word arithmetic algorithms, some complex arithmetic operations and probably many other algorithms.

## 6.2. *Alternative arithmetics*

It is natural and sound to consider that floating-point arithmetic, as defined in the 1970s and 1980s, may now be questioned. As we saw in the Introduction, the processor technology and target applications have drastically changed since the birth of IEEE-754. For some applications, arithmetics other than conventional

<footnote n="48">⁴⁸ See https://patents.google.com/patent/US20220222073A1/en.</footnote>
floating-point may be better suited, for instance when the range of numbers we need to represent is known beforehand or very large. The emergence of digital neural networks for AI applications requires arithmetics with tiny precisions (to achieve high bandwidth) yet rather large range (Wang and Kanwar 2019, Bertaccini et al. 2022).

In order to obtain a larger range than conventional floating-point while maintaining good precision for numbers of the usual order of magnitude, Gustafson (2015) introduced the *unums*, and later on their successors, the *posits* (Posit Working Group 2022). Posits are still numbers of the form $M \cdot 2^E$, where *M* and *E* are integers, but with a cleverly designed encoding that allows for variable sizes of *M* and *E* (but with a fixed total word size). Experiments by Cococcioni, Rossi, Ruffaldi and Saponara (2022) suggest that *Posit8* could be an interesting solution for implementing digital neural networks. For general higher-precision numerical computing, however, the price to pay is huge. Indeed, with posits, the standard model (see Section 2.1) no longer applies, that is, the individual arithmetic operations no longer have a bounded relative error (de Dinechin, Forget, Muller and Uguen 2019).

### 6.3. Floating-point arithmetic and beyond

As soon as a numerical algorithm contains more than a few operations, it is a tremendous task to obtain very tight error bounds and to make sure that underflows and overflows will not occur and that NaNs will not propagate throughout the calculation. The proofs we publish are seldom fully satisfactory. Either we just give a rough idea of what makes the algorithm work, coyly hiding all the dirty stuff, or we try to take into account all possible corner cases, ending, as mentioned in the Introduction, with long and tedious proofs, with the consequence that a flaw may remain unnoticed for years. For example, Kahan (2004b) proposed an intricate algorithm for computing a correct discriminant.<fnref n="49" /> The formal verification of Kahan’s algorithm showed a gap in the pen-and-paper proof, as a test could be wrong with respect to its mathematical counterpart, creating unstudied cases. Fortunately, the algorithm was still correct in these special cases and formally proved by Boldo (2009).

And yet, floating-point arithmetic is needed in many critical applications, and for a given application we would like to analyse not just one solution but many of them, in order to choose the best suited. For small formats up to 32 bits, exhaustive testing is achievable for basic operators. But when the precision increases it becomes intractable, and *formal proof* is then a precious tool that can provide a strong validation of the pen-and-paper proof of an algorithm, as seen in several parts of this article.

<footnote n="49">⁴⁹ A naive algorithm may not be accurate enough, as a cancellation may endanger the sign of the result.</footnote>
Another solution is to try to build algorithms and proofs that are correct by construction. From that point of view, *computer algebra* could considerably help the design and analysis of floating-point programs, in several respects. First, the design of function software could be made easier and the probability of bugs in such software could be made much lower, using tools that automatically find symmetries and build local as well as asymptotic approximations, for instance from the differential equation that defines the function. Second, part of the analysis that uses the standard model could be assisted by computer. This would allow one to explore many variants of a numerical algorithm; this would also allow the analysis of numerical programs significantly larger than the ones we are able to deal with by pen-and-paper calculations. The pioneering work of Mezzarobba (2010, 2020) addresses these two topics.

## Acknowledgements

We thank Michael Overton for his comments on an early draft of this article. We are also grateful for the thorough work of the copy-editor.

This work was partly supported by the European Research Council (ERC) under the European Union's Horizon 2020 Research and Innovation Programme – Grant Agreements 810367 and 101001995. It was also partly supported by the NuSCAP project (ANR-20-CE48-0014) of the French national research agency (ANR).

## References

A. Agrawal, S. M. Mueller, B. M. Fleischer, X. Sun, N. Wang, J. Choi and K. Gopalakrishnan (2019), DLFloat: A 16-b floating point format designed for deep learning training and inference, in *26th IEEE Symposium on Computer Arithmetic*, IEEE, pp. 92–95.

C. S. Anderson, J. Zhang and M. Cornea (2018), Enhanced vector math support on the Intel®AVX-512 architecture, in *25th IEEE Symposium on Computer Arithmetic*, pp. 120–124.

I. Babuška (1969), Numerical stability in mathematical analysis, in *Proceedings of the 1968 IFIP Congress*, Vol. 1, pp. 11–23.

R. C. M. Barnes, E. H. Cooke-Yarborough and D. G. A. Thomas (1951), An electronic digital computer using cold cathode counting tubes for storage (Part 1), *Electron. Engng 23*, 286–291.

T. Bartels, V. Fisikopoulos and M. Weiser (2022), Fast floating-point filters for robust predicates. Available at arXiv:2208.00497.

M. Baudin and R. L. Smith (2012), A robust complex division in Scilab. Available at arXiv:1210.4539.

N. H. F. Beebe (2017), *The Mathematical-Function Computation Handbook*, Springer.

L. Bertaccini, G. Paulin, T. Fischer, S. Mach and L. Benini (2022), MiniFloat-NN and ExSdotp: An ISA extension and a modular open hardware unit for low-precision training on RISC-V cores, in *29th IEEE Symposium on Computer Arithmetic*.

P. Blanchard, N. J. Higham and T. Mary (2020), A class of fast and accurate summation algorithms, *SIAM J. Sci. Comput.* **42**, A1541–A1557.
G.Bohlender, W. Walter, P. Kornerup and D. Matula (1991), Semantics for exact floating point operations, in *10th IEEE Symposium on Computer Arithmetic*, pp. 22–26.

S. Boldo (2006), Pitfalls of a full floating-point proof: Example on the formal proof of the Veltkamp/Dekker algorithms, in *3rd International Joint Conference on Automated Reasoning* (U. Furbach and N. Shankar, eds), Vol. 4130 of Lecture Notes in Computer Science, Springer, pp. 52–66.

S. Boldo (2009), Kahan’s algorithm for a correct discriminant computation at last formally proven, *IEEE Trans. Comput.* **58**, 220–225.

S. Boldo and M. Daumas (2003), Representable correcting terms for possibly underflowing floating point operations, in *16th IEEE Symposium on Computer Arithmetic* (J.-C. Bajard and M. Schulte, eds), pp. 79–86.

S. Boldo and G. Melquiond (2008), Emulation of a FMA and correctly rounded sums: Proved algorithms using rounding to odd, *IEEE Trans. Comput.* **57**, 462–471.

S. Boldo and G. Melquiond (2017), *Computer Arithmetic and Formal Proofs*, ISTE Press / Elsevier.

S. Boldo and J.-M. Muller (2005), Some functions computable with a fused-mac, in *17th IEEE Symposium on Computer Arithmetic*, pp. 52–58.

S. Boldo and J.-M. Muller (2011), Exact and approximated error of the FMA, *IEEE Trans. Comput.* **60**, 157–164.

S. Boldo, S. Graillat and J.-M. Muller (2017), On the robustness of the 2Sum and Fast2Sum algorithms, *ACM Trans. Math. Softw.* **4**, 4:1–4:14.

S. Boldo, C. Lauter and J.-M. Muller (2021), Emulating round-to-nearest ties-to-zero 'augmented' floating-point operations using round-to-nearest ties-to-even arithmetic, *IEEE Trans. Comput.* **70**, 1046–1058.

C. F. Borges (2021), Algorithm 1014: An improved algorithm for Hypot(x, y), *ACM Trans. Math. Softw.* **4**, 1–12.

C. F. Borges, C.-P. Jeannerod and J.-M. Muller (2022), High-level algorithms for correctly-rounded reciprocal square roots, in *29th IEEE Symposium on Computer Arithmetic*, pp. 18–25.

R. P. Brent (1973), On the precision attainable with various floating-point number systems, *IEEE Trans. Comput. C-22*, 601–607.

R. P. Brent (1978), Algorithm 524: MP, a Fortran multiple-precision arithmetic package [A1], *ACM Trans. Math. Softw.* **4**, 71–81.

R. Brent, C. Percival and P. Zimmermann (2007), Error bounds on complex floating-point multiplication, *Math. Comp.* **76**, 1469–1481.

N. Brisebarre and S. Chevillard (2007), Efficient polynomial L-approximations, in *18th IEEE Symposium on Computer Arithmetic*, pp. 169–176.

N. Brisebarre and J.-M. Muller (2008), Correctly rounded multiplication by arbitrary precision constants, *IEEE Trans. Comput.* **57**, 165–174.

N. Brisebarre, G. Hanrot and O. Robert (2017), Exponential sums and correctly-rounded functions, *IEEE Trans. Comput.* **66**, 2044–2057.

N. Brisebarre, M. Joldeş, J.-M. Muller, A.-M. Nanes and J. Picot (2020), Error analysis of some operations involved in the Cooley–Tukey fast Fourier transform, *ACM Trans. Math. Softw.* **46**, 11:1–11:27.

N. Brunie, F. de Dinechin, O. Kupriianova and C. Lauter (2015), Code generators for mathematical functions, in *22nd IEEE Symposium on Computer Arithmetic*, pp. 66–73.
T. R. Cameron and S. Graillat (2022), On a compensated Ehrlich–Aberth method for the accurate computation of all polynomial roots, *Electron. Trans. Numer. Anal.* **55**, 401–423.

A. M. Castaldo, R. C. Whaley and A. T. Chronopoulos (2009), Reducing floating point error in dot product using the superblock family of algorithms, *SIAM J. Sci. Comput.* **31**, 1156–1174.

P. E. Ceruzzi (1981), The early computers of Konrad Zuse, 1935 to 1945, *Ann. Hist. Comput.* **3**, 241–262.

W. P. Champagne (1964), On finding roots of polynomials by hook or by crook. MSc thesis, University of Texas, Austin, TX.

S. Chevillard, J. Harrison, M. Joldeş and C. Lauter (2011), Efficient and accurate computation of upper bounds of approximation errors, *Theoret. Comput. Sci.* **412**, 1523–1543.

S. Chevillard, M. Joldeş and C. Lauter (2010), Sollya: An environment for the development of numerical codes, in *International Conference on Mathematical Software* (K. Fukuda et al., eds), Vol. 6327 of Lecture Notes in Computer Science, Springer, pp. 28–31.

E. Chung, J. Fowers, K. Ovtcharov, M. Papamichael, A. Caulfield, T. Massengill, M. Liu, D. Lo, S. Alkalay, M. Haselman, M. Abeydeera, L. Adams, H. Angepat, C. Boehn, D. Chiou, O. Firestein, A. Forin, K. S. Gatlin, M. Ghandi, S. Heil, K. Holohan, A. El Husseini, T. Juhasz, K. Kagi, R. K. Kovvuri, S. Lanka, F. van Megen, D. Mukhortov, P. Patel, B. Perez, A. Rapsang, S. Reinhardt, B. Rouhani, A. Sapek, R. Seera, S. Shekar, B. Sridharan, G. Weisz, L. Woods, P. Yi Xiao, D. Zhang, R. Zhao and D. Burger (2018), Serving DNNs in real time at datacenter scale with project brainwave, *IEEE Micro* **38**, 8–20.

J. Cocke and V. Markstein (1990), The evolution of RISC technology at IBM, *IBM J. Res. Dev.* **34**, 4–11.

M. Cococcioni, F. Rossi, E. Ruffaldi and S. Saponara (2022), Small reals representations for deep learning at the edge: A comparison, in *Next Generation Arithmetic* (J. Gustafson and V. Dimitrov, eds), Springer, pp. 117–133.

W. J. Cody and W. Waite (1980), *Software Manual for the Elementary Functions*, Prentice-Hall.

C. Collange, D. Defour, S. Graillat and R. Iakymchuk (2015), Numerical reproducibility for the parallel reduction on multi- and many-core architectures, *Parallel Comput.* **49**, 83–97.

M. P. Connolly and N. J. Higham (2022), Probabilistic rounding error analysis of Householder QR factorization. MIMS EPrint 2022.5, Manchester Institute for Mathematical Sciences, The University of Manchester, UK. Available at http://eprints.maths.manchester.ac.uk/2865/.

M. P. Connolly, N. J. Higham and T. Mary (2021), Stochastic rounding and its probabilistic backward error analysis, *SIAM J. Sci. Comput.* **43**, A566–A585.

M. P. Connolly, N. J. Higham and S. Pranesh (2022), Randomized low rank matrix approximation: Rounding error analysis and a mixed precision algorithm. MIMS EPrint 2022.10, Manchester Institute for Mathematical Sciences, The University of Manchester, UK. Available at http://eprints.maths.manchester.ac.uk/2863/.

M. A. Cornea-Hasegan, R. A. Golliver and P. Markstein (1999), Correctness proofs outline for Newton–Raphson based floating-point divide and square root algorithms, in *14th IEEE Symposium on Computer Arithmetic*, pp. 96–105.

M. Cornea, J. Harrison and P. T. P. Tang (2002), *Scientific Computing on Itanium®-based Systems*, Intel Press.
M. Croci, M. Fasi, N. J. Higham, T. Mary and M. Mikaitis (2022), Stochastic rounding: implementation, error analysis and applications, *Royal Soc. Open Sci.* **9**, 1–25.

J. Darcy (2017), Restore always-strict floating-point semantics. Technical report JEP 306.

M. Daumas (1999), Multiplications of floating point expansions, in *14th IEEE Symposium on Computer Arithmetic*, pp. 250–257.

M. Daumas, L. Rideau and L. Théry (2001), A generic library of floating-point numbers and its application to exact computing, in *14th International Conference on Theorem Proving in Higher Order Logics* (R. J. Boulton and P. B. Jackson, eds), Vol. 2152 of Lecture Notes in Computer Science, Springer, pp. 169–184.

F. de Dinechin, L. Forget, J.-M. Muller and Y. Uguen (2019), Posits: The good, the bad and the ugly, in *Conference on Next-Generation Arithmetic*, ACM Press, pp. 1–10.

F. de Dinechin, C. Lauter and G. Melquiond (2011), Certifying the floating-point implementation of an elementary function using Gappa, *IEEE Trans. Comput.* **60**, 242–253.

T. J. Dekker (1971), A floating-point technique for extending the available precision, *Numer. Math.* **18**, 224–242.

J. Demmel (1984), Underflow and the reliability of numerical software, *SIAM J. Sci. Statist. Comput.* **5**, 887–919.

J. Demmel, P. Ahrens and H. D. Nguyen (2016), Efficient reproducible floating point summation and BLAS. Technical report UCB/EECS-2016-121, EECS Department, University of California, Berkeley.

J. Demmel and Y. Hida (2004), Fast and accurate floating point summation with application to computational geometry, *Numer. Algorithms* **37**, 101–112.

J. Demmel and H. D. Nguyen (2015), Parallel reproducible summation, *IEEE Trans. Comput.* **64**, 2060–2070.

J. Demmel and J. Riedy (2021), A new IEEE 754 standard for floating-point arithmetic in an ever-changing world, *SIAM News* **54**, 9.

J. Demmel, J. Dongarra, M. Gates, G. Henry, J. Langou, X. Li, P. Luszczek, W. Pereira, J. Riedy and C. Rubio-González (2022), Proposed consistent exception handling for the BLAS and LAPACK. Available at arXiv:2207.09281.

E.-M. El Arar, D. Sohier, P. de Oliveira Castro and E. Petit (2022), The positive effects of stochastic rounding in numerical algorithms, in *29th IEEE Symposium on Computer Arithmetic*, pp. 58–65.

N. Fabiano, J.-M. Muller and J. Picot (2019), Algorithms for triple-word arithmetic, *IEEE Trans. Comput.* **68**, 1573–1583.

M. Fasi and M. Mikaitis (2020), CPFloat: A C library for simulating low-precision arithmetic. MIMS EPrint 2020.22, Manchester Institute for Mathematical Sciences, The University of Manchester, UK. Available at http://eprints.maths.manchester.ac.uk/2873/.

M. Fasi, N. J. Higham, M. Mikaitis and S. Pranesh (2021), Numerical behavior of NVIDIA tensor cores, *PeerJ Comput. Sci.* **7**, e330.

F. Févotte and B. Lathuilière (2016), VERROU: Assessing floating-point accuracy without recompiling. Available at https://hal.archives-ouvertes.fr/hal-01383417.

S. A. Figueroa (1995), When is double rounding innocuous?, *ACM SIGNUM Newsletter* **30**, 21–26.

G. Flegg, C. Hay and B. Moss (1985), *Nicolas Chuquet, Renaissance Mathematician: A Study With Extensive Translation of Chuquet's Mathematical Manuscript Completed in 1484*, Springer.

G. E. Forsythe (1959), Reprint of a note on rounding-off errors, *SIAM Review* **1**, 66–67.
S. Fortune and C. J. Van Wyk (1993), Efficient exact arithmetic for computational geometry, in *9th Annual Symposium on Computational Geometry*, ACM, pp. 163–172.

L. Fousse, G. Hanrot, V. Lefèvre, P. Pélissier and P. Zimmermann (2007), MPFR: A multiple-precision binary floating-point library with correct rounding, *ACM Trans. Math. Softw.* **33**, 13–es.

P. Friedland (1967), Algorithm 312: Absolute value and square root of a complex number, *Commun. Assoc. Comput. Mach.* **10**, 665.

S. Gill (1951), A process for the step-by-step integration of differential equations in an automatic digital computing machine, *Math. Proc. Cambridge Philos. Soc.* **47**, 96–108.

D. Goldberg (1991), What every computer scientist should know about floating-point arithmetic, *ACM Computing Surveys* **23**, 5–48. Edited reprint available at https://docs.oracle.com/cd/E19059-01/fortec6u2/806-7996/806-7996.pdf from Sun's Numerical Computation Guide; it contains an addendum *Differences Among IEEE 754 Implementations*, also available at http://www validlab.com/goldberg/addendum.html.

I. B. Goldberg (1967), 27 bits are not enough for 8-digit accuracy, *Commun. Assoc. Comput. Mach.* **10**, 105–106.

F. Goualard (2014), How do you compute the midpoint of an interval?, *ACM Trans. Math. Softw.* **40**, 11:1–11:25.

F. Goualard (2022), Drawing random floating-point numbers from an interval, *ACM Trans. Model. Comput. Simul.* **32**, 16:1–16:24.

S. Graillat and V. Ménissier-Morain (2007), Error-free transformations in real and complex floating-point arithmetic, in *2007 International Symposium on Nonlinear Theory and its Applications*, pp. 341–344.

S. Graillat and V. Ménissier-Morain (2008), Compensated Horner scheme in complex floating point arithmetic, in *8th Conference on Real Numbers and Computer*, pp. 133–146.

S. Graillat and V. Ménissier-Morain (2012), Accurate summation, dot product and polynomial evaluation in complex floating-point arithmetic, *Inform. Comput.* **216**, 57–71.

S. Graillat, V. Lefèvre and J.-M. Muller (2020), Alternative split functions and Dekker's product, in *27th IEEE Symposium on Computer Arithmetic*, pp. 41–47.

R. T. Gregory and J. L. Raney (1964), Floating-point arithmetic with 84-bit numbers, *Commun. Assoc. Comput. Mach.* **7**, 10–13.

J. L. Gustafson (2015), *The End of Error: Unum Computing*, Chapman & Hall / CRC.

E. Hallman and I. C. F. Ipsen (2022), Precision-aware deterministic and probabilistic error bounds for floating point summation. Available at arXiv:2203.15928.

J. Harrison (1999), A machine-checked theory of floating point arithmetic, in *12th International Conference in Theorem Proving in Higher Order Logics* (Y. Bertot et al., eds), Vol. 1690 of Lecture Notes in Computer Science, Springer, pp. 113–130.

J. R. Hauser (1996), Handling floating-point exceptions in numeric programs, *ACM Trans. Program. Lang. Syst.* **18**, 139–174.

Y. He and C. H. Q. Ding (2000), Using accurate arithmetics to improve numerical reproducibility and stability in parallel applications, in *14th International Conference on Supercomputing*, ACM, pp. 225–234.

J. L. Hennessy and D. A. Patterson (2012), *Computer Architecture: A Quantitative Approach*, fifth edition, Morgan Kaufman.

G. Henry, P. T. P. Tang and A. Heinecke (2019), Leveraging the bfloat16 artificial intelligence datatype for higher-precision computations, in *26th IEEE Symposium on Computer Arithmetic*, pp. 69–76.
Y. Hida, X. S. Li and D. H. Bailey (2001), Algorithms for quad-double precision floating-point arithmetic, in *15th IEEE Symposium on Computer Arithmetic*, pp. 155–162.

N. J. Higham (1993), The accuracy of floating point summation, *SIAM J. Sci. Comput.* **14**, 783–799.

N. J. Higham (2002), *Accuracy and Stability of Numerical Algorithms*, second edition, SIAM.

N. J. Higham (2021a), The mathematics of floating-point arithmetic, *LMS Newsletter* **493**, 35–41.

N. J. Higham (2021b), Numerical stability of algorithms at extreme scale and low precisions. MIMS EPrint 2021.14, Manchester Institute for Mathematical Sciences, The University of Manchester, UK. Available at http://eprints.maths.manchester.ac.uk/id/eprint/2833.

N. J. Higham and T. Mary (2019), A new approach to probabilistic rounding error analysis, *SIAM J. Sci. Comput.* **41**, A2815–A2835.

N. J. Higham and T. Mary (2020), Sharper probabilistic backward error analysis for basic linear algebra kernels with random data, *SIAM J. Sci. Comput.* **42**, A3427–A3446.

N. J. Higham and T. Mary (2022), Mixed precision algorithms in numerical linear algebra, *Acta Numer.* **31**, 347–414.

N. J. Higham and S. Pranesh (2019), Simulating low precision floating-point arithmetic, *SIAM J. Sci. Comput.* **41**, C585–C602.

A. Hirshfeld (2009), *Eureka Man: The Life and Legacy of Archimedes*, Walker & Company.

T. E. Hull, T. F. Fairgrieve and P. T. P. Tang (1994), Implementing complex elementary functions using exception handling, *ACM Trans. Math. Softw.* **20**, 215–244.

IEEE (2015), *IEEE Standard for Interval Arithmetic (IEEE Std 1788-2015)*, IEEE.

IEEE (2019), *IEEE Standard for Floating-Point Arithmetic (IEEE Std 754-2019)*, IEEE.

G. Iffrah (1999), *The Universal History of Numbers: From Prehistory to the Invention of the Computer*, Wiley.

Y. Ikebe (1965), Note on triple-precision floating-point arithmetic with 132-bit numbers, *Commun. Assoc. Comput. Mach.* **8**, 175–177.

V. Innocente and P. Zimmermann (2022), Accuracy of mathematical functions in single, double, extended double and quadruple precision. Available at [hal-03141101](https://hal-03141101).

Intel (2018), BFLOAT16: Hardware numerics definition. White Paper, available at [https://www.intel.com/content/dam/develop/external/us/en/documents/bf16-hardware-numerics-definition-white-paper.pdf](https://www.intel.com/content/dam/develop/external/us/en/documents/bf16-hardware-numerics-definition-white-paper.pdf).

International Organization for Standardization (2010), *Programming Languages – Fortran – Part 1: Base language*, International Standard ISO/IEC 1539-1:2010.

International Organization for Standardization, Geneva, Switzerland (2011), *Programming Languages – C*, International Standard ISO/IEC 9899:2011.

I. C. F. Ipsen and H. Zhou (2020), Probabilistic error analysis for inner products, *SIAM J. Matrix Anal. Appl.* **41**, 1726–1741.

ISO/IEC (2022), C programming language – N3054, working draft of the standard (September 2022). [https://en.wikipedia.org/wiki/C2](https://en.wikipedia.org/wiki/C2).

C.-P. Jeannerod (2016), A radix-independent error analysis of the Cornea–Harrison–Tang method, *ACM Trans. Math. Softw.* **42**, 19:1–19:20.

C.-P. Jeannerod (2020), The relative accuracy of $(x+y)*(x-y)$, *J. Comput. Appl. Math.* **369**, 112613.
C.-P. Jeannerod and J.-M. Muller (2017), On the relative error of computing complex square roots in floating-point arithmetic, in *51st Asilomar Conference on Signals, Systems, and Computers*, IEEE, pp. 737–740.

C.-P. Jeannerod and S. M. Rump (2018), On relative errors of floating-point operations: optimal bounds and applications, *Math. Comp.* **87**, 803–819.

C.-P. Jeannerod, P. Kornerup, N. Louvet and J.-M. Muller (2017a), Error bounds on complex floating-point multiplication with an FMA, *Math. Comp.* **86**, 881–898.

C.-P. Jeannerod, N. Louvet and J.-M. Muller (2013a), Further analysis of Kahan’s algorithm for the accurate computation of $2 \times 2$ determinants, *Math. Comp.* **82**, 2245–2264.

C.-P. Jeannerod, N. Louvet and J.-M. Muller (2013b), On the componentwise accuracy of complex floating-point division with an FMA, in *21st IEEE Symposium on Computer Arithmetic* (A. Nannarelli et al., eds), pp. 83–90.

C.-P. Jeannerod, N. Louvet, J.-M. Muller and A. Plet (2016), Sharp error bounds for complex floating-point inversion, *Numer. Algorithms* **73**, 735–760.

C.-P. Jeannerod, C. Monat and L. Thévenoux (2017b), More accurate complex multiplication for embedded processors, in *12th IEEE International Symposium on Industrial Embedded Systems*, pp. 1–4.

C.-P. Jeannerod, J.-M. Muller and P. Zimmermann (2018), On various ways to split a floating-point number, in *25th IEEE Symposium on Computer Arithmetic*, IEEE, pp. 53–60.

H. Jiang, S. Graillat, R. Barrio and C. Yang (2016), Accurate, validated and fast evaluation of elementary symmetric functions and its application, *Appl. Math. Comput.* **273**, 1160–1178.

F. Johansson (2013), Arb: A C library for ball arithmetic, *ACM Commun. Comput. Algebra* **47**, 166–169.

M. Joldeş, J.-M. Muller and V. Popescu (2017), Tight and rigorous error bounds for basic building blocks of double-word arithmetic, *ACM Trans. Math. Softw.* **44**, 1–27.

M. Joldeş, J.-M. Muller, V. Popescu and W. Tucker (2016), CAMPARY: Cuda multiple precision arithmetic library and applications, in *5th International Congress on Mathematical Software* (G. M. Greuel et al., eds), Vol. 9725 of Lecture Notes in Computer Science, Springer, pp. 232–240.

W. Kahan (1965), Pracniques: Further remarks on reducing truncation errors, *Commun. Assoc. Comput. Mach.* **8**, 40.

W. Kahan (1981), Why do we need a floating-point arithmetic standard? Technical report, Computer Science, UC Berkeley. Available at http://www.cs.berkeley.edu/~wkahan/ieee754status/why-ieee.pdf.

W. Kahan (1987), Branch cuts for complex elementary functions or much ado about nothing’s sign bit, in *The State of the Art in Numerical Analysis* (A. Iserles and M. J. D. Powell, eds), Oxford University Press, pp. 165–211.

W. Kahan (1997), Lecture notes on the status of IEEE standard 754 for binary floating-point arithmetic. Available at http://www.cs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF.

W. Kahan (1998), Matlab’s loss is nobody’s gain. Available at https://people.eecs.berkeley.edu/~wkahan/MxMulEps.pdf.

W. Kahan (2004a), A logarithm too clever by half. Available at http://http.cs.berkeley.edu/~wkahan/LOG10HAF.TXT.
W. Kahan (2004b), On the cost of floating-point computation without extra-precise arithmetic. Available at http://www.cs.berkeley.edu/~wkahan/Qdrtcs.pdf.

W. Kahan and J. W. Thomas (1991), Augmenting a programming language with complex arithmetic. Technical report UCB/CSD-92-667, EECS Department, University of California, Berkeley.

R. Karpinsky (1985), *PARANOIA: A floating-point benchmark*, *BYTE* **10**, 223.

D. E. Knuth (1998), *The Art of Computer Programming*, Vol. 2, third edition, Addison-Wesley.

P. Kornerup, V. Lefèvre, N. Louvet and J.-M. Muller (2012), On the computation of correctly rounded sums, *IEEE Trans. Comput. 61*, 289–298. A proof of Theorems 2 and 3 can be found at https://hal.inria.fr/inria-00475279.

T. Kouya (2019), Performance evaluation of an efficient double-double BLAS1 function with error-free transformation and its application to explicit extrapolation methods, in *26th IEEE Symposium on Computer Arithmetic*, pp. 120–123.

H. Kuki and W. J. Cody (1973), A statistical study of the accuracy of floating point number systems, *Commun. Assoc. Comput. Mach.* **16**, 223–230.

U. Kulisch (1971), An axiomatic approach to rounded computations, *Numer. Math.* **18**, 1–17.

U. Kulisch (2013), *Computer Arithmetic and Validity: Theory, Implementation, and Applications*, Vol. 33 of Studies in Mathematics, De Gruyter.

M. La Porte and J. Vignes (1974), Error analysis in computing, in *Information Processing* **74**, North-Holland.

M. Lange (2022), Toward accurate and fast summation, *ACM Trans. Math. Softw.* **48**, 1–39.

M. Lange and S. Oishi (2020), A note on Dekker’s FastTwoSum algorithm, *Numer. Math.* **145**, 383–403.

M. Lange and S. M. Rump (2017), Error estimates for the summation of real numbers with application to floating-point summation, *BIT Numer. Math.* **57**, 927–941.

M. Lange and S. M. Rump (2019), Sharp estimates for perturbation errors in summations, *Math. Comp.* **88**, 349–368.

M. Lange and S. M. Rump (2020), Faithfully rounded floating-point computations, *ACM Trans. Math. Softw.* **46**, 1–20.

P. Langlois and N. Louvet (2007), How to ensure a faithful polynomial evaluation with the compensated Horner algorithm, in *18th IEEE Symposium on Computer Arithmetic*, pp. 141–149.

O. Lawlor, H. Govind, I. Dooley, M. Breitenfeld and L. Kale (2005), Performance degradation in the presence of subnormal floating-point values, in *International Workshop on Operating System Interference in High Performance Application*.

V. Lefèvre (2013), SIPE: Small Integer Plus Exponent, in *21th IEEE Symposium on Computer Arithmetic*, pp. 99–106.

V. Lefèvre and J.-M. Muller (2001), Worst cases for correct rounding of the elementary functions in double precision, in *15th IEEE Symposium on Computer Arithmetic*, pp. 111–118.

V. Lefèvre, N. Louvet, J.-M. Muller, J. Picot and L. Rideau (2022), Accurate calculation of Euclidean norms using double-word arithmetic, *ACM Trans. Math. Softw.* https://doi.org/10.1145/3568672.
X. Li, J. Demmel, D. H. Bailey, G. Henry, Y. Hida, J. Iskandar, W. Kahan, A. Kapur, M. Martin, T. Tung and D. J. Yoo (2000), Design, implementation and testing of extended and mixed precision BLAS. Technical report 45991, Lawrence Berkeley National Laboratory. Available at https://netlib.org/lapack/lawnspdf/lawn149.pdf.

C. Lichtenau, A. Buyuktosunoglu, R. Bertran, P. Figuli, C. Jacobi, N. Papandreou, H. Pozidis, A. Saporito, A. Sica and E. Tzortzatos (2022), AI accelerator on IBM Telum processor: Industrial product, in *49th ACM International Symposium on Computer Architecture*, ACM, pp. 1012–1028.

R. J. Lohner (2001), On the ubiquity of the wrapping effect in the computation of error bounds, in *Perspectives on Enclosure Methods* (U. Kulisch et al., eds), Springer, pp. 201–216.

T. Lynch and E. Swartzlander (1992), A formalization for computer arithmetic, in *Computer Arithmetic and Enclosure Methods* (L. Atanassova and J. Hertzberger, eds), Elsevier Science, pp. 137–145.

M. A. Malcolm (1971), On accurate floating-point summation, *Commun. Assoc. Comput. Mach.* **14**, 731–736.

P. Markstein (1990), Computation of elementary functions on the IBM RISC System/6000 processor, *IBM J. Res. Dev.* **34**, 111–119.

W. F. Mascarenhas (2016), Floating point numbers are real numbers. Available at arXiv:1605.09202.

D. W. Matula (1968), In-and-out conversions, *Commun. Assoc. Comput. Mach.* **11**, 47–50.

G. Melquiond (2019), Formal verification for numerical computations, and the other way around. Habilitation à Diriger des Recherches, Université Paris Sud, Orsay.

M. Mezzarobba (2010), NumGfun: A package for numerical and analytic computation with D-finite functions, in *Proceedings of the 2010 International Symposium on Symbolic and Algebraic Computation*, ACM, pp. 139–145.

M. Mezzarobba (2020), Rounding error analysis of linear recurrences using generating series. Available at arXiv:2011.00827.

P. Micikevicius, D. Stosic, N. Burgess, M. Cornea, P. Dubey, R. Grisenthwaite, S. Ha, A. Heinecke, P. Judd, J. Kamalu, N. Mellempudi, S. Oberman, M. Shoeybi, M. Siu and H. W (2022), FP8 formats for deep learning. Available at https://paperswithcode.com/paper/fp8-formats-for-deep-learning.

O. Møller (1965), Quasi double-precision in floating-point addition, *BIT* **5**, 37–50.

D. Monniaux (2008), The pitfalls of verifying floating-point computations, *ACM Trans. Program. Lang. Syst.* **30**, 1–41.

J. S. Moore, T. Lynch and M. Kaufmann (1998), A mechanically checked proof of the correctness of the kernel of the AMD5K86 floating point division algorithm, *IEEE Trans. Comput.* **47**, 913–926.

R. E. Moore (1979), *Methods and Applications of Interval Analysis*, SIAM Studies in Applied Mathematics, SIAM.

R. E. Moore, R. B. Kearfott and M. J. Cloud (2009), *Introduction to Interval Analysis*, SIAM.

J.-M. Muller (2015), On the error of computing $ab+cd$ using Cornea, Harrison and Tang’s method, *ACM Trans. Math. Softw.* **41**, 7:1–7:8.

J.-M. Muller (2016), *Elementary Functions, Algorithms and Implementation*, third edition, Birkhäuser.
J.-M. Muller and L. Rideau (2022), Formalization of double-word arithmetic, and comments on ‘Tight and rigorous error bounds for basic building blocks of double-word arithmetic’, *ACM Trans. Math. Softw.* **48**, 1–24.

J.-M. Muller, N. Brunie, F. de Dinechin, C.-P. Jeannerod, M. Joldeş, V. Lefèvre, G. Melquiond, N. Revol and S. Torres (2018), *Handbook of Floating-Point Arithmetic*, second edition, Birkhäuser.

A. Neumaier (1974), *Rundungsfehleranalyse einiger Verfahren zur Summation endlicher Summen*, ZAMM **54**, 39–51. In German.

A. Neumaier (1990), *Interval Methods for Systems of Equations*, Cambridge University Press.

Y. Nievergelt (2003), Scalar fused multiply-add instructions produce floating-point matrix arithmetic provably accurate to the penultimate digit, *ACM Trans. Math. Softw.* **29**, 27–48.

B. Noune, P. Jones, D. Justus, D. Masters and C. Luschi (2022), 8-bit numerical formats for deep neural networks. Available at arXiv:2206.02915.

T. Ogita, S. M. Rump and S. Oishi (2005), Accurate sum and dot product, *SIAM J. Sci. Comput.* **26**, 1955–1988.

F. W. J. Olver (1983), Error analysis of complex arithmetic, in *Computational Aspects of Complex Analysis*, Vol. 102 of NATO Science Series C, D. Reidel, pp. 279–292.

J. Osorio, A. Armejach, E. Petit, G. Henry and M. Casas (2022), A BF16 FMA is all you need for DNN training, *IEEE Trans. Emerg. Topics Comput.* **10**, 1302–1314.

M. L. Overton (2001), *Numerical Computing with IEEE Floating Point Arithmetic*, SIAM.

K. Ozaki, T. Ogita and D. Mukunoki (2021), Interval matrix multiplication using fast low-precision arithmetic on GPU, in *9th International Workshop on Reliable Engineering Computing*, pp. 419–434.

K. Ozaki, T. Ogita, S. Oishi and S. M. Rump (2012), Error-free transformations of matrix multiplication by using fast routines of matrix multiplication and its applications, *Numer. Algorithms* **59**, 95–118.

D. S. Parker, B. Pierce and P. R. Eggert (2000), Monte Carlo arithmetic: How to gamble with floating point and win, *Comput. Sci. Engng* **2**, 58–68.

M. Pichat (1972), Correction d'une somme en arithmétique à virgule flottante, *Numer. Math.* **19**, 400–406. In French.

M. Pichat (1976), Contribution à l'étude des erreurs d'arrondi en arithmétique à virgule flottante. PhD thesis, Université Scientifique et Médicale de Grenoble & Institut National Polytechnique de Grenoble.

S. Pion (1999), De la géométrie algorithmique au calcul géométrique. PhD dissertation, Université Nice Sophia Antipolis.

V. Popescu (2017), Towards fast and certified multiple-precision librairies. PhD dissertation, Université de Lyon, no. 2017LYSEN036.

Posit Working Group (2022), Standard for posit arithmetic. Available at https://github.org/docs/posit_standard-2.pdf.

D. M. Priest (1991), Algorithms for arbitrary precision floating point arithmetic, in *10th IEEE Symposium on Computer Arithmetic*, pp. 132–143.

D. M. Priest (1992), On properties of floating-point arithmetics: Numerical stability and the cost of accurate computations. PhD thesis, University of California at Berkeley.

D. M. Priest (2004), Efficient scaling for complex division, *ACM Trans. Math. Softw.* **30**, 389–401.
N. Revol and F. Rouillier (2005), Motivations for an arbitrary precision interval arithmetic and the MPFI library, *Reliable Computing* **11**, 275–290.

E. J. Riedy and J. Demmel (2018), Augmented arithmetic operations proposed for IEEE-754 2018, in *25th IEEE Symposium on Computer Arithmetic*, pp. 45–52.

P. Roux (2014), Innocuous double rounding of basic arithmetic operations, *J. Formal. Reasoning* **7**, 131–142.

S. M. Rump (2009), Ultimately fast accurate summation, *SIAM J. Sci. Comput.* **31**, 3466–3502.

S. M. Rump (2010), Verification methods: Rigorous results using floating-point arithmetic, *Acta Numer.* **19**, 287–449.

S. M. Rump (2012), Error estimation of floating-point summation and dot product, *BIT Numer. Math.* **52**, 201–220.

S. M. Rump (2015), Computable backward error bounds for basic algorithms in linear algebra, *Nonlinear Theory Appl. IEICE* **6**, 360–363.

S. M. Rump (2017), IEEE754 precision-*k* base-*β* arithmetic inherited by precision-*m* base-*β* arithmetic for *k* < *m*, *ACM Trans. Math. Softw.* **43**, 20:1–20:15.

S. M. Rump (2019), Error bounds for computer arithmetics, in *26th IEEE Symposium on Computer Arithmetic*, pp. 1–14.

S. M. Rump, T. Ogita and S. Oishi (2008), Accurate floating-point summation, I: Faithful rounding, *SIAM J. Sci. Comput.* **31**, 189–224.

S. M. Rump, P. Zimmermann, S. Boldo and G. Melquiond (2009), Computing predecessor and successor in rounding to nearest, *BIT Numer. Math.* **49**, 419–431.

C. Severance (1998), IEEE 754: An interview with William Kahan, *Computer* **31**, 114–115.

J. R. Shewchuk (1997), Adaptive precision floating-point arithmetic and fast robust geometric predicates, *Discrete Comput. Geom.* **18**, 305–363.

N. Shibata and F. Petrogalli (2020), SLEEF: A portable vectorized library of C standard mathematical functions, *IEEE Trans. Parallel Distrib. Syst.* **31**, 1316–1327.

A. Sibidanov, P. Zimmermann and S. Glondu (2022), The CORE-MATH project, in *29th IEEE Symposium on Computer Arithmetic*, pp. 26–34.

R. L. Smith (1962), Algorithm 116: Complex division, *Commun. Assoc. Comput. Mach.* **5**, 435.

G. L. Steele Jr and J. L. White (2004), Retrospective: How to print floating-point numbers accurately, *ACM SIGPLAN Notices* **39**, 372–389.

P. H. Sterbenz (1974), *Floating-Point Computation*, Prentice-Hall.

G. W. Stewart (1985), A note on complex division, *ACM Trans. Math. Softw.* **11**, 238–241.

C. Strachey (1959), On taking the square root of a complex number, *Comput. J.* **2**, 89.

X. Sun, N. Wang, C.-Y. Chen, J. Ni, A. Agrawal, X. Cui, S. Venkataramani, K. El Maghraoui, V. V. Srinivasan and K. Gopalakrishnan (2020), Ultra-low precision 4-bit training of deep neural networks, in *Advances in Neural Information Processing Systems 33* (H. Larochelle et al., eds), Curran Associates, pp. 1796–1807.

E. E. Swartzlander and A. G. Alexpoulos (1975), The sign-logarithm number system, *IEEE Trans. Comput.* Reprinted in E. E. Swartzlander, *Computer Arithmetic*, Vol. 1, IEEE, 1990.

Y. Uguen and F. de Dinechin (2017), Design-space exploration for the Kulisch accumulator. Available at [hal-01488916](https://hal.inria.fr/Halshal-01488916).

G. W. Veltkamp (1968), ALGOL procedures voor het berekenen van een inwendig product in dubbele precisie. Technical report 22, RC-Informatie, Technische Hogeschool Eindhoven.
G. W. Veltkamp (1969), ALGOL procedures voor het rekenen in dubbele lengte. Technical report 21, RC-Informatie, Technische Hogeschool Eindhoven.

S. Wang and P. Kanwar (2019), Bfloat16: The secret to high performance on cloud TPUs. Available at https://cloud.google.com/blog/products/ai-machine-learning/bfloat16-the-secret-to-high-performance-on-cloud-tpus.

R. C. Whaley, A. Petitet and J. J. Dongarra (2001), Automated empirical optimizations of software and the ATLAS project, *Parallel Comput.* **27**, 3–35.

J. H. Wilkinson (1960), Error analysis of floating-point computation, *Numer. Math.* **2**, 319–340.

J. H. Wilkinson (1961), Error analysis of direct methods of matrix inversion, *J. Assoc. Comput. Mach.* **8**, 281–330.

J. H. Wilkinson (1963), *Rounding Errors in Algebraic Processes*, Notes on Applied Science no. 32, HMSO. Also published by Prentice-Hall. Reprinted by Dover, 1994.

J. H. Wilkinson (1965), *The Algebraic Eigenvalue Problem*, Oxford University Press.

J. M. Wolfe (1964), Reducing truncation errors by programming, *Commun. Assoc. Comput. Mach.* **7**, 355–356.

I. Yamazaki, S. Tomov and J. Dongarra (2015), Mixed-precision Cholesky QR factorization and its case studies on multicore CPU with multiple GPUs, *SIAM J. Sci. Comput.* **37**, C307–C330.

A. Ziv (1999), Sharp ULP rounding error bound for the hypotenuse function, *Math. Comp.* **68**, 1143–1148.