The `memo`

package implements a simple in-memory cache for the results of repeated computations.

Consider this terrible way to compute the Fibonnacci sequence:

`fib <- function(n) if (n <= 1) 1 else fib(n-1) + fib(n-2)`

This function is very slow to compute larger values. Each call to `fib(n)`

with `n > 1`

generates two more calls to `fib`

, leading to a runtime complexity of `O(2^n)`

. Let's count how many recursive calls to `fib`

are involved in computing each `fib(n)`

:

```
count.calls <- function(f) {
force(f)
function(...) {
count <<- count+1;
f(...)
}
}
with_count <- function(f) {
force(f)
function(x) {
count <<- 0
c(n=x, result=f(x), calls=count)
}
}
fib <- count.calls(fib)
t(sapply(1:16, with_count(fib)))
```

```
## n result calls
## [1,] 1 1 1
## [2,] 2 2 3
## [3,] 3 3 5
## [4,] 4 5 9
## [5,] 5 8 15
## [6,] 6 13 25
## [7,] 7 21 41
## [8,] 8 34 67
## [9,] 9 55 109
## [10,] 10 89 177
## [11,] 11 144 287
## [12,] 12 233 465
## [13,] 13 377 753
## [14,] 14 610 1219
## [15,] 15 987 1973
## [16,] 16 1597 3193
```

The number of calls increases unreasonably. This is because, say, `fib(6)`

calls both `fib(5)`

and `fib(4)`

, but `fib(5)`

also calls `fib(4)`

, so the second computation is wasted work, and this gets worse the higher `n`

you have. We would be in better shape if later invocations of `fib`

could access the values that were previously computed.

By wrapping `fib`

using `memo`

, fewer calls are made:

```
library(memo)
fib <- memo(fib)
t(sapply(1:16, with_count(fib)))
```

```
## n result calls
## [1,] 1 1 1
## [2,] 2 2 3
## [3,] 3 3 2
## [4,] 4 5 2
## [5,] 5 8 2
## [6,] 6 13 2
## [7,] 7 21 2
## [8,] 8 34 2
## [9,] 9 55 2
## [10,] 10 89 2
## [11,] 11 144 2
## [12,] 12 233 2
## [13,] 13 377 2
## [14,] 14 610 2
## [15,] 15 987 2
## [16,] 16 1597 2
```

Here is only called to compute new values. Note that `fib(16)`

only took two calls to compute, because `fib(15)`

was previously computed. To compute `fib(16)`

*de novo* takes 17 calls:

```
fib <- function(n) if (n <= 1) 1 else fib(n-1) + fib(n-2)
fib <- memo(count.calls(fib))
with_count(fib)(16)
```

```
## n result calls
## 16 1597 17
```