.Machine {base} | R Documentation |
.Machine
is a variable holding information on the numerical
characteristics of the machine R is running on, such as the largest
double or integer and the machine's precision.
.Machine
The algorithm is based on Cody's (1988) subroutine MACHAR. As all current implementations of R use 32-bit integers and almost all use IEC 60059 floating-point (double precision) arithmetic, all but the last two values are the same for almost all R builds.
Note that on most platforms smaller positive values than
.Machine$double.xmin
can occur. On a typical R platform the
smallest positive double is about 5e-324
.
A list with components
double.eps |
the smallest positive floating-point number
x such that 1 + x != 1 . It equals
double.base ^ ulp.digits if either double.base is 2 or
double.rounding is 0; otherwise, it is
(double.base ^ double.ulp.digits) / 2 . Normally
2.220446e-16 . |
double.neg.eps |
a small positive floating-point number x
such that 1 - x != 1 . It equals
double.base ^ double.neg.ulp.digits if double.base is 2
or double.rounding is 0; otherwise, it is
(double.base ^ double.neg.ulp.digits) / 2 . Normally
1.110223e-16 . As double.neg.ulp.digits is bounded
below by -(double.digits + 3) , double.neg.eps may not
be the smallest number that can alter 1 by subtraction. |
double.xmin |
the smallest non-zero normalized
floating-point number, a power of the radix, i.e.,
double.base ^ double.min.exp . Normally 2.225074e-308 . |
double.xmax |
the largest normalized floating-point number.
Typically, it is equal to (1 - double.neg.eps) *
double.base ^ double.max.exp , but
on some machines it is only the second or third largest such
number, being too small by 1 or 2 units in the last digit of the
significand. Normally 1.797693e+308 . Note that larger
unnormalized numbers can occur. |
double.base |
the radix for the floating-point representation:
normally 2 . |
double.digits |
the number of base digits in the floating-point
significand: normally 53 . |
double.rounding |
the rounding action, one of. 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. Normally 5 . |
double.guard |
the number of guard digits for multiplication
with truncating arithmetic. It is 1 if floating-point arithmetic
truncates and more than double digits base-double.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 + double.base ^ i != 1 , except that it is bounded below by
-(double.digits + 3) . Normally -52 . |
double.neg.ulp.digits |
the largest negative integer i
such that 1 - double.base ^ i != 1 , except that it is bounded
below by -(double.digits + 3) . Normally -53 . |
double.exponent |
the number of bits (decimal places if double.base is 10) reserved
for the representation of the exponent (including the bias or sign)
of a floating-point number. Normally 11 . |
double.min.exp |
the largest in magnitude negative integer i such that
double.base ^ i is positive and normalized. Normally -1022 . |
double.max.exp |
the smallest positive power of double.base that overflows. Normally
1024 . |
integer.max |
the largest integer which can be represented.
Always 2147483647 . |
sizeof.long |
the number of bytes in a C long type:
4 or 8 (most 64-bit systems, but not Windows). |
sizeof.longlong |
the number of bytes in a C long long
type. Will be zero if there is no such type, otherwise usually
8 . |
sizeof.longdouble |
the number of bytes in a C long double
type. Will be zero if there is no such type, otherwise possibly
12 (most 32-bit builds) or 16 (most 64-bit builds). |
sizeof.pointer |
the number of bytes in a C SEXP
type. Will be 4 on 32-bit builds and 8 on 64-bit
builds of R. |
sizeof.longdouble
only tells you the amount of storage
allocated for a long double (which are used internally by R for
accumulators in e.g. sum
, and can be read by
readBin
). Often what is stored is the 80-bit extended
double type of IEC 60059, padded to the double alignment used on the
platform — this seems to be the case for the common R platforms
using ix86 and x86_64 chips.
Cody, W. J. (1988) MACHAR: A subroutine to dynamically determine machine parameters. Transactions on Mathematical Software, 14, 4, 303–311.
.Platform
for details of the platform.
.Machine ## or for a neat printout noquote(unlist(format(.Machine)))