[ RDocumentation ](/)

Moon  [ ](https://github.com/datacamp/rdocumentation-2.0) [ Learn R
](https://www.datacamp.com/learn/r)

Search all packages and functions

[ base  (version  3.6.2  ) ](/packages/base/versions/3.6.2)

#  double: Double-Precision Vectors

##  Description

Create, coerce to or test for a double-precision vector.

##  Usage

    
    
    double(length = 0)
    as.double(x, …)
    is.double(x)
    
    single(length = 0)
    as.single(x, …)

##  Arguments

length

A non-negative integer specifying the desired length. Double values will be
coerced to integer: supplying an argument of length other than one is an
error.

x

object to be coerced or tested.

…

further arguments passed to or from other methods.

##  Value

` double ` creates a double-precision vector of the specified length. The
elements of the vector are all equal to ` 0 ` .

` as.double ` attempts to coerce its argument to be of double type: like ` [
as.vector ](/link/as.vector?package=base&version=3.6.2) ` it strips attributes
including names. (To ensure that an object is of double type without stripping
attributes, use ` [ storage.mode
](/link/storage.mode?package=base&version=3.6.2) ` .) Character strings
containing optional whitespace followed by either a decimal representation or
a hexadecimal representation (starting with ` 0x ` or ` 0X ` ) can be
converted, as can special values such as ` "NA" ` , ` "NaN" ` , ` "Inf" ` and
` "infinity" ` , irrespective of case.

` as.double ` for factors yields the codes underlying the factor levels, not
the numeric representation of the labels, see also ` [ factor
](/link/factor?package=base&version=3.6.2) ` .

` is.double ` returns ` TRUE ` or ` FALSE ` depending on whether its argument
is of double [ type ](/link/type?package=base&version=3.6.2) or not.

##  Double-precision values

All  R  platforms are required to work with values conforming to the IEC 60559
(also known as IEEE 754) standard. This basically works with a precision of 53
bits, and represents to that precision a range of absolute values from about
\\(2 \times 10^{-308}\\) to \\(2 \times 10^{308}\\). It also has special
values ` [ NaN ](/link/NaN?package=base&version=3.6.2) ` (many of them), plus
and minus infinity and plus and minus zero (although  R  acts as if these are
the same). There are also _denormal(ized)_ (or _subnormal_ ) numbers with
absolute values above or below the range given above but represented to less
precision.

See ` [ .Machine ](/link/.Machine?package=base&version=3.6.2) ` for precise
information on these limits. Note that ultimately how double precision numbers
are handled is down to the CPU/FPU and compiler.

In IEEE 754-2008/IEC60559:2011 this is called ‘binary64’ format.

##  Note on names

It is a historical anomaly that  R  has two names for its floating-point
vectors, ` [ double ](/link/double?package=base&version=3.6.2) ` and ` [
numeric ](/link/numeric?package=base&version=3.6.2) ` (and formerly had ` real
` ).

` double ` is the name of the [ type ](/link/type?package=base&version=3.6.2)
. ` numeric ` is the name of the [ mode
](/link/mode?package=base&version=3.6.2) and also of the implicit [ class
](/link/class?package=base&version=3.6.2) . As an S4 formal class, use `
"numeric" ` .

The potential confusion is that  R  has used _[ mode
](/link/mode?package=base&version=3.6.2) _ ` "numeric" ` to mean ‘double or
integer’, which conflicts with the S4 usage. Thus ` is.numeric ` tests the
mode, not the class, but ` as.numeric ` (which is identical to ` as.double ` )
coerces to the class.

##  Details

` double ` creates a double-precision vector of the specified length. The
elements of the vector are all equal to ` 0 ` . It is identical to ` [ numeric
](/link/numeric?package=base&version=3.6.2) ` .

` as.double ` is a generic function. It is identical to ` as.numeric ` .
Methods should return an object of base type ` "double" ` .

` is.double ` is a test of double [ type
](/link/type?package=base&version=3