# stats

Dark Mode

- Manual
- Standard library
- Index
- devel, stable

Search:
Group by:

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

Examples:

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

        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