Does R treat numbers as double internally?

Question

Does R treat numbers mainly as double?

The following code suggests that R treats numbers as double. Even if I make it integer, it easily becomes double after some calculation. (Code1)

Also, even if the result looks like integer, interanlly it is treated as double. (Code2)

Is my understanding right?

Code 1:

> typeof(5)
[1] "double"

> typeof( 5 / 1 )
[1] "double"

> typeof( as.integer(c(1,2,3)) )
[1] "integer"

> typeof( as.integer(c(1,2,3)) + 1 )
[1] "double"

> typeof( as.integer(c(1,2,3)) / 1 )
[1] "double"

Code 2:

> 1 + 2 
[1] 3

> typeof( 1 + 2)
[1] "double"

Please read [this SO question](https://stackoverflow.com/questions/50255318/difference-between-double-precision-data-type-and-numeric-data-type-in-r). — Tim Biegeleisen, Apr 15 '19 at 05:30
Possible duplicate of [Difference between double- precision data type and numeric data type](https://stackoverflow.com/questions/50255318/difference-between-double-precision-data-type-and-numeric-data-type) — LocoGris, Apr 15 '19 at 06:47

Oliver · Accepted Answer · 2021-11-03T18:45:31.887

R handles numbers in different ways. In R both integers and double precision float defaults to their 32 bit version.

As pointed out by Andrey, there are two different types of numbers in R.

Literals 1L, 2L, 3L, ...., this is equivalent to as.integer(1)
regular numbers (1, 2, 3.4, any number really)

As well as their complex counterparts.

Literals are integers as such

typeof(1)  #double
class(1)   #numeric
typeof(1L) #integer
class(1L)  #integer

is well defined. However upon calculation, if any part of the calculation is not stored as a lower or equal type than integer, it will automatically be converted to a double:

typeof(1L + 1L)   #integer
typeof(1L + 1)    #double
typeof(1L + TRUE) #integer
typeof(1L * 3)    #double
typeof(1L * 3L)   #integer

One should note however, as R runs with 32 bit variables, these have a limited range, compared to python 3.x. However one can get around the 32 bit variables ( in most cases! ) by using the packages bit64 for 64 bit integers and Rmpfr which gives an interface for arbitrary floating point precision (according to their documentation).

Edit

I wrongly stated that "In R both integers and double precision float defaults to their 32 bit version". This is not the case for double precision variables, which default to a their 64 bit counterpart in almost all releases of R nowadays.

*In R both integers and double precision float defaults to their 32 bit version.* This part is incorrect. Integers are indeed signed 32-bit types, but doubles are 64-bits in "almost all R builds." See https://stat.ethz.ch/R-manual/R-devel/library/base/html/zMachine.html — ZachB, Nov 03 '21 at 01:03
That is correct, a note that I have learned later on in life. :-) — Oliver, Nov 03 '21 at 18:44

score 0 · Answer 2 · answered Apr 15 '19 at 05:29

To make a number an integer from the start, add L to it:

typeof(1L)
# [1] "integer"

There are dangers in working with 32 bit integers though:

2e9L
# [1] 2000000000
2e9L + 2e9L
# [1] NA
# Warning message:
# In 2000000000L + 2000000000L : NAs produced by integer overflow

Does R treat numbers as double internally?

2 Answers2

Edit