MakingAndBreakingFunctions_InClass.Rmd

---
title: "MakingAndBreakingFunctions"
author: "Ian Dworkin"
date: "`r format(Sys.time(),'%d %b %Y')`"
output: 
  html_document: 
    toc: yes
    number_sections: yes
    keep_md: yes
editor_options: 
  chunk_output_type: console
---

```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
options(digits = 2)
```


## Why write a function in R?

- We have now used a few built in functions in R (there are many). 
- anything where you use "()" is a function.

- We have also written custom functions, as shown in class and in your assignment.


## Why write your own functions

However, if you write some good functions and scripts people will want to use them and edit them for their own purposes. Of course, they (and even you 6 months later) don't always know what the functions are always supposed to do or not do. So it is useful to always build robust functions that spit out warnings and errors, and also to consider unit tests.

As a review [here](https://r4ds.had.co.nz/functions.html#when-should-you-write-a-function) and [here](https://r4ds.had.co.nz/functions.html)


## When should you write a function
Have you ever copy and pasted a block of code more than a couple of times? If so, write a function! Indeed, this rule-of-thumb is called the [rule of three](https://en.wikipedia.org/wiki/Rule_of_three_(computer_programming). In addition to saving time for repeated use, it reduces the risks of introducing errors into your code. 


 Thankfully it is straightforward to write our own functions in R. You should definitely get in the habit of doing so whenever you are going to need to do something more than once. You can collect all of these functions in a script and can use `source()` to read them in whenever you need them. No copying-pasting functions in lots of different places!
 
 
## Review: functions have the following format
```{r, eval = FALSE}
aFunction <- function(input variable 1, input variable 2, argument, etc...) {
expressions to calculate}
```

This is abstract so let me give you a real example.

We want to compute the standard error of the mean (SEM) which is approximately equal to the standard deviation divided by the square root of the sample size. How might we do it?

## standard error of the mean 

```{r}
a <- c(1,2,3,5,7,3,2,5,2) # our data 

sd_a <- sd(a)

sample_a <- length(a)

sd_a/sqrt(sample_a)
```


Or we could do it in one line. ** Notice the call to a function within a function**

```{r}
sd(a)/sqrt(length(a)) 
```


But what happens if we have another set of data `b` that we want to examime

```{r}
b <- rnorm(100, mean = 10, sd = 1)

sd(b)/sqrt(length(b)) 

```

or c? d?

 This gets not only very monotonous, but very error prone!
 
## SEM as a function

 Try to write a function for the SEM 
 
 
## SEM function

```{r}
StdErr <- function(dat_in) {
       sd(dat_in) / sqrt(length(dat_in)) }
```


Now we can just use the variable `a` we created above that stores the vector of numbers and plug it in to our function. 

```{r}
StdErr(a)
```


We can also easily use it for other data like in the object `b`

```{r}
StdErr(b)
```


## taking a look at our function


Just type the name of the function to see what the function is.

```{r}
StdErr
```


And if you want to edit it

```{r}
edit(StdErr)
```


## looking at base R functions does not always work so easily

```{r}
mean
```


This is because many of the functions are either hidden or in this case written in another programming language that R calls. You can [read here](https://stackoverflow.com/questions/19226816/how-can-i-view-the-source-code-for-a-function)


## What if you want to return multiple things from your function

Practically speaking the last thing you write will be returned in a function, but it is better to be a bit formal about it with the `return()` function.

So this will not behave as you might expect. Why?


```{r}
StdErr_V2 <- function(vector_vals) {
       se <- sd(vector_vals)/sqrt(length(vector_vals))} 
```


```{r}
StdErr_V2(a)
```


## using return

```{r}
StdErr_V3 <- function(vector_vals) {
       se <- sd(vector_vals)/sqrt(length(vector_vals))
       return(se)} 
```


```{r}
StdErr_V3(a)
```

## you can give the output names

```{r}
StdErr_V4 <- function(vector_vals) {
       se <- sd(vector_vals)/sqrt(length(vector_vals))
       return(c(StandardError = se))} 
```

```{r}
StdErr_V4(a)
```


You may have noticed that despite only having one output, I have concatenated this. This is a bit of an R thing, but it comes in handy when we want multiple outputs


```{r}
StdErr_V5 <- function(vector_vals) {
       se <- sd(vector_vals)/sqrt(length(vector_vals))
       return(c(StandardError = se, 
                StandardDeviation = sd(vector_vals)))} 
```

```{r}
StdErr_V5(a)
```

## See if you can modify this to output a list instead of a vector, and it additionally outputs the mean (as well as SE and SD)



```{r}
StdErr_V6 <- function(vector_vals) {
       se <- sd(vector_vals)/sqrt(length(vector_vals))
       return(list(StandardError = se, 
                   StandardDeviation = sd(vector_vals), 
                   Mean_val = mean(vector_vals)))} 
```

```{r}
StdErr_V6(a)
```


## The function you can work with in groups

This function computers the [coefficient of variation.](https://en.wikipedia.org/wiki/Coefficient_of_variation), a *positive*, unitless measure of relative variation. It is nothing more than the ratio of the standard deviation to the mean. 

$$CV = \frac{\sigma}{\mu} = \frac{sd}{mean}$$


## Coefficient of variation

```{r}
CoefVar_v1 <- function(x) {
    cv <- sd(x)/mean(x)
}
```



## Time to break it. 
In groups of 4, each of you will (one at a time) give your version of the function to one other person in the group, who will write some code to "break" the function in some way. Don't tell your neighbours what the variables are, just let them try and use it and break it...


### Things to throw into it

- negative values that give a -ve CV
- NA
- non integer or numeric
- vector of length zero
- Something else?

### Fixes
- `stop` with an if
- `break`
-`stopifnot` # really useful
- checking object class
- `stop` vs. `warning` vs. `message`
-`exist` or `file.exists()`
- `try`
- 
- using `if` in case of different types
- `conditions` for handling unusual conditions


### warning, messages, errors
- `message` (a diagnostic message)
- `warning`