# stats

Statistical analysis framework for performing basic statistical analysis of data. The data is analysed in a single pass, when a data value is pushed to the `RunningStat` or `RunningRegress` objects

`RunningStat` calculates for a single data set

• n (data count)
• min (smallest value)
• max (largest value)
• sum
• mean
• variance
• varianceS (sample var)
• standardDeviation
• standardDeviationS (sample stddev)
• skewness (the third statistical moment)
• kurtosis (the fourth statistical moment)

`RunningRegress` calculates for two sets of data

• n
• slope
• intercept
• correlation

Procs have been provided to calculate statistics on arrays and sequences.

However, if more than a single statistical calculation is required, it is more efficient to push the data once to the RunningStat object, and call the numerous statistical procs for the RunningStat object.

```var rs: RunningStat
rs.push(MySeqOfData)
rs.mean()
rs.variance()
rs.skewness()
rs.kurtosis()```

Example:

```static:
block:
var statistics: RunningStat  ## Must be "var"
statistics.push(@[1.0, 2.0, 1.0, 4.0, 1.0, 4.0, 1.0, 2.0])
doAssert statistics.n == 8
template `===`(a, b: float): bool = (abs(a - b) < 1e-9)
doAssert statistics.mean() === 2.0
doAssert statistics.variance() === 1.5
doAssert statistics.varianceS() === 1.714285714285715
doAssert statistics.skewness() === 0.8164965809277261
doAssert statistics.skewnessS() === 1.018350154434631
doAssert statistics.kurtosis() === -1.0
doAssert statistics.kurtosisS() === -0.7000000000000008```

math

## Types

```RunningStat = object
n*: int                    ## number of pushed data
min*, max*, sum*: float    ## self-explaining
mom1, mom2, mom3, mom4: float ## statistical moments, mom1 is mean```
an accumulator for statistical data Source Edit
```RunningRegress = object
n*: int                    ## number of pushed data
x_stats*: RunningStat      ## stats for first set of data
y_stats*: RunningStat      ## stats for second set of data
s_xy: float                ## accumulated data for combined xy```
an accumulator for regression calculations Source Edit

## Procs

`proc clear(s: var RunningStat) {...}{.raises: [], tags: [].}`
reset `s` Source Edit
`proc push(s: var RunningStat; x: float) {...}{.raises: [], tags: [].}`
pushes a value `x` for processing Source Edit
`proc push(s: var RunningStat; x: int) {...}{.raises: [], tags: [].}`

pushes a value `x` for processing.

`x` is simply converted to `float` and the other push operation is called.

Source Edit
`proc push(s: var RunningStat; x: openArray[float | int])`

pushes all values of `x` for processing.

Int values of `x` are simply converted to `float` and the other push operation is called.

Source Edit
`proc mean(s: RunningStat): float {...}{.raises: [], tags: [].}`
computes the current mean of `s` Source Edit
`proc variance(s: RunningStat): float {...}{.raises: [], tags: [].}`
computes the current population variance of `s` Source Edit
`proc varianceS(s: RunningStat): float {...}{.raises: [], tags: [].}`
computes the current sample variance of `s` Source Edit
`proc standardDeviation(s: RunningStat): float {...}{.raises: [], tags: [].}`
computes the current population standard deviation of `s` Source Edit
`proc standardDeviationS(s: RunningStat): float {...}{.raises: [], tags: [].}`
computes the current sample standard deviation of `s` Source Edit
`proc skewness(s: RunningStat): float {...}{.raises: [], tags: [].}`
computes the current population skewness of `s` Source Edit
`proc skewnessS(s: RunningStat): float {...}{.raises: [], tags: [].}`
computes the current sample skewness of `s` Source Edit
`proc kurtosis(s: RunningStat): float {...}{.raises: [], tags: [].}`
computes the current population kurtosis of `s` Source Edit
`proc kurtosisS(s: RunningStat): float {...}{.raises: [], tags: [].}`
computes the current sample kurtosis of `s` Source Edit
`proc `+`(a, b: RunningStat): RunningStat {...}{.raises: [], tags: [].}`

combine two RunningStats.

Useful if performing parallel analysis of data series and need to re-combine parallel result sets

Source Edit
`proc `+=`(a: var RunningStat; b: RunningStat) {...}{.inline, raises: [], tags: [].}`
add a second RunningStats `b` to `a` Source Edit
`proc `\$`(a: RunningStat): string {...}{.raises: [], tags: [].}`
produces a string representation of the `RunningStat`. The exact format is currently unspecified and subject to change. Currently it contains:
• the number of probes
• min, max values
• sum, mean and standard deviation.
Source Edit
`proc mean[T](x: openArray[T]): float`
computes the mean of `x` Source Edit
`proc variance[T](x: openArray[T]): float`
computes the population variance of `x` Source Edit
`proc varianceS[T](x: openArray[T]): float`
computes the sample variance of `x` Source Edit
`proc standardDeviation[T](x: openArray[T]): float`
computes the population standardDeviation of `x` Source Edit
`proc standardDeviationS[T](x: openArray[T]): float`
computes the sample standardDeviation of `x` Source Edit
`proc skewness[T](x: openArray[T]): float`
computes the population skewness of `x` Source Edit
`proc skewnessS[T](x: openArray[T]): float`
computes the sample skewness of `x` Source Edit
`proc kurtosis[T](x: openArray[T]): float`
computes the population kurtosis of `x` Source Edit
`proc kurtosisS[T](x: openArray[T]): float`
computes the sample kurtosis of `x` Source Edit
`proc clear(r: var RunningRegress) {...}{.raises: [], tags: [].}`
reset `r` Source Edit
`proc push(r: var RunningRegress; x, y: float) {...}{.raises: [], tags: [].}`
pushes two values `x` and `y` for processing Source Edit
`proc push(r: var RunningRegress; x, y: int) {...}{.inline, raises: [], tags: [].}`

pushes two values `x` and `y` for processing.

`x` and `y` are converted to `float` and the other push operation is called.

Source Edit
`proc push(r: var RunningRegress; x, y: openArray[float | int])`
pushes two sets of values `x` and `y` for processing. Source Edit
`proc slope(r: RunningRegress): float {...}{.raises: [], tags: [].}`
computes the current slope of `r` Source Edit
`proc intercept(r: RunningRegress): float {...}{.raises: [], tags: [].}`
computes the current intercept of `r` Source Edit
`proc correlation(r: RunningRegress): float {...}{.raises: [], tags: [].}`
computes the current correlation of the two data sets pushed into `r` Source Edit
`proc `+`(a, b: RunningRegress): RunningRegress {...}{.raises: [], tags: [].}`

combine two `RunningRegress` objects.

Useful if performing parallel analysis of data series and need to re-combine parallel result sets

Source Edit
`proc `+=`(a: var RunningRegress; b: RunningRegress) {...}{.raises: [], tags: [].}`
add RunningRegress `b` to `a` Source Edit