Error in Ulps of the Multiplication or Division by a Correctly-Rounded Function or Constant in Binary Floating-Point Arithmetic

Assume we use a binary floating-point arithmetic and that $\operatorname{RN}$ is the round-to-nearest function. Also assume that $c$ is a constant or a real function of one or more variables, and that we have at our disposal a correctly rounded implementation of $c$, say $\hat{c}= \operatorname{RN}(c)$. For evaluating $x \cdot c$ (resp. $ x / c$ or $c / x$), the natural way is to replace it by $\operatorname{RN}(x \cdot \hat{c})$ (resp. $ \operatorname{RN}(x / \hat{c})$ or $\operatorname{RN}(\hat{c}/ x)$), that is, to call function $\hat{c}$ and to perform a floating-point multiplication or division. This can be generalized to the approximation of $n/d$ by $\operatorname{RN}(\hat{n}/\hat{d})$ and the approximation of $n \cdot d$ by $\operatorname{RN}(\hat{n} \cdot \hat{d})$, where $\hat{n} = \operatorname{RN}(n)$ and $\hat{d} = \operatorname{RN}(d)$, and $n$ and $d$ are functions for which we have at our disposal a correctly rounded implementation. We discuss tight error bounds in ulps of such approximations. From our results, one immediately obtains tight error bounds for calculations such as $\mathtt {x * pi}$, $\mathtt {ln(2)/x}$, $\mathtt {x/(y+z)}$, $\mathtt {(x+y)*z}$, $\mathtt {x/sqrt(y)}$, $\mathtt {sqrt(x)/{y}}$, $\mathtt {(x+y)(z+t)}$, $\mathtt {(x+y)/(z+t)}$, $\mathtt {(x+y)/(zt)}$, etc. in floating-point arithmetic.

I. Introduction

Multiplying a floating-point number by a real constant (such as \$\pi\$ or \$\ln (2)\$), or multiplying or dividing it by a correctly rounded function of one or more variables (such as \$\sqrt{x}\$, \$x+y\$, or \$xy\$), or dividing a constant or correctly-rounded function by a floating-point number are very frequent operations in numerical computing. When last-bit accuracy is desired, one can use specifically-designed solutions (see for instance [1] for multiplication by a constant). However, here, we are interested by the error of the straightforward approach. For instance, when a programmer writes the statement \begin{equation*} \mathtt {s = x * pi;} \end{equation*} s=x*pi;he or she most probably wants to compute \$x\cdot \pi\$ as accurately as possible. However the variable \$\mathtt {pi}\$ is already a floating-point approximation of the real \$\pi\$, and, as a result, the error in this computation is larger than the mere approximation caused by the floating-point multiplication. We are also interested in calculations such as \begin{equation*} \mathtt {s = x / sqrt(y);} \end{equation*} s=x/sqrt(y);or \begin{equation*} \mathtt {s = (x+y) * (z+t);} \end{equation*} s=(x+y)*(z+t);