Ch2.3.3 Overflow and Underflow

• Because R's numeric data type can hold such a wide range of numbers, underflow and overflow are less likely to be a problem than they could be with other systems.
• We still need to understand risks of underflow and overflow when R is working with other operating environments.

• Underflow occurs when a number is too small, regardless of sign, to be represented as anything other than 0.
• Overflow occurs when a number is too large to be represented as a numeric type.

• Thus even at extreme lower boundary of small-scale physics and probability, the numbers involved are far larger than the lower bound of double precision.
• These exceptionally small numbers are 270 orders of magnitude larger than smallest number a double precision number can hold, but they are there if we need them.

• The internal floating point representation moves leading zeros to mantissa to avoid underflow.

0.5*.Machine$double.xmin

[1] 1.112537e-308

• These numbers are called denormalized and push underflow boundary even lower than .Machine$double.xmin.

• IEEE standard denormalizes numbers to fill the gap between 0 and the smallest normalized floating point number.
• This provides a gradual underflow to zero; see weblink.

\[ (-1)^s 2^{c-127} (1+f) \]

• The implementation of denormalization is machine dependent and may not necessarily be available.
• In practice, we are unlikely to reach the underflow boundary with a real-world problem.

• Note that .Machine$double.xmin value is substantially smaller than machine \( \epsilon \).

library(pracma)
c(.Machine$double.xmin,eps(1))

[1] 2.225074e-308  2.220446e-16

• The value of the next floating point number after \( x \) changes based on how large \( x \) is.

library(pracma)
x <- .Machine$double.xmin
c(eps(0),x)

[1] 2.225074e-308 2.225074e-308

• Strange result here:

x <- .Machine$double.xmin
c(eps(0),x,eps(x))

[1] 2.225074e-308 2.225074e-308 4.940656e-324

• Floating point numbers are closer together closer to 0.
• Interestingly, there are roughly the same number of floating point numbers between 0 and 1 as there are greater than 1.

• Overflow occurs when number is too large to be expressed.
• Like undeflow, most real-world applications do not require numbers this large.

.Machine$double.xmax

[1] 1.797693e+308

• Recall magnitude of \( \epsilon(x) \) proportional to magnitude of \( x \).

x <- .Machine$double.xmax
c(x,eps(x))

[1] 1.797693e+308           Inf

• R does not cause an error for underflow and overflow.
• It simply uses the best available option.
• For underflow, using 0 may be a good enough answer.
• For overflow, it is unlikely that infinity is a good enough answer, but it can signal that something has gone wrong.

• Not all systems will process data with double precision floating point numbers.
• R is capable of interacting with and exchanging data with systems that only support single precision arithmetic, where the limits are substantially smaller.