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

Imports

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: 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 `+`(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 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