R Language Creating Custom Functions Complete Guide

Complete Examples, Step by Step for Beginners: Creating Custom Functions in R

Introduction

Custom functions are an essential part of programming in R. They allow you to perform specific tasks repeatedly without having to rewrite code. By creating your own functions, you can make your code more organized, faster, and easier to read.

Step 1: Understand the Structure

The basic syntax for a custom function in R is:

function_name <- function(arguments) {
  # Function body
  # Perform operations using the arguments
  # Return a value (optional)
}

• function_name is the name you give to your function.
• arguments are the inputs your function will take.
• Function body contains the operations to be performed using the arguments.
• return is used to send back a value from the function to the caller. (optional, if the last line of the function is a value, it will be returned automatically.)

Step 2: Create a Simple Function

Let's start by creating a simple function that adds two numbers:

# Define the function
add_two_numbers <- function(a, b) {
  result <- a + b  # Perform addition
  return(result)   # Return the result
}

# Call the function
add_two_numbers(3, 4)  # Output: 7

Explanation:

• The function is named add_two_numbers.
• It takes two arguments, a and b.
• Inside the function, it calculates the sum of a and b and stores the result in the variable result.
• The function returns the result.
• When you call add_two_numbers(3, 4), you pass 3 and 4 to the function, which returns their sum, 7.

Step 3: Use Default Arguments

You can set default values for arguments in your function:

# Define the function with a default value for b
add_two_numbers_with_default <- function(a, b = 2) {
  result <- a + b
  return(result)
}

# Call the function with only one argument
add_two_numbers_with_default(5)  # Output: 7 (because 5 + 2)

Explanation:

• The function add_two_numbers_with_default has two arguments, a and b.
• If b is not provided, it defaults to 2.
• When add_two_numbers_with_default(5) is called, b defaults to 2, making the result 5 + 2 = 7.

Step 4: Return Multiple Values

You can return multiple values from a function using vectors or lists:

# Define a function that returns multiple values
get_stats <- function(numbers) {
  min_value <- min(numbers)
  max_value <- max(numbers)
  mean_value <- mean(numbers)
  return(list(min = min_value, max = max_value, mean = mean_value))
}

# Call the function with a vector
stats <- get_stats(c(1, 2, 3, 4, 5))
print(stats)

Explanation:

• The function get_stats takes a single argument numbers, which is expected to be a vector of numeric values.
• Inside the function, it calculates the minimum, maximum, and mean of the numbers.
• It returns these values as a list.
• When you call get_stats(c(1, 2, 3, 4, 5)), the function returns a list with the minimum, maximum, and mean values.

Step 5: Create a More Complex Function

Let's create a more complex function that performs a simple linear regression:

# Define a function to perform linear regression
simple_linear_regression <- function(x, y) {
  # Fit the linear model
  model <- lm(y ~ x)
  # Extract the coefficients
  coeffs <- coef(model)
  # Extract the summary statistics
  summary_stats <- summary(model)
  # Create a list with the model, coefficients, and summary
  return(list(model = model, coefficients = coeffs, summary = summary_stats))
}

# Prepare some sample data
x_data <- c(1, 2, 3, 4, 5)
y_data <- c(2, 4, 5, 4, 5)

# Call the function with the sample data
regression_result <- simple_linear_regression(x_data, y_data)

# Print the coefficients and summary
print(regression_result$coefficients)
print(regression_result$summary)

Explanation:

• The function simple_linear_regression takes two arguments, x and y, which are numeric vectors.
• The function fits a linear model using lm(y ~ x).
• It extracts the coefficients of the model and the summary statistics of the fit.
• It returns a list containing the model, coefficients, and summary.
• When you call simple_linear_regression(x_data, y_data), it performs the linear regression and returns the model, coefficients, and summary.
• You can access the coefficients and summary using $coefficients and $summary, respectively.

Step 6: Debugging and Error Handling

When creating functions, you might encounter errors. It is a good practice to include error handling to make your functions more robust:

# Define a function with error handling
safe_divide <- function(numerator, denominator) {
  # Check if the denominator is zero
  if (denominator == 0) {
    stop("Denominator cannot be zero.")
  }
  result <- numerator / denominator
  return(result)
}

# Test the function with a valid denominator
safe_divide(10, 2)  # Output: 5

# Test the function with a zero denominator
tryCatch(safe_divide(10, 0), error = function(e) {print(e$message)})  
# Output: [1] "Denominator cannot be zero."

Explanation:

• The function safe_divide takes two arguments, numerator and denominator.
• Before performing the division, it checks if the denominator is zero.
• If the denominator is zero, it stops the execution and returns an error message.
• When you call safe_divide(10, 2), it performs the division and returns the result.
• When you call safe_divide(10, 0), it stops execution and returns the error message "Denominator cannot be zero."
• The tryCatch function is used here to handle the error gracefully and print the message.

Summary

In this guide, you learned:

• How to create basic custom functions in R.
• How to use arguments and return values.
• How to set default values for arguments.
• How to handle multiple return values using vectors and lists.
• How to create more complex functions using built-in R functions.
• How to include error handling in your functions.

By mastering these concepts, you can write clear, efficient, and reusable code in R. Practice creating and using your own functions to solidify your understanding.