I have added a big PNG (tall, with similar aspect ratio to A4 paper) image in my rmd between two paragraphs using the following chunk (caption was made that way since it will include citations):
(ref:cap-etlm) The ETLM.
```{r etlm, results = "asis", echo = FALSE, fig.cap = "(ref:cap-etlm)", out.width='\\textwidth'}
include_graphics("figures/etlm.png")
````
The problem is, when generating a pdf output, the previous page becomes sparse, with many empty lines (shown with red lines):
This (could) also be the case if the image didn't take the whole page, but was large enough.
How can I let some of the text (that, in the rmd, have been written after the chunk/its reference) appear before the image?
Thanks in advance.
Edit:
This Gist is rmd of a minimal reproducible example (updated screenshot). It also requires csl files, etc., which are in a zip file here on TinyUpload.
Your file template.tex contains the following lines:
\usepackage{float}
\floatplacement{figure}{H}
This forces LaTeX to place figures always HERE, i.e. where they are defined. Removing these two lines solves the problem for me.
Related
I have a series of .png images that I would like to add notes to in an Rmarkdown document that I am knitting to a .pdf. The basic code for each image looks like this:
```{r certs_coefplot, out.width="100%", fig.cap=fig.4_cap}
knitr::include_graphics("certs_coefplot.png")
```
With beamer slides, I have just inserted some basic latex like this:
\tiny \emph{Notes}: Put Notes here \normalsize
below each code chunk.
But if I try this in the context of a larger document, the notes do not appear below the figure.
A solution involving a custom hook was proposed to a similar question asked here about adding notes to figures in an .Rnw file. In particular, the version where you put the code for the hook at the beginning and then write:
notes = "Notes to explain the plot"
sources = "Explain the sources"
in each chunk seems really convenient.
Is it possible to apply a similar solution an RMarkdown file?
I am combining several .Rmd-files into one large document using bookdown. The individual files all contain footnotes, starting with ^[1]. This obviously leads to duplicate footnotes in the final document, with bookdown unable to assert which reference belongs to which footnote.
As a consequence, I am wondering whether there is a way to dynamically generate footnotes when the document is rendered, but I could not find anything related to that in the bookdown docs.
I have this working solution using a custom function:
---
title: "Untitled"
output:
html_document:
---
```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
footnote.nr <- 0
footnote.counter <- function(){
footnote.nr <- footnote.nr + 1
.GlobalEnv$footnote.nr <- footnote.nr
return(footnote.nr)
}
```
Lorem ipsum.[^`r footnote.counter()`]
[^`r footnote.nr`]: Test
Lorem ipsum.[^`r footnote.counter()`]
[^`r footnote.nr`]: Test2
However, this would result in me having to retrofit the entire document which would be just as much manual labor as starting footnote numbering completely anew (though it is probably less error prone). Are there any other solutions? I would also be okay with footnotes being rendered for each individual chapter, meaning that the first footnote in each chapter starts with a 1.
In my humble opinion, #jtbayly's answer is only partially correct as using Rstudio's visual editing mode can indeed prompt it to make automatic changes to your text by adding a unique identifier before the citation (ex: [^love1]).
However, that did not initially work for me, and I had to add, for each child document the following option in the yaml header :
editor_options:
markdown:
references:
prefix: "[insert the unique identifier you want for this child document]"
This should then work, and would allow you to compile multiple .Rmd files into a single large document without RMarkdown/Pandoc messing with the citations. However, don't forget to go back to "Source" mode and "Visual" mode once after editing the yaml header for the editor to make the change.
Another option is to use Rstudio to edit your files, and turn on visual editing. If you do, it will make some automatic changes to your text, including giving your footnotes unique names.
Based on the answer to this question, I was able to get 2-column papaja with listings wrapping (rather than overflowing column width). But the listings package turns off various features that help code listings and R output stand out relative to the main text.
A simple solution would be if I could globally change the font faces and/or sizes selectively for code and R output. Is there a way to do that in papaja? I haven't been able to figure this out from papaja or Rmarkdown documentation. Thank you!
When you use the listings package in a papaja (or bookdown) document, what is technically happening is that all code is wrapped into an lstlisting LaTeX environment that comes with its own capabilities of customizing code appearance. Hence, you don't see the syntax highlighting that you would otherwise see if you would not use the listings package. The documentation of the listings package with instructions how to style your code can be found here.
To make use of this, you can extend the YAML header of your papaja document like this:
documentclass : "apa6"
classoption : "jou"
output :
papaja::apa6_pdf:
pandoc_args: --listings
header-includes:
- \lstset{breaklines=true,language=R,basicstyle=\tiny\ttfamily,frame=trB,commentstyle=\color{darkgray}\textit}
Here, I first specify the code's language, and use a tiny monospace font. With frame, I add a frame around the code block, and with commentstyle I set comments in italic and gray.
I am producing a Tutorial Workbook for my class using bookdown. I have a large class (500+), and so have a couple of other people helping me with the course.
So I would like to produce the answers for these tutorial questions.
I can produce a whole new document... but then it would be tricky to (automatically) cross-reference the exercise numbers.
So I wondered: Is there a way to password-protect a single page, or a single chapter, in bookdown? (Thinking HTML here; in PDF I can just not include that page/chapter.)
Is this possible? If so how? If not... any other ideas...?
P.
This solution does not use a password, but since you say that for PDF you can simply distribute a version that does not include the material in question, perhaps the following simple approach might help
Inspired by this question on how to conditionally input material as well as the option to use parameters in Rmarkdown, consider two Rmarkdown files:
main.Rmd, which contains what you want to show everyone.
protected.Rmd, which should only be shown to some people.
These files look as follows:
main.Rmd:
---
output: html_document
params:
include:
label: "Include extra material?"
value: ""
input: select
choices: [True, False]
---
```{r, include=FALSE}
print(params)
show_all <- as.logical(params$include)
```
```{r conditional_print, child="protected.Rmd", eval = show_all}
```
protected.Rmd:
Hello World!
Assuming you are in RStudio, if you choose "Knit with parameters" on main.Rmd, you will be asked to select either TRUE or FALSE from an interactive dropdown. If and only if you choose TRUE, the output will include "Hello World". More generally, code blocks with eval = show_all will only be displayed when selecting to include extra material. Therefore, you can of course have multiple sections (each contained in a separate .Rmd file) that are only conditionally included.
In this way, you could knit the same document twice: once with questions only, and once with questions and answers both. Since this is the same for both pdf and html, it also gives you a consistent workflow for both of these output types.
I teach an introductory statistics course using R Markdown in RStudio (Server). We have students knit to html_notebooks, and we often have them use inline code to report various elements of their statistical analyses. It'd be really helpful for grading purposes if we could have the result of inline code output in a different color -- that way we could easily see if they were indeed using inline code or if they copy-pasted a number from their output into raw text.
There's a couple of ideas for solutions posted here, but these won't super work in my case. These are introductory students who are generally kinda afraid of RStudio to begin with, so asking them to do anything complicated with text_spec or sprintf will likely cause mild riots. I really need something that won't change students' workflow at all.
I wonder if there's any way to configure things either on the backend in RStudio Server (maybe by messing with knitr?), or through some kind of <style> tag wizardry in the preamble, so that inline code will print its results in a different color.
Thanks!
EDIT: Arthur Berg below has provided something that's almost exactly what I need. Here's a MWE:
---
title: "test knit_hook"
output: html_document
---
```{r, setup, include="FALSE"}
knitr::knit_hooks$set(inline=function(x){paste0("<span style=\"color: #0000FF;\">",
x,"</span>")})
```
`r pi`
The only issue with this is that it doesn't work if I change to html_notebook in the YAML header and thus use the "Preview" button in the RStudio IDE. For external reasons, it's important for us to have the output type as html_notebook. Anyone know how we might modify this to get it to work with html_notebook?
A way to achieve this without changing the workflow too much is to create your own format (e.g. html_notebook2) that is derived from the original but modifies the inline hook of knitr.
To get started you can check out this document.
Basic steps include
Create a new R package
Within this project run usethis::use_rmarkdown_template(). This creates the folder structure for your new format.
Edit skeleton.rmd and template.yaml
Define your format in a R file which has the same name html_notebook2.R(kind of a convention).
The content of the html_notebook2.R file could be
#'#import knitr
set_hooks <- function() {
default_hooks <- knit_hooks$get()
list(
inline = function(x) {
paste0("<span style=\"color: #FF0000;\">", x,"</span>")
})
}
#' #importFrom rmarkdown output_format knitr_options pandoc_options html_notebook
#' #export
html_notebook2 = function() {
output_format(
knitr = knitr_options(knit_hooks = set_hooks()),
pandoc = pandoc_options(to = "html"),
clean_supporting = FALSE,
base_format = html_notebook()
)
}
In the first part we define a new inline hook which only changes the font color.
The second part is the definition of the new format.
After building and installing the package you can create a new rmarkdown document and use output: packagename::html_notebook2 as the output format. All inline code output will be colored red using my code. Here is an example:
---
title: "Inline"
output: cformat::html_notebook2
---
## R Markdown
`r pi`
I created such a package and you can find it on GitHub. Feel free to copy it and rename it (cformat is a pretty lame working title ;) ).
Notice though that your students could change the color manually using HTML/CSS anyways. A way around could be some kind of key generation using a certain rule (unknown to the students obviously). For each inline chunk a key is generated and embedded using
paste0("<span code=", key," style=\"color: #FF0000;\">", x,"</span>")
If a valid key is embedded, the output was generated using R and not simply copied.
For those looking for a fix to a simple R markdown document, adding this line changes the inline output to blue.
knitr::knit_hooks$set(inline=function(x){paste0("<span style=\"color: #0000FF;\">", x,"</span>")})