# std/stats

Dark Mode
Search:
Source   Edit

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

RunningStat calculates for a single data set

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

RunningRegress calculates for two sets of data

• n (data count)
• slope
• intercept
• correlation

Procs are provided to calculate statistics on openArrays.

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

Example:

```import std/stats
from std/math import almostEqual

template `~=`(a, b: float): bool = almostEqual(a, b)

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

```RunningRegress = object
n*: int                    ## amount of pushed data
x_stats*: RunningStat      ## stats for the first set of data
y_stats*: RunningStat      ## stats for the second set of data
s_xy: float                ## accumulated data for combined xy
```
An accumulator for regression calculations.   Source   Edit
```RunningStat = object
n*: int                    ## amount 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

# Procs

`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 `+`(a, b: RunningRegress): RunningRegress {....raises: [], tags: [].}`

Combines two RunningRegress objects.

Useful when performing parallel analysis of data series and needing to re-combine parallel result sets

Source   Edit
`proc `+`(a, b: RunningStat): RunningStat {....raises: [], tags: [].}`

Combines two RunningStats.

Useful when performing parallel analysis of data series and needing to re-combine parallel result sets.

Source   Edit
`proc `+=`(a: var RunningRegress; b: RunningRegress) {....raises: [], tags: [].}`
Adds the RunningRegress b to a.   Source   Edit
`proc `+=`(a: var RunningStat; b: RunningStat) {.inline, ...raises: [], tags: [].}`
Adds the RunningStat b to a.   Source   Edit
`proc clear(r: var RunningRegress) {....raises: [], tags: [].}`
Resets r.   Source   Edit
`proc clear(s: var RunningStat) {....raises: [], tags: [].}`
Resets s.   Source   Edit
`proc correlation(r: RunningRegress): float {....raises: [], tags: [].}`
Computes the current correlation of the two data sets pushed into r.   Source   Edit
`proc intercept(r: RunningRegress): float {....raises: [], tags: [].}`
Computes the current intercept of r.   Source   Edit
`proc kurtosis(s: RunningStat): float {....raises: [], tags: [].}`
Computes the current population kurtosis of s.   Source   Edit
`proc kurtosis[T](x: openArray[T]): float`
Computes the population kurtosis of x.   Source   Edit
`proc kurtosisS(s: RunningStat): float {....raises: [], tags: [].}`
Computes the current sample kurtosis of s.   Source   Edit
`proc kurtosisS[T](x: openArray[T]): float`
Computes the sample kurtosis of x.   Source   Edit
`proc mean(s: RunningStat): float {....raises: [], tags: [].}`
Computes the current mean of s.   Source   Edit
`proc mean[T](x: openArray[T]): float`
Computes the mean of x.   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 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 skewness(s: RunningStat): float {....raises: [], tags: [].}`
Computes the current population skewness of s.   Source   Edit
`proc skewness[T](x: openArray[T]): float`
Computes the population skewness of x.   Source   Edit
`proc skewnessS(s: RunningStat): float {....raises: [], tags: [].}`
Computes the current sample skewness of s.   Source   Edit
`proc skewnessS[T](x: openArray[T]): float`
Computes the sample skewness of x.   Source   Edit
`proc slope(r: RunningRegress): float {....raises: [], tags: [].}`
Computes the current slope of r.   Source   Edit
`proc standardDeviation(s: RunningStat): float {....raises: [], tags: [].}`
Computes the current population standard deviation of s.   Source   Edit
`proc standardDeviation[T](x: openArray[T]): float`
Computes the population standard deviation of x.   Source   Edit
`proc standardDeviationS(s: RunningStat): float {....raises: [], tags: [].}`
Computes the current sample standard deviation of s.   Source   Edit
`proc standardDeviationS[T](x: openArray[T]): float`
Computes the sample standard deviation of x.   Source   Edit
`proc variance(s: RunningStat): float {....raises: [], tags: [].}`
Computes the current population variance of s.   Source   Edit
`proc variance[T](x: openArray[T]): float`
Computes the population variance of x.   Source   Edit
`proc varianceS(s: RunningStat): float {....raises: [], tags: [].}`
Computes the current sample variance of s.   Source   Edit
`proc varianceS[T](x: openArray[T]): float`
Computes the sample variance of x.   Source   Edit