

Machine {base}                               R Documentation

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

_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
     largest double or integer and the machine's precision.

     `.Machine' is a variable holding this information.

_U_s_a_g_e_:

     Machine()
     .Machine

_D_e_t_a_i_l_s_:

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

_V_a_l_u_e_:

     `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.

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

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

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

     `machine' to determine the computer type which 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

