A lot of programming tasks require you to repeat the same operation multiple times on each of a set of input items. In many programming languages, the most convenient way to accomplish this is to write a for loop. However, most R blogs online suggest to their readers that they “vectorize” their code whenever possible. For a really long time I did not know exactly what this meant. I was able to point to certain R functions as vectorized functions and use them appropriately, I did not know how to take advantage of vectorization when I was writing my own functions.
Vectorized functions will return a vector of the same length as the longest input to the function, usually recycling any input shorter than that value. These functions represent a specialized way of repeating the same operation on every item in a set of data.
However, even if a function repeats the same operation on a set of data and outputs a vector the same length as the input vector, it may not be truely vectorized. Truely vectorized functions do this repeating process outside of the R language, usually in the code that underlies R itself: C++. Performing this process outside of R (which is an interpreted language) in C++ (which is a compiled language) makes vectorized functions much faster than if an operation was repeated within R itself because it simplifies the work the computer has to do. The end effect for the user is that a vectorized function appears to produce the resulting vector all at once rather than item by item.
Vectorization is not super noticeable to most R users until you have repeat a complex process many times. This can be particularly valuable for simulations. Say you are a statistics professor who wants to create a demonstration of the central limit theorem. You might start by building a Monte Carlo simulation in which you pull multiple samples from a distribution for which you have defined the main parameters. In many programming language, you might accomplish this with a for loop using a strategy like that below:
Because the for loop is written in R itself, this implementation of the Monte Carlo simulation will be slow compared to what it could be. If we wanted to really speed it up, we would write a function that called on the code underlying R instead. Luckily, we don’t have to do that. R has a provided a way of hiding this for loop that allows the code to be implemented faster: the function lapply. This function is not true vectorization, but it does allow the user to run a function on a set of data many times much more quickly than an explicit for loop. One implementaion of this technique is below.
To truely optimize our code, we want to avoid using any for loops at all, meaning we also want to avoid using lapply. We won’t be vectorizing our code directly in that we won’t be writing anything in C++. Instead, we will be writing a function that takes advantage of multiple vectorized native R functions. This reduces the number of tasks that the computer has to do in the R program and speeds up execution.
For this example, I take advantage of the nature of random selection to cut out some of the steps inherent in the for loop approach. I use an id variable to mark what sample a particular value will be assigned to, generating as many id values as there are samples and repeating these values for the desired number of simluation trials using the vectorized rep function. I then draw a much larger sample using rnorm than I have in the prior examples, generating all values for all samples at once. Then I aggregate by sample as I have done before. The result is essentially equivalent to the above examples, but it is accomplished much more quickly.
I have one caveat about this approach. At work, I am limited to the processing power available on my assigned laptop. Unfortunately, generating the very large vectors necessary to implement the above approach can take a lot of memory, so in practice, I usually adopt a hybrid approach. I avoid for loops in the actual generation and calculation, but I break up the task into smaller vectors that my computer memory can handle, saving each chunck in a CSV file or database as I go. This way, I can take advantage of the speedier vectorized functions without freezing up the program by loading too much data into RAM.
I hope these examples are helpful. As always, I welcome your feedback and questions!