Machine                 package:base                 R Documentation

Machine Characteristics

Description:

     `Machine()' returns information on numeric characteristics of the
     machine R is running on, such as the largest double or integer and
     the machine's precision.

     `.Machine' is a variable holding this information.

Usage:

     Machine()
     .Machine

Details:

     The algorithm is based on Cody's (1988) subroutine MACHAR.

Value:

     `Machine()' returns a list with components (for simplicity, the
     prefix ``double'' is omitted in the explanations) 

double.eps: the smallest positive floating-point number `x' such that
          `1 + x != 1'.  It equals `base^ulp.digits' if either `base'
          is 2 or `rounding' is 0;  otherwise, it is `(base^ulp.digits)
          / 2'.

double.neg.eps: a small positive floating-point number `x' such that `1
          - x != 1'.  It equals `base^neg.ulp.digits' if `base' is 2 or
          `round' is 0;  otherwise, it is `(base^neg.ulp.digits) / 2'.
          As `neg.ulp.digits' is bounded below by `-(digits + 3)',
          `neg.eps' may not be the smallest number that can alter 1 by
          subtraction.

double.xmin: the smallest non-vanishing normalized floating-point power
          of the radix, i.e., `base^min.exp'.

double.xmax: the largest finite floating-point number. Typically, it is
          equal to `(1 - neg.eps) * base^max.exp', but on some machines
          it is only the second, or perhaps third, largest number,
          being too small by 1 or 2 units in the last digit of the
          significand.

double.base: the radix for the floating-point representation

double.digits: the number of base digits in the floating-point
          significand

double.rounding: the rounding action. 
          0 if floating-point addition chops; 
          1 if floating-point addition rounds, but not in the IEEE
          style; 
          2 if floating-point addition rounds in the IEEE style; 
          3 if floating-point addition chops, and there is partial
          underflow; 
          4 if floating-point addition rounds, but not in the IEEE
          style, and there is partial underflow; 
          5 if floating-point addition rounds in the IEEE style, and
          there is partial underflow

double.guard: the number of guard digits for multiplication with
          truncating arithmetic.  It is 1 if floating-point arithmetic
          truncates and more than `digits' base `base' digits
          participate in the post-normalization shift of the
          floating-point significand in multiplication, and 0
          otherwise.

double.ulp.digits: the largest negative integer `i' such that `1 +
          base^i != 1', except that it is bounded below by `-(digits +
          3)'.

double.neg.ulp.digits: the largest negative integer `i' such that `1 -
          base^i != 1', except that it is bounded below by `-(digits +
          3)'.

double.exponent: the number of bits (decimal places if `base' is 10)
          reserved for the representation of the exponent (including
          the bias or sign) of a floating-point number

double.min.exp: the largest in magnitude negative integer `i' such that
          `base ^ i' is positive and normalized.

double.max.exp: the smallest positive power of `base' that overflows.

integer.max: the largest integer which can be represented.

sizeof.long: the number of bytes in a C `long' type.

sizeof.longlong: the number of bytes in a C `long long' type. Will be
          zero if there is no such type.

References:

     Cody, W. J. (1988) MACHAR: A subroutine to dynamically determine
     machine parameters. Transactions on Mathematical Software, 14, 4,
     303-311.

See Also:

     `machine' to determine the computer type which R is running on.

Examples:

     str(Machine())
     (Meps <- .Machine $ double.eps)

     ## All the following relations must hold :
     stopifnot(
      1 +     Meps != 1,
      1 + .5* Meps == 1,
      log2(.Machine$double.xmax) == .Machine$double.max.exp,
      log2(.Machine$double.xmin) == .Machine$double.min.exp
     )

