stats

func ArgMax ¶ added in v0.10.0

func ArgMax(input Float64Data) (int, error)

ArgMax finds the index of the highest number in a slice, returning the first occurrence in the case of ties

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	d := []float64{1.1, 2.3, 3.2, 4.0, 4.01, 5.09}
	a, _ := stats.ArgMax(d)
	fmt.Println(a)
}

Output:
5

func ArgMin ¶ added in v0.10.0

func ArgMin(input Float64Data) (int, error)

ArgMin finds the index of the lowest number in a slice, returning the first occurrence in the case of ties

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	d := []float64{1.1, 2.3, 3.2, 4.0, 4.01, 5.09}
	a, _ := stats.ArgMin(d)
	fmt.Println(a)
}

Output:
0

func AutoCorrelation ¶

func AutoCorrelation(data Float64Data, lags int) (float64, error)

AutoCorrelation is the correlation of a signal with a delayed copy of itself as a function of delay

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	s1 := []float64{1, 2, 3, 4, 5}
	a, _ := stats.AutoCorrelation(s1, 1)
	fmt.Println(a)
}

Output:
0.4

func ChebyshevDistance ¶

func ChebyshevDistance(dataPointX, dataPointY Float64Data) (distance float64, err error)

ChebyshevDistance computes the Chebyshev distance between two data sets

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	d1 := []float64{2, 3, 4, 5, 6, 7, 8}
	d2 := []float64{8, 7, 6, 5, 4, 3, 2}
	cd, _ := stats.ChebyshevDistance(d1, d2)
	fmt.Println(cd)
}

Output:
6

func Clip ¶ added in v0.11.0

func Clip(input Float64Data, min, max float64) ([]float64, error)

Clip clamps each value in the input slice into the inclusive range between min and max.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	c, _ := stats.Clip([]float64{1, 5, 10}, 2, 8)
	fmt.Println(c)
}

Output:
[2 5 8]

func CoefficientOfVariation ¶ added in v0.10.0

func CoefficientOfVariation(input Float64Data) (float64, error)

CoefficientOfVariation finds the coefficient of variation of a slice of floats, defined as the sample standard deviation divided by the mean. This matches the behavior of Python's scipy.stats.variation with ddof=1.

The input must not be empty and its mean must not be zero.

func Correlation ¶

func Correlation(data1, data2 Float64Data) (float64, error)

Correlation describes the degree of relationship between two sets of data

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	s1 := []float64{1, 2, 3, 4, 5}
	s2 := []float64{1, 2, 3, 5, 6}
	a, _ := stats.Correlation(s1, s2)
	rounded, _ := stats.Round(a, 5)
	fmt.Println(rounded)
}

Output:
0.99124

func Covariance ¶

func Covariance(data1, data2 Float64Data) (float64, error)

Covariance is a measure of how much two sets of data change

func CovariancePopulation ¶

func CovariancePopulation(data1, data2 Float64Data) (float64, error)

CovariancePopulation computes covariance for entire population between two variables.

func CumulativeMax ¶ added in v0.10.0

func CumulativeMax(input Float64Data) ([]float64, error)

CumulativeMax calculates the cumulative maximum of the input slice

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	data := []float64{3.0, 1.0, 4.0, 1.0, 5.0}
	cmax, _ := stats.CumulativeMax(data)
	fmt.Println(cmax)
}

Output:
[3 3 4 4 5]

func CumulativeMin ¶ added in v0.10.0

func CumulativeMin(input Float64Data) ([]float64, error)

CumulativeMin calculates the cumulative minimum of the input slice

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	data := []float64{3.0, 1.0, 4.0, 1.0, 5.0}
	cmin, _ := stats.CumulativeMin(data)
	fmt.Println(cmin)
}

Output:
[3 1 1 1 1]

func CumulativeProduct ¶ added in v0.10.0

func CumulativeProduct(input Float64Data) ([]float64, error)

CumulativeProduct calculates the cumulative product of the input slice

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	data := []float64{1.0, 2.0, 3.0, 4.0}
	cprod, _ := stats.CumulativeProduct(data)
	fmt.Println(cprod)
}

Output:
[1 2 6 24]

func CumulativeSum ¶

func CumulativeSum(input Float64Data) ([]float64, error)

CumulativeSum calculates the cumulative sum of the input slice

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	data := []float64{1.0, 2.1, 3.2, 4.823, 4.1, 5.8}
	csum, _ := stats.CumulativeSum(data)
	fmt.Println(csum)
}

Output:
[1 3.1 6.300000000000001 11.123000000000001 15.223 21.023]

func Diff ¶ added in v0.10.0

func Diff(input Float64Data) ([]float64, error)

Diff calculates the successive differences of the input slice, returning input[i] - input[i-1] for each i in 1..len(input)-1. The output has length len(input) - 1; a single-element input returns an empty slice.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	data := []float64{1, 4, 9, 16}
	diff, _ := stats.Diff(data)
	fmt.Println(diff)
}

Output:
[3 5 7]

func EWMA ¶ added in v0.11.0

func EWMA(input Float64Data, alpha float64) ([]float64, error)

EWMA calculates the exponentially weighted moving average of the input with smoothing factor alpha. The first output equals the first input and each subsequent entry is alpha*input[i] + (1-alpha)*output[i-1], so the result has the same length as the input. The alpha must satisfy 0 < alpha <= 1 or ErrBounds is returned. An empty input returns ErrEmptyInput.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	data := []float64{1, 2, 3}
	ewma, _ := stats.EWMA(data, 0.5)
	fmt.Println(ewma)
}

Output:
[1 1.5 2.25]

func Entropy ¶ added in v0.6.0

func Entropy(input Float64Data) (float64, error)

Entropy provides calculation of the entropy

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	d := []float64{1.1, 2.2, 3.3}
	e, _ := stats.Entropy(d)
	fmt.Println(e)
}

Output:
1.0114042647073518

func EuclideanDistance ¶

func EuclideanDistance(dataPointX, dataPointY Float64Data) (distance float64, err error)

EuclideanDistance computes the Euclidean distance between two data sets

func ExpGeom ¶ added in v0.7.0

func ExpGeom(p float64) (exp float64, err error)

ProbGeom generates the expectation or average number of trials for a geometric random variable with parameter p

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	p := 0.5
	exp, _ := stats.ExpGeom(p)
	fmt.Println(exp)
}

Output:
2

func GeometricMean ¶

func GeometricMean(input Float64Data) (float64, error)

GeometricMean gets the geometric mean for a slice of numbers

func HarmonicMean ¶

func HarmonicMean(input Float64Data) (float64, error)

HarmonicMean gets the harmonic mean for a slice of numbers

func Histogram ¶ added in v0.11.0

func Histogram(input Float64Data, bins int) ([]int, []float64, error)

Histogram calculates the histogram of a slice using the given number of equal-width bins over [min, max], returning the count of values in each bin along with the bins+1 bin edges. Each bin is half-open [edges[i], edges[i+1]) except the last, which also includes the maximum value.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	counts, edges, _ := stats.Histogram([]float64{1, 2, 1, 3, 4}, 3)
	fmt.Println(counts, edges)
}

Output:
[2 1 2] [1 2 3 4]

func InterQuartileRange ¶

func InterQuartileRange(input Float64Data) (float64, error)

InterQuartileRange finds the range between Q1 and Q3

func Interp ¶ added in v0.11.0

func Interp(x, xp, fp Float64Data) ([]float64, error)

Interp calculates the one-dimensional piecewise-linear interpolant to a function with given discrete data points (xp, fp), evaluated at each x. Values of x below xp[0] return fp[0] and values above xp[len(xp)-1] return fp[len(xp)-1], so no extrapolation is performed. Unlike numpy's interp, which silently returns nonsense for unsorted coordinates, xp must be strictly increasing or ErrBounds is returned. An empty x or xp returns ErrEmptyInput and xp and fp of different lengths return ErrSize.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	out, _ := stats.Interp([]float64{1.5}, []float64{1, 2}, []float64{10, 20})
	fmt.Println(out)
}

Output:
[15]

func KendallTau ¶ added in v0.11.0

func KendallTau(data1, data2 Float64Data) (float64, error)

KendallTau calculates Kendall's tau-b rank correlation coefficient between two variables. Tau-b corrects for ties, matching the values produced by SciPy's kendalltau and pandas' corr(method="kendall"). Pairs are compared with a simple O(n^2) loop for clarity.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	s1 := []float64{1, 2, 2, 3}
	s2 := []float64{1, 2, 3, 3}
	a, _ := stats.KendallTau(s1, s2)
	rounded, _ := stats.Round(a, 5)
	fmt.Println(rounded)
}

Output:
0.8

func Kurtosis ¶ added in v0.11.0

func Kurtosis(input Float64Data) (float64, error)

Kurtosis computes the population excess kurtosis of the dataset

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	k, _ := stats.Kurtosis([]float64{1, 2, 3, 4, 5})
	fmt.Println(k)
}

Output:
-1.3

func ManhattanDistance ¶

func ManhattanDistance(dataPointX, dataPointY Float64Data) (distance float64, err error)

ManhattanDistance computes the Manhattan distance between two data sets

func Max ¶

func Max(input Float64Data) (max float64, err error)

Max finds the highest number in a slice

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	d := []float64{1.1, 2.3, 3.2, 4.0, 4.01, 5.09}
	a, _ := stats.Max(d)
	fmt.Println(a)
}

Output:
5.09

func Mean ¶

func Mean(input Float64Data) (float64, error)

Mean gets the average of a slice of numbers

func Median ¶

func Median(input Float64Data) (median float64, err error)

Median gets the median number in a slice of numbers

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	data := []float64{1.0, 2.1, 3.2, 4.823, 4.1, 5.8}
	median, _ := stats.Median(data)
	fmt.Println(median)
}

Output:
3.65

func MedianAbsoluteDeviation ¶

func MedianAbsoluteDeviation(input Float64Data) (mad float64, err error)

MedianAbsoluteDeviation finds the median of the absolute deviations from the dataset median

func MedianAbsoluteDeviationPopulation ¶

func MedianAbsoluteDeviationPopulation(input Float64Data) (mad float64, err error)

MedianAbsoluteDeviationPopulation finds the median of the absolute deviations from the population median

func Midhinge ¶

func Midhinge(input Float64Data) (float64, error)

Midhinge finds the average of the first and third quartiles

func Min ¶

func Min(input Float64Data) (min float64, err error)

Min finds the lowest number in a set of data

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	d := stats.LoadRawData([]interface{}{1.1, "2", 3.0, 4, "5"})
	a, _ := stats.Min(d)
	fmt.Println(a)
}

Output:
1.1

func MinkowskiDistance ¶

func MinkowskiDistance(dataPointX, dataPointY Float64Data, lambda float64) (distance float64, err error)

MinkowskiDistance computes the Minkowski distance between two data sets

Arguments:

dataPointX: First set of data points
dataPointY: Second set of data points. Length of both data
            sets must be equal.
lambda:     aka p or city blocks; With lambda = 1
            returned distance is manhattan distance and
            lambda = 2; it is euclidean distance. Lambda
            reaching to infinite - distance would be chebysev
            distance.

Return:

Distance or error

func Mode ¶

func Mode(input Float64Data) (mode []float64, err error)

Mode gets the mode [most frequent value(s)] of a slice of float64s

func MovingAverage ¶ added in v0.10.0

func MovingAverage(input Float64Data, window int) ([]float64, error)

MovingAverage calculates the rolling mean of the input over a trailing window. Only fully-populated windows produce output, so the result has len(input)-window+1 entries and entry i is the mean of input[i : i+window]. The window must satisfy 1 <= window <= len(input) or ErrBounds is returned. An empty input returns ErrEmptyInput.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	data := []float64{1, 2, 3, 4, 5}
	avg, _ := stats.MovingAverage(data, 3)
	fmt.Println(avg)
}

Output:
[2 3 4]

func MovingMax ¶ added in v0.11.0

func MovingMax(input Float64Data, window int) ([]float64, error)

MovingMax calculates the rolling maximum of the input over a trailing window. Only fully-populated windows produce output, so the result has len(input)-window+1 entries and entry i is the maximum of input[i : i+window]. The window must satisfy 1 <= window <= len(input) or ErrBounds is returned. An empty input returns ErrEmptyInput.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	data := []float64{5, 1, 4, 2, 3}
	max, _ := stats.MovingMax(data, 3)
	fmt.Println(max)
}

Output:
[5 4 4]

func MovingMedian ¶ added in v0.11.0

func MovingMedian(input Float64Data, window int) ([]float64, error)

MovingMedian calculates the rolling median of the input over a trailing window. Only fully-populated windows produce output, so the result has len(input)-window+1 entries and entry i is the median of input[i : i+window]. The window must satisfy 1 <= window <= len(input) or ErrBounds is returned. An empty input returns ErrEmptyInput.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	data := []float64{5, 1, 4, 2, 3}
	median, _ := stats.MovingMedian(data, 3)
	fmt.Println(median)
}

Output:
[4 2 3]

func MovingMin ¶ added in v0.11.0

func MovingMin(input Float64Data, window int) ([]float64, error)

MovingMin calculates the rolling minimum of the input over a trailing window. Only fully-populated windows produce output, so the result has len(input)-window+1 entries and entry i is the minimum of input[i : i+window]. The window must satisfy 1 <= window <= len(input) or ErrBounds is returned. An empty input returns ErrEmptyInput.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	data := []float64{5, 1, 4, 2, 3}
	min, _ := stats.MovingMin(data, 3)
	fmt.Println(min)
}

Output:
[1 1 2]

func MovingStdDev ¶ added in v0.10.0

func MovingStdDev(input Float64Data, window int) ([]float64, error)

MovingStdDev calculates the rolling sample standard deviation of the input over a trailing window. Only fully-populated windows produce output, so the result has len(input)-window+1 entries and entry i is the sample standard deviation of input[i : i+window]. The window must satisfy 2 <= window <= len(input) or ErrBounds is returned, since the sample standard deviation of a single value is undefined. An empty input returns ErrEmptyInput.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	data := []float64{1, 2, 3, 4}
	sdev, _ := stats.MovingStdDev(data, 4)
	fmt.Println(sdev)
}

Output:
[1.2909944487358056]

func MovingSum ¶ added in v0.11.0

func MovingSum(input Float64Data, window int) ([]float64, error)

MovingSum calculates the rolling sum of the input over a trailing window. Only fully-populated windows produce output, so the result has len(input)-window+1 entries and entry i is the sum of input[i : i+window]. The window must satisfy 1 <= window <= len(input) or ErrBounds is returned. An empty input returns ErrEmptyInput.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	data := []float64{1, 2, 3, 4, 5}
	sum, _ := stats.MovingSum(data, 3)
	fmt.Println(sum)
}

Output:
[6 9 12]

func Ncr ¶ added in v0.6.0

func Ncr(n, r int) int

Ncr is an N choose R algorithm. Aaron Cannon's algorithm.

func NormBoxMullerRvs ¶ added in v0.6.0

func NormBoxMullerRvs(loc float64, scale float64, size int) []float64

NormBoxMullerRvs generates random variates using the Box–Muller transform. For more information please visit: http://mathworld.wolfram.com/Box-MullerTransformation.html

func NormCdf ¶ added in v0.6.0

func NormCdf(x float64, loc float64, scale float64) float64

NormCdf is the cumulative distribution function.

func NormEntropy ¶ added in v0.6.0

func NormEntropy(loc float64, scale float64) float64

NormEntropy is the differential entropy of the RV.

func NormFit ¶ added in v0.6.0

func NormFit(data []float64) [2]float64

NormFit returns the maximum likelihood estimators for the Normal Distribution. Takes array of float64 values. Returns array of Mean followed by Standard Deviation.

func NormInterval ¶ added in v0.6.0

func NormInterval(alpha float64, loc float64, scale float64) [2]float64

NormInterval finds endpoints of the range that contains alpha percent of the distribution.

func NormIsf ¶ added in v0.6.0

func NormIsf(p float64, loc float64, scale float64) (x float64)

NormIsf is the inverse survival function (inverse of sf).

func NormLogCdf ¶ added in v0.6.0

func NormLogCdf(x float64, loc float64, scale float64) float64

NormLogCdf is the log of the cumulative distribution function.

func NormLogPdf ¶ added in v0.6.0

func NormLogPdf(x float64, loc float64, scale float64) float64

NormLogPdf is the log of the probability density function.

func NormLogSf ¶ added in v0.6.0

func NormLogSf(x float64, loc float64, scale float64) float64

NormLogSf is the log of the survival function.

func NormMean ¶ added in v0.6.0

func NormMean(loc float64, scale float64) float64

NormMean is the mean/expected value of the distribution.

func NormMedian ¶ added in v0.6.0

func NormMedian(loc float64, scale float64) float64

NormMedian is the median of the distribution.

func NormMoment ¶ added in v0.6.0

func NormMoment(n int, loc float64, scale float64) float64

NormMoment approximates the non-central (raw) moment of order n. For more information please visit: https://math.stackexchange.com/questions/1945448/methods-for-finding-raw-moments-of-the-normal-distribution

func NormPdf ¶ added in v0.6.0

func NormPdf(x float64, loc float64, scale float64) float64

NormPdf is the probability density function.

func NormPpf ¶ added in v0.6.0

func NormPpf(p float64, loc float64, scale float64) (x float64)

NormPpf is the point percentile function. This is based on Peter John Acklam's inverse normal CDF. algorithm: http://home.online.no/~pjacklam/notes/invnorm/ (no longer visible). For more information please visit: https://stackedboxes.org/2017/05/01/acklams-normal-quantile-function/

func NormPpfRvs ¶ added in v0.6.0

func NormPpfRvs(loc float64, scale float64, size int) []float64

NormPpfRvs generates random variates using the Point Percentile Function. For more information please visit: https://demonstrations.wolfram.com/TheMethodOfInverseTransforms/

func NormSample ¶ added in v0.10.0

func NormSample(loc float64, scale float64, size int) []float64

NormSample generates random samples from a normal distribution with the given mean (loc) and standard deviation (scale).

func NormSf ¶ added in v0.6.0

func NormSf(x float64, loc float64, scale float64) float64

NormSf is the survival function (also defined as 1 - cdf, but sf is sometimes more accurate).

func NormStats ¶ added in v0.6.0

func NormStats(loc float64, scale float64, moments string) []float64

NormStats returns the mean, variance, skew, and/or kurtosis. Mean(‘m’), variance(‘v’), skew(‘s’), and/or kurtosis(‘k’). Takes string containing any of 'mvsk'. Returns array of m v s k in that order.

func NormStd ¶ added in v0.6.0

func NormStd(loc float64, scale float64) float64

NormStd is the standard deviation of the distribution.

func NormVar ¶ added in v0.6.0

func NormVar(loc float64, scale float64) float64

NormVar is the variance of the distribution.

func Pearson ¶

func Pearson(data1, data2 Float64Data) (float64, error)

Pearson calculates the Pearson product-moment correlation coefficient between two variables

func PercentChange ¶ added in v0.10.0

func PercentChange(input Float64Data) ([]float64, error)

PercentChange calculates the fractional change between successive elements of the input slice, returning (input[i] - input[i-1]) / input[i-1] for each i in 1..len(input)-1. The output has length len(input) - 1; a single-element input returns an empty slice. A zero denominator follows IEEE 754 semantics, yielding +Inf, -Inf, or NaN (for 0/0), matching the behavior of pandas pct_change.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	data := []float64{100, 110, 99}
	change, _ := stats.PercentChange(data)
	fmt.Println(change)
}

Output:
[0.1 -0.1]

func Percentile ¶

func Percentile(input Float64Data, percent float64) (percentile float64, err error)

Percentile finds the relative standing in a slice of floats.

The function uses the Linear Interpolation Between Closest Ranks method as recommended by NIST [1] and used by Excel (PERCENTILE), Google Sheets, NumPy (default), and other standard tools.

Algorithm (for percent p and sorted data of length n):

1. Compute the rank: rank = (p / 100) * (n - 1)
2. Split into integer part k and fractional part f
3. Result = data[k] + f * (data[k+1] - data[k])

[1] https://www.itl.nist.gov/div898/handbook/prc/section2/prc262.htm

func PercentileNearestRank ¶

func PercentileNearestRank(input Float64Data, percent float64) (percentile float64, err error)

PercentileNearestRank finds the relative standing in a slice of floats using the Nearest Rank method

func PercentileOfScore ¶ added in v0.11.0

func PercentileOfScore(input Float64Data, score float64) (float64, error)

PercentileOfScore calculates the percentile rank of a score relative to a slice of floats, defined as the percentage of values strictly below the score plus half the percentage of values equal to the score. The result is between 0 and 100. This matches the behavior of Python's scipy.stats.percentileofscore with kind="rank".

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	rank, _ := stats.PercentileOfScore([]float64{1, 2, 3, 4}, 3)
	fmt.Println(rank)
}

Output:
62.5

func PercentileWeighted ¶ added in v0.10.0

func PercentileWeighted(data, weights Float64Data, percent float64) (percentile float64, err error)

PercentileWeighted finds the weighted percentile of a slice of floats using the weighted empirical CDF (inverse CDF / nearest-rank method).

For a given percent p, it returns the smallest data value x such that the cumulative weight of all values <= x is at least p% of the total weight. This matches the behavior of Python's statsmodels DescrStatsW.quantile.

The data and weights slices must be the same length. Weights must be non-negative and at least one weight must be positive. The percent parameter must be between 0 and 100 (exclusive).

func PopulationKurtosis ¶ added in v0.11.0

func PopulationKurtosis(input Float64Data) (float64, error)

PopulationKurtosis computes the population excess kurtosis (Fisher definition) using the fourth central moment normalized by the squared variance, so a normal distribution has a kurtosis of zero.

func PopulationSkewness ¶ added in v0.9.0

func PopulationSkewness(input Float64Data) (float64, error)

PopulationSkewness computes the population skewness using the third central moment normalized by the cube of the standard deviation.

func PopulationVariance ¶

func PopulationVariance(input Float64Data) (pvar float64, err error)

PopulationVariance finds the amount of variance within a population

func ProbGeom ¶ added in v0.7.0

func ProbGeom(a int, b int, p float64) (prob float64, err error)

ProbGeom generates the probability for a geometric random variable with parameter p to achieve success in the interval of [a, b] trials See https://en.wikipedia.org/wiki/Geometric_distribution for more information

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	p := 0.5
	a := 1
	b := 2
	chance, _ := stats.ProbGeom(a, b, p)
	fmt.Println(chance)
}

Output:
0.25

func Product ¶ added in v0.11.0

func Product(input Float64Data) (float64, error)

Product calculates the product of a slice of floats by multiplying the values from left to right. It is the scalar counterpart of CumulativeProduct. Large inputs can overflow to Inf; use GeometricMean for an overflow-safe summary of multiplicative data.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	product, _ := stats.Product([]float64{2, 3, 4})
	fmt.Println(product)
}

Output:
24

func RMS ¶ added in v0.11.0

func RMS(input Float64Data) (float64, error)

RMS calculates the root mean square of a slice of floats, defined as the square root of the mean of the squared values.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	rms, _ := stats.RMS([]float64{3, 4})
	fmt.Printf("%.4f", rms)
}

Output:
3.5355

func Range ¶ added in v0.10.0

func Range(input Float64Data) (float64, error)

Range finds the difference between the highest and lowest numbers in a slice

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	d := []float64{4, 1, 9}
	a, _ := stats.Range(d)
	fmt.Println(a)
}

Output:
8

func Rank ¶ added in v0.10.0

func Rank(input Float64Data) ([]float64, error)

Rank assigns fractional (average) ranks to the input values. Ranks are 1-based and tied values receive the average of the ranks they would have been assigned.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	r, _ := stats.Rank([]float64{3, 1, 4, 1})
	fmt.Println(r)
}

Output:
[3 1.5 4 1.5]

func Rescale ¶ added in v0.11.0

func Rescale(input Float64Data) ([]float64, error)

Rescale normalizes the input values to the range of 0 to 1 by subtracting the minimum and dividing by the range, also known as min-max normalization.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	r, _ := stats.Rescale([]float64{2, 4, 6})
	fmt.Println(r)
}

Output:
[0 0.5 1]

func Round ¶

func Round(input float64, places int) (rounded float64, err error)

Round a float to a specific decimal place or precision

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	rounded, _ := stats.Round(1.534424, 1)
	fmt.Println(rounded)
}

Output:
1.5

func SEM ¶ added in v0.11.0

func SEM(input Float64Data) (float64, error)

SEM calculates the standard error of the mean of a slice of floats, defined as the sample standard deviation divided by the square root of the sample size. This matches the behavior of Python's scipy.stats.sem with ddof=1.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	sem, _ := stats.SEM([]float64{1, 2, 3, 4, 5})
	fmt.Printf("%.4f", sem)
}

Output:
0.7071

func Sample ¶

func Sample(input Float64Data, takenum int, replacement bool) ([]float64, error)

Sample returns sample from input with replacement or without

func SampleKurtosis ¶ added in v0.11.0

func SampleKurtosis(input Float64Data) (float64, error)

SampleKurtosis computes the bias-corrected sample excess kurtosis, matching pandas .kurt() and scipy.stats.kurtosis with bias=False.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	k, _ := stats.SampleKurtosis([]float64{1, 2, 3, 4, 5})
	fmt.Printf("%.1f\n", k)
}

Output:
-1.2

func SampleSkewness ¶ added in v0.9.0

func SampleSkewness(input Float64Data) (float64, error)

SampleSkewness computes the adjusted Fisher-Pearson standardized moment coefficient, correcting for bias in small samples.

func SampleVariance ¶

func SampleVariance(input Float64Data) (svar float64, err error)

SampleVariance finds the amount of variance within a sample

func Sigmoid ¶ added in v0.5.0

func Sigmoid(input Float64Data) ([]float64, error)

Sigmoid returns the input values in the range of -1 to 1 along the sigmoid or s-shaped curve, commonly used in machine learning while training neural networks as an activation function.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	s, _ := stats.Sigmoid([]float64{3.0, 1.0, 2.1})
	fmt.Println(s)
}

Output:
[0.9525741268224334 0.7310585786300049 0.8909031788043871]

func Skewness ¶ added in v0.9.0

func Skewness(input Float64Data) (float64, error)

Skewness computes the population skewness of the dataset

func SoftMax ¶ added in v0.5.0

func SoftMax(input Float64Data) ([]float64, error)

SoftMax returns the input values in the range of 0 to 1 with sum of all the probabilities being equal to one. It is commonly used in machine learning neural networks.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	sm, _ := stats.SoftMax([]float64{3.0, 1.0, 0.2})
	fmt.Println(sm)
}

Output:
[0.8360188027814407 0.11314284146556013 0.05083835575299916]

func Spearman ¶ added in v0.10.0

func Spearman(data1, data2 Float64Data) (float64, error)

Spearman calculates the Spearman rank correlation coefficient between two variables. It works by ranking the data and then computing the Pearson correlation of the ranks. This method handles tied values using fractional (average) ranking.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	s1 := []float64{1, 2, 3, 4, 5}
	s2 := []float64{5, 6, 7, 8, 7}
	a, _ := stats.Spearman(s1, s2)
	rounded, _ := stats.Round(a, 5)
	fmt.Println(rounded)
}

Output:
0.82078

func StableSample ¶ added in v0.6.0

func StableSample(input Float64Data, takenum int) ([]float64, error)

StableSample like stable sort, it returns samples from input while keeps the order of original data.

func StandardDeviation ¶

func StandardDeviation(input Float64Data) (sdev float64, err error)

StandardDeviation the amount of variation in the dataset

func StandardDeviationPopulation ¶

func StandardDeviationPopulation(input Float64Data) (sdev float64, err error)

StandardDeviationPopulation finds the amount of variation from the population

func StandardDeviationSample ¶

func StandardDeviationSample(input Float64Data) (sdev float64, err error)

StandardDeviationSample finds the amount of variation from a sample

func StdDevP ¶

func StdDevP(input Float64Data) (sdev float64, err error)

StdDevP is a shortcut to StandardDeviationPopulation

func StdDevS ¶

func StdDevS(input Float64Data) (sdev float64, err error)

StdDevS is a shortcut to StandardDeviationSample

func Sum ¶

func Sum(input Float64Data) (sum float64, err error)

Sum adds all the numbers of a slice together

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	d := []float64{1.1, 2.2, 3.3}
	a, _ := stats.Sum(d)
	fmt.Println(a)
}

Output:
6.6

func TTest ¶ added in v0.10.0

func TTest(data1, data2 Float64Data, populationMean float64) (t float64, pvalue float64, err error)

TTest performs a one-sample or two-sample (independent) Student's t-test.

For a one-sample t-test, pass the sample data as data1, nil for data2, and the expected population mean as populationMean.

For a two-sample independent t-test (assuming equal variance), pass both sample datasets. The populationMean parameter is ignored in this case.

Returns the t statistic and the two-tailed p-value.

https://en.wikipedia.org/wiki/Student%27s_t-test

func Trimean ¶

func Trimean(input Float64Data) (float64, error)

Trimean finds the average of the median and the midhinge

func TrimmedMean ¶ added in v0.11.0

func TrimmedMean(input Float64Data, percent float64) (float64, error)

TrimmedMean finds the mean of a slice of floats after removing a fraction of the smallest and largest values. This matches the behavior of Python's scipy.stats.trim_mean.

The percent parameter is the fraction removed from each tail and must be in the range [0, 0.5). The number of elements trimmed from each tail is floor(len(input) * percent). A percent of zero returns the same result as Mean.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	tm, _ := stats.TrimmedMean([]float64{1, 2, 3, 4, 100}, 0.2)
	fmt.Println(tm)
}

Output:
3

func VarGeom ¶ added in v0.7.0

func VarGeom(p float64) (exp float64, err error)

ProbGeom generates the variance for number for a geometric random variable with parameter p

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	p := 0.5
	vari, _ := stats.VarGeom(p)
	fmt.Println(vari)
}

Output:
2

func VarP ¶

func VarP(input Float64Data) (sdev float64, err error)

VarP is a shortcut to PopulationVariance

func VarS ¶

func VarS(input Float64Data) (sdev float64, err error)

VarS is a shortcut to SampleVariance

func Variance ¶

func Variance(input Float64Data) (sdev float64, err error)

Variance the amount of variation in the dataset

func WeightedMean ¶ added in v0.10.0

func WeightedMean(data, weights Float64Data) (float64, error)

WeightedMean finds the weighted mean of a slice of floats, defined as the sum of each data value multiplied by its weight divided by the sum of all the weights. This matches the behavior of Python's numpy.average with the weights argument.

The data and weights slices must be the same length. Weights must be non-negative and at least one weight must be positive.

func Winsorize ¶ added in v0.11.0

func Winsorize(input Float64Data, percent float64) ([]float64, error)

Winsorize limits the effect of outliers in a slice of floats by clamping a fraction of the smallest and largest values. This matches the behavior of Python's scipy.stats.mstats.winsorize with symmetric limits.

The percent parameter is the fraction clamped in each tail and must be in the range [0, 0.5). With k = floor(len(input) * percent), values below the k-th smallest value are set to it and values above the k-th largest value are set to it. The returned slice preserves the original element order and a percent of zero returns a copy of the input.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	w, _ := stats.Winsorize([]float64{1, 2, 3, 4, 100}, 0.2)
	fmt.Println(w)
}

Output:
[2 2 3 4 4]

func ZScore ¶ added in v0.10.0

func ZScore(input Float64Data) ([]float64, error)

ZScore standardizes the input values by subtracting the mean and dividing by the sample standard deviation, returning the number of standard deviations each value is from the mean.

package main

import (
	"fmt"

	"github.com/montanaflynn/stats"
)

func main() {
	z, _ := stats.ZScore([]float64{2, 4, 6})
	fmt.Println(z)
}

Output:
[-1 0 1]

func ZTest ¶ added in v0.10.0

func ZTest(data1, data2 Float64Data, populationMean, populationStdDev float64) (z float64, pvalue float64, err error)

ZTest performs a one-sample or two-sample Z-test.

For a one-sample Z-test, pass the sample data as data1, nil for data2, the known population mean as populationMean, and the known population standard deviation as populationStdDev.

For a two-sample Z-test, pass both sample datasets and the known population standard deviations. The populationMean parameter is ignored in this case.

Returns the Z statistic and the two-tailed p-value.

https://en.wikipedia.org/wiki/Z-test