R: Generate your own Weighted C++ Roll Function

rollit {RcppRoll}

R Documentation

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`.

Details

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

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.

Note

All functions generated use Rcpp's NumericVector and NumericMatrix to interface with R vectors and matrices. Elements within these vectors are translated as doubles so any function that receives a double will work fine.

If you want to just write your own C++ function to wrap into a 'rolling' interface, see rollit_raw.

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
    )
  }
## End(Not run)

[Package RcppRoll version 0.2.2 Index]