Vectors

]

# Week 6: .fancy[Vectors]

### <svg aria-hidden="true" role="img" viewBox="0 0 512 512" style="height:1em;width:1em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:white;overflow:visible;position:relative;"><path d="M243.4 2.6l-224 96c-14 6-21.8 21-18.7 35.8S16.8 160 32 160v8c0 13.3 10.7 24 24 24H456c13.3 0 24-10.7 24-24v-8c15.2 0 28.3-10.7 31.3-25.6s-4.8-29.9-18.7-35.8l-224-96c-8.1-3.4-17.2-3.4-25.2 0zM128 224H64V420.3c-.6 .3-1.2 .7-1.8 1.1l-48 32c-11.7 7.8-17 22.4-12.9 35.9S17.9 512 32 512H480c14.1 0 26.5-9.2 30.6-22.7s-1.1-28.1-12.9-35.9l-48-32c-.6-.4-1.2-.7-1.8-1.1V224H384V416H344V224H280V416H232V224H168V416H128V224zm128-96c-17.7 0-32-14.3-32-32s14.3-32 32-32s32 14.3 32 32s-14.3 32-32 32z"/></svg> EMSE 4571: Intro to Programming for Analytics
### <svg aria-hidden="true" role="img" viewBox="0 0 448 512" style="height:1em;width:0.88em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:white;overflow:visible;position:relative;"><path d="M272 304h-96C78.8 304 0 382.8 0 480c0 17.67 14.33 32 32 32h384c17.67 0 32-14.33 32-32C448 382.8 369.2 304 272 304zM48.99 464C56.89 400.9 110.8 352 176 352h96c65.16 0 119.1 48.95 127 112H48.99zM224 256c70.69 0 128-57.31 128-128c0-70.69-57.31-128-128-128S96 57.31 96 128C96 198.7 153.3 256 224 256zM224 48c44.11 0 80 35.89 80 80c0 44.11-35.89 80-80 80S144 172.1 144 128C144 83.89 179.9 48 224 48z"/></svg> John Paul Helveston
### <svg aria-hidden="true" role="img" viewBox="0 0 448 512" style="height:1em;width:0.88em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:white;overflow:visible;position:relative;"><path d="M152 64H296V24C296 10.75 306.7 0 320 0C333.3 0 344 10.75 344 24V64H384C419.3 64 448 92.65 448 128V448C448 483.3 419.3 512 384 512H64C28.65 512 0 483.3 0 448V128C0 92.65 28.65 64 64 64H104V24C104 10.75 114.7 0 128 0C141.3 0 152 10.75 152 24V64zM48 448C48 456.8 55.16 464 64 464H384C392.8 464 400 456.8 400 448V192H48V448z"/></svg> February 23, 2023

]

---

# Week 6: .fancy[Vectors]

### 1. Making vectors
### 2. Vector operations
### 3. Comparing vectors

### BREAK

### 4. Slicing vectors
### 5. Lists

---

# Week 6: .fancy[Vectors]

### 1. .orange[Making vectors]
### 2. Vector operations
### 3. Comparing vectors

### BREAK

### 4. Slicing vectors
### 5. Lists

---

# We've already been using vectors!

```r
x <- 1
x
```

```
#> [1] 1
```

]

```r
is.vector(x)
```

```
#> [1] TRUE
```

]

```r
length(x)
```

```
#> [1] 1
```

]

---

# The universal vector generator: `c()`

## Numeric vectors

```r
x <- c(1, 2, 3)
x
```

```
#> [1] 1 2 3
```

]

## Character vectors

```r
y <- c('a', 'b', 'c')
y
```

```
#> [1] "a" "b" "c"
```

]

## Logical vectors

```r
z <- c(TRUE, FALSE, TRUE)
z
```

```
#> [1]  TRUE FALSE  TRUE
```

]

---

# Elements in vectors must be the same type

### Type hierarchy:

- `character` > `numeric` > `logical`
- `double` > `integer`

Coverts to characters:

```r
c(1, "foo", TRUE)
```

```
#> [1] "1"    "foo"  "TRUE"
```

]

Coverts to numbers:

```r
c(7, TRUE, FALSE)
```

```
#> [1] 7 1 0
```

]

Coverts to double:

```r
c(1L, as.integer(2), 3.14)
```

```
#> [1] 1.00 2.00 3.14
```

]

---

# Other ways to make a vector

Sequences (we saw these last week):

```r
seq(1, 5)
```

```
#> [1] 1 2 3 4 5
```

```r
1:5
```

```
#> [1] 1 2 3 4 5
```

]

Repeating a value:

```r
rep(5, 3)
```

```
#> [1] 5 5 5
```

```r
rep("snarf", 3)
```

```
#> [1] "snarf" "snarf" "snarf"
```

]

---

# Repeating a vector

Repeating a sequence

```r
x <- rep(seq(1, 3), times = 3)
x
```

```
#> [1] 1 2 3 1 2 3 1 2 3
```

```r
length(x)
```

```
#> [1] 9
```

]]

Note what the `each` argument does:

```r
x <- rep(seq(1, 3), each = 3)
x
```

```
#> [1] 1 1 1 2 2 2 3 3 3
```

```r
length(x)
```

```
#> [1] 9
```

]]

---

# You can name vector elements

```r
x <- seq(5)
x
```

```
#> [1] 1 2 3 4 5
```

```r
names(x)
```

```
#> NULL
```

---

# You can name vector elements

```r
x <- seq(5)
x
```

```
#> [1] 1 2 3 4 5
```

1) Add names with the `names()` function:

```r
names(x) <- c('a', 'b', 'c', 'd', 'e')
x
```

```
#> a b c d e 
#> 1 2 3 4 5
```

]

2) Create a named vector:

```r
y <- c('a'=1, 'b'=2, 'c'=3, 'd'=4, 'e'=5)
y
```

```
#> a b c d e 
#> 1 2 3 4 5
```

]

---

# Quick code tracing

What will each of these lines produce?

```r
rep(c(TRUE, FALSE, "TRUE"), 2)
```

```r
seq(FALSE, 3)
```

```r
rep(c(seq(3), seq(2)), each = 2)
```

]

---

# Week 6: .fancy[Vectors]

### 1. Making vectors
### 2. .orange[Vector operations]
### 3. Comparing vectors

### BREAK

### 4. Slicing vectors
### 5. Lists

---

## Math on vectors is done **by element**

```r
x <- 1:10
```

```r
x + 2
```

```
#>  [1]  3  4  5  6  7  8  9 10 11 12
```

```r
x - 2
```

```
#>  [1] -1  0  1  2  3  4  5  6  7  8
```

```r
x * 2
```

```
#>  [1]  2  4  6  8 10 12 14 16 18 20
```

```r
x / 2
```

```
#>  [1] 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0
```

---

## Math on vectors is done **by element**

```r
x
```

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

```r
x %% 2
```

```
#>  [1] 1 0 1 0 1 0 1 0 1 0
```

---

## Math on vectors is done **by element**

```r
x1 <- c(1, 2, 3)
x2 <- c(4, 5, 6)
```

```r
x1 + x2 # Returns (1+4, 2+5, 3+6)
```

```
#> [1] 5 7 9
```

```r
x1 - x2 # Returns (1-4, 2-5, 3-6)
```

```
#> [1] -3 -3 -3
```

```r
x1 * x2 # Returns (1*4, 2*5, 3*6)
```

```
#> [1]  4 10 18
```

```r
x1 / x2 # Returns (1/4, 2/5, 3/6)
```

```
#> [1] 0.25 0.40 0.50
```

---

# If dimensions don't match, R "wraps" the vector

```r
x1 <- c(1, 2, 3, 4)
x2 <- c(4, 5)
```

```r
x1 + x2
```

```
#> [1] 5 7 7 9
```

```r
x1 <- c(1, 2, 3, 4)
x2 <- c(1)
```

```r
x1 + x2
```

```
#> [1] 2 3 4 5
```

---

# Most R functions work on vectors

```r
x <- c(3.1415, 1.618, 2.718)
x
```

```
#> [1] 3.1415 1.6180 2.7180
```

```r
round(x, 2)
```

```
#> [1] 3.14 1.62 2.72
```

```r
sqrt(x)
```

```
#> [1] 1.772428 1.272006 1.648636
```

]]

Works with your own functions too:

```r
isEven <- function(x) {
    return((x %% 2) == 0)
}
```

```r
x <- c(1, 4, 5, 10)
isEven(x)
```

```
#> [1] FALSE  TRUE FALSE  TRUE
```

]]

---

# Using vectors instead of a loop: **Summation**

Example: Sum the integers from 1 to 10

Summing with a loop:

```r
x <- seq(1, 10)

total <- 0
for (i in x) {
    total <- total + i
}
total
```

```
#> [1] 55
```

]]

Use a _summary function_ on the vector:

```r
sum(x)
```

```
#> [1] 55
```

]]

---

## **Summary functions** return one value

```r
x <- 1:10
```

```r
length(x)
```

```
#> [1] 10
```

```r
sum(x)
```

```
#> [1] 55
```

```r
prod(x)
```

```
#> [1] 3628800
```

]

```r
min(x)
```

```
#> [1] 1
```

```r
max(x)
```

```
#> [1] 10
```

```r
mean(x)
```

```
#> [1] 5.5
```

```r
median(x)
```

```
#> [1] 5.5
```

]

---

# Quick code tracing

Consider this function:

```r
f <- function(x) {
    m <- x
    n <- sum(x + 4)
    m <- m + 5
    return(c(m, n))
}
```

]]

What will each of these lines return?

```r
x <- c(1, 3)
f(x)
```

```r
y <- c(TRUE, FALSE, 1)
f(y)
```

]]

---

# Week 6: .fancy[Vectors]

### 1. Making vectors
### 2. Vector operations
### 3. .orange[Comparing vectors]

### BREAK

### 4. Slicing vectors
### 5. Lists

---

# Comparing vectors

Check if 2 vectors are the same:

```r
x <- c(1, 2, 3)
y <- c(1, 2, 3)
```

```r
x == y
```

]

```
#> [1] TRUE TRUE TRUE
```

]

---

# Comparing vectors with `all()` and `any()`

`all()`: Check if _all_ elements are the same

```r
x <- c(1, 2, 3)
y <- c(1, 2, 3)
x == y
```

```
#> [1] TRUE TRUE TRUE
```

```r
all(x == y)
```

```
#> [1] TRUE
```

]]

```r
x <- c(1, 2, 3)
y <- c(-1, 2, 3)
x == y
```

```
#> [1] FALSE  TRUE  TRUE
```

```r
all(x == y)
```

```
#> [1] FALSE
```

]]

---

# Comparing vectors with `all()` and `any()`

`any()`: Check if _any_ elements are the same

```r
x <- c(1, 2, 3)
y <- c(1, 2, 3)
x == y
```

```
#> [1] TRUE TRUE TRUE
```

```r
any(x == y)
```

```
#> [1] TRUE
```

]]

```r
x <- c(1, 2, 3)
y <- c(-1, 2, 3)
x == y
```

```
#> [1] FALSE  TRUE  TRUE
```

```r
any(x == y)
```

```
#> [1] TRUE
```

]]

---

# `all()` vs. `identical()`

```r
x <- c(1, 2, 3)
y <- c(1, 2, 3)
names(x) <- c('a', 'b', 'c')
names(y) <- c('one', 'two', 'three')
```

]

`all()` only compares the element _values_:

```r
all(x == y)
```

```
#> [1] TRUE
```

]]

`identical()` compares _values_ and _names_:

```r
identical(x, y)
```

```
#> [1] FALSE
```

```r
names(y) <- c('a', 'b', 'c')
identical(x, y)
```

```
#> [1] TRUE
```

]]

---

## Your turn

Re-write `isPrime(n)` from last week, but **without loops!**.

Remember, `isPrime(n)` takes a non-negative integer, `n`, and returns `TRUE` if it is a prime number and `FALSE` otherwise. Here are some test cases:

- `isPrime(1) == FALSE`
- `isPrime(2) == TRUE`
- `isPrime(7) == TRUE`
- `isPrime(13) == TRUE`
- `isPrime(14) == FALSE`

(If you're stuck, go to the next slide for a hint)

---

## Hint

Loop solution:

```r
isPrime <- function(n) {
    if (n <= 1) {
        return(FALSE)
    }
    if (n == 2) {
        return(TRUE)
    }
    for (i in seq(2, (n - 1))) {
        if ((n %% i) == 0) {
            return(FALSE)
        }
    }
    return(TRUE)
}
```

]

---

# .fancy[Break]

---

# Week 6: .fancy[Vectors]

### 1. Making vectors
### 2. Vector operations
### 3. Comparing vectors

### BREAK

### 4. .orange[Slicing vectors]
### 5. Lists

---

# Use brackets `[]` to get elements from a vector

```r
x <- seq(1, 10)
```

Indices start at 1:

```r
x[1] # Returns the first element
```

```
#> [1] 1
```

```r
x[3] # Returns the third element
```

```
#> [1] 3
```

```r
x[length(x)] # Returns the last element
```

```
#> [1] 10
```

]

Slicing with a vector of indices:

```r
x[1:3]  # Returns the first three elements
```

```
#> [1] 1 2 3
```

```r
x[c(2, 7)] # Returns the 2nd and 7th elements
```

```
#> [1] 2 7
```

]

---

# Use negative integers to _remove_ elements

```r
x <- seq(1, 10)
```

```r
x[-1] # Drops the first element
```

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

```r
x[-1:-3] # Drops the first three elements
```

```
#> [1]  4  5  6  7  8  9 10
```

```r
x[-c(2, 7)] # Drops the 2nd and 7th elements
```

```
#> [1]  1  3  4  5  6  8  9 10
```

```r
x[-length(x)] # Drops the last element
```

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

---

# Slicing with logical indices

```r
x <- seq(1, 20, 3)
x
```

```
#> [1]  1  4  7 10 13 16 19
```

Create a logical vector based on some condition:

```r
x > 10
```

```
#> [1] FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE
```

Slice `x` with logical vector - only `TRUE` indices will be returned:

```r
x[x > 10]
```

```
#> [1] 13 16 19
```

---

# You can also use `which()` to find indices

```r
x <- seq(1, 20, 3)
x
```

```
#> [1]  1  4  7 10 13 16 19
```

Use `which()` around a condition to get the indices where condition is `TRUE`:

```r
which(x > 10)
```

```
#> [1] 5 6 7
```

```r
x[which(x > 10)]
```

```
#> [1] 13 16 19
```

---

# Using names to slice a vector

```r
names(x) <- c('a', 'b', 'c', 'd', 'e', 'f', 'g')
x
```

```
#>  a  b  c  d  e  f  g 
#>  1  4  7 10 13 16 19
```

```r
x['a']
```

```
#> a 
#> 1
```

```r
x[c('a', 'c')]
```

```
#> a c 
#> 1 7
```

---

# Sorting vectors with `sort()`

```r
a = c(2, 4, 6, 3, 1, 5)
a
```

```
#> [1] 2 4 6 3 1 5
```

```r
sort(a)
```

```
#> [1] 1 2 3 4 5 6
```

```r
sort(a, decreasing = TRUE)
```

```
#> [1] 6 5 4 3 2 1
```

---

## `order()` returns the indices of the sorted vector

```r
a
```

```
#> [1] 2 4 6 3 1 5
```

```r
order(a)
```

```
#> [1] 5 1 4 2 6 3
```

This does the same thing as `sort(a)`:

```r
a[order(a)]
```

```
#> [1] 1 2 3 4 5 6
```

---

# Look for membership with `%in%`

```r
cities <- c("atlanta", "dc", "nyc", "sf")
cities
```

```
#> [1] "atlanta" "dc"      "nyc"     "sf"
```

```r
"chicago" %in% cities
```

```
#> [1] FALSE
```

```r
"dc" %in% cities
```

```
#> [1] TRUE
```

---

# Quick code tracing

Consider this function:

```r
f <- function(x) {
    for (i in seq(length(x))) {
        x[i] <- x[i] + sum(x) + max(x)
    }
    return(x)
}
```

]]

What will this code return?

```r
x <- c(1, 2, 3)
f(x)
```

]]

---

## Your turn

1) `reverse(x)`: Write a function that returns the vector in reverse order. You cannot use the `rev()` function.

- `all(reverseVector(c(5, 1, 3)) == c(3, 1, 5))`
- `all(reverseVector(c('a', 'b', 'c')) == c('c', 'b', 'a'))`
- `all(reverseVector(c(FALSE, TRUE, TRUE)) == c(TRUE, TRUE, FALSE))`

2) `alternatingSum(a)`: Write a function that takes a vector of numbers `a` and returns the alternating sum, where the sign alternates from positive to negative or vice versa.

- `alternatingSum(c(5,3,8,4)) == (5 - 3 + 8 - 4)`
- `alternatingSum(c(1,2,3)) == (1 - 2 + 3)`
- `alternatingSum(c(0,0,0)) == 0`
- `alternatingSum(c(-7,5,3)) == (-7 - 5 + 3)`

**Challenge**: For each function, try writing a solution that uses loops and another that only uses vectors.

]

---

# Week 6: .fancy[Vectors]

### 1. Making vectors
### 2. Vector operations
### 3. Comparing vectors

### BREAK

### 4. Slicing vectors
### 5. .orange[Lists]

---

# Elements in lists can be any object

Vectors force things to one type:

```r
c(1, "foo", TRUE)
```

```
#> [1] "1"    "foo"  "TRUE"
```

]]

Lists store any type:

```r
list(1, "foo", TRUE)
```

```
#> [[1]]
#> [1] 1
#> 
#> [[2]]
#> [1] "foo"
#> 
#> [[3]]
#> [1] TRUE
```

]]

---

## .center[Subsetting lists]

---

# Slice list with indices or names

Slice with index using `[[]]`

```r
x <- list(
  c(1, 2, 3),
  c("foo", "bar"),
  TRUE
)
```

```r
x[[1]]
```

```
#> [1] 1 2 3
```

```r
x[[2]]
```

```
#> [1] "foo" "bar"
```

]]

Slice with name using ``[[]]` or `$`

```r
x <- list(
  numbers = c(1, 2, 3),
  chars   = c("foo", "bar"),
  logical = TRUE
)
```

```r
x[['numbers']]
```

```
#> [1] 1 2 3
```

```r
x$numbers
```

```
#> [1] 1 2 3
```

]]

---

# [HW 6](https://p4a.seas.gwu.edu/2023-Spring/hw/6-vectors.html)

- Next week is Quiz 4 - the last quiz before the midterm.

- Midterm is during class period on 3/9.