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

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.

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

it strips attributes including names.
(To ensure that an object is of double type without stripping
attributes, use `storage.mode`

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

.`is.double`

returns `TRUE`

or `FALSE`

depending on
whether its argument is of double type or not.
`NaN`

(many of them), plus and minus infinity and plus and
minus zero (although R acts as if these are the same). There are
also `.Machine`

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

and `numeric`

(and formerly had `real`

). `double`

is the name of the type.
`numeric`

is the name of the mode and also of the implicit
class. As an S4 formal class, use `"numeric"`

. The potential confusion is that R has used `"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.`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`

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

*R has no single precision data type. All real numbers are
stored in double precision format*. The functions `as.single`

and `single`

are identical to `as.double`

and `double`

except they set the attribute `Csingle`

that is used in the
`.C`

and `.Fortran`

interface, and they are
intended only to be used in that context.

https://en.wikipedia.org/wiki/IEEE_754-1985, https://en.wikipedia.org/wiki/IEEE_754-2008, https://en.wikipedia.org/wiki/Double_precision, https://en.wikipedia.org/wiki/Denormal_number.

http://grouper.ieee.org/groups/754/ for links to information on the standards.

`integer`

, `numeric`

, `storage.mode`

.
```
is.double(1)
all(double(3) == 0)
```

Run the code above in your browser using DataCamp Workspace