I recently pushed version 0.2.0 of my `fromo`

package to
CRAN.
This package implements (relatively) fast, numerically robust
computation of moments via `Rcpp`

.

The big changes in this release are:

- Support for weighted moment estimation.
- Computation of running moments over windows defined by time (or some other increasing index), rather than vector index.
- Some modest improvements in speed for the 'dangerous'
use cases (no checking for
`NA`

, no weights,*etc.*)

The time-based running moments are supported via the `t_running_*`

operations,
and we support means, standard deviation, skew, kurtosis, centered and
standardized moments and cumulants, z-score, Sharpe, and t-stat. The
idea is that your observations are associated with some increasing
index, which you can think of as the observation time, and you wish
to compute moments over a fixed time window. To bloat the API, the
times from which you 'look back' can optionally be something other
than the time indices of the input, so the input and output size
can be different.

Some example uses might be:

- Compute the volatility of an asset's returns over the previous 6 months, on every trade day.
- Compute the total monthly sales of a company at month ends.

Because the API also allows you to use weights as implicit time deltas, you can also do weird and unadvisable things like compute the Sharpe of an asset over the last 1 million shares traded.

Speed improvements come from my random walk through c++ design idioms.
I also implemented a 'swap' procedure for the running standard deviation
which incorporates a Welford's method addition and removal into a single
step. I do not believe that Welford's method is the fastest algorithm
for a summarizing moment computation: probably a two pass solution to
compute the mean first, then the centered moments is faster. However,
for the case of *running* moments computations, Welford's method
probably is the fastest.

Here is an example of the speedups seen in the 0.2.0 release. Again,
I am cherry picking the running standard deviation computation, but I
believe most methods have seen at least some modest improvements in speed.
I compute the base `sd`

of the data just a baseline to compare times
in two different versions. Here are timings under the 0.2.0 code:

```
options(width=180)
options(digits=2)
library(fromo)
library(microbenchmark)
set.seed(1234)
x <- rnorm(1e5)
fromo_running_sd <- function(x) {
running_sd3(x,window=1000,na_rm=FALSE,restart_period=10000L)
}
gc()
```

```
used (Mb) gc trigger (Mb) max used (Mb)
Ncells 5.2e+06 279 9.7e+06 516 9.7e+06 516
Vcells 5.9e+07 451 2.8e+08 2146 8.9e+08 6816
```

```
# compute sd(x) as a reference
microbenchmark(sd(x),
fromo_running_sd(x),
times=1000L)
```

```
Unit: microseconds
expr min lq mean median uq max neval cld
sd(x) 304 308 331 321 339 501 1000 a
fromo_running_sd(x) 1409 1448 1637 1502 1688 32200 1000 b
```

Under the old 0.1.3 code:

```
Unit: microseconds
expr min lq mean median uq max neval cld
sd(x) 457 473 498 488 508 767 1000 a
fromo_running_sd(x) 4183 4523 5168 4730 5623 66529 1000 b
```

I would call this a win, except you might interpret it as meaning the old code was crap. Also, I worry about the maximum time taken, which suggests some kind of lurking boo-boo.