Data types

Basic skills in R: Your first calculations with R

Data types

Content

What are data types?
Why do we need to know about data types?
Some examples of creating variables and checking properties
How to change the data type of a variable?
Working with dates
Summary of logical test and coercion functions

What are data types? R can store many different kinds of information or values in variables. For example, we can store numbers and words in a variable. There are a few basic types of data that we can store in a variable. Below we list the main ones:

Numeric data type: These are numbers, possibly in scientific notation. They can be
- integers (\(\ldots, -2,-1,0,1,2,\ldots\));
- floating-point numbers, i.e., numbers with a decimal point such as \(1.23\), \(1.234\mathrm{e}56\) or \(1.234\mathrm{E}56\);
- complex numbers such as \(2+3\ii\).

Character data type: This all about letters, words. and other characters. A sequence of characters is also called a string. Remember to enclose the characters by quotes. For example "fifteen" or "child's age".

Logical data: This concerns binary choices, like "yes" or "no," "on" or "off", TRUE, FALSE. We'll see in another theory page why on earth you would like to store "yesses" and "no's" in a variable. For the moment it suffices to consider the logical data type has one of two possible values: true or false, which is intended to represent the two truth values used in logic.

Factor data: This is not really a basic data type, but more a data structure. Nevertheless we put it in this list as it can be considered as a type used for categorical data (for example, factors for a book object could be the genre, the colour of the cover, the title, the name of the author, the name of the publisher, and so on). See the page Working with factors if you want to learn more about this type.

Date: This is not really a basic data type either, but more a distinguished use of an integer. Dates are represented as the number of days since the 1st of Januay 1970, with negative values for earlier dates.

More on integers

Integer data type

If you create a variable and store a whole number in it in the usual notation, R will actually save your whole number as an floating point number. See the sample session on the right-hand side, with the instruction one <- 1. When we ask wthat kind of object it is via the function class(), it will answer numeric, i.e.. the data type is numeric, which is in fact a double floating-point number (64-bit float) reveled by application of the function typeof().

You can force R to assign an integer instead of a floating-point number by entering 1L instead of 1. The letter L indicates that the object is actually of type long integer, i.e. a 32-bit integer allowing for an integer between \(-2^{31}\) and \(2^{31}\)

To make things more complicated: when yoy enter the number as 1:1, it will also consider it as an integer.

Sample session

> one <- 1
> class(one)
[1] "numeric"
> typeof(one)
[1] "double"
> one <- 1L
> class(one)
[1] "integer"
> typeof(one)
[1] "integer"
> one <- 1:1 
> class(one) 
[1] "integer" 
> typeof(one) 
[1] "integer"

Why do we need to know about data types? Knowing the data type of your variables is important because it helps you perform the right operations on them. For example, you can add numbers, concatenate strings, or compare values, but you can't add a string to a number. Knowing the data types allows you to use the appropriate operators and prevent errors.

Some examples of creating variables and checking properties

Explanation

Let's look at some examples of how to create variables of various data types and check their properties.

Run the instructions in the example to the right and look at the output in R. The function str() gives you the internal structure of the variable, i.e., the data type and the contents. If you only want to get the data type, then you can use the function typeof() or class(). There are also functions like is.numeric(), is.character(), and is.factor() to test if an object is of certain type

Don't worry about no further discussion of the logical data type or factor yet. At this point, the goal is only to let you know that there are multiple data types and that two of them are called factor and logical. You will learn more about them later.

Sample script

# create a numeric variable
age <- 15
str(age)
is.numeric(age)

# create a character variable
age <- "fifteen" 
str(age) 
is.character(age)

# create a factor variable
ages <- factor(c(16, 18, 16, 21, 21, 16))
str(ages)

# create a logical variable 
adultQ <- TRUE
str(adultQ)
is.logical(adultQ)

How to change the data type of a variable?

Explanation

R assigns data types automatically to variables, as we saw above. But R has several functions to convert variables from one data type to another. This type of conversion is called coercion. Here are some commonly used functions:

as.character(): converts an object to character type.
as.numeric(): converts an object to numeric type.
as.logical(): converts an object to logical type.

Try some of them out!

Sample script

# convert a numerical variable to character
x <- 5
x <- as.character(x)
str(x)
# output: chr "5" 

# convert logical to numeric
v <- TRUE
v <- as.numeric(v)
str(v)
# output: num 1

Practice

Create a numerical variable and convert it to character. Can you still do arithmetic calculations with this variable? Try to add the number 5 to it.
Can you convert a character variable to numerical? When can you do this, and when not?
Can you convert the following variable into a logical type? myvariable <- "elephant"
Suppose you have a variable named age and it contains the number 16. Now you want it to contain "16" as a name. Someone gives you this piece of code to do that:
```
age <- 16 
as.character(age)
```
R gives you as output: chr "16". But when you look in your working environment at at the variable with the function str(), then you see that the contents of your variable has not changed at all! What went wrong?

Working with dates

Explanation

R has a special data type (or actually a class of object) to represent dates. The current date can be found by the function Sys.Date(). The function format() allows various choice of formatting the printing of a date. The functions weekdays() and months() return the name of the weekday and the month, respectively, for a given date.

An integer can be converted to a date via the coercion function as.Date() and the origin option allows you to choose a reference date.

See the sample session on the right-hand side

Sample session

> today <- Sys.Date()
> typeof(today)
[1] "double"
> class(today)
[1] "Date"
> str(today)
 Date[1:1], format: "2023-09-22"
> format(today, "%d %b %y")
[1] "22 Sep 23"
> weekdays(today)
[1] "Friday"
> two_weeks_later <- as.Date(14, 
+    origin = today) 
> two_weeks_later 
[1] "2023-10-06" 
> format(two_weeks_later, 
+        "%d %b %y") 
[1] "06 Oct 23"

Date formats Formats of dates are described by special symbols listed in the tabel below.

Symbol	Meaning	Example
`%d`	day as a number (0-31)	03
`%a`	abbreviated weekday	Mon
`%A`	unabbreviated weekday	Monday
`%m`	month as a number (01-12)	09
`%b`	abbreviated month	Sep
`%B`	unabbreviated month	September
`%y`	two-digit year	23
`%Y`	four-digit year	2023

An example:

> Sys.Date()
[1] "2023-09-27"
> format(Sys.Date(), "%A %B %Y")
[1] "Wednesday September 2023"
> date()
[1] "Wed Sep 27 07:35:18 2023"

Timing a computation The function Sys.time() gives not only the date but also the clock time. It allows you to compute elapsed time in a computation. The function difftime() allows to change the unit of time.

> Sys.time()
[1] "2023-09-27 08:01:32 CEST"
> start.time <- Sys.time() # start timing
> end.time <- Sys.time()   # stop timing 
> end.time - start.time    # elapsed time
Time difference of 15.63281 secs
> difftime(end.time, start.time, units="mins")
Time difference of 0.2605469 mins

Summary of logical test and coercion functions

Type	Logical test	Coercion function
numeric	`is.numeric()`	`as.numeric()`
complex	`is.complex()`	`as.complex()`
character	`is.character()`	`as.character()`
logical	`is.logical()`	`as.logical()`
factor	`is.factor()`	`as.factor()`