New `find_finite` function in Armadillo 3.5x slower than loop? - r

Question

the new find_finite and find_nonfinite functions in Armadillo 4.300 are great additions! In my tests using Rcpp, they are about 2.5x slower compared to a standard loop though. Below is some code for calculating the sum and mean with case-wise deletion corresponding to R's na.rm=TRUE option. The performance benchmarks from R show that the first version (sum_arma and mean_arma) is about 3.5x faster compared to the loop. I am doing everything correct? Any way to improve the performance?
C++ code
#include <numeric>
#include <RcppArmadillo.h>
// [[Rcpp::depends(RcppArmadillo)]]
// [[Rcpp::export]]
double sum_arma1(arma::mat& X) {
double sum = 0;
for (int i = 0; i < X.size(); ++i) {
if (arma::is_finite(X(i)))
sum += X(i);
}
return sum;
}
// [[Rcpp::export]]
double sum_arma2(arma::mat& X) {
return arma::sum(X.elem(arma::find_finite(X)));
}
// [[Rcpp::export]]
double mean_arma1(arma::mat& X) {
double sum = 0;
int n = 0;
for (int i = 0; i < X.size(); ++i) {
if (arma::is_finite(X(i))) {
sum += X(i);
n += 1;
}
}
return sum/n;
}
// [[Rcpp::export]]
double mean_arma2(arma::mat& X) {
return arma::mean(X.elem(arma::find_finite(X)));
}
Benchmark results from R
# data
X = matrix(rnorm(1e6),1000,1000)
X[sample(1:1000,100),sample(1:1000,100)] = NA
# equal?
all.equal(sum(X, na.rm=TRUE),sum_arma1(X))
all.equal(sum(X, na.rm=TRUE),sum_arma2(X))
all.equal(mean(X, na.rm=TRUE),mean_arma1(X))
all.equal(mean(X, na.rm=TRUE),mean_arma2(X))
# benchmark
benchmark(
sum(X, na.rm=TRUE),
sum_arma1(X),
sum_arma2(X),
replications=100)
# test replications elapsed relative user.self sys.self
# 2 sum_arma1(X) 100 0.259 1.000 0.259 0.001
# 3 sum_arma2(X) 100 1.035 3.996 0.750 0.293
# 1 sum(X, na.rm = TRUE) 100 0.491 1.896 0.492 0.003
benchmark(
mean(X, na.rm=TRUE),
mean_arma1(X),
mean_arma2(X),
replications=100)
# test replications elapsed relative user.self sys.self
# 2 mean_arma1(X) 100 0.252 1.00 0.253 0.001
# 3 mean_arma2(X) 100 0.819 3.25 0.620 0.206
# 1 mean(X, na.rm = TRUE) 100 7.440 29.52 7.120 0.373

Answer 1

The general functions find_finite() and find_nonfinite() will always be slower than specialised summation loops. find_finite() was not designed specifically for summation, but for the general case of, well, finding the indices of finite values. What you do with those indices is up to you, and you've chosen to use them as input to the .elem() function.
In the code arma::sum(X.elem(arma::find_finite(X))), the function find_finite() has to go through X, looking for finite values, and the store the resulting indices of the finite values in a temporary vector. The .elem() member function then looks at the vector generated by find_finite() and creates another vector which contains only finite values. In turn, the vector generated by .elem() is then used by sum().
C++ allows abstractions so that your code is quite compact, but sometimes you have to pay for such abstractions. General functions will always be slower than specialised loops.
However, for arithmetic functions such as addition, multiplication, etc, Armadillo will try to avoid the generation of temporary vectors/matrices, through the use of a smart delayed operations framework (based on template expressions) which queues up and combines several operations before executing them. This reduces the generation of temporaries.
The implementation of delayed operations is quite complex, which is why it's mainly done for the most important arithmetic functions. However, Armadillo has it in a few other cases as well, for example, find(X > 123) will avoid generating the temporary for X > 123.