RcppRoll (version 0.2.2)

rollit: Generate your own Weighted C++ Roll Function

Description

Using this interface, you can define a function that you would like to be called on each sub-vector you are rolling over. The generated code is compiled and exposed via sourceCpp.

Usage

rollit(fun = "x", vector = FALSE, const_vars = NULL, combine = "+",
  final_trans = NULL, includes = NULL, depends = NULL, inline = TRUE,
  name = NULL, ...)

Arguments

fun

A character string defining the function call. The function must be in terms of x. The function will be applied individually to each element being 'roll'ed over, unless vector is TRUE.

vector

boolean; if TRUE, then fun is a scalar-valued function of a vector, rather than a function to apply to each element individually.

const_vars

Constant variables that will live within the sourced C++ function. Format is a named list; e.g, you could pass list(e=exp(1)) to have e as a constant variable available in the function being called. Note that the variable N is fixed to be the number of non-zero weights passed, to facilitate the use of 0 weights in terms of skipping elements.

combine

character; typically one of "+", "-", "*", "/", but any operator usable as a C++ compound assignment operator is accepted. This specifies how each element should be combined in the rolling function. Only used when vector is FALSE.

final_trans

A final transformation to perform after either 'rolling' over each element in the vector x (with vector=FALSE), or after applying a scalar-valued function of a vector (with vector=TRUE). Must be in terms of x.

includes

Other C++ libraries to include. For example, to include boost/math.hpp, you would pass c("<boost/math.hpp>").

depends

Other libraries to link to. Linking is done through Rcpp attributes.

inline

boolean; mark the function generated as inline? This may or may not increase execution speed.

name

string; a name to internally assign to your generated C++ functions.

...

Additional arguments passed to sourceCpp.

Value

A wrapper R function that calls compiled C++ files, as generated through sourceCpp. See rollit_example for more information on the functions generated by rollit.

Details

By default, we include <RcppArmadillo.h> in each file; however, you can include your own libraries with the includes call.

See Also

rollit_example for an example of the function signature for functions generated with rollit, sourceCpp for information on how Rcpp compiles your functions, get_rollit_source for inspection of the generated C++ code, and rollit_raw for wrapping in your own C++ code.

Examples

# NOT RUN {
x <- matrix(1:16, nrow=4)

## the squared rolling sum -- we square the sum of our rolled results
rolling_sqsum <- rollit( final_trans="x*x" )

rolling_sqsum( x, 4 )
rolling_sqsum( x, 4, by.column=FALSE )
cbind( as.vector(rolling_sqsum(x, 4)), apply(x, 2, function(x) { sum(x)^2 } ) )

## implement your own variance function
## we can use the sugar function 'mean' to get
## the mean of x

const_vars <- list(m = "mean(x)")
var_fun <- "( (x-m) * (x-m) )/(N-1)"
rolling_var <- rollit( var_fun, const_vars=const_vars )

x <- c(1, 5, 10, 15)
cbind( rolling_var(x, 2), roll_var(x, 2) )

## use a function from cmath

rolling_log10 <- rollit( "log10(x)" )
rolling_log10( 10^(1:5), 2 )

## rolling product
rolling_prod <- rollit( combine="*" )
rolling_prod( 1:10, 2 )

## using weights to specify something like a 'by' argument
rolling_prod( 1:10, 3, weights=c(1,0,1) )

## a benchmark

if( require("microbenchmark") && require("zoo") ) {
  x <- rnorm(1E4)
  microbenchmark(
    rolling_var(x, 100),
    roll_var(x, 100),
    rollapply(x, 100, var),
    times=10
    )
  }
# }