In this post, I will talk about the ifelse function, which behaviour can be easily misunderstood, as pointed out in my latest question on SO. I will try to show how it can be used, and misued. We will also check if it is as fast as we could expect from a vectorized base function of R.

## How can it be used?

The first example comes directly from the R documentation:

```x <- c(6:-4)
sqrt(x)  #- gives warning
## Warning in sqrt(x): NaNs produced
##   2.449490 2.236068 2.000000 1.732051 1.414214 1.000000 0.000000      NaN      NaN
##       NaN      NaN
sqrt(ifelse(x >= 0, x, NA))  # no warning
##   2.449490 2.236068 2.000000 1.732051 1.414214 1.000000 0.000000       NA       NA
##        NA       NA```

So, it can be used, for instance, to handle special cases, in a vectorized, succinct way.

The second example comes from the vignette of Rcpp Sugar:

```foo <- function(x, y) {
ifelse(x < y, x*x, -(y*y))
}
foo(1:5, 5:1)
##   1  4 -9 -4 -1```

So, it can be used to construct a vector, by doing an element-wise comparison of two vectors, and specifying a custom output for each comparison.

A last example, just for the pleasure:

```(a <- matrix(1:9, 3, 3))
##      [,1] [,2] [,3]
## [1,]    1    4    7
## [2,]    2    5    8
## [3,]    3    6    9
ifelse(a %% 2 == 0, a, 0)
##      [,1] [,2] [,3]
## [1,]    0    4    0
## [2,]    2    0    8
## [3,]    0    6    0```

## How can it be misused?

I think many people think they can use `ifelse` as a shorter way of writing an `if-then-else` statement (this is a mistake I made). For example, I use:

```legend.pos <- ifelse(is.top, ifelse(is.right, "topright", "topleft"),
ifelse(is.right, "bottomright", "bottomleft"))```

```if (is.top) {
if (is.right) {
legend.pos <- "topright"
} else {
legend.pos <- "topleft"
}
} else {
if (is.right) {
legend.pos <- "bottomright"
} else {
legend.pos <- "bottomleft"
}
}```

That works, but this doesn’t:

```ifelse(FALSE, 0, 1:5)
##  1```

Indeed, if you read carefully the R documentation, you see that `ifelse` is returning a vector of the same length and attributes as the condition (here, of length 1).

If you really want to use a more succinct notation, you could use

````if`(FALSE, 0, 1:5)
##  1 2 3 4 5```

If you’re not familiar with this notation, I suggest you read the chapter about functions in book Advanced R.

## Benchmarks

### Reimplementing ‘abs’

```abs2 <- function(x) {
ifelse(x < 0, -x, x)
}
abs2(-5:5)
##   5 4 3 2 1 0 1 2 3 4 5
library(microbenchmark)
x <- rnorm(1e4)

print(microbenchmark(
abs(x),
abs2(x)
))
## Unit: microseconds
##     expr     min       lq       mean   median      uq       max neval
##   abs(x)   3.973   5.2975   36.19779   6.9530   9.271  1613.386   100
##  abs2(x) 496.299 523.9450 1595.51016 549.7695 634.859 80076.957   100```

### Comparing with C++

Consider the Rcpp Sugar example again, 4 means to compute it:

```#include <Rcpp.h>
using namespace Rcpp;

// [[Rcpp::export]]
NumericVector fooRcpp(const NumericVector& x, const NumericVector& y) {
int n = x.size();
NumericVector res(n);
double x_, y_;
for (int i = 0; i < n; i++) {
x_ = x[i];
y_ = y[i];
if (x_ < y_) {
res[i] = x_*x_;
} else {
res[i] = -(y_*y_);
}
}
return res;
}
fooRcpp(1:5, 5:1)
##   1  4 -9 -4 -1
#include <Rcpp.h>
using namespace Rcpp;

// [[Rcpp::export]]
NumericVector fooRcppSugar(const NumericVector& x,
const NumericVector& y) {
return ifelse(x < y, x*x, -(y*y));
}
fooRcppSugar(1:5, 5:1)
##   1  4 -9 -4 -1
foo2 <- function(x, y) {
cond <- (x < y)
cond * x^2 - (1 - cond) * y^2
}
foo2(1:5, 5:1)
##   1  4 -9 -4 -1
x <- rnorm(1e4)
y <- rnorm(1e4)
print(microbenchmark(
foo(x, y),
foo2(x, y),
fooRcpp(x, y),
fooRcppSugar(x, y)
))
## Unit: microseconds
##                expr     min       lq      mean  median       uq      max neval
##           foo(x, y) 510.535 542.6510 872.23474 563.510 716.9680 2439.447   100
##          foo2(x, y)  71.183  75.1560 147.17468  83.765  93.8635 1977.250   100
##       fooRcpp(x, y)  40.393  44.6970  63.59186  47.676  51.1535 1468.038   100
##  fooRcppSugar(x, y) 138.394 141.3745 179.16429 142.533 161.4045 1575.972   100```

Even if it is a vectorized base R function, `ifelse` is known to be slow.

## Conclusion

Beware when you use the `ifelse` function. Moreover, if you make a substantial number of calls to it, be aware that it isn’t very fast, but it exists at least 3 faster alternatives to it.