DRAFT This draft is under development — DO NOT CITE OR SHARE.

Appendix C — R Language Concepts for Statistical Computing

This appendix provides a structured overview of core R language concepts for readers who want to move beyond app-based usage and perform analysis directly in code. The focus is on concepts that are repeatedly used in statistical workflows.

C.1 1. Computational Model of R

R is an interpreted language with vectorized semantics and a functional core. Most statistical procedures in R are exposed as functions that operate on vectors, matrices, data frames, or model objects. In practice, this means:

  • Objects are first-class values that can be created, transformed, and passed to functions.
  • Functions are the central abstraction for analysis and automation.
  • Many operations are defined element-wise, which reduces the need for explicit loops.

R can be used procedurally, functionally, and object-orientedly (e.g., S3 classes in many statistical packages).

C.2 2. Objects and Data Structures

C.2.1 2.1 Atomic vectors

An atomic vector stores values of a single underlying type (logical, integer, double, character, etc.).

Code 
x_num <- c(2.1, 3.4, 5.0)
x_chr <- c("A", "B", "C")
typeof(x_num)
length(x_num)

C.2.2 2.2 Factors

Factors represent categorical variables with explicit levels. Many model-fitting functions automatically encode factors as contrast matrices (treatment/dummy coding by default; see contrasts() for alternatives).

Code 
g <- factor(c("control", "treatment", "control"))
levels(g)

C.2.3 2.3 Lists

Lists can store heterogeneous elements and are widely used for function returns.

Code 
obj <- list(a = 1:3, b = "text", c = TRUE)
obj$a

C.2.4 2.4 Matrices and arrays

Matrices are 2-dimensional homogeneous structures. Arrays generalize this to higher dimensions.

Code 
M <- matrix(1:9, nrow = 3)
dim(M)

C.2.5 2.5 Data frames and tibbles

A data frame is a tabular structure with rows as observations and columns as variables. Columns can have different types. Tibbles are modern data frames with stricter printing and subsetting behavior.

Code 
df <- data.frame(y = c(1.2, 2.3), group = factor(c("A", "B")))
str(df)

C.3 3. Operators and Evaluation

R distinguishes assignment from comparison:

  • Assignment: <-, = (= also names function arguments, e.g., na.rm = TRUE; prefer <- for variable assignment to avoid ambiguity)
  • Equality test: ==
  • Relational operators: <, <=, >, >=, !=
  • Vectorized logical operators: !, &, | (element-wise; use in subsetting and ifelse())
  • Scalar short-circuit operators: &&, || (first element only; use in if() control flow)
  • Membership: %in%

Operator precedence matters in complex expressions. Parentheses should be used explicitly when readability is important.

Code 
x <- 5
y <- 2
x == y
(x > 1) & (y < 3)

C.4 4. Missingness and Special Numeric Values

R distinguishes several special values:

  • NA: missing value
  • NaN: undefined numeric result (e.g., 0/0)
  • Inf, -Inf: positive/negative infinity

Most summary functions propagate NA unless na.rm = TRUE is set.

Code 
z <- c(4, NA, 7, 10)
mean(z)                 # returns NA
mean(z, na.rm = TRUE)   # ignores missing values
is.na(z)

C.5 5. Coercion and Type Discipline

R may coerce types implicitly. This is convenient but can introduce subtle errors if not monitored.

Code 
c(1, 2, "3")      # numeric values coerced to character
as.numeric("3.14")
as.factor(c("low", "high", "low"))

In statistical work, type checks (str, typeof, is.factor, is.numeric) should be part of routine data validation.

C.6 6. Indexing and Subsetting

Subsetting can be positional, logical, or name-based.

Code 
x <- c(10, 20, 30, 40)
x[2]                  # positional
x[x > 20]             # logical

df <- data.frame(a = 1:4, b = c("x", "y", "x", "z"))
df[df$a >= 3, "b"]    # row/column subset

For matrices/data frames, be explicit about dimensions (drop = FALSE) when a 2D structure must be preserved.

C.7 7. Functions, Scope, and Environments

Functions encapsulate logic and improve reproducibility. R uses lexical scoping: a function resolves names in its local environment first, then in enclosing environments.

Code 
compute_mean <- function(x, na_rm = TRUE) {
  mean(x, na.rm = na_rm)
}
compute_mean(c(1, 2, NA, 4))

As a rule, functions should avoid side effects (e.g., modifying global objects) unless explicitly intended.

C.8 8. Control Flow and Vectorization

R supports if, for, while, and repeat, but vectorized solutions are often clearer and faster for statistical tasks.

Code 
x <- 1:10
ifelse(x %% 2 == 0, "even", "odd")

The apply family (apply, lapply, sapply, vapply) is frequently used for structured iteration.

C.9 9. Formula Interface in Statistical Models

Many methods in R use the formula interface:

  • y ~ x1 + x2: additive model
  • y ~ x1 * x2: interaction plus main effects
  • y ~ .: all available predictors
  • y ~ x - 1: no intercept
Code 
fit <- lm(mpg ~ wt + hp, data = mtcars)
summary(fit)

Model outputs are structured objects; extraction of coefficients, residuals, fitted values, and diagnostics is typically done with accessor functions.

C.10 10. Packages, Documentation, and Citation

R’s statistical ecosystem is package-based. A robust workflow includes:

  1. Install once (install.packages)
  2. Load per session (library)
  3. Verify behavior via help pages and examples
  4. Cite packages used in academic work
Code 
install.packages("lmtest")
library(lmtest)
?bptest
citation("lmtest")

C.11 11. Practical Guidance for Students

When moving from app-based analysis to coding, prioritize the following sequence:

  1. Data structures (vector, factor, data.frame)
  2. Missing data handling (NA, na.rm, complete.cases)
  3. Formula syntax for models
  4. Function writing for repeatable workflows

This sequence is sufficient to reproduce most analyses presented in this handbook with R.