\Header{Machine}{Machine Characteristics}
\alias{.Machine}{Machine}
\keyword{sysdata}{Machine}
\keyword{programming}{Machine}
\keyword{math}{Machine}
\begin{Description}\relax
\code{Machine()} returns information on numeric characteristics of the
machine \R{} is running on, such as the largest double or integer and the
machine's precision.

\code{.Machine} is a variable holding this information.\end{Description}
\begin{Usage}
\begin{verbatim}
Machine()
.Machine
\end{verbatim}
\end{Usage}
\begin{Details}\relax
The algorithm is based on Cody's (1988) subroutine MACHAR.\end{Details}
\begin{Value}
\code{Machine()} returns a list with components (for simplicity, the
prefix ``double'' is omitted in the explanations)
\begin{ldescription}
\item[\code{double.eps}] the smallest positive floating-point number
\code{x} such that \code{1 + x != 1}.  It equals
\code{base$\,\hat{\,}$ulp.digits} if either \code{base} is 2 or \code{rounding}
is 0;  otherwise, it is \code{(base$\,\hat{\,}$ulp.digits) / 2}.
\item[\code{double.neg.eps}] a small positive floating-point number \code{x}
such that \code{1 - x != 1}.  It equals \code{base$\,\hat{\,}$neg.ulp.digits}
if \code{base} is 2 or \code{round} is 0;  otherwise, it is
\code{(base$\,\hat{\,}$neg.ulp.digits) / 2}.
As \code{neg.ulp.digits} is bounded below by \code{-(digits + 3)},
\code{neg.eps} may not be the smallest number that can alter 1 by
subtraction.
\item[\code{double.xmin}] the smallest non-vanishing normalized
floating-point power of the radix, i.e., \code{base$\,\hat{\,}$min.exp}.
\item[\code{double.xmax}] the largest finite floating-point number.
Typically, it is equal to \code{(1 - neg.eps) * base$\,\hat{\,}$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.
\item[\code{double.base}] the radix for the floating-point representation
\item[\code{double.digits}] the number of base digits in the floating-point
significand
\item[\code{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
\item[\code{double.guard}] the number of guard digits for multiplication
with truncating arithmetic.  It is 1 if floating-point arithmetic
truncates and more than \code{digits} base \code{base} digits
participate in the post-normalization shift of the floating-point
significand in multiplication, and 0 otherwise.
\item[\code{double.ulp.digits}] the largest negative integer \code{i} such
that \code{1 + base$\,\hat{\,}$i != 1}, except that it is bounded below by
\code{-(digits + 3)}.
\item[\code{double.neg.ulp.digits}] the largest negative integer \code{i}
such that \code{1 - base$\,\hat{\,}$i != 1}, except that it is bounded below by
\code{-(digits + 3)}.
\item[\code{double.exponent}] the number of bits (decimal places if \code{base} is 10) reserved
for the representation of the exponent (including the bias or sign)
of a floating-point number
\item[\code{double.min.exp}] the largest in magnitude negative integer \code{i} such that
\code{base $\,\hat{\,}$ i} is positive and normalized.
\item[\code{double.max.exp}] the smallest positive power of \code{base} that overflows.
\item[\code{integer.max}] the largest integer which can be represented.
\end{ldescription}
\end{Value}
\begin{References}\relax
Cody, W. J. (1988)
MACHAR: A subroutine to dynamically determine machine parameters.
\emph{Transactions on Mathematical Software}, \bold{14}, 4, 303--311.\end{References}
\begin{SeeAlso}\relax
\code{\Link{machine}} to determine the computer type which \R{} is running on.\end{SeeAlso}
\begin{Examples}
\begin{ExampleCode}
str(Machine())
(Meps <- .Machine $ double.eps)

## All the following relations must hold :
stopifnot(
 1 +     Meps != 1,
 1 + .5* Meps == 1,
 log2(.Machine$double.xmax) == .Machine$double.max.exp,
 log2(.Machine$double.xmin) == .Machine$double.min.exp,
 is.infinite(.Machine$double.base ^ .Machine$double.max.exp)
)
\end{ExampleCode}
\end{Examples}

