Lecture 03: R Functions

R Function

Jihong Zhang*, Ph.D

Educational Statistics and Research Methods (ESRM) Program*

University of Arkansas

2025-01-28

R Function

Prebuilt functions

  • Functions: Once we defined the objects, the data analysis process can usually be described as a series of functions applied to the data.

    • In other words, we considered “function” as a set of pre-specified operations (e.g., macro in SAS)

    • R includes several predefined functions and most of the analysis pipelines we construct make extensive use of these.

    • We already used or discussed the install.packages, library, and ls functions. We also used the function sqrt to solve the quadratic equation above.

  • Evaluation: In general, we need to use parentheses followed by a function name to evaluate a function.

    • If you type ls, the function is not evaluated and instead R shows you the code that defines the function. If you type ls() the function is evaluated and, as seen above, we see objects in the workspace.

  • Function Arguments: Unlike ls, most functions require one or more arguments to specify the settings of the function.

    • For example, we assign different object to the argument of the function log. Remember that we earlier defined coef_a to be 1:
log(8)
[1] 2.079442

Functions in R

Overview of Functions

  • Definition: Functions are blocks of code designed to perform specific tasks.
  • Purpose:
    • Automate repetitive tasks.
    • Increase code reusability and readability.
      • A good rule of thumb is to consider writing a function whenever you’ve copied and pasted a block of code more than twice
  • Key Characteristics:
    • Inputs (arguments) → Process → Output (return value).
    • Functions can contain other functions.

Benefits of Using Functions

  1. Code Reusability: Write once, use multiple times.
  2. Readability: Simplify complex code.
  3. Debugging: Isolate errors within specific functions.
  4. Scalability: Build modular, extensible codebases.

Factor Creation

Helpful function: Pipe

  • In R, a pipe is a powerful operator (“|>” or “%>%”) used to streamline the flow of data analysis.
    • A operator is a special function with the name as symbol and left/right hand sides as arguments.
1 + 2
`+`(1, 2)

  • It enables chaining multiple operations together in a readable, sequential manner.

  • Key idea: The pipe operator passes the output of one function as the first argument to the next function, eliminating the need for intermediate variables or nested function calls.

data |> function1() |> function2() |> function3()

This is equivalent to:

function3(function2(function1(data)))

Example: With vs. Without Pipe

Example: Without Pipe

# Without pipe
result <- filter(mtcars, mpg > 20)
result <- select(result, mpg, cyl)
result <- arrange(result, desc(mpg))

Example: With Pipe

# With pipe
mtcars |> 
  filter(mpg > 20) |> 
  select(mpg, cyl) |> 
  arrange(desc(mpg))
  • Which one you prefer?

Creating Custom Function

Example: Celsius to Fahrenheit Converter

celsius_to_fahrenheit <- function(temp_c) {
  temp_f <- (temp_c * 9/5) + 32
  return(temp_f)
}

celsius_to_fahrenheit(25)  # Output: 77
  • Converts a temperature from Celsius to Fahrenheit.
  • Input: temp_c (temperature in Celsius).
  • Output: temp_f (temperature in Fahrenheit).

Example: Standardization

  • Did you spot the mistake?
library(dplyr)
df <- tibble(
  a = rnorm(5),
  b = rnorm(5),
  c = rnorm(5),
  d = rnorm(5),
)
df
# A tibble: 5 × 4
       a       b      c       d
   <dbl>   <dbl>  <dbl>   <dbl>
1 -0.565 -0.0712 -0.980  0.0125
2 -1.11   0.634   1.26   0.405 
3  1.17  -1.16   -0.569  1.86  
4 -0.152  0.150   1.23   0.148 
5 -0.437  0.894   0.662 -0.912 
df |> mutate(
  a = (a - mean(a, na.rm = TRUE)) / sd(a),
  b = (b - mean(a, na.rm = TRUE)) / sd(b),
  c = (c - mean(c, na.rm = TRUE)) / sd(c),
  d = (d - mean(d, na.rm = TRUE)) / sd(d),
)
# A tibble: 5 × 4
        a       b      c      d
    <dbl>   <dbl>  <dbl>  <dbl>
1 -0.405  -0.0896 -1.25  -0.290
2 -1.05    0.797   0.904  0.101
3  1.63   -1.46   -0.857  1.55 
4  0.0797  0.189   0.877 -0.155
5 -0.255   1.12    0.330 -1.21
  • tibble creates a data frame with 4 columns
  • mutate creates new columns - generate standardized scores of all columns
  • Extract the “argument”:
    • The arguments are things that vary across calls and our analysis above tells us that we have just one. We’ll call it x because this is the conventional name for a numeric vector.
standardized <- function(x){
  (x - mean(x, na.rm = TRUE)) / sd(x)
}

df |> mutate(
  a = standardized(a),
  b = standardized(b),
  c = standardized(c),
  d = standardized(d)
)
# A tibble: 5 × 4
        a       b      c      d
    <dbl>   <dbl>  <dbl>  <dbl>
1 -0.405  -0.203  -1.25  -0.290
2 -1.05    0.684   0.904  0.101
3  1.63   -1.57   -0.857  1.55 
4  0.0797  0.0758  0.877 -0.155
5 -0.255   1.01    0.330 -1.21

Exercise: Rescale

  • Create a new function called rescale to simplify following code:
df |> mutate(
  a = (a - mean(a, na.rm = TRUE)) / (max(a) - min(a)),
  b = (b - mean(b, na.rm = TRUE)) / (max(b) - min(b)),
  c = (c - mean(c, na.rm = TRUE)) / (max(c) - min(c)),
  d = (d - mean(d, na.rm = TRUE)) / (max(d) - min(d)),
)
# A tibble: 5 × 4
        a       b      c       d
    <dbl>   <dbl>  <dbl>   <dbl>
1 -0.151  -0.0785 -0.581 -0.105 
2 -0.392   0.265   0.419  0.0365
3  0.608  -0.608  -0.397  0.562 
4  0.0297  0.0294  0.406 -0.0560
5 -0.0953  0.392   0.153 -0.438
  • The basic skeleton of function is like this:
name <- function(arguments) {
  body
}

  • A name. Here we’ll use ‘rescale’ because this function rescales a vector to lie between 0 and 1.

  • The body. The body is the code that’s repeated across all the calls.

Anatomy of a Function

Example Code for one function

function_name <- function(argument1, argument2 = default_value) {
  # Body of the function
  result <- argument1 + argument2
  return(result)
}
  • Components:
    • function_name: Name of the function.
    • arguments: Inputs provided to the function.
    • body: Code block that performs the computation.
    • return(): Specifies the output of the function.

Arguments in Functions

Default Arguments

  • Assign default values to arguments to make them optional.
greet <- function(name = "World") {
  return(paste("Hello,", name))
}

greet()            # Output: "Hello, World"
greet("R User")    # Output: "Hello, R User"

Flexible Arguments

  • ...: Allow a function to accept a variable number of arguments.
sum_numbers <- function(...) {
  numbers <- c(...) # combine into a vector
  return(sum(numbers))
}

sum_numbers(1, 2, 3, 4)  # Output: 10
[1] 10
  • Look at the help page of mean, tell me why we can have y argument in mean function
mean(x = c(1, 2, 3), y = 3)
[1] 2
  • Flexible argument can be useful when you do not know users want to use which argument
mean(y = 3, x = 8, z = 9, one_vector = c(7, TRUE))
[1] 8
(3 + 8 + 9 + 7 + 1 ) / 5 # what we expect
[1] 5.6
flexible_mean <- function(...){
  return(mean(x = c(...)))
}
flexible_mean(y = 3, x = 8, z = 9, one_vector = c(7, TRUE))
[1] 5.6
  • Question: test the sum function, tell me why sum can accept flexible arguments.
sum(y = 3, x = 8, z = 9, one_vector = c(7, TRUE))

Returning Values

  • Functions return the last evaluated expression by default.
  • Use return() for clarity.

Example: Summing Two Numbers

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

add(10, 5)  # Output: 15
[1] 15

Nested Functions

  • Functions can call other functions.

Example: Calculating BMI

bmi <- function(weight, height) {
  return(weight / (height^2))
}

bmi(70, 1.75)  # Output: 22.86
  • Combines mathematical operations into a single function.

Function Scope

  • Local Scope: Variables defined inside a function are local to that function.
x = 5
print_x <- function(x) {x = 3; return(x)}
x
  • Global Scope: Variables defined outside a function are accessible throughout the script.

Example: Local Scope

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

add(2, 3)   # Output: 5
result      # Error: object 'result' not found
add <- function(x, y) {
  result <<- x + y
  return(result)
}
add(2, 3)   # Output: 5
result

Exercise 03

  • Create a blank Quarto document
  • Finish Exercise 03: R Function in the Quarto

Summary

  • Functions are the cornerstone of programming in R.
  • They encapsulate reusable logic, making code efficient and modular.
  • Key concepts include arguments, return values, and scope.
  • Practice writing functions to automate tasks and solve complex problems.

ESRM 64503 - Lecture 03: Object/Function/Package

1 / 21
Lecture 03: R Functions R Function Jihong Zhang*, Ph.D Educational Statistics and Research Methods (ESRM) Program* University of Arkansas 2025-01-28

  1. Slides

  2. Tools

  3. Close
  • Lecture 03: R Functions
  • R Function
  • Prebuilt functions
  • Functions in R
  • Benefits of Using Functions
  • Factor Creation
  • Helpful function: Pipe
  • Example: With vs. Without Pipe
  • Creating Custom Function
  • Example: Standardization
  • Extract the “argument”:...
  • Exercise: Rescale
  • Anatomy of a Function
  • Arguments in Functions
  • Flexible argument...
  • Returning Values
  • Nested Functions
  • Function Scope
  • Example: Local Scope
  • Exercise 03
  • Summary
  • f Fullscreen
  • s Speaker View
  • o Slide Overview
  • e PDF Export Mode
  • r Scroll View Mode
  • b Toggle Chalkboard
  • c Toggle Notes Canvas
  • d Download Drawings
  • ? Keyboard Help