```{r echo=FALSE, message=FALSE, warning=FALSE}
library(tidyverse)
shed <- read_csv("http://heike.github.io/rwrks/01-r-intro/data/daily_shedding.csv")

final_shed <- shed %>% 
  group_by(pignum) %>% 
  mutate(gain = pig_weight[time_point == 21] - pig_weight[time_point == 0]) %>% filter(time_point == 21) %>% ungroup() %>% select(-c(4:9))
```

## Overgrown Calculator

```{r}
# Addition and Subtraction
2 + 5 - 1

# Multiplication
109*23452

# Division
3/7
```

---
## More Calculator Operations

```{r}
# Integer division
7 %/% 2

# Modulo operator (Remainder)
7 %% 2

# Powers
1.5^3
```

---
## Even More Functions

- Exponentiation 
    - `exp(x)`
- Logarithms
    - `log(x)`
    - `log(x, base = 10)`
- Trigonometric functions
    - `sin(x)`
    - `asin(x)`
    - `cos(x)`
    - `tan(x)`
    
---
## Creating Variables

We can create variables using the assignment operator `<-`:

```{r}
x <- 5
MyAge <- 26
```

We can then perform any of the functions on the variables:

```{r}
log(x)
MyAge^2
```

---
## Rules for Variable Creation

- Variable names can't start with a number

- Variables in `R` are case-sensitive

- Some common letters are used internally by R and should be avoided as variable names (c, q, t, C, D, F, T, I)

- There are reserved words that R won't let you use for variable names. (for, in, while, if, else, repeat, break, next)

- R *will* let you use the name of a predefined function.  Try not to overwrite those though!

---
## Vectors

A variable does not need to be a single value. We can create a **vector** using the `c` (combine) function:

```{r}
y <- c(1, 5, 3, 2)
```

Operations will then be done element-wise:

```{r}
y / 2
```

---
## Getting Help

We will talk MUCH more about vectors in a bit, but for now, let's talk about a couple ways to get help. The primary function to use is the `help` function. Just pass in the name of the function you need help with:

```{r, eval=FALSE}
help(head)
```

The `?` function also works:

```{r, eval=FALSE}
?head
```

Googling for help can be difficult at first. You might need to search for R + CRAN + \<your query\> to get good results

Stackoverflow is VERY helpful

---
## Getting Help

**R Reference Card **

We will pass you out a copy, but you can download the reference card from:

http://cran.r-project.org/doc/contrib/Short-refcard.pdf

Having this open or printed off and near you while working is helpful.

</br>

**Rstudio cheatsheets**

The Rstudio cheatsheets are VERY helpful.

https://www.rstudio.com/resources/cheatsheets/


---
class: inverse

## Your Turn

Using the R Reference Card (and the Help pages, if needed), do the following:

Find out how many rows and columns the `iris` data set has. Figure out at least 2 ways to do this.

**Hint**: "Variable Information" section on the first page of the reference card!

Use the `rep` function to construct the following vector: `1 1 2 2 3 3 4 4 5 5`

**Hint**: "Data Creation" section of the reference card

Use `rep` to construct this vector: `1 2 3 4 5 1 2 3 4 5 1 2 3 4 5`

---
## Data Frames: Introduction

- `final_shed` is a data frame.

- Data frames hold data sets

- Not every column need be the same type - like an Excel spreadsheet

- Each column in a data frame is a vector <sup>1</sup> - so each column needs to have values that are all the same type. 

- We can access different columns using the `$` operator.

```{r}
shedding <- final_shed$total_shedding
treatment <- final_shed$treatment
```

.footnote[
[1] a column can also be a list! This is a more advanced topic that will be saved for later.
]
---
## More about Vectors

A vector is a list of values that are all the same type. We have seen that we can create them using the `c` or the `rep` function. We can also use the `:` operator if we wish to create consecutive values:

```{r}
a <- 10:15
a
```

We can extract the different elements of the vector like so:

```{r}
shedding[3]
```

---
## Indexing Vectors

We saw that we can access individual elements of the vector. But **indexing** is a lot more powerful than that:

```{r}
head(shedding)

shedding[c(1, 3, 5)]
shedding[1:5]
```

---
## Logical Values

- R has built in support for logical values

- TRUE and FALSE are built in.  T (for TRUE) and F (for FALSE) are supported but can be modified

- Logicals can result from a comparison using
    - `<` : "less than"
    - `>` : "greater than"
    - `<=` : "less than or equal to"
    - `>=` : "greater than or equal to"
    - `==` : "is equal to"
    - `!=` : "not equal to"
    
---
## Indexing with Logicals

We can index vectors using logical values as well:

```{r}
x <- c(2, 3, 5, 7)
x[c(TRUE, FALSE, FALSE, TRUE)]
x > 3.5
x[x > 3.5]
```

---
## Logical Examples

```{r}
bad_shedder <- shedding > 50
shedding[bad_shedder]
```

---
class: inverse

## Your Turn 

1. Find out how many pigs had a total shedding value of less than 30 log10 CFUs.

**Hint**: if you use the `sum` function on a logical vector, it'll return how many TRUEs are in the vector:

```{r}
sum(c(TRUE, TRUE, FALSE, TRUE, FALSE))
```

2. **More Challenging**: Calculate the sum of the total shedding log10 CFUs of all pigs with a total shedding value of less than 30 log10 CFUs.

---
## Element-wise Logical Operators

- `&` (elementwise AND)
- `|` (elementwise OR)

```{r}
c(T, T, F, F) & c(T, F, T, F)
c(T, T, F, F) | c(T, F, T, F)
# Which are high shedders in the control group?
id <- (shedding > 50 & treatment == "control")
final_shed[id,]
```

---

## Modifying Vectors

We can modify vectors using indexing as well:

```{r}
x <- shedding[1:5]
x
x[1] <- 20
x
```

---
## Vector Elements

Elements of a vector must all be the same type:

```{r}
head(shedding)
shedding[bad_shedder] <- ":-("
head(shedding)
```

By changing a value to a string, all the other values were also changed.

---
## Data Types in R

- Can use `mode` or `class` to find out information about variables

- `str` is useful to find information about the structure of your data

- Many data types: numeric, integer, character, Date, and factor most common
    
```{r}
str(final_shed)
```

---
## Converting Between Types

We can convert between different types using the `as` series of functions:

```{r}
pignum <- head(final_shed$pignum)
pignum
as.character(pignum)
as.numeric("77")
```

---
## Some useful functions

There are a whole variety of useful functions to operate on vectors. 

A couple of the more common ones are `length`, which returns the length (number of elements) of a vector, and `sum`, which adds up all the elements of a vector.

```{r}
pig_weight <- final_shed$pig_weight
x <- pig_weight[1:5]
length(x)
sum(x)
```

---
## Statistical Functions

Using the basic functions we've learned it wouldn't be hard to compute some basic statistics.

```{r}
(n <- length(pig_weight))
(meanweight <- sum(pig_weight) / n)
(standdev <- sqrt(sum((pig_weight - meanweight)^2) / (n - 1)))
```

But we don't have to.

---
## Built-in Statistical Functions

```{r}
mean(pig_weight)
sd(pig_weight)
summary(pig_weight)
quantile(pig_weight, c(.025, .975))
```

<!-- 


class: inverse
## Your Turn

1. Read up on the diamonds dataset (`?diamonds`)

2. Plot price by carat (use qplot - go back to the motivating example for help with the syntax)

3. Create a variable `ppc` for price/carat. Store this variable as a column in the diamonds data

4. Make a histogram of all ppc values that exceed $10000 per carat.

5. Explore any other interesting relationships you find
-->