Category Archives: Packages

Useful packages for R.

tikzDevice has a new home

Back in February the tikzDevice package became ORPHANED on CRAN. Consequently Kirill Müller and Yihui Xie searched for a new maintainer. When I read about it some time later, we decided that it makes sense for us to step in here. After a brief mail exchange with Yihui Xie the GitHub repository was transfered to our organization and can now be found at https://github.com/daqana/tikzDevice. Meanwhile I have implemented fixes for the existing warning messages from the CRAN checks and uploaded version 0.12, which is currently making its’ way onto CRAN. The next steps will be to work through the existing issues.

What can one do with the tikzDevice? It is a graphics device similar to pdf() or png(). But instead of an image file that might be included in a report as external graphic, it generates files in the TikZ format that makes LaTeX generate the graphic. This enables consistent fonts between text and graphics and TeX’s capabilities for typesetting mathematical equations within graphics. The pdf vignette contains many examples.

One can even use it in a R-markdown document. A document using

header-includes:
  - \\usepackage{tikz}
  - \\usepackage[osf]{mathpazo}

in the YAML header and

# c.f. https://github.com/daqana/tikzDevice/issues/60
library(knitr)
knit_hooks$set(plot = function(x, options) {
  if ("tikz" %in% options$dev && !options$external) {
    hook_plot_tex(x, options)
  } else hook_plot_md(x, options)
})

library(tikzDevice)
options(tikzLatexPackages = c(
  getOption("tikzLatexPackages"),
  "\\usepackage[osf]{mathpazo}",
  "\\usepackage[T1]{fontenc}",
  "\\usepackage{textcomp}"
))

in a setup chunk will use the same fonts for text and graphics when those are created with dev = "tikz". In this example Palatino with text-figures:

Example Palatino with text-figures

First CRAN release for dqrng

The dqrng package is now available from CRAN. It is possible to install it using

install.packages("dqrng")

Besides this simplified installation the included RNGs have been updated: Xorshift128+ and Xorshift1024* have been removed in favor of the new Xorshiro256+, c.f. http://xoshiro.di.unimi.it/. Using the provided RNGs from R is unchanged:

library(dqrng)
dqRNGkind("Xoroshiro128+")
dqset.seed(42)
dqrunif(5, min = 2, max = 10)
## [1] 4.498747 9.500660 2.457009 5.249195 2.370585
dqrnorm(5, mean = 3, sd = 5)
## [1]  5.748100 -4.368370 -1.231515 -7.552863  8.959892
dqrexp(5, rate = 4)
## [1] 0.002043171 0.261604407 0.132934079 0.048892818 0.549762841

Fast Random Numbers for R with dqrng

If you need only a few truly random numbers you might use dice or atmospheric noise. However, if you need many random numbers you will have to use a pseudo random number generator (RNG). R includes support for different RNGs (c.f. ?Random) and a wide variety of distributions (c.f. ?distributions). The underlying methods have been well tested, but faster methods are available. The dqrng package provides fast random number generators with good statistical properties for usage with R. It combines these RNGs with fast distribution functions to sample from uniform, normal or exponential distributions.

Installation

At the moment dqrng is not on CRAN, but you can install the current version via drat:

if (!requireNamespace("drat", quietly = TRUE)) install.packages("drat")
drat::addRepo("daqana")
install.packages("dqrng")

Usage

Using the provided RNGs from R is deliberately similar to using R’s build-in RNGs:

library(dqrng)
dqRNGkind("Xoroshiro128+")
dqset.seed(42)
dqrunif(5, min = 2, max = 10)
## [1] 4.498747 9.500660 2.457009 5.249195 2.370585
dqrnorm(5, mean = 3, sd = 5)
## [1]  5.748100 -4.368370 -1.231515 -7.552863  8.959892
dqrexp(5, rate = 4)
## [1] 0.002043171 0.261604407 0.132934079 0.048892818 0.549762841

They are quite a bit faster, though, as we can see by comparing 10 million random draws from different distributions:

N <- 1e7
tm <- microbenchmark(
  runif = runif(N),
  dqrunif = dqrunif(N),
  rnorm = rnorm(N), 
  dqrnorm = dqrnorm(N),
  rexp = rexp(N),
  dqrexp = dqrexp(N))
expr min lq mean median uq max neval
runif 248.16730 251.83371 262.20559 260.33073 265.69415 322.15771 100
dqrunif 34.77413 35.44569 39.40738 36.82459 38.42524 109.96758 100
rnorm 587.40975 596.92850 618.79356 613.08345 624.31043 706.79528 100
dqrnorm 63.17649 64.43796 68.77696 66.80184 68.39577 141.97466 100
rexp 392.79228 397.48715 413.66996 411.14180 420.42473 494.49631 100
dqrexp 52.75875 53.64510 57.15006 55.80021 58.65553 79.11577 100

plot of chunk unnamed-chunk-4

For r* the default Mersenne-Twister was used, while dqr* used Xoroshiro128+ in this comparison. For rnorm the default inversion method was used, while dqrnorm (and dqrexp) used the Ziggurat algorithm from Boost.Random with additional tuning.

Both the RNGs and the distribution functions are distributed as C++ header-only library. See the included vignette for possible usage from C++.

Supported Random Number Generators

Support for the following 64 bit RNGs is currently included:

  • Mersenne-Twister
    The 64 bit variant of the well-known Mersenne-Twister, which is also used as default. This is a conservative default that allows you to take advantage of the fast distribution functions provided by dqrng while staying close to R’s default RNG (32 bit Mersenne-Twister).
  • pcg64
    The default 64 bit variant from the PCG family developed by Melissa O’Neill. See http://www.pcg-random.org for more details.
  • Xoroshiro128+, Xorshift128+, and Xorshift1024*
    RNGs mainly developed by Sebastiano Vigna. They are used as default RNGs in Erlang and different JavaScript engines. See http://xoroshiro.di.unimi.it/ for more details.

RcppArrayFire 0.0.2: Rcpp integration for ArrayFire

The RcppArrayFire package uses Rcpp to provide an interface from R to and from the ArrayFire library, an open source library that can make use of GPUs and other hardware accelerators via CUDA or OpenCL.

The official R bindings expose ArrayFire data structures as objects in R, which would require a large amount of code to support all the methods defined in ArrayFire’s C/C++ API. RcppArrayFire instead, which is derived from RcppFire by Kazuki Fukui, follows the lead of packages like RcppArmadillo or RcppEigen to provide seamless communication between R and ArrayFire at the C++ level.

Installation

Please note that currently RcppArrayFire has only been tested on Linux systems.

Prerequisites

In order to use RcppArrayFire you will need development tools for R, Rcpp and the ArrayFire library and header files. On a sufficiently recent Debian based or derived system, this can be achieved with:

sudo apt-get install r-base-dev r-cran-rcpp libarrayfire-dev libarrayfire-unified3 

This will install the unified and CPU backends. The CUDA backend has not been packaged for Debian, and usage of the packaged OpenCL backend is hindered by a bug in the clBLAS package. For serious usage it is currently better to build from source or use the binary installer from ArrayFire:

sudo apt-get install r-base-dev r-cran-rcpp libglfw3
# download installer from http://arrayfire.com/download/
sudo sh arrayfire-installer.sh --exclude-subdir --prefix=/usr/local

In the last command you have to adjust the name of the installer script and (optionally) the installation prefix. For GPU support, you have to install additional drivers. For many build-in Intel GPUs, you can use

sudo apt-get install beignet-opencl-icd ocl-icd-libopencl1

Installing CUDA or other OpenCL drivers is beyond the scope of this post, but see the ArrayFire documentation for details.

Package installation

RcppArrayFire is not on CRAN, but you can install the current version via drat:

#install.packages("drat")
drat::addRepo("daqana")
install.packages("RcppArrayFire")

If you have installed ArrayFire in a non-standard directory, you have to use the configure argument --with-arrayfire:

install.packages("RcppArrayFire", configure.args = "--with-arrayfire=/opt/arrayfire-3")

Usage

Calculating pi by simulation

Let’s look at the classical example of calculating pi via simulation. The basic idea is to generate a large number of random points within the unit square. An approximation for pi can then be calculated from the ratio of points within the unit circle to the total number of points. A vectorized implementation in R might look like this:

piR <- function(N) {
    x <- runif(N)
    y <- runif(N)
    4 * sum(sqrt(x^2 + y^2) < 1.0) / N
}

set.seed(42)
system.time(cat("pi ~= ", piR(10^7), "\n"))
## pi ~=  3.140899
##    user  system elapsed 
##   0.688   0.076   0.766

A simple way to use C++ code in R is to use the inline package or cppFunction() from Rcpp, which are both possible with RcppArrayFire. An implementation in C++ using ArrayFire might look like this:

src <- '
double piAF (const int N) {
    array x = randu(N, f32);
    array y = randu(N, f32);
    return 4.0 * sum<float>(sqrt(x*x + y*y) < 1.0) / N;
}'
Rcpp::cppFunction(code = src, depends = "RcppArrayFire", includes = "using namespace af;")

RcppArrayFire::arrayfire_set_seed(42)
system.time(cat("pi ~= ", piAF(10^7), "\n"))
## pi ~=  3.141066
##    user  system elapsed 
##   0.036   0.024  0.019

Several things are worth noting:

(1) The syntax is almost identical. Besides the need for using types and a different function name when generating random numbers, the argument f32 to randu as well as the float type catches the eye. These instruct ArrayFire to use single precision floats, since not all devices support double precision floating point numbers. If you want to use double precision, you have to specify f64 and double.

(2) The results are not the same, since ArrayFire uses a different random number generator.

(3) The speed-up is quite impressive. However, sometimes the first invocation of a function is not as fast as expected due to the just-in-time compilation used by ArrayFire.

Arrays as parameters

Up to now we have only considered simple types like double or int as function parameters and return values. However, we can also use arrays. Consider the matrix product X’ X for a random matrix X in R:

set.seed(42)
N <- 40
X <- matrix(rnorm(N * N * 2), ncol = N)
tXXR <- t(X) %*% X

The matrix multiplication can be implemented with RcppArrayFire using the appropriate matmul function:

src <- '
af::array squareMatrix(const RcppArrayFire::typed_array<f32>& x) {
    return af::matmulTN(x ,x);
}'
Rcpp::cppFunction(code = src, depends = "RcppArrayFire")
tXXGPU <- squareMatrix(X)

all.equal(tXXR, tXXGPU)
## [1] "Mean relative difference: 1.372856e-07"

Since an object of type af::array can contain different data types, the templated wrapper class RcppArrayFire::typed_array<> is used to indicate the desired data type when converting from R to C++. Again single precision floats are used with ArrayFire, which explains the difference between the two results. We can be sure that double precision is supported by switching the computation backend to “CPU”, which produces identical results:

src <- '
af::array squareMatrixF64(const RcppArrayFire::typed_array<f64>& x) {
    return af::matmulTN(x ,x);
}'
Rcpp::cppFunction(code = src, depends = "RcppArrayFire")

RcppArrayFire::arrayfire_set_backend("CPU")
tXXCPU <- squareMatrixF64(X)
RcppArrayFire::arrayfire_set_backend("DEFAULT")

all.equal(tXXR, tXXCPU)
## [1] TRUE

Usage in a package

More serious functions should be defined in a permanent fashion. To facilitate this, RcppArrayFire contains the function RcppArraFire.package.skeleton(). This functions initialises a package with suitable configure script for linking with ArrayFire and RcppArrayFire. In order to implement new functionality you can then write C++ functions and save them in the src folder. Functions that should be callable from R should be marked with the [[Rcpp::export]] attribute. See the Rcpp vignettes on attributes and package writing for further details.

Outlook

Besides testing the package on other platforms than Linux, future versions might include

Preparing Data with Package stringr

by Karl-Kuno Kunze

In the beginning of most data science projetcs, data must be prepared for the task at hand. Very often only parts of entries in columns are necessary or entries must be re-formatted, especially for date and time entries. For this task you need good tools to manipulate text.

Even in the base version R comes packed with many functions for that purpose. However, these are partly inconsistent as syntax is concerned or run somewhat behind the abilities of languages like Python – or require quite some complex code. Package stingr by Hadley Wickham comes in quite handy to fill the gap.

Continue reading