Solutions to this workshop can be found here

The techniques we’ve learned in the last few workshops are geared towards helping you understand the basics of how to analyze data in R. However, R is a full-fledged programming language, and you can use it to do a lot more than just plot data and run stats.

One technique that can be incredibly helpful in planning experiments, understanding data, and trying out statistical approaches is simulation. In many cases, by simulating what we expect our data to look like (ideally before even setting up any experiments), we can quickly figure out confounding factors in experimental design we had not yet thought about; estimate the sample sizes we would need to detect effects that interest us, if those effects indeed exist; and start to think about and program the statistical analyses we’d have to perform on our real data once we have it.

These final workshops cover some ideas that are fundamental to programming in any language through the lens of simulating the expected results of an experiment. We’ll also try to come back to some of the concepts we’ve already covered, but a key point is that while most of the material in workshops 5-7 is quite specific to R, the ideas we’ll cover in this workshop will carry over (with some syntax differences) to any other computer language you learn.

Conditional (If/Else) Statements

One very useful construct in programming is a conditional statement. It allows you to perform different actions (run different code) in different situations. This won’t really be used in our simulation, but it’s really useful in many other contexts. These statements look something like this:

if (some_logical_statement){
  ...do one thing...
} else if (some other logical statement){
  ...do a different thing...
} else{
  ...do a third thing...
}

These conditional statements can contain just the if part, or just the if and else parts, or any number of else if statements in the middle.

They look something like this:

best_plant <- 'moss'

if (best_plant == 'moss'){
  print("Bryophytes forever")
}else{
  print("You're mistaken")
}

Try changing the value of the best_plant variable above and re-running the code.

Importantly, these chains of statements are evaluated top to bottom, and once one part is found to be true, the rest is not run. Take a look at this example:

current_value <- 8

if (current_value > 6){
  print('Greater than 6')
} else if (current_value > 4){
  print("Greater than 4, but not 6!")
} else{
  print("Less than or equal to 4")
}

Notice that if we set current_value to 8, even though that’s both greater than 6 AND 4, only the first statement prints. This is what the else part of the else if is doing.

Simulation experiment setup

We’ve been working with the iris dataset throughout this course, so let’s stick with plants for this simulation! Let’s think about an experiment in which we try to test the effect of salt on plant growth. This will allow us to explore some of the key programming concepts we want to learn.

Using variables to set up simulations

Let’s start simple, and try to just perform a very simple digital plant growth experiment, with no salt treatment for now. We can start our virtual plants as seeds at timepoint t0, and record their height in centimeters in a vector. Here, we need to make a key first decision: sample size!

Let’s decide our sample size is 3 for now. One (not great) way we can make our initial vector is by just writing out the starting heights.

not_great_day_0_plants <- c(0, 0, 0)

Why is this not great? Well, what if we want to start with a much larger sample size? Or, what if we want to be able to easily change the sample size in our experiment, as we’ll want to do later? Instead, we can declare the sample size as a variable, and use the rep() function, which repeats a vector (or single string/number) a specified number of times, to create this initial vector. (A note for your future programmer self: rep() can be used to repeat both individual elements in a vector and a whole vector, and can come in quite useful.)

# declare sample size
sample_size <- 3
# create a vector in which 0 is repated sample_size times
day_0_plants <- rep(0, sample_size)
print(day_0_plants)

OK, now let’s try to make our plants grow. Here, we need to decide how many centimeters our plants are growing each day!

# specify plant growth per timepoint
plant_growth_per_day <- 0.5

# create a new vector, day_1_plants, in which each of the plants grows by
# plant_growth_per_day

Simulation using randomly drawn numbers

This model, in which each plant grows identically by the same amount every day, hardly seems realistic or useful. Maybe a more realistic model is that each plant grows some amount on average, but with random noise in each plant’s growth amount. R can easily simulate randomly drawn numbers from a large number of distributions, with the format r{distribution name abbreviation}({sample_number_to_draw}, {distribution parameters}), where the ‘r’ at the beginning stands for ‘random’: for example, for random samples from a normal distribution, we can use rnorm({sample_number_to_draw}, {mean}, {standard_deviation}), for a binomial distribution rbinom({sample_number_to_draw}, {num_trials}, {trial_probability}), etc. The documentation for these functions in R is usually quite helpful.

We’ll use a Normal distribution to model growth here, even though that’s really not a good idea in general, since that can result in negative growth amounts. Thinking about what the noise in your data might realistically look like is key for both running your simulations and running statistical analysis on your data!

# specify the standard deviation of daily plant growth
plant_growth_sd <- 0.1

# create a new vector, day_2_plants, using day_1_plants, plant_growth_per_day,
# plant_growth_sd, and the rnorm() function

Let’s remind ourselves of the assumptions in our model so far:

  • linear growth
  • all seeds germinate on day 0
  • normally distributed growth rates

Saving simulation results into a dataframe

We now have two vectors, day_0_plants and day_1_plants, for the growth of plants over time. However, what if we want to track these plants over the course of a month? Do we make a new vector for each day? And, how do we handle plotting these plants’ growth, or doing statistical analysis (e.g. trying to run lm())? Clearly, it’d be better to put this data into a “tidy” dataframe.

The first step to doing this is thinking about what that would look like. Remember that in a tidy dataframe, each individual observation has its own row. But what is an observation here? Is it a single plant, with a column for each day’s height? Or is it a single plant on a single day? Remember that one thing that may help you to think about this is to imagine plotting this data on a scatterplot (e.g. plant height over time). If you’re using ggplot, each observation (row) would result in a single point on your plot.


As hopefully everyone agrees, our dataframe in this case should have a single row for our observation of each plant on each day, with a height column for that day. We should also have a day column to indicate which day the height was recorded on. Finally, it’s probably a good idea to have some sort of plant.id column, so that we can look at the growth of individual plants later on if we need.

Let’s first create a dataframe just for the day 0 data.

# Create a new dataframe, day_0_df, containing the columns described above, and
# the data for plant heights from day_0_data (hint: check class 5)
# For simplicity, make plant.id just integers from 1 to sample_size
# hint: use seq() or just a colon

We can now create a new dataframe for the day 1 data based on the day 0 dataframe

# Use day_0_df, as well as the rnorm function and parameters described above, to
# create a new dataframe, day_1_df

We can combine day_0_df and day_1_df into a single tidy dataframe by using the rbind() (row bind) function, which adds a dataframe to the bottom of another dataframe, as long as they have the same columns.

plant_growth_df <- rbind(day_0_df, day_1_df)

Writing custom functions

Above, we have the code we need to add a day of growth to an existing dataframe. Let’s create a function to do this automatically. That way, when we need to add a new day to plant_growth_df in the future, we can do this automatically in a single line, by calling our function the same way we call any other function in R.

Simple function example

Below is an example of what a function with two inputs (input_1 and input_2) and one output (output_2) would look like:

my_function_name <- function(input_1, input_2){
  # Some code that does something to input_1 and input_2 to create an
  # output_variable, output_1
  # ...
  return(output_1)
}

Notice that you’re assigning the function to a function name you make up, just like you’d assign a variable. The variable names in parentheses after function are inputs into your function; these will be used as variables inside the function code. Then you open a curly brace {, write out the code of your function, and end it with a return(). Although functions in R will work without a return(), their behavior will be unclear and maybe difficult to predict, so I really suggest not forgetting to include this line (once!) at the end of every function.

Also, note that the code inside your function can work just like any other code: you can declare variables, run other functions (either built-in, or ones you’ve already declared earlier), etc. The caveat, though, is that the only variables you should assume the function has access to at the start are the input variables specified in your parentheses. Think of a function as a completely closed box that can only communicate with the rest of your code via the input(s) you pass into it, and the output(s) it returns.

Here’s a function that finds the hypotenuse of a right triangle. It needs to take two inputs and add their squares, and then return the square root of the result.

# create a function that calculates the length of the hypotenuse of a right
# triangle
pythagorean_theorem_fun <- function(side_1, side_2){
  # square each of the triangle sides and add them
  hypotenuse_squared <- side_1^2 + side_2^2
  # take the square root of the sum of squared sides
  hypotenuse <- sqrt(hypotenuse_squared)
  # don't forget to tell R which of the variables created inside this function
  # you want it to output!
  return(hypotenuse)
}

# Try running the function above on some test numbers, just as you would any
# other R function

Notice that my function contains a ton of comments, explaining exactly what each of the steps does. Doing this will get you a big, big thank you from your future self!

One really key thing to remember, especially in R, is to be careful about naming variables inside this function. You want to avoid declaring a function in which some variables are called the same thing as variables you already have loaded into your workspace: this could cause the source of any errors in your function to be incredibly difficult to track down. So, be creative about your variable names.

Writing a function for plant growth

Now we can start putting together our plant growth function. First, we need to figure out what the inputs and outputs of our function will be. Here’s a proposal:

Inputs:

  • a dataframe containing plant heights for previous days (something that looks like plant_growth_df)
  • the ‘current day’
  • mean plant growth per day
  • standard deviation of plant growth per day

Outputs:

  • a dataframe containing plant heights, with the new day’s growth added

We’ll also need to figure out the steps we’ll need to get from the inputs to the outputs. Again, here is a proposal:

Algorithm

  1. Subset the data from the plant height dataframe, containing only the data recorded on the day before the ‘current day’
  2. Create a new dataframe for the ‘current’ day, using rnorm() and the previous day’s heights to generate new heights
  3. Combined the new dataframe with the full plant height dataframe
  4. Return the new, combined plant height dataframe using the return() function (this is how R knows what you want the output of the function to be!)

Let’s follow the template above to write a function that takes in a dataframe containing plant heights (something that looks like plant_growth_df, for example), as well as the other required inputs, as described above.

# Write a function called grow_plants that adds a day of plant growth to a
# dataframe containing plant_IDs, plant heights, and growth days

# Run grow_plants on plant_growth_df to add another day to this dataframe

Saving function scripts

Let’s save our grow_plants() function to its own separate script so we can use it again next time.

  1. Click on File -> New File -> R Script. A new tab should appear in Rstudio.

  2. Take the entire grow_plants function (including the part where you assign the function to the grow_plants variable), copy it, and paste it into the newly opened script.

  3. Click on File -> Save As, and save your function somewhere on your computer (probably best to do this in the directory where you are saving your notebooks for this course). You can name the file anything you want (it should have a .R extension), but I suggest naming files that hold functions after the functions themselves, i.e. grow_plants.R.

  4. To test that this worked, clear everything in your environment using the little broom at the top right corner of your screen. Then, run the source() command with the full path to grow_plants.R as the argument

# something like this
source('~/Documents/Teaching/Intro_R_Course/grow_plants.R')
  1. Check that the grow_plants() function has appeared in your Environment. You can try rerunning it using the code above
---
title: "Intro R Course, Workshop 8: Basics of programming, and simulation in biology (Part I)"
subtitle: |
    |   - conditional statements
    |   - simulating biological data (intro)
    |   - random number generation
    |   - writing your own functions
author:
  - Eugene Plavskin
output:
  html_notebook:
    code_folding: show
    depth: 3
    tidy: yes
    toc: yes
---
**Solutions to this workshop can be found [here](Solutions_Workshop_8.nb.html)**

The techniques we've learned in the last few workshops are geared towards helping you understand the basics of how to analyze data in R. However, R is a full-fledged programming language, and you can use it to do a lot more than just plot data and run stats.

One technique that can be incredibly helpful in planning experiments, understanding data, and trying out statistical approaches is *simulation*. In many cases, by simulating what we expect our data to look like (ideally before even setting up any experiments), we can quickly figure out confounding factors in experimental design we had not yet thought about; estimate the sample sizes we would need to detect effects that interest us, if those effects indeed exist; and start to think about and program the statistical analyses we'd have to perform on our real data once we have it.

These final workshops cover some ideas that are fundamental to programming in any language through the lens of simulating the expected results of an experiment. We'll also try to come back to some of the concepts we've already covered, but a key point is that while most of the material in workshops 5-7 is quite specific to R, the ideas we'll cover in this workshop will carry over (with some syntax differences) to any other computer language you learn.

# Conditional (If/Else) Statements

One very useful construct in programming is a conditional statement. It allows you to perform different actions (run different code) in different situations. This won't really be used in our simulation, but it's really useful in many other contexts. These statements look something like this:
```{}
if (some_logical_statement){
  ...do one thing...
} else if (some other logical statement){
  ...do a different thing...
} else{
  ...do a third thing...
}
```
These conditional statements can contain just the `if` part, or just the `if` and `else` parts, or any number of `else if` statements in the middle.

They look something like this:
```{r}
best_plant <- 'moss'

if (best_plant == 'moss'){
  print("Bryophytes forever")
}else{
  print("You're mistaken")
}
```
Try changing the value of the `best_plant` variable above and re-running the code.

Importantly, these chains of statements are evaluated top to bottom, and once one part is found to be true, the rest is not run. Take a look at this example:
```{r}
current_value <- 8

if (current_value > 6){
  print('Greater than 6')
} else if (current_value > 4){
  print("Greater than 4, but not 6!")
} else{
  print("Less than or equal to 4")
}
```
Notice that if we set current_value to 8, even though that's both greater than 6 AND 4, only the first statement prints. This is what the `else` part of the `else if` is doing.

# Simulation experiment setup

We've been working with the iris dataset throughout this course, so let's stick with plants for this simulation! Let's think about an experiment in which we try to test the effect of salt on plant growth. This will allow us to explore some of the key programming concepts we want to learn.

## Using variables to set up simulations

Let's start simple, and try to just perform a very simple digital plant growth experiment, with no salt treatment for now. We can start our virtual plants as seeds at timepoint *t0*, and record their height in centimeters in a vector. Here, we need to make a key first decision: sample size!

Let's decide our sample size is 3 for now. One (not great) way we can make our initial vector is by just writing out the starting heights.
```{r}
not_great_day_0_plants <- c(0, 0, 0)
```

Why is this not great? Well, what if we want to start with a *much* larger sample size? Or, what if we want to be able to easily change the sample size in our experiment, as we'll want to do later? Instead, we can declare the sample size as a variable, and use the `rep()` function, which repeats a vector (or single string/number) a specified number of times, to create this initial vector. (A note for your future programmer self: `rep()` can be used to repeat both individual elements in a vector and a whole vector, and can come in quite useful.)
```{r}
# declare sample size
sample_size <- 3
# create a vector in which 0 is repated sample_size times
day_0_plants <- rep(0, sample_size)
print(day_0_plants)
```

OK, now let's try to make our plants grow. Here, we need to decide how many centimeters our plants are growing each day!
```{r}
# specify plant growth per timepoint
plant_growth_per_day <- 0.5

# create a new vector, day_1_plants, in which each of the plants grows by
# plant_growth_per_day

```

## Simulation using randomly drawn numbers

This model, in which each plant grows identically by the same amount every day, hardly seems realistic or useful. Maybe a more realistic model is that each plant grows some amount on average, but with random noise in each plant's growth amount. R can easily simulate randomly drawn numbers from a large number of distributions, with the format `r{distribution name abbreviation}({sample_number_to_draw}, {distribution parameters})`, where the 'r' at the beginning stands for 'random': for example, for random samples from a normal distribution, we can use `rnorm({sample_number_to_draw}, {mean}, {standard_deviation})`, for a binomial distribution `rbinom({sample_number_to_draw}, {num_trials}, {trial_probability})`, etc. The documentation for these functions in R is usually quite helpful.

We'll use a Normal distribution to model growth here, even though that's really not a good idea in general, since that can result in negative growth amounts. **Thinking about what the noise in your data might realistically look like is key for both running your simulations and running statistical analysis on your data!**

```{r}
# specify the standard deviation of daily plant growth
plant_growth_sd <- 0.1

# create a new vector, day_2_plants, using day_1_plants, plant_growth_per_day,
# plant_growth_sd, and the rnorm() function

```

**Let's remind ourselves of the assumptions in our model so far:**

* linear growth
* all seeds germinate on day 0
* normally distributed growth rates

## Saving simulation results into a dataframe

We now have two vectors, `day_0_plants` and `day_1_plants`, for the growth of plants over time. However, what if we want to track these plants over the course of a month? Do we make a new vector for each day? And, how do we handle plotting these plants' growth, or doing statistical analysis (e.g. trying to run `lm()`)? Clearly, it'd be better to put this data into a "tidy" dataframe.

The first step to doing this is thinking about what that would look like. Remember that in a tidy dataframe, each individual observation has its own row. But what is an observation here? Is it a single plant, with a column for each day's height? Or is it a single plant on a single day? Remember that one thing that may help you to think about this is to imagine plotting this data on a scatterplot (e.g. plant height over time). If you're using ggplot, each observation (row) would result in a single point on your plot.

***

As hopefully everyone agrees, our dataframe in this case should have a single row for our observation of each plant on each day, with a `height` column for that day. We should also have a `day` column to indicate which day the height was recorded on. Finally, it's probably a good idea to have some sort of `plant.id` column, so that we can look at the growth of individual plants later on if we need.

Let's first create a dataframe just for the day 0 data.
```{r}
# Create a new dataframe, day_0_df, containing the columns described above, and
# the data for plant heights from day_0_data (hint: check class 5)
# For simplicity, make plant.id just integers from 1 to sample_size
# hint: use seq() or just a colon

```

We can now create a new dataframe for the day 1 data based on the day 0 dataframe
```{r}
# Use day_0_df, as well as the rnorm function and parameters described above, to
# create a new dataframe, day_1_df

```

We can combine `day_0_df` and `day_1_df` into a single tidy dataframe by using the `rbind()` (row bind) function, which adds a dataframe to the bottom of another dataframe, as long as they have the same columns.
```{r}
plant_growth_df <- rbind(day_0_df, day_1_df)
```

# Writing custom functions

Above, we have the code we need to add a day of growth to an existing dataframe. Let's create a function to do this automatically. That way, when we need to add a new day to plant_growth_df in the future, we can do this automatically in a single line, by calling our function the same way we call any other function in R.

## Simple function example

Below is an example of what a function with two inputs (`input_1` and `input_2`) and one output (`output_2`) would look like:
```{}
my_function_name <- function(input_1, input_2){
  # Some code that does something to input_1 and input_2 to create an
  # output_variable, output_1
  # ...
  return(output_1)
}
```
Notice that you're assigning the function to a function name you make up, just like you'd assign a variable. The variable names in parentheses after `function` are inputs into your function; these will be used as variables inside the function code. Then you open a curly brace `{`, write out the code of your function, and end it with a `return()`. Although functions in R will work without a `return()`, their behavior will be unclear and maybe difficult to predict, so I really suggest not forgetting to include this line (once!) at the end of every function.

Also, note that the code inside your function can work just like any other code: you can declare variables, run other functions (either built-in, or ones you've already declared earlier), etc. The caveat, though, is that the only variables you should assume the function has access to at the start are the input variables specified in your parentheses. **Think of a function as a completely closed box that can only communicate with the rest of your code via the input(s) you pass into it, and the output(s) it returns.**

Here's a function that finds the hypotenuse of a right triangle. It needs to take two inputs and add their squares, and then return the square root of the result.
```{r}
# create a function that calculates the length of the hypotenuse of a right
# triangle
pythagorean_theorem_fun <- function(side_1, side_2){
  # square each of the triangle sides and add them
  hypotenuse_squared <- side_1^2 + side_2^2
  # take the square root of the sum of squared sides
  hypotenuse <- sqrt(hypotenuse_squared)
  # don't forget to tell R which of the variables created inside this function
  # you want it to output!
  return(hypotenuse)
}

# Try running the function above on some test numbers, just as you would any
# other R function

```
Notice that my function contains a ton of comments, explaining exactly what each of the steps does. Doing this will get you a big, big thank you from your future self!

One really key thing to remember, especially in R, is to be careful about naming variables inside this function. **You want to avoid declaring a function in which some variables are called the same thing as variables you already have loaded into your workspace**: this could cause the source of any errors in your function to be incredibly difficult to track down. So, be creative about your variable names.

## Writing a function for plant growth

Now we can start putting together our plant growth function. First, we need to figure out what the inputs and outputs of our function will be. Here's a proposal:

**Inputs:**

* a dataframe containing plant heights for previous days (something that looks like `plant_growth_df`)
* the 'current day'
* mean plant growth per day
* standard deviation of plant growth per day

**Outputs:**

* a dataframe containing plant heights, with the new day's growth added

We'll also need to figure out the steps we'll need to get from the inputs to the outputs. Again, here is a proposal:

**Algorithm**

1. Subset the data from the plant height dataframe, containing only the data recorded on  the day before the 'current day'
2. Create a new dataframe for the 'current' day, using `rnorm()` and the previous day's heights to generate new heights
3. Combined the new dataframe with the full plant height dataframe
4. *Return the new, combined plant height dataframe* using the `return()` function (this is how R knows what you want the output of the function to be!)

Let's follow the template above to write a function that takes in a dataframe containing plant heights (something that looks like plant_growth_df, for example), as well as the other required inputs, as described above.
```{r}
# Write a function called grow_plants that adds a day of plant growth to a
# dataframe containing plant_IDs, plant heights, and growth days

# Run grow_plants on plant_growth_df to add another day to this dataframe

```

## Saving function scripts

Let's save our `grow_plants()` function to its own separate script so we can use it again next time.

1. Click on File -> New File -> R Script. A new tab should appear in Rstudio.

2. Take the entire grow_plants function (including the part where you assign the function to the `grow_plants` variable), copy it, and paste it into the newly opened script.

3. Click on File -> Save As, and save your function somewhere on your computer (probably best to do this in the directory where you are saving your notebooks for this course). You can name the file anything you want (it should have a *.R* extension), but I suggest naming files that hold functions after the functions themselves, i.e. *grow_plants.R*.

4. To test that this worked, clear everything in your environment using the little broom at the top right corner of your screen. Then, run the `source()` command with the full path to *grow_plants.R* as the argument
```{r}
# something like this
source('~/Documents/Teaching/Intro_R_Course/grow_plants.R')
```

5. Check that the `grow_plants()` function has appeared in your Environment. You can try rerunning it using the code above





