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

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

© 2006–2021 Andreas Rumpf
Licensed under the MIT License.
https://nim-lang.org/docs/stats.html