R: Numerical Characteristics of the Machine

.Machine {base}

R Documentation

Numerical Characteristics of the Machine

Description

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

Usage

.Machine

Details

The algorithm is based on Cody's (1988) subroutine MACHAR. As all current implementations of R use 32-bit integers and use IEC 60559 floating-point (double precision) arithmetic, the "integer" and "double" related 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.

Value

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. Normally `0`.
`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 `2^{31} - 1 = 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 (or its use was disabled when R was built), otherwise possibly `12` (most 32-bit builds), `16` (most 64-bit builds) or 8 (CPUs such as ARM where for most compilers ‘⁠long double⁠’ is identical to `double`).
`sizeof.pointer`	the number of bytes in the C `SEXP` type. Will be `4` on 32-bit builds and `8` on 64-bit builds of R.
`sizeof.time_t`	the number of bytes in the C `time_t` type: a 64-bit `time_t` (value `8`) is much preferred these days. Note that this is the type used by code in R itself, not necessarily the system type if R was configured with --with-internal-tzcode as also used on Windows.
`longdouble.eps`, `longdouble.neg.eps`, `longdouble.digits`, `...`	introduced in R 4.0.0. When `capabilities("long.double")` is true, there are 10 such `"longdouble.kind"` values, specifying the ‘⁠long double⁠’ property corresponding to its `"double.*"` counterpart. See also ‘Note’.

Note

In the (typical) case where capabilities("long.double") is true, R uses the ‘⁠long double⁠’ C type in quite a few places internally for accumulators in e.g. sum, reading non-integer numeric constants into (binary) double precision numbers, or arithmetic such as x %% y; also, ‘⁠long double⁠’ can be read by readBin.
For this reason, in that case, .Machine contains ten further components, longdouble.eps, *.neg.eps, *.digits, *.rounding *.guard, *.ulp.digits, *.neg.ulp.digits, *.exponent, *.min.exp, and *.max.exp, computed entirely analogously to their double.* counterparts, see there.

sizeof.longdouble only tells you the amount of storage allocated for a long double. Often what is stored is the 80-bit extended double type of IEC 60559, 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. There are other implementation of long double, usually in software for example on Sparc Solaris and AIX.

Note that it is legal for a platform to have a ‘⁠long double⁠’ C type which is identical to the ‘⁠double⁠’ type — this happens on ARM CPUs. In that case capabilities("long.double") will be false but on versions of R prior to 4.0.4, .Machine may contain "longdouble.kind" elements.

Source

Uses a C translation of Fortran code in the reference, modified by the R Core Team to defeat over-optimization in modern compilers.

References

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

Examples

.Machine
## or for a neat printout
noquote(unlist(format(.Machine)))

[Package base version 4.4.0 Index]