# Data Types in R

## Introduction

In the previous post, we learnt how to create variables in R. In this post, we will learn about the following data types:

• numeric/double
• integer
• character
• logical
• date/time

## Numeric

In R, numbers are represented by the data type `numeric`. We will first create a variable and assign it a value. Next we will learn a few methods of checking the type of the variable.

``````# create two variables
number1 <- 3.5
number2 <- 3

# check data type
class(number1)``````
``## [1] "numeric"``
``class(number2)``
``## [1] "numeric"``
``````# check if data type is numeric
is.numeric(number1)``````
``## [1] TRUE``
``is.numeric(number2)``
``## [1] TRUE``

If you carefully observe, `integers` are also treated as `numeric/double`. We will learn to create integers in a while. In the meanwhile, we have introduced two new funtions in the above example:

• `class()`: returns the `class` or `type`
• `is.numeric()`: tests whether the variable is of type `numeric`

## Integer

Unless specified otherwise, integers are treated as `numeric` or `double`. In this section, we will learn to create variables of the type `integer` and to convert other data types to `integer`.

• create a variable `number1` and assign it the value `3`
• check the data type of `number1` using `class`
• create a second variable `number2` using `as.integer` and assign it the value `3`
• check the data type of `number2` using `class`
• finally use `is.integer` to check the data type of both `number1` and `number2`
``````# create a variable and assign it an integer value
number1 <- 3

# create another variable using as.integer
number2 <- as.integer(3)

# check the data type
class(number1)``````
``## [1] "numeric"``
``class(number2)``
``## [1] "integer"``
``````# use is.integer to check data type
is.integer(number1)``````
``## [1] FALSE``
``is.integer(number2)``
``## [1] TRUE``

## Character

Letters, words and group of words are represented by the data type `character`. All data of type `character` must be enclosed in single or double quotation marks. In fact any value enclosed in quotes will be treated as `character`. Let us create two variables to store the first and last name of a some random guy.

``````# first name
first_name <- "jovial"

# last name
last_name <- 'mann'

# check data type
class(first_name)``````
``## [1] "character"``
``class(last_name)``
``## [1] "character"``
``````# use is.charactert to check data type
is.character(first_name)``````
``## [1] TRUE``
``is.character(last_name)``
``## [1] TRUE``

You can coerce any data type to `character` using `as.character()`.

``````# create variable of different data types
age <- as.integer(30) # integer
score <- 9.8          # numeric/double
opt_course <- TRUE    # logical
today <- Sys.time()   # date time

as.character(age) ``````
``## [1] "30"``
``as.character(score)``
``## [1] "9.8"``
``as.character(opt_course)``
``## [1] "TRUE"``
``as.character(today)``
``## [1] "2020-06-10 18:20:48"``

## Logical

Logical data types take only 2 values. Either `TRUE` or `FALSE`. Sich data types are created when we compare two objects in R using comparison or logical operators.

• create two variables `x` and `y`
• assign them the values `TRUE` and `FALSE` respectively
• use `is.logical` to check data type
• use `as.logical` to coerce other data types to `logical`
``````# create variables x and y
x <- TRUE
y <- FALSE

# check data type
class(x)``````
``## [1] "logical"``
``is.logical(y)``
``## [1] TRUE``

The outcome of comparison operators is always `logical`. In the below example, we compare two numbers to see the outcome.

``````# create two numeric variables
x <- 3
y <- 4

# compare x and y
x > y``````
``## [1] FALSE``
``x < y``
``## [1] TRUE``
``````# store the result
z <- x > y
class(z)``````
``## [1] "logical"``

`TRUE` is represented by all numbers except `0`. `FALSE` is represented only by `0` and no other numbers.

``````# TRUE and FALSE are represented by 1 and 0
as.logical(1)``````
``## [1] TRUE``
``as.logical(0)``
``## [1] FALSE``
``````# using numbers
as.numeric(TRUE)``````
``## [1] 1``
``as.numeric(FALSE)``
``## [1] 0``
``````# using different numbers
as.logical(-2, -1.5, -1, 0, 1, 2)``````
``## [1] TRUE``

Use `as.logical()` to coerce other data types to `logical`.

``````# create variable of different data types
age <- as.integer(30) # integer
score <- 9.8          # numeric/double
opt_course <- TRUE    # logical
today <- Sys.time()   # date time

as.logical(age) ``````
``## [1] TRUE``
``as.logical(score)``
``## [1] TRUE``
``as.logical(opt_course)``
``## [1] TRUE``
``as.logical(today)``
``## [1] TRUE``

## Summary

• numeric, integer, character, logical and date are the basic data types in R
• `class()` or `typeof()` return the data type
• `is.data_type` checks whether the data is of the specified data type
• `is.numeric()`
• `is.integer()`
• `is.character()`
• `is.logical()`
• `is.date()`
• `as.data_type` will coerce objects to the specified data type
• `as.numeric()`
• `as.integer()`
• `as.character()`
• `as.logical()`
• `as.date()`