Vectors

.leftcol30[
<center>
<img src="https://github.com/emse-p4a-gwu/emse-p4a-gwu.github.io/raw/master/images/p4a_hex_sticker.png" width=250>
</center>
]

### <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="M496 128v16a8 8 0 0 1-8 8h-24v12c0 6.627-5.373 12-12 12H60c-6.627 0-12-5.373-12-12v-12H24a8 8 0 0 1-8-8v-16a8 8 0 0 1 4.941-7.392l232-88a7.996 7.996 0 0 1 6.118 0l232 88A8 8 0 0 1 496 128zm-24 304H40c-13.255 0-24 10.745-24 24v16a8 8 0 0 0 8 8h464a8 8 0 0 0 8-8v-16c0-13.255-10.745-24-24-24zM96 192v192H60c-6.627 0-12 5.373-12 12v20h416v-20c0-6.627-5.373-12-12-12h-36V192h-64v192h-64V192h-64v192h-64V192H96z"/></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="M224 256c70.7 0 128-57.3 128-128S294.7 0 224 0 96 57.3 96 128s57.3 128 128 128zm89.6 32h-16.7c-22.2 10.2-46.9 16-72.9 16s-50.6-5.8-72.9-16h-16.7C60.2 288 0 348.2 0 422.4V464c0 26.5 21.5 48 48 48h352c26.5 0 48-21.5 48-48v-41.6c0-74.2-60.2-134.4-134.4-134.4z"/></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="M0 464c0 26.5 21.5 48 48 48h352c26.5 0 48-21.5 48-48V192H0v272zm320-196c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v40c0 6.6-5.4 12-12 12h-40c-6.6 0-12-5.4-12-12v-40zm0 128c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v40c0 6.6-5.4 12-12 12h-40c-6.6 0-12-5.4-12-12v-40zM192 268c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v40c0 6.6-5.4 12-12 12h-40c-6.6 0-12-5.4-12-12v-40zm0 128c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v40c0 6.6-5.4 12-12 12h-40c-6.6 0-12-5.4-12-12v-40zM64 268c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v40c0 6.6-5.4 12-12 12H76c-6.6 0-12-5.4-12-12v-40zm0 128c0-6.6 5.4-12 12-12h40c6.6 0 12 5.4 12 12v40c0 6.6-5.4 12-12 12H76c-6.6 0-12-5.4-12-12v-40zM400 64h-48V16c0-8.8-7.2-16-16-16h-32c-8.8 0-16 7.2-16 16v48H160V16c0-8.8-7.2-16-16-16h-32c-8.8 0-16 7.2-16 16v48H48C21.5 64 0 85.5 0 112v48h448v-48c0-26.5-21.5-48-48-48z"/></svg> February 17, 2022
]

---

# 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
```

]]

---

# 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
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)
all(x == y)
```

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

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

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

]]

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

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

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

```r
x <- c(1, 2, 3)
y <- c(-1, 2, 3)
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) <- names(x)
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
```

---

# 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
```

]

---

# Using names to slice a vector

```r
x
```

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

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

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

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

```
#> a c 
#> 1 3
```

---

# 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
```

---

# 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)
```

]]

---

## Think-Pair-Share

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]

---

# Lists are like vectors that can store anything

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
```

]]

---

# Elements in lists can be any object

List of vectors:

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

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

]]

List of vector and function:

```r
vector <- c(1, 2, 3)
square <- function(x) {
    return(x^2)
}

list(vector, square)
```

```
#> [[1]]
#> [1] 1 2 3
#> 
#> [[2]]
#> function(x) {
#>     return(x^2)
#> }
#> <environment: 0x7f90cbab31f8>
```

]]

---

# 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/2022-Spring/hw6-vectors.html)

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

- Midterm is during class period on 3/10.