06-Iterate.rmd

---
title: "Iteration"
output: html_document
---

```{r setup}
library(tidyverse)

# Toy data
set.seed(1000)
exams <- list(
  student1 = round(runif(10, 50, 100)),
  student2 = round(runif(10, 50, 100)),
  student3 = round(runif(10, 50, 100)),
  student4 = round(runif(10, 50, 100)),
  student5 = round(runif(10, 50, 100))
)

extra_credit <- list(0, 0, 10, 10, 15)
```

## Your Turn 1

What kind of object is `mod`?  Why are models stored as this kind of object?
mod is a "lm" object. Models are stored as lm's because they are linear models. 

```{r}
mod <- lm(price ~ carat + cut + color + clarity, data = diamonds)
## View(mod)
class(mod)
```

## Consider

What's the difference between a list and an **atomic** vector?
Lists are vertical and can hold objects of different data types, as well as other lists. Atomic vectors are horizontal and one atomic vectors can only hold objects of the same data type, and cannot hold other atomic vectors. 

Atomic vectors are: "logical", "integer", "numeric" (synonym "double"), "complex", "character" and "raw" vectors.

## Your Turn 2

Here is a list:

```{r}
a_list <- list(nums = c(8, 9), 
            log = TRUE,    
            cha = c("a", "b", "c"))
```

Here are two subsetting commands. Do they return the same values? Run the code chunk above, _and then_ run the code chunks below to confirm
a_list["nums"] returns a list that contains an atomic vector, while a_list$nums returns an atomic vector (no list).

```{r}
a_list["nums"] 
```

```{r}
a_list$nums
```

## Your Turn 3

What will each of these return? Run the code chunks to confirm.
These run a vector and an error message.

```{r}
vec <- c(-2, -1, 0, 1, 2)
abs(vec)
```

```{r, error = TRUE}
lst <- list(-2, -1, 0, 1, 2)
abs(lst)
```

## Your Turn 4

Run the code in the chunks. What does it return?
This code returns a list.

```{r}
list(student1 = mean(exams$student1),
     student2 = mean(exams$student2),
     student3 = mean(exams$student3),
     student4 = mean(exams$student4),
     student5 = mean(exams$student5))
```

```{r}
library(purrr)
map(exams, mean)
```

## Your Turn 5

Calculate the variance (`var()`) of each student’s exam grades.

```{r}
exams %>% 
  map(var)
```

## Your Turn 6

Calculate the max grade (`max()`)for each student. Return the result as a vector.

```{r}
exams %>% 
  map_dbl(max)
```

## Your Turn 7

Write a function that counts the best exam twice and then takes the average. Use it to grade all of the students.

1. Write code that solves the problem for a real object  
2. Wrap the code in `function(){}` to save it  
3. Add the name of the real object as the function argument 

```{r}
vec <- exams[[1]]
grade <- function(vec) {
  (sum(vec) - min(vec)) / (length(vec) - 1)
}  

exams %>% 
  map_dbl(grade)
```

### Your Turn 8

Compute a final grade for each student, where the final grade is the average test score plus any `extra_credit` assigned to the student. Return the results as a double (i.e. numeric) vector.

```{r}
exams %>% 
  map2_dbl(extra_credit, function(x, y) mean(x) + y)
```


***

# Take Aways

Lists are a useful way to organize data, but you need to arrange manually for functions to iterate over the elements of a list.

You can do this with the `map()` family of functions in the purrr package.

To write a function, 

1. Write code that solves the problem for a real object  
2. Wrap the code in `function(){}` to save it  
3. Add the name of the real object as the function argument 

This sequence will help prevent bugs in your code (and reduce the time you spend correcting bugs). 

<!-- This file by Charlotte Wickham is licensed under a Creative Commons Attribution 4.0 International License, adapted from the orignal work at https://github.com/rstudio/master-the-tidyverse by RStudio. -->