Vectors

A vector in R is simply a sequence of data elements, usually numbers. A vector can be created using the command c(). The elements are held between the brackets and separated by a comma as follows:

#1) A numeric vector:

x <- c(2,3,6)

#2) A character vector:

y <- c("peter", "paul", "mary")

#3) a logical vector

z <- c(TRUE, TRUE, FALSE)

x
## [1] 2 3 6
y
## [1] "peter" "paul"  "mary"
z
## [1]  TRUE  TRUE FALSE

Note that the elements of a character vector and held between quotation marks " ". Despite TRUE and FALSE being words, they are logical elements not character elements in R. They are not held between quotation marks.

Vector Arithmetic

Notice how we can quickly apply operations “element-wise” on vectors:

vec.1 <- c(2, 3, 4)
vec.2 <- c(3, -2, 1)

#you can insert helpful comments in your code
#to do so, use #

#here is some simple vector arithmetic:

vec.1 + vec.2
vec.1 - vec.2
vec.1*vec.2
vec.1/vec.2
vec.1 + 7
vec.1*7
vec.1/7

Here are the results in order:

## [1] 5 1 5
## [1] -1  5  3
## [1]  6 -6  4
## [1]  0.6666667 -1.5000000  4.0000000
## [1]  9 10 11
## [1] 14 21 28
## [1] 0.2857143 0.4285714 0.5714286

Generating Vector Sequences

There are a few tricks for quickly generating sequences which you will find helpful:

rep(4, 7)
seq(1,21, by = 2)
seq(0, 10, len = 5)
seq(0, 10, len = 10)
1:20

Here are the results in order:

## [1] 4 4 4 4 4 4 4
##  [1]  1  3  5  7  9 11 13 15 17 19 21
## [1]  0.0  2.5  5.0  7.5 10.0
## [1]  0.00  1.25  2.50  3.75  5.00  6.25  7.50  8.75 10.00
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20

Functions of Vectors

Functions can be applied element-wise to vectors. Here are some examples:

vec.3 <- 1:5

vec.3^2
sqrt(vec.3)
1/vec.3
sin(vec.3)
exp(vec.3)
vec.3^(1/3)

Here are the results in order:

## [1]  1  4  9 16 25
## [1] 1.000000 1.414214 1.732051 2.000000 2.236068
## [1] 1.0000000 0.5000000 0.3333333 0.2500000 0.2000000
## [1]  0.8414710  0.9092974  0.1411200 -0.7568025 -0.9589243
## [1]   2.718282   7.389056  20.085537  54.598150 148.413159
## [1] 1.000000 1.259921 1.442250 1.587401 1.709976

Interrogating Vectors

Given a vector, we can ask R lots of useful questions about it. We will look at: Common Functions, Searching a vector for a Condition and Indexing a vector.

Common Functions

vec.4 <- c(2,2,3,3,3,4,5,6,7,7,7,7,8,9,10,10,10)

#common functions:
length(vec.4)
unique(vec.4)
sum(vec.4)
prod(vec.4)
mean(vec.4)
var(vec.4)
sd(vec.4)
quantile(vec.4)

Here are the results in order:

## [1] 17
## [1]  2  3  4  5  6  7  8  9 10
## [1] 103
## [1] 2.240421e+12
## [1] 6.058824
## [1] 8.058824
## [1] 2.838807
##   0%  25%  50%  75% 100% 
##    2    3    7    8   10

Searching for a Condition

Look at the following code using the which() function. What do you think the results will be?

vec.4 <- c(2,2,3,3,3,4,5,6,7,7,7,7,8,9,10,10,10)

#searching for a condition:
which(vec.4 == 3)
which(vec.4 < 7)
which(vec.4 <= 7)
which((vec.4 < 3) | (vec.4 > 8))
which((vec.4 > 3) & (vec.4 < 8))

The results are the positions of elements within vec.4 for which the stated condition holds:

## [1] 3 4 5
## [1] 1 2 3 4 5 6 7 8
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12
## [1]  1  2 14 15 16 17
## [1]  6  7  8  9 10 11 12

Indexing a Vector

We can easily look up an element of a vector in a given position. For example, to ask R for the fifth element of vec.4, we simply type vec.4[5]. This is known as indexing the vector. We index a vector using square brackets as in the following code:

vec.4 <- c(2,2,3,3,3,4,5,6,7,7,7,7,8,9,10,10,10)

#in the following, notice that we "index" a vector using square brackets.

#the element in position 8:
vec.4[8]

#the element in position 9:
vec.4[9]

#the elements in the positions specified by a vector of indices:
index <- c(1,5,8,11)
vec.4[index]

The results are the elements to be found in the positions specified:

## [1] 6
## [1] 7
## [1] 2 3 6 7

Manipulating Vectors

We can search and subsequently alter vectors. Notice that sometimes we might want to keep both versions of the vector and other times we might want to over-write the original vector.

example 1

The \(8^{th}\) element is altered and the vector is over-written:

vec.4[8] <- 76
vec.4
##  [1]  2  2  3  3  3  4  5 76  7  7  7  7  8  9 10 10 10

example 2

All the elements of vec.4 which are equal to \(7\) are replaced with \(21\) and the vector is over-written:

vec.4[which(vec.4 == 7)] <- 21
vec.4
##  [1]  2  2  3  3  3  4  5 76 21 21 21 21  8  9 10 10 10

example 3

All elements less than \(10\) are set to \(0\) and the result is stored as a new vector:

vec.5 <- vec.4
vec.5[which(vec.5 < 10)] <- 0
vec.4
##  [1]  2  2  3  3  3  4  5 76 21 21 21 21  8  9 10 10 10
vec.5
##  [1]  0  0  0  0  0  0  0 76 21 21 21 21  0  0 10 10 10

Make sure you understand the logic of this code. which(vec.5 < 10) is a vector of indices providing the positions of elements in vec.5 which are less than \(10\). vec.5[which(vec.5 < 10)] then picks out the elements of vec.5 indexed by which(vec.5 < 10). Finally, these elements are assigned value \(0\) using <- 0.

This whole process could have been split up to make this logic a little more clear in the code:

vec.5 <- vec.4
#I gives the positions of elements in vec.5 which are less than 10.
I <- which(vec.5 < 10)
I
## [1]  1  2  3  4  5  6  7 13 14

We now use this index set to assign the values in these positions to \(0\):

vec.5 <- vec.4
#I gives the positions of elements in vec.5 which are less than 10.
vec.5[I] <- 0
vec.5
##  [1]  0  0  0  0  0  0  0 76 21 21 21 21  0  0 10 10 10