

   MMaacchhiinnee CChhaarraacctteerriissttiiccss

        Machine()
        .Machine

   DDeessccrriippttiioonn::

        `Machine()' returns information on numeric characteris-
        tics 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.

        The algorithm is based on Cody's subroutine MACHAR (see
        the reference below).

   VVaalluuee::

        `Machine()' returns a list with components (for sim-
        plicity, the prefix ``double'' is omitted in the expla-
        nations)

   double.eps: the smallest positive floating-point number `x'
             such that `1 + x != 1'.  It equals `base^ulp.dig-
             its' 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.  Typ-
             ically, 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-normal-
             ization 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 normal-
             ized.

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

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

   RReeffeerreenncceess::

        W. J. Cody (1988), MACHAR: A Subroutine to Dynamically
        Determine Machine Parameters.  Transactions on Mathe-
        matical Software, 14, 4, 303-311.

   SSeeee AAllssoo::

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

   EExxaammpplleess::

        str(Machine())
        1 +     .Machine$double.eps != 1
        1 + .5* .Machine$double.eps == 1

