MATH167R: Functions and Loops

Peter Gao

Overview of today

Writing R functions
Loops
Vectorization
Recursion

Anatomy of a function

Recall the structure of a function:

function_name <- function(param1, param2 = "default") {
  # body of the function
  return(output)
}

function_name: the name you want to give your function, what you will use to call it
function(): call this to define a function
param1, param2: formal arguments input by the user. You can assign default values by setting them equal to something in the call to function()
body: the actual code that is executed
return(): the output value returned to the user

Exercise: degrees to radians

Write a function degreesToRadians that takes as input one number, degrees, and returns its value in radians. You do not need to check the data type of the input.

Exercise: degrees to radians

degreesToRadians <- function(degrees) {
  return((degrees / 360) * 2 * pi)
}
degreesToRadians(180)

[1] 3.141593

Additional notes on functions

How do I know if a function is working?
- Test it on easy examples for which you know the results
- When using if, test all the possible cases

Loops

Loops enable us to repeat a line/lines of code many times.

R provides three types of explicit loops: for, while, and repeat. We will focus on for and while.

`for` loops

for loops repeat a chunk of code for each value of a vector.

for (name in vector) {body}

for (i in 1:8) {
  print(i)
}

[1] 1
[1] 2
[1] 3
[1] 4
[1] 5
[1] 6
[1] 7
[1] 8

Example: Vector sum

x <- c(1:10)
sum(x)

[1] 55

total_sum <- 0
for (i in x) {
  total_sum <- total_sum + i
}
print(total_sum)

[1] 55

Example: Fibonacci sequence

# code to compute the first 10 Fibonacci numbers
fib_10 <- numeric(10) # empty numeric vector of length 10
fib_10[1] <- 1
fib_10[2] <- 1
for (i in 3:10) {
  fib_10[i] <- fib_10[i - 1] + fib_10[i - 2]
}
fib_10

 [1]  1  1  2  3  5  8 13 21 34 55

`while` loops

while loops continuously evaluate the inner code chunk until the condition is FALSE.

Be careful here: It is possible to get stuck in an infinite loop!

x <- 0
while (x < 5) {
  cat("x is currently", x, ". Let's increase it by 1.")
  x <- x + 1
}

x is currently 0 . Let's increase it by 1.x is currently 1 . Let's increase it by 1.x is currently 2 . Let's increase it by 1.x is currently 3 . Let's increase it by 1.x is currently 4 . Let's increase it by 1.

`while` loops

Let’s see if we can clean up that output. Add "\n" to a string to force a line break.

x <- 0
while (x < 5) {
  cat("x is currently ", x, ". Let's increase it by 1! \n", sep = "")
  x <- x + 1
}

x is currently 0. Let's increase it by 1! 
x is currently 1. Let's increase it by 1! 
x is currently 2. Let's increase it by 1! 
x is currently 3. Let's increase it by 1! 
x is currently 4. Let's increase it by 1!

Example: String input

string_vector <- c("a", "b", "c", "d", "e")
for (mystring in string_vector) {
  print(mystring)
}

[1] "a"
[1] "b"
[1] "c"
[1] "d"
[1] "e"

Nested Loops

In nested loops, the innermost loop iterates most quickly.

counter <- 0
for (i in 1:3) {
  for (j in 1:2) {
    counter <- counter + 1
    cat("i = ", i, ", j = ", j, ", counter = ", counter, "\n", sep = "")
  }
}

i = 1, j = 1, counter = 1
i = 1, j = 2, counter = 2
i = 2, j = 1, counter = 3
i = 2, j = 2, counter = 4
i = 3, j = 1, counter = 5
i = 3, j = 2, counter = 6

Nested Loops

for (i in 1:3) {
  for (j in 1:2) {
    print(i * j)
  }
}

[1] 1
[1] 2
[1] 2
[1] 4
[1] 3
[1] 6

Filling in a vector

Note: Usually, this is an inefficient way to do this. We will see a faster way to work with vectors next class.

# Inefficient
x <- rep(NA, 5)
for (i in 1:5) {
  x[i] <- i * 2
}
x

[1]  2  4  6  8 10

# Much better
x <- seq(2, 10, by = 2)
x

[1]  2  4  6  8 10

Filling in a vector

library(stringr)
x <- rep(NA, 5)
my_strings <- c("a", "a ", "a c", "a ca", "a cat")
for (i in 1:5) {
  x[i] <- str_length(my_strings[i])
  print(x)
}

[1]  1 NA NA NA NA
[1]  1  2 NA NA NA
[1]  1  2  3 NA NA
[1]  1  2  3  4 NA
[1] 1 2 3 4 5

Filling in a matrix

Note: Usually, this is an inefficient way to do this. We will see a faster way to work with vectors next class.

x <- matrix(NA, nrow = 4, ncol = 3)
for (i in 1:4) {
  for (j in 1:3) {
    x[i, j] <- i * j
  }
}
x

     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    2    4    6
[3,]    3    6    9
[4,]    4    8   12

Continue until positive sample

set.seed(3)
x <- -1
while (x < 0) {
  x <- rnorm(1)
  print(x)
}

[1] -0.9619334
[1] -0.2925257
[1] 0.2587882

[1] 0.2587882

Combining Loops and Conditional Evaluation

Consider the following code. What do you think it does?

for (i in 1:10) {
  if (i %% 2 == 1) {
    print("odd")
  } else {
    print("even")
  }
}

[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"
[1] "odd"
[1] "even"

Fizz Buzz

Everyone takes turns to count incrementally.
Any number divisible by three is replaced with the word “fizz.”
Any number divisible by five is replaced with the word “buzz.”
Any number divisible by both three and five is replaced with the word “fizzbuzz.”

Can we write code for a computer to play fizz buzz with itself? Suppose we want the computer to play Fizz Buzz up to 100.

Fizz Buzz

for (i in 1:100) {
  if (i %% 3 == 0 & i %% 5 == 0) {
    print("fizzbuzz")
  } else if (i %% 3 == 0) {
    print("fizz")
  } else if (i %% 5 == 0) {
    print("buzz")
  } else {
    print(i)
  }
}

[1] 1
[1] 2
[1] "fizz"
[1] 4
[1] "buzz"
[1] "fizz"
[1] 7
[1] 8
[1] "fizz"
[1] "buzz"
[1] 11
[1] "fizz"
[1] 13
[1] 14
[1] "fizzbuzz"
[1] 16
[1] 17
[1] "fizz"
[1] 19
[1] "buzz"
[1] "fizz"
[1] 22
[1] 23
[1] "fizz"
[1] "buzz"
[1] 26
[1] "fizz"
[1] 28
[1] 29
[1] "fizzbuzz"
[1] 31
[1] 32
[1] "fizz"
[1] 34
[1] "buzz"
[1] "fizz"
[1] 37
[1] 38
[1] "fizz"
[1] "buzz"
[1] 41
[1] "fizz"
[1] 43
[1] 44
[1] "fizzbuzz"
[1] 46
[1] 47
[1] "fizz"
[1] 49
[1] "buzz"
[1] "fizz"
[1] 52
[1] 53
[1] "fizz"
[1] "buzz"
[1] 56
[1] "fizz"
[1] 58
[1] 59
[1] "fizzbuzz"
[1] 61
[1] 62
[1] "fizz"
[1] 64
[1] "buzz"
[1] "fizz"
[1] 67
[1] 68
[1] "fizz"
[1] "buzz"
[1] 71
[1] "fizz"
[1] 73
[1] 74
[1] "fizzbuzz"
[1] 76
[1] 77
[1] "fizz"
[1] 79
[1] "buzz"
[1] "fizz"
[1] 82
[1] 83
[1] "fizz"
[1] "buzz"
[1] 86
[1] "fizz"
[1] 88
[1] 89
[1] "fizzbuzz"
[1] 91
[1] 92
[1] "fizz"
[1] 94
[1] "buzz"
[1] "fizz"
[1] 97
[1] 98
[1] "fizz"
[1] "buzz"

Coding challenges

Project Euler
HackerRank
LeetCode (doesn’t support R)

Vectorization

Last class, we saw how to use for and while loops to repeat tasks. However, often in R, functions or operations are vectorized, meaning they automatically act on every entry in a vector.

x <- 1:4
x * 2

[1] 2 4 6 8

Vectorization

x <- 1:4
x < 2

[1]  TRUE FALSE FALSE FALSE

x <- 1:4
y <- 4:1
x + y

[1] 5 5 5 5

Vectorization with data

We often rely on vectorization when working with columns of a data frame.

library(palmerpenguins)
library(tidyverse)
data(penguins)
penguins <- penguins |>
  mutate(bill_len_dep_ratio = bill_length_mm / bill_depth_mm)
penguins$bill_len_dep_ratio

  [1] 2.090909 2.270115 2.238889       NA 1.901554 1.907767 2.185393 2.000000
  [9] 1.883978 2.079208 2.210526 2.184971 2.335227 1.820755 1.639810 2.056180
 [17] 2.036842 2.053140 1.869565 2.139535 2.065574 2.016043 1.869792 2.110497
 [25] 2.255814 1.867725 2.182796 2.262570 2.037634 2.142857 2.365269 2.055249
 [33] 2.219101 2.164021 2.141176 1.857820 1.940000 2.281081 1.948187 2.083770
 [41] 2.027778 2.217391 1.945946 2.238579 2.189349 2.106383 2.163158 1.984127
 [49] 2.011173 1.995283 2.237288 2.121693 1.955307 2.153846 1.906077 2.225806
 [57] 2.228571 2.159574 2.198795 1.968586 2.112426 1.957346 2.211765 2.258242
 [65] 2.128655 2.311111 2.191358 2.151832 2.162651 2.154639 1.763158 2.157609
 [73] 2.302326 2.423280 2.028571 2.313514 2.434524 1.917526 2.248447 2.204188
 [81] 2.011628 2.437500 1.952128 1.809278 2.095506 2.034483 1.861538 1.983871
 [89] 1.994792 2.069149 1.983333 2.270718 1.988304 2.187845 2.092486 2.158730
 [97] 2.048387 2.178378 2.055901 2.335135 1.955307 2.050000 2.356250 1.890000
[105] 2.037634 2.100529 2.244186 1.910000 2.241176 2.273684 2.309091 2.246305
[113] 2.242938 2.164103 1.913043 2.333333 2.270588 1.819512 2.100000 2.209677
[121] 2.104651 1.904040 2.364706 2.237838 2.213836 2.136842 2.204545 2.267760
[129] 2.280702 2.450000 2.150838 2.244792 1.989189 2.027027 2.164773 2.348571
[137] 2.034286 2.000000 2.242424 2.217877 2.350877 2.360465 2.070968 2.394118
[145] 2.220238 2.085561 2.107527 1.989130 2.022472 2.088398 2.105263 2.243243
[153] 3.492424 3.067485 3.453901 3.289474 3.282759 3.444444 3.109589 3.052288
[161] 3.231343 3.038961 2.985401 3.043478 3.321168 3.315068 3.136986 3.140127
[169] 3.111111 3.236842 3.186207 3.225166 3.510490 3.110345 3.206897 2.930380
[177] 3.274809 3.052980 3.111888 3.186667 3.370629 3.267974 3.091503 3.014085
[185] 3.110345 3.505882 3.317568 2.969325 3.109489 2.566474 3.235294 3.101911
[193] 3.116788 3.100000 3.306569 3.306667 3.176101 3.136691 3.273381 3.176101
[201] 3.375940 2.860759 3.281690 3.439716 3.131944 3.340000 3.229167 2.922078
[209] 3.151079 3.033333 2.979310 3.294118 3.282609 3.100671 3.287770 3.458599
[217] 3.225352 2.964286 3.208333 3.055556 3.063380 3.380000 3.180000 2.974359
[225] 3.089744 3.141892 3.093333 3.037500 3.345070 3.134969 3.275362 2.756098
[233] 3.386207 3.365385 3.246575 3.144654 3.253623 2.936416 3.013889 3.612676
[241] 3.392857 3.064706 3.166667 3.052632 3.137931 3.074534 3.027211 3.235669
[249] 3.126582 3.212329 3.361111 3.096970 3.233333 3.288235 3.045161 3.273333
[257] 3.427536 2.906832 2.836735 3.379747 3.092857 3.185430 3.322368 3.132075
[265] 2.861842 3.159509 3.276596 3.443750 2.834395 3.012346 3.445255       NA
[273] 3.272727 3.210191 3.054054 3.099379 2.597765 2.564103 2.671875 2.427807
[281] 2.661616 2.539326 2.532967 2.818681 2.433862 2.577889 2.617978 2.546798
[289] 2.716763 2.872928 2.684211 2.576531 2.515000 3.258427 2.494624 2.703297
[297] 2.450867 2.771429 2.602410 2.608247 2.608939 2.736842 2.744565 2.605263
[305] 2.606742 2.640000 2.463855 2.605769 2.544910 2.712766 2.672043 2.827381
[313] 2.601093 2.512077 2.825301 2.688442 2.512821 2.640000 2.664921 2.676471
[321] 2.843575 2.745946 2.798883 2.500000 2.754011 2.878613 2.932927 2.705263
[329] 2.641618 2.573604 2.456647 2.776596 2.722892 2.477387 2.670213 2.350515
[337] 2.661538 2.836364 2.688235 2.818182 2.403315 2.725275 2.673684 2.684492

Vectorization in functions

Often we desire our function to be vectorized: so that it can take in vectors as inputs and perform an operation/task for each entry of the vector(s).

For this reason, it is important to begin remembering which functions are vectorized/vectorizable.

Absolute error

weather_forecasts <- readr::read_csv('https://raw.githubusercontent.com/rfordatascience/tidytuesday/master/data/2022/2022-12-20/weather_forecasts.csv')
weather_forecasts <- weather_forecasts |>
  mutate(abs_err_temp = abs(observed_temp - forecast_temp))

Exercise: Write a function that takes as input two vectors of length \(n\), observed and predicted and returns a vector of length \(n\) of the absolute errors.

Absolute error

absolute_error <- function(observed, predicted) {
  return(abs(observed - predicted))
}

Squared error

Exercise: Write a function that takes as input two vectors of length \(n\), observed and predicted and returns a vector of length \(n\) of the squared errors.

squared_error <- function(observed, predicted) {
  return((observed - predicted)^2)
}

Why not vectorize?

modifying in place
while loops
recursive functions

Modifying in place

Sometimes we wish to change the value of some object iteratively. In such cases, vectorizing code may not be possible.

What do you expect the output of this code to be?

x <- 1:10
for (i in 10:1) {
  x[i] <- sum(x[1:i])
}
x

 [1]  1  3  6 10 15 21 28 36 45 55

These are known as the triangular numbers.

Recursion

Recursion is a method for solving a problem where the solution can be divided into simpler or smaller versions of the same problem.

Example: Factorial function

Example: Fractals

Recursive functions: factorial

Recursive functions are those that call themselves to solve problems.

fact <- function(x) {
  if (x == 0 | x == 1) {
    return(1)
  } else {
    return(x * fact(x - 1))
  }
}
fact(4)

[1] 24

Recursive functions: Fibonacci

Exercise: write a function fibonacci() that takes as input a natural number n and returns the \(n\)th Fibonacci number.

fibonacci <- function(n) {
  if (n == 1 | n == 2) {
    return(1)
  } else {
    return(fibonacci(n - 1) + fibonacci(n - 2))
  }
}
fibonacci(10)

[1] 55

Recursive functions: Prime factorization

Write a function factorize() that takes as input a natural number n and returns its prime factorization.

How might we get started with this question?

MATH167R: Functions and Loops

Overview of today

Anatomy of a function

Exercise: degrees to radians

Exercise: degrees to radians

Additional notes on functions

Loops

for loops

Example: Vector sum

Example: Fibonacci sequence

while loops

while loops

Example: String input

Nested Loops

Nested Loops

Filling in a vector

Filling in a vector

Filling in a matrix

Continue until positive sample

Combining Loops and Conditional Evaluation

Fizz Buzz

Fizz Buzz

Coding challenges

Vectorization

Vectorization

Vectorization with data

Vectorization in functions

Absolute error

Absolute error

Squared error

Why not vectorize?

Modifying in place

Recursion

Recursive functions: factorial

Recursive functions: Fibonacci

Recursive functions: Prime factorization

`for` loops

`while` loops

`while` loops