09-intro-to-loops.Rmd

---
title: "Introduction to loops"
subtitle: "Stat 133"
author: "Gaston Sanchez"
output: github_document
fontsize: 11pt
urlcolor: blue
---

> ### Learning Objectives
>
> - Why do you need loops?
> - Get to know the For loop
> - Get to know the While loop
> - Get to know the Repeat loop

```{r setup, include=FALSE}
knitr::opts_chunk$set(error = TRUE)
```

------

## About Loops

- Many times we need to perform a procedure several times
- We perform the same operation several times as long as some condition
is fulfilled
- For this purpose we use loops
- The main idea is that of __iteration__
- R provides three basic paradigms: `for`, `repeat`, `while`


## Motivation example

Consider a numeric vector with prices of five items:

```{r}
prices <- c(2.50, 2.95, 3.45, 3.25)

prices
```


### Printing prices "manually"

Say you are interested in printing each price individually. You can manually 
display them one by one, by typing the same command several times:

```{r print_prices, eval = FALSE}
cat("Price 1 is", prices[1])
cat("Price 2 is", prices[2])
cat("Price 3 is", prices[3])
cat("Price 4 is", prices[4])
```

```{r print_prices, echo=FALSE}
```


### Printing prices with a `for` loop

Or you can use a loop structure in which you tell the computer to display the 
prices a given number of times, but using one command instead of typing it 
various times:

```{r}
for (i in 1:4) {
  cat("Price", i, "is", prices[i], "\n")
}
```


Let's make it less simple by creating a vector of prices with the names of 
the associated coffees:

```{r}
coffee_prices <- c(
  expresso = 2.50,
  latte = 2.95,
  mocha = 3.45, 
  cappuccino = 3.25)

coffee_prices
```

Without using a loop, you can display, via `cat()`, the prices one-by-one;
(this, of course, involves a lot of repetition)

```{r print_coffee, eval = FALSE}
cat("Expresso has a price of", coffee_prices[1])
cat("Latte has a price of", coffee_prices[2])
cat("Mocha has a price of", coffee_prices[3])
cat("Capuccino has a price of", coffee_prices[4])
```

```{r print_coffee, echo = FALSE}
```


### Printing coffee prices with a `for` loop

```{r}
for (i in 1:4) {
  cat(names(coffee_prices)[i], "has a price of", 
      prices[i], "\n")
}
```

-----

## For Loops

- Often we want to repeatedly carry out some computation a __fixed__ number of times. 
- For instance, repeat an operation for each element of a vector. 
- In R this can be done with a __`for`__ loop.
- `for` loops are used when __we know exactly how many times__ we want the code to repeat

The anatomy of a `for` loop is as follows:

```{r eval = FALSE}
for (iterator in times) { 
  do_something
}
```

`for()` takes an __iterator__ variable and a vector of __times__ to iterate 
through.

```{r}
value <- 2

for (i in 1:5) { 
  value <- value * 2 
  print(value)
}
```


The vector of _times_ does NOT have to be a numeric vector; it can be __any__ vector

```{r}
value <- 2
times <- c('one', 'two', 'three', 'four')

for (i in times) { 
  value <- value * 2 
  print(value)
}
```


However, if the _iterator_ is used inside the loop in a numerical computation, then the vector of _times_ will almost always be a numeric vector:

```{r}
set.seed(4321)
numbers <- rnorm(5)

for (h in 1:length(numbers)) {
  if (numbers[h] < 0) {
    value <- sqrt(-numbers[h])
  } else {
    value <- sqrt(numbers[h])
  }
  print(value)
}
```


### For Loops and Next statement

Sometimes we need to skip a loop iteration if a given condition is met, this can be done with a next statement

```{r eval=FALSE}
for (iterator in times) { 
  expr1
  expr2
  if (condition) {
    next
  }
  expr3
  expr4
}
```


Example:

```{r}
x <- 2

for (i in 1:5) {
  y <- x * i
  if (y == 8) {
    next
  }
  print(y)
}
```


### Nested Loops

It is common to have nested loops
```{r eval = FALSE}
for (iterator1 in times1) { 
  for (iterator2 in times2) {
    expr1
    expr2
    ...
  }
}
```


Example: Nested loops

```{r}
# some matrix
A <- matrix(1:12, nrow = 3, ncol = 4)

A
```


Example: Nested Loops

```{r}
# reciprocal of values less than 6
for (i in 1:nrow(A)) { 
  for (j in 1:ncol(A)) {
    if (A[i,j] < 6) A[i,j] <- 1 / A[i,j] 
  }
}

A
```

-----

## About `for` Loops and Vectorized Computations

- R loops have a bad reputation for being slow.

- Experienced users will tell you: "tend to avoid `for` loops in R" (me included).

- It is not really that the loops are slow; the slowness has more to do with the way R handles the _boxing and unboxing_ of data objects, which may be a bit inefficient.

- R provides a family of functions that are usually more efficient than loops
(i.e. `apply()` functions).

- For this course, especially if you have NO programming experience, you should ignore any advice about avoiding loops in R.

- You should learn how to write loops, and understand how they work; every programming language provides some type of loop structure.

- In practice, many (programming) problems can be tackled using some loop structure.

- When using R, you may need to start solving a problem using a loop. Once you solved it, try to see if you can find a vectorized alternative.

- It takes practice and experience to find alternative solutions to `for` loops.

- There are cases when using `for` loops is not that bad.


-----


## Repeat Loop

`repeat` executes the same code over and over until a stop condition is met:

```{r eval=FALSE}
repeat { 
  # keep
  # doing
  # something
  if (stop_condition) {
    break
  }
}
```

The `break` statement stops the loops. If you enter an infinite loop, you can
manually break it by pressing the `ESC` key.

```{r}
value <- 2

repeat {
  value <- value * 2 
  print(value)
  if (value >= 40) {
    break
  }
}
```


To skip a current iteration, use `next`

```{r}
value <- 2

repeat {
  value <- value * 2
  print(value)
  if (value == 16) {
    value <- value * 2
    next
  }
  if (value > 80) break 
}
```



## While Loops

It can also be useful to repeat a computation until a condition is false.
A `while` loop provides this form of control flow.

```{r eval=FALSE}
while (condition) { 
  # keep
  # doing
  # something
  # until
  # condition is FALSE
}
```


### About while loops

- `while` loops are backward `repeat` loops
- `while` checks first and then attempts to execute
- computations are carried out for as long as the condition is true
- the loop stops when the condition is FALSE
- If you enter an infinite loop, break it by pressing `ESC` key


```{r}
value <- 2

while (value < 40) { 
  value <- value * 2 
  print(value)
}
```

-----

## Loops: `for`, `while`, `repeat`

Let's see one last example of a `for` loop, and how to achieve the same task
with `while` and `repeat` loops.

Say you have a vector `x <- c(2, 4, 6, 8, 10)`, and the goal is to obtain the 
sum of the elements in `x`; in other words get `sum(x)` but using loops.

```{r}
# using a for loop
x <- c(2, 4, 6, 8, 10)

# initialize output
sumx <- 0

for (i in seq_along(x)) {
  print(paste('iteration:'), i)
  sumx <- sumx + x[i]
  print(paste('sum =', sumx))
}

sumx
```

Now let's do it with a while loop

```{r}
# initialize output
sumx <- 0

# initialize counter
i <- 1

# while loop
while (i <= length(x)) {
  print(paste('iteration:', i))
  sumx <- sumx + x[i]
  print(paste('sum =', sumx))
  i <- i + 1
}

sumx
```

And finally with a `repeat` loop:

```{r}
# initialize output
sumx <- 0

# initialize counter
i <- 1

# repeat loop (visualizing iterations)
repeat {
  print(paste('iteration:', i))
  sumx <- sumx + x[i]
  print(paste('sum =', sumx))
  i <- i + 1
  if (i > length(x)) {
    break
  }
}

sumx
```

-----

## Repeat, While, For

- If you don't know the number of times something will be done, you can use
either `repeat` or `while`
- `while` evaluates the condition at the beginning
- `repeat` executes operations until a stop condition is met
- If you know the number of times that something will be done, use `for`
- `for` needs an _iterator_ and a vector of _times_


### Questions

- What happens if you pass `NA` as a condition to `if()`?
- What happens if you pass `NA` as a condition to `ifelse()`?
- What types of values can be passed as the first argument to `switch()`?
- How do you stop a `repeat` loop executing?
- How do you jump to next iteration of a loop?