

_M_a_c_h_i_n_e _C_h_a_r_a_c_t_e_r_i_s_t_i_c_s

     Machine()
     .Machine

_D_e_s_c_r_i_p_t_i_o_n:

     `Machine()' returns information on numeric characteris-
     tics of the machine R is running on, such as the larg-
     est 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).

_V_a_l_u_e:

     `Machine()' returns a list with components (for simpli-
     city, the prefix ``double'' is omitted in the explana-
     tions)

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 `round-
          ing' 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-
          normalization shift of the floating-point signifi-
          cand 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.

_R_e_f_e_r_e_n_c_e_s:

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

_S_e_e _A_l_s_o:

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

_E_x_a_m_p_l_e_s:

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

