ews_sw.qmd

---
title: "EWS"
author: "Sean Westwood"
format: revealjs
---

```{r, include = FALSE}
knitr::opts_chunk$set(error = TRUE,
                      echo = TRUE,
                      message = FALSE,
                      eval = FALSE)
# remember to set evel = FALSE on code chunks that I don't want code to run
# this may make more sense than error depending if we want error message
```


# Demystifying Functions

## Why Demystification?

::: {.incremental}
-   Programming as a beginner is mysterious and scary
-   Things almost seem to work by magic
:::

::: {.fragment .absolute left=50 top=350}
![](images/mops3.jpg){width=400 height=300}
:::

::: incremental
-   **How can we fix something magical when it breaks??**
:::

::: {.fragment .absolute right=50 top=350}
![](images/fantasia.jpg){width=400 height=300}
:::

## Why Demystification?

::: {.incremental}
-   Similar panic can be induced by stats formula
-   Mapping intuition onto an equation is not easy
-   What if we can find a common solution?
:::

::: {.fragment .absolute left=250 width=700 height=400}
![](images/oneplusone.png)
:::

## The Goal

::: {.incremental}
-   Crack open the black box of functions in coding
-   Systematically defang scary formulas
-   Instill a sense of confidence and independence
:::

::: {.fragment .absolute left=250 width=500 height=300}
![](images/fantasia2.jpg)
:::

## The `function()` Function {auto-animate="true"}

::: fragment
-   **Input**: We use the function function to specify our inputs
:::

::: fragment
```{r}
function(`input`)
```
:::

::: fragment
-   **Process**: We put the process inside the curly brackets `{}`
:::

::: fragment
```{r}
function(`input`){
  # inside the curly brackets goes the process
}
```
:::

::: fragment
-   **Output**: We specify the output using `return()`
:::

::: fragment
```{r}
function(`input`){
  `process` # inside the curly brackets goes the process
  return(`output`) # the outcome of the process goes here
}
```
:::

## Step 1: I Make a Mean Function

::: incremental
-   We need a non-intimidating example to ease into things
-   The mean is a simple & familiar statistical concept
-   An ideal starting point for demystification!!
:::

::: {.fragment .absolute right=100 width=400 height=400}
![](images/mean.png)
:::

::: {.fragment .absolute left=150 bottom=150}
$$
\bar{x} = \frac{\sum x}{n} 
$$
:::

## Mean Function: Input {auto-animate="true"}

::: fragment
A vector of numeric values (`x`)
:::

::: {.absolute top="400" left="0" width=700 height="300"}
```{r}
mean_function <- function(x){
  
  
  
  
  
  
}
```
:::

::: {.fragment .absolute right=0 bottom=100}
$$
\bar{x} = \frac
{\sum \color{red}{x}}
{n} 
$$
:::

## Mean Function: Process {auto-animate="true"}

1. Add up all the values within `x` 

::: {.absolute top=400 left=0 width=700 height="300"}
```{r}
mean_function <- function(x){
  
  numer  <- sum(x)
  
  
  
  
}
```
::: 

::: {.absolute right=0 bottom=100}
$$
\bar{x} = \frac
{\color{red}{\sum x}}
{n} 
$$
:::

## Mean Function: Process {auto-animate=true}

1. Add up all the values within `x` 
2. Find the number of values within `x` 

::: {.absolute top=400 left=0 width=700 height="300"}
```{r}
mean_function <- function(x){
  
  numer  <- sum(x)
  denom  <- length(x)
  
  
  
}
```
:::
::: {.absolute right=0 bottom=100}
$$
\bar{x} = \frac
{\sum x}
{\color{red}{n}} 
$$
:::

## Mean Function: Process {auto-animate=true}

1. Add up all the values within `x` 
2. Find the number of values within `x` 
3. Divide the sum of values by the number of values

::: {.absolute top=400 left=0 width=700 height="300"}
```{r}
mean_function <- function(x){
  
  numer  <- sum(x)
  denom  <- length(x)
  output <- numer/denom
  
  
}
```
::: 
::: {.absolute right=0 bottom=100}
$$
\bar{x} = \color{red}{\frac
{\sum x}
{n}} 
$$
:::

## Mean Function: Output {auto-animate=true}

Return the value contained in `output`

::: {.absolute top=400 left=0 width=700 height="300"}
```{r, eval=TRUE}
mean_function <- function(x){
  
  numer  <- sum(x)
  denom  <- length(x)
  output <- numer/denom
  
  return(output)
}
```
:::
::: {.absolute right=0 bottom=100}
$$
\color{red}{\bar{x}} = \frac
{\sum x}
{n}
$$
:::

## Mean Function: Testing

Now that we have made our function, we can test it by comparing the output it gives us to the regular old `mean()` function in base R!

::: {.fragment .absolute bottom=300}
Let's simulate some random values to test our function with:
:::
::: {.fragment .absolute bottom=100}
```{r, eval=TRUE}
test_data <- rnorm(n = 10, mean = 0, sd = 1)
test_data
```
:::

## Mean Function: Testing
::: {.fragment}
Let's see how our function compares to `mean()` in base R
:::
::: {.fragment}
We can use `test_data` as a test case:
:::
::: {.fragment}
```{r, eval=TRUE}
# print the mean that our function calculates
mean_function(test_data)
```
:::
::: {.fragment}
```{r, eval=TRUE}
# print the mean that the base R function calculates
mean(test_data)

```
:::
:::{.fragment}
```{r, eval=FALSE}
# return TRUE if the two  means are equivalent
mean_function(test_data) == mean(test_data)
```
```{r, eval=TRUE, echo=FALSE}
# return TRUE if the two means are equivalent
round(mean_function(test_data),5) == round(mean(test_data),5)
```
:::
:::{.fragment .absolute bottom=25}
**It wasn't magic after all!!**
:::

## Step 2: Variance is the Spice of Life 

::: {.incremental}
- Now we have dipped our toe in, let's up the complexity
- Variance is a little trickier, but not totally alien
- We can use our new mean function too!
:::
::: {.fragment .absolute right=50 width=400 height=400}
![](images/var.png)
:::

::: {.fragment .absolute left=150 bottom=150}
$$\sigma^2 = \frac{\sum(x - \bar{x})^2}{n-1}$$
:::

## Variance Function: Input {auto-animate=true}
::: fragment
A vector of numeric values (`x`)
:::
::: {.absolute top="400" left="0" width=700 height="300"}
```{r}
var_function <- function(x){
  
  
  
  
  
  
  
}
```
::: 

::: {.fragment .absolute right=0 bottom=100}
$$
\sigma^2 = \frac
{\sum(\color{red}{x} - \bar{x})^2}
{n-1}
$$
:::

## Variance Function: Process {auto-animate=true}

1. Calculate the mean of `x` using our `mean_function()`

::: {.absolute top="400" left="0" width=700 height="300"}
```{r}
var_function <- function(x){
  
  av     <- mean_function(x)
  
  
  
  
  
}
```
:::

::: {.absolute right=0 bottom=100}
$$
\sigma^2 = \frac
{\sum(x - \color{red}{\bar{x}})^2}
{n-1}
$$
:::

## Variance Function: Process {auto-animate=true}

2. Calculate the top part (numerator) of the formula

    1.  subtract the mean from each value of x 

::: {.absolute top="400" left="0" width=700 height="300"}
```{r}
var_function <- function(x){
  
  av     <- mean_function(x)
  numer  <- sapply(x,`-`,av)
  
  
  
  
}
```
::: 

::: {.absolute right=0 bottom=100}
$$
\sigma^2 = \frac
{\sum(x \color{red}{-} \bar{x})^2}
{n-1}
$$
:::

## Variance Function: Process {auto-animate=true}

2. Calculate the top part (numerator) of the formula

    1.  subtract the mean from each value of x 
    2.  square each of the resulting values
    
::: {.absolute top="400" left="0" width=700 height="300"}
```{r}
var_function <- function(x){
  
  av     <- mean_function(x)
  numer  <- sapply(x,`-`,av)^2
  
  
  
  
}
```
::: 

::: {.absolute right=0 bottom=100}
$$
\sigma^2 = \frac
{\sum(x - \bar{x})^\color{red}{2}}
{n-1}
$$
:::

## Variance Function: Process {auto-animate=true}

2. Calculate the top part (numerator) of the formula

    1.  subtract the mean from each value of x 
    2.  square each of the resulting values
    3.  sum all of the squared values together
    
::: {.absolute top="400" left="0" width=700 height="300"}
```{r}
var_function <- function(x){
  
  av     <- mean_function(x)
  numer  <- sum(sapply(x,`-`,av)^2) 
  
  
  
  
}
```
::: 

::: {.absolute right=0 bottom=100}
$$
\sigma^2 = \frac
{\color{red}{\sum}(x - \bar{x})^2}
{n-1}
$$
:::

## Variance Function: Process {auto-animate=true}

3. Calculate the bottom part (denominator) of the formula

::: {.absolute top="400" left="0" width=700 height="300"}
```{r}
var_function <- function(x){
  
  av     <- mean_function(x)
  numer  <- sum(sapply(x,`-`,av)^2)
  denom  <- length(x) - 1
  
  
  
}
```
::: 

::: {.absolute right=0 bottom=100}
$$
\sigma^2 = \frac
{\sum(x - \bar{x})^2}
{\color{red}{n-1}}
$$
:::

## Variance Function: Process {auto-animate=true}

3. Calculate the bottom part (denominator) of the formula
4. Divide the numerator by the denominator

::: {.absolute top="400" left="0" width=700 height="300"}
```{r}
var_function <- function(x){
  
  av     <- mean_function(x)
  numer  <- sum(sapply(x,`-`,av)^2)
  denom  <- length(x) - 1
  output <- numer/denom

  
}
```
::: 

::: {.absolute right=0 bottom=100}
$$
\sigma^2 = \color{red}{
\frac
{\sum (x - \bar{x})^2}
{n-1}
}
$$
:::

## Variance Function: Output {auto-animate=true}

Return the resulting value from Step 4 in the process

::: {.absolute top="400" left="0" width="700" height="300"}
```{r, eval=TRUE}
var_function <- function(x){
  
  av     <- mean_function(x)
  numer  <- sum(sapply(x,`-`,av)^2)
  denom  <- length(x) - 1
  output <- numer/denom
  
  return(output)
}
```
::: 

::: {.absolute right=0 bottom=100}
$$
\color{red}{\sigma^2} = \frac
{\sum (x - \bar{x})^2}
{n-1}
$$
:::

## Variance Function: Testing
::: {.fragment}
Let's use our `test_data` again to see if our function works: 
:::
::: {.fragment}
```{r, eval=TRUE}
# print the variance that our function calculates
var_function(test_data)
```
:::
::: {.fragment}
```{r, eval=TRUE}
# print the variance that the base R function calculates
var(test_data)

```
:::
:::{.fragment}
```{r, eval=FALSE}
# return TRUE if the two variances are equivalent
var_function(test_data) == var(test_data)
```
```{r, eval=TRUE, echo=FALSE}
# return TRUE if the two variances are equivalent
round(var_function(test_data),5) == round(var(test_data),5)
```
:::

:::{.fragment .absolute bottom=50}
**The mystery is disappearing before our eyes!!**
:::

## Step 3: Making a Standard Error (but in a good way)

::: {.incremental}
- We are now ready to put it all together for our SEM function
- This is a nice practical end goal as there no SEM in base R
- A simple equation that neatly applies our `mean` and `var` 
:::

::: fragment
$$
SE = \frac{s}{\sqrt{n}}
$$
:::
::: fragment
Where $s$ is the standard deviation of the sample 
(i.e. the square root of the variance)
:::

## SEM Function: Input {auto-animate=true}
::: fragment
A vector of numeric values (`x`)
:::
::: {.absolute top="400" left="0" width=700 height="300"}
```{r}
sem_function <- function(x){
  
  
  
  
  
  
}
```
::: 

::: {.fragment .absolute right=0 bottom=100}
$$
SE = \frac{s}{\sqrt{n}}
$$
:::

## SEM Function: Process {auto-animate=true}

1. For our numerator, calculate the standard deviation of `x` by taking the square root of our `var_function()`

::: {.absolute top="400" left="0" width=700 height="300"}
```{r}
sem_function <- function(x){
  
  numer  <- sqrt(var_function(x))
  
  
  
  
}
```
:::

::: {.absolute right=0 bottom=100}
$$
SE = \frac
{\color{red}{s}}
{\sqrt{n}}
$$
:::

## SEM Function: Process {auto-animate=true}

1. For our numerator, calculate the standard deviation of `x` by taking the square root of our `var_function()`
2. For our denominator, take the square root of the number of values in `x`

::: {.absolute top="400" left="0" width=700 height="300"}
```{r}
sem_function <- function(x){
  
  numer  <- sqrt(var_function(x))
  denom  <- sqrt(length(x))
  
  
  
}
```
:::

::: {.absolute right=0 bottom=100}
$$
SE = \frac
{s}
{\color{red}{\sqrt{n}}}
$$
:::

## SEM Function: Process {auto-animate=true}

1. For our numerator, calculate the standard deviation of `x` by taking the square root of our `var_function()`
2. For our denominator, take the square root of the number of values in `x`

::: {.absolute top="400" left="0" width=700 height="300"}
```{r}
sem_function <- function(x){
  
  numer  <- sqrt(var_function(x))
  denom  <- sqrt(length(x))
  output <- numer/denom
  
  
}
```
:::

::: {.absolute right=0 bottom=100}
$$
SE = \color{red}{\frac
{s}
{\sqrt{n}}
}
$$
:::

## SEM Function: Output {auto-animate=true}

Return the resulting value from this division
    
::: {.absolute top="400" left="0" width=700 height="300"}
```{r}
sem_function <- function(x){
  
  numer  <- sqrt(var_function(x))
  denom  <- sqrt(length(x))
  output <- numer/denom
  
  return(output)
}
```
::: 

::: {.absolute right=0 bottom=100}
$$
\color{red}{SE} = \frac
{s}
{\sqrt{n}}
$$
:::

::: fragment
And of course you can start to simplify things e.g. 
:::

::: fragment
```{r}
sem_function_mini <- function(x){
  sd(x)/sqrt(length(x))
}
```
:::

## Of course many mysteries remain...
::: incremental
- Demystification is a philosophy, not a lesson
- The core idea is **emboldening** and **empowering** learners 
- Programming has a special capacity to overwhelm:

  - Software and package installation/dependencies
  - Project & file management
  - Unintuitive logic & conventions
  - $\color{red}{\textbf{ERRORS}}$
  
:::