R Markdown #

Including custom styles is achieved in two steps:

1. Modifying the YAML header as such

output:
  beamer_presentation:
    includes:
      in_header: styles/styles.tex

1. Creating a .tex file in our project in the directory slides/styles.tex

These few commands (written in your LaTeX file) will allow you to make a few changes to your slides:

• Add custom colours and themes to your slides
• Go to the Beamer gallery to find themes and colours you like!

\usetheme{THEME_NAME}
\usecolortheme{COLOUR_THEME_NAME}

• Add slide numbers to your slides

\setbeamertemplate{navigation symbols}{}
\setbeamertemplate{footline}[page number]

Controlling Chart Output #

LinkedIn Learning 6.1 - 6.3

• We produce graphs in R Markdown by putting the relevant code in code chunks and then running them
• This works with normal code and ggplot2 code

# Base R plot
x = seq(-5,5,0.1)
y = x^2
plot(x,y)

# ggplot2 plot
library("tidyverse")

load("tidy_EnvAcc_data/consumption.rdata")
consumption %>%
  ggplot() +
  geom_col(aes(x = year,
               y = water_consumption,
               fill = State))

fig.width and fig.height can only take numeric arguments, and one or both can be specified. Measurements are in inches. Generally used for PDF.

fig.width and fig.asp (also numeric, often between 0 and 1) can both be specified, and figure height will be determined based on fig.asp.

out.width and out.height can take several arguments. Generally we use a character string to specify percentage or pixel measurement (eg out.width = “40%” or out.width = “480px”). However, out.height cannot overwrite the aspect ratio, and so it has limited usefulness.

Take note that these options can take some special LaTeX arguments as well. See here under “out.width, out.height”.

Of course, all chunk options can also be modified globally.

Images and R Markdown #

Images with Knitr #

LinkedIn Learning 7.1

If you know the directory to your image, you can use include_graphics() from the knitr package to output the image as a figure. It will be responsive to chunk figure options.

knitr::include_graphics("images/Rlogo.svg")

Images with Raw HTML #

LinkedIn Learning 7.2

Keep in mind: HTML images (that is, images included using this html code) can only be inserted into HTML documents.

With even no understanding of HTML, inserting images is very simple. HTML can be pasted directly into an R Markdown file.

src specifies the file path of the image.

<img src = "images/Rlogo.svg" width = "20%">

The image can easily be centred with the centre tag.

<center> <img src = "images/Rlogo.svg" width = "20%"> </center>

HTML images are extremely tweakable, but require knowledge of HTML!

Images with Raw LaTeX #

LinkedIn Learning 7.3

Keep in mind: LaTeX insertion can only be done in PDF documents.

LaTeX insertion, like HTML, is relatively simple to use. With LaTeX knowledged, images become extremely tweakable. This LaTeX can be pasted directly into an R Markdown script and run.

The argument in curly brackets specifies the file path of the image.

\includegraphics{images/Rlogo.JPG}

We can adjust the size using some LaTeX as well.

\includegraphics[width = 5cm]{images/Rlogo.JPG}

Tables #

LinkedIn Learning 8.1

We can display tables in R Markdown in two ways.

1. As an R Markdown formatted table
2. As the output from code

The first option is fixed: there is only one method for creating R Markdown formatted tables. However, code output can be configured in several ways.

R Markdown Formatted Tables #

LinkedIn Learning 8.2

Let’s consider a table and how it is formatted. The following table describes the capabilities of HTMLwidgets packages in R:

• Formatting tables relies heavily on the vertical bar (|) key
• First we write the column headings
• Then we specify the alignment of column words
• Lastly we fill our final rows with data

Using our example, the first line of the table looks like this:

| Library | Charts | Maps | Networks | Tables |

• We simply separate our column headings with bars

Our second line will have the same number of entries as our table above, spaced with bars. In each entry we type one of:

• :-: (centre text for the column)
• :- (text wraps left)
• -: (text wraps right)

In our example, the “Library” column wraps left, and the remaining table entries are cetred, so our second line looks like this:

| :- | :-: | :-: | :-: | :-: |

We then simply enter our data, spacing with bars. The whole table looks like this:

| Library | Charts | Maps | Networks | Tables |
| :- | :-: | :-: | :-: | :-: |
| DT | No | No | No | Yes |
| Highcharter | Yes | Yes | No | No |
| Leaflet | No | Yes | No | No |
| Plotly | Yes | Yes | No | No |
| visNetwork | No | No | Yes | No |

Kable Tables and other tables #

LinkedIn Learning 8.3 - 8.5,

We can print out tables using R code in R Markdown. consumption is a tibble created using the Tidyverse package:

head(consumption)

## # A tibble: 6 x 3
##   State year    water_consumption
##   <chr> <chr>               <dbl>
## 1 NSW   2008–09              4555
## 2 VIC   2008–09              2951
## 3 QLD   2008–09              3341
## 4 SA    2008–09              1179
## 5 WA    2008–09              1361
## 6 TAS   2008–09               466

We can also use the kable() function from knitr to print tables that appear to be much nicer in R Markdown. We simply pipe our data through the function:

head(consumption) %>%
  knitr::kable()

We can also customise the way these tables look if we install the kableExtra package:

library("knitr")
library("kableExtra")

head(consumption) %>%
  kable() %>%
  kable_styling(bootstrap_options = "striped")

bootstrap_options is just one modification we can make to our kable tables. See here for the full argument breakdown.

Lastly we note there is a way to make formating tables as kable tables automatic in a document. That is by modifying the YAML header. The output: html_document (etc) line should be removed and replaced with:

output:
  html_document:
    df_print: kable

Remember that indentation matters!

Note: df_print: tibble formats tables as tibbles (from the Tidyverse package) and df_print: paged formats tables as HTML tables which support pagination over rows and columns.

As one final option, the DT package is able to produce interactive tables we can use with R Markdown. Using the package, we can pipe tibbles or data.frames into the datatable() function:

library("DT")
consumption %>%
  datatable()

Captions with Bookdown #

LinkedIn Learning 9.1 and

LinkedIn Learning 9.2

Bookdown is an R package that facilitates writing books and long-form media with R Markdown. We use it for for the useful captioning solutions it provides. To use them, however, we must change our output type in the YAML header to special Bookdown outputs. One of:

• output: bookdown::pdf_document2
• output: bookdown::html_document2

For captioning figures, we use the fig.cap code chunk option as normal. This will now automatically number figures.

text <- "R Markdown is cool"
print(text)

## [1] "R Markdown is cool"

x = seq(-5,5,0.1)
y = x^2
plot(x,y)

For captioning tables, we use the caption argument of the kable function

head(consumption) %>%
  knitr::kable(caption = "Water Consumption in Australia")

For referring to figures or tables, we use the special Bookdown notation \@ref. We then specify that we are referencing either a figure or a table, and finally we specify the code chunk we are referencing. In the below examples, replace “label” with the name of the relevant code chunk.

\@ref(fig:label)
\@ref(tab:label)

Here is a reference to the above Figure 2 , and here is one to the above Table 1.

Custom Styles #

LinkedIn Learning 10.1

There are two ways to style R Markdown documents.

• HTML output types require CSS options in a .css file
  • Recall this includes html_document, bookdown::html_document2 and slidy_presentation output
• PDF output types require LaTeX options in a .tex file
  • Recall this includes pdf_document, bookdown::pdf_document2 and beamer_presentation output

Custom HTML with CSS #

LinkedIn Learning 10.2

CSS is a stylesheet language. We use it to specify the presentation of documents written in HTML or XML. It is simple to find the right code to do whatever you need, online, but we consider the basics here.

Before we format our file, we must create a new .css file. The steps to do this are:

1. In RStudio navigate File()New File()Text File
2. Save the new file to the relevant project folder
3. Name the file with the .css extension, eg styles.css

We must also specify in the YAML header that we will be using these styles in our document. We add the line:

css: styles.css

We now add to the .css file. We use CSS syntax to target parts of our document we wish to modify.

body {
  font-size: 14px; 
  font-family: "Times New Roman";
  background-color: #e0fbff;
} 

Here is an example of modifying an element of our document We type body to specify we are making changes to the main text. We open our curly brackets ({ }) and specify each option on a new line. Each line ends with a semi-colon (;). We have changed these options:

• font-size is now 14 pixels
• font-family is now in Times New Roman (ie we have changed the text font)
• background-color is now a shade of light blue selected using HTML colour codes

Of course, each element has its own options, meaning there are many, many options we can modify altogether. Here are a few in action:

Custom PDF with TeX #

LinkedIn Learning 10.3

We already know that TeX is the underlying force behind the configuration of PDF documents with R Markdown, so it’s unsurprising that we call on it for our PDF styles.

Before we format our file, we must create a new .tex file. The steps to do this are:

1. In RStudio navigate File()New File()Text File
2. Save the new file to the relevant project folder
3. Name the file with the .sty extension, eg pdf_styles.sty

We must also specify in the YAML header that we will be using these styles in our document. We add the lines:

header-includes:
  - \usepackage{"pdf_styles.sty"}

Note: if we wanted to use multiple .sty files, we can do this with:

header-includes:
  - \usepackage{"pdf_styles.sty"}
  - \usepackage{"other_styles.sty"}

It takes some knowledge of LaTeX to be able to implement options. Here are a few:

\usepackage{sectsty}            % Call on a package to modify styles

\sectionfont{\color{red}}       % Change header font
\subsectionfont{\color{blue}}   % Change subheader font

\usepackage{helvet}             % Change font type to Helvetica

Displaying Other Languages #

LinkedIn Learning 11.2

To display HTML, we simply copy some HTML into a code chunk and set the language as html. This works for other languages, including latex and markdown itself.

 

<div class="row">
  <div class="col-md-6">
    Hello
  </div>
  <div class="col-md-6">
    World!
  </div>
</div>

\usepackage{my_package}
% latex

# Example Heading

Here is an example of some text I could put in R Markdown. My **italics** and *bold* won't display in a code chunk!

See here for some other possible languages.

Calling on LaTeX in R Markdown #

LinkedIn Learning 11.3

LaTeX Code #

• If we call on LaTeX code, we can paste it directly
• R Markdown handles almost all of it fine, but not the following:

LaTeX symbol	We must write
\#	\\#
\\	\\\\

• Also if we are in a code chunk and using LaTeX, we must put a \\ before the following:
  • $, %, &, ~, _, ^, {, }

LaTeX Formatting #

To call upon (LaTeX) formatting, we have two options.

• If we wish to call on a formula in a line, we surround the line with \( and \)

\(X_{t} = \theta X_{t-1} + Z_t + \phi Z_{t-1}\)

(X_{t} = X_{t-1} + Z_t + Z_{t-1})

• We may also frame a section of LaTeX code with $$ to render entire sections of formatting

$$
\quad
\begin{pmatrix} 
12 & 4 & 1 \\
4/3 & 0.9 & e \\
\pi & 0 & 8 \\
\end{pmatrix}
\quad
$$

$$ \quad \begin{pmatrix} 12 & 4 & 1 \
4/3 & 0.9 & e \
\pi & 0 & 8 \
\end{pmatrix}` \quad $$

Calling on HTML in R Markdown #

LinkedIn Learning 11.4

Note that this is only possible in HTML document formats.

Some HTML will run fine and without the need for formatting after being pasted into R Markdown. If this is not the case, code can be framed with special “html_preserve” framing.

This is the power of HTML!

Pubishing HTML Documents to the Web #

LinkedIn Learning 13

There are two main ways to publish:

• RPubs is a free platform provided by RStudio
• GitHub Pages is a free-to-use platform, but requires knowledge of Git

Using RPubs #

1. Connect to the RPubs website and register an account

2. Click the “Publish” button from within R Studio. This can be done either from the .Rmd file or from the knitted document

3. Select “Publish”

4. Set a title, description, and choose a slug (the slug is the last part of the URL)

Your document is now public at the available URL!

---

1. Mann, H. (2019) ↩︎