# std/stats

Dark Mode

- Manual
- Standard library
- Index
- Compiler docs
- Fusion docs
- devel, stable

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 `openArray`s.

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 `RunningStat`s.

  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