Daniel J. McGlinn

R is great for many aspects of statistical analysis but it is often criticized for running iterative programs (e.g., for loops) slowly.  There are many new packages that are attempting to rectify this by allowing the user to 1) use multiple processing cores (see Todd Jobe’s Blog for an example), and 2) by calling compiled code within R (the purpose of this post).  Both solutions can take time to implement but are often worth the development time as they can really pay off in the long run.  I have found that solution #1 usually is best if there are a few iterations that each take several seconds to process and solution #2 is usually best if there are many thousands of iterations over a very trivial calculation.

There is actually a decent amount on the web about how to format  your syntax in R and C to make things work out well (see this page for example); however, almost all of the instructions and tutorials out there assume that you are able to compile your C code yourself.  If you’re like me an you use a PC that runs Windows you may not be very familiar with compiling your own code. This is where I can lend some instruction based upon my own experiences.

Tutorial Outline:
1) Getting Windows ready to go
2) Writing the C code
3) Compiling the C code
4) Loading and calling C code in R

1) Getting Windows ready to go:

First you are going to have to install some tools that will allow you to build R packages and compile C code from the command line (R installation and Administration – Appendix D).

Luckily all of the tools you will need have been bundled together for you as Rtools.exe which can be downloaded from any CRAN mirror (e.g., http://cran.cs.wwu.edu/bin/windows/Rtools)

Once you have downloaded and installed those tools, you will need to change the PATH of your environment variables. I think this is necessary so that the R tools you just installed can be called from the command line or DOS prompt. Here is a link that describes three different ways to perform this: R FAQ: 2.15. We need to redefine the path such it that includes (see R installation and Administration – Appendix D):

PATH=c:\Rtools\bin;c:\Rtools\gcc-4.6.3\bin;c:\R-2.15.1\bin\i386;<others>

Note that there may be a way when installing R tools to have this path changed for you automatically, although I found that I had to perform this task manually.  Here I will describe in detail how to do this because information is scant on the web on this topic.  As noted above there are three ways to change the PATH of your environment variables, here I will describe the third method (quoted directly from R FAQ: 2.15):

“For all applications via Windows. How you set an environment variable is system specific: under Windows 2000/XP/2003 you can use `System’ in the control panel or the properties of `My Computer’ (under the `Advanced’ tab). Under Vista, go to `User Accounts’ in the Control Panel, and select your account and then `Change my environment variables’.”

Once you are in the change environment variable box, select “New”. Name the new variable “PATH” and then set the value to (at a minimum):

PATH=c:\Rtools\bin;c:\Rtools\gcc-4.6.3\bin;c:\R\R-2.15\bin\i386;

Note that above c:\R\R-2.15\bin\i386 should be tailored to your specific path directory of R that you downloaded the Rtools for. Then click “OK” twice and your environment variables should now be set and you should be ready to compile some C code via the command line with R.

After performing these steps be sure to restart your machine.

2) Writing the C code:

Before we compile our C code we need to generate some sample code or lift some from the web. Here are two example functions written in C that you can copy and paste into a text file you name “sequence_examples.c” (exactly what you name it does not matter).

3) Compiling the C code:

Once you have R ready to go and your bit of C code you’ll need to compile it into a .dll file that can be dynamically loaded into R.  To compile the .C file you must open the Windows Command Prompt.  This is a program that allows you to write DOS code straight into the computer’s innards (for lack of a better word).  Once the Command Prompt is open you’ll have to direct it towards the folder that contains the .C file you wish to compile. For example if my file was on my desktop, I would enter the following into the command prompt:

The cd in the above statement stands for change directory.  Now all you have to do is send the compile command to the Command Prompt with your file name. For example if I wanted to compile the file sequence_example.c I would send the following command to the Command Prompt

If no errors occur (error statement will appear in the Command Prompt, they are actually usually fairly informative) then two files should be produced: sequence_examples.o and sequence_examples.dll.  The file sequence_examples.dll is the only one you will need to link in with R.

4) Loading and calling C code in R

Now that our C code is compiled we are ready to bring it into the R environment like so:

These R commands should return lists that contain the input to the C function and the resulting output. Because we are only usually interested in the output it is a good idea to be more specific about what portion of the list you would like returned.

That’s all there is to it. To make this cleaner next I would place my call to the .C function in an R wrapper function that handles the passing of my R variables to the C functions for me.

Please leave feedback or suggestions below. Good luck!