notes.Rmd

---
title: "Stat 33A - Lecture Notes 11"
date: Nov 1, 2020
output: pdf_document
---


Printing Output
===============

The `cat` function prints a message to the console:
```{r}
cat("Hello")

cat(4)

cat("Hello", "Nick")
```

Strings lose their quotes and escape sequences are converted.

The `cat` function always returns `NULL`:
```{r}
x = cat("Hello")
x
```


The `print` function prints R's representation of an object to the console:
```{r}
print(5)

print(c(5, 6))

x = c(5, 6)
print(x)

print("Hello")
```

Strings keep their quotes and escape sequences are not converted.

The `print` function returns the object being printed:
```{r}
y = print(5)
y
```

The `show` function is similar to `print`, but always returns `NULL`.

A later lecture might cover why both `print` and `show` are necessary.


For most output, `print` is the wrong function to use!


Formatting Output
-----------------

_Escape sequences_ allow you to write characters that aren't on your keyboard
in strings.

Escape sequences always begin with a backslash.

See `?Quotes` for a complete list.

For example, `\n` is a newline:
```{r}
x = "Hello\nNick"

cat(x)

print(x)
```

The `paste` function combines strings:
```{r}
y = paste("Hello", "Nick")
y
```

The `sprintf` function can substitute values into strings.

Substitutions are marked with `%` followed by a character:
```{r}
sprintf("My age is %i, and my name is %s", 32, "Nick")
```



For-loops
=========

A for-loop runs a block of code once for each element of a vector or list:
```{r}
x = c("Hi", "Hello", "Hope you had a nice day!")

for (msg in x) {
  cat(msg, "\n")
}

for (i in 1:5) {
  cat("This iteration is ", i, "\n")
}
```
Curly braces `{ }` are only required if you have multiple lines of code.


You have to write code to save the results from the loop.

In other words, create a variable where you can save results.

For example:
```{r}
# Add up the cubes of the numbers
numbers = c(-4, 10, -3, 6)

total = 0
for (number in numbers) {
  total = total + number^3
}

numbers
```

Use for-loops when some (or all) of the iterations depend on results from other
iterations.

If the iterations are not dependent, use one of:

1. Vectorization (because it's faster)
2. Apply functions (because they're idiomatic)

In some cases, you can use vectorization even when the iterations are
dependent. For example:
```{r}
sum(numbers^3)
```


As another example, let's use a loop to compute Fibonacci numbers.

Each Fibonacci number is the sum of the previous two. The first few Fibonacci
numbers are:
```
1 1 2 3 5 8 13
```

We can use a loop to compute the first `n` Fibonacci numbers:
```{r}
n = 10
fib = c(1, 1, numeric(n - 2))

for (i in 3:n) {
  fib[i] = fib[i - 1] + fib[i - 2]
}

fib
```

If you want to reuse this code, you could make it a function:
```{r}
fibonacci = function(n = 10) {
  fib = c(1, 1, numeric(n - 2))

  for (i in 3:n) {
    fib[i] = fib[i - 1] + fib[i - 2]
  }

  fib
}

fibonacci(30)
```


Break & Next
------------

Use `break` to exit a loop early:
```{r}
my_messages = list("Hi", "Hello", 5, "Goodbye")

for (msg in my_messages) {
  if (is.character(msg)) {
    cat(msg, "\n")
  } else {
    break
  }
}
```


Use `next` to skip to the next iteration early:
```{r}
for (msg in my_messages) {
  if (is.character(msg)) {
    cat(msg, "\n")
  } else {
    next
  }
}
```



Loop Indices
============

If you need indices, using `1:n` can cause bugs:
```{r}
n = 0
for (i in 1:n) {
  message(i)
}
```

Use `seq_len(n)` instead:
```{r}
n = 0
for (i in seq_len(n)) {
  message(i)
}
```

Similarly, using `1:length(x)` can cause bugs:
```{r}
#x = c(-3, 5, 7)
x = c()

for (i in 1:length(x)) {
  message("The element is ", x[i])
}
```

Use `seq_along(x)` instead:
```{r}
# x = c(-3, 5, 7)
x = c()

for (i in seq_along(x)) {
  message("The element is ", x[i])
}
```

More generally, use `seq()` to produce sequences of indices.



Preallocation
=============

_Preallocation_ means allocating memory for results before a computation.

These functions allocate vectors:

* `character()`
* `complex()`
* `numeric()`
* `logical()`

* `vector()`
* `rep()`

Examples:
```{r}
character(3)

complex(10)

numeric(4)

logical(3)

vector("logical", 6)

vector("list", 3)
```

Preallocation is especially important for loops:
```{r}
# BAD, NO PREALLOCATION:
x = c()

for (i in 1:1e5) {
  x = c(x, i * 2)
}
x

# GOOD:

n = 1e5
x = numeric(n)
for (i in seq_len(n)) {
  x[i] = i * 2
}
```



Loops Example
=============

Let's simulate a two-dimensional discrete random walk.

In a random walk, at each time step the walker randomly moves 1 unit along the
x-coordinates or the y-coordinates.

The algorithm is:

1. Flip a coin to determine whether walker moves in x or y.
2. Flip a coin to determine whether walker moves `-1` or `+1`.
3. Update the walker's position.
4. Repeat 1-3 for the desired number of steps.

We can do this with a for-loop:
```{r}
# Take n steps in a random walk.
n = 10
x = numeric(n + 1)
y = numeric(n + 1)

xy = sample(c(0, 1), n, replace = TRUE)  
move = sample(c(-1, 1), n, replace = TRUE)

for (i in seq_len(n)) {
  if (xy[i] == 0) { # x
    x[i + 1] = x[i] + move[i]
    y[i + 1] = y[i]
  } else { # y
    x[i + 1] = x[i]
    y[i + 1] = y[i] + move[i]
  }
}
```