R Markdown on Stats and R

Getting started in R markdown

Tue, 18 Feb 2020 00:00:00 +0000

If you have spent some time writing code in R, you probably have heard of generating dynamic reports incorporating R code, R outputs (results) and text or comments. In this article, I will explain how R Markdown works and give you the basic elements you need to get started easily in the production of these dynamic reports.

R Markdown: what, why and how?

R Markdown allows to generate a report (most of the time in PDF, HTML, Word or as a beamer presentation) that is automatically generated from a file written within RStudio. The generated documents can serve as a neat record of your analysis that can be shared and published in a detailed and complete report. Even if you never expect to present the results to someone else, it can also be used as a personal notebook to look back so you can see what you did at that time. A R Markdown file has the extension .Rmd, while a R script file has the extension .R.

The first main advantage of using R Markdown over R is that, in a R Markdown document, you can combine three important parts of any statistical analysis:

R code to show how the analyses have been done. For instance, the data and the functions you used. This allows readers to follow your code and to check that the analyses were correctly performed.
Results of the code, that is, the output of your analyses. For example, the output of your linear model, plots, or results of the hypothesis test you just coded. This allows readers to see the results of your analyses.
Text, comments and interpretations of the results. For instance, after computing the main descriptive statistics and plotting some graphs, you can interpret them in the context of your problem and highlight important findings. This enables readers to understand your results thanks to your interpretations and your comments, delivered as if you wrote a document explaining your work.

Another advantage of R Markdown is that the reports are dynamic and reproducible by anyone who has access to the .Rmd file (and the data if external data are used of course), making it perfectly suited to collaboration and dissemination of results. By dynamic, we mean that if your data changes, your results and your interpretations will change accordingly, without any work from your side.

The production of the reports is done in two stages:

The .Rmd file which contains blocks of R code (called chunks) and text is provided to the {knitr} package which will execute the R code to get the output, and create a document in markdown (.md) format. This document then contains the R code, the results (or outputs), and the text.
This .md file is then converted to the desired format (HTML, PDF or Word), by the markdown package based on pandoc (i.e., a document conversion tool).

Before you start

To create a new R Markdown document (.Rmd), you first need to install and load the following packages:

install.packages(c("knitr", "rmarkdown", "markdown"))

library(knitr)
library(rmarkdown)
library(markdown)

Then click on File -> New File -> R Markdown or click on the small white sheet with a green cross in the top left corner and select R Markdown:

Create a new R Markdown document

A window will open, choose the title and the author and click on OK. The default output format is HTML. It can be changed later to PDF or Word.

After you have clicked on OK, a new .Rmd file which serves as example has been created. We are going to use this file as starting point to our more complex and more personalized file.

To compile your R Markdown document into a HTML document, click on the Knit button located at the top:

Knit a R Markdown document

A preview of the HTML report appears and it is also saved in your working directory (see a reminder of what is a working directory).

Components of a `.Rmd` file

Below the main components of a R Markdown document:

These components are detailed in the following sections.

YAML header

A .Rmd file starts with the YAML header, enclosed by two series of ---. By default, this includes the title, author, date and the format of the report. If you want to generate the report in a PDF document, replace output: html_document byoutput: pdf_document. These information from the YAML header will appear at the top of the generated report after you compile it (i.e., after knitting the document).

To add a table of contents to your documents, replace output: html_document by

output:
  html_document:
    toc: true

Here are my usual settings regarding the format of a HTML document (remove everything after number_sections: true if you render the document in PDF, as PDF documents do not accept these options in the YAML header):

output:
  html_document:
    toc: true
    toc_depth: 6
    number_sections: true
    toc_float: true
    code_folding: hide
    theme: flatly
    code_download: true

In addition to adding a table of contents, it sets its depth, adds a section numbering, the table of contents is floating when scrolling down the document, the code is hidden by default, the flatly theme is used and it adds the possibility to download the .Rmd document.

You can visualize your table of contents even before knitting the document, or go directly to a specific section by clicking on the small icon in the top right corner. Your table of contents will appear, click on a section to go to this section in your .Rmd document:

Visualize your table of contents

In addition to this enhanced table of contents, I usually set the following date in the YAML header:

Dynamic date in R Markdown

This piece of code allows to write the current date, without having to change it myself. This is very convenient for projects that last several weeks or months to always have an updated date at the top of the document.

Code chunks

Below the YAML header, there is a first code chunk which is used for the setup options of your entire document. It is best to leave it like this at the moment, we can change it later if needed.

Code chunks in R Markdown documents are used to write R code. Every time you want to include R code, you will need to enclose it with three backwards apostrophes. For instance, to compute the mean of the values 1, 7 and 11, we first need to insert a R code chunk by clicking on the Insert button located at the top and select R (see below a picture), then we need to write the corresponding code inside the code chunk we just inserted:

Insert R code chunk in R Markdown

Example of code chunk

In the example file, you can see that the first R code chunk (except the setup code chunk) includes the function summary() of the preloaded dataset cars: summary(cars). If you look at the HTML document that is generated from this example file, you will see that the summary measures are displayed just after the code chunk.

The next code chunk in this example file is plot(pressure), which will produce a plot. Try writing other R codes and knit (i.e., compile the document by clicking on the knit button) the document to see if your code is generated correctly.

If you already wrote code in a R script and want to reuse it in your R Markdown document, you can simply copy paste your code inside code chunks. Do not forget to always include your code inside code chunks or R will throw an error when compiling your document.

As you can see, there are two additional arguments in the code chunk of the plot compared to my code chunk of the mean presented above. The first argument following the letter r (without comma between the two) is used to set the name of the chunk. In general, do not bother with this, it is mainly used to refer to a specific code chunk. You can remove the name of the chunk, but do not remove the letter r between the {} as it tells R that the code that follows corresponds to R code (yes you read it well, that also means you can include code from another programming language, e.g., Python, SQL, etc.).

After the name of the chunk (after pressure in the example file), you can see that there is an additional argument: echo = FALSE. This argument, called an option, indicates that you want to hide the code, and display only the output of the code. Try removing it (or change it to echo = TRUE), and you will see that after knitting the document, both the code AND the output will appear, while only the results appeared previously.

You can specify if you want to hide or display the code alongside the output of that code for each code chunk separately, for instance if you want to show the code for some code chunks, but not for others. Alternatively, if you want to always hide/display the code together with the output for the entire document, you can specify it in the setup code chunk located just after the YAML header. The options passed to this setup code chunk will determine the options for all code chunks, except for those that have been specifically modified.

By default, the only setup option when you open a new R Markdown file is knitr::opts_chunk$set(echo = TRUE), meaning that by default, all outputs will be accompanied by its corresponding code. If you want to display only the results without the code for the whole document, replace it by knitr::opts_chunk$set(echo = FALSE). Two other options often passed to this setup code chunk are warning = FALSE and message = FALSE to prevent warnings and messages to be displayed on the report. If you want to pass several options, do not forget to separate them with a comma:

Several options for a code chunk

You can also choose to display the code, but not the result. For this, pass the option results = "hide". Alternatively, with the option include = FALSE, you can prevent code and results from appearing in the finished file while R still runs the code in order to use it at a later stage. If you want to prevent the code and the results to appear, and do not want R to run the code, use eval = FALSE. To edit the width and height of figures, use the options fig.width and fig.height. Another very interesting option is the tidy = 'styler' option which automatically reformats the R code shown in the output.

See all options and their description here or see the list of the default options by running str(knitr::opts_chunk$get()).

Tip: When writing in R Markdown, you will very often need to insert new R code chunks. To insert a new R code chunk more rapidly, press CTRL + ALT + I on Windows or command + option + I on Mac. If you are interested in such shortcuts making you more efficient, see other tips and tricks in R Markdown.

Note that a code chunk can be run without the need to compile the entire document, if you want to check the results of a specific code chunk for instance. In order to run a specific code chunk, select the code and run it as you would do in a R script (.R), by clicking on run or by pressing CTRL + Enter on Windows or command + Enter on Mac. Results of this code chunk will be displayed directly in the R Markdown document, just below the code chunk.

Text

Text can be added everywhere outside code chunks. R Markdown documents use the Markdown syntax for the formatting of the text. In our example file just below the setup code chunk, some text has been inserted. To insert text, you simply write text without any enclosing. Try adding some sentences and knit the document to see how it appears in the HTML document.

Example of text below an example of R code chunk

Markdown syntax can be used to change the formatting of your text appearing in the output file, for example to format some text in italics, in bold, etc. Below some common formatting commands:

Title: # Title
Subtitle: ## Subtitle
Subsubtitle: ### Subsubtitle. These headings will automatically be included in the table of contents if you included one.
italics: *italics* or _italics_
bold: **bold** or __bold__
Link: [link](https://statsandr.com/) (do not forget https:// or http:// if it is an external URL)
Equations:

Enclose your equation (written in LaTeX) with one $ to have it in the text:

$A = \pi*r^{2}$

This is a well-know equation $A = \pi*r^{2}$.

Enclose your LaTeX equation with two $$ to have it centered on a new line:

$$A = \pi*r^{2}$$

This is another well-known equation:

\[E = mc^2\]

Lists:

Unordered list, item 1: * Unordered list, item 1
Unordered list, item 2: * Unordered list, item 2

Ordered list, item 1: 1. Ordered list, item 1
Ordered list, item 2: 2. Ordered list, item 2

Code inside text

Before going further, I would like to introduce an important feature of R Markdown. It is often the case that, when writing interpretations or detailing an analysis, we would like to refer to a result directly in our text. For instance, suppose we work on the iris dataset (preloaded in R). We may want to explain in words, that the mean of the length of the petal is a certain value, while the median is another value.

Without R Markdown, the user would need to compute the mean and median, and then report it manually. Thanks to R Markdown, it is possible to report these two descriptive statistics directly in the text, without manually encoding it. Even better, if the dataset happens to change because we removed some observations, the mean and median reported in the generated document will change automatically, without any change in the text from our side.

We can insert results directly in the interpretations (i.e., in the text) by placing a backward apostrophe, the letter r, a space, the code, and then close it with another backward apostrophe:

Inline code in R Markdown

Here is an illustration with the mean and median of the length of the sepal for the iris dataset integrated in a sentence:

Example of inline code and text

This combination of text and code will give the following output in the generated report:

The mean of the length of the sepal is 5.8433333 and the standard deviation is 0.8280661.

This technique, referred as inline code, allows you to insert results directly into the text of a R Markdown document. And as mentioned, if the dataset changes, the results incorporated inside the text (the mean and standard deviation in our case) will automatically be adjusted to the new dataset, exactly like the output of a code chunk is dynamically updated if the dataset changes.

This technique of inline code and the fact that it is possible to combine code, outputs of code, and text to comment the outputs makes R Markdown my favorite tool when it comes to statistical analyses. Since I discovered the power of R Markdown (and I am still learning as it has a huge amount of possibilities and features), I almost never write R code in scripts anymore. Every R code I write is supplemented by text and inline code in a R Markdown document, resulting in a professional and complete final document ready to be shared, published, or stored for future usage. If you are unfamiliar to this type of document, I invite you to learn more about it and to try it with your next analysis, you will most likely not go back to R scripts anymore.

Highlight text like it is code

Alternatively to the inline code technique, you may want to make some text appears as if it is a piece of code in the generated report, without actually running it.

For this, surround your text with back ticks (the same backward apostrophe used for inline code) without the letter r. Writing the following:

will produce this in the generated report:

For example, in this sentence I would like to highlight the variable name Species from the dataframe iris as if it is a piece of code.

The word “Species” and “iris” appear and are highlighted as if it is a piece of code.

Images

In addition to code, results and text, you can also insert images in your final document. To insert an image, place it in your current working directory, and outside a code chunk write:

![](path_to_your_image.jpg)

Note that the the file/url path is NOT quoted. To add an alt text to your image, add it between the square brackets []:

![alt text here](path_to_your_image.jpg)

Tables

There are two options to insert tables in R Markdown documents:

the kable() function from the {knitr} package
the pander() function from the {pander} package

Here are an example of a table without any formatting, and the same code with the two functions applied on the iris dataset:

# without formatting
summary(iris)

##   Sepal.Length    Sepal.Width     Petal.Length    Petal.Width   
##  Min.   :4.300   Min.   :2.000   Min.   :1.000   Min.   :0.100  
##  1st Qu.:5.100   1st Qu.:2.800   1st Qu.:1.600   1st Qu.:0.300  
##  Median :5.800   Median :3.000   Median :4.350   Median :1.300  
##  Mean   :5.843   Mean   :3.057   Mean   :3.758   Mean   :1.199  
##  3rd Qu.:6.400   3rd Qu.:3.300   3rd Qu.:5.100   3rd Qu.:1.800  
##  Max.   :7.900   Max.   :4.400   Max.   :6.900   Max.   :2.500  
##        Species  
##  setosa    :50  
##  versicolor:50  
##  virginica :50  
##                 
##                 
##

# with kable()
library(knitr)
kable(summary(iris))

# with pander()
library(pander)
pander(summary(iris))

The advantage of pander() over kable() is that it can be used for many more different outputs than table. Try on your own code, with results of a linear regression or a simple vector for example.

Additional notes and useful resources

For more advanced users, R Markdown files can also be used to create Shiny apps, websites (this website is built thanks to R Markdown and the {blogdown} package), to write scientific papers based on templates from several international journals (with the {rticles} package), or even to write books (with the {bookdown} package).

To continue learning about R Markdown, see two complete cheat sheets from the R Studio team here and here, and a more complete guide here written by Yihui Xie, J. J. Allaire and Garrett Grolemund.

Conclusion

Thanks for reading.

I hope this article convinced you to use R Markdown for your future projects. See more tips and tricks in R Markdown to increase even further your efficiency in R Markdown.

As always, if you have a question or a suggestion related to the topic covered in this article, please add it as a comment so other readers can benefit from the discussion.

RStudio addins, or how to make your coding life easier?

Sun, 26 Jan 2020 00:00:00 +0000

What are RStudio addins?

Although I have been using RStudio for several years, I only recently discovered RStudio addins. Since then, I am using these addins almost every time I use RStudio.

What are RStudio addins? RStudio addins are extensions which provide a simple mechanism for executing advanced R functions from within RStudio. In simpler words, when executing an addin (by clicking a button in the Addins menu), the corresponding code is executed without you having to write the code. If it is still not clear, remember that for importing a dataset in RStudio, you have two options:

import it by writing the code (thanks to the read.csv() function for instance)
or you can import it by clicking on the “Import Dataset” button in the Environment pane, set the importing settings, then click on “Import”

An RStudio addin is exactly like the Import Dataset button but for other common functionalities. So you could write code as you can import a dataset by writing code, but thanks to RStudio addins you can execute code without actually writing the necessary code. By using the RStudio addins, RStudio will run the required code for you. RStudio addins can be as simple as a function that inserts a commonly used snippet of code, and as complex as a Shiny application that accepts input from the user to draw a plot. RStudio addins have the advantage that they allow you to execute complex and advanced code much more easily than if you would have to write it yourself.

I believe addins are worth trying for all R users. Beginners will have the possibility to use functions that they would not have used otherwise because the code is too complex, whereas advanced users may find them useful to speed up the writing of their code in some circumstances. For other tips in R, see the article “Tips and tricks in RStudio and R Markdown”.

Installation

RStudio Addins are distributed as R packages. So before being able to use them, you need to install them.

You can install an addin exactly the same way you install a package: install.packages("name_of_addin"). Once you have installed the R package that contains the addin, it will immediately become available within RStudio, via the Addins menu located at the top.

RStudio addins toolbar

See this guide if you want to install a personal package as addin. In short, you have to create an R package, put your functions in a specific file and RStudio will automatically discover and register these addins when your package is installed.

Addins

If you are still not convinced, see below a list of the addins I find most useful together with concrete examples in the following sections.

Note that this list is not exhaustive and you are likely to find others useful too depending on what type of analyses you do on RStudio. Feel free to comment at the end of the article to let me know (and other readers) addins you found worth using.

Esquisse

{esquisse} is an addin developed by a French company called dreamRs. Here is how they define it:

This addin allows you to interactively explore your data by visualizing it with the ggplot2 package. It allows you to draw bar plots, curves, scatter plots, histograms, boxplot and sf objects, then export the graph or retrieve the code to reproduce the graph.

With this addin you can easily create beautiful graphs from the {ggplot2} package and the best part according to me is that you can retrieve the code to reproduce the graph. Compared to the default {graphics} package, it is true that graphs from the {ggplot2} package look usually better but the code is also longer and more complex. With this addin, you can draw graphs from the {ggplot2} package by dragging and dropping variables of interest in an user-friendly and interactive window, and then use the generated code in your script.

For the sake of illustration, let’s say we want to create a scatter plot of the variables Sepal.Length and Petal.Length of the dataset iris and color the points by the variable Species. For this, follow these steps:

load the dataset and rename it:¹

dat <- iris

install the package {esquisse}. This must be done only once

install.packages("esquisse")

open the ‘ggplot2’ builder from the RStudio Addins menu:

Step 3: Open ‘ggplot2’ builder from the RStudio addins menu

Select the dataset you want to work on (in this case dat) and click on “Validate imported data” after checking that the number of observations and variables are correct (green box):

Step 4: Select dataset and validate the imported data

Drag and drop the variables of interest in the corresponding areas. In this case, we would like to draw a scatter plot of the variables Sepal.Length and Petal.Length and color points based on the variable Species:

Step 5: Drag and drop the variables in the corresponding areas

Click on “</> Export & code” at the bottom right of the window. You can either copy the code and paste it where you want to place it in your script, or you can click on “Insert code in script” to place the code where your cursor is located in your script:

Step 6: Retrieve the code to use it in your script

If you chose the second option, the following code should appear where your cursor was located:

ggplot(dat) +
  aes(x = Sepal.Length, y = Petal.Length, colour = Species) +
  geom_point(shape = "circle", size = 1.5) +
  scale_color_hue(direction = 1) +
  theme_minimal()

Many different options and customizations are possible (e.g., axis labels, colors, legend position, theme, data filtering, etc.). For this, use the buttons located at the bottom of the window (“Labels & title”, “Plot options” and “Data”). You can see the changes instantly in the window, and when the plot corresponds to your needs, export the code into your script.

I will not go into more details regarding the different types of plots and the customizations, but make sure to try other types of plots by moving variables and customize it to see what is possible.

ggThemeAssist

Note that there is another addin called {ggThemeAssist} which helps you to edit the theme() layer of a {ggplot2} plot.

This layer allows you to modify the appearance of the background, grids, axes, labels, legend, (sub)title, caption, etc.

To use this addin:

Write the code of the plot in {ggplot2} (it does not work for a plot written in base R)
Highlight the code
Select the {ggThemeAssist} addin in the addins menu
Customize your plot according to your needs
Click on the button Done and your code will be edited with your changes:

ggplot(dat) +
  aes(x = Sepal.Length, y = Petal.Length, colour = Species) +
  geom_point(shape = "circle", size = 1.5) +
  scale_color_hue(direction = 1) +
  theme_minimal() +
  theme(
    panel.grid.major = element_line(linetype = "blank"),
    panel.grid.minor = element_line(linetype = "blank"),
    legend.position = c(0.88, 0.22)
  ) +
  theme(plot.caption = element_text(face = "italic")) +
  labs(
    title = "Sepal & petal length by species",
    x = "Sepal length", y = "Petal length",
    caption = "Data: iris"
  )

Find more information about the theme() layer in this cheatsheet.

Questionr

The {questionr} addin is useful for survey analysis and when dealing with factor variables. With this addin, you can easily reorder and recode factor variables. The addin also allows to easily transform a numeric variable into factors (i.e., categorize a continuous variable) thanks to the cut() function. Like any other addin, after having installed the {questionr} package, you should see it appearing in the addins menu at the top. From the addins dropdown menu, choose whether you want to reorder or recode your factor variable, or categorize your numeric variable.

Recoding factors

Instead of writing the recode() function from the {dplyr} package, we can use the {questionr} addin.

For this example, let’s say we want to recode the Species variable to shorten the length of the factors, and then store this new variable as Species_rec:

Step 1: Select the variable to be recoded and the recoding settings

Step 2: Specify the names of the new factors

Step 3: Check the results thanks to the contingency table and use the code at the top

Reordering factors

Similar to recoding, we can reorder factors thanks to the {questionr} addin. Let’s say we want to reorder the 3 factors of the Species variable such that the order is versicolor then virginica and finally setosa. This can be done as follows:

Step 1: Select the variable to reorder and the new variable name

Step 2: Specify the order you want

Step 3: Use the code at the top in your script

Categorize a numeric variable

The {questionr} addin also allows to transform a numeric variable into a categorical variable. This is often done for the age, when age is transformed into age groups for instance. For this example, let’s say we want to create 3 categories of the variable Sepal.Length:

Step 1: Choose the variable to be transformed and the new variable name

Step 2: Set the number of breaks equal to 3

(Try by yourself the other cutting methods and see the results directly in the window.)

Step 3: Check the result thanks to the barplot at the bottom

Step 4: Use the code in your script

Remedy

If you often write in R Markdown, the {remedy} addins will greatly facilitate your work. The addins allow you to add bold, creating lists, urls, italics, title (H1 to H6), footnote, etc. in an efficient way. I reckon that some of these tasks can be done faster by using the code directly rather than by going through the addins menu and then selecting the transformations you want. However, I personally cannot remember the code for all transformations, and it is quicker to apply it through the menu than by searching for the answer on Google or on your Markdown cheat sheet.

Styler

The {styler} addin allows to reformat your code in a more readable format by running styler::tidyverse_style(). It works both for R scripts and R Markdown documents. You can either reformat the selected code, the active file or the active package. I find this addin particularly useful before sharing or publishing my code, so that it respects the most common styling guidelines for code.

For instance, a piece of code like this:

1+1
#this is a comment
  for(i in 1:10){if(!i%%2){next}
print(i)
 }

becomes much more neat and readable:

1 + 1
# this is a comment
for (i in 1:10) {
  if (!i %% 2) {
    next
  }
  print(i)
}

Snakecaser

The {snakecaser} addins converts a character string to the snake case styling. Snake case styling is the practice of writing character strings of several words separated by space into character strings with words separated with an underscore (_). Moreover, it replaces capital letters with lowercases. For instance, the following string:

This is the Test 1

will be transformed to:

this_is_the_test_1

The snake case styling is particularly useful (and even recommended by many R users) for variables, functions and file names, etc.

ViewPipeSteps

Thanks to a reader of this article, I discovered the ViewPipeSteps addin. This addin allows to print or view the output of your pipe chain after each step.

For instance, here is a chain with the dataset diamonds:

library(tidyverse)

diamonds %>%
  select(carat, cut, color, clarity, price) %>%
  group_by(color) %>%
  summarise(n = n(), price = mean(price)) %>%
  arrange(desc(color))

## # A tibble: 7 × 3
##   color     n price
##   <ord> <int> <dbl>
## 1 J      2808 5324.
## 2 I      5422 5092.
## 3 H      8304 4487.
## 4 G     11292 3999.
## 5 F      9542 3725.
## 6 E      9797 3077.
## 7 D      6775 3170.

If you are unsure about your pipe chain or want to debug it, you can view the output after each step by highlighting your entire chain then clicking on “View Pipe Chain Steps” from the addins menu:

From the addins menu, you can choose to either print the result to the console, or view the result in a new pane (as if you called the function View() after each step of the pipe). Clicking on View Pipe Chain Steps will open a new window with the output of each step:

Note that you have to use the following command to install the ViewPipeSteps addin:

devtools::install_github("daranzolin/ViewPipeSteps")
library(ViewPipeSteps)

Now, you have no more excuses to use this pipe operator!

Ymlthis

ymlthis addin to easily write YAML header

The ymlthis addin makes it easy to write YAML front matter for R Markdown and related documents. The addin will create YAML for you and put it in a file, such as an .Rmd file, or on your clipboard.

This addin is particularly useful if you want to write (more complicated) YAML header.

Reprex

If you often ask the R community for help, this addin may be very useful!

It is important to remember that when you ask someone for help, you have to help them help you by giving a precise and clear overview of your problem. This helps the community to quickly understand your issue and thus reduces the response time.

In most cases, this involves providing a reproducible example, that is to say a piece of code (as small and as readable as possible) reproducing the problem encountered.

The {reprex} addin allows you to transform your reproducible example so that it can easily be shared on platforms such as GitHub, Stack Overflow, RStudio community, etc. The layout of your reproducible example will be adapted to the platform, and you can even include information about your R session.²

Here is how to use it steps by steps:

First create your reproducible example in R (remember to keep it as short and readable as possible to save time to potential helpers):

Minimal reproducible example

Select the {reprex} addin in the list of addins:

Select the {reprex} addin

Select the platform on which you will post your issue (and check “Append session info” if you want to display your session info at the end of your reproducible example):

Set options in the {reprex} addin

You can now see the output of your reproducible example (right panel), but more importantly, it has been copied in your clipboard and it is now ready to be pasted on the platform of your choice:

Your reprex is copied in your clipboard

Paste your reprex on the platform of your choice (here, it is posted as an issue on GitHub):

Paste your reprex

Check the final result of your reproducible example:

Final result

(Visit this GitHub issue to see the final result.)

Blogdown

I put this addin at the end of the list because it will be of interest for only a limited number of RStudio users: people maintaining a blog written in R like this one (see why I recommend everyone to start a technical blog).

The most useful functionalities in this addin are the following:

New post: create a new post with blogdown::new_post(). It can be used to create new pages as well, not only posts
Insert image: insert an external image into a blog post
Update metadata: update the title, author, date, categories and tags of the current blog post
Serve site: run blogdown::serve_site() to live preview your website locally

Conclusion

Thanks for reading.

I hope that you will find these addins useful for your future R-related projects. See other tips and tricks in RStudio and R Markdown.

As always, if you have a question or a suggestion related to the topic covered in this article, please add it as a comment so other readers can benefit from the discussion.

You actually do not need to rename it. However, I often rename the datasets I work on with the same generic name dat so when I reuse codes from a previous project for a new project, I do not have to change the name of the dataset in the code.↩︎
Thanks to Josep for the suggestion.↩︎

Tips and tricks in RStudio and R Markdown

Tue, 21 Jan 2020 00:00:00 +0000

If you have the chance to work with an experienced programmer, you may be amazed by how fast she can write code. In this article, I share some tips and shortcuts you can use in RStudio and R Markdown to speed up the writing of your code.

Run code

You most probably already know this shortcut but I still mention it for new R users. From your script you can run a chunk of code with:

command + Enter on Mac
Ctrl + Enter on Windows

Insert a comment in R and R Markdown

To insert a comment:

command + Shift + C on Mac
Ctrl + Shift + C on Windows

This shortcut can be used both for:

R code when you want to comment your code. It will add a # at the beginning of the line
for text in R Markdown. It will add  around the text

Note that if you want to comment more than one line, select all the lines you want to comment then use the shortcut. If you want to uncomment a comment, apply the same shortcut.

Knit a R Markdown document

You can knit R Markdown documents by using this shortcut:

command + Shift + K on Mac
Ctrl + Shift + K on Windows

Code snippets

Code snippets is usually a few characters long and is used as a shortcut to insert a common piece of code. You simply type a few characters then press Tab and it will complete your code with a larger code. Tab is then used again to navigate through the code where customization is required. For instance, if you type fun then press Tab, it will auto-complete the code with the required code to create a function:

name <- function(variables) {
  
}

Pressing Tab again will jump through the placeholders for you to edit it. So you can first edit the name of the function, then the variables and finally the code inside the function (try by yourself!).

There are many code snippets by default in RStudio. Here are the code snippets I use most often:

lib to call library()

library(package)

mat to create a matrix

matrix(data, nrow = rows, ncol = cols)

if, el, and ei to create conditional expressions such as if() {}, else {} and else if () {}

if (condition) {
  
}

else {
  
}

else if (condition) {
  
}

fun to create a function

name <- function(variables) {

}

for to create for loops

for (variable in vector) {

}

ts to insert a comment with the current date and time (useful if you have very long code and share it with others so they see when it has been edited)

# Tue Jan 21 20:20:14 2020 ------------------------------

shinyapp every time I create a new shiny app

library(shiny)

ui <- fluidPage()

server <- function(input, output, session) {

}

shinyApp(ui, server)

You can see all default code snippets and add yours by clicking on Tools > Global Options… > Code (left sidebar) > Edit Snippets…

Ordered list in R Markdown

In R Markdown, when creating an ordered list such as this one:

Item 1
Item 2
Item 3

Instead of bothering with the numbers and typing

1. Item 1
2. Item 2
3. Item 3

you can simply type

1. Item 1
1. Item 2
1. Item 3

for the exact same result (try it yourself or check the code of this article!). This way you do not need to bother which number is next when creating a new item.

To go even further, any numeric will actually render the same result as long as the first item is the number you want to start from. For example, you could type:

1. Item 1
7. Item 2
3. Item 3

which renders

Item 1
Item 2
Item 3

However, I suggest always using the number you want to start from for all items because if you move one item at the top, the list will start with this new number. For instance, if we move 7. Item 2 from the previous list at the top, the list becomes:

7. Item 2
1. Item 1
3. Item 3

which incorrectly renders

Item 2
Item 1
Item 3

New code chunk in R Markdown

When editing R Markdown documents, you will need to insert a new R code chunk many times. The following shortcuts will make your life easier:

command + option + I on Mac (or command + alt + I depending on your keyboard)
Ctrl + ALT + I on Windows

New R code chunk in R Markdown

Reformat code

A clear and readable code is always easier and faster to read (and look more professional when sharing it to collaborators). To automatically apply the most common coding guidelines such as whitespaces, indents, etc., use:

cmd + Shift + A on Mac
Ctrl + Shift + A on Windows

So for example the following code which does not respect the guidelines (and which is not easy to read):

1+1
  for(i in 1:10){if(!i%%2){next}
print(i)
 }

becomes much more neat and readable:

1 + 1
for (i in 1:10) {
  if (!i %% 2) {
    next
  }
  print(i)
}

RStudio addins

RStudio addins are extensions which provide a simple mechanism for executing advanced R functions from within RStudio. In simpler words, when executing an addin (by clicking a button in the Addins menu), the corresponding code is executed without you having to write the code. RStudio addins have the advantage that they allow you to execute complex and advanced code much more easily than if you would have to write it yourself.

The addin I use most often is probably the {esquisse} addin, which allows to draw plots with the {ggplot2} package in a user-friendly and interactive way, and without having to write the code myself.

RStudio addins are quite diverse and require a more detailed explanation, so I wrote an article focusing on these addins. See the article here.

`{pander}` and `{report}` for aesthetics

The pander() function from the {pander} package is very useful for R Markdown documents and reporting. It is not actually a shortcut but it greatly improves the aesthetics of R outputs.

For instance, see below the difference between the default output of a Chi-square test of independence and the output from the same test with the pander() function (using the diamonds dataset from the {ggplot2} package):

library(ggplot2)
dat <- diamonds

test <- chisq.test(table(dat$cut, dat$color))
test

## 
##  Pearson's Chi-squared test
## 
## data:  table(dat$cut, dat$color)
## X-squared = 310.32, df = 24, p-value < 2.2e-16

library(pander)
pander(test)

Pearson’s Chi-squared test: `table(dat$cut, dat$color)`
Test statistic	df	P value
310.3	24	1.395e-51 * * *

All information that you need are displayed in an elegant table. The pander() function works on many statistical tests (not to say all of them, but I have not tried it on all available tests in R) and on regression models:

# Linear model with lm()
model <- lm(price ~ carat + x + y + z,
  data = dat
)
model

## 
## Call:
## lm(formula = price ~ carat + x + y + z, data = dat)
## 
## Coefficients:
## (Intercept)        carat            x            y            z  
##      1921.2      10233.9       -884.2        166.0       -576.2

pander(model)

Fitting linear model: price ~ carat + x + y + z
	Estimate	Std. Error	t value	Pr(>\|t\|)
(Intercept)	1921	104.4	18.41	1.977e-75
carat	10234	62.94	162.6	0
x	-884.2	40.47	-21.85	2.317e-105
y	166	25.86	6.421	1.365e-10
z	-576.2	39.28	-14.67	1.277e-48

The pander function also makes datasets, tables, vectors, etc. more readable in R Markdown output. For example, see the differences below:

head(dat)[1:7] # first 6 observations of the first 7 variables

## # A tibble: 6 × 7
##   carat cut       color clarity depth table price
##   <dbl> <ord>     <ord> <ord>   <dbl> <dbl> <int>
## 1  0.23 Ideal     E     SI2      61.5    55   326
## 2  0.21 Premium   E     SI1      59.8    61   326
## 3  0.23 Good      E     VS1      56.9    65   327
## 4  0.29 Premium   I     VS2      62.4    58   334
## 5  0.31 Good      J     SI2      63.3    58   335
## 6  0.24 Very Good J     VVS2     62.8    57   336

pander(head(dat)[1:7])

carat	cut	color	clarity	depth	table	price
0.23	Ideal	E	SI2	61.5	55	326
0.21	Premium	E	SI1	59.8	61	326
0.23	Good	E	VS1	56.9	65	327
0.29	Premium	I	VS2	62.4	58	334
0.31	Good	J	SI2	63.3	58	335
0.24	Very Good	J	VVS2	62.8	57	336

summary(dat) # main descriptive statistics

##      carat               cut        color        clarity          depth      
##  Min.   :0.2000   Fair     : 1610   D: 6775   SI1    :13065   Min.   :43.00  
##  1st Qu.:0.4000   Good     : 4906   E: 9797   VS2    :12258   1st Qu.:61.00  
##  Median :0.7000   Very Good:12082   F: 9542   SI2    : 9194   Median :61.80  
##  Mean   :0.7979   Premium  :13791   G:11292   VS1    : 8171   Mean   :61.75  
##  3rd Qu.:1.0400   Ideal    :21551   H: 8304   VVS2   : 5066   3rd Qu.:62.50  
##  Max.   :5.0100                     I: 5422   VVS1   : 3655   Max.   :79.00  
##                                     J: 2808   (Other): 2531                  
##      table           price             x                y         
##  Min.   :43.00   Min.   :  326   Min.   : 0.000   Min.   : 0.000  
##  1st Qu.:56.00   1st Qu.:  950   1st Qu.: 4.710   1st Qu.: 4.720  
##  Median :57.00   Median : 2401   Median : 5.700   Median : 5.710  
##  Mean   :57.46   Mean   : 3933   Mean   : 5.731   Mean   : 5.735  
##  3rd Qu.:59.00   3rd Qu.: 5324   3rd Qu.: 6.540   3rd Qu.: 6.540  
##  Max.   :95.00   Max.   :18823   Max.   :10.740   Max.   :58.900  
##                                                                   
##        z         
##  Min.   : 0.000  
##  1st Qu.: 2.910  
##  Median : 3.530  
##  Mean   : 3.539  
##  3rd Qu.: 4.040  
##  Max.   :31.800  
##

pander(summary(dat))

Table continues below
carat	cut	color	clarity	depth
Min. :0.2000	Fair : 1610	D: 6775	SI1 :13065	Min. :43.00
1st Qu.:0.4000	Good : 4906	E: 9797	VS2 :12258	1st Qu.:61.00
Median :0.7000	Very Good:12082	F: 9542	SI2 : 9194	Median :61.80
Mean :0.7979	Premium :13791	G:11292	VS1 : 8171	Mean :61.75
3rd Qu.:1.0400	Ideal :21551	H: 8304	VVS2 : 5066	3rd Qu.:62.50
Max. :5.0100	NA	I: 5422	VVS1 : 3655	Max. :79.00
NA	NA	J: 2808	(Other): 2531	NA

table	price	x	y	z
Min. :43.00	Min. : 326	Min. : 0.000	Min. : 0.000	Min. : 0.000
1st Qu.:56.00	1st Qu.: 950	1st Qu.: 4.710	1st Qu.: 4.720	1st Qu.: 2.910
Median :57.00	Median : 2401	Median : 5.700	Median : 5.710	Median : 3.530
Mean :57.46	Mean : 3933	Mean : 5.731	Mean : 5.735	Mean : 3.539
3rd Qu.:59.00	3rd Qu.: 5324	3rd Qu.: 6.540	3rd Qu.: 6.540	3rd Qu.: 4.040
Max. :95.00	Max. :18823	Max. :10.740	Max. :58.900	Max. :31.800
NA	NA	NA	NA	NA

table(dat$cut, dat$color) # contingency table

##            
##                D    E    F    G    H    I    J
##   Fair       163  224  312  314  303  175  119
##   Good       662  933  909  871  702  522  307
##   Very Good 1513 2400 2164 2299 1824 1204  678
##   Premium   1603 2337 2331 2924 2360 1428  808
##   Ideal     2834 3903 3826 4884 3115 2093  896

pander(table(dat$cut, dat$color))

	D	E	F	G	H	I	J
Fair	163	224	312	314	303	175	119
Good	662	933	909	871	702	522	307
Very Good	1513	2400	2164	2299	1824	1204	678
Premium	1603	2337	2331	2924	2360	1428	808
Ideal	2834	3903	3826	4884	3115	2093	896

names(dat) # variable names

##  [1] "carat"   "cut"     "color"   "clarity" "depth"   "table"   "price"  
##  [8] "x"       "y"       "z"

pander(names(dat))

carat, cut, color, clarity, depth, table, price, x, y and z

rnorm(4) # generates 4 observations from a standard normal distribution

## [1]  1.3709584 -0.5646982  0.3631284  0.6328626

pander(rnorm(4))

0.4043, -0.1061, 1.512 and -0.09466

This trick is particularly useful when writing in R Markdown, as the generated document will look much nicer.

Another trick for the aesthetics is the report() function from the {report} package.

Similar to pander(), the report() function allows to report test results in a more readable way—but it also interprets results for you. See for example with an ANOVA:

# install.packages("remotes")
# remotes::install_github("easystats/report") # You only need to do that once
library("report") # Load the package every time you start R

report(aov(price ~ cut,
  data = dat
))

## The ANOVA (formula: price ~ cut) suggests that:
## 
##   - The main effect of cut is statistically significant and small (F(4, 53935) =
## 175.69, p < .001; Eta2 = 0.01, 95% CI [0.01, 1.00])
## 
## Effect sizes were labelled following Field's (2013) recommendations.

In addition to the p-value and the test statistic, the result of the test is displayed and interpreted for you.

Note that the report() function can be used for other analyses. See more examples in the package’s documentation.

Extract equation model with `{equatiomatic}`

If you often need to write equations corresponding to statistical models in R Markdown reports, the {equatiomatic} will help you to save time.

Here is a basic example with a simple linear regression using the same dataset as above (i.e., diamonds from {ggplot2}):

# install.packages("equatiomatic")
library(equatiomatic)

# fit a basic multiple linear regression model
model <- lm(price ~ carat,
  data = dat
)

extract_eq(model,
  use_coefs = TRUE
)

\[ \operatorname{\widehat{price}} = -2256.36 + 7756.43(\operatorname{carat}) \]

If the equation is long, you can display it on multiple lines by adding the argument wrap = TRUE:

model <- lm(price ~ carat + x + y + z + depth,
  data = dat
)

extract_eq(model,
  use_coefs = TRUE,
  wrap = TRUE,
  terms_per_line = 2
)

\[ \begin{aligned} \operatorname{\widehat{price}} &= 12196.69 + 10615.5(\operatorname{carat})\ - \\ &\quad 1369.67(\operatorname{x}) + 97.6(\operatorname{y})\ + \\ &\quad 64.2(\operatorname{z}) - 156.62(\operatorname{depth}) \end{aligned} \]

Note that:

If you use it in R Markdown, you need to add results = 'asis' for that specific code chunk, otherwise the equation will be rendered as a LaTeX equation
At the time of writing, it works only for PDF and HTML output and not for Word
The default number of terms per line is 4. You can change that with the terms_per_line argument
{equatiomatic} supports output from logistic regression as well. See all supported models in the vignette
If you need the theoretical model without the actual parameter estimates, remove the use_coefs argument:

extract_eq(model,
  wrap = TRUE
)

\[ \begin{aligned} \operatorname{price} &= \alpha + \beta_{1}(\operatorname{carat}) + \beta_{2}(\operatorname{x}) + \beta_{3}(\operatorname{y})\ + \\ &\quad \beta_{4}(\operatorname{z}) + \beta_{5}(\operatorname{depth}) + \epsilon \end{aligned} \]

In that case, I prefer to use $\beta_0$ as intercept instead of $\alpha$. You can change that with the intercept = "beta" argument:

extract_eq(model,
  wrap = TRUE,
  intercept = "beta"
)

\[ \begin{aligned} \operatorname{price} &= \beta_{0} + \beta_{1}(\operatorname{carat}) + \beta_{2}(\operatorname{x}) + \beta_{3}(\operatorname{y})\ + \\ &\quad \beta_{4}(\operatorname{z}) + \beta_{5}(\operatorname{depth}) + \epsilon \end{aligned} \]

Print model’s parameters

Thanks to the print_html() and model_parameters() functions from the {parameters} packages, you can print a summary of a model in a nicely formatted way to make the output more readable in your HTML file. See for instance with the multiple linear regression presented above:

library(parameters)
library(gt)

print_html(model_parameters(model, summary = TRUE))

Parameter	Coefficient	SE	95% CI	t(53934)	p
(Intercept)	12196.69	367.64	(11476.10, 12917.27)	33.18	< .001
carat	10615.50	63.81	(10490.43, 10740.56)	166.37	< .001
x	-1369.67	43.48	(-1454.89, -1284.45)	-31.50	< .001
y	97.60	25.76	(47.10, 148.10)	3.79	< .001
z	64.20	44.75	(-23.51, 151.91)	1.43	0.151
depth	-156.62	5.38	(-167.16, -146.09)	-29.13	< .001
Model: price ~ carat + x + y + z + depth (53940 Observations) Residual standard deviation: 1512.175 (df = 53934) R2: 0.856; adjusted R2: 0.856

Pipe operator `%>%`

If you are using the {dplyr}, {tidyverse} or {magrittr} packages often, here is a shortcut for the pipe operator %>%:

command + Shift + M on Mac
Ctrl + Shift + M on Windows

Others

Similar to many other programs, you can also use:

command + Shift + N on Mac and Ctrl + Shift + N on Windows to open a new R Script
command + S on Mac and Ctrl + S on Windows to save your current script or R Markdown document

Conclusion

Thanks for reading.

I hope you find these tips and tricks useful. If you are using others, feel free to share them in the comment section. See this starting guide in R Markdown if you are not familiar with it.

As always, if you have a question or a suggestion related to the topic covered in this article, please add it as a comment so other readers can benefit from the discussion.

R Markdown on Stats and R

Getting started in R markdown

R Markdown: what, why and how?

Before you start

Components of a .Rmd file

YAML header

Code chunks

Text

Code inside text

Highlight text like it is code

Images

Tables

Additional notes and useful resources

Conclusion

RStudio addins, or how to make your coding life easier?

What are RStudio addins?

Installation

Addins

Esquisse

ggThemeAssist

Questionr

Recoding factors

Reordering factors

Categorize a numeric variable

Remedy

Styler

Snakecaser

ViewPipeSteps

Ymlthis

Reprex

Blogdown

Conclusion

Tips and tricks in RStudio and R Markdown

Run code

Insert a comment in R and R Markdown

Knit a R Markdown document

Code snippets

Ordered list in R Markdown

New code chunk in R Markdown

Reformat code

RStudio addins

{pander} and {report} for aesthetics

Extract equation model with {equatiomatic}

Print model’s parameters

Pipe operator %>%

Others

Conclusion

Components of a `.Rmd` file

`{pander}` and `{report}` for aesthetics

Extract equation model with `{equatiomatic}`

Pipe operator `%>%`