1. Structure of simple functions
2. Advanced functions for iteration
   • if, ifelse, for, while
   • apply() and its family (tapply, lapply, sapply, mapply)
3. Homework
4. Exercises

# the ingredients
rescale01 <- function(x) {
  # step 1
  rng <- range(x, na.rm = TRUE)
  # step 2
  r <- (x - rng[1]) / (rng[2] - rng[1])
  # return allows me to modify the output
  return(list(rng, r))                  
}
# see the result!
rescale01(c(0, 5, 10))                  

[[1]]
[1]  0 10

[[2]]
[1] 0.0 0.5 1.0

1. Open an RStudio session https://github.com/ifetzer/RStudioForTeaching
2. Load the gapminder data
3. country is of the class factor, discuss in couples what are they and when are useful?
   • Tip: help(factor) & help(levels)
4. How many countries has the gapminder data?
5. Write a function to calculate the average
   • Test it in small cases

6. For every country in the dataset calculate the average life expectancy, the range of the popluation, and the median GDP per capita
   • Tip: for(), median(), range()
7. Use the result to plot:
   • Average lifeExp vs median gdpPercap
8. For every year in the dataset calculate the average life expectancy across all countries. Plot the result over time
   • ??base::plot

4. How many countries has the gapminder data?

library(gapminder)
data(gapminder)

class(gapminder$country)

[1] "factor"

levels(gapminder$country) |> 
    length()

[1] 142

5. Write a function to calculate the average

avg <- function(x){
    sum(x, na.rm = TRUE) / length(x)
}

#test
avg(c(3,4,6,7,9,11))

[1] 6.666667

avg(c(NA, 43, 68))

[1] 37

avg(gapminder$gdpPercap)

[1] 7215.327

base

countries <- levels(gapminder$country)
# when working with loops, it is a good practice to
# declare the objects that will collect your results
ale <- list() # average life expectancy
pop_rng <- list() # population range
med_gdp <- list() # median gdp

for (i in seq_along(countries)) {
    ale[[i]] <- avg(
        gapminder[gapminder$country == countries[i], "lifeExp"])
    pop_rng[[i]] <- range(
        gapminder[gapminder$country == countries[i], "pop"])
    med_gdp[[i]] <- median(
        gapminder[gapminder$country == countries[i],]$gdpPercap, na.rm = TRUE)

}

tidyverse

suppressPackageStartupMessages(library(tidyverse))
solution <- gapminder |> 
    group_by(country) |> 
    summarise(
        ale = mean(lifeExp),
        pop_min = min(pop),
        pop_max = max(pop),
        med_gdp = median(gdpPercap)
    )

base

plot(x = unlist(ale), y = unlist(med_gdp), 
     xlab = "Average life expectancy",
     ylab = "Median GDP", 
     type = "p", col = "orange")

tidyverse

# you can create a new object or pipe it!
solution |> 
    ggplot(aes(x = ale, y = med_gdp)) +
    geom_point(color = "orange") +
    geom_smooth() +
    labs(x = "Average life expectancy", y = "Median GDP")

• Functional programming
  • Functions of functions: functions can be arguments to other functions, returned to other functions, and be treated as data types.
• Advantages of purrr:
  • First argument is data
  • All functions are type-stable
  • Accepts functions or formulas
  • Understand variables by name or position
  • Easier to handle errors

All functions are type-stable

• map(): list
• map_dbl(): double
• map_chr(): character
• map_int(): integer
• map_raw(): raw vector
• map_dfr(): data frame binding rows
• map_dfc(): data frame binding columns
• modify(): same as input

Why do you think map works with data frames without complain?

gapminder |> 
    select(-country, -continent) |> 
    map(mean)

$year
[1] 1979.5

$lifeExp
[1] 59.47444

$pop
[1] 29601212

$gdpPercap
[1] 7215.327

lm(gdpPercap ~ year, data = gapminder)

Call:
lm(formula = gdpPercap ~ year, data = gapminder)

Coefficients:
(Intercept)         year  
  -249693.7        129.8  

gapminder |> 
    ggplot(aes(year, gdpPercap)) +
    geom_smooth(method = "lm") + theme_light(base_size = 10)

split(gapminder, ~country) |> 
    map(~ lm(gdpPercap ~ year, data = .)) |> 
    map(summary) |> 
    map(coef) |> 
    map_dfr(function(x) x["year","Estimate"]) |> 
    pivot_longer(cols = everything(), names_to = "country", values_to = "slope") |> 
    arrange(slope)

# A tibble: 142 × 2
   country                     slope
   <chr>                       <dbl>
 1 Kuwait                   -1584.  
 2 Iraq                       -48.6 
 3 Nicaragua                  -29.4 
 4 Angola                     -23.3 
 5 Djibouti                   -20.1 
 6 Madagascar                 -14.1 
 7 Congo, Dem. Rep.           -12.9 
 8 Central African Republic    -9.81
 9 Haiti                       -9.55
10 Somalia                     -7.91
# … with 132 more rows

x <- list(list(1,2,3),
          list(4,5,6),
          list(7,8,9))

x |> map_dbl(2)

[1] 2 5 8

models <- mtcars |> 
    split( ~cyl) |> 
    map(function(df) lm(mpg ~ wt, data = df))

models <- mtcars |> 
    split( ~cyl) |> 
    map(~lm(mpg ~ wt, data = .))

models |> 
    map(summary) |> 
    map_dbl(~.$r.squared)

        4         6         8 
0.5086326 0.4645102 0.4229655 

models |> 
    map(summary) |> 
    map_dbl("r.squared")

        4         6         8 
0.5086326 0.4645102 0.4229655 

log("juan")

Error in log("juan"): non-numeric argument to mathematical function

safe_log <- safely(log)
str(safe_log(10))

List of 2
 $ result: num 2.3
 $ error : NULL

str(safe_log("mary"))

List of 2
 $ result: NULL
 $ error :List of 2
  ..$ message: chr "non-numeric argument to mathematical function"
  ..$ call   : language .Primitive("log")(x, base)
  ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"

When there is an error, the result is null and the error message captured

x <- list(1, 10, "a")
y <- x |> map(safely(log))
str(y)

List of 3
 $ :List of 2
  ..$ result: num 0
  ..$ error : NULL
 $ :List of 2
  ..$ result: num 2.3
  ..$ error : NULL
 $ :List of 2
  ..$ result: NULL
  ..$ error :List of 2
  .. ..$ message: chr "non-numeric argument to mathematical function"
  .. ..$ call   : language .Primitive("log")(x, base)
  .. ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"

y <- transpose(y)
str(y)

List of 2
 $ result:List of 3
  ..$ : num 0
  ..$ : num 2.3
  ..$ : NULL
 $ error :List of 3
  ..$ : NULL
  ..$ : NULL
  ..$ :List of 2
  .. ..$ message: chr "non-numeric argument to mathematical function"
  .. ..$ call   : language .Primitive("log")(x, base)
  .. ..- attr(*, "class")= chr [1:3] "simpleError" "error" "condition"

is_ok <- y$error |> map_lgl(is_null)
x[!is_ok]

[[1]]
[1] "a"

y$result[is_ok] |> flatten_dbl()

[1] 0.000000 2.302585

Advantages:

• You can run your computation in all the objects catching up errors
• You can then investigate what errors you get and why
• Correct and focus only on the problematic cases

purrr offers other adverb functions:

• possibly()
• quietly()