---
title: "Logic in R"
author: "Colin Rundel"
date: "2018-08-29"
output:
xaringan::moon_reader:
css: "slides.css"
lib_dir: libs
nature:
highlightStyle: github
highlightLines: true
countIncrementalSlides: false
---
exclude: true
```{r, message=FALSE, warning=FALSE, include=FALSE}
options(
htmltools.dir.version = FALSE, # for blogdown
width=80
)
htmltools::tagList(rmarkdown::html_dependency_font_awesome())
```
---
class: middle
count: false
# (Almost)
Everything is a Vector
---
## Types of vectors
The fundamental building block of data in R are vectors (collections of related values, objects, other data structures, etc).
--
R has two fundamental vector classes:
* Vectors (**atomic** vectors)
- collections of values that are all of the *same* type (e.g. all logical values, all numbers, or all character strings).
* Lists (**generic** vectors)
- collections of *any* type of R object, even other lists (meaning they can have a hierarchical/tree-like structure).
---
## Atomic Vectors
R has six atomic vector types:
.center[
`logical`, `double`, `integer`, `character`, `complex`, `raw`
]
For today we'll mostly worry about the first type, we'll discuss the subsequent three next week (the last two almost never come up).
---
count: false
class: middle
# Conditionals
---
## Logical (boolean) operations
| Operator | Operation | Vectorized?
|:-----------------------------:|:-------------:|:------------:
| x | y
| or | Yes
| `x & y` | and | Yes
| `!x` | not | Yes
| x || y
| or | No
| `x && y` | and | No
|`xor(x,y)` | exclusive or | Yes
---
## Vectorized?
```{r}
x = c(TRUE,FALSE,TRUE)
y = c(FALSE,TRUE,TRUE)
```
.pull-left[
```{r}
x | y
x || y
```
]
.pull-right[
```{r}
x & y
x && y
```
]
---
## Length coercion
```{r}
x = c(TRUE,FALSE,TRUE)
y = c(TRUE)
z = c(FALSE,TRUE)
```
--
.pull-left[
```{r}
x | y
x & y
```
]
--
.pull-right[
```{r}
y | z
y & z
```
]
--
```{r}
x | z
```
---
## Comparisons
Operator | Comparison | Vectorized?
:----------:|:--------------------------:|:----------------:
`x < y` | less than | Yes
`x > y` | greater than | Yes
`x <= y` | less than or equal to | Yes
`x >= y` | greater than or equal to | Yes
`x != y` | not equal to | Yes
`x == y` | equal to | Yes
`x %in% y` | contains | Yes (for `x`)
---
## Comparisons
```{r}
x = c("A","B","C")
z = c("A")
```
.pull-left[
```{r}
x == z
x != z
x > z
```
]
--
.pull-right[
```{r}
x %in% z
z %in% x
```
]
---
## Conditional Control Flow
Conditional execution of code blocks is achieved via `if` statements.
```{r}
x = c(1,3)
```
--
```{r}
if (3 %in% x)
print("This!")
```
--
```{r}
if (1 %in% x)
print("That!")
```
--
```{r}
if (5 %in% x)
print("Other!")
```
---
## `if` is not vectorized
```{r}
x = c(1,3)
```
--
```{r}
if (x %in% 3)
print("Now Here!")
```
--
```{r}
if (x %in% 1)
print("Now Here!")
```
---
## Collapsing logical vectors
There are a couple of helper functions for collapsing a logical vector down to a single value: `any`, `all`
```{r}
x = c(3,4,1)
```
.pull-left[
```{r}
x >= 2
any(x >= 2)
all(x >= 2)
```
]
.pull-right[
```{r}
x <= 4
any(x <= 4)
all(x <= 4)
```
]
---
## Nesting Conditionals
.pull-left[
```{r}
x = 3
if (x < 0) {
"Negative"
} else if (x > 0) {
"Positive"
} else {
"Zero"
}
```
]
.pull-right[
```{r}
x = 0
if (x < 0) {
"Negative"
} else if (x > 0) {
"Positive"
} else {
"Zero"
}
```
]
---
class: middle
count: false
# Error Checking
---
## `stop` and `stopifnot`
Often we want to validate user input or function arguments - if our assumptions are not met then we often want to report the error and stop execution.
```{r error=TRUE}
ok = FALSE
if (!ok)
stop("Things are not ok.")
stopifnot(ok)
```
*Note* - an error (like the one generated by `stop`) will prevent an RMarkdown document from compiling unless `error=TRUE` is set for that code chunk
---
## Style choices
.pull-left[
Do stuff:
```{r eval=FALSE}
if (condition_one) {
##
## Do stuff
##
} else if (condition_two) {
##
## Do other stuff
##
} else if (condition_error) {
stop("Condition error occured")
}
```
]
.pull-right[
Do stuff (better):
```{r eval=FALSE}
# Do stuff better
if (condition_error) {
stop("Condition error occured")
}
if (condition_one) {
##
## Do stuff
##
} else if (condition_two) {
##
## Do other stuff
##
}
```
]
---
## Exercise 1
Write a set of conditional(s) that satisfies the following requirements,
* If `x` is greater than 3 and `y` is less than or equal to 3 then print "Hello world!"
* Otherwise if `x` is greater than 3 print "!dlrow olleH"
* If `x` is less than or equal to 3 then print "Something else ..."
* Stop execution if x is odd and y is even and report an error, don't print any of the text strings above.
Test out your code by trying various values of `x` and `y`.
---
class: middle
count: false
# Loops
---
## `for` loops
Simplest, and most common type of loop in R - given a vector iterate through the elements and evaluate the code block for each.
```{r}
res = c()
for(x in 1:10) {
res = c(res, x^2)
}
res
```
--
```{r}
res = c()
for(y in list(1:3, LETTERS[1:7], c(TRUE,FALSE))) {
res = c(res, length(y))
}
res
```
*Note* - the code above is terrible for several reasons, you should never write anything that looks like this
---
## `while` loops
Repeat until the given condition is **not** met (i.e. evaluates to `FALSE`)
```{r}
i = 1
res = rep(NA,10)
while (i <= 10) {
res[i] = i^2
i = i+1
}
res
```
---
## `repeat` loops
Repeat until `break`
```{r}
i = 1
res = rep(NA,10)
repeat {
res[i] = i^2
i = i+1
if (i > 10)
break
}
res
```
---
class: split-50
## Special keywords - `break` and `next`
These are special actions that only work *inside* of a loop
* `break` - ends the current *loop* (inner-most)
* `next` - ends the current *iteration*
.pull-left[
```{r}
res = c()
for(i in 1:10) {
if (i %% 2 == 0)
break
res = c(res, i)
print(res)
}
```
]
.pull-right[
```{r}
res = c()
for(i in 1:10) {
if (i %% 2 == 0)
next
res = c(res,i)
print(res)
}
```
]
---
## Some helper functions
Often we want to use a loop across the indexes of an object and not the elements themselves. There are several useful functions to help you do this: `:`, `length`, `seq`, `seq_along`, `seq_len`, etc.
.pull-left[
```{r}
4:7
length(4:7)
seq(4,7)
```
]
.pull-right[
```{r}
seq_along(4:7)
seq_len(length(4:7))
seq(4,7,by=2)
```
]
---
## Exercise 2
Below is a vector containing all prime numbers between 2 and 100:
.center[
```r
primes = c( 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97)
```
]
If you were given the vector `x = c(3,4,12,19,23,51,61,63,78)`, write the R code necessary to print only the values of `x` that are *not* prime (without using subsetting or the `%in%` operator).
Your code should use *nested* loops to iterate through the vector of primes and `x`.
---
count: false
# Acknowledgments
Above materials are derived in part from the following sources:
* Hadley Wickham - [Advanced R](http://adv-r.had.co.nz/)
* [R Language Definition](http://stat.ethz.ch/R-manual/R-devel/doc/manual/R-lang.html)