vectors.qmd

# Vectors {#sec-vectors}

## Questions

-   What are vectors, and why are they essential in R?

-   What are the different types of vectors and their key characteristics?

-   How does one create a vector?

-   What operations can be performed on a vector?

-   How do I create and access different elements within a vector?

-   Can I combine and manipulate vectors to achieve specific tasks?

-   What are some common functions for working with vectors?

## Learning Objectives

-   Define and create vectors in R.

-   Understand how to perform basic operations on vectors.

-   Understand the concept of vectors as fundamental data structures in R.

-   Master the creation and manipulation of vectors using various techniques.

-   Identify and differentiate between different types of vectors based on their elements.

-   Utilize functions and operators to combine, subset, and transform vectors with ease.

-   Apply your understanding of vectors to enhance your R coding and data analysis efficiency.

## Lesson Content

### Introduction

A vector is a collection of elements of the same data type, and they are a basic data structure in R programming.

Vectors cannot be of mixed data type. The most common way to create a vector is with `c()`, where “c” stands for combine. In R, vectors do not have dimensions; therefore, they cannot be defined by columns or rows. Vectors can be divided into atomic vectors and lists (discussed in the "Data Structures" {@sec-data-structure-1} section). The atomic vectors include logical, character, and numeric (integer or double).

Additionally, R is a vectorized language because mathematical operations are applied to each element of the vector without the need to loop through the vector.

Examples of vectors made up of different data types are shown below:

-   Numbers

```{r}
c(2, 10, 16, -5)
```

-   Characters

```{r}
c("R", "RStudio", "Shiny", "Quarto")
```

-   Logicals

```{r}
c("TRUE", "FALSE", "TRUE")
```

### Sequence Generation

To generate a vector with a sequence of consecutive numbers, we can use: `sequence()`, or `seq()`.

Generate a sequence using `:`

```{r}
a <- 9:18
a
```

```{r}
a_rev <- 18:9
a_rev
```

```{r}
a_rev_minus <- 5:-3
a_rev_minus
```

Generate a sequence using `sequence()`

```{r}
b <- sequence(7)
b
```

```{r}
c <- sequence(c(5,9))
c
```

Generate a sequence using `seq()`

The `seq()` function has four main arguments: `seq(from, to, by, length.out)`, where "from" and "to" are the starting and ending elements of the sequence. Additionally, "by" is the difference between the elements, and "length.out" is the maximum length of the vector.

```{r}
d <- seq(2,20,by=2)
d
```

```{r}
f <- seq(2,20, length.out=5)
f
```

```{r}
h <- seq(20,2,by=-2)
h
```

```{r}
j <- seq(20, 2, length.out=3)
j
```

The `seq()` function can also be used with the arguments first, by, and length.

`seq(first, by = ___, length = ____)`

Example

```{r}
seq(3, by = 4, length = 30)
```

Repeating vectors

To create a repeating vector, we can use `rep()`.

`rep(number, times)`

```{r}
k <- rep(c(0,3,6), times = 3)
k
```

`rep(range, times)`

```{r}
l <- rep(2:6, each = 3)
l
```

`rep(number or range, length.out)`

```{r}
m <- rep(7, length.out = 20)
m
n <- rep(7:10, length.out = 20)
n
```

Random number generation

The `runif()` function can be used to generate a specific number of random numbers between a minimum and maximum value.

`runif(n, min = 0, max = 1)`

```{r}
runif(5, min = 3, max = 100)
```

**NOTE**: If you run the previous code block multiple times you will get different answers. Use `set.seed()` to get a similar sequence every time you run the calculation.

```{r}
set.seed(12345)
runif(5, min = 3, max = 100)
```

### More functions to manipulate vectors

Generate a random vector with 50 elements

```{r}
set.seed(54321)
sam <- runif(50, min = 3, max = 100)
sam
```

Sample

```{r}
sample(sam, size = 15)
```

To get the same sample repeatedly

```{r}
set.seed(1234)
sample(sam, size = 15)
```

```{r}
sort(sam)
```

```{r}
rev(sort(sam))
```

```{r}
quantile(sam)
```

Create two vectors and look at the similarities/differences between the two

```{r}
set.seed(2468)
vec_top_1 <- seq(2, by = 6, length = 100)
vec_top_2 <- seq(4, by = 4, length = 100)
```

```{r}
vec_top_1 
```

```{r}
vec_top_2
```

```{r}
union(vec_top_1, vec_top_2)
```

```{r}
intersect(vec_top_1, vec_top_2)
```

```{r}
setdiff(vec_top_1, vec_top_2)
```

### Vector Operations

Vectors of equal length can be operated on together. If one vector is shorter, it will get recycled, as its elements are repeated until it matches the elements of the longer vector. When using vectors of unequal lengths, it would be ideal if the longer vector is a multiple of the shorter vector.

1.  Basic Vector Operations

```{r}
vec_1 <- 1:10
```

```{r}
vec_1 * 12 # multiplication
```

```{r}
vec_1 + 12 # addition
```

```{r}
vec_1 - 12 # subtraction
```

```{r}
vec_1 / 3 # division
```

```{r}
vec_1^4 # power
```

```{r}
sqrt(vec_1) # square root
```

2.  Operations on vectors

Operations on vectors of equal length Additionally, we can perform operations on two vectors of equal length.

a.  Create two vectors

```{r}
vec_3 <- 5:14
vec_3
```

```{r}
vec_4 <- 12:3
vec_4
```

b.  Perform various arithmetic operations

```{r}
vec_3 + vec_4
```

```{r}
vec_3 - vec_4
```

```{r}
vec_3 / vec_4
```

```{r}
vec_3 * vec_4
```

```{r}
vec_3 ^ vec_4
```

3.  Functions that can be applied to vectors

The functions listed below can be applied to vectors:

a.  `any()`

b.  `all()`

c.  `nchar()`

d.  `length()`

e.  `typeof()`

Examples

```{r}
any(vec_3 > vec_4)
```

```{r}
any(vec_3 < vec_4)
```

```{r}
all(vec_3 > vec_4)
```

```{r}
all(vec_3 < vec_4)
```

```{r}
length(vec_3)
```

```{r}
length(vec_4)
```

```{r}
typeof(vec_3)
```

```{r}
typeof(vec_4)
```

Determine the number of letters in a character

```{r}
vec_5 <- c("R", "RStudio", "Shiny", "Quarto")
```

```{r}
nchar(vec_5)
```

3.  Vectors and mathmatical/statistical operations

A variety of mathematical operations can be performed on vectors. These operations together with examples are listed below.

a.  Create a new vector

```{r}
stat_math_vec_1 <- seq(2, by = 6, length = 120)
stat_math_vec_1
```

b.  Perform mathematical operations on the vector

-   Length

```{r}
length(stat_math_vec_1)
```

-   Sum

```{r}
sum(stat_math_vec_1)
```

-   Minimum

```{r}
min(stat_math_vec_1)
```

-   Maximum

```{r}
max(stat_math_vec_1)
```

-   Mean

```{r}
mean(stat_math_vec_1)
```

-   Median

```{r}
median(stat_math_vec_1)
```

-   Quantile

```{r}
quantile(stat_math_vec_1)
```

-   Standard Deviation

```{r}
sd(stat_math_vec_1)
```

-   Inter-Quartile Range (IQR)

```{r}
IQR(stat_math_vec_1)
```

-   Cumulative Sum

```{r}
cumsum(stat_math_vec_1)
```

-   Range

```{r}
range(stat_math_vec_1)
```

-   Cut This function cuts a range of values into bins and specifies labels for each bin.

The argument "breaks" can be the number of bins, or it can be specific break points.

```{r}
cut(stat_math_vec_1, breaks = 6)

cut(stat_math_vec_1, breaks = c(0, 120, 240, 360, 480, 600, 720))
```

-   Pretty

This function creates a sequence of equally spaced values that are rounded to the closest integer.The argument "n" lists the number of intervals.

```{r}
pretty(stat_math_vec_1)
pretty(stat_math_vec_1, n = 20)
```

-   Trigonometric functions

```{r}
sin(stat_math_vec_1)
```

```{r}
cos(stat_math_vec_1)
```

```{r}
tan(stat_math_vec_1)
```

-   Logarithmic functions

```{r}
log(stat_math_vec_1)
```

```{r}
log2(stat_math_vec_1)
```

```{r}
log10(stat_math_vec_1)
```

4.  Miscellaneous functions

<!-- -->

a.  Changing the case of a character vector

```{r}
char_vec <- c("a", "b", "c", "d")
```

```{r}
char_vec_upper <- toupper(char_vec)
char_vec_upper
```

```{r}
char_vec_lower <- tolower(char_vec_upper)
char_vec_lower
```

4.  Recycling of vectors

```{r}
vec_3 + c(10, 20)
```

```{r}
vec_3 + c(10, 20, 30) 
# Will result in a warning as the longer vector is not a multiple of the shorter one
```

D)  Accessing elements of a vector and subsetting

To access the elements of a vector, we can use numeric-, character-, or logical-based indexing.

Examples

1.  Name the columns of a vector with names().

<!-- -->

a)  Create the vector.

```{r}
vec_name <- 1:5
vec_name
```

b)  Name the individual elements.

```{r}
names(vec_name) <- c("a", "c", "e", "g", "i")
vec_name
```

2.  Use the vector index to filter

```{r}
vec_index <- 1:5
vec_index
```

a)  Logical vector as an index

```{r}
vec_index[c(TRUE, FALSE, TRUE, FALSE, TRUE)]
```

b)  Filter vector based on an index

```{r}
vec_index[1:3]
```

c)  Access a vector using its position

```{r}
vec_index[4]
```

With negative indexing, every element except the one specified is returned.

```{r}
vec_index[-2]
```

```{r}
vec_index[c(2,4)]
```

d)  Modify a vector using indexing

```{r}
vec_index
```

```{r}
vec_index[5] <- 1000
```

```{r}
vec_index
```

E)  Create matrices by combining vectors by row and column

<!-- -->

1.  Create four new vectors

```{r}
vec_mat_df_1 <- seq(2,20, length.out=10)
vec_mat_df_2 <- rep(2:6, each = 2)
vec_mat_df_3 <- runif(10, min = 3, max = 100)
vec_mat_df_4 <- sequence(10)

vec_mat_df_1
vec_mat_df_2
vec_mat_df_3
vec_mat_df_4
```

2.  Create a new matrix by combining each vector as a column, `cbind()`.

```{r}
new_matrix <- cbind(vec_mat_df_1, vec_mat_df_2, vec_mat_df_3, vec_mat_df_4)
new_matrix
str(new_matrix)
class(new_matrix)
```

3.  Create a new matrix by combining each vector as a row, `rbind()`.

```{r}
new_matrix <- rbind(vec_mat_df_1, vec_mat_df_2, vec_mat_df_3, vec_mat_df_4)
new_matrix
str(new_matrix)
class(new_matrix)
```

## Exercises

i.  Create a numeric vector with values 1 through 5 using `c()` and extract the middle element from the vector using the described subsetting methods.
ii. Generate a sequence of even numbers from 2 to 10 using the `seq()` function, and calculate the total sum and average of this new vector.
iii. Create a vector of student ages (between 16 and 20, n = 10), calculate their average and standard deviation, and identify students younger than 18.
iv. Use logical indexing to subset elements from a vector based on a condition.
v.  Perform element-wise addition and multiplication on two newly created numeric vectors of the same length.
vi. Concatenate two newly created character vectors to create a longer vector.
vii. Create a named vector with elements representing days of the week.
viii. Use vector functions to find the length, sum, and mean of a numeric vector.
ix. Use the functions `sort()` or `rev()` to arrange elements in ascending, descending, or reversed order.
x.  Use functions like `which()` or `match()` to locate elements based on conditions or matching values.
xi. How can you append elements to an existing vector?
xii. When binding vectors together, what is the difference between `cbind()` and `rbind()`?
xiii. Explore other vector capabilities like recycling, naming elements, and using vector lengths in your R code.

## Summary

Vectors are an essential data structure for data analysis purposes. In this chapter, I have demonstrated the different types of vectors, how to generate vectors, and the various types of vector operations that can be performed. Now that we have a deeper understanding of vectors, it is time to explore other data structures (that are useful for data analysis) in the subsequent chapters.