Unit in the last place

This article needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. Find sources: "Unit in the last place" – news · newspapers · books · scholar · JSTOR (March 2015) (Learn how and when to remove this message)

In

The most common definition is: In radix ${\displaystyle b}$ with precision ${\displaystyle p}$, if ${\displaystyle b^{e}\leq |x|<b^{e+1}}$, then ${\displaystyle \operatorname {ulp} (x)=b^{\max\{e,\,e_{\min }\}-p+1}}$,^[2] where ${\displaystyle e_{\min }}$ is the minimal exponent of the normal numbers. In particular, ${\displaystyle \operatorname {ulp} (x)=b^{e-p+1}}$ for normal numbers, and ${\displaystyle \operatorname {ulp} (x)=b^{e_{\min }-p+1}}$ for subnormals.

Another definition, suggested by John Harrison, is slightly different: ${\displaystyle \operatorname {ulp} (x)}$ is the distance between the two closest straddling floating-point numbers ${\displaystyle a}$ and ${\displaystyle b}$ (i.e., satisfying ${\displaystyle a\leq x\leq b}$ and ${\displaystyle a\neq b}$), assuming that the exponent range is not upper-bounded.^[3][4] These definitions differ only at signed powers of the radix.^[2]

The

Since the 2010s, advances in floating-point mathematics have allowed correctly rounded functions to be almost as fast in average as these earlier, less accurate functions. A correctly rounded function would also be fully reproducible. An earlier, intermediate milestone was the 0.501 ulp functions,^[clarification needed] which theoretically would only produce one incorrect rounding out of 1000 random floating-point inputs.^[6]

Examples

Example 1

Let ${\displaystyle x}$ be a positive floating-point number and assume that the active rounding mode is

${\displaystyle \operatorname {RN} }$

${\displaystyle \operatorname {ulp} (x)\leq 1}$

${\displaystyle \operatorname {RN} (x+1)>x}$

${\displaystyle \operatorname {RN} (x+1)=x}$

${\displaystyle \operatorname {RN} (x+1)=x+\operatorname {ulp} (x)}$

${\displaystyle x}$

> until (\x -> x == x+1) (+1) 0 :: Float
1.6777216e7
> it-1
1.6777215e7
> it+1
1.6777216e7

Here we start with 0 in single precision (binary32) and repeatedly add 1 until the operation does not change the value. Since the significand for a single-precision number contains 24 bits, the first integer that is not exactly representable is 2²⁴+1, and this value rounds to 2²⁴ in round to nearest, ties to even. Thus the result is equal to 2²⁴.

Example 2

The following example in Java approximates π as a floating point value by finding the two double values bracketing ${\displaystyle \pi }$: ${\displaystyle p_{0}<\pi <p_{1}}$.

// π with 20 decimal digits
BigDecimal π = new BigDecimal("3.14159265358979323846");

// truncate to a double floating point
double p0 = π.doubleValue();
// -> 3.141592653589793  (hex: 0x1.921fb54442d18p1)

// p0 is smaller than π, so find next number representable as double
double p1 = Math.nextUp(p0);
// -> 3.1415926535897936 (hex: 0x1.921fb54442d19p1)

Then ${\displaystyle \operatorname {ulp} (\pi )}$ is determined as ${\displaystyle \operatorname {ulp} (\pi )=p_{1}-p_{0}}$.

// ulp(π) is the difference between p1 and p0
BigDecimal ulp = new BigDecimal(p1).subtract(new BigDecimal(p0));
// -> 4.44089209850062616169452667236328125E-16
// (this is precisely 2**(-51))

// same result when using the standard library function
double ulpMath = Math.ulp(p0);
// -> 4.440892098500626E-16 (hex: 0x1.0p-51)

Example 3

Another example, in Python, also typed at an interactive prompt, is:

>>> x = 1.0
>>> p = 0
>>> while x != x + 1:
...   x = x * 2
...   p = p + 1
... 
>>> x
9007199254740992.0
>>> p
53
>>> x + 2 + 1
9007199254740996.0

In this case, we start with x = 1 and repeatedly double it until x = x + 1. Similarly to Example 1, the result is 2⁵³ because the

Language support

The

The C language library provides functions to calculate the next floating-point number in some given direction: nextafterf and nexttowardf for float, nextafter and nexttoward for double, nextafterl and nexttowardl for long double, declared in <math.h>. It also provides the macros FLT_EPSILON, DBL_EPSILON, LDBL_EPSILON, which represent the positive difference between 1.0 and the next greater representable number in the corresponding type (i.e. the ulp of one).^[9]

The

The Swift standard library provides access to the next floating-point number in some given direction via the instance properties nextDown and nextUp. It also provides the instance property ulp and the type property ulpOfOne (which corresponds to C macros like FLT_EPSILON^[10]) for Swift's floating-point types.^[11]

See also

• IEEE 754
• ISO/IEC 10967, part 1 requires an ulp function
• Least significant bit
  (LSB)
• Machine epsilon
• Round-off error

References

Bibliography

Look up ulp in Wiktionary, the free dictionary.

• Goldberg, David (1991–03). "Rounding Error" in "What Every Computer Scientist Should Know About Floating-Point Arithmetic". Computing Surveys, ACM, March 1991. Retrieved from http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html#689.
• Muller, Jean-Michel (2010). Handbook of floating-point arithmetic. Boston: Birkhäuser. pp. 32–37.
  ISBN 978-0-8176-4704-9
  .