chapter_1.qmd

---
filters:
 - naquiz
format:
  html:
    toc: true
    toc-location: left
    toc-title: "In this chapter:"
---

<!-- things to change: -->

<!-- mention that ~ in path means home -->

<!-- adjust timing -->

# Introduction to R {#sec-chapter01}

In this chapter, we will get familiar with R.

::: {.callout-tip title="Learning Objectives"}
1.  Use RStudio to create an R project and R script

2.  Perform basic mathematical operations, comparisons and function calls in R

3.  Store the results of analysis in variables

4.  Describe the different data types and data structures used in R

5.  Recall how to use RStudio to find data files and read them in as data frames
:::

## Using RStudio {#sec-usingRstudio}

### What is R and RStudio? {#sec-whatIsR}

**R** is a free and popular statistical programming language, great for performing data analysis. **RStudio** is a free [integrated development environment (IDE)](https://en.wikipedia.org/wiki/Integrated_development_environment) that provides useful support features for writing code. During this course, we will learn how to use RStudio's handy features like projects (which help us to keep track of different analyses) and the environment panel (which shows us all of our data/variables in one place).

### Creating a project {#sec-creatingProject}

Rstudio Projects are a way we can organise our work in RStudio, so that we can resume where we left off and keep different analyses separate. Any time you start working on something new (like this course!) it is recommended that you start a new project. You can see the current project you're working on, switch between projects or create a new project using the menu in the top right hand corner of RStudio:

![In the top right hand corner of RStudio, you can see all of your projects](images/S01F01_make_project.png){width="960"}

To begin this course, let's make a new project. We'll do this in a new directory (folder) so that everything stays organised:

![We usually want to make a new project in its own directory (folder)](images/S01F02_make_project.png){width="960"}

Next, we need to tell R that we want to make a 'New Project' and not any of the other fancy things we could create:

![There are many types of projects we can make in R, but for now we'll stick with a regular project.](images/S01F03_make_project.png){width="960"}

Finally, we need to give our project an informative name:

![Choose a name that will help you remember what this project is about!](images/S01F04_make_project.png){width="960"}

::: {.callout-note title="Name with underscores, not spaces"}
You'll notice I named my project using an underscore (R_course) rather than a space (R course). **In general, when coding we want to name things without spaces**, so that it is clear to the computer that we are talking about a single entity (the 'R_course') as opposed to multiple things ('R' and 'course'). We'll revisit this idea later in the chapter in @sec-variables
:::

### Creating an R script {#sec-createRScript}

Now that our project is set up, we need to create a file to write our code in:

![How to create a new R Script](images/S01F05_new_script.png){width="960"}

This file is called an **R Script**. Don't forget to save your R Script as you work so you don't lose your progress! You can do this through the file menu or by using the keyboard shortcut {{< kbd Cmd-S >}}.

### Overview of the RStudio layout

At this point, your RStudio window should look like this, with four different panels visible:

![The four panels of RStudio](images/S01F06_panels.png){width="960"}

This is what they're used for:

1.  **The R Script panel.** This is a text document where you can write code, and run it by highlighting the code or putting your cursor on that line, then either clicking the 'Run' button in the top-right corner, or using the {{< kbd Cmd-Enter >}} keyboard shortcut.

2.  **The console.** This is where the output (results) of your code will appear. You can also run code in the console, by typing it next to the `>` symbol and pressing {{< kbd Enter >}} but it's better to use the R Script, as the code you write there is saved and acts as a record of your work.

3.  **The environment panel.** This is where the data and variables you use in your analysis will be listed. More on this later.

4.  **The files/plot/help panel.**

    -   Under the 'files' tab you can see the files in your current folder

    -   Under the 'plots' tab you can view the plots you have created

    -   Under the 'help' tab you can read manual pages to learn how to use functions

Although there are other tabs for some of these panels, they are used for more niche things out of scope of this course. You can read more about it in the [RStudio documentation](https://docs.posit.co/ide/user/ide/guide/ui/ui-panes.html).

### Writing our first piece of code

Now we are ready to write our bit of code! We'll start with one of the most important concepts in programming: comments. Comments are lines of our script that begin with `#` and they are ignored by the computer: they are just notes that we write to ourselves. It's really important to write 'well-commented' code, with plenty of comments that clearly explain what your code is doing, so that your script can easily be understood by whoever looks at it next (whether this is someone else or you revisiting an analysis many months later!)

::: {.callout-warning title="Don't forget your #"}
If you forget the `#` at the start of your comment, R will try to interpret your notes as actual code, and you'll get an error message:

```{r}
#| error: true
oops I forgot the hashtag
```
:::

During this course, we will practice writing well-commented code, but here is an example of how we could write comments to explain the code for one plus one:

```{r}
#| eval: false
# calculate one plus one
1 + 1 # the + symbol means plus
```

Note that comments can be written on their own line or at the end of a line after the code. Crucially, you cannot write any code after a `#` on the same line, as R will ignore it. This is sometimes useful for 'commenting out' code that you don't want to run, but want to keep in your script for later use.

## Practicing R code with maths {#sec-maths}

To practice running R code, let's do some maths. Here's how to code some basic mathematical operations in R:

| Operation | Code | Example |
|----|----|----|
| Addition | `+` | one plus one: `1 + 1` |
| Subtraction | `-` | two minus ten: `2 - 10` |
| Multiplication | `*` | eight times 4: `8 * 4` |
| Division | `/` | ten divided by 3: `10 / 3` |
| Exponents | `^` | three squared: `3 ^ 2` |
| Brackets | `()` | sixteen divided by the result of three minus one: `16 / (3 - 1)` |

Like in regular maths, R follows the order of operations. Here, the `3 + 2` in the brackets will be evaluated first, and then result will be multiplied by 7.

```{r}
# brackets evaluate first
(3 + 2) * 7
```

You might notice when running this code that before the output (result), there is a number one that looks like this: `[1]`. This relates to the length of our output, which here is just one single number (hence the `1`). Later in the chapter we will write code with longer output, and the purpose of this number will become clearer, but you can ignore it for now.

::: {.callout-note title="Using whitespace in code"}
Above we used spaces between the numbers and mathematical operators in our code. R understands code without spaces too, but this makes it easier to read. Note that this is different to when we are naming things, when spaces are bad!

```{r}
# spaces don't matter in code
3 ^ 2
# so both of these should give the same result
3^2
```
:::

::::::::::::::: {.callout-important title="Practice exercises"}
Try these practice questions to test your understanding

:::::::: question
1\. Which R expression would give me a result of 10?

::::::: choices
::: {.choice .correct-choice}
`(2 * 3) + (2 ^ 2)`
:::

::: choice
`(5 - 3) * 4`
:::

::: choice
`1 + 1`
:::

::: choice
`20 - 1`
:::
:::::::
::::::::

:::::::: question
2\. What would be the result of running this line of R code: `# test 1+1`

::::::: choices
::: choice
1
:::

::: choice
2
:::

::: choice
An error
:::

::: {.choice .correct-choice}
Nothing
:::
:::::::
::::::::

<details>

<summary>Solutions</summary>

<p>

1.  `(2 * 3) + (2 ^ 2)` is equal to 10. If you're not sure, try copy-pasting this code into the console and running it! The best way to learn is by doing.

2.  The code `# test 1+1` is a comment, because it starts with a `#`. This means R ignores it: if you run this code, you won't see any output in the console.

</p>

</details>
:::::::::::::::

## Comparisons {#sec-comparisons}

R can perform comparisons, using the following notation:

| Comparison                    | Code         |
|-------------------------------|--------------|
| Equal to                      | `==`         |
| Not equal to                  | `!=`         |
| Greater/less than             | `>` or `<`   |
| Greater/less than or equal to | `>=` or `<=` |

::: {.callout-warning title="Mind your equal signs!"}
Be careful to use double equal signs `==` when checking for equality. If you use only one, you'll get an error:

```{r}
#| error: true
1 == 1 # this is TRUE
1 = 1 # this gives an error
```
:::

Comparisons in R return either `TRUE` or `FALSE`:

```{r}
10 > 10
10 >= 10
```

You can also negate the result of a comparison or any TRUE/FALSE value by using the `!` operator before the expression.

```{r}
# gives FALSE (i.e. not TRUE)
!TRUE

# gives TRUE: 1 is not equal to 2, but we've negated the result
!(1 == 2)
```

This is really useful for filtering data, which we will cover in [Chapter @sec-chapter02]

::::::::::::::::::::: {.callout-important title="Practice exercises"}
Try these practice questions to test your understanding

:::::::: question
1\. What would be the result of running this R code: `10 >= 10`

::::::: choices
::: choice
10
:::

::: choice
`FALSE`
:::

::: {.choice .correct-choice}
`TRUE`
:::

::: choice
An error
:::
:::::::
::::::::

:::::::: question
2\. Which of the following R expressions would give me a result of `FALSE`?

::::::: choices
::: choice
`1 == 1`
:::

::: choice
`1 != (3 - 4) * 1`
:::

::: choice
`1 = 10`
:::

::: {.choice .correct-choice}
`1 == 2`
:::
:::::::
::::::::

:::::::: question
3\. What would be the result of running this R code: `!TRUE`

::::::: choices
::: {.choice .correct-choice}
`FALSE`
:::

::: choice
`TRUE`
:::

::: choice
An error
:::

::: choice
Nothing
:::
:::::::
::::::::

<details>

<summary>Solutions</summary>

<p>

1.  `10 >= 10` is TRUE because 10 is equal to 10, and we are using the greater than or equal to operator, `>=`.
2.  `1 == 2` is the only expression that would give a result of `FALSE`. Be mindful that `1 = 10` is not a valid expression in R, and would give an error (since we need to use the double equal sign `==` for comparisons).
3.  `!TRUE` is `FALSE` because we are negating the value using `!`.

</p>

</details>
:::::::::::::::::::::

## Variables {#sec-variables}

### What's a variable?

A variable (also known as an object) in R is like a label we can use to keep track of values. We assign (save) values to variables so that we can refer to them later.

For example, let's say I use R to do some maths:

```{r}
(2 + 6) * 7
```

R outputs simply the result. To use this value later, I would need to assign the output to a variable.

Variables are assigned with the assignment operator `<-` (you can type this using the {{< kbd < >}} and {{< kbd - >}} keys, or use the shortcut {{< kbd alt- >}}).

::: {.callout-note title="Assignment arrows"}
You might be familiar with assigning values to variables using the equal sign `=`, which is used in other programming languages and in maths. Although this does also work in R, **it's preferred to use the arrow** `<-` as this makes it really clear that a variable is being assigned. In this course we'll be using `<-`.
:::

Returning to our example, let's save the result of the above calculation to a variable called `my_number`

```{r}
# assign the result to my_number
my_number <- (2 + 6) * 7
```

Here, R has performed the calculation to the right of the arrow (`(2 + 6) * 7`) and assigned the result of this to the `my_number` variable.

You'll notice that this line of code doesn't produce any output, because it has gone straight into our variable. If we want to know the value of `my_number`, we can either run it as a line of R code, like so:

```{r}
my_number
```

Or, we can look at the environment panel in RStudio:

![We can see our variables and their values in the environment panel](images/S01F07_environment_panel.png)

### Using variables in R code

Variables can be used in place of values (e.g. numbers) in R code. For example, we can use the `my_number` variable in a calculation:

```{r}
# multiply my_number by 2
my_number * 2
```

As the name suggests, variables can vary! We can assign a new value to a variable at any time:

```{r}
# change the value of my_number to 12
my_number <- 12
my_number
```

Because the right hand side of the arrow is evaluated first, you can also assign to a variable a calculation that involves itself:

```{r}
# add 5 to my_number
my_number <- my_number + 5
my_number # value is now 17 since 12 + 5 = 17
```

::: {.callout-warning title="Careful of cases!"}
One thing we need to be careful of when using variables is that R is case-sensitive. This means that `MY_NUMBER` is not the same as `my_number`:

```{r}
#| error: true
# create the my_number variable
my_number <- (2 + 6) * 7

# produces error because MY_NUMBER is not the same as my_number
MY_NUMBER
```
:::

There's not really any harm in keeping variables around, but if you would like to remove them you can use the `rm()` function like so:

```{r}
# assign a variable
my_variable <- 10

# remove it
rm(my_variable) # put the variable name inside the brackets
```

We'll cover functions in more detail in @sec-functions.

If you want to remove ALL the variables you've assigned and start fresh, you can use the broom button in the environment panel:

![The broom button removes all your variables](images/S01F09_broom_button.png){width="686"}

Try using the broom to clean up your environment after completing the practice exercises at the end of this section.

### Choosing good variable names

When naming variables, we need to follow these rules:

+----------------------------------------------------------------------+----------------------------------------+
| Rule                                                                 | Examples                               |
+======================================================================+========================================+
| **Variable names can only contain letters, numbers and underscores** | ✅ Allowed: `my_number`, `ID_2`        |
|                                                                      |                                        |
|                                                                      | ❌ Not allowed: `my_number!`, `price$` |
+----------------------------------------------------------------------+----------------------------------------+
| **Variable names can't start with a number**                         | ✅ Allowed: `my_number_2`              |
|                                                                      |                                        |
|                                                                      | ❌ Not allowed: `2_my_number`          |
+----------------------------------------------------------------------+----------------------------------------+
| **Variable names can't contain spaces**                              | ✅ Allowed: `my_number`                |
|                                                                      |                                        |
|                                                                      | ❌ Not allowed: `my number`            |
+----------------------------------------------------------------------+----------------------------------------+

If we try to create a variable that breaks these rules, R will give an error:

```{r}
#| error: true
# gives an error because we use a non-allowed character
percentage% <- 100
```

```{r}
#| error: true
# gives an error because we start with a number
1place <- 1
```

```{r}
#| error: true
# gives an error because we have a space
my age <- 5
```

RStudio will try to help you spot these mistakes in your script, by using underlining them in red:

![RStudio underlines errors in your code](images/S01F08_variable_errors.png)

Beyond those three key rules, there are also some best practices we should try to keep in mind when naming our variables:

-   Try not to use capital letters. Since R is case sensitive, `Genes` is a different variable to `genes`. It can be easy to forget to use a capital letter, so it's generally better to avoid them if you can.

-   Use descriptive names. It's better to use a longer name that describes what the variable is for, rather than a short name that doesn't give much information. For example, `gene_counts` is better than `gc`. You'll thank yourself later when you come back to your code and can't remember what `gc` stands for!

-   Avoid using names that are already used in R. For example, `mean` is a function in R that calculates the average of a set of numbers. If you use `mean` as a variable name, this could lead to errors: how will R know if you are referring to the function `mean` or your variable `mean`?

::::::::::::::::::::::::::: {.callout-important title="Practice exercises"}
Try these practice questions to test your understanding

:::::::: question
1\. How would I assign the value of 10 to a variable called `my_variable`?

::::::: choices
::: choice
`10`
:::

::: {.choice .correct-choice}
`my_variable <- 10`
:::

::: choice
`my_variable = 10`
:::

::: choice
`my variable <- 10`
:::
:::::::
::::::::

:::::::: question
2\. I have assigned the value of 10 to a variable called `my_variable` as in Q1. What then would be the output from running this line of R code: `my_variable + 5`?

::::::: choices
::: choice
An error
:::

::: choice
Nothing
:::

::: choice
5
:::

::: {.choice .correct-choice}
15
:::
:::::::
::::::::

:::::::: question
3\. I have assigned the value of 10 to a variable called `my_variable` as in Q1. If I run the code `my_variable <- my_variable + 10`, what is the new value of `my_variable`?

::::::: choices
::: choice
10
:::

::: choice
25
:::

::: {.choice .correct-choice}
20
:::

::: choice
`my_variable`
:::
:::::::
::::::::

:::::::: question
4\. Which of the following is a valid variable name?

::::::: choices
::: choice
`10th_place`
:::

::: choice
`(n)_mice`
:::

::: choice
`disease status`
:::

::: {.choice .correct-choice}
`expression_level`
:::
:::::::
::::::::

<details>

<summary>Solutions</summary>

<p>

1.  `my_variable <- 10` is the correct way to assign the value of 10 to a variable called `my_variable`. Remember the arrow `<-` is used for assignment in R.
2.  The output would be 15, since `my_variable` is 10 and we are adding 5 to it.
3.  The new value of `my_variable` would be 20, since we are adding 10 to the current value of `my_variable` (which is 10). Note that even though we added 5 to `my_variable` earlier, this value is not saved anywhere (since we didn't assign it), so we are starting from the original value of 10.
4.  `expression_level` is the only valid variable name. `10th_place` starts with a number, `(n)_mice` contains brackets, and `disease status` contains a space.

</p>

</details>
:::::::::::::::::::::::::::

## Functions {#sec-functions}

### Functions and arguments

Functions are programs that take inputs (also known as arguments) and produce outputs. They have a name, followed by round brackets `()` which contain the arguments.

For example, when we used the code `rm(my_variable)` earlier, the function `rm()` was taking the input (argument) `my_variable` and producing the output of deleting that variable.

Some functions have multiple arguments, which are specified by separating them with commas. Arguments have a set order in which they can be given, or they can be referred to specifically by their name (using a equal sign `=` to provide a value).

As an example, the `round()` function rounds a number to a specified number of decimal places. The first argument is the number to be rounded, and the second argument is the number of decimal places to round to.

```{r}
# we'll use this decimal to demonstrate the round function
decimal <- 3.14159

# round to 3 decimal places
round(decimal, digits = 3)

# we don't have to specify the argument name if we provide the arguments in the correct order
round(decimal, 3)
```

We can see that both of our calls to the `round()` function produced the same result, but the first is easier to understand since we explicitly specified the argument.

Many arguments have default values so you don't need to specify every argument for every function. For example, the `round()` function has a default value of 0 for the `digits` argument, so if you don't specify it, the number will be rounded to the nearest whole number.

```{r}
round(decimal)
```

::: {.callout-warning title="Common errors with functions"}
Here are some common errors you might encounter when using functions. Have a look at the code below and read the error messages to see how the two relate. This will help you to fix typos/errors in your own code.

```{r}
#| error: true

# forgot to enclose the arguments in brackets
round 3.14159

```

```{r}
#| error: true

# forgot the comma between the arguments
round(3.14159 digits = 3)

```

```{r}
#| error: true

# spelt the argument name wrong
round(3.14159, digts = 3)

```

```{r}
#| error: true

# forgot to close the brackets
round(3.14159, digits = 3
```

RStudio will also flag some of these sorts of issues in the script panel, although it won't catch everything:

![RStudio can help you to find errors in your function calls before you run the code](images/S01F15_errors_in_functions.png){width="900"}
:::

### Getting help with functions: within R

When you're using a function, you might not know what arguments it takes, what they do or what their default values are. Nobody can remember all of this information, so one of the most important skills in programming is learning how to access help.

You can access the help pages for a function by typing `?` followed by the name of the function:

```{r}
#| eval: false
?round
```

Or searching for the function in the help tab in RStudio:

![You can search for functions directly in the help panel](images/S01F10_help_search.png){width="688"}

Here's what the help page looks like for the `round` function:

![The help page for the round function](images/S01F11_help_page.png){width="688"}

Help pages can sometimes be quite technical or complicated– for example the help page for `round` also describes various other similar functions for rounding numbers. Often the most important section to look at is the 'arguments' one:

![Help pages have a section for describing arguments](images/S01F12_help_arguments.png){width="638"}

You can also see help for functions in the script panel, as you are typing your code:

![RStudio will show you a preview of the help page as you type a function name](images/S01F13_help_when_typing.png){width="1438"}

It will also suggest you the names of arguments:

![RStudio also suggests arguments for functions as you type](images/S01F14_help_when_typing_2.png){width="1682"}

So, if you get stuck with how to use a function, wait a moment and see if RStudio will suggest what you need.

### Getting help with functions: beyond R

Sometimes, the R help pages can be pretty tricky to understand, and they can't help you if you don't know the name of the function you need! In this course, we'll learn about lots of different functions, but even R experts need to look things up sometimes. Here are some good resources for getting help:

-   **Google**. R is a pretty popular language, so if you google 'how to do x in R', you'll probably find an answer

-   **Package vignettes**. Many R packages have vignettes, which are short guides to using the package. Once you find the name of a package you might want to use, you should go through their vignettes to see what functions are available and how to use them.

-   **ChatGPT** (or similar). AI tools can be really useful in helping you write code, although make sure you double-check the results because it can make mistakes. Tips and advice on how to effectively use AI tools is available in the "Further reading" section.

-   **Ask others**! There are lots of R users, and working together is often the best way to solve problems. This could be through online forums, like [StackOverflow](http://stackoverflow.com/questions/tagged/r) or in-person

No matter where you get your help, try to make sure you understand the code you find. Reading the help pages for new functions, or asking an AI like ChatGPT to explain what code is doing is a great way to expand your R knowledge. We also list some recommended additional resources in the "Useful references" section of "Further reading".

::::::::::::::::::::: {.callout-important title="Practice exercises"}
Try these practice questions to test your understanding

:::::::: question
1\. What would be the result of running this R code: `round(3.14159, digits = 2)`

::::::: choices
::: choice
3.14159
:::

::: choice
3.141
:::

::: {.choice .correct-choice}
3.14
:::

::: choice
3
:::
:::::::
::::::::

2\. Look up the help pages for the following functions, and describe what they do:

-   `mean()`
-   `Sys.Date()`
-   `sin()`

:::::::: question
3\. What is wrong with this line of R code: `round(3.14159, digits = 3`

::::::: choices
::: choice
Digits is not a valid argument for the round function
:::

::: choice
You need to use a double equal sign `==` for the digits argument
:::

::: choice
You don't need to specify the digits argument
:::

::: {.choice .correct-choice}
You need to close the brackets at the end of the line
:::
:::::::
::::::::

:::::::: question
4\. Which of the following lines of R code will run without error?

::::::: choices
::: choice
`rm(my_variable`
:::

::: choice
`round(3.14159, Digits = 3)`
:::

::: choice
`round(3.14159 digits = 3)`
:::

::: {.choice .correct-choice}
`round(3.14159, 3)`
:::
:::::::
::::::::

<details>

<summary>Solutions</summary>

<p>

1.  The result of running `round(3.14159, digits = 2)` would be 3.14. Remember the `round()` function rounds the number 3.14159 to 2 decimal places, according to the digits argument.
2.  The `mean()` function calculates the average of a set of numbers, `Sys.Date()` returns the current date, and `sin()` calculates the sine of an angle (in radians).
3.  The line of R code `round(3.14159, digits = 3` is missing a closing bracket at the end, which is why it would produce an error.
4.  The line of R code `round(3.14159, 3)` will run without error. The other lines of code have errors: `rm(my_variable` is missing a closing bracket, `round(3.14159, Digits = 3)` has a typo in the argument name (argument names are case sensitive), and `round(3.14159 digits = 3)` is missing a comma between the arguments. Remember that we don't always need to specify the argument names if we provide the arguments in the correct order, which is why we could omit the `digits =` part in the correct line of code.

</p>

</details>
:::::::::::::::::::::

## Data types {#sec-dataTypes}

Every variable in R has a 'type'. The type tells R what kind of data it is and consequently what it can and can't do with the data. For example, it makes sense to perform mathematical functions like multiplication or division on numbers but not on words.

There are three basic types of data in R:

+-------------+---------------------------------------------------------------------------------------------------+-------------------+
| Type        | Description                                                                                       | Examples          |
+=============+===================================================================================================+===================+
| `logical`   | also known as 'boolean', true or false                                                            | `TRUE`            |
|             |                                                                                                   |                   |
|             |                                                                                                   | `FALSE`           |
+-------------+---------------------------------------------------------------------------------------------------+-------------------+
| `numeric`   | numbers                                                                                           | `1`               |
|             |                                                                                                   |                   |
|             |                                                                                                   | `0.523`           |
|             |                                                                                                   |                   |
|             |                                                                                                   | `10000`           |
+-------------+---------------------------------------------------------------------------------------------------+-------------------+
| `character` | text/numbers surrounded by quotation marks (double `""` or single `''`). Also known as a 'string' | `'hello'`         |
|             |                                                                                                   |                   |
|             |                                                                                                   | `"cat"`           |
|             |                                                                                                   |                   |
|             |                                                                                                   | `"my name is..."` |
+-------------+---------------------------------------------------------------------------------------------------+-------------------+

These are called 'atomic' data types as they are the most basic types of data from which other data types derive.

You can find the type of something using the `class()` function:

```{r}
class(TRUE)
class(1)

# whatever you put in quotation marks is always a character
class("hello")
class("TRUE")
class("123")
```

It is important to know the type of your data because, as mentioned earlier, R will not let you perform certain operations on data of the wrong type. For example, you can't add two characters together:

```{r}
#| error: true
# this works
1 + 1

# but this gives an error
"1" + "1"
```

Nor can you use the logical operator `!` on a character:

```{r}
#| error: true
# this works
!TRUE

# but this gives an error
!"TRUE"
```

You'll notice that the error messages for these two examples explain that R can't perform the operation you're asking it to do on that data type.

If you want to change the type of a piece of data, you can use the `as.x()` functions like (e.g.`as.logical()`, `as.numeric()`, and `as.character()`):

```{r}
# convert a number to a character
as.character(100)

# convert a character to a number
as.numeric("100")

```

Of course, it doesn't make sense to make some conversions. In the example below, we can't convert the word "hello" to a number, so we get an `NA`:

```{r}
# if a conversion is not possible, you'll get an NA
as.numeric("hello")
```

::::::::::::::::::::: {.callout-important title="Practice exercises"}
Try these practice questions to test your understanding

:::::::: question
1\. What are the three atomic data types in R?

::::::: choices
::: {.choice .correct-choice}
logical, numeric, character
:::

::: choice
integer, float, string
:::

::: choice
dataset, vector, matrix
:::

::: choice
boolean, text, number
:::
:::::::
::::::::

:::::::: question
2\. How do you find the type of a piece of data in R?

::::::: choices
::: choice
You can't
:::

::: choice
Using the `type()` function
:::

::: choice
Guess
:::

::: {.choice .correct-choice}
Using the `class()` function
:::
:::::::
::::::::

:::::::: question
3\. How would you convert the character "TRUE" to a logical?

::::::: choices
::: choice
`TRUE`
:::

::: {.choice .correct-choice}
`as.logical("TRUE")`
:::

::: choice
You can't convert a character to a logical
:::

::: choice
Using the `logical()` function
:::
:::::::
::::::::

4\. What are the types of the following?

-   `11`

-   `"eleven"`

-   `TRUE`

-   `!FALSE`

-   `0.49826`

-   `"-0.53"`

-   `as.numeric("11")`

<details>

<summary>Solutions</summary>

<p>

1.  The three atomic data types in R are logical, numeric, and character.
2.  You can find the type of a piece of data in R using the `class()` function.
3.  To convert the character "TRUE" to a logical, you would use `as.logical("TRUE")` (we always use 'as...' functions to convert between types).
4.  The types are:
    -   `11` is numeric
    -   `"eleven"` is character
    -   `TRUE` is logical
    -   `!FALSE` is logical
    -   `0.49826` is numeric
    -   `"-0.53"` is character (even though it looks like a number, it is surrounded by quotation marks so it is a character)
    -   `as.numeric("11")` is numeric (since we converted the character "11" to a number with the `as.numeric()` function)

</p>

</details>
:::::::::::::::::::::

## Data structures {#sec-datastructures}

Beyond the atomic data types, R has more complex data structures that can store multiple values. These are the building blocks of data analysis in R. The most common data structures are vectors, matrices, and data frames.

This figure summarises their key differences:

![Overview of the three main data structures in R. 📷 credit: https://bookdown.org/introrbook/intro2r/](images/data-structure.png)

### Vectors {#sec-vectors}

A vector is a collection of values **of the same atomic type**. Values in a vector are laid out linearly, one after another.

You can create vectors with the `c()` function, like so:

```{r}
# a vector of numbers
c(1, 2, 3)

# a vector of characters
c("a", "vector", "of", "characters")

# a vector of logicals
c(TRUE, FALSE, TRUE)
```

Fun fact: the 'c' in `c()` stands for 'combine'.

There are a few ways to see the contents of a vector. You can simply type the name of the vector into the console, which will print out the whole thing:

```{r}
# in these examples we will use the letters vector that is
# pre-loaded in R. It contains the alphabet in lowercase
letters
```

You'll notice that, in addition to the `[1]` that we usually see printed next to the output, there is also a `[20]`. This number is telling us where we are up to in the vector (so `[1]` means that line of output starts with the first element, `"a"` and `[20]` means that line of output starts with the 20th element of the vector, `"t"`).

But what if we don't always want to print the whole thing? For long vectors, it's handy to use the `head()` and `tail()` functions to inspect just a few values. By default, these print the first and last 6 elements of a vector (you can change that by setting the `n` argument).

```{r}
# use head() and tail() to take a quick look
head(letters)
tail(letters)
```

You can also use functions to look at other features of a vector, like its type (using the `class()` function just as for single values) or its length (using the `length()` function):

```{r}
# find the class of a vector
class(letters)

# find the length of a vector
length(letters)
```

Just like you can with single values, vectors can be assigned to variables:

```{r}
pet_names <- c("sprinkle", "lucky", "coco")
```

These variables will show up in the 'Environment' tab in RStudio:

![The environment panel shows vectors too](images/S01F16_environment_panel_vectors.png){width="800"}

You'll notice vector variables are displayed a little differently to those with single values. The type (`chr`, for character) is displayed first, followed by `[1:3]` which tells you that the `pet_names` vector has elements from 1 to 3 (in other words, it has a length of 3). This is particularly helpful when part of the vector is cut off, like in this picture!

::: {.callout-note title="Colon (:) notation for vectors"}
In programming, the colon `:` is typically used to create sequences of numbers. You can use it to create a sequence of numbers from a starting point to an ending point.

For example, `1:5` creates a vector of numbers from 1 to 5:

```{r}
1:5
```
:::

R is a vectorised language, which means that many functions and operations (like `*`, `+` etc) work directly on vectors without you having to write extra code. For example, we can use the `mean()` function to calculate the average of a vector of numbers, or add a single number to each value in the vector:

```{r}
# create a vector of numbers
numbers <- c(1, 2, 3, 4, 5)

# calculate the mean
mean(numbers)

# add 5 to each value
numbers + 5
```

Because the other data structures we'll cover are built on vectors, this concept will be useful for them as well.

### Matrices {#sec-matrices}

A matrix is the two-dimensional extension of the vector-- it stores a collection of values **of the same type** that are laid out in a grid with rows and columns. An example of this is a gene count matrices where each row represents a gene, each column represents a sample and therefore each cell represents the count for a particular gene in a particular sample.

You can create a matrix using the `matrix()` function. The first argument is the vector of values to be put into the matrix, and the `nrow` and `ncol` arguments specify the number of rows and columns in the matrix:

```{r}
# create a 2x2 matrix and assign it to gene_counts
gene_counts <- matrix(c(1, 2, 3, 4), nrow = 2, ncol = 2)

# print the matrix
gene_counts
```

Usually though you would read in a matrix from a file (e.g. the gene count matrix from a sequencing experiment).

Matrices are their own type of object in R:

```{r}
class(gene_counts)
```

And they show up in the environment panel in RStudio under 'Data': ![Matrices show up in the environmen panel](images/S01F17_enrivonrment_panel_matrix.png){width="800"}

The rows and columns are usually labelled with names, although these names are considered metadata rather than being a part of the matrix. You can set them by assigning vectors of names to the `rownames()` and `colnames()` functions:

```{r}
# set row and column names
rownames(gene_counts) <- c("gene1", "gene2")
colnames(gene_counts) <- c("sample1", "sample2")

# print the matrix, now with names!
gene_counts
```

### Data frames {#sec-dataframes}

Data frames are similar to matrices in that they store data in rows and columns. The difference is each column can have a different type: for example you could have a column of gene names (character), a column of gene counts (numeric) and another column telling you whether or not the gene is protein-coding (logical). For this reason, data frames are the most common data structure used in R.

You can create a data frame using the `data.frame()` function. The arguments are vectors of values to be put into the data frame, with the names of the vectors becoming the column names:

```{r}
# create a data frame
mouse_facts <- data.frame(
  name = c("mickey", "minnie", "stuart"),
  age = c(12, 8, 16),
  weight = c(39.7, 42.2, 46.3)
)

# print the data frame
mouse_facts
```

When creating a data frame, it's important that all vectors are the same length. If they're not, you'll get an error:

```{r}
#| error: true
mouse_facts <- data.frame(
  name = c("mickey", "minnie", "stuart"),
  age = c(12, 8), # forgot to add stuart's age!
  weight = c(39.7, 42.2, 46.3)
)
```

For the rest of this section, we'll use the `iris` data set that comes pre-loaded in R. This is a bigger data set that contains measurements of different species of iris flowers, and will help us to learn how to work with data frames in R.

First, let's load in the dataset using the `data()` function:

```{r}
data(iris)
```

`iris` has the class `data.frame`:

```{r}
class(iris)
```

Just like for vectors, there are functions to look at the contents of a data frame. This is useful as printing the whole data frame can be overwhelming if it's large (try printing `iris` and see for yourself!). The `head()` and `tail()` functions work the same way as for vectors:

```{r}
head(iris)
tail(iris)
```

You can also use the `View()` function to open the data frame in a new tab in RStudio:

```{r}
#| eval: false
# don't forget the capital V!
View(iris)
```

This will open a new tab in RStudio with the data frame displayed in a spreadsheet-like format, where you can sort and filter the columns to get a better view of the data:

![The View() function opens the data frame in a new tab in RStudio](images/S01F18_view_function.png){width="800"}

Another way to view the data frame is by clicking on its name in the environment panel:

![Clicking on the data frame's name in the environment panel opens it in the viewer](images/S01F19_env_panel_data_frame.png){width="800"}

This panel also shows you the names and types of the columns in the data frame. You might notice that the `Species` is described as a factor, which is a special type of data in R that we'll return to in @sec-chapter06.

Before the column names, you'll see the `$` symbol. The dollar sign `$` is a shortcut used in R to access columns of a data frame. For example, to access the `Petal.Width` column of the `iris` data frame, you can use `iris$Petal.Width`:

```{r}
iris$Petal.Width
```

Try typing this code into your R script. You'll notice once you write `iris$`, RStudio will list out all of the columns like so:

![RStudio will suggest column names as you type](images/S01F20_column_suggestions.png){width="800"}

You can navigate through these suggestions using the up and down arrow keys, and press {{< kbd Enter >}} or {{< kbd Tab >}} to select the column you want.

These columns are vectors, so you can use the functions we've learned about so far to work with them:

```{r}
# find the class of the Petal.Width column
class(iris$Petal.Width)

# find the average Petal.Width column
mean(iris$Petal.Width)
```

::::::::::::::::::::::::::::::::::::::: {.callout-important title="Practice exercises"}
Try these practice questions to test your understanding

:::::::: question
1\. Which of the following is NOT a valid vector in R?

::::::: choices
::: choice
`c(TRUE, FALSE, FALSE)`
:::

::: {.choice .correct-choice}
`(1, 2, 3, 4)`
:::

::: choice
`1:10`
:::

::: choice
`c("cat", "dog", "fish")`
:::
:::::::
::::::::

:::::::: question
2\. What is the result of running this R code: `c(1, 2, 3) * 2`?

::::::: choices
::: choice
`2(1, 2, 3)`
:::

::: choice
`c(1, 2, 3, 1, 2, 3)`
:::

::: choice
`c(1, 2, 3, 2)`
:::

::: {.choice .correct-choice}
`c(2, 4, 6)`
:::
:::::::
::::::::

:::::::: question
3\. What is the difference between a matrix and a data frame?

::::::: choices
::: {.choice .correct-choice}
A matrix has all elements of the same type, while a data frame can have different types in each column
:::

::: choice
They're the same thing
:::

::: choice
A matrix can only contain numbers, while a data frame can contain numbers and text
:::

::: choice
A matrix is used for mathematical operations, while a data frame is used for data analysis
:::
:::::::
::::::::

:::::::: question
4\. I wrote this code to create a data frame, but it gave me an error. What is wrong with it?

```{r}
#| eval: false
favourite_fruits <- data.frame(
  fruit = c("apple", "banana", "cherry"),
  colour = c("red", "yellow", "red"),
  price = c(0.5, 0.3)
)
```

::::::: choices
::: choice
The column names are not in quotation marks
:::

::: {.choice .correct-choice}
The columns are not the same length: 'fruit' and 'colour' have 3 elements, but 'price' has 2
:::

::: choice
It's not allowed to have character columns and numeric columns in the same data frame
:::

::: choice
You should use the `tibble()` function instead of `data.frame()`
:::
:::::::
::::::::

:::::::: question
5\. What is NOT a way that I could view the contents of a data frame in R?

::::::: choices
::: choice
Running the name of the data frame as code in the R script panel
:::

::: choice
Typing the name of the data frame into the console
:::

::: choice
Clicking on its name in the environment panel
:::

::: {.choice .correct-choice}
Using the `view()` function
:::
:::::::
::::::::

:::::::: question
6\. I have created the `mouse_facts` data frame using the code below. How would I calculate the average age of the mice?

```{r}
#| eval: false
mouse_facts <- data.frame(
  name = c("mickey", "minnie", "stuart"),
  age = c(12, 8, 16),
  weight = c(39.7, 42.2, 46.3)
)
```

::::::: choices
::: choice
mean(age)
:::

::: {.choice .correct-choice}
mean(mouse_facts\$age)
:::

::: choice
average(age)
:::

::: choice
average(mouse_facts\$age)
:::
:::::::
::::::::

<details>

<summary>Solutions</summary>

1\. The vector `(1, 2, 3, 4)` is not a valid vector: you need to use the `c()` function to create a vector in R. The exception is the colon `:` notation, which creates a sequence of numbers.

2\. The result of running `c(1, 2, 3) * 2` would be `c(2, 4, 6)`. This is because R is a vectorised language, so the `*` operator multiplies each element of the vector by 2.

3\. The difference between a matrix and a data frame is that a matrix has all elements of the same type (could be character, logical or numeric), while a data frame can have different types in each column.

4\. The code to create the data frame `favourite_fruits` gave an error because the columns are not the same length: 'fruit' and 'colour' have 3 elements, but 'price' has 2. You can't create a data frame with columns of different lengths. As for the other options, you can have character and numeric columns in the same data frame, the column names don't need to be in quotation marks (although the code will work if they are), and the `tibble()` function is an alternative to `data.frame()` but either is fine.

5\. Using the `view()` function is not a way to view the contents of a data frame in R. The correct function is `View()` (with a capital 'V'). All the other options are valid ways to view the contents of a data frame.

6\. To calculate the average age of the mice, you would use `mean(mouse_facts$age)`. This is because the `age` column is part of the `mouse_facts` data frame, so you need to use the `$` symbol to access it, and the function for calculating the average in R is `mean()`.

</details>
:::::::::::::::::::::::::::::::::::::::

## Reading in data {#sec-readingin}

So far, we've explored the basics of R by creating our own data, or using built-in data objects like `letters` or `iris`. However, in real life analyses, we almost always need to read in data from files on our computers.

In this section we will use the file named `mousezempic_dosage_data.csv`, which you downloaded from the Setup instructions at the start of this book.

Check in the Files tab (bottom right panel) that this file is in the project directory you have made for this course (it's generally a good idea to keep all the data and code for a certain analysis together). It should be inside a folder named `data`.

### Paths {#sec-paths}

Paths tell R where to find the file you want to read in. They are strings of characters that first include the directory or series of directories in which a file is located, followed by the name of the file itself. For example, the path to a file called `my_data.csv` in a folder called `data` would be `data/my_data.csv`.

In this course, we will use RStudio to help us find the paths to our files, without needing to type them out ourselves. If you're interested in learning more about paths, [codeacademy has a nice simple article on them](https://www.codecademy.com/resources/docs/general/file-paths).

To find a file path easily in RStudio, you can use the file explorer panel. First, open it by clicking on the 'Files' tab in the bottom right panel of RStudio:

![The file explorer panel in RStudio](images/S01F21_file_explorer.png){width="900"}

By default, it will put you in your project directory. If you have data files in a different directory, you can navigate to that directory by clicking on the folders. Here, I have navigated to a folder on my desktop called 'data', which is inside the 'R_course' folder. Once you're in the right place, to get the path for that folder, click on `More > Copy Folder Path to Clipboard`:

![Copying the folder path to the clipboard](images/S01F22_copy_folder_path.png){width="800"}

This will copy the path to the folder to your clipboard, which you can then paste into your R script. Then, you just need to add a `/` followed by the name of the file to the end of the path.

For example, the path to the folder in the above image is `~/Desktop/BIOL90042_workshops/data`, so the path to the `mousezempic_dosage_data.csv` file is `~/Desktop/BIOL90042_workshops/data/mousezempic_dosage_data.csv`.

### Reading data with functions {#sec-readinFunctions}

Now that we know how to find our data, we can read it in. We'll do this using a handy package called `readr`, that is part of the `tidyverse`.

::: {.callout-note title="Packages in R"}
Packages are collections of functions that other people have written to help us do specific tasks, beyond what is built-in to R itself. The [tidyverse](https://www.tidyverse.org/) is a collection of packages that help to streamline data analysis in R. Its a 'universe of functions for tidy data analysis.' To use the tidyverse, we first need to install it. This is done using the `install.packages()` function run in the Setup code. If you have run the Setup code, there is no need to run the code below again, but for reference:

```{r}
#| eval: false
# install the tidyverse package
# only do this once
install.packages("tidyverse")
```

We only need to install a package once, but you must load it each time you open R. This is done using the `library()` function:

```{r}
# load the tidyverse package
# do this every time you open R
library(tidyverse)
```

You'll see some output from the `tidyverse` package when you load it, which is just telling you that some of the tidyverse functions have the same name as other functions in R.

If you forget to load a package, R will give you an error when you try to use that package's functions, so it's usually a good idea to load all the packages you'll need at the start of your script to prevent you forgetting to load them the next time you open R. We'll do this at the start of each chapter in this course.
:::

To read in our data, we'll use the `read_delim()` function from the `readr` package. This function takes in the path to the file you want to read in (in quotation marks `""`, as this is a character string) and returns as output a tibble.

```{r}
#| eval: false
read_delim("~/Desktop/BIOL90042_workshops/data/mousezempic_dosage_data.csv")
```

::: {.callout-note title="Delimiters"}
The 'delim' in 'read_delim' stands for delimiter, and refers to the character used to separates columns of the data.

The most common types of delimiter are comma-separated values (.csv files) and tab-separated values (.tsv files). Here's an example of what they look like:

``` {filename="example.csv"}
Name, Age
Andy, 10
Bob, 8
```

\

``` {filename="example.tsv"}
Name  Age
Andy  10
Bob   8
```

By default `read_delim()` will guess your delimiter, so it's easiest to use that to read files, no matter their format. However, if you read other people's code, you might also encounter the `read_tsv()` and `read_csv()` functions which are specifically for reading in tab-separated and comma-separated files, respectively. It's up to you which you use, just make sure to get the delimiter right! If you try to read in a file with the wrong delimiter, it'll look like a mess.

<details>

<summary>What happens if we use the wrong delimiter?</summary>

As an example, let's try reading in our comma-separated file with `read_tsv()`, which is specifically for tab-separated files:

```{r}
#| eval: false
read_tsv("~/Desktop/BIOL90042_workshops/data/mousezempic_dosage_data.csv")
```

```{r}
#| echo: false
# this is for rendering the book
read_tsv("data/mousezempic_dosage_data.csv")
```

We can see that the data is all in one column, which is not what we want!

</details>
:::

Depending on where you have put your data, your path to the `mousezempic_dosage_data.csv` file may be different. You should be able to find the path by following the instructions in the 'Paths' section above.

::: {.callout-note title="Using RStudio to autocomplete paths"}
Another conveninent way to get the path of your file (so long as you are working within an R project) is to use a feature called 'tab completion'. Within R projects, R can discover any files sitting in, or downstream of the project directory. So, assuming our `mousezempic_dosage_data.csv` file is located within a folder called 'data', if we start typing `read_delim("data/mouse` then press {{< kbd Tab >}}, R will auto-complete the full file path and close the quotes and bracket for us!

Even better, we need only type `read_delim('mouse` and RStudio will find all files within the project beginning with that word, and automatically fill in the required file path!
:::

Now, let's take a look at the output of `read_delim()`:

```{r}
#| echo: false
# this is for rendering the book, path is maybe different for learners so don't show this chunk
read_delim("data/mousezempic_dosage_data.csv")
```

The first line tells us how many rows and columns are in the data. Then, the `Column specification` section tells you:

-   What delimiter was used to separate values.

-   Which columns belong to each type. `read_delim()` is quite clever and will guess this for us, but it's useful to check and make sure it's correct.

Then, the data will be printed out as a tibble.

::: {.callout-note title="Tibbles and data frames"}
Tibbles are a more modern version of data frames introduced in the [tidyverse](https://www.tidyverse.org/). They are very similar to data frames, but have some additional features like printing more nicely in the console.

Let's use `iris` to highlight the advantages of tibbles:

```{r}
#| message: false
# need to load the tidyverse package to use tibbles
# see below for more information on loading packages
library(tidyverse)
```

When we print a data frame, it shows every single row and column, which can be overwhelming if the data frame is large:

<details>

<summary>Click here to print `iris` as a data frame!</summary>

```{r}
# print iris
iris
```

</details>

But when we print a tibble, only a small preview is shown, which is much easier to read:

```{r}
# print iris as a tibble
as_tibble(iris)
```

It also tells us the number of rows (150) and columns (5) in the data, as well as the types of each column (`<dbl>` is short for `double`, which is a type of numeric data). Unlike data frames, tibbles can not include row names that sit 'outside' the cells.

For the purpose of this course, we can treat tibbles and data frames as the same thing. However, if you're interested in learning more about tibbles, you can read about them [here](https://r4ds.had.co.nz/tibbles.html#tibbles-vs.-data.frame).
:::

No matter which function you use to read in your data, R simply prints the values out in the console. To actually work with data in R, we need assign our data frame to a variable:

```{r}
#| eval: false
m_dose <- read_delim("~/Desktop/R_course/data/mousezempic_dosage_data.csv")
```

```{r}
#| echo: false
# this is for rendering the book, path is different for learners so don't show this chunk
m_dose <- read_delim("data/mousezempic_dosage_data.csv")
```

### Reading data through RStudio's graphical interface {#sec-readinGUI}

You can also read in data through RStudio's graphical interface. This is a good way to get the code to read in data if you're not sure how to do it yourself.

To do this, click on the 'Import Dataset' button in the environment panel (for our data, we will use the 'from Text (readr)' option):

![The import dataset button in the environment panel](images/S01F23_import_dataset_button.png){width="800"}

This will open a window where you can select the file you want to read in, like so:

![The import dataset window in RStudio](images/S01F24_import_dataset_window.png){width="800"}

R will then generate the code to read in the data for you, and you can use the preview to check that it has worked ok:

![RStudio will then read in the data, and give you the code that it used](images/S01F25_import_dataset_code.png){width="800"}

You can then copy this code and paste it into your script. This step is really important because not only does it helps you to learn how to read in data yourself, **it keeps a record in the script of how you read in the data so that you can reproduce your analysis later.**

![Don't forget to paste the code into the script!!!](images/S01F26_paste_code.png){width="1000"}

::::::::::::::::::::: {.callout-important title="Practice exercises"}
Try these practice questions to test your understanding

:::::::: question
1\. What is a path?

::::::: choices
::: choice
A type of data in R
:::

::: choice
The data you want to analyse
:::

::: {.choice .correct-choice}
A string of characters that tells R where to find a file
:::

::: choice
A function in R
:::
:::::::
::::::::

:::::::: question
2\. What is NOT a way to read in a file called `my_data.tsv` in R?

::::::: choices
::: choice
Using the `read_delim()` function
:::

::: choice
Using the 'Import Dataset' button in RStudio
:::

::: choice
Using the `read_tsv()` function
:::

::: {.choice .correct-choice}
Using the `read_csv()` function
:::
:::::::
::::::::

:::::::: question
3\. What do we need to do before we can use functions from `readr` or any other R package?

::::::: choices
::: choice
Install it
:::

::: {.choice .correct-choice}
Install it, then load it into our R session using the `library()` function
:::

::: choice
Download it
:::

::: choice
Look at the help page for the functions we want to use
:::
:::::::
::::::::

<details>

<summary>Solutions</summary>

1\. A path is a string of characters that tells R where to find a file. Note that it isn't the data itself, but rather the location of the data.

2\. The `read_csv()` function is not a way to read in a file called `my_data.tsv`, because it is specifically for reading in comma-separated files, so it would not work for a tab-separated file like `my_data.tsv`.

3\. Before we can use functions from `readr` or any other R package, we need to install it, then load it into our R session using the `library()` function. Otherwise we will get an error message when we try to use the functions.

</details>
:::::::::::::::::::::

## Summary

<!-- TO DO: make a nicely formatted PDF cheat sheet for printing -->

Here's what we've learnt in this chapter:

-   How to create an R project (to keep our files organised) and how to write and run code from an R script (so that the code is saved as a record of our work)

-   The operators for basic maths (`*`, `/`, `+` and `-`) and comparisons (`==`, `<`, `<=` and `!`)

-   How to use functions and specify their arguments, as well as how to get help

-   How to assign variables using the `<-` operator, and how to name them appropriately

-   The three basic atomic data types in R (character, numeric and logical)

-   Three different data structures in R (vectors, matrices and data frames/tibbles)

-   How to find file paths using RStudio

-   How to load the `readr` package and use it to read in files

Try the practice questions below to test your understanding!

### Practice questions

1.  What would be the result of evaluating the following expressions? You don't need to know these off the top of your head, use R to help! (Hint: some expressions might give an error. Try to think about why)

    a.  `5 + 10`
    b.  `100 >= (5 + 2) ^ 2`
    c.  `!(100 > 1)`
    d.  `500 = 5 * 100`
    e.  `2fast <- "zoom"`
    f.  `round(428.195721, 2)`
    g.  `?t.test`
    h.  `class("banana")`
    i.  `class(as.numeric("500"))`
    j.  `"1" + "10"`
    k.  `length(1:100)`
    l.  `sum(c(1, 2, 3, 4))`
    m.  `head(iris)`
    n.  `mean(iris$Sepal.Width)`
    o.  `read_tsv("gene_counts.csv")`

2.  Write some R code to complete the right-hand side of this comparison: `as.numeric("100") * 3 ==`

3.  I wrote the following R code, and got an error. How can I fix it?

    ```{r}
    #| error: true
    # the number of frogs I counted
    Frog_counts <- c(11, 2, 4, 9, 10)

    # convert to a proportion: divide by the sum
    frog_counts / sum(Frog_counts)
    ```

4.  Load the `iris` dataframe into your R session using `data(iris)`. What is the median petal length? Show the code you used to calculate this.

5.  Imagine I have a file called `mouse_survival.tsv` located in a folder with the path `~/Downloads/experimental_data/latest`. Write a line of R code to read in this file and assign it to a variable called `mouse_survival`

<details>

<summary>Solutions</summary>

1.  The results of evaluating the expressions are:

    a.  `5 + 10` is `15`
    b.  `100 >= (5 + 2) ^ 2` is `TRUE`
    c.  `!(100 > 1)` is `FALSE` (although 100 is greater than 1, the `!` operator negates this)
    d.  `500 = 5 * 100` gives an error because we need two equals signs `==` to check for equality in R. Actually this code is trying to assign the value of `5 * 100` to the variable `500`, which is not allowed, because variable names can't start with a number.
    e.  `2fast <- "zoom"` gives an error because variable names can't start with a number
    f.  `round(428.195721, 2)` is `428.2`
    g.  `?t.test` opens the help page for the `t.test()` function
    h.  `class("banana")` is `"character"`
    i.  `class(as.numeric("500"))` is `"numeric"`
    j.  `"1" + "10"` gives an error because you can't add two character strings together
    k.  `length(1:100)` is `100`
    l.  `sum(c(1, 2, 3, 4))` is `10`
    m.  `head(iris)` shows the first 6 rows of the `iris` data frame
    n.  `mean(iris$Sepal.Width)` is the average of the `Sepal.Width` column in the `iris` data frame
    o.  `read_tsv("gene_counts.csv")` will try to read in `gene_counts.csv` as if it were tab-separated, which will result in all the data being in one column

2.  The right-hand side of the comparison `as.numeric("100") * 3 ==` can be anything that results in 300 e.g. `300` or `299 + 1`, for example

3.  The error in the code is because the variable name `Frog_counts` is not the same as `frog_counts`. R is case-sensitive, so it thinks you are trying to divide a variable that doesn't exist. To fix this, make sure all your variables have the same case (lowercase is better!):

```{r}
    # the number of frogs I counted
    frog_counts <- c(11, 2, 4, 9, 10)

    # convert to a proportion: divide by the sum
    frog_counts / sum(frog_counts)
```

4.  To calculate the median petal length in the `iris` data frame, you can use `median(iris$Petal.Length)`

5.  To read in the `mouse_survival.tsv` file and assign it to a variable called `mouse_survival`, you could use `red_delim()`: `mouse_survival <- read_delim("~/Downloads/experimental_data/latest/mouse_survival.tsv")` or `read_tsv()`: `mouse_survival <- read_tsv("~/Downloads/experimental_data/latest/mouse_survival.tsv")`.

</details>