memoise {memoise}R Documentation

Memoise a function.

Description

mf <- memoise(f) creates mf, a memoised copy of f. A memoised copy is basically a lazier version of the same function: it saves the answers of new invocations, and re-uses the answers of old ones. Under the right circumstances, this can provide a very nice speedup indeed.

Usage

memoise(f)

Arguments

f

Function of which to create a memoised copy.

Details

There are two main ways to use the memoise function. Say that you wish to memoise glm, which is in the stats package; then you could use
mem_glm <- memoise(glm), or you could use
glm <- memoise(stats::glm).
The first form has the advantage that you still have easy access to both the memoised and the original function. The latter is especially useful to bring the benefits of memoisation to an existing block of R code.

Two example situations where memoise could be of use:

See Also

forget, is.memoised, http://en.wikipedia.org/wiki/Memoization

Examples

# a() is evaluated anew each time. memA() is only re-evaluated
# when you call it with a new set of parameters.
a <- function(n) { runif(n) }
memA <- memoise(a)
replicate(5, a(2))
replicate(5, memA(2))

# Caching is done based on parameters' value, so same-name-but-
# changed-value correctly produces two different outcomes...
N <- 4; memA(N)
N <- 5; memA(N)
# ... and same-value-but-different-name correctly produces
#     the same cached outcome.
N <- 4; memA(N)
N2 <- 4; memA(N2)

# memoise() doesn't know about default parameters.
memB <- memoise(function(n, dummy="a") { runif(n) })
memB(2)
memB(2, dummy="a")
# It doesn't know about parameter relevance, either.
# Different call means different cacheing, no matter
# that the outcome is the same.
memB(2, dummy="b")

# You can create multiple memoisations of the same function,
# and they'll be independent.
memA(2)
memA2 <- memoise(a)
memA(2)  # Still the same outcome
memA2(2) # Different cache, different outcome

# Don't do the same memoisation assignment twice: a brand-new
# memoised function also means a brand-new cache, and *that*
# you could as easily and more legibly achieve using forget().
# (If you're not sure whether you already memoised something,
#  use is.memoised() to check.)
memA(2)
memA <- memoise(a)
memA(2)

[Package memoise version 0.2.1 Index]