base (version 3.5.3)

# .Machine: 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`

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

## 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, all but three of the last four 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`.

## References

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

`.Platform` for details of the platform.

## Examples

Run this code
``````# NOT RUN {
.Machine
## or for a neat printout
noquote(unlist(format(.Machine)))
# }
``````

Run the code above in your browser using DataCamp Workspace