Eric Campbell 5 min read Statistics

How to Calculate the Mode in R

If you've ever tried to calculate the mode in R and typed `mode(my_data)`, you've encountered one of R's more confusing naming decisions. Instead of returning the most frequent value, you got...

Key Insights

  • R’s built-in mode() function returns the data type, not the statistical mode—you need a custom function or package to find the most frequent value
  • A simple mode function using table() and which.max() handles most cases, but you’ll need enhanced logic for multimodal data
  • The modeest and DescTools packages provide production-ready mode functions that handle edge cases automatically

If you’ve ever tried to calculate the mode in R and typed mode(my_data), you’ve encountered one of R’s more confusing naming decisions. Instead of returning the most frequent value, you got something like "numeric" or "character". That’s because R’s mode() function returns the storage mode of an object—its internal data type—not the statistical mode.

Unlike mean() and median(), R doesn’t include a built-in function for calculating the statistical mode. This omission makes sense when you consider that mode is less universally applicable than other measures of central tendency, and it has complications like multimodal distributions. But it does mean you need to roll your own solution or reach for a package.

Creating a Custom Mode Function

The most straightforward approach is building your own mode function. The logic is simple: count how often each value appears, then return the value with the highest count.

get_mode <- function(x) {
  frequency_table <- table(x)
  mode_value <- names(frequency_table)[which.max(frequency_table)]
  return(mode_value)
}

Let’s break down what’s happening here. The table() function creates a frequency table of your data, counting occurrences of each unique value. The which.max() function returns the index of the maximum value in that table. We then extract the name at that index, which represents our mode.

Here’s the function in action:

# Numeric vector
test_numbers <- c(1, 2, 2, 3, 3, 3, 4, 5)
get_mode(test_numbers)
# [1] "3"

# Character vector
test_colors <- c("red", "blue", "blue", "green", "blue", "red")
get_mode(test_colors)
# [1] "blue"

One issue with this basic implementation: it returns a character string, even for numeric data. If you need the result as the original type, add a conversion step:

get_mode_typed <- function(x) {
  frequency_table <- table(x)
  mode_value <- names(frequency_table)[which.max(frequency_table)]
  
  if (is.numeric(x)) {
    return(as.numeric(mode_value))
  }
  return(mode_value)
}

get_mode_typed(c(1, 2, 2, 3, 3, 3))
# [1] 3

Handling Edge Cases

The basic function works for simple cases, but real data is messier. What happens when multiple values share the highest frequency? Or when every value appears exactly once?

The which.max() function only returns the first maximum it finds. If your data is bimodal or multimodal, you’ll miss the other modes:

bimodal_data <- c(1, 1, 1, 2, 2, 2, 3, 4)
get_mode(bimodal_data)
# [1] "1"  # Misses that 2 is also a mode

Here’s an enhanced function that handles these edge cases:

get_modes <- function(x, na.rm = TRUE) {
  if (na.rm) {
    x <- x[!is.na(x)]
  }
  
  if (length(x) == 0) {
    return(NA)
  }
  
  frequency_table <- table(x)
  max_frequency <- max(frequency_table)
  
  # If all values appear only once, there's no mode
  if (max_frequency == 1) {
    return(NA)
  }
  
  # Return all values with the maximum frequency
  mode_values <- names(frequency_table)[frequency_table == max_frequency]
  
  # Convert back to numeric if input was numeric
  if (is.numeric(x)) {
    mode_values <- as.numeric(mode_values)
  }
  
  return(mode_values)
}

Now the function handles multiple scenarios:

# Bimodal data
get_modes(c(1, 1, 1, 2, 2, 2, 3, 4))
# [1] 1 2

# Trimodal data
get_modes(c("a", "a", "b", "b", "c", "c", "d"))
# [1] "a" "b" "c"

# No repeated values (no mode)
get_modes(c(1, 2, 3, 4, 5))
# [1] NA

# Handles NA values
get_modes(c(1, 1, 2, NA, NA, NA))
# [1] 1

The decision to return NA when all values are unique is opinionated. Some statisticians argue every value is a mode in this case. Adjust the logic based on your needs.

Using Packages for Mode Calculation

Writing custom functions is educational, but for production code, established packages offer tested, optimized solutions. Two packages stand out for mode calculation: modeest and DescTools.

The modeest package specializes in mode estimation and provides multiple methods:

install.packages("modeest")
library(modeest)

sample_data <- c(2, 3, 3, 4, 4, 4, 5, 5, 6)

# mfv() returns the most frequent value(s)
mfv(sample_data)
# [1] 4

# For multimodal data, it returns all modes
mfv(c(1, 1, 2, 2, 3))
# [1] 1 2

The mfv() function (most frequent value) is what you want for discrete data. The package also includes mlv() for continuous data, which estimates the mode using various statistical methods—useful when you’re working with distributions rather than discrete counts.

The DescTools package takes a different approach with its Mode() function:

install.packages("DescTools")
library(DescTools)

Mode(c(1, 2, 2, 3, 3, 3, 4))
# [1] 3

# Returns all modes with frequency attribute
Mode(c(1, 1, 2, 2, 3))
# [1] 1 2
# attr(,"freq")
# [1] 2

The DescTools::Mode() function includes a frequency attribute, which can be useful for understanding your data. It also integrates well with the package’s other descriptive statistics functions.

Choose modeest if you need advanced mode estimation for continuous distributions. Choose DescTools if you want a comprehensive descriptive statistics toolkit. Use a custom function if you want to avoid dependencies or need specific behavior.

Mode for Different Data Types

Mode works across all data types in R, making it more versatile than mean or median (which only apply to numeric data). Here’s how to handle different types:

# Numeric vectors
numeric_data <- c(10, 20, 20, 30, 30, 30, 40)
get_modes(numeric_data)
# [1] 30

# Character vectors
survey_responses <- c("Agree", "Disagree", "Agree", "Neutral", 
                      "Agree", "Disagree", "Agree")
get_modes(survey_responses)
# [1] "Agree"

# Factors
satisfaction <- factor(c("Low", "Medium", "High", "Medium", "Medium", "Low"),
                       levels = c("Low", "Medium", "High"))
get_modes(satisfaction)
# [1] "Medium"

For factors, the mode function returns the character representation. If you need the factor level back:

mode_result <- get_modes(satisfaction)
factor(mode_result, levels = levels(satisfaction))
# [1] Medium
# Levels: Low Medium High

Categorical data analysis relies heavily on mode. When analyzing survey data, customer segments, or any classification problem, mode tells you the most common category—often more meaningful than trying to compute a mean.

Practical Application

Let’s apply these concepts to a real dataset. We’ll analyze the mtcars dataset to find the most common cylinder configuration:

# Using our custom function
get_modes(mtcars$cyl)
# [1] 8

# Verify with table
table(mtcars$cyl)
#  4  6  8 
# 11  7 14

Eight-cylinder engines are the most common in this dataset. Now let’s build a function that calculates mode for multiple columns in a data frame:

get_column_modes <- function(df, columns = NULL) {
  if (is.null(columns)) {
    columns <- names(df)
  }
  
  results <- sapply(columns, function(col) {
    modes <- get_modes(df[[col]])
    if (length(modes) > 1) {
      paste(modes, collapse = ", ")
    } else {
      as.character(modes)
    }
  })
  
  return(data.frame(column = names(results), mode = unname(results)))
}

# Apply to mtcars
get_column_modes(mtcars, c("cyl", "gear", "carb"))
#   column mode
# 1    cyl    8
# 2   gear    3
# 3   carb 2, 4

The carburetor column is bimodal—both 2 and 4 carburetors appear with equal frequency (10 times each). This kind of insight gets lost if you only look at means.

For a more complete analysis workflow:

library(dplyr)

# Summarize categorical columns with mode and frequency
mtcars %>%
  summarise(
    mode_cyl = get_modes(cyl)[1],
    mode_cyl_count = max(table(cyl)),
    mode_gear = get_modes(gear)[1],
    mode_gear_count = max(table(gear))
  )
#   mode_cyl mode_cyl_count mode_gear mode_gear_count
# 1        8             14         3              15

Conclusion

Calculating the mode in R requires a bit more work than mean or median, but the implementations are straightforward. For quick analyses, a custom function using table() and which.max() handles most cases. When you need to handle multimodal data or want battle-tested code, reach for modeest::mfv() or DescTools::Mode().

Use custom functions when you want zero dependencies and full control over edge case behavior. Use packages when you need reliability, additional features like continuous mode estimation, or when you’re already using that package’s ecosystem.

The mode might be the forgotten sibling of central tendency measures, but for categorical data and discrete distributions, it’s often the most meaningful summary statistic you can report.

Liked this? There's more.

Every week: one practical technique, explained simply, with code you can use immediately.

Similar Articles