5.1 Scalars

The simplest object type in R is a scalar. A scalar object is just a single value like a number or a name. In the previous chapter we defined several scalar objects. Here are examples of numeric scalars:

# Examples of numeric scalars
a <- 100
b <- 3 / 100
c <- (a + b) / b

Scalars don’t have to be numeric, they can also be characters (also known as strings). In R, you denote characters using quotation marks. Here are examples of character scalars:

# Examples of character scalars
d <- "ship"
e <- "cannon"
f <- "Do any modern armies still use cannons?"

As you can imagine, R treats numeric and character scalars differently. For example, while you can do basic arithmetic operations on numeric scalars – they won’t work on character scalars. If you try to perform numeric operations (like addition) on character scalars, you’ll get an error like this one:

a <- "1"
b <- "2"
a + b
Error in a + b: non-numeric argument to binary operator

If you see an error like this one, it means that you’re trying to apply numeric operations to character objects. That’s just sick and wrong.

##Vectors

Now let’s move onto vectors. A vector object is just a combination of several scalars stored as a single object. For example, the numbers from one to ten could be a vector of length 10, and the characters in the English alphabet could be a vector of length 26. Like scalars, vectors can be either numeric or character (but not both!).

There are many ways to create vectors in R. Here are the methods we will cover in this chapter:

Functions to create vectors.
Function Example Result
c(a, b, ...) c(1, 5, 9) 1, 5, 9
a:b 1:5 1, 2, 3, 4, 5
seq(from, to, by, length.out) seq(from = 0, to = 6, by = 2) 0, 2, 4, 6
rep(x, times, each, length.out) rep(c(7, 8), times = 2, each = 2) 7, 7, 8, 8, 7, 7, 8, 8

The simplest way to create a vector is with the c() function. The c here stands for concatenate, which means “bring them together”. The c() function takes several scalars as arguments, and returns a vector containing those objects. When using c(), place a comma in between the objects (scalars or vectors) you want to combine:

Let’s use the c() function to create a vector called a containing the integers from 1 to 5.

# Create an object a with the integers from 1 to 5
a <- c(1, 2, 3, 4, 5)

# Print the result
a
## [1] 1 2 3 4 5

As you can see, R has stored all 5 numbers in the object a. Thanks R!

You can also create longer vectors by combining vectors you have already defined. Let’s create a vector of the numbers from 1 to 10 by first generating a vector a from 1 to 5, and a vector b from 6 to 10 then combine them into a single vector x:

a <- c(1, 2, 3, 4, 5)
b <- c(6, 7, 8, 9, 10)
x <- c(a, b)
x
##  [1]  1  2  3  4  5  6  7  8  9 10

You can also create character vectors by using the c() function to combine character scalars into character vectors:

This is not a pipe. It is a character vector.

Figure 5.2: This is not a pipe. It is a character vector. 

char.vec <- c("Ceci", "nest", "pas", "une", "pipe")
char.vec
## [1] "Ceci" "nest" "pas"  "une"  "pipe"

While the c() function is the most straightforward way to create a vector, it’s also one of the most tedious. For example, let’s say you wanted to create a vector of all integers from 1 to 100. You definitely don’t want to have to type all the numbers into a c() operator. Thankfully, R has many simple built-in functions for generating numeric vectors. Let’s start with three of them: a:b, seq(), and rep():

5.1.1 a:b

The a:b function takes two numeric scalars a and b as arguments, and returns a vector of numbers from the starting point a to the ending point b in steps of 1.

Here are some examples of the a:b function in action. As you’ll see, you can go backwards or forwards, or make sequences between non-integers:

1:10
##  [1]  1  2  3  4  5  6  7  8  9 10
10:1
##  [1] 10  9  8  7  6  5  4  3  2  1
2.5:8.5
## [1] 2.5 3.5 4.5 5.5 6.5 7.5 8.5

###seq()

Argument Definition
from The start of the sequence
to The end of the sequence
by The step-size of the sequence
length.out The desired length of the final sequence (only use if you don’t specify by)

The seq() function is a more flexible version of a:b. Like a:b, seq() allows you to create a sequence from a starting number to an ending number. However, seq() has additional arguments that allow you to specify either the size of the steps between numbers, or the total length of the sequence.

The seq() function has two new arguments: by and length.out. If you use the by argument, the sequence will be in steps of the input to the by argument:

# Create the numbers from 1 to 10 in steps of 1
seq(from = 1, to = 10, by = 1)
##  [1]  1  2  3  4  5  6  7  8  9 10

# Integers from 0 to 100 in steps of 10
seq(from = 0, to = 100, by = 10)
##  [1]   0  10  20  30  40  50  60  70  80  90 100

If you use the length.out argument, the sequence will have a length equal to length.out.

# Create 10 numbers from 1 to 5
seq(from = 1, to = 5, length.out = 10)
##  [1] 1.0 1.4 1.9 2.3 2.8 3.2 3.7 4.1 4.6 5.0

# 3 numbers from 0 to 100
seq(from = 0, to = 100, length.out = 3)
## [1]   0  50 100

###rep()

Argument Definition
x A scalar or vector of values to repeat
times The number of times to repeat x
each The number of times to repeat each value within x
length.out The desired length of the final sequence
Not a good depiction of a rep in R.

Figure 5.3: Not a good depiction of a rep in R.

The rep() function allows you to repeat a scalar (or vector) a specified number of times, or to a desired length. Let’s do some reps.

rep(x = 3, times = 10)
##  [1] 3 3 3 3 3 3 3 3 3 3
rep(x = c(1, 2), each = 3)
## [1] 1 1 1 2 2 2
rep(x = 1:3, length.out = 10)
##  [1] 1 2 3 1 2 3 1 2 3 1

As you can see, you can can include an a:b call within a rep()!

You can even combine the times and each arguments within a single rep() function. For example, here’s how to create the sequence {1, 1, 2, 2, 3, 3, 1, 1, 2, 2, 3, 3} with one call to rep():

rep(x = 1:3, each = 2, times = 2)
##  [1] 1 1 2 2 3 3 1 1 2 2 3 3

Warning! Vectors contain either numbers or characters, not both

A vector can only contain one type of scalar: either numeric or character. If you try to create a vector with numeric and character scalars, then R will convert all of the numeric scalars to characters. In the next code chunk, I’ll create a new vector called my.vec that contains a mixture of numeric and character scalars.

my.vec <- c("a", 1, "b", 2, "c", 3)
my.vec
## [1] "a" "1" "b" "2" "c" "3"

As you can see from the output, my.vec is stored as a character vector where all the numbers are converted to characters.