Module 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()

Imports

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

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

Procs

proc clear(s: var RunningStat) {...}{.raises: [], tags: [].}

reset s

proc push(s: var RunningStat; x: float) {...}{.raises: [], tags: [].}

pushes a value x for processing

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.

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.

proc mean(s: RunningStat): float {...}{.raises: [], tags: [].}

computes the current mean of s

proc variance(s: RunningStat): float {...}{.raises: [], tags: [].}

computes the current population variance of s

proc varianceS(s: RunningStat): float {...}{.raises: [], tags: [].}

computes the current sample variance of s

proc standardDeviation(s: RunningStat): float {...}{.raises: [], tags: [].}

computes the current population standard deviation of s

proc standardDeviationS(s: RunningStat): float {...}{.raises: [], tags: [].}

computes the current sample standard deviation of s

proc skewness(s: RunningStat): float {...}{.raises: [], tags: [].}

computes the current population skewness of s

proc skewnessS(s: RunningStat): float {...}{.raises: [], tags: [].}

computes the current sample skewness of s

proc kurtosis(s: RunningStat): float {...}{.raises: [], tags: [].}

computes the current population kurtosis of s

proc kurtosisS(s: RunningStat): float {...}{.raises: [], tags: [].}

computes the current sample kurtosis of s

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

proc `+=`(a: var RunningStat; b: RunningStat) {...}{.inline, raises: [], tags: [].}

add a second RunningStats b to a

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.

proc mean[T](x: openArray[T]): float

computes the mean of x

proc variance[T](x: openArray[T]): float

computes the population variance of x

proc varianceS[T](x: openArray[T]): float

computes the sample variance of x

proc standardDeviation[T](x: openArray[T]): float

computes the population standardDeviation of x

proc standardDeviationS[T](x: openArray[T]): float

computes the sanple standardDeviation of x

proc skewness[T](x: openArray[T]): float

computes the population skewness of x

proc skewnessS[T](x: openArray[T]): float

computes the sample skewness of x

proc kurtosis[T](x: openArray[T]): float

computes the population kurtosis of x

proc kurtosisS[T](x: openArray[T]): float

computes the sample kurtosis of x

proc clear(r: var RunningRegress) {...}{.raises: [], tags: [].}

reset r

proc push(r: var RunningRegress; x, y: float) {...}{.raises: [], tags: [].}

pushes two values x and y for processing

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.

proc push(r: var RunningRegress; x, y: openArray[float | int])

pushes two sets of values x and y for processing.

proc slope(r: RunningRegress): float {...}{.raises: [], tags: [].}

computes the current slope of r

proc intercept(r: RunningRegress): float {...}{.raises: [], tags: [].}

computes the current intercept of r

proc correlation(r: RunningRegress): float {...}{.raises: [], tags: [].}

computes the current correlation of the two data sets pushed into r

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

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

add RunningRegress b to a