Dear R enthusiasts,

Welcome to the first Tutorial I publish on CodeHub! Tutorials are a new format where I will share tips to get the most out of R, and to improve coding skills.

In this first Tutorial, I would like to share an elegant solution to plot mathematical functions with ggplot2.

A simple function

Let’s begin with a simple function: a logarithm.

f \left( x \right) = \ln x

We want to produce the following plot.

Often, when I read tutorials to plot functions with ggplot2, they do the following:

1. Generate a data frame from the function
2. Plot the data frame

I find this method cumbersome, especially if we want to edit the function as we need to regenerate the data frame. More steps mean a higher chance to introduce bugs and errors. It is also not particularly elegant. What I want is to plot the function by specifying it symbolically, i.e., without generating an intermediary data frame. This is possible thanks to geom_function().

geom_function() takes at least one argument: fun. To plot a logarithm, we can use the built-in log() function.

geom_function(
    fun = log
)
Code language: R (r)

The following code produces Figure 1:

ggplot() +
    geom_function(
        fun = log
    ) +
    scale_x_continuous(
        limits = c(0, 1000)
    ) +
    scale_y_continuous(
        limits = c(0, 10)
    ) +
    labs(
        x = "x",
        y = "y"
    )
Code language: R (r)

I use scale_continuous() and limits to specify the limits of the axes.

So far, so good. But what if we want to plot a more complicated function? What if we want to have a lot more control over the function we plot?

A more complicated function

Let’s say we want to plot a logistic function.

The general equation of a logistic function is the following:

f \left( x \right) = \frac{L}{1 + e^{- k \left( x + x_0\right)}}

• L is the supremum, i.e., the maximum value the curve reaches on the plot
• k is the growth rate, i.e., the steepness of the curve
• x_0 is the midpoint

Similar to log(), R has a built-in function to work with logistic functions. But let’s say we want to specify all parameters ourselves. Or we want to use a modified form of a sigmoid function. Used in conjunction with geom_function(), as_function() makes all this possible.

With as_function(), we can manually specify the mathematical function we want to plot. With as_function(), we have complete control.

The following code produces Figure 2, with L = 1 , k = 1.5 and x_0 = 6 .

library(rlang)

supremum <- 1
growth_rate <- 1.5
midpoint <- 6

ggplot() +
    geom_function(
        fun = as_function(
            ~ (supremum)
                /
                (1 + exp(-1 * growth_rate * (.x - midpoint)))
                )
    ) +
    scale_x_continuous(
        limits = c(0, midpoint * 2)
    ) +
    scale_y_continuous(
        limits = c(0, 1)
    ) +
    labs(
        x = "x",
        y = "y"
    )
Code language: R (r)

Let’s break down the code.

First, we need to load rlang to use as_function(). If you use the Tidyverse, rlang should already be installed. If you do not use the Tidyverse, you probably need to install it.

Second, I defined three variables that store the values of the parameters. I could have hard coded the values directly in as_function(). But defining variables makes the code easier to read. It also makes easier to change the value of the parameters. A clearer and simpler code is a code that is less prone to bugs and errors.

Third, the rest. It looks a lot like the code we wrote to plot the logarithm, but with some differences.

fun now calls as_function(). The syntax of as_function() is the following:

as_function(~ .x)
Code language: R (r)

~ tells as_function() what is on the right-hand side of the equation. .x is basically a computational representation of the mathematical x .

Fun fact: if you use as_function(~ .x), it plots a linear function (try it!).

One important thing to note: inside as_function(), you need to explicitly write * everywhere there is a multiplication. R, or at least as_function(), is not able to infer multiplication. Without writing *, R interprets var() as a call to a function named var. With var * (), R knows that we want to multiply the numerical value stored in the variable named var with what is inside the parentheses.

Wrapping up

So here it is! You know how to plot any arbitrary function with ggplot2.

If you enjoyed this Tutorial, please share it on social media and in your network. To not miss my future Tutorials on R and coding, you can also subscribe to CodeHub’s newsletter below — or here.

Olivier