week3_loopFunctions.Rmd

---
title: "R Programming Week 3, Loop Functions"
author: "Krista DeStasio"
date: "12/29/2016"
output: html_document
---
# Notes from R Programming, week 1
*Note: much of the following text is directly from the course slides, available here: [www.coursera.org/learn/r-programming](www.coursera.org/learn/r-programming)*
```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
setwd("~/Dropbox (PfeiBer Lab)/kdestasio/R_projects/coursera/r_programming/")
rm(list = ls())
list.of.packages <- c("datasets")
new.packages <- list.of.packages[!(list.of.packages %in% installed.packages()[,"Package"])]
if(length(new.packages)) install.packages(new.packages)
library(datasets)
```
# LOOP FUNCTIONS
____________________
Idea behaind the loop function is to execute a loop over an object or set of objects in a way that does a lot of work in a small amount of space.

## Looping on the Command Line
Writing *for* and *while* loops is useful when programming, but not particularly easy when working interactively on the command line. There are some functions that implement looping to make life easier.

- **lapply**: Loop over a list and evaluate a function on each element
- **sapply**: Same as lapply , but try to simplify the result
- **apply**: Apply a function over the margins of an array
- **tapply**: Apply a function over a subset of a vector (short for *table apply*)
- **mapply**: Multivariate version of **lapply**

An auxiliary function, **split**, is also useful; particularly in conjunction with **lapply**.  

### lapply 
**lapply** takes 3 arguments: (1) a list **x**; (2) a function (or the name of a function) **FUN**; (3) other arguments via its "..." argument. If **x** is not a list, it will be coerced into a list using **as.list**.
```{r}
lapply
```
The actual looping is done internally in C code.  

**lapply** always returns a list, regardless of the class of the input.  
```{r}
x <- list(a = 1:5, b = rnorm(10))
lapply(x, mean)
x <- list(a = 1:4, b = rnorm(10), c = rnorm(20, 1), d = rnorm(100, 5))
lapply(x, mean)
## Another way to call lapply
x <- 1:4
lapply(x, runif)
## Can adjust the defaults of runif 
lapply(x, runif, min = 0, max = 10)
```
lapply and friends make havy use of *anonymous* functions.
```{r}
x <- list(a = matrix(1:4, 2, 2), b = matrix(1:6, 3, 2))
x
```
An anonymous function for extracting the first column of each matrix.
```{r}
## There is no function that laready extracts the first column of the matrix, but we can write a function quickly. The function only exists within the context of lapply, once it's finished, the function goes away.
lapply(x, function(elt) elt[,1])
```
### sapply

**sapply** will try to simplify the result of **lapply** if possible.

- If the result is a list where every element is length 1, then a vector is returned.
- If the result is a list where every element is a vector of the same length (>1), a matrix is returned.
- If it can't figure things out, a list is returned.
```{r}
x <- list(a = 1:4, b = rnorm(10), c = rnorm(20, 1), d = rnorm(100, 5))
lapply(x, mean)
sapply(x, mean)
mean(x) ## Can't call mean on the list itself
```
### apply
**apply** is used to evaluate a function (often an anonymous one) over the margins of an array.

- Most often used to apply a function to the rows of a column or a matrix.
- It can be used with general arrays, e.g. taking the average of an array matrix.
- It is not really faster than writing a loop, but it works in one line!
    + Particularly useful on the command line.
```{r}
str(apply)
```

- x is an array (An array is a vector that has dimensions attached to it; a matrix is a 2-dimensional vector, for example)
- **MARGIN** is an integer vector indicating which margins should be "retained".
- **FUN** is a function to be applied.
- "..." is for other arguments to be passed to **FUN**
```{r}
x <- matrix(rnorm(200), 20, 10)
## Calculate the mean of each column of the matrix
apply(x, 2, mean)  ## The matrix has 20 rows and 10 columns (dimension 1 has 20 rows and dimension 2 has 10 columns), when you apply the function "mean" over the matrix, you want to keep the 2nd dimension (the number of columns) and collapse the 1st dimension (rows). You're taking the mean across all the the values in each column and eliminating the rows from the array.
## Can also take the sum of all the rows
apply(x, 1, sum)  ## Preserve the rows, collapse the columns
```
#### col/row Sums and Means
For sums and means of matrix dimensions, we have some shortcuts.

- **rowSums** = *apply(x, 1, sum)*
- **rowMeans** = *apply(x, 1, mean)*
- **colSums** = *apply(x, 2, sum)*
- **colMeans** = *apply(x, 2, mean)*

The shortcut functions are *much* faster, but you won't notice unless you are using a large matrix.

#### Other Ways to apply
Quantiles of the rows of a matrix.
```{r}
x <- matrix(rnorm(200), 20, 10)
## Calculate the 25th and 75th percentile
apply(x, 1, quantile, probs = c(0.25, 0.75))
```

#### apply
Average matrix in an array
```{r}
a <- array(rnorm(2 * 2 * 10), c(2, 2, 10))  ## A bunch of 2x2 matrices
apply(a, c(1, 2), mean)  ## Keep the 1st and 2nd dimension, collapse the 3rd dimension
rowMeans(a, dims = 2)
```

### mapply
A multivariate apply that applies a function in parallel over a set of arguments.
```{r}
str(apply)
```

- **FUN** is a function to apply
- **"..."** contains arguments to apply over
- **MoreArgs** is a list of other arguments to FUN
- **SIMPLIFY** indicates whether the result should be simplified

The following is tedious to type
```{r}
list(rep(1, 4), rep(2,3), rep(3, 2), rep(4, 1))
```
Instead, we can do
```{r}
mapply(rep, 1:4, 4:1) ## First arg gives the numbers, Second arg gives the number of repetitions for each
```
#### Vectorizing a Function
```{r}
## THE FUNCTION
noise <- function(n, mean, sd) {  ## Function has 3 arguments
    rnorm(n, mean, sd)
}
noise(5, 1, 2) ## 5 random variables with mean=1 and sd=2
noise(1:5, 1:5, 2) ## Doesn't work correctly if passed a vector of arguments

## THE VECTORIZATION
mapply(noise, 1:5, 1:5, 2) 
```
Which is the same as
```{r}
list(noise(1, 1, 2), noise(2, 2, 2),
     noise(3, 3, 2), noise(4, 4, 2),
     noise(5, 5, 2))
```

### tapply
**tapply** is used to apply a function over *subsets* of a vector.
```{r}
str(tapply)
```
- **x** is a vector
- **INDEX** is a factor or list of factors (otherwise they are coerced into factors)
- **FUN** is a function to be applied
- **"..."** contains other arguments to be passed to FUN
- **simplify**, should we simplify the result?
```{r}
x <- c(rnorm(10), runif(10), rnorm(10, 1)) 
f <- gl(3, 10) ## 3 levels, each repeated 10 times
f
tapply(x, f, mean) ## Take the mean of each group in x
```
Take group means without simplification
```{r}
tapply(x, f, mean, simplify = FALSE) ## when simplify = FALSE, we get back a list with 3 elements. In each element of the list is the mean of that subgroup
```
Find group ranges.
```{r}
tapply(x, f, range) ## Gives min and max of each subgroup in the list
```

### split
**split** takes a vector or other objects and splits it into groups by a factor or a list of factors. Like **tapply**, but without applying the summary statistis.
```{r}
str(split)
```

- **x** is a vector (or list) or data frame
- **f** is a factor (or coerced to one) or a list of factors
- **drop** indicates whether empty factors levels should be dropped
```{r}
x <- c(rnorm(10), runif(10), rnorm(10, 1))
f <- gl(3, 10)
split(x, f) ## Returns list with 3 elements
```
It is common to **split**, followed by an **lapply**.
```{r}
lapply(split(x, f), mean)
```

#### Splitting a Data Frame
```{r}
head(airquality)
```
To calculate the mean of *Ozone*, *Solar radiation*, and *Wind* wihin each month.
```{r}
## Split the data frame into month pieces (can convert month into a factor variable)
s <- split(airquality, airquality$Month)
## Caclulate the column means on those new variables
lapply(s, function(x) colMeans(x[, c("Ozone", "Solar.R", "Wind")])) ## apply an anonymous function
```
There are NAs because there are missing values in that column.  
Can also call **sapply**, which instead of returning a list will simplify the result. Because each vector of the returned list is the same length, **sapply** can put them into a matrix.
```{r}
sapply(s, function(x) colMeans(x[, c("Ozone", "Solar.R", "Wind")]))
sapply(s, function(x) colMeans(x[, c("Ozone", "Solar.R", "Wind")], na.rm = TRUE))
```
#### Splitting on More than One Level
You might have more than one factor and want to look at the combinations of the levels within the factor.
```{r}
x <- rnorm(10)
f1 <- gl(2, 5) ## a factor with 2 levels, repeated 5 times
f2 <- gl(5, 2) ## a factor with 5 levels, repeated 2 times
f1
f2
interaction(f1, f2) ## Gives the (10) total combinations of the levels
```
Interactions can create empty levels. 
```{r}
str(split(x, list(f1, f2))) ## Split the numeric vector x according to the two different factors. Will automatically call the interaction function and create that interaction factors.  
```
Empty levels can be dropped.
```{r}
str(split(x, list(f1, f2), drop = TRUE))
```