Alternative to loops in R

for-loop, r

Solution

Using filters, you can do your computation even without any loop (and `sapply` is nothing more than a hidden loop).

absdif <- abs(V_s - V_b)
signal <- filter(absdif[1:L], rep(1/(n*V), n), sides=1)
signal[is.na(signal)] <- 0

Understanding what is happening in the second line is not trivial when your not used to filters, though. Let's have a closer look:

First we compute the absolute differences of `V_s` and `V_b`, which you loop uses frequently. Then comes the filter. Your computation is nothing more than summing up the the `n` past values at each time value `j`. Thus, we have something like

signal[j] <- sum(absdif[j-n+1:j])

That is exactly what convolution filters do - summing up some values - in the general form by multiplication with some weight. As weight we choose `1/(n*V)`, for all values, which corresponds to the normalization you do in your outer loop. The last argument, `sides=1` simply tells the filter to take values only from the past (`sides=2` would mean `sum(absdif[(j-n/2):(j+n/2)])`).

The last line just fills up the `NA` values at the beginning (where the filter does not have enough data to compute the sum - this equals to skipping the first `n` values).

Finally, some timing:

Your full-loop solution:

   User      System       total 
  0.037       0.000       0.037 

The solution of juba:

   User      System       total 
  0.007       0.000       0.008 

The solution using filters:

   User      System       total 
  0.000       0.000       0.001 

Note that the concept of filters is really well researched and can be done incredibly fast.

Edit: As noted in `?filter`, R does not use Fast fourier transform with the standard `filter` command. Usually, FFT is the most efficient way to implement convolutions. However, even this can be done by replacing the filter command with

signal <- convolve(absdif[1:L], rep(1/(n*V), n), type='filter')

Note that now the first `n` entries are stripped of instead of set to `NA`. The result is the same, however. Timing this time is of no use - the total time is below the three digit output of `system.time`... However, note the following remark in the R help of `filter`:

convolve(, type="filter") uses the FFT for computations and so may be faster for long filters on univariate series, but it does not return a time series (and so the time alignment is unclear), nor does it handle missing values. filter is faster for a filter of length 100 on a series of length 1000, for example

Problem

Original source

Related problems

• Speed up the loop operation in R
• Speed up the loop operation in R