Objects types and some useful R functions for beginners

The numeric class

To define single numbers, you can do the following:

a <- 3

The class() function allows you to check the class of an object:

class(a)

## [1] "numeric"

Decimals are defined with the character .:

a <- 3.14

R also supports integers. If you find yourself in a situation where you explicitly need an integer and not a floating point number, you can use the following:

a  <- as.integer(3)
class(a)

## [1] "integer"

The as.integer() function is very useful, because it converts its argument into an integer. There is a whole family of as.*() functions. To convert a into a floating point number again:

class(as.numeric(a))

## [1] "numeric"

There is also is.numeric() which tests whether a number is of the numeric class:

is.numeric(a)

## [1] TRUE

These functions are very useful, there is one for any of the supported types in R. Later, we are going to learn about the {purrr} package, which is a very powerful package for functional programming. This package includes further such functions.

The character class

Use " " to define characters (called strings in other programming languages):

a <- "this is a string"

class(a)

## [1] "character"

To convert something to a character you can use the as.character() function:

a <- 4.392

class(a)

## [1] "numeric"

class(as.character(a))

## [1] "character"

It is also possible to convert a character to a numeric:

a <- "4.392"

class(a)

## [1] "character"

class(as.numeric(a))

## [1] "numeric"

But this only works if it makes sense:

a <- "this won't work, chief"

class(a)

## [1] "character"

as.numeric(a)

## Warning: NAs introduced by coercion

## [1] NA

A very nice package to work with characters is {stringr}, which is also part of the {tidyverse}.

The factor class

Factors look like characters, but are very different. They are the representation of categorical variables. A {tidyverse} package to work with factors is {forcats}. You would rarely use factor variables outside of datasets, so for now, it is enough to know that this class exists. We are going to learn more about factor variables in Chapter 4, by using the {forcats} package.

The Date class

Dates also look like characters, but are very different too:

as.Date("2019/03/19")

## [1] "2019-03-19"

class(as.Date("2019/03/19"))

## [1] "Date"

Manipulating dates and time can be tricky, but thankfully there’s a {tidyverse} package for that, called {lubridate}. We are going to go over this package in Chapter 4.

The logical class

This class is the result of logical comparisons, for example, if you type:

4 > 3

## [1] TRUE

R returns TRUE, which is an object of class logical:

k <- 4 > 3
class(k)

## [1] "logical"

In other programming languages, logicals are often called bools. A logical variable can only have two values, either TRUE or FALSE. You can test the truthiness of a variable with isTRUE():

k <- 4 > 3
isTRUE(k)

## [1] TRUE

How can you test if a variable is false? There is not a isFALSE() function (at least not without having to load a package containing this function), but there is way to do it:

k <- 4 > 3
!isTRUE(k)

## [1] FALSE

The ! operator indicates negation, so the above expression could be translated as is k not TRUE?. There are other such operators, namely &, &&, |, ||. & means and and | stands for or. You might be wondering what the difference between & and && is? Or between | and ||? & and | work on vectors, doing pairwise comparisons:

one <- c(TRUE, FALSE, TRUE, FALSE)
two <- c(FALSE, TRUE, TRUE, TRUE)
one & two

## [1] FALSE FALSE  TRUE FALSE

Compare this to the && operator:

one <- c(TRUE, FALSE, TRUE, FALSE)
two <- c(FALSE, TRUE, TRUE, TRUE)
one && two

## [1] FALSE

The && and || operators only compare the first element of the vectors and stop as soon as a the return value can be safely determined. This is called short-circuiting. Consider the following:

one <- c(TRUE, FALSE, TRUE, FALSE)
two <- c(FALSE, TRUE, TRUE, TRUE)
three <- c(TRUE, TRUE, FALSE, FALSE)
one && two && three

## [1] FALSE

one || two || three

## [1] TRUE

The || operator stops as soon it evaluates to TRUE whereas the && stops as soon as it evaluates to FALSE. Personally, I rarely use || or && because I get confused. I find using | or & in combination with the all() or any() functions much more useful:

one <- c(TRUE, FALSE, TRUE, FALSE)
two <- c(FALSE, TRUE, TRUE, TRUE)
any(one & two)

## [1] TRUE

all(one & two)

## [1] FALSE

any() checks whether any of the vector’s elements are TRUE and all() checks if all elements of the vector are TRUE.

As a final note, you should know that is possible to use T for TRUE and F for FALSE but I would advise against doing this, because it is not very explicit.

Vectors and matrices

You can create a vector in different ways. But first of all, it is important to understand that a vector in most programming languages is nothing more than a list of things. These things can be numbers (either integers or floats), strings, or even other vectors. A vector in R can only contain elements of one single type. This is not the case for a list, which is much more flexible. We will talk about lists shortly, but let’s first focus on vectors and matrices.

a <- c(1,2,3,4,5)

class(a)

## [1] "numeric"

dim(a)

## NULL

c(1, 2, "3")

## [1] "1" "2" "3"

a <- cbind(1, 2, 3, 4, 5)

class(a)

## [1] "matrix"

dim(a)

## [1] 1 5

b <- cbind(6,7,8,9,10)

matrix_c <- rbind(a,b)
print(matrix_c)

##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    2    3    4    5
## [2,]    6    7    8    9   10

matrix_a <- matrix(0, nrow = 5, ncol = 5)

B <- matrix(c(2, 4, 3, 1, 5, 7), nrow = 2, byrow = TRUE)

matrix_a[2, 3]

## [1] 0

matrix_a[2, 3] <- 7

print(matrix_a)

##      [,1] [,2] [,3] [,4] [,5]
## [1,]    0    0    0    0    0
## [2,]    0    0    7    0    0
## [3,]    0    0    0    0    0
## [4,]    0    0    0    0    0
## [5,]    0    0    0    0    0

b <- cbind(6,7,8,9,10)

b[3]

## [1] 8

The list class

The list class is a very flexible class, and thus, very useful. You can put anything inside a list, such as numbers:

list1 <- list(3, 2)

or other lists constructed with c():

list2 <- list(c(1, 2), c(3, 4))

you can also put objects of different classes in the same list:

list3 <- list(3, c(1, 2), "lists are amazing!")

and of course create list of lists:

my_lists <- list(list1, list2, list3)

To check the contents of a list, you can use the structure function str():

str(my_lists)

## List of 3
##  $ :List of 2
##   ..$ : num 3
##   ..$ : num 2
##  $ :List of 2
##   ..$ : num [1:2] 1 2
##   ..$ : num [1:2] 3 4
##  $ :List of 3
##   ..$ : num 3
##   ..$ : num [1:2] 1 2
##   ..$ : chr "lists are amazing!"

or you can use RStudio’s Environment pane:

You can also create named lists:

list4 <- list("a" = 2, "b" = 8, "c" = "this is a named list")

and you can access the elements in two ways:

list4[[1]]

## [1] 2

or, for named lists:

list4$c

## [1] "this is a named list"

Lists are used extensively because they are so flexible. You can build lists of datasets and apply functions to all the datasets at once, build lists of models, lists of plots, etc… In the later chapters we are going to learn all about them. Lists are central objects in a functional programming workflow for interactive statistical analysis.

The data.frame and tibble classes

In the next chapter we are going to learn how to import datasets into R. Once you import data, the resulting object is either a data.frame or a tibble depending on which package you used to import the data. tibbles extend data.frames so if you know about data.frame objects already, working with tibbles will be very easy. tibbles have a better print() method, and some other niceties.

However, I want to stress that these objects are central to R and are thus very important; they are actually special cases of lists, discussed above. There are different ways to print a data.frame or a tibble if you wish to inspect it. You can use View(my_data) to show the my_data data.frame in the View pane of RStudio:

You can also use the str() function:

str(my_data)

And if you need to access an individual column, you can use the $ sign, same as for a list:

my_data$col1

Formulas

We will learn more about formulas later, but because it is an important object, it is useful if you already know about them early on. A formula is defined in the following way:

my_formula <- ~x

class(my_formula)

## [1] "formula"

Formula objects are defined using the ~ symbol. Formulas are useful to define statistical models, for example for a linear regression:

lm(y ~ x)

or also to define anonymous functions, but more on this later.

NULL, NA and NaN

The NULL, NA and NaN classes are pretty special. NULL is returned when the result of function is undetermined. For example, consider list4:

list4

## $a
## [1] 2
## 
## $b
## [1] 8
## 
## $c
## [1] "this is a named list"

if you try to access an element that does not exist, such as d, you will get NULL back:

list4$d

## NULL

NaN means “Not a Number” and is returned when a function return something that is not a number:

sqrt(-1)

## Warning in sqrt(-1): NaNs produced

## [1] NaN

or:

0/0

## [1] NaN

Basically, numbers that cannot be represented as floating point numbers are NaN.

Finally, there’s NA which is closely related to NaN but is used for missing values. NA stands for Not Available. There are several types of NAs:

• NA_integer_
• NA_real_
• NA_complex_
• NA_character_

but these are in principle only used when you need to program your own functions and need to explicitly test for the missingness of, say, a character value.

To test whether a value is NA, use the is.na() function.

Useful functions to get you started

This section will list several basic R functions that are very useful and should be part of your toolbox.

rep(1, 10)

##  [1] 1 1 1 1 1 1 1 1 1 1

rep("HAHA", 10)

##  [1] "HAHA" "HAHA" "HAHA" "HAHA" "HAHA" "HAHA" "HAHA" "HAHA" "HAHA" "HAHA"

seq(1, 10)

##  [1]  1  2  3  4  5  6  7  8  9 10

seq(70, 80)

##  [1] 70 71 72 73 74 75 76 77 78 79 80

seq(1, 10, by = 2)

## [1] 1 3 5 7 9

seq_along(list4)

## [1] 1 2 3

seq(list4)

## [1] 1 2 3

seq(10)

##  [1]  1  2  3  4  5  6  7  8  9 10

seq_along(10)

## [1] 1

seq_len(10)

##  [1]  1  2  3  4  5  6  7  8  9 10

seq_along(10)

## [1] 1

ifelse(3 > 5, 1, "this is false")

## [1] "this is false"

if_else(3 > 5, 1, "this is false")
Error: `false` must be type double, not character
Call `rlang::last_error()` to see a backtrace

paste("Hello", "amigo")

## [1] "Hello amigo"

paste("Hello", "amigo", sep = "--")

## [1] "Hello--amigo"

paste0("Hello", "amigo")

## [1] "Helloamigo"

paste0(c("Joseph", "Mary", "Jesus"), collapse = ", and ")

## [1] "Joseph, and Mary, and Jesus"

tolower("HAHAHAHAH")

## [1] "hahahahah"

toupper("hueuehuehuheuhe")

## [1] "HUEUEHUEHUHEUHE"