Making Factors

We can make factors that have an inherent order

monthLevels <- c("Jan", "Feb", "Mar", "Apr", "May", "Jun",
                 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec")
data <- factor(c("Dec", "Jun", "Apr"))
data

[1] Dec Jun Apr
Levels: Apr Dec Jun

But sorting them may not give us what we expect

sort(data)

[1] Apr Dec Jun
Levels: Apr Dec Jun

Making Factors

• Factors always have an internal order, even if you don’t give one
• If you don’t set the levels, they will be alphabetical
• If you want a specific order, you need to give it:

monthLevels <- c("Jan", "Feb", "Mar", "Apr", "May", "Jun",
                 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec")
data <- factor(c("Dec", "Jun", "Apr"), levels = monthLevels)
sort(data)

[1] Apr Jun Dec
Levels: Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec

Factors Practice

• create a factor vector called ‘marauders’ that contains the strings ‘moony’, ‘wormtail’, ‘padfoot’ and ‘prongs’ in alphabetical order
• create a factor called ‘patronus’ with the strings ‘stag’, ‘dog’, ‘otter’, creating levels from the order they appear in the input vector
• print only the levels of these factors

Using diamonds

• use dplyr::count() to show how many rows there are for each factor level in the ‘cut’ column. Is it any different to using forcats::fct_count()?
• use dplyr::arrange(desc()) to sort the cut column in descending order. What were the rows sorted by?

Why use the Forcats* package?

• It enables a lot of the common needs we have with factors
• It works well with ggplot2 (also written by Hadley/the tidyverse team)
• It generally tries to warn you when something may be wrong
• It has the word cats in it
• It’s an anagram of factors
• It’s for categoricals (factors)
• Something about cats

*strictly for humans

fct_reorder()

• the most useful (in my opinion)
• reorder your factor levels by another variable
• allows you to bring structure to plots

gss_cat |>
    group_by(marital) |>
    summarise(tvhours = mean(tvhours, na.rm = TRUE)) |>
    ggplot(aes(tvhours, fct_reorder(marital, tvhours))) + # <<<---
      geom_point()

Forcats - Practice!

Using gss_cat

• how many levels are there in the ‘relig’ column?
• reorder the levels of ‘denom’ in order of appearance
• take the code below which plots income by age. Try changing the order of the levels in ‘rincome’ to be sorted by ‘age’. Now try just moving n/a to the start. Which option works best?

gss_cat |>
  group_by(rincome) |>
  summarise(
    age = mean(age, na.rm = TRUE),
    tvhours = mean(tvhours, na.rm = TRUE),
    n = n()) |>
  ggplot(aes(age, rincome)) +
    geom_point()

How Dates Work in R

• Dates and times are not just strings, they have many formats like YYYY-MM-DD, MM/DD/YYYY, or even DD-MM-YYYY.
• Handling dates involves dealing with varied formats, time zones, leap years, and calculations between dates
• R has special packages to parse and manage dates efficiently.

class("2024-10-20") # a simple date string

[1] "character"

class(as.Date("2024-10-20")) # a date object

[1] "Date"

typeof(as.Date("2024-10-20")) # but a double under the hood

[1] "double"

Introduction to lubridate

• lubridate is an R package designed to make working with dates and times easier
• It helps parse different date formats, manipulate dates, and perform calculations.
• It’s just not possible to be accurate in handling dates without a dedicated date package
• But with lubridate, you can:
  • parse dates from strings in common formats
  • do arithmetic with dates easily
  • account for time zones, leap years etc.
  • handle times too (though we don’t cover that here)

lubridate::practice()

• John Doe was born on 4th September, 1983. Create a date object for his birth date
• How old was John on the 6th June, 2020?
• What about today?

using the lakers dataset which comes with lubridate

• choose the correct function to replace some_function below:

lakers |> 
  as_tibble() |> 
  mutate(date = some_function(sprintf("%08d", date)))

lubridate::practice_more()

using the economics dataset from ggplot2

• take the date column from the economics dataset and create two new columns which contain the year and month of each date
• create a new column called time_since_nyse, which contains the number of years between the founding of the New York Stock Exchange on 17th May, 1792 and the date column

Functions

Functions in R:

• allow you to automate tasks in a more powerful way than copy/paste
• mean you only need to update code in one place
• reduce the likelihood of errors
• are for others, but mainly for YOU
• should be written for readability and reusability
• have the format

function_name <- function(arg1, arg2, arg3) {
  # function body
}

Functions - Practice!

call your functions after creating them to check their output

• write an empty function with no arguments, called ‘stub_func’.
• write a function that takes no arguments and returns the number 3 using the return() statement. Choose an appropriate name.
• create another function with no return statement or arguments, which only contains the number 3. Run the function. Is it different to before?
• create a function called my_divide() which takes two arguments, ‘x’ and ‘y’ and returns x divided by y. Use an explicit return statement.
• we want to still return a value when y is zero. Change the my_divide() function so that there is another argument called ‘tol’. Set it to a very low value, and add it to y before dividing.

General Rules for Writing Functions

Try to decipher the following code below - what does it do? - does it work? Are there errors?

df <- data.frame(a = rnorm(10), b = rnorm(10), c = rnorm(10), d = rnorm(10))
df$a <- (df$a - min(df$a, na.rm = TRUE)) / (max(df$a, na.rm = TRUE) - min(df$a, na.rm = TRUE))
df$b <- (df$b - min(df$b, na.rm = TRUE)) / (max(df$b, na.rm = TRUE) - min(df$a, na.rm = TRUE))
df$c <- (df$c - min(df$c, na.rm = TRUE)) / (max(df$c, na.rm = TRUE) - min(df$c, na.rm = TRUE))
df$d <- (df$d - min(df$d, na.rm = TRUE)) / (max(df$d, na.rm = TRUE) - min(df$d, na.rm = TRUE))

Anonymous functions

• sometimes we need to package up some code in a function, but we know we’ll never need it again
• this is common where we do something trivial, like a simple calculation
• in these cases we often create a function on the fly in the call to another function
• these are called anonymous functions (because we don’t name them) or lambda functions (from lambda calculus)
• they’re reasonably common in R, especially when using dplyr

Anonymous functions

• you’ve already seen these in calls to functions like summarise()!
• the tilde (~) is used to create a lambda function, and the dot (.x) is used to refer to the input
• you will also see . used to refer to the input - this is the same as .x
• you can actually use anything you like, but . and .x are common conventions

# example use of an anonymous function with summarise
gapminder |>
  group_by(continent) |>
  summarise(across(where(is.numeric), ~ mean(.x, na.rm = TRUE))) |>
  head(3)

Anonymous functions

• In this way,

~ mean(.x, na.rm = TRUE)

is equivalent to

function(.x) {
  mean(.x, na.rm = TRUE)
}

if-else statements

• ifelse() lets us use vectorised if-else statements (note, dplyr has a version called dplyr::if_else() that’s a bit stricter)
• if you have a lot of if statements, check out the switch() function
• dplyr::case_when() handles multiple vectorised if_else() statements

# example use of case_when to simplify multiple if_else statements
gapminder |>
  mutate(lifeExp_category = case_when(
    lifeExp < 50 ~ "Low",
    lifeExp >= 50 & lifeExp <= 70 ~ "Medium",
    lifeExp > 70 ~ "High"
  )) |>
  head(3)

Unit Testing

• for testing the smallest unit of code (functions)
• they are simply functions that test your code to make sure it does what it is supposed to
• this can mean it gives the correct output with expected input, but also that it errors as expected when you give it faulty input
• allows you to change your code and quickly check it still works
• allows you to sleep at night
• done in r using the testthat package

Unit testing - practice!

• create a function called my_multiply() that takes two arguments, x and y and returns their product
• write a test for this function that checks that my_multiply(2, 3) returns 6
• use the example of my_add below and modify it:

my_add <- function(x, y) {
  return(x + y)
}

testthat::test_that("my_add() works as expected",
{
  testthat::expect_equal(my_add(2, 3), 5)
})