commit 05657cd5a8b3d838bd4b205d32d468767f13aeec Author: upstream Date: Thu Sep 3 14:05:13 2026 +0200 Upstream montanaflynn/stats state of the touched files before 9ead4dd879 diff --git a/DOCUMENTATION.md b/DOCUMENTATION.md new file mode 100644 index 0000000..a7a75a8 --- /dev/null +++ b/DOCUMENTATION.md @@ -0,0 +1,2236 @@ + + +# stats +`import "github.com/montanaflynn/stats"` + +* [Overview](#pkg-overview) +* [Index](#pkg-index) +* [Examples](#pkg-examples) +* [Subdirectories](#pkg-subdirectories) + +## Overview +Package stats is a well tested and comprehensive +statistics library package with no dependencies. + +Example Usage: + + + // start with some source data to use + data := []float64{1.0, 2.1, 3.2, 4.823, 4.1, 5.8} + + // you could also use different types like this + // data := stats.LoadRawData([]int{1, 2, 3, 4, 5}) + // data := stats.LoadRawData([]interface{}{1.1, "2", 3}) + // etc... + + median, _ := stats.Median(data) + fmt.Println(median) // 3.65 + + roundedMedian, _ := stats.Round(median, 0) + fmt.Println(roundedMedian) // 4 + +MIT License Copyright (c) 2014-2026 Montana Flynn (https://montanaflynn.com) + + + + +## Index +* [Variables](#pkg-variables) +* [func ArgMax(input Float64Data) (int, error)](#ArgMax) +* [func ArgMin(input Float64Data) (int, error)](#ArgMin) +* [func AutoCorrelation(data Float64Data, lags int) (float64, error)](#AutoCorrelation) +* [func ChebyshevDistance(dataPointX, dataPointY Float64Data) (distance float64, err error)](#ChebyshevDistance) +* [func Clip(input Float64Data, min, max float64) ([]float64, error)](#Clip) +* [func CoefficientOfVariation(input Float64Data) (float64, error)](#CoefficientOfVariation) +* [func Correlation(data1, data2 Float64Data) (float64, error)](#Correlation) +* [func Covariance(data1, data2 Float64Data) (float64, error)](#Covariance) +* [func CovariancePopulation(data1, data2 Float64Data) (float64, error)](#CovariancePopulation) +* [func CumulativeMax(input Float64Data) ([]float64, error)](#CumulativeMax) +* [func CumulativeMin(input Float64Data) ([]float64, error)](#CumulativeMin) +* [func CumulativeProduct(input Float64Data) ([]float64, error)](#CumulativeProduct) +* [func CumulativeSum(input Float64Data) ([]float64, error)](#CumulativeSum) +* [func Diff(input Float64Data) ([]float64, error)](#Diff) +* [func EWMA(input Float64Data, alpha float64) ([]float64, error)](#EWMA) +* [func Entropy(input Float64Data) (float64, error)](#Entropy) +* [func EuclideanDistance(dataPointX, dataPointY Float64Data) (distance float64, err error)](#EuclideanDistance) +* [func ExpGeom(p float64) (exp float64, err error)](#ExpGeom) +* [func GeometricMean(input Float64Data) (float64, error)](#GeometricMean) +* [func HarmonicMean(input Float64Data) (float64, error)](#HarmonicMean) +* [func Histogram(input Float64Data, bins int) ([]int, []float64, error)](#Histogram) +* [func InterQuartileRange(input Float64Data) (float64, error)](#InterQuartileRange) +* [func Interp(x, xp, fp Float64Data) ([]float64, error)](#Interp) +* [func KendallTau(data1, data2 Float64Data) (float64, error)](#KendallTau) +* [func Kurtosis(input Float64Data) (float64, error)](#Kurtosis) +* [func ManhattanDistance(dataPointX, dataPointY Float64Data) (distance float64, err error)](#ManhattanDistance) +* [func Max(input Float64Data) (max float64, err error)](#Max) +* [func Mean(input Float64Data) (float64, error)](#Mean) +* [func Median(input Float64Data) (median float64, err error)](#Median) +* [func MedianAbsoluteDeviation(input Float64Data) (mad float64, err error)](#MedianAbsoluteDeviation) +* [func MedianAbsoluteDeviationPopulation(input Float64Data) (mad float64, err error)](#MedianAbsoluteDeviationPopulation) +* [func Midhinge(input Float64Data) (float64, error)](#Midhinge) +* [func Min(input Float64Data) (min float64, err error)](#Min) +* [func MinkowskiDistance(dataPointX, dataPointY Float64Data, lambda float64) (distance float64, err error)](#MinkowskiDistance) +* [func Mode(input Float64Data) (mode []float64, err error)](#Mode) +* [func MovingAverage(input Float64Data, window int) ([]float64, error)](#MovingAverage) +* [func MovingMax(input Float64Data, window int) ([]float64, error)](#MovingMax) +* [func MovingMedian(input Float64Data, window int) ([]float64, error)](#MovingMedian) +* [func MovingMin(input Float64Data, window int) ([]float64, error)](#MovingMin) +* [func MovingStdDev(input Float64Data, window int) ([]float64, error)](#MovingStdDev) +* [func MovingSum(input Float64Data, window int) ([]float64, error)](#MovingSum) +* [func Ncr(n, r int) int](#Ncr) +* [func NormBoxMullerRvs(loc float64, scale float64, size int) []float64](#NormBoxMullerRvs) +* [func NormCdf(x float64, loc float64, scale float64) float64](#NormCdf) +* [func NormEntropy(loc float64, scale float64) float64](#NormEntropy) +* [func NormFit(data []float64) [2]float64](#NormFit) +* [func NormInterval(alpha float64, loc float64, scale float64) [2]float64](#NormInterval) +* [func NormIsf(p float64, loc float64, scale float64) float64](#NormIsf) +* [func NormLogCdf(x float64, loc float64, scale float64) float64](#NormLogCdf) +* [func NormLogPdf(x float64, loc float64, scale float64) float64](#NormLogPdf) +* [func NormLogSf(x float64, loc float64, scale float64) float64](#NormLogSf) +* [func NormMean(loc float64, scale float64) float64](#NormMean) +* [func NormMedian(loc float64, scale float64) float64](#NormMedian) +* [func NormMoment(n int, loc float64, scale float64) float64](#NormMoment) +* [func NormPdf(x float64, loc float64, scale float64) float64](#NormPdf) +* [func NormPpf(p float64, loc float64, scale float64) (x float64)](#NormPpf) +* [func NormPpfRvs(loc float64, scale float64, size int) []float64](#NormPpfRvs) +* [func NormSample(loc float64, scale float64, size int) []float64](#NormSample) +* [func NormSf(x float64, loc float64, scale float64) float64](#NormSf) +* [func NormStats(loc float64, scale float64, moments string) []float64](#NormStats) +* [func NormStd(loc float64, scale float64) float64](#NormStd) +* [func NormVar(loc float64, scale float64) float64](#NormVar) +* [func Pearson(data1, data2 Float64Data) (float64, error)](#Pearson) +* [func PercentChange(input Float64Data) ([]float64, error)](#PercentChange) +* [func Percentile(input Float64Data, percent float64) (percentile float64, err error)](#Percentile) +* [func PercentileNearestRank(input Float64Data, percent float64) (percentile float64, err error)](#PercentileNearestRank) +* [func PercentileOfScore(input Float64Data, score float64) (float64, error)](#PercentileOfScore) +* [func PercentileWeighted(data, weights Float64Data, percent float64) (percentile float64, err error)](#PercentileWeighted) +* [func PopulationKurtosis(input Float64Data) (float64, error)](#PopulationKurtosis) +* [func PopulationSkewness(input Float64Data) (float64, error)](#PopulationSkewness) +* [func PopulationVariance(input Float64Data) (pvar float64, err error)](#PopulationVariance) +* [func ProbGeom(a int, b int, p float64) (prob float64, err error)](#ProbGeom) +* [func Product(input Float64Data) (float64, error)](#Product) +* [func RMS(input Float64Data) (float64, error)](#RMS) +* [func Range(input Float64Data) (float64, error)](#Range) +* [func Rank(input Float64Data) ([]float64, error)](#Rank) +* [func Rescale(input Float64Data) ([]float64, error)](#Rescale) +* [func Round(input float64, places int) (rounded float64, err error)](#Round) +* [func SEM(input Float64Data) (float64, error)](#SEM) +* [func Sample(input Float64Data, takenum int, replacement bool) ([]float64, error)](#Sample) +* [func SampleKurtosis(input Float64Data) (float64, error)](#SampleKurtosis) +* [func SampleSkewness(input Float64Data) (float64, error)](#SampleSkewness) +* [func SampleVariance(input Float64Data) (svar float64, err error)](#SampleVariance) +* [func Sigmoid(input Float64Data) ([]float64, error)](#Sigmoid) +* [func Skewness(input Float64Data) (float64, error)](#Skewness) +* [func SoftMax(input Float64Data) ([]float64, error)](#SoftMax) +* [func Spearman(data1, data2 Float64Data) (float64, error)](#Spearman) +* [func StableSample(input Float64Data, takenum int) ([]float64, error)](#StableSample) +* [func StandardDeviation(input Float64Data) (sdev float64, err error)](#StandardDeviation) +* [func StandardDeviationPopulation(input Float64Data) (sdev float64, err error)](#StandardDeviationPopulation) +* [func StandardDeviationSample(input Float64Data) (sdev float64, err error)](#StandardDeviationSample) +* [func StdDevP(input Float64Data) (sdev float64, err error)](#StdDevP) +* [func StdDevS(input Float64Data) (sdev float64, err error)](#StdDevS) +* [func Sum(input Float64Data) (sum float64, err error)](#Sum) +* [func TTest(data1, data2 Float64Data, populationMean float64) (t float64, pvalue float64, err error)](#TTest) +* [func Trimean(input Float64Data) (float64, error)](#Trimean) +* [func TrimmedMean(input Float64Data, percent float64) (float64, error)](#TrimmedMean) +* [func VarGeom(p float64) (exp float64, err error)](#VarGeom) +* [func VarP(input Float64Data) (sdev float64, err error)](#VarP) +* [func VarS(input Float64Data) (sdev float64, err error)](#VarS) +* [func Variance(input Float64Data) (sdev float64, err error)](#Variance) +* [func WeightedMean(data, weights Float64Data) (float64, error)](#WeightedMean) +* [func Winsorize(input Float64Data, percent float64) ([]float64, error)](#Winsorize) +* [func ZScore(input Float64Data) ([]float64, error)](#ZScore) +* [func ZTest(data1, data2 Float64Data, populationMean, populationStdDev float64) (z float64, pvalue float64, err error)](#ZTest) +* [type Coordinate](#Coordinate) + * [func ExpReg(s []Coordinate) (regressions []Coordinate, err error)](#ExpReg) + * [func LinReg(s []Coordinate) (regressions []Coordinate, err error)](#LinReg) + * [func LogReg(s []Coordinate) (regressions []Coordinate, err error)](#LogReg) +* [type Description](#Description) + * [func Describe(input Float64Data, allowNaN bool, percentiles *[]float64) (*Description, error)](#Describe) + * [func DescribePercentileFunc(input Float64Data, allowNaN bool, percentiles *[]float64, percentileFunc func(Float64Data, float64) (float64, error)) (*Description, error)](#DescribePercentileFunc) + * [func (d *Description) String(decimals int) string](#Description.String) +* [type Float64Data](#Float64Data) + * [func LoadRawData(raw interface{}) (f Float64Data)](#LoadRawData) + * [func (f Float64Data) ArgMax() (int, error)](#Float64Data.ArgMax) + * [func (f Float64Data) ArgMin() (int, error)](#Float64Data.ArgMin) + * [func (f Float64Data) AutoCorrelation(lags int) (float64, error)](#Float64Data.AutoCorrelation) + * [func (f Float64Data) Clip(min, max float64) ([]float64, error)](#Float64Data.Clip) + * [func (f Float64Data) CoefficientOfVariation() (float64, error)](#Float64Data.CoefficientOfVariation) + * [func (f Float64Data) Correlation(d Float64Data) (float64, error)](#Float64Data.Correlation) + * [func (f Float64Data) Covariance(d Float64Data) (float64, error)](#Float64Data.Covariance) + * [func (f Float64Data) CovariancePopulation(d Float64Data) (float64, error)](#Float64Data.CovariancePopulation) + * [func (f Float64Data) CumulativeMax() ([]float64, error)](#Float64Data.CumulativeMax) + * [func (f Float64Data) CumulativeMin() ([]float64, error)](#Float64Data.CumulativeMin) + * [func (f Float64Data) CumulativeProduct() ([]float64, error)](#Float64Data.CumulativeProduct) + * [func (f Float64Data) CumulativeSum() ([]float64, error)](#Float64Data.CumulativeSum) + * [func (f Float64Data) Diff() ([]float64, error)](#Float64Data.Diff) + * [func (f Float64Data) EWMA(alpha float64) ([]float64, error)](#Float64Data.EWMA) + * [func (f Float64Data) Entropy() (float64, error)](#Float64Data.Entropy) + * [func (f Float64Data) GeometricMean() (float64, error)](#Float64Data.GeometricMean) + * [func (f Float64Data) Get(i int) float64](#Float64Data.Get) + * [func (f Float64Data) HarmonicMean() (float64, error)](#Float64Data.HarmonicMean) + * [func (f Float64Data) Histogram(bins int) ([]int, []float64, error)](#Float64Data.Histogram) + * [func (f Float64Data) InterQuartileRange() (float64, error)](#Float64Data.InterQuartileRange) + * [func (f Float64Data) KendallTau(d Float64Data) (float64, error)](#Float64Data.KendallTau) + * [func (f Float64Data) Kurtosis() (float64, error)](#Float64Data.Kurtosis) + * [func (f Float64Data) Len() int](#Float64Data.Len) + * [func (f Float64Data) Less(i, j int) bool](#Float64Data.Less) + * [func (f Float64Data) Max() (float64, error)](#Float64Data.Max) + * [func (f Float64Data) Mean() (float64, error)](#Float64Data.Mean) + * [func (f Float64Data) Median() (float64, error)](#Float64Data.Median) + * [func (f Float64Data) MedianAbsoluteDeviation() (float64, error)](#Float64Data.MedianAbsoluteDeviation) + * [func (f Float64Data) MedianAbsoluteDeviationPopulation() (float64, error)](#Float64Data.MedianAbsoluteDeviationPopulation) + * [func (f Float64Data) Midhinge(d Float64Data) (float64, error)](#Float64Data.Midhinge) + * [func (f Float64Data) Min() (float64, error)](#Float64Data.Min) + * [func (f Float64Data) Mode() ([]float64, error)](#Float64Data.Mode) + * [func (f Float64Data) MovingAverage(window int) ([]float64, error)](#Float64Data.MovingAverage) + * [func (f Float64Data) MovingMax(window int) ([]float64, error)](#Float64Data.MovingMax) + * [func (f Float64Data) MovingMedian(window int) ([]float64, error)](#Float64Data.MovingMedian) + * [func (f Float64Data) MovingMin(window int) ([]float64, error)](#Float64Data.MovingMin) + * [func (f Float64Data) MovingStdDev(window int) ([]float64, error)](#Float64Data.MovingStdDev) + * [func (f Float64Data) MovingSum(window int) ([]float64, error)](#Float64Data.MovingSum) + * [func (f Float64Data) Pearson(d Float64Data) (float64, error)](#Float64Data.Pearson) + * [func (f Float64Data) PercentChange() ([]float64, error)](#Float64Data.PercentChange) + * [func (f Float64Data) Percentile(p float64) (float64, error)](#Float64Data.Percentile) + * [func (f Float64Data) PercentileNearestRank(p float64) (float64, error)](#Float64Data.PercentileNearestRank) + * [func (f Float64Data) PercentileOfScore(score float64) (float64, error)](#Float64Data.PercentileOfScore) + * [func (f Float64Data) PopulationKurtosis() (float64, error)](#Float64Data.PopulationKurtosis) + * [func (f Float64Data) PopulationVariance() (float64, error)](#Float64Data.PopulationVariance) + * [func (f Float64Data) Product() (float64, error)](#Float64Data.Product) + * [func (f Float64Data) Quartile(d Float64Data) (Quartiles, error)](#Float64Data.Quartile) + * [func (f Float64Data) QuartileOutliers() (Outliers, error)](#Float64Data.QuartileOutliers) + * [func (f Float64Data) Quartiles() (Quartiles, error)](#Float64Data.Quartiles) + * [func (f Float64Data) RMS() (float64, error)](#Float64Data.RMS) + * [func (f Float64Data) Range() (float64, error)](#Float64Data.Range) + * [func (f Float64Data) Rank() ([]float64, error)](#Float64Data.Rank) + * [func (f Float64Data) Rescale() ([]float64, error)](#Float64Data.Rescale) + * [func (f Float64Data) SEM() (float64, error)](#Float64Data.SEM) + * [func (f Float64Data) Sample(n int, r bool) ([]float64, error)](#Float64Data.Sample) + * [func (f Float64Data) SampleKurtosis() (float64, error)](#Float64Data.SampleKurtosis) + * [func (f Float64Data) SampleVariance() (float64, error)](#Float64Data.SampleVariance) + * [func (f Float64Data) Sigmoid() ([]float64, error)](#Float64Data.Sigmoid) + * [func (f Float64Data) SoftMax() ([]float64, error)](#Float64Data.SoftMax) + * [func (f Float64Data) Spearman(d Float64Data) (float64, error)](#Float64Data.Spearman) + * [func (f Float64Data) StandardDeviation() (float64, error)](#Float64Data.StandardDeviation) + * [func (f Float64Data) StandardDeviationPopulation() (float64, error)](#Float64Data.StandardDeviationPopulation) + * [func (f Float64Data) StandardDeviationSample() (float64, error)](#Float64Data.StandardDeviationSample) + * [func (f Float64Data) Sum() (float64, error)](#Float64Data.Sum) + * [func (f Float64Data) Swap(i, j int)](#Float64Data.Swap) + * [func (f Float64Data) Trimean(d Float64Data) (float64, error)](#Float64Data.Trimean) + * [func (f Float64Data) TrimmedMean(percent float64) (float64, error)](#Float64Data.TrimmedMean) + * [func (f Float64Data) Variance() (float64, error)](#Float64Data.Variance) + * [func (f Float64Data) WeightedMean(weights Float64Data) (float64, error)](#Float64Data.WeightedMean) + * [func (f Float64Data) Winsorize(percent float64) ([]float64, error)](#Float64Data.Winsorize) + * [func (f Float64Data) ZScore() ([]float64, error)](#Float64Data.ZScore) +* [type Outliers](#Outliers) + * [func QuartileOutliers(input Float64Data) (Outliers, error)](#QuartileOutliers) +* [type Quartiles](#Quartiles) + * [func Quartile(input Float64Data) (Quartiles, error)](#Quartile) +* [type Series](#Series) + * [func ExponentialRegression(s Series) (regressions Series, err error)](#ExponentialRegression) + * [func LinearRegression(s Series) (regressions Series, err error)](#LinearRegression) + * [func LogarithmicRegression(s Series) (regressions Series, err error)](#LogarithmicRegression) + +#### Examples +* [ArgMax](#example_ArgMax) +* [ArgMin](#example_ArgMin) +* [AutoCorrelation](#example_AutoCorrelation) +* [ChebyshevDistance](#example_ChebyshevDistance) +* [Clip](#example_Clip) +* [Correlation](#example_Correlation) +* [CumulativeMax](#example_CumulativeMax) +* [CumulativeMin](#example_CumulativeMin) +* [CumulativeProduct](#example_CumulativeProduct) +* [CumulativeSum](#example_CumulativeSum) +* [Diff](#example_Diff) +* [EWMA](#example_EWMA) +* [Entropy](#example_Entropy) +* [ExpGeom](#example_ExpGeom) +* [Histogram](#example_Histogram) +* [Interp](#example_Interp) +* [KendallTau](#example_KendallTau) +* [Kurtosis](#example_Kurtosis) +* [LinearRegression](#example_LinearRegression) +* [LoadRawData](#example_LoadRawData) +* [Max](#example_Max) +* [Median](#example_Median) +* [Min](#example_Min) +* [MovingAverage](#example_MovingAverage) +* [MovingMax](#example_MovingMax) +* [MovingMedian](#example_MovingMedian) +* [MovingMin](#example_MovingMin) +* [MovingStdDev](#example_MovingStdDev) +* [MovingSum](#example_MovingSum) +* [PercentChange](#example_PercentChange) +* [PercentileOfScore](#example_PercentileOfScore) +* [ProbGeom](#example_ProbGeom) +* [Product](#example_Product) +* [RMS](#example_RMS) +* [Range](#example_Range) +* [Rank](#example_Rank) +* [Rescale](#example_Rescale) +* [Round](#example_Round) +* [SEM](#example_SEM) +* [SampleKurtosis](#example_SampleKurtosis) +* [Sigmoid](#example_Sigmoid) +* [SoftMax](#example_SoftMax) +* [Spearman](#example_Spearman) +* [Sum](#example_Sum) +* [TrimmedMean](#example_TrimmedMean) +* [VarGeom](#example_VarGeom) +* [Winsorize](#example_Winsorize) +* [ZScore](#example_ZScore) + +#### Package files +[clip.go](/src/github.com/montanaflynn/stats/clip.go) [coefficient_of_variation.go](/src/github.com/montanaflynn/stats/coefficient_of_variation.go) [correlation.go](/src/github.com/montanaflynn/stats/correlation.go) [cumulative.go](/src/github.com/montanaflynn/stats/cumulative.go) [cumulative_sum.go](/src/github.com/montanaflynn/stats/cumulative_sum.go) [data.go](/src/github.com/montanaflynn/stats/data.go) [describe.go](/src/github.com/montanaflynn/stats/describe.go) [deviation.go](/src/github.com/montanaflynn/stats/deviation.go) [diff.go](/src/github.com/montanaflynn/stats/diff.go) [distances.go](/src/github.com/montanaflynn/stats/distances.go) [doc.go](/src/github.com/montanaflynn/stats/doc.go) [entropy.go](/src/github.com/montanaflynn/stats/entropy.go) [errors.go](/src/github.com/montanaflynn/stats/errors.go) [ewma.go](/src/github.com/montanaflynn/stats/ewma.go) [extremes.go](/src/github.com/montanaflynn/stats/extremes.go) [geometric_distribution.go](/src/github.com/montanaflynn/stats/geometric_distribution.go) [histogram.go](/src/github.com/montanaflynn/stats/histogram.go) [interp.go](/src/github.com/montanaflynn/stats/interp.go) [kendall.go](/src/github.com/montanaflynn/stats/kendall.go) [kurtosis.go](/src/github.com/montanaflynn/stats/kurtosis.go) [legacy.go](/src/github.com/montanaflynn/stats/legacy.go) [load.go](/src/github.com/montanaflynn/stats/load.go) [max.go](/src/github.com/montanaflynn/stats/max.go) [mean.go](/src/github.com/montanaflynn/stats/mean.go) [median.go](/src/github.com/montanaflynn/stats/median.go) [min.go](/src/github.com/montanaflynn/stats/min.go) [mode.go](/src/github.com/montanaflynn/stats/mode.go) [moving.go](/src/github.com/montanaflynn/stats/moving.go) [norm.go](/src/github.com/montanaflynn/stats/norm.go) [outlier.go](/src/github.com/montanaflynn/stats/outlier.go) [percentile.go](/src/github.com/montanaflynn/stats/percentile.go) [percentile_of_score.go](/src/github.com/montanaflynn/stats/percentile_of_score.go) [percentile_weighted.go](/src/github.com/montanaflynn/stats/percentile_weighted.go) [product.go](/src/github.com/montanaflynn/stats/product.go) [quartile.go](/src/github.com/montanaflynn/stats/quartile.go) [rank.go](/src/github.com/montanaflynn/stats/rank.go) [ranksum.go](/src/github.com/montanaflynn/stats/ranksum.go) [regression.go](/src/github.com/montanaflynn/stats/regression.go) [rescale.go](/src/github.com/montanaflynn/stats/rescale.go) [rms.go](/src/github.com/montanaflynn/stats/rms.go) [rolling.go](/src/github.com/montanaflynn/stats/rolling.go) [round.go](/src/github.com/montanaflynn/stats/round.go) [sample.go](/src/github.com/montanaflynn/stats/sample.go) [sem.go](/src/github.com/montanaflynn/stats/sem.go) [sigmoid.go](/src/github.com/montanaflynn/stats/sigmoid.go) [skewness.go](/src/github.com/montanaflynn/stats/skewness.go) [softmax.go](/src/github.com/montanaflynn/stats/softmax.go) [sum.go](/src/github.com/montanaflynn/stats/sum.go) [trimmed_mean.go](/src/github.com/montanaflynn/stats/trimmed_mean.go) [ttest.go](/src/github.com/montanaflynn/stats/ttest.go) [util.go](/src/github.com/montanaflynn/stats/util.go) [variance.go](/src/github.com/montanaflynn/stats/variance.go) [weighted_mean.go](/src/github.com/montanaflynn/stats/weighted_mean.go) [winsorize.go](/src/github.com/montanaflynn/stats/winsorize.go) [zscore.go](/src/github.com/montanaflynn/stats/zscore.go) [ztest.go](/src/github.com/montanaflynn/stats/ztest.go) + + + +## Variables +``` go +var ( + // ErrEmptyInput Input must not be empty + ErrEmptyInput = statsError{"Input must not be empty."} + // ErrNaN Not a number + ErrNaN = statsError{"Not a number."} + // ErrNegative Must not contain negative values + ErrNegative = statsError{"Must not contain negative values."} + // ErrZero Must not contain zero values + ErrZero = statsError{"Must not contain zero values."} + // ErrBounds Input is outside of range + ErrBounds = statsError{"Input is outside of range."} + // ErrSize Must be the same length + ErrSize = statsError{"Must be the same length."} + // ErrInfValue Value is infinite + ErrInfValue = statsError{"Value is infinite."} + // ErrYCoord Y Value must be greater than zero + ErrYCoord = statsError{"Y Value must be greater than zero."} +) +``` +These are the package-wide error values. +All error identification should use these values. +https://github.com/golang/go/wiki/Errors#naming + +``` go +var ( + EmptyInputErr = ErrEmptyInput + NaNErr = ErrNaN + NegativeErr = ErrNegative + ZeroErr = ErrZero + BoundsErr = ErrBounds + SizeErr = ErrSize + InfValue = ErrInfValue + YCoordErr = ErrYCoord + EmptyInput = ErrEmptyInput +) +``` +Legacy error names that didn't start with Err + + + +## func [ArgMax](/extremes.go?s=129:172#L5) +``` go +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 + + + +## func [ArgMin](/extremes.go?s=671:714#L28) +``` go +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 + + + +## func [AutoCorrelation](/correlation.go?s=2282:2347#L102) +``` go +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 + + + +## func [ChebyshevDistance](/distances.go?s=368:456#L20) +``` go +func ChebyshevDistance(dataPointX, dataPointY Float64Data) (distance float64, err error) +``` +ChebyshevDistance computes the Chebyshev distance between two data sets + + + +## func [Clip](/clip.go?s=109:174#L5) +``` go +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. + + + +## func [CoefficientOfVariation](/coefficient_of_variation.go?s=322:385#L11) +``` go +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](/correlation.go?s=120:179#L9) +``` go +func Correlation(data1, data2 Float64Data) (float64, error) +``` +Correlation describes the degree of relationship between two sets of data + + + +## func [Covariance](/variance.go?s=1284:1342#L53) +``` go +func Covariance(data1, data2 Float64Data) (float64, error) +``` +Covariance is a measure of how much two sets of data change + + + +## func [CovariancePopulation](/variance.go?s=1864:1932#L81) +``` go +func CovariancePopulation(data1, data2 Float64Data) (float64, error) +``` +CovariancePopulation computes covariance for entire population between two variables. + + + +## func [CumulativeMax](/cumulative.go?s=486:542#L24) +``` go +func CumulativeMax(input Float64Data) ([]float64, error) +``` +CumulativeMax calculates the cumulative maximum of the input slice + + + +## func [CumulativeMin](/cumulative.go?s=874:930#L44) +``` go +func CumulativeMin(input Float64Data) ([]float64, error) +``` +CumulativeMin calculates the cumulative minimum of the input slice + + + +## func [CumulativeProduct](/cumulative.go?s=89:149#L4) +``` go +func CumulativeProduct(input Float64Data) ([]float64, error) +``` +CumulativeProduct calculates the cumulative product of the input slice + + + +## func [CumulativeSum](/cumulative_sum.go?s=81:137#L4) +``` go +func CumulativeSum(input Float64Data) ([]float64, error) +``` +CumulativeSum calculates the cumulative sum of the input slice + + + +## func [Diff](/diff.go?s=238:285#L7) +``` go +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. + + + +## func [EWMA](/ewma.go?s=392:454#L9) +``` go +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. + + + +## func [Entropy](/entropy.go?s=77:125#L6) +``` go +func Entropy(input Float64Data) (float64, error) +``` +Entropy provides calculation of the entropy + + + +## func [EuclideanDistance](/distances.go?s=836:924#L36) +``` go +func EuclideanDistance(dataPointX, dataPointY Float64Data) (distance float64, err error) +``` +EuclideanDistance computes the Euclidean distance between two data sets + + + +## func [ExpGeom](/geometric_distribution.go?s=816:864#L28) +``` go +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 + + + +## func [GeometricMean](/mean.go?s=319:373#L18) +``` go +func GeometricMean(input Float64Data) (float64, error) +``` +GeometricMean gets the geometric mean for a slice of numbers + + + +## func [HarmonicMean](/mean.go?s=842:895#L41) +``` go +func HarmonicMean(input Float64Data) (float64, error) +``` +HarmonicMean gets the harmonic mean for a slice of numbers + + + +## func [Histogram](/histogram.go?s=327:396#L10) +``` go +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. + + + +## func [InterQuartileRange](/quartile.go?s=821:880#L45) +``` go +func InterQuartileRange(input Float64Data) (float64, error) +``` +InterQuartileRange finds the range between Q1 and Q3 + + + +## func [Interp](/interp.go?s=635:688#L16) +``` go +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. +A NaN in xp returns ErrBounds and a NaN in x gives a NaN in the output. + + + +## func [KendallTau](/kendall.go?s=302:360#L9) +``` go +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. + + + +## func [Kurtosis](/kurtosis.go?s=97:146#L6) +``` go +func Kurtosis(input Float64Data) (float64, error) +``` +Kurtosis computes the population excess kurtosis of the dataset + + + +## func [ManhattanDistance](/distances.go?s=1277:1365#L50) +``` go +func ManhattanDistance(dataPointX, dataPointY Float64Data) (distance float64, err error) +``` +ManhattanDistance computes the Manhattan distance between two data sets + + + +## func [Max](/max.go?s=78:130#L8) +``` go +func Max(input Float64Data) (max float64, err error) +``` +Max finds the highest number in a slice + + + +## func [Mean](/mean.go?s=77:122#L6) +``` go +func Mean(input Float64Data) (float64, error) +``` +Mean gets the average of a slice of numbers + + + +## func [Median](/median.go?s=85:143#L6) +``` go +func Median(input Float64Data) (median float64, err error) +``` +Median gets the median number in a slice of numbers + + + +## func [MedianAbsoluteDeviation](/deviation.go?s=125:197#L6) +``` go +func MedianAbsoluteDeviation(input Float64Data) (mad float64, err error) +``` +MedianAbsoluteDeviation finds the median of the absolute deviations from the dataset median + + + +## func [MedianAbsoluteDeviationPopulation](/deviation.go?s=360:442#L11) +``` go +func MedianAbsoluteDeviationPopulation(input Float64Data) (mad float64, err error) +``` +MedianAbsoluteDeviationPopulation finds the median of the absolute deviations from the population median + + + +## func [Midhinge](/quartile.go?s=1075:1124#L55) +``` go +func Midhinge(input Float64Data) (float64, error) +``` +Midhinge finds the average of the first and third quartiles + + + +## func [Min](/min.go?s=78:130#L6) +``` go +func Min(input Float64Data) (min float64, err error) +``` +Min finds the lowest number in a set of data + + + +## func [MinkowskiDistance](/distances.go?s=2133:2237#L78) +``` go +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](/mode.go?s=85:141#L4) +``` go +func Mode(input Float64Data) (mode []float64, err error) +``` +Mode gets the mode [most frequent value(s)] of a slice of float64s + + + +## func [MovingAverage](/rolling.go?s=362:430#L8) +``` go +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. + + + +## func [MovingMax](/moving.go?s=1892:1956#L60) +``` go +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. + + + +## func [MovingMedian](/moving.go?s=365:432#L8) +``` go +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. + + + +## func [MovingMin](/moving.go?s=1136:1200#L34) +``` go +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. + + + +## func [MovingStdDev](/rolling.go?s=1239:1306#L36) +``` go +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. + + + +## func [MovingSum](/moving.go?s=2640:2704#L86) +``` go +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. + + + +## func [Ncr](/norm.go?s=8827:8849#L277) +``` go +func Ncr(n, r int) int +``` +Ncr is an N choose R algorithm. +Aaron Cannon's algorithm. + + + +## func [NormBoxMullerRvs](/norm.go?s=906:975#L29) +``` go +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](/norm.go?s=2034:2093#L59) +``` go +func NormCdf(x float64, loc float64, scale float64) float64 +``` +NormCdf is the cumulative distribution function. + + + +## func [NormEntropy](/norm.go?s=7117:7169#L219) +``` go +func NormEntropy(loc float64, scale float64) float64 +``` +NormEntropy is the differential entropy of the RV. + + + +## func [NormFit](/norm.go?s=7402:7441#L226) +``` go +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](/norm.go?s=8320:8391#L260) +``` go +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](/norm.go?s=5589:5648#L177) +``` go +func NormIsf(p float64, loc float64, scale float64) float64 +``` +NormIsf is the inverse survival function (inverse of sf). + + + +## func [NormLogCdf](/norm.go?s=2218:2280#L64) +``` go +func NormLogCdf(x float64, loc float64, scale float64) float64 +``` +NormLogCdf is the log of the cumulative distribution function. + + + +## func [NormLogPdf](/norm.go?s=1829:1891#L53) +``` go +func NormLogPdf(x float64, loc float64, scale float64) float64 +``` +NormLogPdf is the log of the probability density function. + + + +## func [NormLogSf](/norm.go?s=2664:2725#L78) +``` go +func NormLogSf(x float64, loc float64, scale float64) float64 +``` +NormLogSf is the log of the survival function. + + + +## func [NormMean](/norm.go?s=7904:7953#L245) +``` go +func NormMean(loc float64, scale float64) float64 +``` +NormMean is the mean/expected value of the distribution. + + + +## func [NormMedian](/norm.go?s=7775:7826#L240) +``` go +func NormMedian(loc float64, scale float64) float64 +``` +NormMedian is the median of the distribution. + + + +## func [NormMoment](/norm.go?s=6038:6096#L185) +``` go +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](/norm.go?s=1596:1655#L48) +``` go +func NormPdf(x float64, loc float64, scale float64) float64 +``` +NormPdf is the probability density function. + + + +## func [NormPpf](/norm.go?s=3828:3891#L107) +``` go +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](/norm.go?s=486:549#L18) +``` go +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](/norm.go?s=194:257#L12) +``` go +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](/norm.go?s=2498:2556#L73) +``` go +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](/norm.go?s=6621:6689#L201) +``` go +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](/norm.go?s=8158:8206#L255) +``` go +func NormStd(loc float64, scale float64) float64 +``` +NormStd is the standard deviation of the distribution. + + + +## func [NormVar](/norm.go?s=8019:8067#L250) +``` go +func NormVar(loc float64, scale float64) float64 +``` +NormVar is the variance of the distribution. + + + +## func [Pearson](/correlation.go?s=663:718#L34) +``` go +func Pearson(data1, data2 Float64Data) (float64, error) +``` +Pearson calculates the Pearson product-moment correlation coefficient between two variables + + + +## func [PercentChange](/diff.go?s=891:947#L29) +``` go +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. + + + +## func [Percentile](/percentile.go?s=598:681#L20) +``` go +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 +(Hyndman & Fan type 7), the default in Excel (PERCENTILE, PERCENTILE.INC), +Google Sheets, NumPy, and R. Note that NIST [1] describes the closely +related p(N+1) variant (Hyndman & Fan type 6, Excel PERCENTILE.EXC), +which gives different results for the same input. + +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](/percentile.go?s=1405:1499#L55) +``` go +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](/percentile_of_score.go?s=374:447#L11) +``` go +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="mean". + + + +## func [PercentileWeighted](/percentile_weighted.go?s=620:719#L19) +``` go +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](/kurtosis.go?s=391:450#L13) +``` go +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](/skewness.go?s=318:377#L12) +``` go +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](/variance.go?s=828:896#L31) +``` go +func PopulationVariance(input Float64Data) (pvar float64, err error) +``` +PopulationVariance finds the amount of variance within a population + + + +## func [ProbGeom](/geometric_distribution.go?s=258:322#L10) +``` go +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 + + + +## func [Product](/product.go?s=299:347#L10) +``` go +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. + + + +## func [RMS](/rms.go?s=156:200#L7) +``` go +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. + + + +## func [Range](/extremes.go?s=1181:1227#L51) +``` go +func Range(input Float64Data) (float64, error) +``` +Range finds the difference between the highest and +lowest numbers in a slice + + + +## func [Rank](/rank.go?s=183:230#L6) +``` go +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. + + + +## func [Rescale](/rescale.go?s=174:224#L6) +``` go +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. + + + +## func [Round](/round.go?s=88:154#L6) +``` go +func Round(input float64, places int) (rounded float64, err error) +``` +Round a float to a specific decimal place or precision + + + +## func [SEM](/sem.go?s=265:309#L9) +``` go +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. + + + +## func [Sample](/sample.go?s=112:192#L9) +``` go +func Sample(input Float64Data, takenum int, replacement bool) ([]float64, error) +``` +Sample returns sample from input with replacement or without + + + +## func [SampleKurtosis](/kurtosis.go?s=1071:1126#L41) +``` go +func SampleKurtosis(input Float64Data) (float64, error) +``` +SampleKurtosis computes the bias-corrected sample excess kurtosis, +matching pandas .kurt() and scipy.stats.kurtosis with bias=False. + + + +## func [SampleSkewness](/skewness.go?s=1049:1104#L44) +``` go +func SampleSkewness(input Float64Data) (float64, error) +``` +SampleSkewness computes the adjusted Fisher-Pearson standardized moment +coefficient, correcting for bias in small samples. + + + +## func [SampleVariance](/variance.go?s=1058:1122#L42) +``` go +func SampleVariance(input Float64Data) (svar float64, err error) +``` +SampleVariance finds the amount of variance within a sample + + + +## func [Sigmoid](/sigmoid.go?s=228:278#L9) +``` go +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. + + + +## func [Skewness](/skewness.go?s=90:139#L6) +``` go +func Skewness(input Float64Data) (float64, error) +``` +Skewness computes the population skewness of the dataset + + + +## func [SoftMax](/softmax.go?s=206:256#L8) +``` go +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. + + + +## func [Spearman](/correlation.go?s=1006:1062#L41) +``` go +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. + + + +## func [StableSample](/sample.go?s=974:1042#L50) +``` go +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](/deviation.go?s=695:762#L27) +``` go +func StandardDeviation(input Float64Data) (sdev float64, err error) +``` +StandardDeviation the amount of variation in the dataset + + + +## func [StandardDeviationPopulation](/deviation.go?s=892:969#L32) +``` go +func StandardDeviationPopulation(input Float64Data) (sdev float64, err error) +``` +StandardDeviationPopulation finds the amount of variation from the population + + + +## func [StandardDeviationSample](/deviation.go?s=1250:1323#L46) +``` go +func StandardDeviationSample(input Float64Data) (sdev float64, err error) +``` +StandardDeviationSample finds the amount of variation from a sample + + + +## func [StdDevP](/legacy.go?s=339:396#L14) +``` go +func StdDevP(input Float64Data) (sdev float64, err error) +``` +StdDevP is a shortcut to StandardDeviationPopulation + + + +## func [StdDevS](/legacy.go?s=497:554#L19) +``` go +func StdDevS(input Float64Data) (sdev float64, err error) +``` +StdDevS is a shortcut to StandardDeviationSample + + + +## func [Sum](/sum.go?s=78:130#L6) +``` go +func Sum(input Float64Data) (sum float64, err error) +``` +Sum adds all the numbers of a slice together + + + +## func [TTest](/ttest.go?s=505:604#L16) +``` go +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](/quartile.go?s=1320:1368#L65) +``` go +func Trimean(input Float64Data) (float64, error) +``` +Trimean finds the average of the median and the midhinge + + + +## func [TrimmedMean](/trimmed_mean.go?s=450:519#L13) +``` go +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. + + + +## func [VarGeom](/geometric_distribution.go?s=1049:1097#L38) +``` go +func VarGeom(p float64) (exp float64, err error) +``` +ProbGeom generates the variance for number for a +geometric random variable with parameter p + + + +## func [VarP](/legacy.go?s=59:113#L4) +``` go +func VarP(input Float64Data) (sdev float64, err error) +``` +VarP is a shortcut to PopulationVariance + + + +## func [VarS](/legacy.go?s=193:247#L9) +``` go +func VarS(input Float64Data) (sdev float64, err error) +``` +VarS is a shortcut to SampleVariance + + + +## func [Variance](/variance.go?s=659:717#L26) +``` go +func Variance(input Float64Data) (sdev float64, err error) +``` +Variance the amount of variation in the dataset + + + +## func [WeightedMean](/weighted_mean.go?s=415:476#L12) +``` go +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](/winsorize.go?s=618:687#L16) +``` go +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. + + + +## func [ZScore](/zscore.go?s=205:254#L6) +``` go +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. + + + +## func [ZTest](/ztest.go?s=537:654#L17) +``` go +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 + + + + +## type [Coordinate](/regression.go?s=143:183#L9) +``` go +type Coordinate struct { + X, Y float64 +} + +``` +Coordinate holds the data in a series + + + + + + + +### func [ExpReg](/legacy.go?s=791:856#L29) +``` go +func ExpReg(s []Coordinate) (regressions []Coordinate, err error) +``` +ExpReg is a shortcut to ExponentialRegression + + +### func [LinReg](/legacy.go?s=643:708#L24) +``` go +func LinReg(s []Coordinate) (regressions []Coordinate, err error) +``` +LinReg is a shortcut to LinearRegression + + +### func [LogReg](/legacy.go?s=944:1009#L34) +``` go +func LogReg(s []Coordinate) (regressions []Coordinate, err error) +``` +LogReg is a shortcut to LogarithmicRegression + + + + + +## type [Description](/describe.go?s=89:381#L6) +``` go +type Description struct { + Count int + Mean float64 + Std float64 + Max float64 + Min float64 + Range float64 + DescriptionPercentiles []descriptionPercentile + AllowedNaN bool +} + +``` +Holds information about the dataset provided to Describe + + + + + + + +### func [Describe](/describe.go?s=611:704#L24) +``` go +func Describe(input Float64Data, allowNaN bool, percentiles *[]float64) (*Description, error) +``` +Describe generates descriptive statistics about a provided dataset, similar to python's pandas.describe() + + +### func [DescribePercentileFunc](/describe.go?s=949:1116#L30) +``` go +func DescribePercentileFunc(input Float64Data, allowNaN bool, percentiles *[]float64, percentileFunc func(Float64Data, float64) (float64, error)) (*Description, error) +``` +Describe generates descriptive statistics about a provided dataset, similar to python's pandas.describe() +Takes in a function to use for percentile calculation + + + + + +### func (\*Description) [String](/describe.go?s=2161:2210#L71) +``` go +func (d *Description) String(decimals int) string +``` +Represents the Description instance in a string format with specified number of decimals + + + count 3 + mean 2.00 + std 0.82 + max 3.00 + min 1.00 + range 2.00 + 25.00% NaN + 50.00% 1.50 + 75.00% 2.50 + NaN OK true + + + + +## type [Float64Data](/data.go?s=80:106#L4) +``` go +type Float64Data []float64 +``` +Float64Data is a named type for []float64 with helper methods + + + + + + + +### func [LoadRawData](/load.go?s=145:194#L12) +``` go +func LoadRawData(raw interface{}) (f Float64Data) +``` +LoadRawData parses and converts a slice of mixed data types to floats + + + + + +### func (Float64Data) [ArgMax](/extremes.go?s=1521:1563#L66) +``` go +func (f Float64Data) ArgMax() (int, error) +``` +ArgMax returns the index of the highest number in the data + + + + +### func (Float64Data) [ArgMin](/extremes.go?s=1647:1689#L69) +``` go +func (f Float64Data) ArgMin() (int, error) +``` +ArgMin returns the index of the lowest number in the data + + + + +### func (Float64Data) [AutoCorrelation](/data.go?s=3274:3337#L91) +``` go +func (f Float64Data) AutoCorrelation(lags int) (float64, error) +``` +AutoCorrelation is the correlation of a signal with a delayed copy of itself as a function of delay + + + + +### func (Float64Data) [Clip](/clip.go?s=550:612#L30) +``` go +func (f Float64Data) Clip(min, max float64) ([]float64, error) +``` +Clip clamps each value in the input slice into the +inclusive range between min and max. + + + + +### func (Float64Data) [CoefficientOfVariation](/coefficient_of_variation.go?s=768:830#L29) +``` go +func (f Float64Data) CoefficientOfVariation() (float64, error) +``` +CoefficientOfVariation finds the sample standard deviation divided by the mean + + + + +### func (Float64Data) [Correlation](/data.go?s=3075:3139#L86) +``` go +func (f Float64Data) Correlation(d Float64Data) (float64, error) +``` +Correlation describes the degree of relationship between two sets of data + + + + +### func (Float64Data) [Covariance](/data.go?s=4996:5059#L146) +``` go +func (f Float64Data) Covariance(d Float64Data) (float64, error) +``` +Covariance is a measure of how much two sets of data change + + + + +### func (Float64Data) [CovariancePopulation](/data.go?s=5178:5251#L151) +``` go +func (f Float64Data) CovariancePopulation(d Float64Data) (float64, error) +``` +CovariancePopulation computes covariance for entire population between two variables + + + + +### func (Float64Data) [CumulativeMax](/cumulative.go?s=1416:1471#L69) +``` go +func (f Float64Data) CumulativeMax() ([]float64, error) +``` +CumulativeMax calculates the cumulative maximum of the data + + + + +### func (Float64Data) [CumulativeMin](/cumulative.go?s=1565:1620#L74) +``` go +func (f Float64Data) CumulativeMin() ([]float64, error) +``` +CumulativeMin calculates the cumulative minimum of the data + + + + +### func (Float64Data) [CumulativeProduct](/cumulative.go?s=1259:1318#L64) +``` go +func (f Float64Data) CumulativeProduct() ([]float64, error) +``` +CumulativeProduct calculates the cumulative product of the data + + + + +### func (Float64Data) [CumulativeSum](/data.go?s=883:938#L28) +``` go +func (f Float64Data) CumulativeSum() ([]float64, error) +``` +CumulativeSum returns the cumulative sum of the data + + + + +### func (Float64Data) [Diff](/diff.go?s=1220:1266#L45) +``` go +func (f Float64Data) Diff() ([]float64, error) +``` +Diff returns the successive differences of the data + + + + +### func (Float64Data) [EWMA](/ewma.go?s=848:907#L30) +``` go +func (f Float64Data) EWMA(alpha float64) ([]float64, error) +``` +EWMA returns the exponentially weighted moving average of the data with smoothing factor alpha + + + + +### func (Float64Data) [Entropy](/data.go?s=5675:5722#L167) +``` go +func (f Float64Data) Entropy() (float64, error) +``` +Entropy provides calculation of the entropy + + + + +### func (Float64Data) [GeometricMean](/data.go?s=1340:1393#L40) +``` go +func (f Float64Data) GeometricMean() (float64, error) +``` +GeometricMean returns the geometric mean of the data + + + + +### func (Float64Data) [Get](/data.go?s=129:168#L7) +``` go +func (f Float64Data) Get(i int) float64 +``` +Get item in slice + + + + +### func (Float64Data) [HarmonicMean](/data.go?s=1477:1529#L43) +``` go +func (f Float64Data) HarmonicMean() (float64, error) +``` +HarmonicMean returns the harmonic mean of the data + + + + +### func (Float64Data) [Histogram](/histogram.go?s=1359:1425#L55) +``` go +func (f Float64Data) Histogram(bins int) ([]int, []float64, error) +``` +Histogram returns the counts and equal-width bin edges of the data + + + + +### func (Float64Data) [InterQuartileRange](/data.go?s=3950:4008#L111) +``` go +func (f Float64Data) InterQuartileRange() (float64, error) +``` +InterQuartileRange finds the range between Q1 and Q3 + + + + +### func (Float64Data) [KendallTau](/kendall.go?s=1384:1447#L55) +``` go +func (f Float64Data) KendallTau(d Float64Data) (float64, error) +``` +KendallTau calculates Kendall's tau-b rank correlation coefficient +between two variables. + + + + +### func (Float64Data) [Kurtosis](/kurtosis.go?s=1501:1549#L58) +``` go +func (f Float64Data) Kurtosis() (float64, error) +``` +Kurtosis finds the population excess kurtosis of a slice of floats + + + + +### func (Float64Data) [Len](/data.go?s=217:247#L10) +``` go +func (f Float64Data) Len() int +``` +Len returns length of slice + + + + +### func (Float64Data) [Less](/data.go?s=318:358#L13) +``` go +func (f Float64Data) Less(i, j int) bool +``` +Less returns if one number is less than another + + + + +### func (Float64Data) [Max](/data.go?s=645:688#L22) +``` go +func (f Float64Data) Max() (float64, error) +``` +Max returns the maximum number in the data + + + + +### func (Float64Data) [Mean](/data.go?s=1005:1049#L31) +``` go +func (f Float64Data) Mean() (float64, error) +``` +Mean returns the mean of the data + + + + +### func (Float64Data) [Median](/data.go?s=1111:1157#L34) +``` go +func (f Float64Data) Median() (float64, error) +``` +Median returns the median of the data + + + + +### func (Float64Data) [MedianAbsoluteDeviation](/data.go?s=1647:1710#L46) +``` go +func (f Float64Data) MedianAbsoluteDeviation() (float64, error) +``` +MedianAbsoluteDeviation the median of the absolute deviations from the dataset median + + + + +### func (Float64Data) [MedianAbsoluteDeviationPopulation](/data.go?s=1859:1932#L51) +``` go +func (f Float64Data) MedianAbsoluteDeviationPopulation() (float64, error) +``` +MedianAbsoluteDeviationPopulation finds the median of the absolute deviations from the population median + + + + +### func (Float64Data) [Midhinge](/data.go?s=4107:4168#L116) +``` go +func (f Float64Data) Midhinge(d Float64Data) (float64, error) +``` +Midhinge finds the average of the first and third quartiles + + + + +### func (Float64Data) [Min](/data.go?s=536:579#L19) +``` go +func (f Float64Data) Min() (float64, error) +``` +Min returns the minimum number in the data + + + + +### func (Float64Data) [Mode](/data.go?s=1217:1263#L37) +``` go +func (f Float64Data) Mode() ([]float64, error) +``` +Mode returns the mode of the data + + + + +### func (Float64Data) [MovingAverage](/rolling.go?s=1768:1833#L58) +``` go +func (f Float64Data) MovingAverage(window int) ([]float64, error) +``` +MovingAverage returns the rolling mean of the data over a trailing window + + + + +### func (Float64Data) [MovingMax](/moving.go?s=3475:3536#L118) +``` go +func (f Float64Data) MovingMax(window int) ([]float64, error) +``` +MovingMax returns the rolling maximum of the data over a trailing window + + + + +### func (Float64Data) [MovingMedian](/moving.go?s=3125:3189#L108) +``` go +func (f Float64Data) MovingMedian(window int) ([]float64, error) +``` +MovingMedian returns the rolling median of the data over a trailing window + + + + +### func (Float64Data) [MovingMin](/moving.go?s=3303:3364#L113) +``` go +func (f Float64Data) MovingMin(window int) ([]float64, error) +``` +MovingMin returns the rolling minimum of the data over a trailing window + + + + +### func (Float64Data) [MovingStdDev](/rolling.go?s=1969:2033#L63) +``` go +func (f Float64Data) MovingStdDev(window int) ([]float64, error) +``` +MovingStdDev returns the rolling sample standard deviation of the data over a trailing window + + + + +### func (Float64Data) [MovingSum](/moving.go?s=3643:3704#L123) +``` go +func (f Float64Data) MovingSum(window int) ([]float64, error) +``` +MovingSum returns the rolling sum of the data over a trailing window + + + + +### func (Float64Data) [Pearson](/data.go?s=3472:3532#L96) +``` go +func (f Float64Data) Pearson(d Float64Data) (float64, error) +``` +Pearson calculates the Pearson product-moment correlation coefficient between two variables. + + + + +### func (Float64Data) [PercentChange](/diff.go?s=1374:1429#L48) +``` go +func (f Float64Data) PercentChange() ([]float64, error) +``` +PercentChange returns the fractional change between successive elements of the data + + + + +### func (Float64Data) [Percentile](/data.go?s=2713:2772#L76) +``` go +func (f Float64Data) Percentile(p float64) (float64, error) +``` +Percentile finds the relative standing in a slice of floats + + + + +### func (Float64Data) [PercentileNearestRank](/data.go?s=2886:2956#L81) +``` go +func (f Float64Data) PercentileNearestRank(p float64) (float64, error) +``` +PercentileNearestRank finds the relative standing using the Nearest Rank method + + + + +### func (Float64Data) [PercentileOfScore](/percentile_of_score.go?s=786:856#L29) +``` go +func (f Float64Data) PercentileOfScore(score float64) (float64, error) +``` +PercentileOfScore calculates the percentile rank of a score relative to the data + + + + +### func (Float64Data) [PopulationKurtosis](/kurtosis.go?s=1655:1713#L63) +``` go +func (f Float64Data) PopulationKurtosis() (float64, error) +``` +PopulationKurtosis finds the population excess kurtosis of a slice of floats + + + + +### func (Float64Data) [PopulationVariance](/data.go?s=4690:4748#L136) +``` go +func (f Float64Data) PopulationVariance() (float64, error) +``` +PopulationVariance finds the amount of variance within a population + + + + +### func (Float64Data) [Product](/product.go?s=544:591#L24) +``` go +func (f Float64Data) Product() (float64, error) +``` +Product calculates the product of the data + + + + +### func (Float64Data) [Quartile](/data.go?s=3805:3868#L106) +``` go +func (f Float64Data) Quartile(d Float64Data) (Quartiles, error) +``` +Quartile returns the three quartile points from a slice of data + + + + +### func (Float64Data) [QuartileOutliers](/data.go?s=2559:2616#L71) +``` go +func (f Float64Data) QuartileOutliers() (Outliers, error) +``` +QuartileOutliers finds the mild and extreme outliers + + + + +### func (Float64Data) [Quartiles](/data.go?s=5823:5874#L172) +``` go +func (f Float64Data) Quartiles() (Quartiles, error) +``` +Quartiles returns the three quartile points from instance of Float64Data + + + + +### func (Float64Data) [RMS](/rms.go?s=454:497#L21) +``` go +func (f Float64Data) RMS() (float64, error) +``` +RMS calculates the root mean square of the data + + + + +### func (Float64Data) [Range](/extremes.go?s=1795:1840#L72) +``` go +func (f Float64Data) Range() (float64, error) +``` +Range returns the difference between the highest and lowest numbers in the data + + + + +### func (Float64Data) [Rank](/rank.go?s=382:428#L14) +``` go +func (f Float64Data) Rank() ([]float64, error) +``` +Rank assigns fractional (average) ranks to the input values + + + + +### func (Float64Data) [Rescale](/rescale.go?s=603:652#L27) +``` go +func (f Float64Data) Rescale() ([]float64, error) +``` +Rescale normalizes the input values to the range of 0 to 1 +by subtracting the minimum and dividing by the range + + + + +### func (Float64Data) [SEM](/sem.go?s=625:668#L22) +``` go +func (f Float64Data) SEM() (float64, error) +``` +SEM calculates the standard error of the mean of the data + + + + +### func (Float64Data) [Sample](/data.go?s=4403:4464#L126) +``` go +func (f Float64Data) Sample(n int, r bool) ([]float64, error) +``` +Sample returns sample from input with replacement or without + + + + +### func (Float64Data) [SampleKurtosis](/kurtosis.go?s=1836:1890#L68) +``` go +func (f Float64Data) SampleKurtosis() (float64, error) +``` +SampleKurtosis finds the bias-corrected sample excess kurtosis of a slice of floats + + + + +### func (Float64Data) [SampleVariance](/data.go?s=4847:4901#L141) +``` go +func (f Float64Data) SampleVariance() (float64, error) +``` +SampleVariance finds the amount of variance within a sample + + + + +### func (Float64Data) [Sigmoid](/data.go?s=5364:5413#L156) +``` go +func (f Float64Data) Sigmoid() ([]float64, error) +``` +Sigmoid returns the input values along the sigmoid or s-shaped curve + + + + +### func (Float64Data) [SoftMax](/data.go?s=5554:5603#L162) +``` go +func (f Float64Data) SoftMax() ([]float64, error) +``` +SoftMax returns the input values in the range of 0 to 1 +with sum of all the probabilities being equal to one. + + + + +### func (Float64Data) [Spearman](/data.go?s=3648:3709#L101) +``` go +func (f Float64Data) Spearman(d Float64Data) (float64, error) +``` +Spearman calculates the Spearman rank correlation coefficient between two variables. + + + + +### func (Float64Data) [StandardDeviation](/data.go?s=2043:2100#L56) +``` go +func (f Float64Data) StandardDeviation() (float64, error) +``` +StandardDeviation the amount of variation in the dataset + + + + +### func (Float64Data) [StandardDeviationPopulation](/data.go?s=2216:2283#L61) +``` go +func (f Float64Data) StandardDeviationPopulation() (float64, error) +``` +StandardDeviationPopulation finds the amount of variation from the population + + + + +### func (Float64Data) [StandardDeviationSample](/data.go?s=2399:2462#L66) +``` go +func (f Float64Data) StandardDeviationSample() (float64, error) +``` +StandardDeviationSample finds the amount of variation from a sample + + + + +### func (Float64Data) [Sum](/data.go?s=764:807#L25) +``` go +func (f Float64Data) Sum() (float64, error) +``` +Sum returns the total of all the numbers in the data + + + + +### func (Float64Data) [Swap](/data.go?s=425:460#L16) +``` go +func (f Float64Data) Swap(i, j int) +``` +Swap switches out two numbers in slice + + + + +### func (Float64Data) [Trimean](/data.go?s=4254:4314#L121) +``` go +func (f Float64Data) Trimean(d Float64Data) (float64, error) +``` +Trimean finds the average of the median and the midhinge + + + + +### func (Float64Data) [TrimmedMean](/trimmed_mean.go?s=1132:1198#L36) +``` go +func (f Float64Data) TrimmedMean(percent float64) (float64, error) +``` +TrimmedMean finds the mean of the data after removing a fraction of +the smallest and largest values from each tail + + + + +### func (Float64Data) [Variance](/data.go?s=4545:4593#L131) +``` go +func (f Float64Data) Variance() (float64, error) +``` +Variance the amount of variation in the dataset + + + + +### func (Float64Data) [WeightedMean](/weighted_mean.go?s=976:1047#L40) +``` go +func (f Float64Data) WeightedMean(weights Float64Data) (float64, error) +``` +WeightedMean finds the weighted mean of the data using the given weights + + + + +### func (Float64Data) [Winsorize](/winsorize.go?s=1319:1385#L48) +``` go +func (f Float64Data) Winsorize(percent float64) ([]float64, error) +``` +Winsorize returns a copy of the data with a fraction of the smallest +and largest values in each tail clamped + + + + +### func (Float64Data) [ZScore](/zscore.go?s=632:680#L27) +``` go +func (f Float64Data) ZScore() ([]float64, error) +``` +ZScore standardizes the input values by subtracting the mean +and dividing by the sample standard deviation + + + + +## type [Outliers](/outlier.go?s=73:139#L4) +``` go +type Outliers struct { + Mild Float64Data + Extreme Float64Data +} + +``` +Outliers holds mild and extreme outliers found in data + + + + + + + +### func [QuartileOutliers](/outlier.go?s=197:255#L10) +``` go +func QuartileOutliers(input Float64Data) (Outliers, error) +``` +QuartileOutliers finds the mild and extreme outliers + + + + + +## type [Quartiles](/quartile.go?s=75:136#L6) +``` go +type Quartiles struct { + Q1 float64 + Q2 float64 + Q3 float64 +} + +``` +Quartiles holds the three quartile points + + + + + + + +### func [Quartile](/quartile.go?s=205:256#L13) +``` go +func Quartile(input Float64Data) (Quartiles, error) +``` +Quartile returns the three quartile points from a slice of data + + + + + +## type [Series](/regression.go?s=76:100#L6) +``` go +type Series []Coordinate +``` +Series is a container for a series of data + + + + + + + +### func [ExponentialRegression](/regression.go?s=1269:1337#L54) +``` go +func ExponentialRegression(s Series) (regressions Series, err error) +``` +ExponentialRegression returns an exponential regression on data series. +A non-positive Y value returns ErrYCoord, and a series without at least two +distinct X values returns ErrBounds. + + +### func [LinearRegression](/regression.go?s=333:396#L15) +``` go +func LinearRegression(s Series) (regressions Series, err error) +``` +LinearRegression finds the least squares linear regression on data series. +A series without at least two distinct X values returns ErrBounds. + + +### func [LogarithmicRegression](/regression.go?s=2368:2436#L98) +``` go +func LogarithmicRegression(s Series) (regressions Series, err error) +``` +LogarithmicRegression returns a logarithmic regression on data series. +A non-positive X value or a series without at least two distinct X values +returns ErrBounds. + + + + + + + + + +- - - +Generated by [godoc2md](http://godoc.org/github.com/davecheney/godoc2md) diff --git a/quartile.go b/quartile.go new file mode 100644 index 0000000..40bbf6e --- /dev/null +++ b/quartile.go @@ -0,0 +1,74 @@ +package stats + +import "math" + +// Quartiles holds the three quartile points +type Quartiles struct { + Q1 float64 + Q2 float64 + Q3 float64 +} + +// Quartile returns the three quartile points from a slice of data +func Quartile(input Float64Data) (Quartiles, error) { + + il := input.Len() + if il == 0 { + return Quartiles{}, EmptyInputErr + } + + // Start by sorting a copy of the slice + copy := sortedCopy(input) + + // Find the cutoff places depeding on if + // the input slice length is even or odd + var c1 int + var c2 int + if il%2 == 0 { + c1 = il / 2 + c2 = il / 2 + } else { + c1 = (il - 1) / 2 + c2 = c1 + 1 + } + + // Find the Medians with the cutoff points + Q1, _ := Median(copy[:c1]) + Q2, _ := Median(copy) + Q3, _ := Median(copy[c2:]) + + return Quartiles{Q1, Q2, Q3}, nil + +} + +// InterQuartileRange finds the range between Q1 and Q3 +func InterQuartileRange(input Float64Data) (float64, error) { + if input.Len() == 0 { + return math.NaN(), EmptyInputErr + } + qs, _ := Quartile(input) + iqr := qs.Q3 - qs.Q1 + return iqr, nil +} + +// Midhinge finds the average of the first and third quartiles +func Midhinge(input Float64Data) (float64, error) { + if input.Len() == 0 { + return math.NaN(), EmptyInputErr + } + qs, _ := Quartile(input) + mh := (qs.Q1 + qs.Q3) / 2 + return mh, nil +} + +// Trimean finds the average of the median and the midhinge +func Trimean(input Float64Data) (float64, error) { + if input.Len() == 0 { + return math.NaN(), EmptyInputErr + } + + c := sortedCopy(input) + q, _ := Quartile(c) + + return (q.Q1 + (q.Q2 * 2) + q.Q3) / 4, nil +} diff --git a/quartile_test.go b/quartile_test.go new file mode 100644 index 0000000..93d524e --- /dev/null +++ b/quartile_test.go @@ -0,0 +1,84 @@ +package stats_test + +import ( + "testing" + + "github.com/montanaflynn/stats" +) + +func TestQuartile(t *testing.T) { + s1 := []float64{6, 7, 15, 36, 39, 40, 41, 42, 43, 47, 49} + s2 := []float64{7, 15, 36, 39, 40, 41} + + for _, c := range []struct { + in []float64 + Q1 float64 + Q2 float64 + Q3 float64 + }{ + {s1, 15, 40, 43}, + {s2, 15, 37.5, 40}, + } { + quartiles, err := stats.Quartile(c.in) + if err != nil { + t.Errorf("Should not have returned an error") + } + + if quartiles.Q1 != c.Q1 { + t.Errorf("Q1 %v != %v", quartiles.Q1, c.Q1) + } + if quartiles.Q2 != c.Q2 { + t.Errorf("Q2 %v != %v", quartiles.Q2, c.Q2) + } + if quartiles.Q3 != c.Q3 { + t.Errorf("Q3 %v != %v", quartiles.Q3, c.Q3) + } + } + + _, err := stats.Quartile([]float64{}) + if err == nil { + t.Errorf("Empty slice should have returned an error") + } +} + +func TestInterQuartileRange(t *testing.T) { + s1 := []float64{102, 104, 105, 107, 108, 109, 110, 112, 115, 116, 118} + iqr, _ := stats.InterQuartileRange(s1) + + if iqr != 10 { + t.Errorf("IQR %v != 10", iqr) + } + + _, err := stats.InterQuartileRange([]float64{}) + if err == nil { + t.Errorf("Empty slice should have returned an error") + } +} + +func TestMidhinge(t *testing.T) { + s1 := []float64{1, 3, 4, 4, 6, 6, 6, 6, 7, 7, 7, 8, 8, 9, 9, 10, 11, 12, 13} + mh, _ := stats.Midhinge(s1) + + if mh != 7.5 { + t.Errorf("Midhinge %v != 7.5", mh) + } + + _, err := stats.Midhinge([]float64{}) + if err == nil { + t.Errorf("Empty slice should have returned an error") + } +} + +func TestTrimean(t *testing.T) { + s1 := []float64{1, 3, 4, 4, 6, 6, 6, 6, 7, 7, 7, 8, 8, 9, 9, 10, 11, 12, 13} + tr, _ := stats.Trimean(s1) + + if tr != 7.25 { + t.Errorf("Trimean %v != 7.25", tr) + } + + _, err := stats.Trimean([]float64{}) + if err == nil { + t.Errorf("Empty slice should have returned an error") + } +}