Tip of the Month: Reduce

Whether you are familiar with the concept of functional programming (FP) or not, you have probably came across the Reduce function in R at some point. In one context, we may think about FP as a way to execute a function over a vector or list simultaneously. Of course, one would argue why should I care about it? My quick answer is merging data.

Let’s consider two ETFs (SPY and XLF) and one stock (TSLA). The stock prices date back to June 2010, whereas the SPY (respectively XLF) prices date back to January 1993 (December 1998).

library(quantmod)
v <- c("SPY","XLF","TSLA")
P.list <- lapply(v, function(v_i) get(getSymbols(v_i, from = "1990-01-01")) )  
lapply(P.list, start)

[[1]]
[1] "1993-01-29"

[[2]]
[1] "1998-12-22"

[[3]]
[1] "2010-06-29"

If one is interested in the adjusted prices of all three underlying assets combined altogether, merging xts elements is straightforward:

P.list2 <- lapply(P.list, function(p) p[,6] ) # adjusted prices located in the sixth column
t1 <- system.time({
  P <- merge(merge(P.list2[[1]],P.list2[[2]]),P.list2[[3]])
  })
head(P)

           SPY.Adjusted XLF.Adjusted TSLA.Adjusted
1993-01-29     26.95485           NA            NA
1993-02-01     27.14656           NA            NA
1993-02-02     27.20405           NA            NA
1993-02-03     27.49164           NA            NA
1993-02-04     27.60668           NA            NA
1993-02-05     27.58747           NA            NA

Alternatively, one may consider running a loop:

t2 <- system.time({
  P2 <- P.list2[[1]]
  for(i in 2:length(P.list2)) {
    P2 <- merge(P2,P.list2[[i]])
  }
})
identical(P2,P)

[1] TRUE

In either case, we get an identical result. Nonetheless, the latter option is much slower, while the former is less tractable to implement - especially when the number of the underlying assets is large.

t2[3]/t1[3]

elapsed 
      5 

As we observe above, it takes the loop to 8 times longer than the first option. However, writing the code for P1 is not the best way to go. This is where the Reduce function comes into the picture:

t3 <- system.time(P3 <- Reduce(merge,P.list2))
identical(P3,P2)

[1] TRUE

As its first input, Reduce takes a specific function (in our case merge), whereas the second input takes a list (in our case list of adjusted prices). In terms of operations, the function executes the merging in the same fashion as in P1. First, Reduce takes the first two time series and merge them altogether. Second, it takes the combined result and merges it with the third time series. To see this, consider the following example

Reduce(`-`,1:3)

[1] -4

The Reduce(-,1:3) command is equivalent to the following

(1-2)-3

[1] -4

where the function applies the operator (-) on the first two (1-2= -1), and then run the operator on the result and the next element, i.e. (-1-3= -4).

Summary

Clearly, one can easily utilize the Reduce function to merge multiple time series rather than using a loop or doing so manually as discussed above. I would highly recommend this excellent vignette by Hadley Wickham for those interested in FP.