How to Have Conditional Markdown Chunk Execution in Rmarkdown

Is there a way to have conditional markdown chunk execution in Rmarkdown?

Instead of using cat to print the solution from within an R code chunk, you could write the solution as you usually would in rmarkdown (i.e., with the usual combination of text, latex, and R code chunks), and use the parameter soln to comment out that section when you don't want to include the solution in the final document.

In the sample rmarkdown document below, if the parameter soln is FALSE, then the line r if(!params$soln) {"\\begin{comment}"} inserts \begin{comment} to comment out the solution (with matching code at the end to insert \end{comment}). I've also indented everything with two tabs, so that the question numbers are formatted with a hanging-indent. (If you like this format, you don't have to type the double-tab for each new paragraph or chunk. If you do this for one line, then each subsequent time you press the Enter key, the new line will automatically be formatted with the double-tab. Or, just type in all your text and code for a given question, then when you're done, highlight all of it and type tab twice.)

---
title: "Homework"
output: word_document
header-includes:
  - \usepackage{comment}
params:
  soln: TRUE
---

1. Fit the linear regression model $Y \sim X$ with the following data. Interpret the coefficient estimates.

    ```{r promptchunk, echo = TRUE}
    set.seed(123)
    X <- c(1, 1, 0, 0)
    Y <- rnorm(4)
    ```

`r if(!params$soln) {"\\begin{comment}"}`

    **Solution:**

    Run the following R code to fit the linear regression model:
    ```{r, include = params$soln, echo = TRUE, results = "asis"}
    fit1 = lm(Y ~ X)
    ```

    To see a summary of the regression results, run the following code and review the output: 

    ```{r, include = params$soln, echo=TRUE}
    summary(fit1)
    ```
    The interpretation of the intercept is.... 

    Our estimate $\hat{\beta}_0$ is `r round(coef(fit1)[1], 2)`.

    The estimated X coefficient $\hat{\beta}_1$ is `r round(coef(fit1)[2], 2)`. 

    This can be interpreted as....

`r if(!params$soln) {"\\end{comment}"}`

Also, instead of knitting the file above interactively, you can render both versions by running the render function in a separate R script. For example, assuming the file above is called hw.Rmd, open a separate R script file and run the following:

for (i in c(TRUE, FALSE)) {
  rmarkdown::render("hw.Rmd", 
                    params = list(soln = i),
                    output_file=ifelse(i, "Solutions.doc", "Homework.doc"))
}

Below is what Solutions.doc looks like. Homework.doc is similar, except everything from the bold word Solution: onward is excluded:

Conditionally display a block of text in R Markdown

You need a complete R expression, so you cannot break it into multiple blocks like you show, but if the results of a block are a text string then it will be included as is (without quotes), so you should be able to do something like:

`r if(show.text){"la la la"}`

and it will include the text if and only if show.text is TRUE.

Conditional `echo` (or eval or include) in rmarkdown chunks

knitr options can be stated as R expressions. Per the "output" documentation on the knitr webpage:

Note all options in knitr can take values from R expressions, which brings the feature of conditional evaluation introduced in the main manual. In short, eval=dothis means the real value of eval is taken from a variable named dothis in the global environment; by manipulating this variable, we can turn on/off the evaluation of a batch of chunks.

In other words if you write some chunks like:

```{r label}
doNextChunk <- as.logical(rbinom(1,1,.5))
```

```{r conditional, eval = doNextChunk}
"hello world!"
```

How to not execute certain Rmarkdown chunks based on a parameter?

One of the knitr chunk options is eval=, which controls whether a chunk is evaluated. From that page:

• eval: (TRUE; logical) whether to evaluate the code chunk; it can also be a numeric vector to select which R expression(s) to evaluate, e.g. eval=c(1, 3, 4) or eval=-(4:5).

One benefit of this is that it can use R variables in real-time, either generated within a previous chunk (eval=limit) or passed to a parameterized R-markdown document (as eval=params$limit).

Depending on your global options, you might always want/need to suppress printing the chunk, you can add echo=params$limit as well.

Conditionally display block of markdown text using knitr

You could use the asis engine to conditionally include/exclude arbitrary text in knitr, e.g.

```{asis, echo=FALSE}
Some arbitrary text.

1. item
2. item

Change echo=TRUE or FALSE to display/hide this chunk.
```

But I just discovered a bug in this engine and fixed it. Unless you use knitr >= 1.11.6, you can create a simple asis engine by yourself, e.g.

```{r setup, include=FALSE}
library(knitr)
knit_engines$set(asis = function(options) {
  if (options$echo && options$eval) paste(options$code, collapse = '\n')
})
```

If you want to include inline R expressions in the text, you will have to knit the text, e.g.

```{r setup, include=FALSE}
library(knitr)
knit_engines$set(asis = function(options) {
  if (options$echo && options$eval) knit_child(text = options$code)
})
```

Is there a way to get progress information whan a chunk is running in Rmarkdown?

Turns out there is a package dedicated to exactly this: knitrProgressBar

A minimal example usage based on the package documentation:

library(knitrProgressBar)

slow_function <- function(i, .pb=NULL) {  
  update_progress(.pb)  
  Sys.sleep(0.5)  
  i  
}

# create an R6 progress object for
# the number of loops/iterations in the target chunk

n_iterations <- 20
pb <- progress_estimated(n_iterations)
#class(pb)
#[1] "Progress" "R6"  

Executing a chunk that uses the progress object (or knitting the Rmd file), will produce progress updates for the chunk:

purrr::map_int(1:n_iterations, ~slow_function(.x, .pb = pb))

EDIT: closer to the question - this also works inside a loop, not just inside purrr::map

pb <- progress_estimated(n_iterations)
for(i in 1:n_iterations) {
  slow_function(i, .pb=pb)
}

Conditionally execute cells in Rnotebook that contain markdown and inline code chunks

Does this work for you?

---

---
title: "Report"
output: pdf_document
---

```{r echo=FALSE}
# create some sample data
data <- structure(list(
value = c(0.0877467265976158, 0.0470430107526882, 
        0.0379081350304372, 0.0251588983050848, -0.000220385674931101, 
        -0.00389321468298109, -0.0079051383399209, -0.0100182149362477, 
        -0.0173333333333333, -0.0198838937656, -0.0436432637571157, -0.0771637863594339), 
value2 = c(0.00769948802859674, 0.00221304486067754, 0.00143702670148586, 
         0.000632970163925598, 4.85698457148368e-08, 1.51571205677796e-05, 
         6.24912121732874e-05, 0.000100364630508856, 0.000300444444444444, 
         0.000395369231281665, 0.00190473447137317, 0.00595424992532435)),
class = c("tbl_df", "tbl", "data.frame"), row.names = c(NA, -12L))

text <- c('* The most', 'number for')
```

The following code cell SHOULD BE executed:

```{r, results = 'asis', echo = F, eval=max(data$value > 0)}
cat(text[1],'positive',text[2],'value is',max(data$value), sep=' ')
```

The following code cell SHOULD BE executed:

```{r, results = 'asis', echo = F, eval=min(data$value) < 0}
cat(text[1],'negative',text[2],'value is',min(data$value), sep=' ')
```

The following code cell SHOULD BE executed:

```{r, results = 'asis', echo = F, eval=max(data$value2 > 0)}
cat(text[1],'positive',text[2],'value2 is',max(data$value2), sep=' ')
```

The following code cell SHOULD NOT BE executed:

```{r, results = 'asis',echo = F, eval=min(data$value2) < 0}
cat(text[1],'negative',text[2],'value2 is',min(data$value2), sep=' ')
```

---

Related Topics