README.md

Statistics

Statistical operations for strided arrays.

Usage

var ns = require( '@stdlib/stats/strided' );

ns

Namespace containing APIs for performing statistical operations on strided arrays.

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

The namespace exports the following:

• covarmtk( N, correction, meanx, x, strideX, meany, y, strideY ): calculate the covariance of two strided arrays provided known means and using a one-pass textbook algorithm.
• dcovarmtk( N, correction, meanx, x, strideX, meany, y, strideY ): calculate the covariance of two double-precision floating-point strided arrays provided known means and using a one-pass textbook algorithm.
• dcovmatmtk( order, orient, uplo, M, N, correction, means, strideM, A, LDA, B, LDB ): compute the covariance matrix for an M by N double-precision floating-point matrix A and assign the results to a matrix B when provided known means and using a one-pass textbook algorithm.
• 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.
• distances: distance metrics for strided arrays.
• dmax( N, x, strideX ): calculate the maximum value of a double-precision floating-point strided array.
• dmaxabs( N, x, strideX ): calculate the maximum absolute value of a double-precision floating-point strided array.
• dmaxabssorted( N, x, strideX ): calculate the maximum absolute value of a sorted double-precision floating-point strided array.
• dmaxsorted( N, x, strideX ): calculate the maximum value of a sorted double-precision floating-point strided array.
• dmean( N, x, strideX ): calculate the arithmetic mean of a double-precision floating-point strided array.
• dmeankbn( N, x, strideX ): calculate the arithmetic mean of a double-precision floating-point strided array using an improved Kahan–Babuška algorithm.
• dmeankbn2( N, x, strideX ): calculate the arithmetic mean of a double-precision floating-point strided array using a second-order iterative Kahan–Babuška algorithm.
• dmeanli( N, x, strideX ): calculate the arithmetic mean of a double-precision floating-point strided array using a one-pass trial mean algorithm.
• dmeanlipw( N, x, strideX ): 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, strideX ): calculate the arithmetic mean of a double-precision floating-point strided array using ordinary recursive summation.
• dmeanpn( N, x, strideX ): calculate the arithmetic mean of a double-precision floating-point strided array using a two-pass error correction algorithm.
• dmeanpw( N, x, strideX ): 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, strideX ): calculate the arithmetic mean of a double-precision floating-point strided array using Welford's algorithm.
• dmediansorted( N, x, strideX ): calculate the median value of a sorted double-precision floating-point strided array.
• dmidrange( N, x, strideX ): calculate the mid-range of a double-precision floating-point strided array.
• dmin( N, x, strideX ): calculate the minimum value of a double-precision floating-point strided array.
• dminabs( N, x, strideX ): calculate the minimum absolute value of a double-precision floating-point strided array.
• dminsorted( N, x, strideX ): 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.
• dmskmaxabs( N, x, strideX, mask, strideMask ): calculate the maximum absolute value of a double-precision floating-point strided array according to a mask.
• dmskmidrange( N, x, strideX, mask, strideMask ): calculate the mid-range 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.
• dnancount( N, x, strideX ): calculate the number of non-NaN elements in a double-precision floating-point strided array.
• dnanmax( N, x, strideX ): calculate the maximum value of a double-precision floating-point strided array, ignoring NaN values.
• dnanmaxabs( N, x, strideX ): calculate the maximum absolute value of a double-precision floating-point strided array, ignoring NaN values.
• dnanmean( N, x, strideX ): calculate the arithmetic mean of a double-precision floating-point strided array, ignoring NaN values.
• dnanmeanors( N, x, strideX ): calculate the arithmetic mean of a double-precision floating-point strided array, ignoring NaN values and using ordinary recursive summation.
• dnanmeanpn( N, x, strideX ): 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, strideX ): calculate the arithmetic mean of a double-precision floating-point strided array, ignoring NaN values and using pairwise summation.
• dnanmeanwd( N, x, strideX ): calculate the arithmetic mean of a double-precision floating-point strided array, using Welford's algorithm and ignoring NaN values.
• dnanmidrange( N, x, strideX ): calculate the mid-range of a double-precision floating-point strided array, ignoring NaN values.
• dnanmin( N, x, strideX ): calculate the minimum value of a double-precision floating-point strided array, ignoring NaN values.
• dnanminabs( N, x, strideX ): 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.
• dnanmskmaxabs( N, x, strideX, mask, strideMask ): calculate the maximum absolute value of a double-precision floating-point strided array according to a mask, ignoring NaN values.
• dnanmskmidrange( N, x, strideX, mask, strideMask ): calculate the mid-range 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.
• dnanmskminabs( N, x, strideX, mask, strideMask ): calculate the minimum absolute 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, strideX ): calculate the range of a double-precision floating-point strided array, ignoring NaN values.
• dnanrangeabs( N, \*X, strideX ): compute the range of absolute values of a double-precision floating-point strided array, ignoring NaN values.
• dnanstdev( N, correction, x, strideX ): calculate the standard deviation of a double-precision floating-point strided array ignoring NaN values.
• dnanstdevch( N, correction, x, strideX ): 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, strideX ): 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, strideX ): 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, strideX ): calculate the standard deviation of a double-precision floating-point strided array ignoring NaN values and using Welford's algorithm.
• dnanstdevyc( N, correction, x, strideX ): 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, strideX ): calculate the variance of a double-precision floating-point strided array ignoring NaN values.
• dnanvariancech( N, correction, x, strideX ): 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, strideX ): calculate the variance of a double-precision floating-point strided array ignoring NaN values and using a two-pass algorithm.
• dnanvariancetk( N, correction, x, strideX ): 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, strideX ): calculate the variance of a double-precision floating-point strided array ignoring NaN values and using Welford's algorithm.
• dnanvarianceyc( N, correction, x, strideX ): 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.
• dpcorrwd( N, x, strideX, y, strideY ): calculate the sample Pearson product-moment correlation coefficient of two double-precision floating-point strided arrays using Welford's algorithm.
• drange( N, x, strideX ): calculate the range of a double-precision floating-point strided array.
• drangeabs( N, x, strideX ): compute the range of absolute values of a double-precision floating-point strided array.
• dsem( N, correction, x, strideX ): calculate the standard error of the mean of a double-precision floating-point strided array.
• dsemch( N, correction, x, strideX ): 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, strideX ): calculate the standard error of the mean of a double-precision floating-point strided array using a two-pass algorithm.
• dsemtk( N, correction, x, strideX ): 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, strideX ): calculate the standard error of the mean of a double-precision floating-point strided array using Welford's algorithm.
• dsemyc( N, correction, x, strideX ): 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, strideX ): calculate the arithmetic mean of a single-precision floating-point strided array using extended accumulation and returning an extended precision result.
• dsmeanors( N, x, strideX ): 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, strideX ): 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, strideX ): 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, strideX ): 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, strideX ): 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, strideX ): 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, strideX ): 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, strideX ): 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, strideX ): calculate the standard deviation of a double-precision floating-point strided array.
• dstdevch( N, correction, x, strideX ): calculate the standard deviation of a double-precision floating-point strided array using a one-pass trial mean algorithm.
• dstdevpn( N, correction, x, strideX ): calculate the standard deviation of a double-precision floating-point strided array using a two-pass algorithm.
• dstdevtk( N, correction, x, strideX ): calculate the standard deviation of a double-precision floating-point strided array using a one-pass textbook algorithm.
• dstdevwd( N, correction, x, strideX ): calculate the standard deviation of a double-precision floating-point strided array using Welford's algorithm.
• dstdevyc( N, correction, x, strideX ): 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, strideX ): calculate the variance of a single-precision floating-point strided array using extended accumulation and returning an extended precision result.
• dsvariancepn( N, correction, x, strideX ): 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, strideX ): calculate the variance of a double-precision floating-point strided array.
• dvariancech( N, correction, x, strideX ): calculate the variance of a double-precision floating-point strided array using a one-pass trial mean algorithm.
• dvariancepn( N, correction, x, strideX ): calculate the variance of a double-precision floating-point strided array using a two-pass algorithm.
• dvariancetk( N, correction, x, strideX ): calculate the variance of a double-precision floating-point strided array using a one-pass textbook algorithm.
• dvariancewd( N, correction, x, strideX ): calculate the variance of a double-precision floating-point strided array using Welford's algorithm.
• dvarianceyc( N, correction, x, strideX ): calculate the variance of a double-precision floating-point strided array using a one-pass algorithm proposed by Youngs and Cramer.
• dvarm( N, correction, mean, x, strideX ): calculate the variance of a double-precision floating-point strided array provided a known mean.
• dvarmpn( N, correction, mean, x, strideX ): calculate the variance of a double-precision floating-point strided array provided a known mean and using Neely's correction algorithm.
• dvarmtk( N, correction, mean, x, strideX ): calculate the variance of a double-precision floating-point strided array provided a known mean and using a one-pass textbook algorithm.
• dztest( N, alternative, alpha, mu, sigma, x, strideX, out ): compute a one-sample Z-test for a double-precision floating-point strided array.
• dztest2( NX, NY, alternative, alpha, diff, sigmax, x, strideX, sigmay, y, strideY, out ): compute a two-sample Z-test for two double-precision floating-point strided arrays.
• maxBy( N, x, strideX, clbk[, thisArg] ): calculate the maximum value of a strided array via a callback function.
• max( N, x, strideX ): calculate the maximum value of a strided array.
• maxabs( N, x, strideX ): calculate the maximum absolute value of a strided array.
• maxsorted( N, x, strideX ): calculate the maximum value of a sorted strided array.
• mean( N, x, strideX ): calculate the arithmetic mean of a strided array.
• meankbn( N, x, strideX ): calculate the arithmetic mean of a strided array using an improved Kahan–Babuška algorithm.
• meankbn2( N, x, strideX ): calculate the arithmetic mean of a strided array using a second-order iterative Kahan–Babuška algorithm.
• meanors( N, x, strideX ): calculate the arithmetic mean of a strided array using ordinary recursive summation.
• meanpn( N, x, strideX ): calculate the arithmetic mean of a strided array using a two-pass error correction algorithm.
• meanpw( N, x, strideX ): calculate the arithmetic mean of a strided array using pairwise summation.
• meanwd( N, x, strideX ): calculate the arithmetic mean of a strided array using Welford's algorithm.
• mediansorted( N, x, strideX ): calculate the median value of a sorted strided array.
• midrangeBy( N, x, strideX, clbk[, thisArg] ): calculate the mid-range of a strided array via a callback function.
• midrange( N, x, strideX ): calculate the mid-range of a strided array.
• minBy( N, x, strideX, clbk[, thisArg] ): calculate the minimum value of a strided array via a callback function.
• min( N, x, strideX ): calculate the minimum value of a strided array.
• minabs( N, x, strideX ): calculate the minimum absolute value of a strided array.
• minsorted( N, x, strideX ): 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.
• mskmaxabs( N, x, strideX, mask, strideMask ): calculate the maximum absolute value of a strided array according to a mask.
• mskmidrange( N, x, strideX, mask, strideMask ): calculate the mid-range 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.
• mskminabs( N, x, strideX, mask, strideMask ): calculate the minimum absolute 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.
• nancount( N, x, strideX ): calculate the number of non-NaN elements in a strided array.
• nanmaxBy( N, x, strideX, clbk[, thisArg] ): calculate the maximum value of a strided array via a callback function, ignoring NaN values.
• nanmax( N, x, strideX ): calculate the maximum value of a strided array, ignoring NaN values.
• nanmaxabs( N, x, strideX ): calculate the maximum absolute value of a strided array, ignoring NaN values.
• nanmean( N, x, strideX ): calculate the arithmetic mean of a strided array, ignoring NaN values.
• nanmeanors( N, x, strideX ): calculate the arithmetic mean of a strided array, ignoring NaN values and using ordinary recursive summation.
• nanmeanpn( N, x, strideX ): calculate the arithmetic mean of a strided array, ignoring NaN values and using a two-pass error correction algorithm.
• nanmeanwd( N, x, strideX ): calculate the arithmetic mean of a strided array, ignoring NaN values and using Welford's algorithm.
• nanmidrangeBy( N, x, strideX, clbk[, thisArg] ): calculate the mid-range of a strided array via a callback function, ignoring NaN values.
• nanmidrange( N, x, strideX ): calculate the mid-range of a strided array, ignoring NaN values.
• nanminBy( N, x, strideX, clbk[, thisArg] ): calculate the minimum value of a strided array via a callback function, ignoring NaN values.
• nanmin( N, x, strideX ): calculate the minimum value of a strided array, ignoring NaN values.
• nanminabs( N, x, strideX ): 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.
• nanmskmidrange( N, x, strideX, mask, strideMask ): calculate the mid-range 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, strideX, clbk[, thisArg] ): calculate the range of a strided array via a callback function, ignoring NaN values.
• nanrange( N, x, strideX ): calculate the range of a strided array, ignoring NaN values.
• nanrangeabs( N, x, strideX ): calculate the range of absolute values of a strided array, ignoring NaN values.
• nanstdev( N, correction, x, strideX ): calculate the standard deviation of a strided array ignoring NaN values.
• nanstdevch( N, correction, x, strideX ): calculate the standard deviation of a strided array ignoring NaN values and using a one-pass trial mean algorithm.
• nanstdevpn( N, correction, x, strideX ): calculate the standard deviation of a strided array ignoring NaN values and using a two-pass algorithm.
• nanstdevtk( N, correction, x, strideX ): calculate the standard deviation of a strided array ignoring NaN values and using a one-pass textbook algorithm.
• nanstdevwd( N, correction, x, strideX ): calculate the standard deviation of a strided array ignoring NaN values and using Welford's algorithm.
• nanstdevyc( N, correction, x, strideX ): 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, strideX ): calculate the variance of a strided array ignoring NaN values.
• nanvariancech( N, correction, x, strideX ): calculate the variance of a strided array ignoring NaN values and using a one-pass trial mean algorithm.
• nanvariancepn( N, correction, x, strideX ): calculate the variance of a strided array ignoring NaN values and using a two-pass algorithm.
• nanvariancetk( N, correction, x, strideX ): calculate the variance of a strided array ignoring NaN values and using a one-pass textbook algorithm.
• nanvariancewd( N, correction, x, strideX ): calculate the variance of a strided array ignoring NaN values and using Welford's algorithm.
• nanvarianceyc( N, correction, x, strideX ): calculate the variance of a strided array ignoring NaN values and using a one-pass algorithm proposed by Youngs and Cramer.
• rangeBy( N, x, strideX, clbk[, thisArg] ): calculate the range of a strided array via a callback function.
• range( N, x, strideX ): calculate the range of a strided array.
• rangeabs( N, x, strideX ): calculate the range of absolute values of a strided array.
• scovarmtk( N, correction, meanx, x, strideX, meany, y, strideY ): calculate the covariance of two single-precision floating-point strided arrays provided known means and using a one-pass textbook algorithm.
• 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, strideX ): calculate the arithmetic mean of a single-precision floating-point strided array using extended accumulation.
• sdsmeanors( N, x, strideX ): calculate the arithmetic mean of a single-precision floating-point strided array using ordinary recursive summation with extended accumulation.
• sdsnanmeanors( N, x, strideX ): 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, strideX ): calculate the maximum value of a single-precision floating-point strided array.
• smaxabs( N, x, strideX ): calculate the maximum absolute value of a single-precision floating-point strided array.
• smaxabssorted( N, x, strideX ): 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, strideX ): calculate the arithmetic mean of a single-precision floating-point strided array.
• smeankbn( N, x, strideX ): calculate the arithmetic mean of a single-precision floating-point strided array using an improved Kahan–Babuška algorithm.
• smeankbn2( N, x, strideX ): calculate the arithmetic mean of a single-precision floating-point strided array using a second-order iterative Kahan–Babuška algorithm.
• smeanli( N, x, strideX ): calculate the arithmetic mean of a single-precision floating-point strided array using a one-pass trial mean algorithm.
• smeanlipw( N, x, strideX ): 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, strideX ): calculate the arithmetic mean of a single-precision floating-point strided array using ordinary recursive summation.
• smeanpn( N, x, strideX ): calculate the arithmetic mean of a single-precision floating-point strided array using a two-pass error correction algorithm.
• smeanpw( N, x, strideX ): calculate the arithmetic mean of a single-precision floating-point strided array using pairwise summation.
• smeanwd( N, x, strideX ): calculate the arithmetic mean of a single-precision floating-point strided array using Welford's algorithm.
• smediansorted( N, x, strideX ): calculate the median value of a sorted single-precision floating-point strided array.
• smidrange( N, x, strideX ): calculate the mid-range of a single-precision floating-point strided array.
• smin( N, x, strideX ): calculate the minimum value of a single-precision floating-point strided array.
• sminabs( N, x, strideX ): calculate the minimum absolute value of a single-precision floating-point strided array.
• sminsorted( N, x, strideX ): 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.
• smskmaxabs( N, x, strideX, mask, strideMask ): calculate the maximum absolute value of a single-precision floating-point strided array according to a mask.
• smskmidrange( N, x, strideX, mask, strideMask ): calculate the mid-range 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.
• snancount( N, x, strideX ): calculate the number of non-NaN elements in a single-precision floating-point strided array.
• snanmax( N, x, strideX ): calculate the maximum value of a single-precision floating-point strided array, ignoring NaN values.
• snanmaxabs( N, x, strideX ): calculate the maximum absolute value of a single-precision floating-point strided array, ignoring NaN values.
• snanmean( N, x, strideX ): calculate the arithmetic mean of a single-precision floating-point strided array, ignoring NaN values.
• snanmeanors( N, x, strideX ): calculate the arithmetic mean of a single-precision floating-point strided array, ignoring NaN values and using ordinary recursive summation.
• snanmeanpn( N, x, strideX ): 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, strideX ): calculate the arithmetic mean of a single-precision floating-point strided array, ignoring NaN values and using Welford's algorithm.
• snanmidrange( N, x, strideX ): calculate the mid-range of a single-precision floating-point strided array, ignoring NaN values.
• snanmin( N, x, strideX ): calculate the minimum value of a single-precision floating-point strided array, ignoring NaN values.
• snanminabs( N, x, strideX ): 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.
• snanmskmaxabs( N, x, strideX, mask, strideMask ): calculate the maximum absolute value of a single-precision floating-point strided array according to a mask, ignoring NaN values.
• snanmskmidrange( N, x, strideX, mask, strideMask ): calculate the mid-range 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.
• snanmskminabs( N, x, strideX, mask, strideMask ): calculate the minimum absolute 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, strideX ): calculate the range of a single-precision floating-point strided array, ignoring NaN values.
• srange( N, x, strideX ): calculate the range of a single-precision floating-point strided array.
• srangeabs( N, x, strideX ): compute the range of absolute values of a single-precision floating-point strided array.
• sstdev( N, correction, x, strideX ): calculate the standard deviation of a single-precision floating-point strided array.
• sstdevch( N, correction, x, strideX ): calculate the standard deviation of a single-precision floating-point strided array using a one-pass trial mean algorithm.
• sstdevpn( N, correction, x, strideX ): calculate the standard deviation of a single-precision floating-point strided array using a two-pass algorithm.
• sstdevtk( N, correction, x, strideX ): calculate the standard deviation of a single-precision floating-point strided array using a one-pass textbook algorithm.
• sstdevwd( N, correction, x, strideX ): calculate the standard deviation of a single-precision floating-point strided array using Welford's algorithm.
• sstdevyc( N, correction, x, strideX ): 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, strideX ): calculate the standard deviation of a strided array.
• stdevch( N, correction, x, strideX ): calculate the standard deviation of a strided array using a one-pass trial mean algorithm.
• stdevpn( N, correction, x, strideX ): calculate the standard deviation of a strided array using a two-pass algorithm.
• stdevtk( N, correction, x, strideX ): calculate the standard deviation of a strided array using a one-pass textbook algorithm.
• stdevwd( N, correction, x, strideX ): calculate the standard deviation of a strided array using Welford's algorithm.
• stdevyc( N, correction, x, strideX ): calculate the standard deviation of a strided array using a one-pass algorithm proposed by Youngs and Cramer.
• svariance( N, correction, x, strideX ): calculate the variance of a single-precision floating-point strided array.
• svariancech( N, correction, x, strideX ): calculate the variance of a single-precision floating-point strided array using a one-pass trial mean algorithm.
• svariancepn( N, correction, x, strideX ): calculate the variance of a single-precision floating-point strided array using a two-pass algorithm.
• svariancetk( N, correction, x, strideX ): calculate the variance of a single-precision floating-point strided array using a one-pass textbook algorithm.
• svariancewd( N, correction, x, strideX ): calculate the variance of a single-precision floating-point strided array using Welford's algorithm.
• svarianceyc( N, correction, x, strideX ): calculate the variance of a single-precision floating-point strided array using a one-pass algorithm proposed by Youngs and Cramer.
• sztest( N, alternative, alpha, mu, sigma, x, strideX, out ): compute a one-sample Z-test for a single-precision floating-point strided array.
• sztest2( NX, NY, alternative, alpha, diff, sigmax, x, strideX, sigmay, y, strideY, out ): compute a two-sample Z-test for two single-precision floating-point strided arrays.
• variance( N, correction, x, strideX ): calculate the variance of a strided array.
• variancech( N, correction, x, strideX ): calculate the variance of a strided array using a one-pass trial mean algorithm.
• variancepn( N, correction, x, strideX ): calculate the variance of a strided array using a two-pass algorithm.
• variancetk( N, correction, x, strideX ): calculate the variance of a strided array using a one-pass textbook algorithm.
• variancewd( N, correction, x, strideX ): calculate the variance of a strided array using Welford's algorithm.
• varianceyc( N, correction, x, strideX ): calculate the variance of a strided array using a one-pass algorithm proposed by Youngs and Cramer.
• ztest( N, alternative, alpha, mu, sigma, x, strideX, out ): compute a one-sample Z-test for a strided array.
• ztest2( NX, NY, alternative, alpha, diff, sigmax, x, strideX, sigmay, y, strideY, out ): compute a two-sample Z-test.

Examples

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

console.log( objectKeys( ns ) );