I'm writing my results (both text and tables) and the process is quite time-consuming...
I was wondering if a function in R could help me paste my results into the text so I could copy it into WORD?
For example:
R square = put number here, B = put number here... The difference between the models was significant/nonsignificant with p < put number here
Then I would love to paste it into WORD.
Best regards,
Daniel
Couldn't find any function that would help me... Tried Flextable...
If I understand the question correctly, this can largely be done in base R and reported with R Markdown or Quarto. You can either write the document as a .qmd or .rmd file and export to word, or simply render in RStudio and then copy and paste as you like.
I work the following way:
First assign the models to variables using <-.
Then examine the structure of the model with str().
In the text of the document, use $ with the variable name to access the various parts. Or paste it in the console for cut and paste of the values.
You may want to round() some numbers. Additionally, the function scales::pvalue() is very helpful for p values.
library(scales)
# Generate some model and assign it to a variable
model <- cor.test(cars$speed, cars$dist)
# Examine the structure of the model object
str(model)
Then in the text of an R markdown or Quarto document you can write:
$r$(`r model$parameter`) = `r round(model$estimate, digits = 2)`, $p$= `r pvalue(model$p.value, accuracy = 0.05)`
This will give the following: r(48) = 0.81, p= <0.05
In a code chunk $ is used to access a component. In text $ is used to start an equation. That can be confusing. To access a piece of R code in R Markdown text, use the convention `r <function or variable>` as in `r model$parameter` above. Alternatively, you can simply paste model$parameter into the console and copy the results to your target document.
You could knit the document to word, here's a quick example using inline R:
---
title: "test.Rmd"
output: word_document
---
``` {r, echo = FALSE}
# some variables
a <- 24
b <- 100
```
R square = `r a`, B = `r b` ... The difference between the models was `r if (a == 24) {"significant"} else {"insignificant"}` with p < `r b - a`
Related
I am doing homework (yes) but this question is about the R Markdown I am using to render the answers, rather than the homework question itself. I hope that's fine.
When I use code chunks inside a ordered list (the problems are numbered so almost everything is in numbered lists), then ordered list items after it are rendered verbatim (so inline equations are rendered like: $\beta_0$ instead of showing the symbols) and don't wrap even though I have tidy=TRUE and width.cutoff set to 50. They run right off the page. They also aren't indented, which makes it further clear that they aren't getting evaluated as ordered list items. The width.cutoff option works for the code chunks but not for the ordered list items, for some reason. I can't find this error anywhere else online. I found these questions:
How to wrap code and the output in markdown (.Rmd)
knitr: How to prevent text wrapping in output?
In R markdown in RStudio, how can I prevent the source code from running off a pdf page?
but they all just seem to tell me to play with the width or width.cutoff options, which I have already done and aren't working. I attach some test code below and a screenshot of what the pdf comes out to be(link to disappointing image). As you can see, the a. part comes out fine, but b, c, and sub-questions do not. In the larger file, the top-level numbered list also has this problem. If anyone has any ideas please let me know.
Also, I don't know if this is important, but these lines show in RStudio in blue, unless I add another line break before them, in which case they turn back to black and thereafter alternate between blue and black. But the color doesn't seem to matter, they still get rendered the same way in the same place. I've tried double spaces at the ends of the previous lines, no change. The only thing that makes them not render as verbatim is to delete the new lines before them and allow them to be right next to the text line above them, but since they aren't indented this makes them look like they're part of the previous question and is problematic for reading. Thank you in advance for any help!
---
title: "TestThing"
output:
pdf_document:
latex_engine: xelatex
header-includes:
- \usepackage{amsmath,amsthm,amssymb,graphicx,epstopdf}
---
```{r echo=FALSE, warning=FALSE}
library(knitr)
library(foreign)
library(car)
library(xtable)
library(plyr)
library(reshape2)
```
```{r set-options, echo=FALSE, cache=FALSE}
options(width=50)
opts_chunk$set(comment = "", warning = FALSE, message = FALSE, echo = TRUE, tidy = TRUE, size="small", width.cutoff=50)
```
3. Problem 3
(a) Some amount of text.
Solving for $\hat{\beta}$:
\begin{equation}
\begin{aligned}
(y-X\hat{\beta})'(y-X\hat{\beta}) &= y'y - \hat{\beta}'X'y - y'X\hat{\beta} + \hat{\beta}'X'X\hat{\beta} \\
... \\
\hat{\beta} &= (X'X)^{-1}(X'y)
\end{aligned}
\end{equation}
This solution is well-defined if there is no perfect collinearity among variables (that is, __X__ has full rank).
(b) Text long enough to show that it runs off the page. Why would it do that? After all the width options I set for it... Show that the conditional expectation function yadda yadda etc. etc..
The Zero Conditional Mean Assumption sucks. Since the fitted value $\hat{y}$ is created using OLS estimation and $\hat{y} = X\beta$, E[y|X] = $X\beta$ when the Zero Conditional Mean assumption holds.
(c) Express the values in terms of things.
a. Express the values in terms of the conditional expectations of X and Y:
B = E[Y|X=1]
C = E[Y|X=0]
D = B-C = unit change in Y per increase of 1 in X
b. Express the values in terms of $\beta_0$ and $\beta_1$:
B = $\beta_0 + \beta_1$
C = $\beta_0$
D = $\beta_1$
c. Use the data to estimate B, C, D, $\beta_0$ and $\beta_1$:
```{r echo=FALSE, results="asis"}
datathing <- data.frame(X=c(0,0,1,1), Y=c(1,3,5,7))
print(xtable(summary(lm(datathing$Y ~ datathing$X))), comment=FALSE)
```
B = $\beta_0 + \beta_1$ = 2 + 4 = 6
C = $\beta_0$ = 2
D = $\beta_1$ = 4
I'm new to R and I'm really liking the flexibility of R Markdown to create reports.
My problem is that I want to use a random number generating function I've created my tables. I want simple tables to include string headers and the following function:
> ran<-function(x){
+ x<-runif(n=1, min=13.5,max=15.5)
+ round(x, digits=2)}.
It won't allow me to create a table using this method?
```{r}
String |String |String
-------|------|------
ran(x)|ran(x)|ran(x)
```
My ultimate goal is to create practice worksheets with simple statistics that will be different but within a bounded integer range - so I can ask follow-up questions with some idea of the mean, median etc.
Any help would be greatly appreciated.
Perhaps you should read up on both how to build working R code and how to code up Rmd files since your function doesn't work and there are a few places in the R Markdown docs that show how to do this:
---
output: html_document
---
```{r echo=FALSE}
ran <- function(x) {
runif(n=1, min=13.5, max=15.5) + round(x, digits=2)
}
```
One |Two |Three
-----------|-------------|-----------
`r ran(2)` | `r ran(3)` | `r ran(4)`
`r ran(2)` | `r ran(3)` | `r ran(4)`
`r ran(2)` | `r ran(3)` | `r ran(4)`
`r ran(2)` | `r ran(3)` | `r ran(4)`
generates:
Also, neither SO nor RStudio charges extra for spaces in code blocks. It'd be good to show students good code style while you're layin' down stats tracks.
Here is an approach that automates much of the report generation and reduces the amount of code you need to type. For starters, you can turn this into a parameterized report, which would make it easier to create worksheets using different values of x. Here's an example:
In your rmarkdown document you would declare parameters x and n in the yaml header. n is the number of random values you want to produce for each value of x. The x and n values in the yaml header are just the defaults knitr uses if no other values are input when you render the report:
---
output: html_document
params:
x: !r c(1,5,10)
n: 10
---
Then, in the same rmarkdown document you would have the text and code for your worksheet. You access the parameters x and n with params$x and params$n, respectively.
For example, the rest of the rmarkdown document could look like the code below. We put x into a list called x_vals with named elements, so that the resulting column names in the output will be the names of the list elements. We feed that list to sapply to get a column of n random values for each value of x. The whole sapply statement is wrapped in kable, which produces a table in rmarkdown format.
```{r, include=FALSE}
library(knitr)
```
```{r, echo=FALSE}
# Create a named list of the x values that we passed into this document
x_vals = as.list(setNames(params$x, paste0("x=", params$x)))
kable(sapply(x_vals, function(i) round(runif(params$n, 13.5, 15.5) + i, 2)))
```
You can now click the "knit" button and it will produce a table using the default parameter values:
If instead you want to use different values for x and/or n, open a separate R script file and type the following:
rmarkdown::render("Worksheet.Rmd",
params = list(x = c(2,4,6,8),
n = 5),
output_file="Worksheet.html")
In the code above, the render function compiles the rmarkdown document we just created, but with new x and n values, and saves the output to a file called Worksheet.html. (I've assumed that we've saved the rmarkdown document to a file called Worksheet.Rmd.) Here's what the output looks like:
You can also, of course, add parameters for the lower and upper limits of the runif function, rather than hard-coding them as 13.5 and 15.5.
If you want to create several worksheets, each with different x values, you can put render in a loop:
df = expand.grid(1:3,5:6,10:11)
for (i in 1:nrow(df)) {
rmarkdown::render("Worksheet.Rmd",
params = list(x=unlist(df[i,]), n=10),
output_file=paste0(paste(unlist(df[i,]),collapse="_"),".html"))
}
I am trying to write a vignette based on some example data included with my package. I want the vignette to be as robust as possible to minor changes in example dataset -- for example an id changing.
What I was hoping to do is to define the ids in a hidden code chunk:
<<echo=FALSE, results=hide>>=
ex_id <- functionToGetID() ## Let's assume it returns 1.
#
Then use that variable to insert into functions later in the document. Something like:
<<>>=
someFunction(id = get("ex_id"))
#
The goal is for the text in the vignette to show:
someFunction(id = 1) ## and NOT someFunction(id = get("ex_id"))
I am not sure how to inject a variable into the code chunk, such that the LaTeX result only shows the value of the variable, and not how the variable was called.
Is there a standard way to include the computed values from variables early on in the written knitr report before those values are computed in the code itself? The purpose is to create an executive summary at the top of the report.
For example, something like this, where variable1 and variable2 are not defined until later:
---
title: "Untitled"
output: html_document
---
# Summary
The values from the analysis are `r variable1` and `r variable2`
## Section 1
In this section we compute some values. We find that the value of variable 1 is `r variable1`
```{r first code block}
variable1 <- cars[4, 2]
```
## Section 2
In this section we compute some more values. In this section we compute some values. We find that the value of variable 2 is `r variable2`
```{r second code block}
variable2 <- cars[5, 2]
```
A simple solution is to simply knit() the document twice from a fresh Rgui session.
The first time through, the inline R code will trigger some complaints about variables that can't be found, but the chunks will be evaluated, and the variables they return will be left in the global workspace. The second time through, the inline R code will find those variables and substitute in their values without complaint:
knit("eg.Rmd")
knit2html("eg.Rmd")
## RStudio users will need to explicitly set knit's environment, like so:
# knit("eg.Rmd", envir=.GlobalEnv)
# knit2html("eg.Rmd", envir=.GlobalEnv)
Note 1: In an earlier version of this answer, I had suggested doing knit(purl("eg.Rmd")); knit2html("eg.Rmd"). This had the (minor) advantage of not running the inline R code the first time through, but has the (potentially major) disadvantage of missing out on knitr caching capabilities.
Note 2 (for Rstudio users): RStudio necessitates an explicit envir=.GlobalEnv because, as documented here, it by default runs knit() in a separate process and environment. It default behavior aims to avoid touching anything in global environment, which means that the first run won't leave the needed variables lying around anywhere that the second run can find them.
Here is another approach, which uses brew + knit. The idea is to let knitr make a first pass on the document, and then running it through brew. You can automate this workflow by introducing the brew step as a document hook that is run after knitr is done with its magic. Note that you will have to use brew markup <%= variable %> to print values in place.
---
title: "Untitled"
output: html_document
---
# Summary
The values from the analysis are <%= variable1 %> and
<%= variable2 %>
## Section 1
In this section we compute some values. We find that the value of variable 1
is <%= variable1 %>
```{r first code block}
variable1 = cars[6, 2]
```
## Section 2
In this section we compute some more values. In this section we compute
some values. We find that the value of variable 2 is <%= variable2 %>
```{r second code block}
variable2 = cars[5, 2]
```
```{r cache = F}
require(knitr)
knit_hooks$set(document = function(x){
x1 = paste(x, collapse = '\n')
paste(capture.output(brew::brew(text = x1)), collapse = '\n')
})
```
This has become pretty easy using the ref.label chunk option. See below:
---
title: Report
output: html_document
---
```{r}
library(pixiedust)
options(pixiedust_print_method = "html")
```
### Executive Summary
```{r exec-summary, echo = FALSE, ref.label = c("model", "table")}
```
Now I can make reference to `fit` here, even though it isn't yet defined in the script. For example, a can get the slope for the `qsec` variable by calling `round(coef(fit)[2], 2)`, which yields 0.93.
Next, I want to show the full table of results. This is stored in the `fittab` object created in the `"table"` chunk.
```{r, echo = FALSE}
fittab
```
### Results
Then I need a chunk named `"model"` in which I define a model of some kind.
```{r model}
fit <- lm(mpg ~ qsec + wt, data = mtcars)
```
And lastly, I create the `"table"` chunk to generate `fittab`.
```{r table}
fittab <-
dust(fit) %>%
medley_model() %>%
medley_bw() %>%
sprinkle(pad = 4,
bg_pattern_by = "rows")
```
I work in knitr, and the following two-pass system works for me. I have two (invisible) code chunks, one at the top and one at the bottom. The one at the bottom saves the values of any variables I need to include in the text before they are actually computed in a file (statedata.R). The top chunk sets the variable values to something that stands out if they haven't been defined yet, and then (if it exists) it grabs the actual values from the stored file.
The script needs to be knit twice, as values will be available only after one pass through. Note that the second chunk erases the saved state file at the end of the second pass, so that any later changes to the script that affect the saved variables will have to be computed anew (so that we don't accidentally report old values from an earlier run of the script).
---
title: "Untitled"
output: html_document
---
```{r, echo=FALSE, results='hide'}
# grab saved computed values from earlier passes
if (!exists("variable1")) {
variable1 <- "UNDEFINED"
variable2 <- "UNDEFINED"
if (file.exists("statedata.R")) {
source("statedata.R")
}
}
# Summary
The values from the analysis are `r variable1` and `r variable2`
## Section 1
In this section we compute some values. We find that the value of variable 1 is `r variable1`
```{r first code block}
variable1 <- cars[4, 2]
```
## Section 2
In this section we compute some more values. In this section we compute some values. We find that the value of variable 2 is `r variable2`
```{r second code block}
variable2 <- cars[5, 2]
```
```{r save variables for summary,echo=FALSE,results='hide'}
if (!file.exists("statedata.R")) {
dump(c("variable1","variable2"), file="statedata.R")
} else {
file.remove("statedata.R")
}
```
Latex macros can solve this problem. See this answer to my related question.
\newcommand\body{
\section{Analysis}
<<>>=
x <- 2
#
Some text here
} % Finishes body
\section*{Executive Summary}
<<>>=
x
#
\body
I use Rstudio to create my .Rmd documents, in order to combine the markdown ease-of-use with some neat equation support.
I mainly use the inline code syntax `r bla` for evaluation of arguments in an equation (between $...$) in my .Rmd documents. The problem is that if a result is transformed in the scientific notation, it just screws up the entire equation, which is not displayed correctly:
```{r}
bla = 123456789
bli = 2
```
$$
B = `r bli`
$$
$$
B = `r bla`
$$
You can redefine the inline hook so that numbers can be formatted using LaTeX notation:
knit_hooks$set(inline = function(x) {
if (is.numeric(x)) knitr:::format_sci(x, 'latex') else x
})
(Put this inside your Rmd document)