2987 lines
53 KiB
Plaintext
2987 lines
53 KiB
Plaintext
#LyX 2.1 created this file. For more info see http://www.lyx.org/
|
|
\lyxformat 474
|
|
\begin_document
|
|
\begin_header
|
|
\textclass article
|
|
\begin_preamble
|
|
\renewcommand{\textfraction}{0.05}
|
|
\renewcommand{\topfraction}{0.8}
|
|
\renewcommand{\bottomfraction}{0.8}
|
|
\renewcommand{\floatpagefraction}{0.75}
|
|
|
|
\usepackage[buttonsize=1em]{animate}
|
|
\end_preamble
|
|
\use_default_options true
|
|
\begin_modules
|
|
knitr
|
|
\end_modules
|
|
\maintain_unincluded_children false
|
|
\language english
|
|
\language_package none
|
|
\inputencoding default
|
|
\fontencoding global
|
|
\font_roman palatino
|
|
\font_sans lmss
|
|
\font_typewriter lmtt
|
|
\font_math auto
|
|
\font_default_family default
|
|
\use_non_tex_fonts false
|
|
\font_sc true
|
|
\font_osf false
|
|
\font_sf_scale 100
|
|
\font_tt_scale 100
|
|
\graphics default
|
|
\default_output_format default
|
|
\output_sync 0
|
|
\bibtex_command default
|
|
\index_command default
|
|
\paperfontsize default
|
|
\spacing single
|
|
\use_hyperref true
|
|
\pdf_bookmarks true
|
|
\pdf_bookmarksnumbered true
|
|
\pdf_bookmarksopen true
|
|
\pdf_bookmarksopenlevel 2
|
|
\pdf_breaklinks false
|
|
\pdf_pdfborder false
|
|
\pdf_colorlinks false
|
|
\pdf_backref false
|
|
\pdf_pdfusetitle true
|
|
\pdf_quoted_options "pdfstartview={XYZ null null 1}"
|
|
\papersize default
|
|
\use_geometry true
|
|
\use_package amsmath 1
|
|
\use_package amssymb 1
|
|
\use_package cancel 1
|
|
\use_package esint 1
|
|
\use_package mathdots 1
|
|
\use_package mathtools 1
|
|
\use_package mhchem 1
|
|
\use_package stackrel 1
|
|
\use_package stmaryrd 1
|
|
\use_package undertilde 1
|
|
\cite_engine natbib
|
|
\cite_engine_type authoryear
|
|
\biblio_style plainnat
|
|
\use_bibtopic false
|
|
\use_indices false
|
|
\paperorientation portrait
|
|
\suppress_date false
|
|
\justification true
|
|
\use_refstyle 1
|
|
\index Index
|
|
\shortcut idx
|
|
\color #008000
|
|
\end_index
|
|
\leftmargin 2.5cm
|
|
\topmargin 2.5cm
|
|
\rightmargin 2.5cm
|
|
\bottommargin 2.5cm
|
|
\secnumdepth 2
|
|
\tocdepth 2
|
|
\paragraph_separation indent
|
|
\paragraph_indentation default
|
|
\quotes_language english
|
|
\papercolumns 1
|
|
\papersides 1
|
|
\paperpagestyle default
|
|
\tracking_changes false
|
|
\output_changes false
|
|
\html_math_output 0
|
|
\html_css_as_file 0
|
|
\html_be_strict false
|
|
\end_header
|
|
|
|
\begin_body
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<setup, include=FALSE, cache=FALSE>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
library(knitr)
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
## set global chunk options
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
opts_chunk$set(fig.path='figure/manual-', cache.path='cache/manual-', fig.align='ce
|
|
nter', fig.show='hold', par=TRUE)
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
## I use = but I can replace it with <-; set code/output width to be 68
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
options(formatR.arrow=TRUE, width=68, digits=4)
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
## tune details of base graphics (https://yihui.org/knitr/hooks)
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
knit_hooks$set(par=function(before, options, envir){
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
if (before && options$fig.show!='none') par(mar=c(4,4,.1,.1),cex.lab=.95,cex.axis=.9,mg
|
|
p=c(2,.7,0),tcl=-.3)
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
})
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Title
|
|
knitr: A General-Purpose Tool for Dynamic Report Generation in R
|
|
\end_layout
|
|
|
|
\begin_layout Author
|
|
Yihui Xie
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
The original paradigm of literate programming was brought forward mainly
|
|
for software development, or specifically, to mix source code (for computer)
|
|
and documentation (for human) together.
|
|
Early systems include
|
|
\begin_inset CommandInset href
|
|
LatexCommand href
|
|
name "WEB"
|
|
target "http://www.literateprogramming.com/web.pdf"
|
|
|
|
\end_inset
|
|
|
|
and
|
|
\begin_inset CommandInset href
|
|
LatexCommand href
|
|
name "Noweb"
|
|
target "http://www.cs.tufts.edu/~nr/noweb/"
|
|
|
|
\end_inset
|
|
|
|
; Sweave
|
|
\begin_inset CommandInset citation
|
|
LatexCommand citep
|
|
key "leisch2002"
|
|
|
|
\end_inset
|
|
|
|
was derived from the latter, but it is less focused on documenting software,
|
|
instead it is mainly used for reproducible data analysis and generating
|
|
statistical reports.
|
|
The
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
package
|
|
\begin_inset CommandInset citation
|
|
LatexCommand citep
|
|
key "R-knitr"
|
|
|
|
\end_inset
|
|
|
|
is following the steps of Sweave.
|
|
For this manual, I assume readers have some background knowledge of Sweave
|
|
to understand the technical details; for a reference of available options,
|
|
hooks and demos, see the package homepage
|
|
\begin_inset Flex URL
|
|
status collapsed
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
https://yihui.org/knitr/
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
.
|
|
\end_layout
|
|
|
|
\begin_layout Section
|
|
Hello World
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
A natural question is why to reinvent the wheel.
|
|
The short answer is that extending Sweave by hacking
|
|
\family sans
|
|
SweaveDrivers.R
|
|
\family default
|
|
in the
|
|
\series bold
|
|
utils
|
|
\series default
|
|
package is a difficult job to me.
|
|
Many features in
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
come naturally as users would have expected.
|
|
Figure
|
|
\begin_inset CommandInset ref
|
|
LatexCommand ref
|
|
reference "fig:cars-demo"
|
|
|
|
\end_inset
|
|
|
|
is a simple demo of some features of
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
.
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset Float figure
|
|
wide false
|
|
sideways false
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<cars-demo,dev='tikz',fig.width=4,fig.height=2.8,out.width='.45
|
|
\backslash
|
|
|
|
\backslash
|
|
textwidth',message=FALSE,cache=TRUE>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
fit=lm(dist~speed,data=cars) # linear regression
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
par(mar=c(4, 4, 1, .1), mgp=c(2,1,0))
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
with(cars,plot(speed,dist,panel.last=abline(fit)))
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
text(10,100,'$Y =
|
|
\backslash
|
|
|
|
\backslash
|
|
beta_0 +
|
|
\backslash
|
|
|
|
\backslash
|
|
beta_1x +
|
|
\backslash
|
|
|
|
\backslash
|
|
epsilon$')
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
library(ggplot2)
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
qplot(speed, dist, data=cars)+geom_smooth()
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
\begin_inset Caption Standard
|
|
|
|
\begin_layout Plain Layout
|
|
\begin_inset CommandInset label
|
|
LatexCommand label
|
|
name "fig:cars-demo"
|
|
|
|
\end_inset
|
|
|
|
A simple demo of possible output in
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
: (1) multiple plots per chunk; (2) no need to
|
|
\emph on
|
|
print()
|
|
\emph default
|
|
objects in
|
|
\series bold
|
|
ggplot2
|
|
\series default
|
|
; (3) device size is
|
|
\begin_inset Formula $4\times2.8$
|
|
\end_inset
|
|
|
|
(inches) but output size is adjusted to
|
|
\family typewriter
|
|
.45
|
|
\backslash
|
|
textwidth
|
|
\family default
|
|
in chunk options; (4) base graphics and
|
|
\series bold
|
|
ggplot2
|
|
\series default
|
|
can sit side by side; (5) use the
|
|
\emph on
|
|
tikz()
|
|
\emph default
|
|
device in
|
|
\series bold
|
|
tikzDevice
|
|
\series default
|
|
by setting chunk option
|
|
\family typewriter
|
|
dev='tikz'
|
|
\family default
|
|
(hence can write native LaTeX expressions in R plots); (6) code highlighting.
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
I would have chosen to hide the R code if this were a real report, but here
|
|
I show the code just for the sake of demonstration.
|
|
If we type
|
|
\emph on
|
|
qplot()
|
|
\emph default
|
|
in R, we get a plot, and the same thing happens in
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
.
|
|
If we draw two plots in the code,
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
will show two plots and we do not need to tell it how many plots are there
|
|
in the code in advance.
|
|
If we set
|
|
\family typewriter
|
|
out.width='.49
|
|
\backslash
|
|
|
|
\backslash
|
|
textwidth'
|
|
\family default
|
|
in chunk options, we get it in the final output document.
|
|
If we say
|
|
\family typewriter
|
|
fig.align='center'
|
|
\family default
|
|
, the plots are centered.
|
|
That's it.
|
|
Many enhancements and new features will be introduced later.
|
|
If you come from the Sweave land, you can take a look at the page of transition
|
|
first:
|
|
\begin_inset Flex URL
|
|
status collapsed
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
https://yihui.org/knitr/demo/sweave/
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
.
|
|
\end_layout
|
|
|
|
\begin_layout Section
|
|
Design
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
The flow of processing an input file is similar to Sweave, and two major
|
|
differences are that
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
provides more flexibility to the users to customize the processing, and
|
|
has many built-in options such as the support to a wide range of graphics
|
|
devices and cache.
|
|
Below is a brief description of the process:
|
|
\end_layout
|
|
|
|
\begin_layout Enumerate
|
|
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
takes an input file and automatically determines an appropriate set of
|
|
|
|
\begin_inset CommandInset href
|
|
LatexCommand href
|
|
name "patterns"
|
|
target "https://yihui.org/knitr/patterns/"
|
|
|
|
\end_inset
|
|
|
|
to use if they are not provided in advance (e.g.
|
|
|
|
\family sans
|
|
file.Rnw
|
|
\family default
|
|
will use
|
|
\family typewriter
|
|
knit_patterns$get('rnw')
|
|
\family default
|
|
);
|
|
\end_layout
|
|
|
|
\begin_layout Enumerate
|
|
a set of output
|
|
\begin_inset CommandInset href
|
|
LatexCommand href
|
|
name "hooks"
|
|
target "https://yihui.org/knitr/hooks/"
|
|
|
|
\end_inset
|
|
|
|
will also be set up automatically according to the filename extension (e.g.
|
|
use LaTeX environments or HTML elements to wrap up R results);
|
|
\end_layout
|
|
|
|
\begin_layout Enumerate
|
|
the input file is read in and split into pieces consisting of R code chunks
|
|
and normal texts; the former will be executed one after the other, and
|
|
the latter may contain global chunk options or inline R code;
|
|
\end_layout
|
|
|
|
\begin_layout Enumerate
|
|
for each chunk, the code is evaluated using the
|
|
\series bold
|
|
evaluate
|
|
\series default
|
|
package
|
|
\begin_inset CommandInset citation
|
|
LatexCommand citep
|
|
key "R-evaluate"
|
|
|
|
\end_inset
|
|
|
|
, and the results may be filtered according to chunk options (e.g.
|
|
|
|
\family typewriter
|
|
echo=FALSE
|
|
\family default
|
|
will remove the R source code)
|
|
\end_layout
|
|
|
|
\begin_deeper
|
|
\begin_layout Enumerate
|
|
if
|
|
\family typewriter
|
|
cache=TRUE
|
|
\family default
|
|
for this chunk,
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
will first check if there are previously cached results under the cache
|
|
directory before really evaluating the chunk; if cached results exist and
|
|
this code chunk has not been changed since last run (use MD5 sum to verify),
|
|
the cached results will be (lazy-) loaded, otherwise new cache will be
|
|
built; if a cached chunk depends on other chunks (see the
|
|
\family typewriter
|
|
dependson
|
|
\family default
|
|
|
|
\begin_inset CommandInset href
|
|
LatexCommand href
|
|
name "option"
|
|
target "https://yihui.org/knitr/options/"
|
|
|
|
\end_inset
|
|
|
|
) and any one of these chunks has changed, this chunk must be forcibly updated
|
|
(old cache will be purged)
|
|
\end_layout
|
|
|
|
\begin_layout Enumerate
|
|
there are six types of possible output from
|
|
\series bold
|
|
evaluate
|
|
\series default
|
|
, and their classes are
|
|
\family typewriter
|
|
character
|
|
\family default
|
|
(normal text output),
|
|
\family typewriter
|
|
source
|
|
\family default
|
|
(source code),
|
|
\family typewriter
|
|
warning
|
|
\family default
|
|
,
|
|
\family typewriter
|
|
message
|
|
\family default
|
|
,
|
|
\family typewriter
|
|
error
|
|
\family default
|
|
and
|
|
\family typewriter
|
|
recordedplot
|
|
\family default
|
|
; an internal S3 generic function
|
|
\emph on
|
|
wrap()
|
|
\emph default
|
|
is used to deal with different types of output, using output hooks defined
|
|
in the object
|
|
\family typewriter
|
|
knit_hooks
|
|
\end_layout
|
|
|
|
\begin_layout Enumerate
|
|
note plots are recorded as R objects before they are really saved to files,
|
|
so graphics devices will not be opened unless plots have really been produced
|
|
in a chunk
|
|
\end_layout
|
|
|
|
\begin_layout Enumerate
|
|
a code chunk is evaluated in a separate empty environment with the global
|
|
environment as its parent, and all the objects in this environment after
|
|
the evaluation will be saved if
|
|
\family typewriter
|
|
cache=TRUE
|
|
\end_layout
|
|
|
|
\begin_layout Enumerate
|
|
chunk hooks can be run before and/or after a chunk
|
|
\end_layout
|
|
|
|
\end_deeper
|
|
\begin_layout Enumerate
|
|
for normal texts,
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
will find inline R code (e.g.
|
|
in
|
|
\family typewriter
|
|
|
|
\backslash
|
|
Sexpr{}
|
|
\family default
|
|
) and evaluate it; the output is wrapped by the
|
|
\family typewriter
|
|
inline
|
|
\family default
|
|
hook;
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
The hooks play important roles in
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
: this package makes almost everything accessible to the users.
|
|
Consider the following extremely simple example which may demonstrate this
|
|
freedom:
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<simple-example>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
1+1
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
There are two parts in the final output: the source code
|
|
\family typewriter
|
|
1 + 1
|
|
\family default
|
|
and the output
|
|
\family typewriter
|
|
[1] 2
|
|
\family default
|
|
; the comment characters
|
|
\family typewriter
|
|
##
|
|
\family default
|
|
are from the default chunk option
|
|
\family typewriter
|
|
comment
|
|
\family default
|
|
.
|
|
Users may define a hook function for the source code like this to use the
|
|
|
|
\family typewriter
|
|
lstlisting
|
|
\family default
|
|
environment:
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<hook-source, eval=FALSE>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
knit_hooks$set(source = function(x, options) {
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
paste('
|
|
\backslash
|
|
|
|
\backslash
|
|
begin{lstlisting}
|
|
\backslash
|
|
n', x, '
|
|
\backslash
|
|
|
|
\backslash
|
|
end{lstlisting}
|
|
\backslash
|
|
n', sep = '')
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
})
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
Similarly we can put other types of output into other environments.
|
|
There is no need to hack at
|
|
\family sans
|
|
Sweave.sty
|
|
\family default
|
|
for
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
and you can put the output in any environments.
|
|
What is more, the output hooks make
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
ready for other types of output, and a typical one is HTML (there are built-in
|
|
hooks).
|
|
The website has provided many examples demonstrating the flexibility of
|
|
the output.
|
|
\end_layout
|
|
|
|
\begin_layout Section
|
|
Features
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
The
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
package borrowed features such as tikz graphics and cache from
|
|
\series bold
|
|
pgfSweave
|
|
\series default
|
|
and
|
|
\series bold
|
|
cacheSweave
|
|
\series default
|
|
respectively, but the implementations are different.
|
|
New features like code reference from an external R script as well as output
|
|
customization are also introduced.
|
|
The feature of hook functions in Sweave is re-implemented and hooks have
|
|
new usage now.
|
|
There are several other small features which are motivated from my everyday
|
|
use of Sweave.
|
|
For example, a progress bar is provided when knitting a file so we roughly
|
|
know how long we still need to wait; output from inline R code (e.g.
|
|
|
|
\family typewriter
|
|
|
|
\backslash
|
|
Sexpr{x[1]}
|
|
\family default
|
|
) is automatically formatted in TeX math notation (like
|
|
\begin_inset ERT
|
|
status collapsed
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
|
|
\backslash
|
|
Sexpr{123456789}
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
) if the result is numeric.
|
|
You may check out a number of specific manuals dedicated to specific features
|
|
such as graphics in the website:
|
|
\begin_inset Flex URL
|
|
status collapsed
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
https://yihui.org/knitr/demo/
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
.
|
|
\end_layout
|
|
|
|
\begin_layout Subsection
|
|
Code Decoration
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
The
|
|
\series bold
|
|
highr
|
|
\series default
|
|
package
|
|
\begin_inset CommandInset citation
|
|
LatexCommand citep
|
|
key "R-highr"
|
|
|
|
\end_inset
|
|
|
|
is used to highlight R code, and the
|
|
\series bold
|
|
formatR
|
|
\series default
|
|
package
|
|
\begin_inset CommandInset citation
|
|
LatexCommand citep
|
|
key "R-formatR"
|
|
|
|
\end_inset
|
|
|
|
is used to reformat R code (like
|
|
\family typewriter
|
|
keep.source=FALSE
|
|
\family default
|
|
in Sweave but will also try to retain comments).
|
|
For LaTeX output, the
|
|
\series bold
|
|
framed
|
|
\series default
|
|
package is used to decorate code chunks with a light gray background.
|
|
If this LaTeX package is not found in the system, a version will be copied
|
|
directly from
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
.
|
|
The prompt characters are removed by default because they mangle the R
|
|
source code in the output and make it difficult to copy R code.
|
|
The R output is masked in comments by default based on the same rationale.
|
|
It is easy to revert to the output with prompts (set option
|
|
\family typewriter
|
|
prompt=TRUE
|
|
\family default
|
|
), and you will quickly realize the inconvenience to the readers if they
|
|
want to copy and run the code in the output document:
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<stupid-prompts, prompt=TRUE, comment=NA, highlight=FALSE>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
x=rnorm(5)
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
x
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
var(x)
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
The example below shows the effect of
|
|
\family typewriter
|
|
tidy=TRUE/FALSE
|
|
\family default
|
|
:
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<tidy-no, eval=FALSE, tidy=FALSE>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
## option tidy=FALSE
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
for(k in 1:10){j=cos(sin(k)*k^2)+3;print(j-5)}
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<tidy-yes, eval=FALSE, tidy=TRUE>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
## option tidy=TRUE
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
for(k in 1:10){j=cos(sin(k)*k^2)+3;print(j-5)}
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
Note
|
|
\family typewriter
|
|
=
|
|
\family default
|
|
is replaced by
|
|
\family typewriter
|
|
<-
|
|
\family default
|
|
because
|
|
\family typewriter
|
|
options('formatR.arrow')
|
|
\family default
|
|
was set to be
|
|
\family typewriter
|
|
TRUE
|
|
\family default
|
|
in this document; see the documentation of
|
|
\emph on
|
|
tidy.source()
|
|
\emph default
|
|
in
|
|
\series bold
|
|
formatR
|
|
\series default
|
|
for details.
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
Many highlighting themes can be used in
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
, which are borrowed from the
|
|
\series bold
|
|
highlight
|
|
\series default
|
|
package by
|
|
\begin_inset CommandInset href
|
|
LatexCommand href
|
|
name "Andre Simon"
|
|
target "http://www.andre-simon.de/"
|
|
|
|
\end_inset
|
|
|
|
|
|
\begin_inset Foot
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
not the R package mentioned before; for a preview of these themes, see
|
|
\begin_inset Flex URL
|
|
status collapsed
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
http://www.andre-simon.de/dokuwiki/doku.php?id=theme_examples
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
; it is also possible to use themes from
|
|
\begin_inset Flex URL
|
|
status collapsed
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
http://www.eclipsecolorthemes.org/
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
by providing a theme id to
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
|
|
\begin_inset Foot
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
many thanks to
|
|
\begin_inset CommandInset href
|
|
LatexCommand href
|
|
name "Ramnath Vaidyanathan"
|
|
target "https://github.com/ramnathv"
|
|
|
|
\end_inset
|
|
|
|
for the work on themes
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
.
|
|
See
|
|
\family typewriter
|
|
?knit_theme
|
|
\family default
|
|
for details.
|
|
\end_layout
|
|
|
|
\begin_layout Subsection
|
|
Graphics
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
Graphics is an important part of reports, and several enhancements have
|
|
been made in
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
.
|
|
For example, grid graphics may not need to be explicitly printed as long
|
|
as the same code can produce plots in R (in some cases, however, they have
|
|
to be printed, e.g.
|
|
in a loop, because you have to do so in an R terminal).
|
|
\end_layout
|
|
|
|
\begin_layout Subsubsection
|
|
Graphical Devices
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
Over a long time, a frequently requested feature for Sweave was the support
|
|
for other graphics devices, which has been implemented since R 2.13.0.
|
|
Instead of using logical options like
|
|
\family typewriter
|
|
png
|
|
\family default
|
|
or
|
|
\family typewriter
|
|
jpeg
|
|
\family default
|
|
(this list can go on and on),
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
uses a single option
|
|
\family typewriter
|
|
dev
|
|
\family default
|
|
(like
|
|
\family typewriter
|
|
grdevice
|
|
\family default
|
|
in Sweave) which has support for more than 20 devices.
|
|
For instance,
|
|
\family typewriter
|
|
dev='png'
|
|
\family default
|
|
will use the
|
|
\emph on
|
|
png()
|
|
\emph default
|
|
device, and
|
|
\family typewriter
|
|
dev='CairoJPEG'
|
|
\family default
|
|
uses the
|
|
\emph on
|
|
CairoJPEG()
|
|
\emph default
|
|
device in the
|
|
\series bold
|
|
Cairo
|
|
\series default
|
|
package (it has to be installed first, of course).
|
|
If none of these devices is satisfactory, you can provide the name of a
|
|
customized device function, which must have been defined before it is called.
|
|
\end_layout
|
|
|
|
\begin_layout Subsubsection
|
|
Plot Recording
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
As mentioned before, all the plots in a code chunk are first recorded as
|
|
R objects and then
|
|
\begin_inset Quotes eld
|
|
\end_inset
|
|
|
|
replayed
|
|
\begin_inset Quotes erd
|
|
\end_inset
|
|
|
|
inside a graphical device to generate plot files.
|
|
The
|
|
\series bold
|
|
evaluate
|
|
\series default
|
|
package will record plots per
|
|
\emph on
|
|
expression
|
|
\emph default
|
|
basis, in other words, the source code is split into individual complete
|
|
expressions and
|
|
\series bold
|
|
evaluate
|
|
\series default
|
|
will examine possible plot changes in snapshots after each single expression
|
|
has been evaluated.
|
|
For example, the code below consists of three expressions, out of which
|
|
two are related to drawing plots, therefore
|
|
\series bold
|
|
evaluate
|
|
\series default
|
|
will produce two plots by default:
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<low-level-plots, fig.keep='all', dev='tikz', fig.width=2.5, fig.height=2.5,
|
|
out.width='.3
|
|
\backslash
|
|
|
|
\backslash
|
|
textwidth', cache=TRUE>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
par(mar=c(3,3,.1,.1))
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
plot(1:10, ann=FALSE,las=1)
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
text(5,9,'mass $
|
|
\backslash
|
|
|
|
\backslash
|
|
rightarrow$ energy
|
|
\backslash
|
|
n$E=mc^2$')
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
This brings a significant difference with traditional tools in R for dynamic
|
|
report generation, since low-level plotting changes can also be recorded.
|
|
The option
|
|
\family typewriter
|
|
fig.keep
|
|
\family default
|
|
controls which plots to keep in the output;
|
|
\family typewriter
|
|
fig.keep='all'
|
|
\family default
|
|
will keep low-level changes as separate plots; by default (
|
|
\family typewriter
|
|
fig.keep='high'
|
|
\family default
|
|
),
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
will merge low-level plot changes into the previous high-level plot, like
|
|
most graphics devices do.
|
|
This feature may be useful for teaching R graphics step by step.
|
|
Note, however, low-level plotting commands in a single expression (a typical
|
|
case is a loop) will not be recorded accumulatively, but high-level plotting
|
|
commands, regardless of where they are, will always be recorded.
|
|
For example, this chunk will only produce 2 plots instead of 21 plots because
|
|
there are 2 complete expressions:
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<low-plot-loop, eval=FALSE>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
plot(0,0,type='n',ann=FALSE)
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
for(i in seq(0, 2*pi,length=20)) points(cos(i),sin(i))
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
But this will produce 20 plots as expected:
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<high-plot-loop, eval=FALSE>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
for(i in seq(0, 2*pi,length=20)) {plot(cos(i),sin(i),xlim=c(-1,1),ylim=c(-1,1))}
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
As I showed in the beginning of this manual, it is straightforward to let
|
|
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
keep all the plots in a chunk and insert them into the output document,
|
|
so we no longer need the
|
|
\family typewriter
|
|
cat('
|
|
\backslash
|
|
|
|
\backslash
|
|
includegraphics{}')
|
|
\family default
|
|
trick.
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
We can discard all previous plots and keep the last one only by
|
|
\family typewriter
|
|
fig.keep='last'
|
|
\family default
|
|
, or keep only the first plot by
|
|
\family typewriter
|
|
fig.keep='first'
|
|
\family default
|
|
, or discard all plots by
|
|
\family typewriter
|
|
fig.keep='none'
|
|
\family default
|
|
.
|
|
\end_layout
|
|
|
|
\begin_layout Subsubsection
|
|
Plot Rearrangement
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
The option
|
|
\family typewriter
|
|
fig.show
|
|
\family default
|
|
can decide whether to hold all plots while evaluating the code and
|
|
\begin_inset Quotes eld
|
|
\end_inset
|
|
|
|
flush
|
|
\begin_inset Quotes erd
|
|
\end_inset
|
|
|
|
all of them to the end of a chunk (
|
|
\family typewriter
|
|
fig.show='hold'
|
|
\family default
|
|
), or just insert them to the place where they were created (by default
|
|
|
|
\family typewriter
|
|
fig.show='asis'
|
|
\family default
|
|
).
|
|
Here is an example of
|
|
\family typewriter
|
|
fig.show='asis'
|
|
\family default
|
|
:
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<fig-hold, fig.show='asis', dev='pdf', fig.width=6, fig.height=4, out.width='.35
|
|
\backslash
|
|
|
|
\backslash
|
|
linewidth'>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
contour(volcano) # contour lines
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
filled.contour(volcano) # fill contour plot with colors
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
Beside
|
|
\family typewriter
|
|
hold
|
|
\family default
|
|
and
|
|
\family typewriter
|
|
asis
|
|
\family default
|
|
, the option
|
|
\family typewriter
|
|
fig.show
|
|
\family default
|
|
can take a third value:
|
|
\family typewriter
|
|
animate
|
|
\family default
|
|
, which makes it possible to insert animations into the output document.
|
|
In LaTeX, the package
|
|
\series bold
|
|
animate
|
|
\series default
|
|
is used to put together image frames as an animation.
|
|
For animations to work, there must be more than one plot produced in a
|
|
chunk.
|
|
The option
|
|
\family typewriter
|
|
interval
|
|
\family default
|
|
controls the time interval between animation frames; by default it is 1
|
|
second.
|
|
Note you have to add
|
|
\family typewriter
|
|
|
|
\backslash
|
|
usepackage{animate}
|
|
\family default
|
|
in the LaTeX preamble, because
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
will not add it automatically.
|
|
Animations in the PDF output can only be viewed in Adobe Reader.
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
As a simple demonstration, here is a
|
|
\begin_inset CommandInset href
|
|
LatexCommand href
|
|
name "Mandelbrot animation"
|
|
target "http://en.wikipedia.org/wiki/Mandelbrot_set"
|
|
|
|
\end_inset
|
|
|
|
taken from the
|
|
\series bold
|
|
animation
|
|
\series default
|
|
package
|
|
\begin_inset CommandInset citation
|
|
LatexCommand citep
|
|
key "R-animation"
|
|
|
|
\end_inset
|
|
|
|
; note the PNG device is used because PDF files are too large.
|
|
You should be able to see the animation immediately with Acrobat Reader
|
|
since it was set to play automatically:
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<animate-demo, fig.show='animate', dev='png', out.width='.45
|
|
\backslash
|
|
|
|
\backslash
|
|
linewidth', interval=.5, aniopts='controls,loop,autoplay', cache=TRUE>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
library(animation)
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
demo('Mandelbrot', echo = FALSE, package = 'animation')
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Subsubsection
|
|
Plot Size
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
The
|
|
\family typewriter
|
|
fig.width
|
|
\family default
|
|
and
|
|
\family typewriter
|
|
fig.height
|
|
\family default
|
|
options specify the size of plots in the graphics device, and the real
|
|
size in the output document can be different (see
|
|
\family typewriter
|
|
out.width
|
|
\family default
|
|
and
|
|
\family typewriter
|
|
out.height
|
|
\family default
|
|
).
|
|
When there are multiple plots per chunk, it is possible to arrange more
|
|
than one plot per line in LaTeX -- just specify
|
|
\family typewriter
|
|
out.width
|
|
\family default
|
|
to be less than half of the current line width, e.g.
|
|
|
|
\family typewriter
|
|
out.width='.49
|
|
\backslash
|
|
|
|
\backslash
|
|
linewidth'
|
|
\family default
|
|
.
|
|
\end_layout
|
|
|
|
\begin_layout Subsubsection
|
|
The tikz Device
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
Beside PDF, PNG and other traditional R graphical devices,
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
has special support to tikz graphics via the
|
|
\series bold
|
|
tikzDevice
|
|
\series default
|
|
package
|
|
\begin_inset CommandInset citation
|
|
LatexCommand citep
|
|
key "R-tikzDevice"
|
|
|
|
\end_inset
|
|
|
|
, which is similar to
|
|
\series bold
|
|
pgfSweave
|
|
\series default
|
|
.
|
|
If we set the chunk option
|
|
\family typewriter
|
|
dev='tikz'
|
|
\family default
|
|
, the
|
|
\emph on
|
|
tikz()
|
|
\emph default
|
|
device in
|
|
\series bold
|
|
tikzDevice
|
|
\series default
|
|
will be used to save plots.
|
|
Options
|
|
\family typewriter
|
|
sanitize
|
|
\family default
|
|
and
|
|
\family typewriter
|
|
external
|
|
\family default
|
|
are related to the tikz device: see the documentation of
|
|
\emph on
|
|
tikz()
|
|
\emph default
|
|
for details.
|
|
Note
|
|
\family typewriter
|
|
external=TRUE
|
|
\family default
|
|
in
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
has a different meaning with
|
|
\series bold
|
|
pgfSweave
|
|
\series default
|
|
-- it means
|
|
\family typewriter
|
|
standAlone=TRUE
|
|
\family default
|
|
in
|
|
\emph on
|
|
tikz()
|
|
\emph default
|
|
, and the tikz graphics output will be compiled to PDF
|
|
\emph on
|
|
immediately
|
|
\emph default
|
|
after it is created, so the
|
|
\begin_inset Quotes eld
|
|
\end_inset
|
|
|
|
externalization
|
|
\begin_inset Quotes erd
|
|
\end_inset
|
|
|
|
does not depend on the
|
|
\series bold
|
|
tikz
|
|
\series default
|
|
package; to maintain consistency in (font) styles,
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
will read the preamble of the input document and use it in the tikz device.
|
|
At the moment, I'm not sure if this is a faithful way to externalize tikz
|
|
graphics, but I have not seen any problems so far.
|
|
The assumption to make, however, is that you declare all the styles in
|
|
the preamble;
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
is agnostic of
|
|
\emph on
|
|
local
|
|
\emph default
|
|
style changes in the body of the document.
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
Below is an example taken from StackOverflow
|
|
\begin_inset Foot
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
\begin_inset Flex URL
|
|
status collapsed
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
http://stackoverflow.com/q/8190087/559676
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
; we usually have to write R code like this to obtain a math expression
|
|
|
|
\begin_inset Formula $\mathrm{d}\mathbf{x}_{t}=\alpha[(\theta-\mathbf{x}_{t})\mathrm{d}t+4]\mathrm{d}B_{t}$
|
|
\end_inset
|
|
|
|
in R graphics:
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<math-expr-R, eval=FALSE>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
qplot(1:10, 1:10) + opts(title = substitute(paste(d *
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
bolditalic(x)[italic(t)] == alpha * (theta - bolditalic(x)[italic(t)])
|
|
*
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
d * italic(t) + lambda * d * italic(B)[italic(t)]), list(lambda = 4)))
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
With the tikz device, it is both straightforward and more beautiful:
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<math-expr-tikz, dev='tikz', fig.width=5, fig.height=3, out.width='.55
|
|
\backslash
|
|
|
|
\backslash
|
|
linewidth', cache=TRUE, message=FALSE>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
library(ggplot2)
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
qplot(1:10, 1:10) +
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
labs(title = sprintf('$
|
|
\backslash
|
|
|
|
\backslash
|
|
mathrm{d}
|
|
\backslash
|
|
|
|
\backslash
|
|
mathbf{x}_{t} =
|
|
\backslash
|
|
|
|
\backslash
|
|
alpha[(
|
|
\backslash
|
|
|
|
\backslash
|
|
theta -
|
|
\backslash
|
|
|
|
\backslash
|
|
mathbf{x}_{t})
|
|
\backslash
|
|
|
|
\backslash
|
|
mathrm{d}t + %d]
|
|
\backslash
|
|
|
|
\backslash
|
|
mathrm{d}B_{t}$', 4))
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
The advantage of tikz graphics is the consistency of styles
|
|
\begin_inset Foot
|
|
status collapsed
|
|
|
|
\begin_layout Plain Layout
|
|
Users are encouraged to read the vignette of
|
|
\series bold
|
|
tikzDevice
|
|
\series default
|
|
, which is the most beautiful vignette I have ever seen in R packages:
|
|
\begin_inset Flex URL
|
|
status collapsed
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
http://cran.r-project.org/web/packages/tikzDevice/vignettes/tikzDevice.pdf
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
, and one disadvantage is that LaTeX may not be able to handle too large
|
|
tikz files (it can run out of memory).
|
|
For example, an R plot with tens of thousands of graphical elements may
|
|
fail to compile in LaTeX if we use the tikz device.
|
|
In such cases, we can switch to the PDF or PNG device, or reconsider our
|
|
decision on the type of plots, e.g., a scatter plot with millions of points
|
|
is usually difficult to read, and a contour plot or a hexagon plot showing
|
|
the 2D density can be a better alternative (they are smaller in size).
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
The graphics manual contains more detailed information and you can check
|
|
it out in the
|
|
\begin_inset CommandInset href
|
|
LatexCommand href
|
|
name "website"
|
|
target "https://yihui.org/knitr/demo/graphics/"
|
|
|
|
\end_inset
|
|
|
|
.
|
|
\end_layout
|
|
|
|
\begin_layout Subsection
|
|
Cache
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
The feature of cache is not a new idea -- both
|
|
\series bold
|
|
cacheSweave
|
|
\series default
|
|
and
|
|
\series bold
|
|
weaver
|
|
\series default
|
|
have implemented it based on Sweave, with the former using
|
|
\series bold
|
|
filehash
|
|
\series default
|
|
and the latter using
|
|
\family sans
|
|
.RData
|
|
\family default
|
|
images;
|
|
\series bold
|
|
cacheSweave
|
|
\series default
|
|
also supports lazy-loading of objects based on
|
|
\series bold
|
|
filehash
|
|
\series default
|
|
.
|
|
The
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
package directly uses internal base R functions to save (
|
|
\emph on
|
|
tools:::makeLazyLoadDB()
|
|
\emph default
|
|
) and lazy-load objects (
|
|
\emph on
|
|
lazyLoad()
|
|
\emph default
|
|
).
|
|
These functions are either undocumented or marked as internal, but as far
|
|
as I understand, they are the tools to implement lazy-loading for packages.
|
|
The
|
|
\series bold
|
|
cacheSweave
|
|
\series default
|
|
vignette has clearly explained lazy-loading, and roughly speaking, lazy-loading
|
|
means an object will not be really loaded into memory unless it is really
|
|
used somewhere.
|
|
This is very useful for cache; sometimes we read a large object and cache
|
|
it, then take a subset for analysis and this subset is also cached; in
|
|
the future, the initial large object will not be loaded into R if our computati
|
|
on is only based on the object of its subset.
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
The paths of cache files are determined by the chunk option
|
|
\family typewriter
|
|
cache.path
|
|
\family default
|
|
; by default all cache files are created under a directory
|
|
\family sans
|
|
cache
|
|
\family default
|
|
relative to the current working directory, and if the option value contains
|
|
a directory (e.g.
|
|
|
|
\family typewriter
|
|
cache.path='cache/abc-'
|
|
\family default
|
|
), cache files will be stored under that directory (automatically created
|
|
if it does not exist).
|
|
The cache is invalidated and purged on any changes to the code chunk, including
|
|
both the R code and chunk options
|
|
\begin_inset Foot
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
One exception is the
|
|
\family typewriter
|
|
include
|
|
\family default
|
|
option, which is not cached because
|
|
\family typewriter
|
|
include=TRUE/FALSE
|
|
\family default
|
|
does not affect code evaluation; meanwhile, the value
|
|
\family typewriter
|
|
getOption('width')
|
|
\family default
|
|
is also cached, so if you change this option, the cache will also be invalidate
|
|
d (this option affects the width of text output)
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
; this means previous cache files of this chunk are removed (filenames are
|
|
identified by the chunk label).
|
|
Unlike
|
|
\series bold
|
|
pgfSweave
|
|
\series default
|
|
, cache files will never accumulate since old cache files will always be
|
|
removed in
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
.
|
|
Unlike
|
|
\series bold
|
|
weaver
|
|
\series default
|
|
or
|
|
\series bold
|
|
cacheSweave
|
|
\series default
|
|
,
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
will try to preserve these side-effects:
|
|
\end_layout
|
|
|
|
\begin_layout Enumerate
|
|
printed results: meaning that any output of a code chunk will be loaded
|
|
into the output document for a cached chunk, although it is not really
|
|
evaluated.
|
|
The reason is
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
also cache the output of a chunk as a character string.
|
|
Note this means graphics output is also cached since it is part of the
|
|
output.
|
|
It has been a pain for me for a long time to have to lose output to gain
|
|
cache;
|
|
\end_layout
|
|
|
|
\begin_layout Enumerate
|
|
loaded packages: after the evaluation of each cached chunk, the list of
|
|
packages used in the current R session is written to a file under the cache
|
|
path named
|
|
\family sans
|
|
__packages
|
|
\family default
|
|
; next time if a cached chunk needs to be rebuilt, these packages will be
|
|
loaded first.
|
|
The reasons for caching package names are, it can be slow to load some
|
|
packages, and a package might be loaded in a previous cached chunk which
|
|
is not available to the next cached chunk when only the latter needs to
|
|
be rebuilt.
|
|
Note this only applies to cached chunks, and for uncached chunks, you must
|
|
always use
|
|
\emph on
|
|
library()
|
|
\emph default
|
|
to load packages explicitly;
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
Although
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
tries to keep some side-effects, there are still other types of side-effects
|
|
like setting
|
|
\emph on
|
|
par()
|
|
\emph default
|
|
or
|
|
\emph on
|
|
options()
|
|
\emph default
|
|
which are not cached.
|
|
Users should be aware of these special cases, and make sure to clearly
|
|
separate the code which is not meant to be cached to other chunks which
|
|
are not cached, e.g., set all global options in the first chunk of a document
|
|
and do not cache that chunk.
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
Sometimes a cached chunk may need to use objects from other cached chunks,
|
|
which can bring a serious problem -- if objects in previous chunks have
|
|
changed, this chunk will not be aware of the changes and will still use
|
|
old cached results, unless there is a way to detect such changes from other
|
|
chunks.
|
|
There is an option called
|
|
\family typewriter
|
|
dependson
|
|
\family default
|
|
in
|
|
\series bold
|
|
cacheSweave
|
|
\series default
|
|
which does this job.
|
|
We can explicitly specify which other chunks this chunk depends on by setting
|
|
an option like
|
|
\family typewriter
|
|
dependson='chunkA;chunkB'
|
|
\family default
|
|
or equivalently
|
|
\family typewriter
|
|
dependson=c('chunkA', 'chunkB')
|
|
\family default
|
|
.
|
|
Each time the cache of a chunk is rebuilt, all other chunks which depend
|
|
on this chunk will lose cache, hence their cache will be rebuilt as well.
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
Another way to specify the dependencies among chunks is to use the chunk
|
|
option
|
|
\family typewriter
|
|
autodep
|
|
\family default
|
|
and the function
|
|
\emph on
|
|
dep_auto()
|
|
\emph default
|
|
.
|
|
This is an experimental feature borrowed from
|
|
\series bold
|
|
weaver
|
|
\series default
|
|
which frees us from setting chunk dependencies manually.
|
|
The basic idea is, if a latter chunk uses any objects created from a previous
|
|
chunk, the latter chunk is said to depend on the previous one.
|
|
The function
|
|
\emph on
|
|
findGlobals()
|
|
\emph default
|
|
in the
|
|
\series bold
|
|
codetools
|
|
\series default
|
|
package is used to find out all global objects in a chunk, and according
|
|
to its documentation, the result is an approximation.
|
|
Global objects roughly mean the ones which are not created locally, e.g.
|
|
in the expression
|
|
\family typewriter
|
|
function() {y <- x}
|
|
\family default
|
|
,
|
|
\family typewriter
|
|
x
|
|
\family default
|
|
should be a global object, whereas
|
|
\family typewriter
|
|
y
|
|
\family default
|
|
is local.
|
|
Meanwhile, we also need to save the list of objects created in each cached
|
|
chunk, so that we can compare them to the global objects in latter chunks.
|
|
For example, if chunk A created an object
|
|
\family typewriter
|
|
x
|
|
\family default
|
|
and chunk B uses this object, chunk B must depend on A, i.e.
|
|
whenever A changes, B must also be updated.
|
|
When
|
|
\family typewriter
|
|
autodep=TRUE
|
|
\family default
|
|
,
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
will write out the names of objects created in a cached chunk as well as
|
|
those global objects in two files named
|
|
\family sans
|
|
__objects
|
|
\family default
|
|
and
|
|
\family sans
|
|
__globals
|
|
\family default
|
|
respectively; later we can use the function
|
|
\emph on
|
|
dep_auto()
|
|
\emph default
|
|
to analyze the object names to figure out the dependencies automatically.
|
|
See
|
|
\begin_inset Flex URL
|
|
status collapsed
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
https://yihui.org/knitr/demo/cache/
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
for examples.
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
Yet another way to specify dependencies is
|
|
\emph on
|
|
dep_prev()
|
|
\emph default
|
|
: this is a conservative approach which sets the dependencies so that a
|
|
cached chunk will depend on all its previous chunks, i.e.
|
|
whenever a previous chunk is updated, all later chunks will be updated
|
|
accordingly.
|
|
\end_layout
|
|
|
|
\begin_layout Subsection
|
|
Code Externalization
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
It can be more convenient to write R code in a separate file, rather than
|
|
mixing it into a LaTeX document; for example, we can run R code successively
|
|
in a pure R script from one chunk to the other without jumping through
|
|
other texts.
|
|
Since I prefer using LyX to write reports, Sweave is even more inconvenient
|
|
because I have to recompile the whole document each time, even if I only
|
|
want to know the results of a single chunk.
|
|
Therefore
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
introduced the feature of code externalization to a separate R script.
|
|
Currently the setting is like this: the R script also uses chunk labels
|
|
(marked in the form
|
|
\family typewriter
|
|
## ---- chunk-label
|
|
\family default
|
|
by default); if the code chunk in the input document is empty,
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
will match its label with the label in the R script to input external R
|
|
code.
|
|
For example, suppose this is a code chunk labelled as
|
|
\family typewriter
|
|
Q1
|
|
\family default
|
|
in an R script named
|
|
\family sans
|
|
homework1-xie.R
|
|
\family default
|
|
which is under the same directory as the Rnw document:
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<ext-r-code, eval=FALSE>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
## ---- Q1 ---------------------
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
gcd = function(m, n) {
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
while ((r <- m %% n) != 0) {
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
m = n; n = r
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
}
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
n
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
}
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
In the Rnw document, we can first read the script using the function
|
|
\emph on
|
|
read_chunk()
|
|
\emph default
|
|
:
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<read-chunk, eval=FALSE>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
read_chunk('homework1-xie.R')
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
This is usually done in an early chunk, and we can use the chunk
|
|
\family typewriter
|
|
Q1
|
|
\family default
|
|
later in the Rnw document:
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<use-ext-chunk, echo=FALSE, comment=NA>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
cat('<<Q1, echo=TRUE, tidy=TRUE>>=','@',sep='
|
|
\backslash
|
|
n')
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
Different documents can read the same R script, so the R code can be reusable
|
|
across different input documents.
|
|
\end_layout
|
|
|
|
\begin_layout Subsection
|
|
Evaluation of Chunk Options
|
|
\begin_inset CommandInset label
|
|
LatexCommand label
|
|
name "sub:conditional"
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
By default
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
uses a new syntax to parse chunk options: it treats them as function arguments
|
|
instead of a text string to be split to obtain option values.
|
|
This gives the user much more power than the old syntax; we can pass arbitrary
|
|
R objects to chunk options besides simple ones like
|
|
\family typewriter
|
|
TRUE
|
|
\family default
|
|
/
|
|
\family typewriter
|
|
FALSE
|
|
\family default
|
|
, numbers and character strings.
|
|
The page
|
|
\begin_inset Flex URL
|
|
status collapsed
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
https://yihui.org/knitr/demo/sweave/
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
has given two examples to show the advantages of the new syntax.
|
|
Here we show yet another useful application.
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
Before
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
0.3, there was a feature named
|
|
\begin_inset Quotes eld
|
|
\end_inset
|
|
|
|
conditional evaluation
|
|
\begin_inset Quotes erd
|
|
\end_inset
|
|
|
|
|
|
\begin_inset Foot
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
request from
|
|
\begin_inset Flex URL
|
|
status collapsed
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
https://plus.google.com/u/0/116405544829727492615/posts/43WrRUffjzK
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
.
|
|
The idea is, instead of setting chunk options
|
|
\family typewriter
|
|
eval
|
|
\family default
|
|
and
|
|
\family typewriter
|
|
echo
|
|
\family default
|
|
to be
|
|
\family typewriter
|
|
TRUE
|
|
\family default
|
|
or
|
|
\family typewriter
|
|
FALSE
|
|
\family default
|
|
(constants), their values can be controlled by global variables in the
|
|
current R session.
|
|
This enables
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
to conditionally evaluate code chunks according to variables.
|
|
For example, here we assign
|
|
\family typewriter
|
|
TRUE
|
|
\family default
|
|
to a variable
|
|
\family typewriter
|
|
dothis
|
|
\family default
|
|
:
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<cond-variable>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
dothis=TRUE
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
In the next chunk, we set chunk options
|
|
\family typewriter
|
|
eval=dothis
|
|
\family default
|
|
and
|
|
\family typewriter
|
|
echo=!dothis
|
|
\family default
|
|
, both are valid R expressions since the variable
|
|
\family typewriter
|
|
dothis
|
|
\family default
|
|
exists.
|
|
As we can see, the source code is hidden, but it was indeed evaluated:
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<cond-out1, eval=dothis, echo=!dothis>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
print('you cannot see my source because !dothis is FALSE')
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
Then we set
|
|
\family typewriter
|
|
eval=dothis
|
|
\family default
|
|
and
|
|
\family typewriter
|
|
echo=dothis
|
|
\family default
|
|
for another chunk:
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<cond-out2,eval=dothis,echo=dothis>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
dothis
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
If we change the value of
|
|
\family typewriter
|
|
dothis
|
|
\family default
|
|
to
|
|
\family typewriter
|
|
FALSE
|
|
\family default
|
|
, neither of the above chunks will be evaluated any more.
|
|
Therefore we can control many chunks with a single variable, and present
|
|
results selectively.
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
This old feature requires
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
to treat
|
|
\family typewriter
|
|
eval
|
|
\family default
|
|
and
|
|
\family typewriter
|
|
echo
|
|
\family default
|
|
specially, and we can easily see that it is no longer necessary with the
|
|
new syntax:
|
|
\family typewriter
|
|
eval=dothis
|
|
\family default
|
|
will tell R to find the variable
|
|
\family typewriter
|
|
dothis
|
|
\family default
|
|
automatically just like we call a function
|
|
\family typewriter
|
|
foobar(eval = dothis)
|
|
\family default
|
|
.
|
|
What is more, all options will be evaluated as R expressions unless they
|
|
are already constants which do not need to be evaluated, so this old feature
|
|
has been generalized to all other options naturally.
|
|
\end_layout
|
|
|
|
\begin_layout Subsection
|
|
Customization
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
The
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
package is ready for customization.
|
|
Both the patterns and hooks can be customized; see the package website
|
|
for details.
|
|
Here I show an example on how to save
|
|
\series bold
|
|
rgl
|
|
\series default
|
|
plots
|
|
\begin_inset CommandInset citation
|
|
LatexCommand citep
|
|
key "R-rgl"
|
|
|
|
\end_inset
|
|
|
|
using a customized hook function.
|
|
First we define a hook named
|
|
\family typewriter
|
|
rgl
|
|
\family default
|
|
using the function
|
|
\emph on
|
|
hook_rgl()
|
|
\emph default
|
|
in
|
|
\series bold
|
|
rgl
|
|
\series default
|
|
:
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<rgl-demo>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
library(rgl)
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
knit_hooks$set(rgl = hook_rgl)
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
head(hook_rgl) # the hook function is defined as this
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
Then we only have to set the chunk option
|
|
\family typewriter
|
|
rgl=TRUE
|
|
\family default
|
|
:
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<fancy-rgl, rgl=TRUE, dev='png', fig.width=5, fig.height=5, out.width='2in',
|
|
message=FALSE, warning=FALSE, cache=TRUE>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
library(rgl)
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
demo('bivar', package='rgl', echo=FALSE)
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
par3d(zoom=.7)
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
Due to the flexibility of output hooks,
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
supports several different output formats.
|
|
The implementation is fairly easy, e.g., for LaTeX we put R output in
|
|
\family typewriter
|
|
verbatim
|
|
\family default
|
|
environments, and in HTML, it is only a matter of putting output in
|
|
\family typewriter
|
|
div
|
|
\family default
|
|
layers.
|
|
These are simply character string operations.
|
|
Many demos in
|
|
\begin_inset Flex URL
|
|
status collapsed
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
https://yihui.org/knitr/demo/
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
show this idea clearly.
|
|
This manual did not cover all the features of
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
, and users are encouraged to thumb through the website to know more possible
|
|
features.
|
|
\end_layout
|
|
|
|
\begin_layout Section
|
|
Editors
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
You can use any text editors to write the source documents, but some have
|
|
built-in support for
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
.
|
|
Both RStudio (
|
|
\begin_inset Flex URL
|
|
status collapsed
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
http://www.rstudio.org
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
) and LyX (
|
|
\begin_inset Flex URL
|
|
status collapsed
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
http://www.lyx.org
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
) have full support for
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
, and you can compile the document to PDF with just one click.
|
|
See
|
|
\begin_inset Flex URL
|
|
status collapsed
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
https://yihui.org/knitr/demo/rstudio/
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
and
|
|
\begin_inset Flex URL
|
|
status collapsed
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
https://yihui.org/knitr/demo/lyx/
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
respectively.
|
|
It is also possible to support other editors like
|
|
\begin_inset CommandInset href
|
|
LatexCommand href
|
|
name "Eclipse"
|
|
target "https://yihui.org/knitr/demo/eclipse/"
|
|
|
|
\end_inset
|
|
|
|
,
|
|
\begin_inset CommandInset href
|
|
LatexCommand href
|
|
name "Texmaker and WinEdt"
|
|
target "https://yihui.org/knitr/demo/editors/"
|
|
|
|
\end_inset
|
|
|
|
; see the demo list in the website for configuration instructions.
|
|
\end_layout
|
|
|
|
\begin_layout Section*
|
|
About This Document
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
This manual was written in LyX and compiled with
|
|
\series bold
|
|
knitr
|
|
\series default
|
|
(version
|
|
\begin_inset ERT
|
|
status collapsed
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
|
|
\backslash
|
|
Sexpr{packageVersion('knitr')}
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
).
|
|
The LyX source and the Rnw document exported from LyX can be found under
|
|
these directories:
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<source-location, eval=FALSE>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
system.file('examples', 'knitr-manual.lyx', package='knitr') # lyx source
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
system.file('examples', 'knitr-manual.Rnw', package='knitr') # Rnw source
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
You can use the function
|
|
\emph on
|
|
knit()
|
|
\emph default
|
|
to knit the Rnw document (remember to put the two
|
|
\family sans
|
|
.bib
|
|
\family default
|
|
files under the same directory), and you need to make sure all the R packages
|
|
used in this document are installed:
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<required-packages, eval=FALSE>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
install.packages(c('animation', 'rgl', 'tikzDevice', 'ggplot2'))
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
Feedback and comments on this manual and the package are always welcome.
|
|
Bug reports and feature requests can be sent to
|
|
\begin_inset Flex URL
|
|
status collapsed
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
https://github.com/yihui/knitr/issues
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
, and questions can be delivered to the
|
|
\begin_inset CommandInset href
|
|
LatexCommand href
|
|
name "mailing list"
|
|
target "knitr@googlegroups.com"
|
|
type "mailto:"
|
|
|
|
\end_inset
|
|
|
|
|
|
\begin_inset Flex URL
|
|
status collapsed
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
https://groups.google.com/group/knitr
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
.
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset ERT
|
|
status open
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
% when knitr is updated, this chunk will be updated; why?
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
<<auto-bib, version=packageVersion('knitr'), echo=FALSE, cache=TRUE, message=FAL
|
|
SE, warning=FALSE>>=
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
# write all packages in the current session to a bib file
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
write_bib(c(.packages(), 'evaluate', 'formatR', 'highr'), file = 'knitr-packages.b
|
|
ib')
|
|
\end_layout
|
|
|
|
\begin_layout Plain Layout
|
|
|
|
@
|
|
\end_layout
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\begin_layout Standard
|
|
\begin_inset CommandInset bibtex
|
|
LatexCommand bibtex
|
|
bibfiles "knitr-manual,knitr-packages"
|
|
options "jss"
|
|
|
|
\end_inset
|
|
|
|
|
|
\end_layout
|
|
|
|
\end_body
|
|
\end_document
|