Add week 9.

Author: nick-ulle

Diff for: lecture/10.18/blank_notes.Rmd

@@ -0,0 +1,359 @@
+---
+title: "Stat 33A - Lecture Notes 9"
+date: Oct 18, 2020
+output: pdf_document
+---
+
+
+
+Apply Function Basics
+=====================
+
+Doing the same operation repeatedly is a common pattern in programming.
+
+Vectorization is one way, but not all functions are vectorized.
+
+
+In R, the "apply functions" are another way to do something repeatedly.
+
+The apply functions call a function on each element of a vector or list.
+
+
+
+The `lapply()` Function
+---------------------
+
+The first and most important apply function is `lapply()`. The syntax is:
+```
+lapply(X, FUN, ...)
+```
+
+The function `FUN` is called once for each element of `X`, with the element as
+the first argument. The `...` is for additional arguments to `FUN`, which are
+held constant across all calls.
+
+
+Unrealistic example:
+```{r}
+
+```
+In practice, it's clearer and more efficient to use vectorization here.
+
+
+Let's use the dogs data for some realistic examples:
+```{r}
+
+```
+
+`lapply()` always returns the result as a list.
+
+"l" for **list** result.
+
+
+
+The `sapply()` Function
+---------------------
+
+`sapply()` simplifies the result to a vector, when possible.
+
+"s" for **simplified** result.
+
+Examples:
+```{r}
+
+```
+
+The `sapply()` function is useful if you are working interactively.
+
+
+
+
+
+
+Apply Function Examples
+=======================
+
+The California Counties AQI data set is available on the bCourse (`aqi.zip`).
+
+Let's load one of the files:
+```{r}
+
+```
+
+What are the classes of the columns?
+```{r}
+
+```
+
+How can we load all of the files?
+```{r}
+
+```
+
+The `rbind` function combines two data frames by stacking them together:
+```{r}
+
+```
+
+The data frames we want to stack are in a list.
+
+How can we call `rbind` on all of them?
+
+
+The `do.call` function calls a function using a list as the arguments:
+```{r}
+
+```
+
+How can we convert multiple columns to a different class?
+```{r}
+
+```
+
+
+Are there any missing values in the columns?
+```{r}
+colSums(sapply(aqi_df, is.na))
+```
+
+How can we compute summary statistics about the numeric columns?
+```{r}
+is_numeric = sapply(aqi_df, is.numeric)
+sapply(aqi_df[is_numeric], mean)
+```
+
+
+
+
+
+
+
+
+
+
+
+The Split-Apply Strategy
+========================
+
+The `split()` function splits a vector or data frame into groups based on some
+other vector (usually congruent).
+
+```{r}
+
+```
+
+
+Split weight of dogs by the group column:
+```{r}
+
+```
+
+The `split()` function is especially useful when combined with `lapply()` or
+`sapply`().
+
+```{r}
+
+```
+This is an R idiom!
+
+
+
+The `tapply()` Function
+---------------------
+
+The `tapply()` function is equivalent to the `split()` and `sapply()` idiom.
+
+"t" for **table**, because `tapply()` is a generalization of the
+frequency-counting function `table()`.
+
+
+Examples:
+```{r}
+
+```
+
+This strategy is important for analyzing tabular data regardless of what
+programming language or packages you're using.
+
+
+
+Split-Apply and dplyr
+=====================
+
+We'll use the dogs data here:
+```{r}
+
+```
+
+The split-apply strategy is often used to compute grouped statistics.
+
+For example, we can compute the mean weight of the dogs by group:
+```{r}
+
+```
+
+The `aggregate` function does the same thing as `tapply`, but returns a data
+frame:
+```{r}
+
+```
+
+The dplyr `group_by` and `summarize` functions are another form of split-apply:
+```{r}
+
+```
+
+
+
+Choosing an Apply Function
+==========================
+
+
+1. Is the function you want to apply vectorized?
+
+   If yes, use vectorization.
+
+   Otherwise, continue to #2.
+
+
+2. Do you want to apply the function to elements or to groups?
+
+   For elements, continue to #3.
+
+   For groups, use the split-apply pattern. Use `split()`, then
+   continue to #3 to choose an apply function.
+
+   Note `tapply()` is equivalent to `split()` and `sapply()`.
+
+
+3. Will the function return the same data type for each element?
+
+   If yes, continue to #4.
+
+   Otherwise, use `lapply()`.
+
+
+4. Are you working interactively?
+
+   If yes, use `sapply()`.
+
+   Otherwise, use `vapply()`.
+
+
+Other Apply Functions
+---------------------
+
+See this StackOverflow Post for a summary:
+
+    https://stackoverflow.com/a/7141669
+
+
+The purrr and dplyr packages provide Tidyverse alternatives to apply functions.
+
+
+
+Conditional Expressions
+=======================
+
+Sometimes you'll need code to do different things, depending on a condition.
+
+_If-statements_ provide a way to write conditional code.
+
+
+For example, suppose we want to greet one person differently from the others:
+```{r}
+
+```
+
+Indent code inside of the if-statement by 2 or 4 spaces.
+
+Indentation makes your code easier to read.
+
+
+
+The condition has to be a scalar:
+```{r}
+
+```
+
+You can chain together if-statements:
+```{r}
+
+```
+
+If-statements return the value of the last expression in the evaluated block:
+```{r}
+
+```
+
+Curly braces `{ }` are optional for single-line expressions:
+```{r}
+
+```
+
+But you have to be careful if you don't use them:
+```{r}
+
+```
+
+The `else` block is optional:
+```{r}
+
+```
+
+When there's no `else` block, the value of the `else` block is `NULL`:
+```{r}
+
+```
+
+
+
+The Congruent Vectors Strategy
+==============================
+
+If-statements don't work well with vectors.
+
+For example, suppose we want to transform a vector `x` so that:
+
+* Negative elements are set to 0.
+* Positive elements are squared.
+
+Using an if-statement doesn't work for this:
+```{r}
+
+```
+
+
+Instead, use congruent vectors:
+
+1. An input vector (or vectors) to use in conditions.
+
+2. An output vector to store the results.
+
+Use the input vector to conditionally assign elements to the output vector.
+
+
+So:
+```{r}
+
+```
+
+
+Another example:
+```{r}
+
+```
+
+
+The `ifelse()` Function
+-----------------------
+
+R also has a vectorized `ifelse()` function.
+
+For example:
+```{r}
+
+```
+
+The `ifelse()` function is less efficient than a regular if-statement or the
+congruent vectors strategy.