Programming in R

Think of R as instructions applied to stored objects

An object is a named piece of data. A function is an instruction that takes inputs and returns a result. A script records these instructions so you can repeat the analysis.

height <- c(168, 182, 175, 190)
mean(height)
# 178.75

Read this as “store these four numbers under the name height, then calculate their mean.” The console runs commands; a saved script makes the process reproducible. RStudio supplies editing, object inspection, help and plots around R.

Values, types and assignment

NA means missing/unknown. It is not zero, the word “NA”, or false. It can be a missing value of different types. Date/time is a useful class of objects, rather than a separate primitive typeof() result.

Use <- to assign: age <- 24. The right-hand expression is evaluated and stored on the left. = can assign in many contexts, but <- keeps object assignment visually distinct from named function arguments such as na.rm = TRUE. Rightward assignment exists; the slides discourage it for readability.

R is case-sensitive: height and Height are different objects. Names cannot start with a digit and cannot contain arbitrary punctuation or spaces without special handling. Use simple meaningful names. ls() lists existing object names; typeof(x) checks a storage type; str(x) shows an object's structure. class(x) describes its class, which can convey more meaning than storage type.

mass <- 70
mass * 2       # 140
mass == 70     # TRUE: comparison, not assignment

Data structures: what container do you need?

An atomic vector containing numbers and text is coerced to a common type, usually character. A list can preserve mixed element types. A data frame is list-like, but its columns must form a rectangular table.

height <- c(168, 182, 175, 190)
birthplace <- c("Utrecht", "Delft", "Leiden", "Haarlem")
athletes <- data.frame(height, birthplace)
str(athletes)

matrix(height, nrow = 2)
#      [,1] [,2]
# [1,]  168  175
# [2,]  182  190

R fills matrices by column unless you request byrow = TRUE. A matrix made with byrow = TRUE would instead have first row 168, 182. This difference matters when interpreting code.

information <- list(name = "Ari", height = 182, tests = c(42, 45))
discipline <- factor(c("road", "sprint", "road"))

A factor's labels are categories. Its internal integer codes are not quantities you should average. An ordered factor can explicitly encode an order where appropriate.

Subsetting: retrieve only the part you want

R indexing begins at 1. Square brackets select part of an object.

height[2]                    # 182
height[c(1, 4)]              # 168, 190
height[2:4]                  # 182, 175, 190
height[-2]                   # everything except element 2
height[height >= 180]        # 182, 190
athletes[1, 2]               # row 1, column 2
athletes[, "height"]         # all rows of height column
athletes$height              # named column
athletes[athletes$height >= 180, ]

For a matrix or data frame, the comma separates rows, columns. An empty position means all rows or all columns. athletes["height"] returns a one-column data frame, whereas athletes$height normally returns the vector. For lists, x[1] preserves a sublist and x[[1]] extracts the element.

Logical filtering works because each TRUE selects its corresponding value. A missing comparison can yield NA, so missingness requires attention rather than assuming every comparison is true or false.

Functions and their arguments

A function call has the form function_name(arguments). Use ?mean or help("mean") for help, including argument names and defaults.

vo2 <- c(42.1, 51.6, 47.3, NA)
mean(vo2)                    # NA
mean(vo2, na.rm = TRUE)      # 47
sum(height)                 # 715
median(c(62, 75, 68, 80))    # 71.5
round(c(42.123, 51.678), digits = 2)  # 42.12, 51.68

na.rm = TRUE tells these summaries to omit missing values. It does not restore the unobserved information or guarantee an unbiased estimate. Here it averages the three observed values.

names() attaches names to vector elements, not a new numerical value:

names(height) <- c("Ari", "Bo", "Cam", "Dee")
print(height)

The slide calls this a “named function” in one place; the demonstration actually creates a named vector.

Rounding, floor and ceiling

For negatives, floor(-3.2) is −4 and ceiling(-3.2) is −3. “Nearest 10th value” in the VO₂ exercise means rounding to multiples of ten, not necessarily one decimal place. In R, exact halfway cases use ties-to-even, so do not assume all halfway values round upward.

Write a function you can reuse

absolute_vo2 <- function(relative_vo2, mass_kg) {
  relative_vo2 * mass_kg / 1000
}
absolute_vo2(50, 70)          # 3.5 L/min

Relative VO₂ has units mL/kg/min. Multiplying by kg produces mL/min; dividing by 1,000 produces L/min. The slide example multiplies and divides by 1,000. State the output units. Functions can operate on whole vectors here, with corresponding elements multiplied. The last evaluated expression is returned; explicit return(...) also works.

Conditions: choose a branch

The comparison operators are <, >, <=, >=, ==, !=. Use == to compare equality; <- assigns. A scalar if condition must resolve to one nonmissing logical value.

height_label <- function(h) {
  if (h >= 190) {
    "very tall"
  } else if (h >= 175) {
    "tall"
  } else if (h >= 160) {
    "average"
  } else {
    "short"
  }
}
height_label(182)             # "tall"

Order matters. Test the highest threshold first. Once a branch is selected, subsequent branches are skipped. The second branch covers 175 up to but excluding 190, because the first branch already handled 190 and above. These are the exercise's illustrative labels, not universal physiological classifications.

Loops: repeat an instruction

for (h in height) {
  print(height_label(h))
}

Each iteration takes the next height, runs the same function, and prints its label. for (i in 1:4) iterates over indices instead. You can store results rather than only print them:

labels <- character(length(height))
for (i in seq_along(height)) {
  labels[i] <- height_label(height[i])
}

Vectorized functions often avoid an explicit loop, but knowing how to trace a loop helps you understand a script. Do not treat a code screenshot as something to memorize without following what changes at each step.

Libraries/packages

install.packages("ggplot2") downloads and installs a package; library(ggplot2) loads it for the current R session. Installation needs internet unless the files are already available. Once installed, packages work without downloading them again.

The slides show an ecosystem including plotting (ggplot2), wrangling (dplyr), dates (lubridate), reporting and interactive applications. You should recognize why packages exist rather than learn every logo. Lecture 4 develops wrangling and visualization.

What the ten slide exercises teach

1. Recognize data types.
2. Create vectors, a matrix and a data frame.
3. Name elements and print them.
4. Use mean, sum, median and round.
5. Handle missing values in summaries.
6. Round to a coarser increment.
7. Write a reusable VO₂ function.
8. Trace an if/else chain.
9. Repeat it for every group member.
10. Find relevant packages.