Base Statistics

Base (i.e., lower-level) statistical functions.

Usage

var stats = require( '@stdlib/stats/base' );

stats

Namespace containing "base" (i.e., lower-level) statistical functions.

var ns = stats;
// returns {...}

The namespace contains the following sub-namespaces:

dists: base (i.e., lower-level) probability distribution modules.

The namespace contains the following statistical functions:

cumax( N, x, strideX, y, strideY ): calculate the cumulative maximum of a strided array.
cumaxabs( N, x, strideX, y, strideY ): calculate the cumulative maximum absolute value of a strided array.
cumin( N, x, strideX, y, strideY ): calculate the cumulative minimum of a strided array.
cuminabs( N, x, strideX, y, strideY ): calculate the cumulative minimum absolute value of a strided array.
dcumax( N, x, strideX, y, strideY ): calculate the cumulative maximum of double-precision floating-point strided array elements.
dcumaxabs( N, x, strideX, y, strideY ): calculate the cumulative maximum absolute value of double-precision floating-point strided array elements.
dcumin( N, x, strideX, y, strideY ): calculate the cumulative minimum of double-precision floating-point strided array elements.
dcuminabs( N, x, strideX, y, strideY ): calculate the cumulative minimum absolute value of double-precision floating-point strided array elements.
dmax( N, x, stride ): calculate the maximum value of a double-precision floating-point strided array.
dmaxabs( N, x, stride ): calculate the maximum absolute value of a double-precision floating-point strided array.
dmaxabssorted( N, x, stride ): calculate the maximum absolute value of a sorted double-precision floating-point strided array.
dmaxsorted( N, x, stride ): calculate the maximum value of a sorted double-precision floating-point strided array.
dmean( N, x, stride ): calculate the arithmetic mean of a double-precision floating-point strided array.
dmeankbn( N, x, stride ): calculate the arithmetic mean of a double-precision floating-point strided array using an improved Kahan–Babuška algorithm.
dmeankbn2( N, x, stride ): calculate the arithmetic mean of a double-precision floating-point strided array using a second-order iterative Kahan–Babuška algorithm.
dmeanli( N, x, stride ): calculate the arithmetic mean of a double-precision floating-point strided array using a one-pass trial mean algorithm.
dmeanlipw( N, x, stride ): calculate the arithmetic mean of a double-precision floating-point strided array using a one-pass trial mean algorithm with pairwise summation.
dmeanors( N, x, stride ): calculate the arithmetic mean of a double-precision floating-point strided array using ordinary recursive summation.
dmeanpn( N, x, stride ): calculate the arithmetic mean of a double-precision floating-point strided array using a two-pass error correction algorithm.
dmeanpw( N, x, stride ): calculate the arithmetic mean of a double-precision floating-point strided array using pairwise summation.
dmeanstdev( N, correction, x, strideX, out, strideOut ): calculate the mean and standard deviation of a double-precision floating-point strided array.
dmeanstdevpn( N, correction, x, strideX, out, strideOut ): calculate the mean and standard deviation of a double-precision floating-point strided array using a two-pass algorithm.
dmeanvar( N, correction, x, strideX, out, strideOut ): calculate the mean and variance of a double-precision floating-point strided array.
dmeanvarpn( N, correction, x, strideX, out, strideOut ): calculate the mean and variance of a double-precision floating-point strided array using a two-pass algorithm.
dmeanwd( N, x, stride ): calculate the arithmetic mean of a double-precision floating-point strided array using Welford's algorithm.
dmediansorted( N, x, stride ): calculate the median value of a sorted double-precision floating-point strided array.
dmidrange( N, x, stride ): calculate the mid-range of a double-precision floating-point strided array.
dmin( N, x, stride ): calculate the minimum value of a double-precision floating-point strided array.
dminabs( N, x, stride ): calculate the minimum absolute value of a double-precision floating-point strided array.
dminsorted( N, x, stride ): calculate the minimum value of a sorted double-precision floating-point strided array.
dmskmax( N, x, strideX, mask, strideMask ): calculate the maximum value of a double-precision floating-point strided array according to a mask.
dmskmin( N, x, strideX, mask, strideMask ): calculate the minimum value of a double-precision floating-point strided array according to a mask.
dmskrange( N, x, strideX, mask, strideMask ): calculate the range of a double-precision floating-point strided array according to a mask.
dnanmax( N, x, stride ): calculate the maximum value of a double-precision floating-point strided array, ignoring NaN values.
dnanmaxabs( N, x, stride ): calculate the maximum absolute value of a double-precision floating-point strided array, ignoring NaN values.
dnanmean( N, x, stride ): calculate the arithmetic mean of a double-precision floating-point strided array, ignoring NaN values.
dnanmeanors( N, x, stride ): calculate the arithmetic mean of a double-precision floating-point strided array, ignoring NaN values and using ordinary recursive summation.
dnanmeanpn( N, x, stride ): calculate the arithmetic mean of a double-precision floating-point strided array, ignoring NaN values and using a two-pass error correction algorithm.
dnanmeanpw( N, x, stride ): calculate the arithmetic mean of a double-precision floating-point strided array, ignoring NaN values and using pairwise summation.
dnanmeanwd( N, x, stride ): calculate the arithmetic mean of a double-precision floating-point strided array, using Welford's algorithm and ignoring NaN values.
dnanmin( N, x, stride ): calculate the minimum value of a double-precision floating-point strided array, ignoring NaN values.
dnanminabs( N, x, stride ): calculate the minimum absolute value of a double-precision floating-point strided array, ignoring NaN values.
dnanmskmax( N, x, strideX, mask, strideMask ): calculate the maximum value of a double-precision floating-point strided array according to a mask, ignoring NaN values.
dnanmskmin( N, x, strideX, mask, strideMask ): calculate the minimum value of a double-precision floating-point strided array according to a mask, ignoring NaN values.
dnanmskrange( N, x, strideX, mask, strideMask ): calculate the range of a double-precision floating-point strided array according to a mask, ignoring NaN values.
dnanrange( N, x, stride ): calculate the range of a double-precision floating-point strided array, ignoring NaN values.
dnanstdev( N, correction, x, stride ): calculate the standard deviation of a double-precision floating-point strided array ignoring NaN values.
dnanstdevch( N, correction, x, stride ): calculate the standard deviation of a double-precision floating-point strided array ignoring NaN values and using a one-pass trial mean algorithm.
dnanstdevpn( N, correction, x, stride ): calculate the standard deviation of a double-precision floating-point strided array ignoring NaN values and using a two-pass algorithm.
dnanstdevtk( N, correction, x, stride ): calculate the standard deviation of a double-precision floating-point strided array ignoring NaN values and using a one-pass textbook algorithm.
dnanstdevwd( N, correction, x, stride ): calculate the standard deviation of a double-precision floating-point strided array ignoring NaN values and using Welford's algorithm.
dnanstdevyc( N, correction, x, stride ): calculate the standard deviation of a double-precision floating-point strided array ignoring NaN values and using a one-pass algorithm proposed by Youngs and Cramer.
dnanvariance( N, correction, x, stride ): calculate the variance of a double-precision floating-point strided array ignoring NaN values.
dnanvariancech( N, correction, x, stride ): calculate the variance of a double-precision floating-point strided array ignoring NaN values and using a one-pass trial mean algorithm.
dnanvariancepn( N, correction, x, stride ): calculate the variance of a double-precision floating-point strided array ignoring NaN values and using a two-pass algorithm.
dnanvariancetk( N, correction, x, stride ): calculate the variance of a double-precision floating-point strided array ignoring NaN values and using a one-pass textbook algorithm.
dnanvariancewd( N, correction, x, stride ): calculate the variance of a double-precision floating-point strided array ignoring NaN values and using Welford's algorithm.
dnanvarianceyc( N, correction, x, stride ): calculate the variance of a double-precision floating-point strided array ignoring NaN values and using a one-pass algorithm proposed by Youngs and Cramer.
drange( N, x, stride ): calculate the range of a double-precision floating-point strided array.
dsem( N, correction, x, stride ): calculate the standard error of the mean of a double-precision floating-point strided array.
dsemch( N, correction, x, stride ): calculate the standard error of the mean of a double-precision floating-point strided array using a one-pass trial mean algorithm.
dsempn( N, correction, x, stride ): calculate the standard error of the mean of a double-precision floating-point strided array using a two-pass algorithm.
dsemtk( N, correction, x, stride ): calculate the standard error of the mean of a double-precision floating-point strided array using a one-pass textbook algorithm.
dsemwd( N, correction, x, stride ): calculate the standard error of the mean of a double-precision floating-point strided array using Welford's algorithm.
dsemyc( N, correction, x, stride ): calculate the standard error of the mean of a double-precision floating-point strided array using a one-pass algorithm proposed by Youngs and Cramer.
dsmean( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array using extended accumulation and returning an extended precision result.
dsmeanors( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array using ordinary recursive summation with extended accumulation and returning an extended precision result.
dsmeanpn( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array using a two-pass error correction algorithm with extended accumulation and returning an extended precision result.
dsmeanpw( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array using pairwise summation with extended accumulation and returning an extended precision result.
dsmeanwd( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array using Welford's algorithm with extended accumulation and returning an extended precision result.
dsnanmean( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array, ignoring NaN values, using extended accumulation, and returning an extended precision result.
dsnanmeanors( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array, ignoring NaN values, using ordinary recursive summation with extended accumulation, and returning an extended precision result.
dsnanmeanpn( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array, ignoring NaN values, using a two-pass error correction algorithm with extended accumulation, and returning an extended precision result.
dsnanmeanwd( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array, ignoring NaN values, using Welford's algorithm with extended accumulation, and returning an extended precision result.
dstdev( N, correction, x, stride ): calculate the standard deviation of a double-precision floating-point strided array.
dstdevch( N, correction, x, stride ): calculate the standard deviation of a double-precision floating-point strided array using a one-pass trial mean algorithm.
dstdevpn( N, correction, x, stride ): calculate the standard deviation of a double-precision floating-point strided array using a two-pass algorithm.
dstdevtk( N, correction, x, stride ): calculate the standard deviation of a double-precision floating-point strided array using a one-pass textbook algorithm.
dstdevwd( N, correction, x, stride ): calculate the standard deviation of a double-precision floating-point strided array using Welford's algorithm.
dstdevyc( N, correction, x, stride ): calculate the standard deviation of a double-precision floating-point strided array using a one-pass algorithm proposed by Youngs and Cramer.
dsvariance( N, correction, x, stride ): calculate the variance of a single-precision floating-point strided array using extended accumulation and returning an extended precision result.
dsvariancepn( N, correction, x, stride ): calculate the variance of a single-precision floating-point strided array using a two-pass algorithm with extended accumulation and returning an extended precision result.
dvariance( N, correction, x, stride ): calculate the variance of a double-precision floating-point strided array.
dvariancech( N, correction, x, stride ): calculate the variance of a double-precision floating-point strided array using a one-pass trial mean algorithm.
dvariancepn( N, correction, x, stride ): calculate the variance of a double-precision floating-point strided array using a two-pass algorithm.
dvariancetk( N, correction, x, stride ): calculate the variance of a double-precision floating-point strided array using a one-pass textbook algorithm.
dvariancewd( N, correction, x, stride ): calculate the variance of a double-precision floating-point strided array using Welford's algorithm.
dvarianceyc( N, correction, x, stride ): calculate the variance of a double-precision floating-point strided array using a one-pass algorithm proposed by Youngs and Cramer.
dvarm( N, mean, correction, x, stride ): calculate the variance of a double-precision floating-point strided array provided a known mean.
dvarmpn( N, mean, correction, x, stride ): calculate the variance of a double-precision floating-point strided array provided a known mean and using Neely's correction algorithm.
dvarmtk( N, mean, correction, x, stride ): calculate the variance of a double-precision floating-point strided array provided a known mean and using a one-pass textbook algorithm.
maxBy( N, x, stride, clbk[, thisArg] ): calculate the maximum value of a strided array via a callback function.
max( N, x, stride ): calculate the maximum value of a strided array.
maxabs( N, x, stride ): calculate the maximum absolute value of a strided array.
maxsorted( N, x, stride ): calculate the maximum value of a sorted strided array.
mean( N, x, stride ): calculate the arithmetic mean of a strided array.
meankbn( N, x, stride ): calculate the arithmetic mean of a strided array using an improved Kahan–Babuška algorithm.
meankbn2( N, x, stride ): calculate the arithmetic mean of a strided array using a second-order iterative Kahan–Babuška algorithm.
meanors( N, x, stride ): calculate the arithmetic mean of a strided array using ordinary recursive summation.
meanpn( N, x, stride ): calculate the arithmetic mean of a strided array using a two-pass error correction algorithm.
meanpw( N, x, stride ): calculate the arithmetic mean of a strided array using pairwise summation.
meanwd( N, x, stride ): calculate the arithmetic mean of a strided array using Welford's algorithm.
mediansorted( N, x, stride ): calculate the median value of a sorted strided array.
minBy( N, x, stride, clbk[, thisArg] ): calculate the minimum value of a strided array via a callback function.
min( N, x, stride ): calculate the minimum value of a strided array.
minabs( N, x, stride ): calculate the minimum absolute value of a strided array.
minsorted( N, x, stride ): calculate the minimum value of a sorted strided array.
mskmax( N, x, strideX, mask, strideMask ): calculate the maximum value of a strided array according to a mask.
mskmin( N, x, strideX, mask, strideMask ): calculate the minimum value of a strided array according to a mask.
mskrange( N, x, strideX, mask, strideMask ): calculate the range of a strided array according to a mask.
nanmaxBy( N, x, stride, clbk[, thisArg] ): calculate the maximum value of a strided array via a callback function, ignoring NaN values.
nanmax( N, x, stride ): calculate the maximum value of a strided array, ignoring NaN values.
nanmaxabs( N, x, stride ): calculate the maximum absolute value of a strided array, ignoring NaN values.
nanmean( N, x, stride ): calculate the arithmetic mean of a strided array, ignoring NaN values.
nanmeanors( N, x, stride ): calculate the arithmetic mean of a strided array, ignoring NaN values and using ordinary recursive summation.
nanmeanpn( N, x, stride ): calculate the arithmetic mean of a strided array, ignoring NaN values and using a two-pass error correction algorithm.
nanmeanwd( N, x, stride ): calculate the arithmetic mean of a strided array, ignoring NaN values and using Welford's algorithm.
nanminBy( N, x, stride, clbk[, thisArg] ): calculate the minimum value of a strided array via a callback function, ignoring NaN values.
nanmin( N, x, stride ): calculate the minimum value of a strided array, ignoring NaN values.
nanminabs( N, x, stride ): calculate the minimum absolute value of a strided array, ignoring NaN values.
nanmskmax( N, x, strideX, mask, strideMask ): calculate the maximum value of a strided array according to a mask, ignoring NaN values.
nanmskmin( N, x, strideX, mask, strideMask ): calculate the minimum value of a strided array according to a mask, ignoring NaN values.
nanmskrange( N, x, strideX, mask, strideMask ): calculate the range of a strided array according to a mask, ignoring NaN values.
nanrangeBy( N, x, stride, clbk[, thisArg] ): calculate the range of a strided array via a callback function, ignoring NaN values.
nanrange( N, x, stride ): calculate the range of a strided array, ignoring NaN values.
nanstdev( N, correction, x, stride ): calculate the standard deviation of a strided array ignoring NaN values.
nanstdevch( N, correction, x, stride ): calculate the standard deviation of a strided array ignoring NaN values and using a one-pass trial mean algorithm.
nanstdevpn( N, correction, x, stride ): calculate the standard deviation of a strided array ignoring NaN values and using a two-pass algorithm.
nanstdevtk( N, correction, x, stride ): calculate the standard deviation of a strided array ignoring NaN values and using a one-pass textbook algorithm.
nanstdevwd( N, correction, x, stride ): calculate the standard deviation of a strided array ignoring NaN values and using Welford's algorithm.
nanstdevyc( N, correction, x, stride ): calculate the standard deviation of a strided array ignoring NaN values and using a one-pass algorithm proposed by Youngs and Cramer.
nanvariance( N, correction, x, stride ): calculate the variance of a strided array ignoring NaN values.
nanvariancech( N, correction, x, stride ): calculate the variance of a strided array ignoring NaN values and using a one-pass trial mean algorithm.
nanvariancepn( N, correction, x, stride ): calculate the variance of a strided array ignoring NaN values and using a two-pass algorithm.
nanvariancetk( N, correction, x, stride ): calculate the variance of a strided array ignoring NaN values and using a one-pass textbook algorithm.
nanvariancewd( N, correction, x, stride ): calculate the variance of a strided array ignoring NaN values and using Welford's algorithm.
nanvarianceyc( N, correction, x, stride ): calculate the variance of a strided array ignoring NaN values and using a one-pass algorithm proposed by Youngs and Cramer.
rangeBy( N, x, stride, clbk[, thisArg] ): calculate the range of a strided array via a callback function.
range( N, x, stride ): calculate the range of a strided array.
scumax( N, x, strideX, y, strideY ): calculate the cumulative maximum of single-precision floating-point strided array elements.
scumaxabs( N, x, strideX, y, strideY ): calculate the cumulative maximum absolute value of single-precision floating-point strided array elements.
scumin( N, x, strideX, y, strideY ): calculate the cumulative minimum of single-precision floating-point strided array elements.
scuminabs( N, x, strideX, y, strideY ): calculate the cumulative minimum absolute value of single-precision floating-point strided array elements.
sdsmean( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array using extended accumulation.
sdsmeanors( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array using ordinary recursive summation with extended accumulation.
sdsnanmean( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array, ignoring NaN values and using extended accumulation.
sdsnanmeanors( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array, ignoring NaN values and using ordinary recursive summation with extended accumulation.
smax( N, x, stride ): calculate the maximum value of a single-precision floating-point strided array.
smaxabs( N, x, stride ): calculate the maximum absolute value of a single-precision floating-point strided array.
smaxabssorted( N, x, stride ): calculate the maximum absolute value of a sorted single-precision floating-point strided array.
smaxsorted( N, x, stride ): calculate the maximum value of a sorted single-precision floating-point strided array.
smean( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array.
smeankbn( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array using an improved Kahan–Babuška algorithm.
smeankbn2( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array using a second-order iterative Kahan–Babuška algorithm.
smeanli( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array using a one-pass trial mean algorithm.
smeanlipw( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array using a one-pass trial mean algorithm with pairwise summation.
smeanors( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array using ordinary recursive summation.
smeanpn( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array using a two-pass error correction algorithm.
smeanpw( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array using pairwise summation.
smeanwd( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array using Welford's algorithm.
smediansorted( N, x, stride ): calculate the median value of a sorted single-precision floating-point strided array.
smidrange( N, x, stride ): calculate the mid-range of a single-precision floating-point strided array.
smin( N, x, stride ): calculate the minimum value of a single-precision floating-point strided array.
sminabs( N, x, stride ): calculate the minimum absolute value of a single-precision floating-point strided array.
sminsorted( N, x, stride ): calculate the minimum value of a sorted single-precision floating-point strided array.
smskmax( N, x, strideX, mask, strideMask ): calculate the maximum value of a single-precision floating-point strided array according to a mask.
smskmin( N, x, strideX, mask, strideMask ): calculate the minimum value of a single-precision floating-point strided array according to a mask.
smskrange( N, x, strideX, mask, strideMask ): calculate the range of a single-precision floating-point strided array according to a mask.
snanmax( N, x, stride ): calculate the maximum value of a single-precision floating-point strided array, ignoring NaN values.
snanmaxabs( N, x, stride ): calculate the maximum absolute value of a single-precision floating-point strided array, ignoring NaN values.
snanmean( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array, ignoring NaN values.
snanmeanors( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array, ignoring NaN values and using ordinary recursive summation.
snanmeanpn( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array, ignoring NaN values and using a two-pass error correction algorithm.
snanmeanwd( N, x, stride ): calculate the arithmetic mean of a single-precision floating-point strided array, ignoring NaN values and using Welford's algorithm.
snanmin( N, x, stride ): calculate the minimum value of a single-precision floating-point strided array, ignoring NaN values.
snanminabs( N, x, stride ): calculate the minimum absolute value of a single-precision floating-point strided array, ignoring NaN values.
snanmskmax( N, x, strideX, mask, strideMask ): calculate the maximum value of a single-precision floating-point strided array according to a mask, ignoring NaN values.
snanmskmin( N, x, strideX, mask, strideMask ): calculate the minimum value of a single-precision floating-point strided array according to a mask, ignoring NaN values.
snanmskrange( N, x, strideX, mask, strideMask ): calculate the range of a single-precision floating-point strided array according to a mask, ignoring NaN values.
snanrange( N, x, stride ): calculate the range of a single-precision floating-point strided array, ignoring NaN values.
snanstdev( N, correction, x, stride ): calculate the standard deviation of a single-precision floating-point strided array ignoring NaN values.
snanstdevch( N, correction, x, stride ): calculate the standard deviation of a single-precision floating-point strided array ignoring NaN values and using a one-pass trial mean algorithm.
snanstdevpn( N, correction, x, stride ): calculate the standard deviation of a single-precision floating-point strided array ignoring NaN values and using a two-pass algorithm.
snanstdevtk( N, correction, x, stride ): calculate the standard deviation of a single-precision floating-point strided array ignoring NaN values and using a one-pass textbook algorithm.
snanstdevwd( N, correction, x, stride ): calculate the standard deviation of a single-precision floating-point strided array ignoring NaN values and using Welford's algorithm.
snanstdevyc( N, correction, x, stride ): calculate the standard deviation of a single-precision floating-point strided array ignoring NaN values and using a one-pass algorithm proposed by Youngs and Cramer.
snanvariance( N, correction, x, stride ): calculate the variance of a single-precision floating-point strided array ignoring NaN values.
snanvariancech( N, correction, x, stride ): calculate the variance of a single-precision floating-point strided array ignoring NaN values and using a one-pass trial mean algorithm.
snanvariancepn( N, correction, x, stride ): calculate the variance of a single-precision floating-point strided array ignoring NaN values and using a two-pass algorithm.
snanvariancetk( N, correction, x, stride ): calculate the variance of a single-precision floating-point strided array ignoring NaN values and using a one-pass textbook algorithm.
snanvariancewd( N, correction, x, stride ): calculate the variance of a single-precision floating-point strided array ignoring NaN values and using Welford's algorithm.
snanvarianceyc( N, correction, x, stride ): calculate the variance of a single-precision floating-point strided array ignoring NaN values and using a one-pass algorithm proposed by Youngs and Cramer.
srange( N, x, stride ): calculate the range of a single-precision floating-point strided array.
sstdev( N, correction, x, stride ): calculate the standard deviation of a single-precision floating-point strided array.
sstdevch( N, correction, x, stride ): calculate the standard deviation of a single-precision floating-point strided array using a one-pass trial mean algorithm.
sstdevpn( N, correction, x, stride ): calculate the standard deviation of a single-precision floating-point strided array using a two-pass algorithm.
sstdevtk( N, correction, x, stride ): calculate the standard deviation of a single-precision floating-point strided array using a one-pass textbook algorithm.
sstdevwd( N, correction, x, stride ): calculate the standard deviation of a single-precision floating-point strided array using Welford's algorithm.
sstdevyc( N, correction, x, stride ): calculate the standard deviation of a single-precision floating-point strided array using a one-pass algorithm proposed by Youngs and Cramer.
stdev( N, correction, x, stride ): calculate the standard deviation of a strided array.
stdevch( N, correction, x, stride ): calculate the standard deviation of a strided array using a one-pass trial mean algorithm.
stdevpn( N, correction, x, stride ): calculate the standard deviation of a strided array using a two-pass algorithm.
stdevtk( N, correction, x, stride ): calculate the standard deviation of a strided array using a one-pass textbook algorithm.
stdevwd( N, correction, x, stride ): calculate the standard deviation of a strided array using Welford's algorithm.
stdevyc( N, correction, x, stride ): calculate the standard deviation of a strided array using a one-pass algorithm proposed by Youngs and Cramer.
svariance( N, correction, x, stride ): calculate the variance of a single-precision floating-point strided array.
svariancech( N, correction, x, stride ): calculate the variance of a single-precision floating-point strided array using a one-pass trial mean algorithm.
svariancepn( N, correction, x, stride ): calculate the variance of a single-precision floating-point strided array using a two-pass algorithm.
svariancetk( N, correction, x, stride ): calculate the variance of a single-precision floating-point strided array using a one-pass textbook algorithm.
svariancewd( N, correction, x, stride ): calculate the variance of a single-precision floating-point strided array using Welford's algorithm.
svarianceyc( N, correction, x, stride ): calculate the variance of a single-precision floating-point strided array using a one-pass algorithm proposed by Youngs and Cramer.
variance( N, correction, x, stride ): calculate the variance of a strided array.
variancech( N, correction, x, stride ): calculate the variance of a strided array using a one-pass trial mean algorithm.
variancepn( N, correction, x, stride ): calculate the variance of a strided array using a two-pass algorithm.
variancetk( N, correction, x, stride ): calculate the variance of a strided array using a one-pass textbook algorithm.
variancewd( N, correction, x, stride ): calculate the variance of a strided array using Welford's algorithm.
varianceyc( N, correction, x, stride ): calculate the variance of a strided array using a one-pass algorithm proposed by Youngs and Cramer.

Examples

var objectKeys = require( '@stdlib/utils/keys' );
var ns = require( '@stdlib/stats/base' );

console.log( objectKeys( ns ) );