A Gallery of Animations in Statistics and Utilities to Create Animations

Description

This package contains a variety functions for animations in statistics which could probably aid in teaching statistics and data analysis; it also has several utilities to export R animations to other formats.

Details

This package mainly makes use of HTML & JavaScript and R windows graphics devices (such as x11) to demonstrate animations in statistics; other kinds of output such as Flash (SWF) or GIF animations or PDF animations are also available if required software packages have been installed. See below for details on each type of animation.

On-screen Animations

It's natural and easy to create an animation in R using the windows graphics device, e.g. in x11() or windows(). A basic scheme is like the Example 1 (see below).

On-screen animations do not depend on any third-party software, but the rendering speed of the windows graphics devices is often slow, so the animation might not be smooth (especially under Linux and Mac OS).

HTML Pages

The generation of HTML animation pages does not rely on any third-party software either, and we only need a web browser to watch the animation. See saveHTML.

The HTML interface is just like a movie player – it comes with a series of buttons to control the animation (play, stop, next, previous, ...).

This HTML approach is flexible enough to be used even in Rweb, which means we do not really have to install R to create animations! There is a demo in system.file('misc', 'Rweb', 'demo.html', package = 'animation'). We can use saveHTML to create animations directly in Rweb; this can be helpful when we do not have R or cannot install R.

GIF Animations

If ImageMagick or GraphicsMagick has been installed, we can use im.convert or gm.convert to create a GIF animation (combining several R plots together), or use saveGIF to create a GIF animation from an R code chunk.

Flash Animations

If SWF Tools has been installed, we can use saveSWF to create a Flash animation (again, combining R plots).

PDF Animations

If LaTeX is present in the system, we can use saveLatex to insert animations into a PDF document and watch the animation using the Adobe reader.

The animation is created by the LaTeX package animate.

Video

The function saveVideo can use FFmpeg to convert images to various video formats (e.g. ‘mp4’, ‘avi’ and ‘wmv’, etc).

Note

Bug reports and feature requests can be sent to https://github.com/yihui/animation/issues.

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/animation-package/

The associated website for this package: https://yihui.org/animation

Yihui Xie and Xiaoyue Cheng. animation: A package for statistical animations. R News, 8(2):23–27, October 2008. URL: https://CRAN.R-project.org/doc/Rnews/Rnews_2008-2.pdf

(NB: some functions mentioned in the above article have been slightly modified; see the help pages for the up-to-date usage.)

Yihui Xie (2013). animation: An R Package for Creating Animations and Demonstrating Statistical Methods. Journal of Statistical Software, 53(1), 1-27. URL doi: 10.18637/jss.v053.i01.

See Also

saveHTML, saveGIF, saveSWF, saveVideo, saveLatex

Brownian Motion in a circle

Description

Several points moving randomly in a circle.

Usage

BM.circle(n = 20, col = rainbow(n), ...)

Arguments

Details

This is a solution to the question raised in R-help: https://stat.ethz.ch/pipermail/r-help/2008-December/183018.html.

Value

Invisible NULL.

Note

The maximum number of steps in the motion is specified in ani.options('nmax').

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/bm-circle/

See Also

brownian.motion, rnorm

The NBA game between CLE Cavaliers and LAL Lakers on Dec 25, 2009

Description

Cleveland Cavaliers played against Los Angeles Lakers at Staples Center in LA on Dec 25, 2009 and won the game by 102:87. This data recorded the locations of players on the court and the results of the shots.

Format

A data frame with 455 observations on the following 7 variables.

player

a character vector: the current player

time

a character vector: the time

period

a numeric vector: the period (1 - 4)

realx

a numeric vector: the x-axis location

realy

a numeric vector: the y-axis location

result

a factor with levels made and missed

team

a factor with levels CLE, LAL and OFF

Note

We view the court with CLE in the left and LAL in the right: realx is the distance to the left border of CLE's court, and realy is the distance to the bottom border of the court; notice that the size of the court is 94 \times 50 (feet).

Source

http://www.basketballgeek.com/data/ (transformed based on the original data)

Examples

## see demo('CLEvsLAL', package = 'animation') for a `replay' of the game

Word counts of a speech by the Chinese President Hu

Description

This speech came on the 30th anniversary of China's economic reform in 1978.

Format

int [1:75] 119 175 222 204 276 168 257 89 61 288 ...

Details

On Dec 18, 2008, Chinese President Hu gave a speech on the 30th anniversary of China's economic reform in 1978, and this data has recorded the number of words used in each paragraph of his speech.

Source

The full text of speech is at ⁠http://cpc.people.com.cn/GB/64093/64094/8544901.html⁠ (you may use ⁠web.archive.org⁠ if this URL is no longer accessible).

Examples

## clear pattern: 1/3 short, 1/3 long, 1/3 short again
plot(HuSpeech, type = "b", pch = 20, xlab = "paragraph index", ylab = "word count")
## see ?moving.block for an animation example

Hit or Miss Monte Carlo integration

Description

Integrate a function using the Hit-or-Miss Monte Carlo algorithm.

Usage

MC.hitormiss(
  FUN = function(x) x - x^2,
  n = ani.options("nmax"),
  from = 0,
  to = 1,
  col.points = c("black", "red"),
  pch.points = c(20, 4),
  ...
)

Arguments

Details

We compute the proportion of points hitting the area under the curve, and the integral can be estimated by the proportion multiplied by the total area of the rectangle (from xmin to xmax, ymin to ymax).

Value

A list containing

Note

This function is for demonstration purpose only; the integral might be very inaccurate when n is small.

ani.options('nmax') specifies the maximum number of trials.

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/mc-hitormiss/

See Also

integrate, MC.samplemean

Sample Mean Monte Carlo integration

Description

Integrate a function from 0 to 1 using the Sample Mean Monte Carlo algorithm

Usage

MC.samplemean(
  FUN = function(x) x - x^2,
  n = ani.options("nmax"),
  col.rect = c("gray", "black"),
  adj.x = TRUE,
  ...
)

Arguments

Details

Sample Mean Monte Carlo integration can compute

I=\int_0^1 f(x) dx

by drawing random numbers x_i from Uniform(0, 1) distribution and average the values of f(x_i). As n goes to infinity, the sample mean will approach to the expectation of f(X) by Law of Large Numbers.

The height of the i-th rectangle in the animation is f(x_i) and the width is 1/n, so the total area of all the rectangles is \sum f(x_i) 1/n, which is just the sample mean. We can compare the area of rectangles to the curve to see how close is the area to the real integral.

Value

A list containing

Note

This function is for demonstration purpose only; the integral might be very inaccurate when n is small.

ani.options('nmax') specifies the maximum number of trials.

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/mc-samplemean/

See Also

integrate, MC.hitormiss

Word counts of a speech by the US President Obama

Description

This data recorded the number of words in each paragraph of Barack Obama's speech in Chicago after winning the presidential election.

Format

int [1:59] 2 45 52 53 11 48 28 15 50 29 ...

Source

The full text of speech is at http://web.archive.org/web/20160306143403/http://www.baltimoresun.com/news/nation-world/bal-text1105-story.html

Examples

## pattern: longer paragraph and shorter paragraph
plot(ObamaSpeech, type = "b", pch = 20, xlab = "paragraph index", ylab = "word count")

The bubbles animation in Hans Rosling's Talk

Description

In Hans Rosling's attractive talk “Debunking third-world myths with the best stats you've ever seen”, he used a lot of bubble plots to illustrate trends behind the data over time. This function gives an imitation of those moving bubbles, besides, as this function is based on symbols, we can also make use of other symbols such as squares, rectangles, thermometers, etc.

Usage

Rosling.bubbles(
  x,
  y,
  data,
  type = c("circles", "squares", "rectangles", "stars", "thermometers", "boxplots"),
  bg,
  xlim = range(x),
  ylim = range(y),
  main = NULL,
  xlab = "x",
  ylab = "y",
  ...,
  grid = TRUE,
  text = 1:ani.options("nmax"),
  text.col = rgb(0, 0, 0, 0.5),
  text.cex = 5
)

Arguments

Details

Suppose we have observations of n individuals over ani.options('nmax') years. In this animation, the data of each year will be shown in the bubbles (symbols) plot; as time goes on, certain trends will be revealed (like those in Rosling's talk). Please note that the arrangement of the data for bubbles (symbols) should be a matrix like A_{ijk} in which i is the individual id (from 1 to n), j denotes the j-th variable (from 1 to p) and k indicates the time from 1 to ani.options('nmax').

And the length of x and y should be equal to the number of rows of this matrix.

Value

NULL.

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/rosling-bubbles/

TED talk: https://www.ted.com/talks/hans_rosling_the_best_stats_you_ve_ever_seen

See Also

symbols

Set or query animation options

Description

There are various parameters that control the behaviour of the animation, such as time interval, maximum number of animation frames, height and width, etc.

Usage

ani.options(...)

Arguments

Value

ani.options() returns a list containing the options: when parameters are set, their former values are returned in an invisible named list. Such a list can be passed as an argument to ani.options to restore the parameter values.

ani.options('tag') returns the value of the option 'tag'.

ani.options(c('tag1', 'tag2')) or ani.options('tag1', 'tag2') returns a list containing the corresponding options.

Animation options

The supported animation parameters:

interval

a positive number to set the time interval of the animation (unit in seconds); default to be 1.

nmax

maximum number of steps in a loop (e.g. iterations) to create animation frames. Note: the actual number of frames can be less than this number, depending on specific animations. Default to be 50.

ani.width, ani.height

width and height of image frames (unit in px); see graphics devices like png, jpeg, ...; default to be 480. NB: for different graphics devices, the units of these values might be different, e.g. PDF devices usually use inches, whereas bitmap devices often use pixels.

ani.res

The nominal resolution in ppi which will be recorded in the bitmap file, if a positive integer. Also used for units other than the default, and to convert points to pixels.; see graphics devices like png, jpeg.

imgnfmt

Customizing image number format in saveHTML, saveGIF, saveLatex and saveVideo, saveSWF is not included, it allows user to define the C-style string format for output image.

imgdir

character: the name of the directory (a relative path) for images when creating HTML animation pages; default to be 'images'.

htmlfile

character: name of the target HTML main file (without path name; basename only; default to be 'index.html')

ani.dev

a function or a function name: the graphics device; e.g. (png, pdf, ...); default to be 'png'

ani.type

character: image format for animation frames, e.g. png, jpeg, ...; default to be 'png'; this will be used as the file extension of images, so don't forget to change this option as well when you changed the option ani.dev

title, description

character: the title and description of the animation in the HTML page created by saveHTML

verbose

logical: if TRUE, write a footer part in the HTML page containing detailed technical information else the footer of the page will be blank.

loop

logical or numeric: Number of times the GIF animation is to cycle through the image sequence before stopping. By default, this is set to zero or boolean value TRUE (infinite loop).

autobrowse

logical: whether auto-browse the animation page immediately after it is created? (default to be interactive())

autoplay

logical: whether to autoplay the animation when the HTML page is loaded (default to be TRUE); only applicable to saveHTML

use.dev

whether to use the graphics device specified in ani.options('ani.dev') (default to be TRUE); if FALSE, we need to generate image files by our own approaches in the expression expr (see functions saveHTML, saveGIF, saveLatex and saveSWF); this can be useful when the output cannot be captured by standard R graphics devices – a typical example is the rgl graphics (we can use rgl.snapshot to capture rgl graphics to png files, or rgl.postscript to save plots as postscript/pdf; see demo('rgl_animation') or demo('use_Cairo') for examples or the last example below). Note, however, we do not really have to create the images using R graphics devices – see demo('flowers') on how to download images from the Internet and create an HTML animation page!

Hidden options

There are a couple of “hidden” options which are designed to facilitate the usage of some functions but are not initialized like the above options when the package is loaded, including:

convert

this option will be checked first when calling im.convert (or saveGIF) to see if it contains the path to ‘convert.exe’; we can specify it beforehand to save the efforts in searching for ‘convert.exe’ in ImageMagick under Windows. For example, ani.options(convert = 'c:/program files/imagemagick/convert.exe'); note this option also works for Mac and Linux (see help(im.convert))

swftools

this can help saveSWF save the efforts of searching for the software package “SWF Tools” under Windows; e.g. we can specify ani.options(swftools = 'c:/program files/swftools') in advance

img.fmt

the value of this option can be used to determine the image filename format when we want to use custom graphics devices to record images, e.g. in saveLatex, if ani.options('use.dev') == FALSE, then ani.options('img.fmt') will be a string like 'path/to/output/img.name%d.png', so we can use it to generate file names in the argument expr; see demo('rgl_animation') for example or the last example below

qpdf

the path of the program qpdf, e.g. ani.options(qpdf = 'C:/Software/qpdf/bin/qpdf.exe'); qpdf is mainly used to compress PDF files in this package, and it is a smaller tool than pdftk. It is recommended over pdftk especially under Linux, because tests show that pdftk does not work well under Linux in compressing PDF files, while qpdf is much better.

pdftk

the path of the program Pdftk, e.g. ani.options(pdftk = 'C:/Software/pdftk.exe') or ani.options(pdftk = '/home/john/bin/pdftk'); pdftk will be used to compress the PDF graphics output in the function pdftk; compression will not be tried if this options is NULL. This option will only affect saveGIF, saveLatex and saveSWF when ani.options('ani.type') is 'pdf'.

ffmpeg

the path of the progam ffmpeg, e.g. ani.options(ffmpeg = 'C:/Software/ffmpeg/bin/ffmpeg.exe'); FFmpeg is used to convert a sequence of images to a video. See saveVideo.

Note

Please note that nmax is not always equal to the number of animation frames. Sometimes there is more than one frame recorded in a single step of a loop, for instance, there are 2 frames generated in each step of kmeans.ani, and 4 frames in knn.ani, etc; whereas for newton.method, the number of animation frames is not definite, because there are other criteria to break the loop.

This function can be used for almost all the animation functions such as brownian.motion, boot.iid, buffon.needle, cv.ani, flip.coin, kmeans.ani, knn.ani, etc. Most of the options here will affect the behaviour of animations of the formats HTML, GIF, SWF and PDF; on-screen animations are only affected by interval and nmax.

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/ani-options/

See Also

options, dev.interactive, saveHTML, saveGIF, saveLatex, saveSWF, pdftk

https://qpdf.sourceforge.io/

https://www.pdflabs.com/docs/pdftk-man-page/

Pause for a while and flush the current graphical device

Description

If this function is called in an interactive graphics device, it will pause for a time interval (by default specified in ani.options('interval')) and flush the current device; otherwise it will do nothing.

Usage

ani.pause(interval = ani.options("interval"))

Arguments

Value

Invisible NULL.

Author(s)

Yihui Xie

See Also

dev.interactive, Sys.sleep, dev.flush

Examples

## pause for 2 seconds
oopt = ani.options(interval = 2)

for (i in 1:5) {
    plot(runif(10), ylim = c(0, 1))
    ani.pause()
}

ani.options(oopt)

## see demo('Xmas2', package = 'animation') for another example

Record and replay animations

Description

These two functions use recordPlot and replayPlot to record image frames and replay the animation respectively.

Replay the animation

Usage

ani.record(reset = FALSE, replay.cur = FALSE)

ani.replay(list)

Arguments

Details

One difficulty in capturing images in R (base graphics) is that the off-screen graphics devices cannot capture low-level plotting commands as new image files – only high-level plotting commands can produce new image files; ani.record uses recordPlot to record the plots when any changes are made on the current plot. For a graphical device to be recordable, you have to call dev.control('enable') before plotting.

ani.replay can replay the recorded plots as an animation. Moreover, we can convert the recorded plots to other formats too, e.g. use saveHTML and friends.

The recorded plots are stored as a list in .ani.env$.images, which is the default value to be passed to ani.replay; .ani.env is an invisible environment created when this package is loaded, and it will be used to store some commonly used objects such as animation options (ani.options).

Value

Invisible NULL.

Note

Although we can record changes made by low-level plotting commands using ani.record, there is a price to pay – we need memory to store the recorded plots, which are usually verg large when the plots are complicated (e.g. we draw millions of points or polygons in a single plot). However, we can set replay.cur to force R to produce a new copy of the current plot, which will be automatically recorded by off-screen grapihcs devices as new image files. This method has a limitation: we must open a screen device to assist R to record the plots. See the last example below. We must be very careful that no other graphics devices are opened before we use this function.

If we use base graphics, we should bear in mind that the background colors of the plots might be transparent, which could lead to problems in HTML animation pages when we use the png device (see the examples below).

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/ani-record/

See Also

recordPlot and replayPlot; ani.pause

Examples

library(animation)

n = 20
x = sort(rnorm(n))
y = rnorm(n)
## set up an empty frame, then add points one by one
par(bg = "white")  # ensure the background color is white
plot(x, y, type = "n")

ani.record(reset = TRUE)  # clear history before recording

for (i in 1:n) {
    points(x[i], y[i], pch = 19, cex = 2)
    ani.record()  # record the current frame
}

## now we can replay it, with an appropriate pause between frames
oopts = ani.options(interval = 0.5)
ani.replay()

## or export the animation to an HTML page
saveHTML(ani.replay(), img.name = "record_plot")

## record plots and replay immediately
saveHTML({
    dev.control("enable")  # enable recording
    par(bg = "white")  # ensure the background color is white
    plot(x, y, type = "n")
    for (i in 1:n) {
        points(x[i], y[i], pch = 19, cex = 2)
        ani.record(reset = TRUE, replay.cur = TRUE)  # record the current frame
    }
})

ani.options(oopts)

Generate an HTML animation page

Description

These functions are defunct and should not be used any more.

Usage

ani.start(...)

ani.stop(...)

Arguments

Demonstration of the Bisection Method for root-finding on an interval

Description

This is a visual demonstration of finding the root of an equation f(x) = 0 on an interval using the Bisection Method.

Usage

bisection.method(
  FUN = function(x) x^2 - 4,
  rg = c(-1, 10),
  tol = 0.001,
  interact = FALSE,
  main,
  xlab,
  ylab,
  ...
)

Arguments

Details

Suppose we want to solve the equation f(x) = 0. Given two points a and b such that f(a) and f(b) have opposite signs, we know by the intermediate value theorem that f must have at least one root in the interval [a, b] as long as f is continuous on this interval. The bisection method divides the interval in two by computing c = (a + b) / 2. There are now two possibilities: either f(a) and f(c) have opposite signs, or f(c) and f(b) have opposite signs. The bisection algorithm is then applied recursively to the sub-interval where the sign change occurs.

During the process of searching, the mid-point of subintervals are annotated in the graph by both texts and blue straight lines, and the end-points are denoted in dashed red lines. The root of each iteration is also plotted in the right margin of the graph.

Value

A list containing

Note

The maximum number of iterations is specified in ani.options('nmax').

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/bisection-method/

For more information about Bisection method, please see https://en.wikipedia.org/wiki/Bisection_method

See Also

deriv, uniroot, curve

Demonstrate bootstrapping for iid data

Description

Use a sunflower scatter plot to illustrate the results of resampling, and a histogram to show the distribution of the statistic of interest.

Usage

boot.iid(
  x = runif(20),
  statistic = mean,
  m = length(x),
  mat = matrix(1:2, 2),
  widths = rep(1, ncol(mat)),
  heights = rep(1, nrow(mat)),
  col = c("black", "red", "bisque", "red", "gray"),
  cex = c(1.5, 0.8),
  main,
  ...
)

Arguments

Details

This is actually a very naive version of bootstrapping but may be useful for novices. By default, the circles denote the original dataset, while the red sunflowers (probably) with leaves denote the points being resampled; the number of leaves just means how many times these points are resampled, as bootstrap samples with replacement. The x-axis is the sample values, and y-axis is the indices of sample points.

The whole process has illustrated the steps of resampling, computing the statistic and plotting its distribution based on bootstrapping.

Value

A list containing

Note

The maximum times of resampling is specified in ani.options('nmax').

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/boot-iid/

There are many references explaining the bootstrap and its variations.

Efron, B. and Tibshirani, R. (1993) An Introduction to the Bootstrap. Chapman & Hall.

See Also

sunflowerplot

Bootstrapping with LOWESS

Description

Sample the original data with replacement and fit LOWESS curves accordingly.

Usage

boot.lowess(x, y = NULL, f = 2/3, iter = 3, line.col = "#FF000033", ...)

Arguments

Details

We keep on resampling the data and finally we will see several bootstrapped LOWESS curves, which may give us a rough idea about a “confidence interval” of the LOWESS fit.

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/boot-lowess/

Demonstration of Brownian motion on the 2D plane

Description

Brownian motion, or random walk, can be regarded as the trace of some cumulative normal random numbers.

Usage

brownian.motion(n = 10, xlim = c(-20, 20), ylim = c(-20, 20), ...)

Arguments

Details

The location of the next step is “current location + random Gaussian numbers”, i.e.,

x_{k + 1} = x_{k} + rnorm(1)

y_{k + 1} = y_{k} + rnorm(1)

where (x, y) stands for the location of a point.

Value

None (invisible NULL).

Note

The maximum number of steps in the motion is specified in ani.options('nmax').

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/brownian-motion/

See Also

rnorm

Simulation of Buffon's Needle

Description

This function provides a simulation for the problem of Buffon's Needle, which is one of the oldest problems in the field of geometrical probability.

Usage

buffon.needle(
  l = 0.8,
  d = 1,
  redraw = TRUE,
  mat = matrix(c(1, 3, 2, 3), 2),
  heights = c(3, 2),
  col = c("lightgray", "red", "gray", "red", "blue", "black", "red"),
  expand = 0.4,
  type = "l",
  ...
)

Arguments

Details

This is quite an old problem in probability. For mathematical background, please refer to https://en.wikipedia.org/wiki/Buffon's_needle or https://mste.illinois.edu/activity/buffon/.

‘Needles’ are denoted by segments on the 2D plane, and dropped randomly to check whether they cross the parallel lines. Through many times of ‘dropping’ needles, the approximate value of \pi can be calculated out.

There are three graphs made in each step: the top-left one is a simulation of the scenario, the top-right one is to help us understand the connection between dropping needles and the mathematical method to estimate \pi, and the bottom one is the result for each drop.

Value

The values of estimated \pi are returned as a numerical vector (of length nmax).

Note

Note that redraw has great influence on the speed of the simulation (animation) if the control argument nmax (in ani.options) is quite large, so you'd better specify it as FALSE when doing a large amount of simulations.

The maximum number of drops is specified in ani.options('nmax').

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/buffon-needle/

Ramaley, J. F. (Oct 1969). Buffon's Noodle Problem. The American Mathematical Monthly 76 (8): 916-918.

Demonstration of the Central Limit Theorem

Description

First of all, a number of obs observations are generated from a certain distribution for each variable X_j, j = 1, 2, \cdots, n, and n = 1, 2, \cdots, nmax, then the sample means are computed, and at last the density of these sample means is plotted as the sample size n increases (the theoretical limiting distribution is denoted by the dashed line), besides, the P-values from the normality test shapiro.test are computed for each n and plotted at the same time.

Usage

clt.ani(
  obs = 300,
  FUN = rexp,
  mean = 1,
  sd = 1,
  col = c("bisque", "red", "blue", "black"),
  mat = matrix(1:2, 2),
  widths = rep(1, ncol(mat)),
  heights = rep(1, nrow(mat)),
  xlim,
  ...
)

Arguments

Details

As long as the conditions of the Central Limit Theorem (CLT) are satisfied, the distribution of the sample mean will be approximate to the Normal distribution when the sample size n is large enough, no matter what is the original distribution. The largest sample size is defined by nmax in ani.options.

Value

A data frame of P-values.

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/clt-ani/

See Also

hist, density

Demonstration of the concept of confidence intervals

Description

This function gives a demonstration of the concept of confidence intervals in mathematical statistics.

Usage

conf.int(level = 0.95, size = 50, cl = c("red", "gray"), ...)

Arguments

Details

Keep on drawing samples from the Normal distribution N(0, 1), computing the intervals based on a given confidence level and plotting them as segments in a graph. In the end, we may check the coverage rate against the given confidence level.

Intervals that cover the true parameter are denoted in color cl[2], otherwise in color cl[1]. Each time we draw a sample, we can compute the corresponding confidence interval. As the process of drawing samples goes on, there will be a legend indicating the numbers of the two kinds of intervals respectively and the coverage rate is also denoted in the top-left of the plot.

The argument nmax in ani.options controls the maximum times of drawing samples.

Value

A list containing

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/conf-int/

George Casella and Roger L. Berger. Statistical Inference. Duxbury Press, 2th edition, 2001.

Demonstration for the process of cross-validation

Description

This function uses rectangles to illustrate the k folds and mark the test set and the training set with different colors.

Usage

cv.ani(
  x = runif(150),
  k = 10,
  col = c("green", "red", "blue"),
  pch = c(4, 1),
  ...
)

Arguments

Details

Briefly speaking, the process of cross-validation is just to split the whole data set into several parts and select one part as the test set and the rest parts as the training set.

The computation of sample sizes is base on kfcv.

Value

None (invisible NULL).

Note

For the ‘leave-one-out’ cross-validation, just specify k as length(x), then the rectangles will ‘shrink’ into single lines.

The final number of animation frames is the smaller one of ani.options('nmax') and k.

This function has nothing to do with specific models used in cross-validation.

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/cv-ani/

See Also

kfcv

Cross-validation to find the optimum number of features (variables) in LDA

Description

This function provids an illustration of the process of finding out the optimum number of variables using k-fold cross-validation in a linear discriminant analysis (LDA).

Usage

cv.nfeaturesLDA(
  data = matrix(rnorm(600), 60),
  cl = gl(3, 20),
  k = 5,
  cex.rg = c(0.5, 3),
  col.av = c("blue", "red"),
  ...
)

Arguments

Details

For a classification problem, usually we wish to use as less variables as possible because of difficulties brought by the high dimension.

The selection procedure is like this:

• Split the whole data randomly into k folds:

  • For the number of features g = 1, 2, \cdots, g_{max}, choose g features that have the largest discriminatory power (measured by the F-statistic in ANOVA):

    • For the fold i (i = 1, 2, \cdots, k):

      • Train a LDA model without the i-th fold data, and predict with the i-th fold for a proportion of correct predictions p_{gi};

  • Average the k proportions to get the correct rate p_g;

• Determine the optimum number of features with the largest p.

Note that g_{max} is set by ani.options('nmax') (i.e. the maximum number of features we want to choose).

Value

A list containing

Author(s)

Yihui Xie <https://yihui.org/>

References

Examples at https://yihui.org/animation/example/cv-nfeatureslda/

Maindonald J, Braun J (2007). Data Analysis and Graphics Using R - An Example-Based Approach. Cambridge University Press, 2nd edition. pp. 400

See Also

kfcv, cv.ani, lda

A simulation of the death of two species with certain probabilities

Description

Suppose there are two plant species in a field: A and B. One of them will die at each time and a new plant will grow in the place where the old plant died; the species of the new plant depends on the proportions of two species: the larger the proportion is, the greater the probability for this species to come up will be.

Usage

ecol.death.sim(
  nr = 10,
  nc = 10,
  num.sp = c(50, 50),
  col.sp = c(1, 2),
  pch.sp = c(1, 2),
  col.die = 1,
  pch.die = 4,
  cex = 3,
  ...
)

Arguments

Value

a vector (factor) containing 1's and 2's, denoting the plants finally survived

Note

2 * ani.options('nmax') image frames will actually be produced.

Author(s)

Yihui Xie

References

This animation is motivated by a question raised from Jing Jiao, a student in biology, to show the evolution of two species.

The original post is in the forum of the “Capital of Statistics”: https://d.cosx.org/d/14093 (in Chinese)

Examples

oopt = ani.options(nmax = ifelse(interactive(), 50, 2), interval = 0.3)
par(ann = FALSE, mar = rep(0, 4))
ecol.death.sim()

## large scale simulation
ani.options(nmax = ifelse(interactive(), 1000, 2), interval = 0.02)
ecol.death.sim(col.sp = c(8, 2), pch.sp = c(20, 17))

ani.options(oopt)

Probability in flipping coins

Description

This function provides a simulation to the process of flipping coins and computes the frequencies for ‘heads’ and ‘tails’.

Usage

flip.coin(
  faces = 2,
  prob = NULL,
  border = "white",
  grid = "white",
  col = 1:2,
  type = "p",
  pch = 21,
  bg = "transparent",
  digits = 3
)

Arguments

Details

If faces is a single integer, say 2, a sequence of integers from 1 to faces will be used to denote the faces of a coin; otherwise this character vector just gives the names of each face.

When the i-th face shows up, a colored thin rectangle will be added to the corresponding place (the i-th bar), and there will be corresponding annotations for the number of tosses and frequencies.

The special argument grid is for consideration of a too large number of flipping, in which case if you still draw horizontal lines in these rectangles, the rectangles will be completely covered by these lines, thus we should specify it as NA.

At last the frequency for each face will be computed and shown in the header of the plot – this shall be close to prob if ani.options('nmax') is large enough.

Value

A list containing

Note

You may change the colors of each face using the argument col (repeated if shorter than the number of faces).

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/flip-coin/

See Also

points, sample

Brownian Motion using Google Visualization API

Description

We can use R to generate random numbers from the Normal distribution and write them into an HTML document, then the Google Visualization gadget “motionchart” will prepare the animation for us (a Flash animation with several buttons).

Usage

g.brownian.motion(
  p = 20,
  start = 1900,
  digits = 14,
  file = "index.html",
  width = 800,
  height = 600
)

Arguments

Value

NULL. An HTML page will be opened as the side effect.

Note

The number of frames is controlled by ani.options('nmax') as usual.

Due to the “security settings” of Adobe Flash player, you might not be able to view the generated Flash animation locally, i.e. using an address like ‘⁠file:///C:/Temp/index.html⁠’. In this case, you can upload the HTML file to a web server and use the http address to view the Flash file.

Author(s)

Yihui Xie

References

https://developers.google.com/chart/?csw=1 and https://yihui.org/en/2008/11/brownian-motion-using-google-visualization-api-and-r/

See Also

brownian.motion, BM.circle, rnorm

Examples

if (interactive()) g.brownian.motion(15, digits = 2, width = 600, height = 500,
    file = "BM-motion-chart.html")

Gradient Descent Algorithm for the 2D case

Description

This function provids a visual illustration for the process of minimizing a real-valued function through Gradient Descent Algorithm.

Usage

grad.desc(
  FUN = function(x, y) x^2 + 2 * y^2,
  rg = c(-3, -3, 3, 3),
  init = c(-3, 3),
  gamma = 0.05,
  tol = 0.001,
  gr = NULL,
  len = 50,
  interact = FALSE,
  col.contour = "red",
  col.arrow = "blue",
  main
)

Arguments

Details

Gradient descent is an optimization algorithm. To find a local minimum of a function using gradient descent, one takes steps proportional to the negative of the gradient (or the approximate gradient) of the function at the current point. If instead one takes steps proportional to the gradient, one approaches a local maximum of that function; the procedure is then known as gradient ascent.

The arrows are indicating the result of iterations and the process of minimization; they will go to a local minimum in the end if the maximum number of iterations ani.options('nmax') has not been reached.

Value

A list containing

Note

Please make sure the function FUN provided is differentiable at init, what's more, it should also be 'differentiable' using deriv if you do not provide the gradient function gr.

If the arrows cannot reach the local minimum, the maximum number of iterations nmax in ani.options may need to be increased.

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/grad-desc/

See Also

deriv, persp, contour, optim

Average yearly temperatures in central Iowa

Description

Temperatures in central Iowa over 106 years.

Format

Time-Series [1:116] from 1895 to 2010: 32.7 27.8 32.7 30.4 42.6 31.9 34.5 39.8 32.6 39.6 ...

Source

http://www.wrcc.dri.edu/cgi-bin/divplot1_form.pl?1305

Examples

plot(iatemp)

A wrapper for the ‘convert’ utility of ImageMagick or GraphicsMagick

Description

The main purpose of these two functions is to create GIF animations.

Usage

im.convert(
  files,
  output = "animation.gif",
  convert = c("magick", "convert", "gm convert"),
  cmd.fun = if (.Platform$OS.type == "windows") shell else system,
  extra.opts = "",
  clean = FALSE
)

gm.convert(..., convert = "gm convert")

Arguments

Details

The function im.convert simply wraps the arguments of the convert utility of ImageMagick to make it easier to call ImageMagick in R;

The function gm.convert is a wrapper for the command gm convert of GraphicsMagick.

Value

The command for the conversion.

If ani.options('autobrowse') == TRUE, this function will also try to open the output automatically.

Note

If files is a character vector, please make sure the order of filenames is correct! The first animation frame will be files[1], the second frame will be files[2], ...

Both ImageMagick and GraphicsMagick may have a limit on the number of images to be converted. It is a known issue that this function can fail with more than (approximately) 9000 images. The function saveVideo is a better alternative in such a case.

Most Windows users do not have read the boring notes below after they have installed ImageMagick or GraphicsMagick. For the rest of Windows users:

ImageMagick users

Please install ImageMagick from http://www.imagemagick.org, and make sure the the path to convert.exe is in your 'PATH' variable, in which case the command convert can be called without the full path. Windows users are often very confused about the ImageMagick and 'PATH' setting, so I'll try to search for ImageMagick in the Registry Hive by readRegistry('SOFTWARE\ImageMagick\Current')$BinPath, thus you might not really need to modify your 'PATH' variable.

For Windows users who have installed LyX, I will also try to find the convert utility in the LyX installation directory, so they do not really have to install ImageMagick if LyX exists in their system (of course, the LyX should be installed with ImageMagick).

Once the convert utility is found, the animation option 'convert' will be set (ani.options(convert = 'path/to/convert.exe')); this can save time for searching for convert in the operating system next time.

GraphicsMagick users

During the installation of GraphicsMagick, you will be asked if you allow it to change the PATH variable; please do check the option.

A reported problem is cmd.fun = shell might not work under Windows but cmd.fun = system works fine. Try this option in case of failures.

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/im-convert/

ImageMagick: http://www.imagemagick.org/script/convert.php

GraphicsMagick: http://www.graphicsmagick.org

See Also

Other utilities: saveGIF(), saveHTML(), saveLatex(), saveSWF(), saveVideo()

Sample sizes for k-fold cross-validation

Description

Compute sample sizes for k-fold cross-validation.

Usage

kfcv(k, N)

Arguments

Details

If N/k is an integer, the sample sizes are k ‘N/k’s (N/k, N/k, ...), otherwise the remainder will be allocated to each group as ‘uniformly’ as possible, and at last these sample sizes will be permuted randomly.

Value

A vector of length k containing k sample sizes.

Author(s)

Yihui Xie

See Also

cv.ani

Examples

## divisible
kfcv(5, 25)

## not divisible
kfcv(10, 77)

Demonstration of the k-Means clustering algorithm

Description

This function provides a demo of the k-Means cluster algorithm for data containing only two variables (columns).

Usage

kmeans.ani(
  x = cbind(X1 = runif(50), X2 = runif(50)),
  centers = 3,
  hints = c("Move centers!", "Find cluster?"),
  pch = 1:3,
  col = 1:3
)

Arguments

Details

The k-Means cluster algorithm may be regarded as a series of iterations of: finding cluster centers, computing distances between sample points, and redefining cluster membership.

The data given by x is clustered by the k-means method, which aims to partition the points into k groups such that the sum of squares from points to the assigned cluster centers is minimized. At the minimum, all cluster centres are at the mean of their Voronoi sets (the set of data points which are nearest to the cluster centre).

Value

A list with components

Note

This function is only for demonstration purpose. For practical applications please refer to kmeans.

Note that ani.options('nmax') is defined as the maximum number of iterations in such a sense: an iteration includes the process of computing distances, redefining membership and finding centers. Thus there should be 2 * ani.options('nmax') animation frames in the output if the other condition for stopping the iteration has not yet been met (i.e. the cluster membership will not change any longer).

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/kmeans-ani/

See Also

kmeans

Demonstration of the k-Nearest Neighbour classification

Description

Demonstrate the process of k-Nearest Neighbour classification on the 2D plane.

Usage

knn.ani(
  train,
  test,
  cl,
  k = 10,
  interact = FALSE,
  tt.col = c("blue", "red"),
  cl.pch = seq_along(unique(cl)),
  dist.lty = 2,
  dist.col = "gray",
  knn.col = "green",
  ...
)

Arguments

Details

For each row of the test set, the k nearest (in Euclidean distance) training set vectors are found, and the classification is decided by majority vote, with ties broken at random. For a single test sample point, the basic steps are:

1. locate the test point

2. compute the distances between the test point and all points in the training set

3. find k shortest distances and the corresponding training set points

4. vote for the result (find the maximum in the table for the true classifications)

As there are four steps in an iteration, the total number of animation frames should be 4 * min(nrow(test), ani.options('nmax')) at last.

Value

A vector of class labels for the test set.

Note

There is a special restriction (only two columns) on the training and test data set just for sake of the convenience for making a scatterplot. This is only a rough demonstration; for practical applications, please refer to existing kNN functions such as knn in class, etc.

If either one of train and test is missing, there'll be random matrices prepared for them. (It's the same for cl.)

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/knn-ani/

Venables, W. N. and Ripley, B. D. (2002) Modern Applied Statistics with S. Fourth edition. Springer.

See Also

knn

Demonstrate the least squares method

Description

This is a simple demonstration of the meaning of least squares in univariate linear regression.

Usage

least.squares(
  x,
  y,
  n = 15,
  ani.type = c("slope", "intercept"),
  a,
  b,
  a.range,
  b.range,
  ab.col = c("gray", "black"),
  est.pch = 19,
  v.col = "red",
  v.lty = 2,
  rss.pch = 19,
  rss.type = "o",
  mfrow = c(1, 2),
  ...
)

Arguments

Details

With either the intercept or the slope changing, the lines will be moving in the graph and corresponding residuals will be plotted. We can finally see the best estimate of the intercept and the slope from the residual plot.

Value

The value returned depends on the animation type.

If it is a slope animation, the value will be a list containing

If it is an intercept animation, the second component of the above list will be the estimate of the intercept.

Note the estimate will not be precise generally.

Note

ani.options('nmax') specifies the maximum number of steps for the slope or intercept to move.

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/least-squares/

See Also

lm

Demonstration of Law of Large Numbers

Description

This function plots the sample mean as the sample size grows to check whether the sample mean approaches to the population mean.

Usage

lln.ani(
  FUN = rnorm,
  mu = 0,
  np = 30,
  pch = 20,
  col.poly = "bisque",
  col.mu = "gray",
  ...
)

Arguments

Details

np points are plotted to denote the distribution of the sample mean; we will observe that the range of the sample mean just becomes smaller and smaller as the sample size increases and ultimately there will be an obvious trend that the sample mean converges to the population mean mu.

The parameter nmax in ani.options means the maximum sample size.

Value

None (invisible NULL).

Note

The argument pch will influence the speed of plotting, and for a very large sample size (say, 300), it is suggested that this argument be specified as '.'.

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/lln-ani/

Cycle through an R object and plot each subset of elements

Description

For a long numeric vector or matrix (or data frame), we can plot only a subset of its elements to take a closer look at its structure. With a moving “block” from the beginning to the end of a vector or matrix or any R objects to which we can apply subset, all elements inside the block are plotted as a line or scatter plot or any customized plots.

Usage

moving.block(dat = runif(100), block, FUN, ...)

Arguments

Details

For a vector, the elments from i + 1 to i + block will be plotted in the i-th step; similarly for a matrix or data frame, a (scatter) plot will be created from the i + 1-th row to i + block-th row.

However, this function is not limited to scatter plots or lines – we can customize the function FUN as we wish.

Value

NULL

Note

There will be ani.options('nmax') image frames created in the end. Ideally the relationship between ani.options('nmax') and block should follow this equality: block = length(x) - ani.options('nmax') + 1 (replace length(x) with nrow(x) when x is a matrix). The function will compute block according to the equality by default if no block length is specified.

The three arguments dat, i and block are passed to FUN in case we want to customize the plotting function, e.g. we may want to annonate the x-axis label with i, or we want to compute the mean value of dat[i + 1:block], etc. See the examples below to learn more about how to make use of these three arguments.

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/moving-block/

Demonstration for “Moving Window Auto-Regression”

Description

This function just fulfills a very naive idea about moving window regression using rectangles to denote the “windows” and move them, and the corresponding AR(1) coefficients as long as rough confidence intervals are computed for data points inside the “windows” during the process of moving.

Usage

mwar.ani(
  x,
  k = 15,
  conf = 2,
  mat = matrix(1:2, 2),
  widths = rep(1, ncol(mat)),
  heights = rep(1, nrow(mat)),
  lty.rect = 2,
  ...
)

Arguments

Details

The AR(1) coefficients are computed by arima.

Value

A list containing

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/mwar-ani/

Robert A. Meyer, Jr. Estimating coefficients that change over time. International Economic Review, 13(3):705-710, 1972.

See Also

arima

Demonstration of the Newton-Raphson method for root-finding

Description

This function provides an illustration of the iterations in Newton's method.

Usage

newton.method(
  FUN = function(x) x^2 - 4,
  init = 10,
  rg = c(-1, 10),
  tol = 0.001,
  interact = FALSE,
  col.lp = c("blue", "red", "red"),
  main,
  xlab,
  ylab,
  ...
)

Arguments

Details

Newton's method (also known as the Newton-Raphson method or the Newton-Fourier method) is an efficient algorithm for finding approximations to the zeros (or roots) of a real-valued function f(x).

The iteration goes on in this way:

x_{k + 1} = x_{k} - \frac{FUN(x_{k})}{FUN'(x_{k})}

From the starting value x_0, vertical lines and points are plotted to show the location of the sequence of iteration values x_1, x_2, \ldots; tangent lines are drawn to illustrate the relationship between successive iterations; the iteration values are in the right margin of the plot.

Value

A list containing

Note

The algorithm might not converge – it depends on the starting value. See the examples below.

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/newton-method/

For more information about Newton's method, please see https://en.wikipedia.org/wiki/Newton's_method

See Also

optim

Page views from Sep 21, 2007 to Dec 2, 2007 of Yihui's website

Description

The data is collected by Awstats for the website http://yihui.org.

Format

A data frame with 73 observations on the following 5 variables.

day

Date starts from Sep 21, 2007 to Dec 2, 2007.

visits

number of visits: a new visit is defined as each new incoming visitor (viewing or browsing a page) who was not connected to the site during last 60 min.

pages

number of times a page of the site is viewed (sum for all visitors for all visits). This piece of data differs from “files” in that it counts only HTML pages and excludes images and other files.

files

number of times a page, image, file of the site is viewed or downloaded by someone.

bandwidth

amount of data downloaded by all pages, images and files within the site (units in MegaBytes).

Source

http://yihui.org

Examples

plot(pageview[, 1:2], type = "b", col = "red", main = "Number of Visits in Yihui's Web")
## partial auto-correlation
pacf(pageview$visits)

A wrapper for the PDF toolkit Pdftk

Description

If the toolkit Pdftk is available in the system, it will be called to manipulate the PDF files (especially to compress the PDF files).

Usage

pdftk(input, operation = NULL, output, other.opts = "compress dont_ask")

Arguments

Details

This is a wrapper to call pdftk. The path of pdftk should be set via ani.options(pdftk = 'path/to/pdftk').

See the reference for detailed usage of pdftk.

Value

if ani.options('pdftk') is non-NULL, then this function returns the status of the operation (0 for success; see system); otherwise a warning will be issued

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/pdftk/

pdftk official website https://www.pdflabs.com/tools/pdftk-the-pdf-toolkit/

Synthetic dataset about the geometric features of pollen grains

Description

There are 3848 observations on 5 variables. From the 1986 ASA Data Exposition dataset, made up by David Coleman of RCA Labs

Format

A data frame with 3848 observations on the following 5 variables.

RIDGE

a numeric vector

NUB

a numeric vector

CRACK

a numeric vector

WEIGHT

a numeric vector

DENSITY

a numeric vector

Source

collected from Statlib Datasets Archive: http://lib.stat.cmu.edu/data-expo/

Examples

## some dense points in the center?
plot(pollen[, 1:2], pch = 20, col = rgb(0, 0, 0, 0.1))

## see demo('pollen', package = 'animation') for a 3D demo; truth is there!

Demonstrate stock prices in animations

Description

This function can display the frequencies of stock prices in a certain time span with the span changing.

Usage

price.ani(
  price,
  time,
  time.begin = min(time),
  span = 15 * 60,
  ...,
  xlab = "price",
  ylab = "frequency",
  xlim,
  ylim,
  main
)

Arguments

Value

invisible NULL

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/price-ani/

A wrapper for the PDF toolkit qpdf

Description

If the tool qpdf is available in the system, it will be called to manipulate the PDF files (especially to compress the PDF files).

Usage

qpdf(input, output, options = "--stream-data=compress")

Arguments

Details

This is a wrapper to call qpdf. The path of qpdf should be set via ani.options(qpdf = 'path/to/qpdf').

See the reference for detailed usage of qpdf.

Value

if ani.options('qpdf') is non-NULL, then this function returns the status of the operation (0 for success; see system); otherwise a warning will be issued

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/qpdf/

qpdf official website https://qpdf.sourceforge.io/

Demonstration of the Quincunx (Bean Machine/Galton Box)

Description

Simulates the quincunx with “balls” (beans) falling through several layers (denoted by triangles) and the distribution of the final locations at which the balls hit is denoted by a histogram; quincunx() is shows single layer, and quincunx2() is a two-stage version of the quincunx.

Usage

quincunx(
  balls = 200,
  layers = 15,
  pch.layers = 2,
  pch.balls = 19,
  col.balls = sample(colors(), balls, TRUE),
  cex.balls = 2
)

quincunx2(
  balls = 200,
  layers = 15,
  pch.layers = 2,
  pch.balls = 19,
  col.balls = sample(colors(), balls, TRUE),
  cex.balls = 2
)

Arguments

Details

The bean machine, also known as the quincunx or Galton box, is a device invented by Sir Francis Galton to demonstrate the law of error and the normal distribution.

When a ball falls through a layer, it can either go to the right or left side with the probability 0.5. At last the location of all the balls will show us the bell-shaped distribution.

Value

A named vector: the frequency table for the locations of the balls. Note the names of the vector are the locations: 1.5, 2.5, ..., layers - 0.5.

Note

The maximum number of animation frames is controlled by ani.options('nmax') as usual, but it is strongly recommended that ani.options(nmax = balls + layers -2), in which case all the balls will just fall through all the layers and there will be no redundant animation frames.

Author(s)

Yihui Xie, Lijia Yu, and Keith ORourke

References

Examples at https://yihui.org/animation/example/quincunx/

See Also

rbinom

Demonstration for the cluster sampling

Description

Each rectangle stands for a cluster, and the simple random sampling without replacement is performed for each cluster. All points in the clusters being sampled will be drawn out.

Usage

sample.cluster(
  pop = ceiling(10 * runif(10, 0.2, 1)),
  size = 3,
  p.col = c("blue", "red"),
  p.cex = c(1, 3),
  ...
)

Arguments

Value

None (invisible NULL).

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/sample-cluster/

See Also

sample, sample.simple, sample.ratio, sample.strat, sample.system

Demonstrate the ratio estimation in sampling survey

Description

This function demonstrates the advantage of ratio estimation when further information (ratio) about x and y is available.

Usage

sample.ratio(
  X = runif(50, 0, 5),
  R = 1,
  Y = R * X + rnorm(X),
  size = length(X)/2,
  p.col = c("blue", "red"),
  p.cex = c(1, 3),
  p.pch = c(20, 21),
  m.col = c("black", "gray"),
  legend.loc = "topleft",
  ...
)

Arguments

Details

From this demonstration we can clearly see that the ratio estimation is generally better than the simple sample average when the ratio R really exists, otherwise ratio estimation may not help.

Value

A list containing

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/sample-ratio/

See Also

sample, sample.simple, sample.cluster, sample.strat, sample.system

Demonstration for simple random sampling without replacement

Description

The whole sample frame is denoted by a matrix (nrow * ncol) in the plane just for convenience, and the points being sampled are marked out (by red circles by default). Each member of the population has an equal and known chance of being selected.

Usage

sample.simple(
  nrow = 10,
  ncol = 10,
  size = 15,
  p.col = c("blue", "red"),
  p.cex = c(1, 3)
)

Arguments

Value

None (invisible NULL).

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/sample-simple/

See Also

sample, sample.ratio, sample.cluster, sample.strat, sample.system

Demonstration for the stratified sampling

Description

Each rectangle stands for a stratum, and the simple random sampling without replacement is performed within each stratum. The points being sampled are marked out (by red circles by default).

Usage

sample.strat(
  pop = ceiling(10 * runif(10, 0.5, 1)),
  size = ceiling(pop * runif(length(pop), 0, 0.5)),
  p.col = c("blue", "red"),
  p.cex = c(1, 3),
  ...
)

Arguments

Value

None (invisible 'NULL').

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/sample-strat/

See Also

sample, sample.simple, sample.cluster, sample.ratio, sample.system

Demonstration for the systematic sampling

Description

The whole sample frame is denoted by a matrix (nrow * ncol) in the plane, and the sample points with equal intervals are drawn out according to a random starting point. The points being sampled are marked by red circles.

Usage

sample.system(
  nrow = 10,
  ncol = 10,
  size = 15,
  p.col = c("blue", "red"),
  p.cex = c(1, 3)
)

Arguments

Value

None (invisible NULL).

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/sample-system/

See Also

sample, sample.simple, sample.cluster, sample.ratio, sample.strat

Convert images to a single animation file (typically GIF) using ImageMagick or GraphicsMagick

Description

This function opens a graphical device (specified in ani.options('ani.dev')) first to generate a sequence of images based on expr, then makes use of the command convert in ‘ImageMagick’ to convert these images to a single animated movie (as a GIF or MPG file). An alternative software package is GraphicsMagick (use convert = 'gm convert'), which is smaller than ImageMagick.

Usage

saveGIF(
  expr,
  movie.name = "animation.gif",
  img.name = "Rplot",
  convert = "magick",
  cmd.fun,
  clean = TRUE,
  extra.opts = "",
  ...
)

saveMovie(
  expr,
  movie.name = "animation.gif",
  img.name = "Rplot",
  convert = "magick",
  cmd.fun,
  clean = TRUE,
  extra.opts = "",
  ...
)

Arguments

Details

This function calls im.convert (or gm.convert, depending on the argument convert) to convert images to a single animation.

The advantage of this function is that it can create a single movie file, however, there are two problems too: (1) we need a special (free) software ImageMagick or GraphicsMagick; (2) the speed of the animation will be beyond our control, as the interval option is fixed. Other approaches in this package may have greater flexibilities, e.g. the HTML approach (see saveHTML).

See ani.options for the options that may affect the output, e.g. the graphics device (including the height/width specifications), the file extension of image frames, and the time interval between image frames, etc. Note that ani.options('interval') can be a numeric vector!

Value

The command for the conversion (see im.convert).

Note

See im.convert for details on the configuration of ImageMagick (typically for Windows users) or GraphicsMagick.

It is recommended to use ani.pause() to pause between animation frames in expr, because this function will only pause when called in a non-interactive graphics device, which can save a lot of time. See the demo 'Xmas2' for example (demo('Xmas2', package = 'animation')).

saveGIF has an alias saveMovie (i.e. they are identical); the latter name is for compatibility to older versions of this package (< 2.0-2). It is recommended to use saveGIF to avoid confusions between saveMovie and saveVideo.

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/savegif/

ImageMagick: http://www.imagemagick.org/script/convert.php;

GraphicsMagick: http://www.graphicsmagick.org

See Also

Other utilities: im.convert(), saveHTML(), saveLatex(), saveSWF(), saveVideo()

Insert animations into an HTML page

Description

This function first records all the plots in the R expression as bitmap images, then inserts them into an HTML page and finally creates the animation using the SciAnimator library.

Usage

saveHTML(
  expr,
  img.name = "Rplot",
  global.opts = "",
  single.opts = "",
  navigator = ani.options("nmax") <= 100 && ani.options("interval") >= 0.05,
  htmlfile = "index.html",
  ...
)

Arguments

Details

It mainly uses the SciAnimator library, which is based on jQuery. It has a neat interface (both technically and visually) and is much easier to use or extend. Moreover, this function allows multiple animations in a single HTML page – just use the same HTML filename.

Optionally the source code and some session information can be added below the animations for the sake of reproducibility (specified by the option ani.options('verbose') – if TRUE, the description, loaded packages, the code to produce the animation, as well as a part of sessionInfo() will be written in the bottom of the animation; the R code will be highlighted using the SyntaxHighlighter library for better reading experience).

Value

The path of the HTML output.

Note

Microsoft IE might restrict the HTML page from running JavaScript and try to “protect your security” when you view the animation page, but this is not really a security problem.

When you want to publish the HTML page on the web, you have to upload the associated ‘css’ and ‘js’ folders with the HTML file as well as the images.

For saveHTML, ani.options('description') can be a character vector, in which case this vector will be pasted into a scalar; use '\n\n' in the string to separate paragraphs (see the first example below).

For the users who do not have R at hand, there is a demo in system.file('misc', 'Rweb', 'demo.html', package = 'animation') to show how to create animations online without R being installed locally. It depends, however, on whether the Rweb service can be provided for public use in a long period (currently we are using the Rweb at Tama University). See the last example below.

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/savehtml/

scianimator official website https://github.com/brentertz/scianimator

See Also

Other utilities: im.convert(), saveGIF(), saveLatex(), saveSWF(), saveVideo()

Insert animations into a LaTeX document and compile it

Description

Record animation frames and insert them into a LaTeX document with the animate package. Compile the document if an appropriate LaTeX command is provided.

Usage

saveLatex(
  expr,
  nmax,
  img.name = "Rplot",
  ani.opts,
  centering = TRUE,
  caption = NULL,
  label = NULL,
  pkg.opts = NULL,
  documentclass = "article",
  latex.filename = "animation.tex",
  pdflatex = "pdflatex",
  install.animate = TRUE,
  overwrite = TRUE,
  full.path = FALSE,
  ...
)

Arguments

Details

This is actually a wrapper to generate a LaTeX document using R. The document uses the LaTeX package called animate to insert animations into PDF's. When we pass an R expression to this function, the expression will be evaluated and recorded by a grahpics device (typically png and pdf). At last, a LaTeX document will be created and compiled if an appropriate LaTeX command is provided. And the final PDF output will be opened with the PDF viewer set in getOption('pdfviewer') if ani.options('autobrowse') == TRUE.

Value

Invisible NULL

Note

This function will detect if it was called in a Sweave environment – if so, img.name will be automatically adjusted to prefix.string-label, and the LaTeX output will not be a complete document, but rather a single line like

\animategraphics[ani.opts]{1/interval}{img.name}{}{}

This automatic feature can be useful to Sweave users (but remember to set the Sweave option results=tex). See demo('Sweave_animation') for a complete example.

PDF devices are recommended because of their high quality and usually they are more friendly to LaTeX, but the size of PDF files is often much larger; in this case, we may set the option 'qpdf' or 'pdftk' to compress the PDF graphics output. To set the PDF device, use ani.options(ani.dev = 'pdf', ani.type = 'pdf')

So far animations created by the LaTeX package animate can only be viewed with Acrobat Reader (Windows) or acroread (Linux). Other PDF viewers may not support JavaScript (in fact the PDF animation is driven by JavaScript). Linux users may need to install acroread and set options(pdfviewer = 'acroread').

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/savelatex/

To know more about the animate package, please refer to http://www.ctan.org/tex-archive/macros/latex/contrib/animate/. There are a lot of options can be set in ani.opts and pkg.opts.

See Also

Other utilities: im.convert(), saveGIF(), saveHTML(), saveSWF(), saveVideo()

Convert images to Flash animations

Description

This function opens a graphical device first to generate a sequence of images based on expr, then makes use of the commands in SWFTools (png2swf, jpeg2swf, pdf2swf) to convert these images to a single Flash animation.

Usage

saveSWF(
  expr,
  swf.name = "animation.swf",
  img.name = "Rplot",
  swftools = NULL,
  ...
)

Arguments

Value

An integer indicating failure (-1) or success (0) of the converting (refer to system).

Note

Please download and install the SWFTools before using this function: http://www.swftools.org

We can also set the path to SWF Tools by ani.options(swftools = 'path/to/swftools').

ani.options('ani.type') can only be one of png, pdf and jpeg.

Also note that PDF graphics can be compressed using qpdf or Pdftk (if either one is installed and ani.options('qpdf') or ani.options('pdftk') has been set); see qpdf or pdftk.

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/saveswf/

See Also

Other utilities: im.convert(), saveGIF(), saveHTML(), saveLatex(), saveVideo()

Convert a sequence of images to a video by FFmpeg

Description

This function opens a graphics device to record the images produced in the code expr, then uses FFmpeg to convert these images to a video.

Usage

saveVideo(
  expr,
  video.name = "animation.mp4",
  img.name = "Rplot",
  ffmpeg = ani.options("ffmpeg"),
  other.opts = if (grepl("[.]mp4$", video.name)) "-pix_fmt yuv420p",
  ...
)

Arguments

Details

This function uses system to call FFmpeg to convert the images to a single video. The command line used in this function is: ffmpeg -y -r <1/interval> -i <img.name>%d.<ani.type> other.opts video.name

where interval comes from ani.options('interval'), and ani.type is from ani.options('ani.type'). For more details on the numerous options of FFmpeg, please see the reference.

Some linux systems may use the alternate software 'avconv' instead of 'ffmpeg'. The package will attempt to determine which command is present and set ani.options('ffmpeg') to an appropriate default value. This can be overridden by passing in the ffmpeg argument.

Value

An integer indicating failure (-1) or success (0) of the converting (refer to system).

Note

There are a lot of possibilities in optimizing the video. My knowledge on FFmpeg is very limited, hence the default output by this function could be of low quality or too large. The file ‘presets.xml’ of WinFF might be a good guide: https://code.google.com/archive/p/winff.

Author(s)

Yihui Xie, based on an inital version by Thomas Julou thomas.julou@gmail.com

References

Examples at https://yihui.org/animation/example/savevideo/

To know more about ffmpeg, please see http://ffmpeg.org/documentation.html

See Also

Other utilities: im.convert(), saveGIF(), saveHTML(), saveLatex(), saveSWF()

Simulation of QQ plots for the Normal distribution

Description

This demo shows the possible QQ plots created by random numbers generated from a Normal distribution so that users can get a rough idea about how QQ plots really look like.

Usage

sim.qqnorm(n = 20, last.plot = NULL, ...)

Arguments

Details

When the sample size is small, it is hard to get a correct inference about the distribution of data from a QQ plot. Even if the sample size is large, usually there are outliers far away from the straight line. Therefore, don't overinterpret the QQ plots.

Value

NULL

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/sim-qqnorm/

See Also

qqnorm

Stock prices of Vanke Co., Ltd on 2009/11/27

Description

This is a sample of stock prices of the Vanke Co., Ltd on 2009/11/27.

Format

A data frame with 2831 observations on the following 2 variables.

time

POSIXt: the time corresponding to stock prices

price

a numeric vector: stock prices

Source

This data can be obtained from most stock websites.

Visual illusions: Scintillating grid illusion and Hermann grid illusion

Description

The two most common types of grid illusions are Hermann grid illusions and Scintillating grid illusions. This function provides illustrations for both illusions.

Usage

vi.grid.illusion(
  nrow = 8,
  ncol = 8,
  lwd = 8,
  cex = 3,
  col = "darkgray",
  type = c("s", "h")
)

Arguments

Details

A grid illusion is any kind of grid that deceives a person's vision.

This is actually a static image; pay attention to the intersections of the grid and there seems to be some moving points (non-existent in fact).

Value

NULL

Author(s)

Yihui Xie

See Also

points, abline

Examples

## default to be Scintillating grid illusions
vi.grid.illusion()

## set wider lines to see Hermann grid illusions
vi.grid.illusion(type = "h", lwd = 22, nrow = 5, ncol = 5, col = "white")

Visual Illusions: Lilac Chaser

Description

Stare at the center cross for a few (say 30) seconds to experience the phenomena of the illusion.

Usage

vi.lilac.chaser(np = 16, col = "magenta", bg = "gray", p.cex = 7, c.cex = 5)

Arguments

Details

Just try it out.

Value

NULL

Note

In fact, points in the original version of ‘Lilac Chaser’ are blurred, which is not implemented in this function.

Author(s)

Yihui Xie

References

Examples at https://yihui.org/animation/example/vi-lilac.chaser/

See Also

points