# .Machine

##### Numerical Characteristics of the Machine

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

- Keywords
- programming, math, sysdata

##### 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, 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`

.

##### Value

A list with components

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`

.

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.

the smallest non-zero normalized
floating-point number, a power of the radix, i.e.,
`double.base ^ double.min.exp`

. Normally `2.225074e-308`

.

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.

the radix for the floating-point representation:
normally `2`

.

the number of base digits in the floating-point
significand: normally `53`

.

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`

.

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`

.

the largest negative integer `i`

such
that `1 + double.base ^ i != 1`

, except that it is bounded below by
`-(double.digits + 3)`

. Normally `-52`

.

the largest negative integer `i`

such that `1 - double.base ^ i != 1`

, except that it is bounded
below by `-(double.digits + 3)`

. Normally `-53`

.

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`

.

the largest in magnitude negative integer `i`

such that
`double.base ^ i`

is positive and normalized. Normally `-1022`

.

the smallest positive power of `double.base`

that overflows. Normally
`1024`

.

the largest integer which can be represented. Always \(2^31 - 1 = 2147483647\).

the number of bytes in a C `long`

type:
`4`

or `8`

(most 64-bit systems, but not Windows).

the number of bytes in a C `long long`

type. Will be zero if there is no such type, otherwise usually
`8`

.

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

the number of bytes in a C `SEXP`

type. Will be `4`

on 32-bit builds and `8`

on 64-bit
builds of R.

##### Note

`sizeof.longdouble`

only tells you the amount of storage
allocated for a long double (which are normally 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 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.

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

##### See Also

`.Platform`

for details of the platform.

##### Examples

`library(base)`

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

*Documentation reproduced from package base, version 3.5.2, License: Part of R 3.5.2*