# microbenchmark Package in R (2 Examples)

In this post, I’ll show how to use the microbenchmark package for comparing the performance of different algorithms in the R programming language.

The tutorial contains this information:

Let’s get started.

## Example Data & Packages

First, we have to install and load the microbenchmark package to R. Furthermore, we use the ggplot2 package for visualization.

```install.packages("microbenchmark") # Install & load microbenchmark library("microbenchmark")   install.packages("ggplot2") # Install & load ggplot2 library("ggplot2")```

## Example 1: Microbenchmark Options

With the microbenchmark package, we want to compare the efficiency of different approaches for calculating the sum of the squared values of a vector. We define two different functions for that.

Function f1 uses a loop.

```f1 <- function (x) { # Define function 1 out <- 0 for (i in 1:length(x)) { out <- out + x[i]^2 } out }```

Function f2 uses the ability of R to directly calculate the squared values of all elements of a vector.

```f2 <- function (x) { # Define function 2 sum(x^2) }```

Now, we create a vector x with 1000 randomly drawn values from a normal distribution (using rnorm) and use the microbenchmark function to compare the performance of f1 and f2. Microbenchmark executes both functions 100 (default value) times.

```set.seed(599) # Set seed for reproducible results x <- rnorm(10000) # Generate function input microbench_out <- microbenchmark(f1(x), f2(x)) # Benchmark function performance microbench_out # Unit: microseconds # expr min lq mean median uq max neval # f1(x) 3534.787 3597.6230 5170.40721 3655.4045 3965.551 29759.614 100 # f2(x) 18.733 20.4415 25.40898 26.5995 28.701 44.698 100```

The output presents the summary statistics of the microseconds of the 100 executions. You can see that f2 is much faster than f1.

Let us play around with the options of the microbenchmark package. This time, we change the number of iterations from default value 100 to 1000.

```microbench_out2 <- microbenchmark(f1(x), f2(x), # Benchmark performance with more iterations times = 1000) microbench_out2 # Unit: microseconds # expr min lq mean median uq max neval # f1(x) 3527.276 3593.3040 5097.13182 3662.7825 3869.8840 35090.25 1000 # f2(x) 17.855 19.9215 45.72353 24.8785 26.9695 21652.05 1000```

Compared to the first microbenchmark output, you see that neval now takes value 1000. You can also see that the summary statistics (especially the median, lower and upper quartile) did not change much.

We can visualize the computation time of the 1000 iterations using ggplot.

```ggplot(microbench_out2, aes(x = time/1000, y = expr, color = expr)) + # Plot performance comparison geom_violin() + geom_boxplot(width = 0.1) + scale_x_continuous(trans = 'log2')``` The output of the previous R syntax is shown in Figure 1 – you can see the distribution of the computation time per iteration and function.

Microbenchmark also comes with argument check. With it, you can make sure that the functions which you insert into microbenchmark actually return the same input (check = “equal”).

```microbench_out3 <- microbenchmark(f1(x), f2(x), # Benchmark and check whether input is equal check = "equal") microbench_out3 # Unit: microseconds # expr min lq mean median uq max neval # f1(x) 3529.605 3566.9810 4942.10765 3582.4990 3615.7735 29288.322 100 # f2(x) 18.190 20.0185 24.82022 25.7995 27.5905 42.896 100```

As you can see, when they return the same output, the function simply returns the typical microbenchmark output.

Now, we define x2 (which differs from x) and check again, with f1 calculated with x and f2 calculated with x2.

```x2 <- x # New input x2 x2 <- x + 1 microbenchmark(f1(x), f2(x2), # Benchmark and check whether input is equal check = "equal") # Error: Input expressions are not equivalent.```

As you can see, for that case, microbenchmark returns an error.

## Example 2: Loop vs. Apply

In this example, we calculate the row sums of the squared values of a matrix. This time, we want to see the performance of built-in function rowSums compared to two self-written functions.

We first define two self-written functions f3 and f4. f3 uses a loop, f4 the apply function.

```f3 <- function (X) { # Define function 3 out <- vector() for (i in 1:nrow(X)) { out[i] <- sum(X[i, ]^2) } out }```
```f4 <- function (X) { # Define function 4 apply(X, 1, function (y) { sum(y^2) }) }```

We create a matrix X with randomly drawn values from a normal distribution.

```set.seed(963) # Set seed for reproducible results #  TRUE X <- matrix(rnorm(400, 100), nrow = 400, ncol = 100) # Generate input matrix```

First, let us check that all three approaches return the same output using function all.equal().

```all.equal(f3(X), rowSums(X^2), f4(X), tolerance = 10^(-10)) # Check whether functions return same output # TRUE```

Let us check the performance.

```microbench_out4 <- microbenchmark(f3(X), # Benchmark performance of different functions rowSums(X^2), f4(X))   microbench_out4 # Unit: microseconds # expr min lq mean median uq max neval # f3(X) 1262.018 1294.3235 1778.5585 1307.0220 1320.4775 26950.455 100 # rowSums(X^2) 126.273 134.6435 139.0888 138.7045 141.5695 165.094 100 # f4(X) 1261.270 1284.6600 2160.9523 1296.8225 1313.6545 26949.950 100```

As you see, function rowSums is – by far – the most efficient among the presented approaches.

## Video & Further Resources

Some time ago, I have published a video on my YouTube channel, which demonstrates the R programming codes of this tutorial. You can find the video below.

In addition to the video, you may read the related tutorials on this website. Some tutorials that are related to the performance comparison can be found below:

This tutorial has illustrated how to use the microbenchmark package for comparing the computational performance of different commands in R. Don’t hesitate to let me know in the comments below, in case you have further questions.

This page was created in collaboration with Anna-Lena Wölwer. Have a look at Anna-Lena’s author page to get further instructions about her academic background and the other articles she has written for Statistics Globe.

Subscribe to the Statistics Globe Newsletter