Making use of external R code in knitr and R markdown

  • This post was updated with advanced tips (at the bottom) 2/12/2016

For scientific projects we often using knitr and R markdown in RStudio to share results and code either in HTML or PDF format. These are great tools for reproducible research. We find, however, that keeping all of our R code in an R markdown (.Rmd) file creates two problems. First, you need to completely re-run the report to evaluate new bits of R code and secondly the .Rmd file can become unwieldy very quickly. Fortunately, there is an easy way to make use of external code.

1. Create your external R script

You would create an R script as normal and, within the R script, you create ‘chunks’ using the ## @knitr syntax. So, in this example, we create a new R script entitled example.R with two chunks (variablesXY and plotXY) that looks like this:

# This is our external R script called example.R
# We're adding two chunks variablesXY and plotXY

## @knitr variablesXY

x<-1:100
y<-x+rnorm(100)
head(data.frame(x,y))

## @knitr plotXY

plot(x,y)

2. Create your R markdown script and refer to the external R script

Now you can create your R markdown (.Rmd) file. In order to read your external file you use the function read_chunk and then you can reference individual chunks using the <<chunkname>> syntax. So, continuing with our example, we can create a new file called myreport.Rmd, read the external file and reference/run the code chunks:

# read chunk (does not run code)
```{r echo=FALSE}
read_chunk('example.R')
```

# run the variablesXY chunk and use the variables it creates
```{r first}
<<variablesXY>>
head(data.frame(x,y))

```

# run the plotXY chunk and create the plot
```{r second}
<<plotXY>>
```

3. Alternative syntax

Although we usually use the syntax above which allows us to easily re-use chunks and flexibly name the R markdown chunks, there is an alternative syntax you can use. You can move all of the R code to the chunks in the external file and refer to those chunks in the R markdown chunk headers. For example, to produce exactly the same output as that above you can use the following for the example.R:

## @knitr variablesXY

x<-1:100
y<-x+rnorm(100)
head(data.frame(x,y))

## @knitr plotXY

plot(x,y)

And then the myreport.Rmd can be simplified to look like:

```{r echo=FALSE}
read_chunk('example.R')
```

```{r variablesXY}
```

```{r plotXY}
```

In either case, the output would look like this:

Capture

Advanced tips:

Run and show external code but leave off the comments

This was a tip provided by Bob Rudis. My external code often has comments that I don't want included in my final report but including code and excluding comments is tricky. To do this you add a couple of arguments to your code chunk, one is tidy=TRUE which tells R to tidy up the code (but leaves comments intact). The second is an argument to tidy.opts setting comment=FALSE. To a certain extent this is covered in Yihui's post on chunk options but the various setting available in tidy.opts are not spelled out there.

```{r, echo=TRUE,tidy=TRUE, tidy.opts=list(comment=FALSE)}
<<variablesXY>>
```

Run or show all code from an external script

I occasionally have a situation where I want to echo the code from a script but I don't want to run it. The simplest way to do this would be to copy and paste the code into a code chunk (and set eval=FALSE) but, of course, you would need to re-cut and paste if your code changes. An alternative to this, explained by Yihui at the bottom of this page, would be to use the code argument and readLines. So, as an example, to echo the code (but don't run it) from an external script called myscript.R in your Rmarkdown you can use:

```{r, code=readLines("myscript.R")}
```

Posted in R

8 responses

  1. Thank you and the Lord for being one of the few people using R who actually knows how to explain something with, gasp!!!!!, actual examples!!! Seriously, you are a rare human in the messed up world of R where creating confusion via the lack of basic communication skills seem the norm.

  2. Thanks for this, I wish I had found this 10 hours ago!

    Externalization seems like it should be at the top of the list but all the basic intros give at best a passing mention of it (and little in the way of how to do it).

    This is much appreciated!

  3. Thanks for sharing this! I clueless the ‘code’ argument existed. No more copying and pasting. I echo Michale’s comment about this area being an afterthought.

    Note, like in the example, the script name must be wrapped in double quotes. I default to using single quotes and the document wouldn’t compile.

    Thanks again!

  4. Hi, I am trying to replicate this example. But I get the following error when ever I try to read the chunk in the Rmarkdown file: Error: unexpected input in “<<" . Could you kindly advise on how I can correct this.

    • There are a number of reasons why this could be. You need to set up the external file properly and reference it properly. If you create a stackoverflow question with your reproducible code and send me the link I can take a look.

  5. Thank you so much!
    I have a question. If you have more than one plot in a script chunk, could you reference a specific plot in the markdown script?

Leave a Reply

Your email address will not be published. Required fields are marked *