`Inf`

and `NaN`

are numeric constants (with
`typeof(.) "double"`

). In text input (e.g. in
`scan`

and `as.double`

), these are recognized
ignoring case as is `infinity`

as an alternative to `Inf`

.
`NA_real_`

and `NA_integer_`

are constants of
types `"double"`

and `"integer"`

representing missing
values. All other numeric constants start with a digit or period and
are either a decimal or hexadecimal constant optionally followed by
`L`

.

Hexadecimal constants start with `0x`

or `0X`

followed by
a nonempty sequence from `0-9 a-f A-F .`

which is interpreted as a
hexadecimal number, optionally followed by a binary exponent. A binary
exponent consists of a `P`

or `p`

followed by an optional
plus or minus sign followed by a non-empty sequence of (decimal)
digits, and indicates multiplication by a power of two. Thus
`0x123p456`

is $291 * 2^456$.

Decimal constants consist of a nonempty sequence of digits possibly
containing a period (the decimal point), optionally followed by a
decimal exponent. A decimal exponent consists of an `E`

or
`e`

followed by an optional plus or minus sign followed by a
non-empty sequence of digits, and indicates multiplication by a power
of ten.

Values which are too large or too small to be representable will
overflow to `Inf`

or underflow to `0.0`

.

A numeric constant immediately followed by `i`

is regarded as an
imaginary complex number.

An numeric constant immediately followed by `L`

is regarded as an
`integer`

number when possible (and with a warning if it
contains a `"."`

).

Only the ASCII digits 0--9 are recognized as digits, even in languages which have other representations of digits. The ‘decimal separator’ is always a period and never a comma.

Note that a leading plus or minus is not regarded by the parser as part of a numeric constant but as a unary operator applied to the constant.

`Syntax`

. `Quotes`

for the parsing of character constants,

```
2.1
typeof(2)
sqrt(1i) # remember elementary math?
utils::str(0xA0)
identical(1L, as.integer(1))
## You can combine the "0x" prefix with the "L" suffix :
identical(0xFL, as.integer(15))
```

Run the code above in your browser using DataLab