diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/base/ndarray/docs/types/index.d.ts index a66a3e93e3f2..e3182e42b319 100644 --- a/lib/node_modules/@stdlib/stats/base/ndarray/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/stats/base/ndarray/docs/types/index.d.ts @@ -37,11 +37,19 @@ import dmeankbn = require( '@stdlib/stats/base/ndarray/dmeankbn' ); import dmeankbn2 = require( '@stdlib/stats/base/ndarray/dmeankbn2' ); import dmeanli = require( '@stdlib/stats/base/ndarray/dmeanli' ); import dmeanlipw = require( '@stdlib/stats/base/ndarray/dmeanlipw' ); +import dmeanors = require( '@stdlib/stats/base/ndarray/dmeanors' ); import dmeanpn = require( '@stdlib/stats/base/ndarray/dmeanpn' ); import dmeanpw = require( '@stdlib/stats/base/ndarray/dmeanpw' ); +import dmeanstdev = require( '@stdlib/stats/base/ndarray/dmeanstdev' ); +import dmeanwd = require( '@stdlib/stats/base/ndarray/dmeanwd' ); +import dmediansorted = require( '@stdlib/stats/base/ndarray/dmediansorted' ); +import dmidrange = require( '@stdlib/stats/base/ndarray/dmidrange' ); import dmin = require( '@stdlib/stats/base/ndarray/dmin' ); import dminabs = require( '@stdlib/stats/base/ndarray/dminabs' ); import dminsorted = require( '@stdlib/stats/base/ndarray/dminsorted' ); +import dmskmax = require( '@stdlib/stats/base/ndarray/dmskmax' ); +import dmskmin = require( '@stdlib/stats/base/ndarray/dmskmin' ); +import dmskrange = require( '@stdlib/stats/base/ndarray/dmskrange' ); import dnanmax = require( '@stdlib/stats/base/ndarray/dnanmax' ); import dnanmaxabs = require( '@stdlib/stats/base/ndarray/dnanmaxabs' ); import dnanmean = require( '@stdlib/stats/base/ndarray/dnanmean' ); @@ -49,9 +57,18 @@ import dnanmeanors = require( '@stdlib/stats/base/ndarray/dnanmeanors' ); import dnanmeanpn = require( '@stdlib/stats/base/ndarray/dnanmeanpn' ); import dnanmeanpw = require( '@stdlib/stats/base/ndarray/dnanmeanpw' ); import dnanmeanwd = require( '@stdlib/stats/base/ndarray/dnanmeanwd' ); +import dnanmidrange = require( '@stdlib/stats/base/ndarray/dnanmidrange' ); import dnanmin = require( '@stdlib/stats/base/ndarray/dnanmin' ); import dnanminabs = require( '@stdlib/stats/base/ndarray/dnanminabs' ); +import dnanmskmax = require( '@stdlib/stats/base/ndarray/dnanmskmax' ); +import dnanmskmin = require( '@stdlib/stats/base/ndarray/dnanmskmin' ); +import dnanmskrange = require( '@stdlib/stats/base/ndarray/dnanmskrange' ); +import dnanrange = require( '@stdlib/stats/base/ndarray/dnanrange' ); import drange = require( '@stdlib/stats/base/ndarray/drange' ); +import dstdev = require( '@stdlib/stats/base/ndarray/dstdev' ); +import dstdevch = require( '@stdlib/stats/base/ndarray/dstdevch' ); +import dstdevpn = require( '@stdlib/stats/base/ndarray/dstdevpn' ); +import dstdevwd = require( '@stdlib/stats/base/ndarray/dstdevwd' ); import dztest = require( '@stdlib/stats/base/ndarray/dztest' ); import dztest2 = require( '@stdlib/stats/base/ndarray/dztest2' ); import max = require( '@stdlib/stats/base/ndarray/max' ); @@ -66,20 +83,33 @@ import meanpn = require( '@stdlib/stats/base/ndarray/meanpn' ); import meanpw = require( '@stdlib/stats/base/ndarray/meanpw' ); import meanwd = require( '@stdlib/stats/base/ndarray/meanwd' ); import mediansorted = require( '@stdlib/stats/base/ndarray/mediansorted' ); +import midrange = require( '@stdlib/stats/base/ndarray/midrange' ); +import midrangeBy = require( '@stdlib/stats/base/ndarray/midrange-by' ); import min = require( '@stdlib/stats/base/ndarray/min' ); import minBy = require( '@stdlib/stats/base/ndarray/min-by' ); import minabs = require( '@stdlib/stats/base/ndarray/minabs' ); import minsorted = require( '@stdlib/stats/base/ndarray/minsorted' ); import mskmax = require( '@stdlib/stats/base/ndarray/mskmax' ); +import mskmidrange = require( '@stdlib/stats/base/ndarray/mskmidrange' ); import mskmin = require( '@stdlib/stats/base/ndarray/mskmin' ); import mskrange = require( '@stdlib/stats/base/ndarray/mskrange' ); import nanmax = require( '@stdlib/stats/base/ndarray/nanmax' ); +import nanmaxBy = require( '@stdlib/stats/base/ndarray/nanmax-by' ); import nanmaxabs = require( '@stdlib/stats/base/ndarray/nanmaxabs' ); import nanmean = require( '@stdlib/stats/base/ndarray/nanmean' ); +import nanmeanors = require( '@stdlib/stats/base/ndarray/nanmeanors' ); import nanmeanpn = require( '@stdlib/stats/base/ndarray/nanmeanpn' ); import nanmeanwd = require( '@stdlib/stats/base/ndarray/nanmeanwd' ); +import nanmidrange = require( '@stdlib/stats/base/ndarray/nanmidrange' ); +import nanmidrangeBy = require( '@stdlib/stats/base/ndarray/nanmidrange-by' ); import nanmin = require( '@stdlib/stats/base/ndarray/nanmin' ); +import nanminBy = require( '@stdlib/stats/base/ndarray/nanmin-by' ); import nanminabs = require( '@stdlib/stats/base/ndarray/nanminabs' ); +import nanmskmax = require( '@stdlib/stats/base/ndarray/nanmskmax' ); +import nanmskmin = require( '@stdlib/stats/base/ndarray/nanmskmin' ); +import nanmskrange = require( '@stdlib/stats/base/ndarray/nanmskrange' ); +import nanrange = require( '@stdlib/stats/base/ndarray/nanrange' ); +import nanrangeBy = require( '@stdlib/stats/base/ndarray/nanrange-by' ); import range = require( '@stdlib/stats/base/ndarray/range' ); import rangeBy = require( '@stdlib/stats/base/ndarray/range-by' ); import scovarmtk = require( '@stdlib/stats/base/ndarray/scovarmtk' ); @@ -87,6 +117,9 @@ import scumax = require( '@stdlib/stats/base/ndarray/scumax' ); import scumaxabs = require( '@stdlib/stats/base/ndarray/scumaxabs' ); import scumin = require( '@stdlib/stats/base/ndarray/scumin' ); import scuminabs = require( '@stdlib/stats/base/ndarray/scuminabs' ); +import sdsmean = require( '@stdlib/stats/base/ndarray/sdsmean' ); +import sdsmeanors = require( '@stdlib/stats/base/ndarray/sdsmeanors' ); +import sdsnanmeanors = require( '@stdlib/stats/base/ndarray/sdsnanmeanors' ); import smax = require( '@stdlib/stats/base/ndarray/smax' ); import smaxabs = require( '@stdlib/stats/base/ndarray/smaxabs' ); import smaxabssorted = require( '@stdlib/stats/base/ndarray/smaxabssorted' ); @@ -96,23 +129,48 @@ import smeankbn = require( '@stdlib/stats/base/ndarray/smeankbn' ); import smeankbn2 = require( '@stdlib/stats/base/ndarray/smeankbn2' ); import smeanli = require( '@stdlib/stats/base/ndarray/smeanli' ); import smeanlipw = require( '@stdlib/stats/base/ndarray/smeanlipw' ); +import smeanors = require( '@stdlib/stats/base/ndarray/smeanors' ); import smeanpn = require( '@stdlib/stats/base/ndarray/smeanpn' ); import smeanpw = require( '@stdlib/stats/base/ndarray/smeanpw' ); import smeanwd = require( '@stdlib/stats/base/ndarray/smeanwd' ); +import smediansorted = require( '@stdlib/stats/base/ndarray/smediansorted' ); +import smidrange = require( '@stdlib/stats/base/ndarray/smidrange' ); import smin = require( '@stdlib/stats/base/ndarray/smin' ); import sminabs = require( '@stdlib/stats/base/ndarray/sminabs' ); import sminsorted = require( '@stdlib/stats/base/ndarray/sminsorted' ); +import smskmax = require( '@stdlib/stats/base/ndarray/smskmax' ); +import smskmidrange = require( '@stdlib/stats/base/ndarray/smskmidrange' ); +import smskmin = require( '@stdlib/stats/base/ndarray/smskmin' ); +import smskrange = require( '@stdlib/stats/base/ndarray/smskrange' ); import snanmax = require( '@stdlib/stats/base/ndarray/snanmax' ); import snanmaxabs = require( '@stdlib/stats/base/ndarray/snanmaxabs' ); import snanmean = require( '@stdlib/stats/base/ndarray/snanmean' ); import snanmeanors = require( '@stdlib/stats/base/ndarray/snanmeanors' ); import snanmeanpn = require( '@stdlib/stats/base/ndarray/snanmeanpn' ); import snanmeanwd = require( '@stdlib/stats/base/ndarray/snanmeanwd' ); +import snanmidrange = require( '@stdlib/stats/base/ndarray/snanmidrange' ); import snanmin = require( '@stdlib/stats/base/ndarray/snanmin' ); import snanminabs = require( '@stdlib/stats/base/ndarray/snanminabs' ); +import snanmskmax = require( '@stdlib/stats/base/ndarray/snanmskmax' ); +import snanmskmin = require( '@stdlib/stats/base/ndarray/snanmskmin' ); +import snanmskrange = require( '@stdlib/stats/base/ndarray/snanmskrange' ); +import snanrange = require( '@stdlib/stats/base/ndarray/snanrange' ); import srange = require( '@stdlib/stats/base/ndarray/srange' ); +import sstdev = require( '@stdlib/stats/base/ndarray/sstdev' ); +import sstdevch = require( '@stdlib/stats/base/ndarray/sstdevch' ); +import sstdevpn = require( '@stdlib/stats/base/ndarray/sstdevpn' ); +import sstdevwd = require( '@stdlib/stats/base/ndarray/sstdevwd' ); +import stdev = require( '@stdlib/stats/base/ndarray/stdev' ); +import stdevch = require( '@stdlib/stats/base/ndarray/stdevch' ); +import stdevpn = require( '@stdlib/stats/base/ndarray/stdevpn' ); +import stdevtk = require( '@stdlib/stats/base/ndarray/stdevtk' ); +import stdevwd = require( '@stdlib/stats/base/ndarray/stdevwd' ); +import stdevyc = require( '@stdlib/stats/base/ndarray/stdevyc' ); import sztest = require( '@stdlib/stats/base/ndarray/sztest' ); import sztest2 = require( '@stdlib/stats/base/ndarray/sztest2' ); +import variance = require( '@stdlib/stats/base/ndarray/variance' ); +import variancech = require( '@stdlib/stats/base/ndarray/variancech' ); +import variancewd = require( '@stdlib/stats/base/ndarray/variancewd' ); import ztest = require( '@stdlib/stats/base/ndarray/ztest' ); import ztest2 = require( '@stdlib/stats/base/ndarray/ztest2' ); @@ -527,6 +585,24 @@ interface Namespace { */ dmeanlipw: typeof dmeanlipw; + /** + * Computes the arithmetic mean of a one-dimensional double-precision floating-point ndarray using ordinary recursive summation. + * + * @param arrays - array-like object containing an input ndarray + * @returns arithmetic mean + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.dmeanors( [ x ] ); + * // returns 2.5 + */ + dmeanors: typeof dmeanors; + /** * Computes the arithmetic mean of a one-dimensional double-precision floating-point ndarray using a two-pass error correction algorithm. * @@ -563,6 +639,87 @@ interface Namespace { */ dmeanpw: typeof dmeanpw; + /** + * Computes the mean and standard deviation of a one-dimensional double-precision floating-point ndarray. + * + * @param arrays - array-like object containing an input ndarray, an output ndarray, and ndarray containing the degrees of freedom adjustment + * @returns output ndarray + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var opts = { + * 'dtype': 'float64' + * }; + * + * var xbuf = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] ); + * var x = new ndarray( opts.dtype, xbuf, [ 4 ], [ 2 ], 1, 'row-major' ); + * + * var out = new ndarray( opts.dtype, new Float64Array( 2 ), [ 2 ], [ 1 ], 0, 'row-major' ); + * + * var correction = scalar2ndarray( 1.0, opts ); + * + * var v = ns.dmeanstdev( [ x, out, correction ] ); + * // returns [ ~1.25, ~2.5 ] + */ + dmeanstdev: typeof dmeanstdev; + + /** + * Computes the arithmetic mean of a one-dimensional double-precision floating-point ndarray using Welford's algorithm. + * + * @param arrays - array-like object containing an input ndarray + * @returns arithmetic mean + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.dmeanwd( [ x ] ); + * // returns 2.5 + */ + dmeanwd: typeof dmeanwd; + + /** + * Computes the median value of a sorted one-dimensional double-precision floating-point ndarray. + * + * @param arrays - array-like object containing a sorted input ndarray + * @returns median value + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float64Array( [ 1.0, 2.0, 3.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.dmediansorted( [ x ] ); + * // returns 2.0 + */ + dmediansorted: typeof dmediansorted; + + /** + * Computes the mid-range of a one-dimensional double-precision floating-point ndarray. + * + * @param arrays - array-like object containing an input ndarray + * @returns mid-range + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float64Array( [ 1.0, -2.0, 2.0, 4.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.dmidrange( [ x ] ); + * // returns 1.0 + */ + dmidrange: typeof dmidrange; + /** * Computes the minimum value of a one-dimensional double-precision floating-point ndarray. * @@ -617,6 +774,72 @@ interface Namespace { */ dminsorted: typeof dminsorted; + /** + * Computes the maximum value of a one-dimensional double-precision floating-point ndarray according to a mask. + * + * @param arrays - array-like object containing an input ndarray and a mask ndarray + * @returns maximum value + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float64Array( [ 1.0, -2.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var mbuf = new Uint8Array( [ 0, 0, 1, 0 ] ); + * var mask = new ndarray( 'uint8', mbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.dmskmax( [ x, mask ] ); + * // returns 2.0 + */ + dmskmax: typeof dmskmax; + + /** + * Computes the minimum value of a one-dimensional double-precision floating-point ndarray according to a mask. + * + * @param arrays - array-like object containing an input ndarray and a mask ndarray + * @returns minimum value + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float64Array( [ 1.0, -2.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var maskbuf = new Uint8Array( [ 0, 0, 1, 0 ] ); + * var mask = new ndarray( 'uint8', maskbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.dmskmin( [ x, mask ] ); + * // returns -2.0 + */ + dmskmin: typeof dmskmin; + + /** + * Calculates the range of a one-dimensional double-precision floating-point ndarray according to a mask. + * + * @param arrays - array-like object containing an input ndarray and a mask ndarray + * @returns range + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float64Array( [ 1.0, -2.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var mbuf = new Uint8Array( [ 0, 0, 1, 0 ] ); + * var mask = new ndarray( 'uint8', mbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.dmskrange( [ x, mask ] ); + * // returns 4.0 + */ + dmskrange: typeof dmskrange; + /** * Computes the maximum value of a one-dimensional double-precision floating-point ndarray, ignoring `NaN` values. * @@ -743,6 +966,24 @@ interface Namespace { */ dnanmeanwd: typeof dnanmeanwd; + /** + * Computes the mid-range of a one-dimensional double-precision floating-point ndarray, ignoring `NaN` values. + * + * @param arrays - array-like object containing an input ndarray + * @returns mid-range + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.dnanmidrange( [ x ] ); + * // returns 0.0 + */ + dnanmidrange: typeof dnanmidrange; + /** * Computes the minimum value of a one-dimensional double-precision floating-point ndarray, ignoring `NaN` values. * @@ -780,116 +1021,296 @@ interface Namespace { dnanminabs: typeof dnanminabs; /** - * Computes the range of a one-dimensional double-precision floating-point ndarray. + * Computes the maximum value of a double-precision floating-point ndarray according to a mask, ignoring `NaN` values. * - * @param arrays - array-like object containing an input ndarray - * @returns range + * @param arrays - array-like object containing an input ndarray and a mask ndarray + * @returns maximum value * * @example * var Float64Array = require( '@stdlib/array/float64' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * - * var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var xbuf = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); * - * var v = ns.drange( [ x ] ); - * // returns 3.0 + * var mbuf = new Uint8Array( [ 0, 0, 0, 0 ] ); + * var mask = new ndarray( 'uint8', mbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.dnanmskmax( [ x, mask ] ); + * // returns 2.0 */ - drange: typeof drange; + dnanmskmax: typeof dnanmskmax; /** - * Computes a one-sample Z-test for a one-dimensional double-precision floating-point ndarray. + * Computes the minimum value of a double-precision floating-point ndarray according to a mask, ignoring `NaN` values. * - * ## Notes + * @param arrays - array-like object containing an input ndarray and a mask ndarray + * @returns minimum value * - * - The function expects the following ndarrays in order: + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * - * - a one-dimensional input ndarray. - * - a zero-dimensional output ndarray containing a results object. - * - a zero-dimensional ndarray specifying the alternative hypothesis. - * - a zero-dimensional ndarray specifying the significance level. - * - a zero-dimensional ndarray specifying the mean under the null hypothesis. - * - a zero-dimensional ndarray specifying the known standard deviation. + * var xbuf = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); * - * @param arrays - array-like object containing ndarrays - * @returns output ndarray + * var mbuf = new Uint8Array( [ 0, 0, 0, 0 ] ); + * var mask = new ndarray( 'uint8', mbuf, [ 4 ], [ 1 ], 0, 'row-major' ); * - * @example - * var Float64Results = require( '@stdlib/stats/base/ztest/one-sample/results/float64' ); - * var resolveEnum = require( '@stdlib/stats/base/ztest/alternative-resolve-enum' ); - * var structFactory = require( '@stdlib/array/struct-factory' ); - * var Float64Array = require( '@stdlib/array/float64' ); - * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); - * var ndarray = require( '@stdlib/ndarray/ctor' ); + * var v = ns.dnanmskmin( [ x, mask ] ); + * // returns -2.0 + */ + dnanmskmin: typeof dnanmskmin; + + /** + * Calculates the range of a one-dimensional double-precision floating-point ndarray according to a mask, ignoring `NaN` values. * - * var opts = { - * 'dtype': 'float64' - * }; + * @param arrays - array-like object containing an input ndarray and a mask ndarray + * @returns range * - * // Define a one-dimensional input ndarray: - * var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] ); - * var x = new ndarray( opts.dtype, xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * - * // Specify the alternative hypothesis: - * var alt = scalar2ndarray( resolveEnum( 'two-sided' ), { - * 'dtype': 'int8' - * }); + * var xbuf = new Float64Array( [ 1.0, -2.0, 4.0, 2.0, NaN ] ); + * var x = new ndarray( 'float64', xbuf, [ 5 ], [ 1 ], 0, 'row-major' ); * - * // Specify the significance level: - * var alpha = scalar2ndarray( 0.05, opts ); + * var maskbuf = new Uint8Array( [ 0, 0, 1, 0, 0 ] ); + * var mask = new ndarray( 'uint8', maskbuf, [ 5 ], [ 1 ], 0, 'row-major' ); * - * // Specify the mean value under the null hypothesis: - * var mu = scalar2ndarray( 0.0, opts ); + * var v = ns.dnanmskrange( [ x, mask ] ); + * // returns 4.0 + */ + dnanmskrange: typeof dnanmskrange; + + /** + * Computes the range of a one-dimensional double-precision floating-point ndarray, ignoring NaN values. * - * // Specify the known standard deviation: - * var sigma = scalar2ndarray( 1.0, opts ); + * @param arrays - array-like object containing an input ndarray + * @returns range * - * // Create a zero-dimensional results ndarray: - * var ResultsArray = structFactory( Float64Results ); - * var out = new ndarray( Float64Results, new ResultsArray( 1 ), [], [ 0 ], 0, 'row-major' ); + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * - * // Perform a Z-test: - * var v = ns.dztest( [ x, out, alt, alpha, mu, sigma ] ); - * // returns + * var xbuf = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); * - * console.log( v.get().toString() ); + * var v = ns.dnanrange( [ x ] ); + * // returns 4.0 */ - dztest: typeof dztest; + dnanrange: typeof dnanrange; /** - * Computes a two-sample Z-test for two one-dimensional double-precision floating-point ndarrays. + * Computes the range of a one-dimensional double-precision floating-point ndarray. * - * ## Notes + * @param arrays - array-like object containing an input ndarray + * @returns range * - * - The function expects the following ndarrays in order: + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * - * - first one-dimensional input ndarray. - * - second one-dimensional input ndarray. - * - a zero-dimensional output ndarray containing a results object. - * - a zero-dimensional ndarray specifying the alternative hypothesis. - * - a zero-dimensional ndarray specifying the significance level. - * - a zero-dimensional ndarray specifying the difference in means under the null hypothesis. - * - a zero-dimensional ndarray specifying the known standard deviation of the first one-dimensional input ndarray. - * - a zero-dimensional ndarray specifying the known standard deviation of the second one-dimensional input ndarray. + * var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); * - * @param arrays - array-like object containing ndarrays - * @returns output ndarray + * var v = ns.drange( [ x ] ); + * // returns 3.0 + */ + drange: typeof drange; + + /** + * Computes the standard deviation of a one-dimensional double-precision floating-point ndarray. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying a degrees of freedom adjustment + * @returns standard deviation * * @example - * var Float64Results = require( '@stdlib/stats/base/ztest/two-sample/results/float64' ); - * var resolveEnum = require( '@stdlib/stats/base/ztest/alternative-resolve-enum' ); - * var structFactory = require( '@stdlib/array/struct-factory' ); - * var Float64Array = require( '@stdlib/array/float64' ); - * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); * var ndarray = require( '@stdlib/ndarray/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var Float64Array = require( '@stdlib/array/float64' ); * * var opts = { * 'dtype': 'float64' * }; * - * // Define one-dimensional input ndarrays: - * var xbuf = new Float64Array( [ 4.0, 4.0, 6.0, 6.0, 5.0 ] ); - * var x = new ndarray( opts.dtype, xbuf, [ 5 ], [ 1 ], 0, 'row-major' ); + * var xbuf = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * var x = new ndarray( opts.dtype, xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * var correction = scalar2ndarray( 1.0, opts ); + * + * var v = ns.dstdev( [ x, correction ] ); + * // returns ~2.0817 + */ + dstdev: typeof dstdev; + + /** + * Computes the standard deviation of a one-dimensional double-precision floating-point ndarray using a one-pass trial mean algorithm. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying a degrees of freedom adjustment + * @returns standard deviation + * + * @example + * var ndarray = require( '@stdlib/ndarray/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var opts = { + * 'dtype': 'float64' + * }; + * + * var xbuf = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * var x = new ndarray( opts.dtype, xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * var correction = scalar2ndarray( 1.0, opts ); + * + * var v = ns.dstdevch( [ x, correction ] ); + * // returns ~2.0817 + */ + dstdevch: typeof dstdevch; + + /** + * Computes the standard deviation of a one-dimensional double-precision floating-point ndarray using a two-pass algorithm. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying a degrees of freedom adjustment + * @returns standard deviation + * + * @example + * var ndarray = require( '@stdlib/ndarray/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var opts = { + * 'dtype': 'float64' + * }; + * + * var xbuf = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * var x = new ndarray( opts.dtype, xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * var correction = scalar2ndarray( 1.0, opts ); + * + * var v = ns.dstdevpn( [ x, correction ] ); + * // returns ~2.0817 + */ + dstdevpn: typeof dstdevpn; + + /** + * Computes the standard deviation of a one-dimensional double-precision floating-point ndarray using Welford's algorithm. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying a degrees of freedom adjustment + * @returns standard deviation + * + * @example + * var ndarray = require( '@stdlib/ndarray/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var opts = { + * 'dtype': 'float64' + * }; + * + * var xbuf = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * var x = new ndarray( opts.dtype, xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * var correction = scalar2ndarray( 1.0, opts ); + * + * var v = ns.dstdevwd( [ x, correction ] ); + * // returns ~2.0817 + */ + dstdevwd: typeof dstdevwd; + + /** + * Computes a one-sample Z-test for a one-dimensional double-precision floating-point ndarray. + * + * ## Notes + * + * - The function expects the following ndarrays in order: + * + * - a one-dimensional input ndarray. + * - a zero-dimensional output ndarray containing a results object. + * - a zero-dimensional ndarray specifying the alternative hypothesis. + * - a zero-dimensional ndarray specifying the significance level. + * - a zero-dimensional ndarray specifying the mean under the null hypothesis. + * - a zero-dimensional ndarray specifying the known standard deviation. + * + * @param arrays - array-like object containing ndarrays + * @returns output ndarray + * + * @example + * var Float64Results = require( '@stdlib/stats/base/ztest/one-sample/results/float64' ); + * var resolveEnum = require( '@stdlib/stats/base/ztest/alternative-resolve-enum' ); + * var structFactory = require( '@stdlib/array/struct-factory' ); + * var Float64Array = require( '@stdlib/array/float64' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var ndarray = require( '@stdlib/ndarray/ctor' ); + * + * var opts = { + * 'dtype': 'float64' + * }; + * + * // Define a one-dimensional input ndarray: + * var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( opts.dtype, xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * // Specify the alternative hypothesis: + * var alt = scalar2ndarray( resolveEnum( 'two-sided' ), { + * 'dtype': 'int8' + * }); + * + * // Specify the significance level: + * var alpha = scalar2ndarray( 0.05, opts ); + * + * // Specify the mean value under the null hypothesis: + * var mu = scalar2ndarray( 0.0, opts ); + * + * // Specify the known standard deviation: + * var sigma = scalar2ndarray( 1.0, opts ); + * + * // Create a zero-dimensional results ndarray: + * var ResultsArray = structFactory( Float64Results ); + * var out = new ndarray( Float64Results, new ResultsArray( 1 ), [], [ 0 ], 0, 'row-major' ); + * + * // Perform a Z-test: + * var v = ns.dztest( [ x, out, alt, alpha, mu, sigma ] ); + * // returns + * + * console.log( v.get().toString() ); + */ + dztest: typeof dztest; + + /** + * Computes a two-sample Z-test for two one-dimensional double-precision floating-point ndarrays. + * + * ## Notes + * + * - The function expects the following ndarrays in order: + * + * - first one-dimensional input ndarray. + * - second one-dimensional input ndarray. + * - a zero-dimensional output ndarray containing a results object. + * - a zero-dimensional ndarray specifying the alternative hypothesis. + * - a zero-dimensional ndarray specifying the significance level. + * - a zero-dimensional ndarray specifying the difference in means under the null hypothesis. + * - a zero-dimensional ndarray specifying the known standard deviation of the first one-dimensional input ndarray. + * - a zero-dimensional ndarray specifying the known standard deviation of the second one-dimensional input ndarray. + * + * @param arrays - array-like object containing ndarrays + * @returns output ndarray + * + * @example + * var Float64Results = require( '@stdlib/stats/base/ztest/two-sample/results/float64' ); + * var resolveEnum = require( '@stdlib/stats/base/ztest/alternative-resolve-enum' ); + * var structFactory = require( '@stdlib/array/struct-factory' ); + * var Float64Array = require( '@stdlib/array/float64' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var ndarray = require( '@stdlib/ndarray/ctor' ); + * + * var opts = { + * 'dtype': 'float64' + * }; + * + * // Define one-dimensional input ndarrays: + * var xbuf = new Float64Array( [ 4.0, 4.0, 6.0, 6.0, 5.0 ] ); + * var x = new ndarray( opts.dtype, xbuf, [ 5 ], [ 1 ], 0, 'row-major' ); * * var ybuf = new Float64Array( [ 3.0, 3.0, 5.0, 7.0, 7.0 ] ); * var y = new ndarray( opts.dtype, ybuf, [ 5 ], [ 1 ], 0, 'row-major' ); @@ -1131,6 +1552,46 @@ interface Namespace { */ mediansorted: typeof mediansorted; + /** + * Computes the mid-range of a one-dimensional ndarray. + * + * @param arrays - array-like object containing an input ndarray + * @returns mid-range + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, -2.0, 2.0, 4.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.midrange( [ x ] ); + * // returns 1.0 + */ + midrange: typeof midrange; + + /** + * Computes the mid-range of a one-dimensional ndarray via a callback function. + * + * @param arrays - array-like object containing an input ndarray + * @param clbk - callback function + * @param thisArg - callback execution context + * @returns mid-range + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * function clbk( value ) { + * return value * 2.0; + * } + * + * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.midrangeBy( [ x ], clbk ); + * // returns 5.0 + */ + midrangeBy: typeof midrangeBy; + /** * Computes the minimum value of a one-dimensional ndarray. * @@ -1225,6 +1686,26 @@ interface Namespace { */ mskmax: typeof mskmax; + /** + * Calculates the mid-range of a one-dimensional ndarray according to a mask. + * + * @param arrays - array-like object containing an input ndarray and a mask ndarray + * @returns mid-range + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, -2.0, 4.0, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var mbuf = [ 0, 0, 1, 0 ]; + * var mask = new ndarray( 'generic', mbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.mskmidrange( [ x, mask ] ); + * // returns 0.0 + */ + mskmidrange: typeof mskmidrange; + /** * Computes the minimum value of a one-dimensional ndarray according to a mask. * @@ -1282,6 +1763,29 @@ interface Namespace { */ nanmax: typeof nanmax; + /** + * Computes the maximum value of a one-dimensional ndarray via a callback function, ignoring `NaN` values. + * + * @param arrays - array-like object containing an input ndarray + * @param clbk - callback function + * @param thisArg - callback execution context + * @returns maximum value + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * function clbk( value ) { + * return value * 2.0; + * } + * + * var xbuf = [ 1.0, NaN, 4.0, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.nanmaxBy( [ x ], clbk ); + * // returns 8.0 + */ + nanmaxBy: typeof nanmaxBy; + /** * Computes the maximum absolute value of a one-dimensional ndarray, ignoring `NaN` values. * @@ -1316,6 +1820,23 @@ interface Namespace { */ nanmean: typeof nanmean; + /** + * Computes the arithmetic mean of a one-dimensional ndarray, ignoring `NaN` values and using ordinary recursive summation. + * + * @param arrays - array-like object containing an input ndarray + * @returns arithmetic mean + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, 3.0, NaN, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.nanmeanors( [ x ] ); + * // returns 2.0 + */ + nanmeanors: typeof nanmeanors; + /** * Computes the arithmetic mean of a one-dimensional ndarray, ignoring `NaN` values and using a two-pass error correction algorithm. * @@ -1351,10 +1872,10 @@ interface Namespace { nanmeanwd: typeof nanmeanwd; /** - * Computes the minimum value of a one-dimensional ndarray, ignoring `NaN` values. + * Computes the mid-range of a one-dimensional ndarray, ignoring `NaN` values. * * @param arrays - array-like object containing an input ndarray - * @returns minimum value + * @returns mid-range * * @example * var ndarray = require( '@stdlib/ndarray/base/ctor' ); @@ -1362,44 +1883,207 @@ interface Namespace { * var xbuf = [ 1.0, -2.0, NaN, 2.0 ]; * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); * - * var v = ns.nanmin( [ x ] ); - * // returns -2.0 + * var v = ns.nanmidrange( [ x ] ); + * // returns 0.0 */ - nanmin: typeof nanmin; + nanmidrange: typeof nanmidrange; /** - * Computes the minimum absolute value of a one-dimensional ndarray, ignoring `NaN` values. + * Computes the mid-range of a one-dimensional ndarray via a callback function, ignoring `NaN` values. * * @param arrays - array-like object containing an input ndarray - * @returns minimum absolute value + * @param clbk - callback function + * @param thisArg - callback execution context + * @returns mid-range * * @example * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * + * function clbk( value ) { + * return value * 2.0; + * } + * * var xbuf = [ 1.0, -2.0, NaN, 2.0 ]; * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); * - * var v = ns.nanminabs( [ x ] ); - * // returns 1.0 + * var v = ns.nanmidrangeBy( [ x ], clbk ); + * // returns 0.0 */ - nanminabs: typeof nanminabs; + nanmidrangeBy: typeof nanmidrangeBy; /** - * Computes the range of a one-dimensional ndarray. + * Computes the minimum value of a one-dimensional ndarray, ignoring `NaN` values. * * @param arrays - array-like object containing an input ndarray - * @returns range + * @returns minimum value * * @example * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * - * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; + * var xbuf = [ 1.0, -2.0, NaN, 2.0 ]; * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); * - * var v = ns.range( [ x ] ); - * // returns 3.0 + * var v = ns.nanmin( [ x ] ); + * // returns -2.0 */ - range: typeof range; + nanmin: typeof nanmin; + + /** + * Computes the minimum value of a one-dimensional ndarray via a callback function, ignoring NaN values. + * + * @param arrays - array-like object containing an input ndarray + * @param clbk - callback function + * @param thisArg - callback execution context + * @returns minimum value + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * function clbk( value ) { + * return value * 2.0; + * } + * + * var xbuf = [ 1.0, -2.0, NaN, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.nanminBy( [ x ], clbk ); + * // returns -4.0 + */ + nanminBy: typeof nanminBy; + + /** + * Computes the minimum absolute value of a one-dimensional ndarray, ignoring `NaN` values. + * + * @param arrays - array-like object containing an input ndarray + * @returns minimum absolute value + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, -2.0, NaN, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.nanminabs( [ x ] ); + * // returns 1.0 + */ + nanminabs: typeof nanminabs; + + /** + * Calculates the maximum value of a one-dimensional ndarray according to a mask, ignoring `NaN` values. + * + * @param arrays - array-like object containing an input ndarray and a mask ndarray + * @returns maximum value + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, -2.0, 4.0, 2.0, NaN ]; + * var x = new ndarray( 'generic', xbuf, [ 5 ], [ 1 ], 0, 'row-major' ); + * + * var mbuf = [ 0, 0, 1, 0, 0 ]; + * var mask = new ndarray( 'generic', mbuf, [ 5 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.nanmskmax( [ x, mask ] ); + * // returns 2.0 + */ + nanmskmax: typeof nanmskmax; + + /** + * Computes the minimum value of a one-dimensional ndarray according to a mask, ignoring `NaN` values. + * + * @param arrays - array-like object containing an input ndarray and a mask ndarray + * @returns minimum value + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, -2.0, 4.0, 2.0, NaN ]; + * var x = new ndarray( 'generic', xbuf, [ 5 ], [ 1 ], 0, 'row-major' ); + * + * var maskbuf = [ 0, 0, 1, 0, 0 ]; + * var mask = new ndarray( 'generic', maskbuf, [ 5 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.nanmskmin( [ x, mask ] ); + * // returns -2.0 + */ + nanmskmin: typeof nanmskmin; + + /** + * Calculates the range of a one-dimensional ndarray according to a mask, ignoring `NaN` values. + * + * @param arrays - array-like object containing an input ndarray and a mask ndarray + * @returns range + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, -2.0, 4.0, 2.0, NaN ]; + * var x = new ndarray( 'generic', xbuf, [ 5 ], [ 1 ], 0, 'row-major' ); + * + * var maskbuf = [ 0, 0, 1, 0, 0 ]; + * var mask = new ndarray( 'generic', maskbuf, [ 5 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.nanmskrange( [ x, mask ] ); + * // returns 4.0 + */ + nanmskrange: typeof nanmskrange; + + /** + * Computes the range of a one-dimensional ndarray, ignoring `NaN` values. + * + * @param arrays - array-like object containing an input ndarray + * @returns range + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, -2.0, NaN, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.nanrange( [ x ] ); + * // returns 4.0 + */ + nanrange: typeof nanrange; + + /** + * Computes the range of a one-dimensional ndarray via a callback function, ignoring `NaN` values. + * + * @param arrays - array-like object containing an input ndarray + * @param clbk - callback function + * @param thisArg - callback execution context + * @returns range + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * function clbk( value ) { + * return value * 2.0; + * } + * + * var xbuf = [ 1.0, -2.0, NaN, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.nanrangeBy( [ x ], clbk ); + * // returns 8.0 + */ + nanrangeBy: typeof nanrangeBy; + + /** + * Computes the range of a one-dimensional ndarray. + * + * @param arrays - array-like object containing an input ndarray + * @returns range + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = [ 1.0, 3.0, 4.0, 2.0 ]; + * var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.range( [ x ] ); + * // returns 3.0 + */ + range: typeof range; /** * Computes the range of a one-dimensional ndarray via a callback function. @@ -1576,6 +2260,60 @@ interface Namespace { */ scuminabs: typeof scuminabs; + /** + * Computes the arithmetic mean of a one-dimensional single-precision floating-point ndarray using extended accumulation. + * + * @param arrays - array-like object containing an input ndarray + * @returns arithmetic mean + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.sdsmean( [ x ] ); + * // returns 2.5 + */ + sdsmean: typeof sdsmean; + + /** + * Computes the arithmetic mean of a one-dimensional single-precision floating-point ndarray using ordinary recursive summation with extended accumulation. + * + * @param arrays - array-like object containing an input ndarray + * @returns arithmetic mean + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.sdsmeanors( [ x ] ); + * // returns 2.5 + */ + sdsmeanors: typeof sdsmeanors; + + /** + * Computes the arithmetic mean of a one-dimensional single-precision floating-point ndarray, ignoring NaN values and using ordinary recursive summation with extended accumulation. + * + * @param arrays - array-like object containing an input ndarray + * @returns arithmetic mean + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.sdsnanmeanors( [ x ] ); + * // returns ~0.3333 + */ + sdsnanmeanors: typeof sdsnanmeanors; + /** * Computes the maximum value of a one-dimensional single-precision floating-point ndarray. * @@ -1738,6 +2476,24 @@ interface Namespace { */ smeanlipw: typeof smeanlipw; + /** + * Computes the arithmetic mean of a one-dimensional single-precision floating-point ndarray using ordinary recursive summation. + * + * @param arrays - array-like object containing an input ndarray + * @returns arithmetic mean + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.smeanors( [ x ] ); + * // returns 2.5 + */ + smeanors: typeof smeanors; + /** * Computes the arithmetic mean of a one-dimensional single-precision floating-point ndarray using a two-pass error correction algorithm. * @@ -1792,6 +2548,42 @@ interface Namespace { */ smeanwd: typeof smeanwd; + /** + * Computes the median value of a sorted one-dimensional single-precision floating-point ndarray. + * + * @param arrays - array-like object containing a sorted input ndarray + * @returns median value + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, 2.0, 3.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.smediansorted( [ x ] ); + * // returns 2.0 + */ + smediansorted: typeof smediansorted; + + /** + * Computes the mid-range of a one-dimensional single-precision floating-point ndarray. + * + * @param arrays - array-like object containing an input ndarray + * @returns mid-range + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, -2.0, 2.0, 4.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.smidrange( [ x ] ); + * // returns 1.0 + */ + smidrange: typeof smidrange; + /** * Computes the minimum value of a one-dimensional single-precision floating-point ndarray. * @@ -1847,88 +2639,176 @@ interface Namespace { sminsorted: typeof sminsorted; /** - * Computes the maximum value of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values. + * Computes the maximum value of a one-dimensional single-precision floating-point ndarray according to a mask. * - * @param arrays - array-like object containing an input ndarray + * @param arrays - array-like object containing an input ndarray and a mask ndarray * @returns maximum value * * @example * var Float32Array = require( '@stdlib/array/float32' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * - * var xbuf = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * var xbuf = new Float32Array( [ 1.0, -2.0, 4.0, 2.0 ] ); * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); * - * var v = ns.snanmax( [ x ] ); + * var mbuf = new Uint8Array( [ 0, 0, 1, 0 ] ); + * var mask = new ndarray( 'uint8', mbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.smskmax( [ x, mask ] ); * // returns 2.0 */ - snanmax: typeof snanmax; + smskmax: typeof smskmax; /** - * Computes the maximum absolute value of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values. + * Calculates the mid-range of a one-dimensional single-precision floating-point ndarray according to a mask. * - * @param arrays - array-like object containing an input ndarray - * @returns maximum absolute value + * @param arrays - array-like object containing an input ndarray and a mask ndarray + * @returns mid-range * * @example * var Float32Array = require( '@stdlib/array/float32' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * - * var xbuf = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * var xbuf = new Float32Array( [ 1.0, -2.0, 4.0, 2.0 ] ); * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); * - * var v = ns.snanmaxabs( [ x ] ); - * // returns 2.0 + * var mbuf = new Uint8Array( [ 0, 0, 1, 0 ] ); + * var mask = new ndarray( 'uint8', mbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.smskmidrange( [ x, mask ] ); + * // returns 0.0 */ - snanmaxabs: typeof snanmaxabs; + smskmidrange: typeof smskmidrange; /** - * Computes the arithmetic mean of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values. + * Computes the minimum value of a one-dimensional single-precision floating-point ndarray according to a mask. * - * @param arrays - array-like object containing an input ndarray - * @returns arithmetic mean + * @param arrays - array-like object containing an input ndarray and a mask ndarray + * @returns minimum value * * @example * var Float32Array = require( '@stdlib/array/float32' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * - * var xbuf = new Float32Array( [ 1.0, 3.0, NaN, 2.0 ] ); + * var xbuf = new Float32Array( [ 1.0, -2.0, 4.0, 2.0 ] ); * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); * - * var v = ns.snanmean( [ x ] ); - * // returns 2.0 + * var maskbuf = new Uint8Array( [ 0, 0, 1, 0 ] ); + * var mask = new ndarray( 'uint8', maskbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.smskmin( [ x, mask ] ); + * // returns -2.0 */ - snanmean: typeof snanmean; + smskmin: typeof smskmin; /** - * Computes the arithmetic mean of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values and using ordinary recursive summation. + * Calculates the range of a one-dimensional single-precision floating-point ndarray according to a mask. * - * @param arrays - array-like object containing an input ndarray - * @returns arithmetic mean + * @param arrays - array-like object containing an input ndarray and a mask ndarray + * @returns range * * @example * var Float32Array = require( '@stdlib/array/float32' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * - * var xbuf = new Float32Array( [ 1.0, 3.0, NaN, 2.0 ] ); + * var xbuf = new Float32Array( [ 1.0, -2.0, 4.0, 2.0 ] ); * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); * - * var v = ns.snanmeanors( [ x ] ); - * // returns 2.0 + * var mbuf = new Uint8Array( [ 0, 0, 1, 0 ] ); + * var mask = new ndarray( 'uint8', mbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.smskrange( [ x, mask ] ); + * // returns 4.0 */ - snanmeanors: typeof snanmeanors; + smskrange: typeof smskrange; /** - * Computes the arithmetic mean of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values and using a two-pass error correction algorithm. + * Computes the maximum value of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values. * * @param arrays - array-like object containing an input ndarray - * @returns arithmetic mean + * @returns maximum value * * @example * var Float32Array = require( '@stdlib/array/float32' ); * var ndarray = require( '@stdlib/ndarray/base/ctor' ); * - * var xbuf = new Float32Array( [ 1.0, 3.0, NaN, 2.0 ] ); + * var xbuf = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.snanmax( [ x ] ); + * // returns 2.0 + */ + snanmax: typeof snanmax; + + /** + * Computes the maximum absolute value of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values. + * + * @param arrays - array-like object containing an input ndarray + * @returns maximum absolute value + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.snanmaxabs( [ x ] ); + * // returns 2.0 + */ + snanmaxabs: typeof snanmaxabs; + + /** + * Computes the arithmetic mean of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values. + * + * @param arrays - array-like object containing an input ndarray + * @returns arithmetic mean + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, 3.0, NaN, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.snanmean( [ x ] ); + * // returns 2.0 + */ + snanmean: typeof snanmean; + + /** + * Computes the arithmetic mean of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values and using ordinary recursive summation. + * + * @param arrays - array-like object containing an input ndarray + * @returns arithmetic mean + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, 3.0, NaN, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.snanmeanors( [ x ] ); + * // returns 2.0 + */ + snanmeanors: typeof snanmeanors; + + /** + * Computes the arithmetic mean of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values and using a two-pass error correction algorithm. + * + * @param arrays - array-like object containing an input ndarray + * @returns arithmetic mean + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, 3.0, NaN, 2.0 ] ); * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); * * var v = ns.snanmeanpn( [ x ] ); @@ -1954,6 +2834,24 @@ interface Namespace { */ snanmeanwd: typeof snanmeanwd; + /** + * Computes the mid-range of a one-dimensional single-precision floating-point ndarray, ignoring NaN values. + * + * @param arrays - array-like object containing an input ndarray + * @returns mid-range + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.snanmidrange( [ x ] ); + * // returns 0.0 + */ + snanmidrange: typeof snanmidrange; + /** * Computes the minimum value of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values. * @@ -1990,6 +2888,90 @@ interface Namespace { */ snanminabs: typeof snanminabs; + /** + * Computes the maximum value of a one-dimensional single-precision floating-point ndarray according to a mask, ignoring `NaN` values. + * + * @param arrays - array-like object containing an input ndarray and a mask ndarray + * @returns maximum value + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, -2.0, 4.0, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var mbuf = new Uint8Array( [ 0, 0, 1, 0 ] ); + * var mask = new ndarray( 'uint8', mbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.snanmskmax( [ x, mask ] ); + * // returns 2.0 + */ + snanmskmax: typeof snanmskmax; + + /** + * Computes the minimum value of a one-dimensional single-precision floating-point ndarray according to a mask, ignoring `NaN` values. + * + * @param arrays - array-like object containing an input ndarray and a mask ndarray + * @returns minimum value + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, -2.0, 4.0, 2.0, NaN ] ); + * var x = new ndarray( 'float32', xbuf, [ 5 ], [ 1 ], 0, 'row-major' ); + * + * var maskbuf = new Uint8Array( [ 0, 0, 1, 0, 0 ] ); + * var mask = new ndarray( 'uint8', maskbuf, [ 5 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.snanmskmin( [ x, mask ] ); + * // returns -2.0 + */ + snanmskmin: typeof snanmskmin; + + /** + * Calculates the range of a one-dimensional single-precision floating-point ndarray according to a mask, ignoring `NaN` values. + * + * @param arrays - array-like object containing an input ndarray and a mask ndarray + * @returns range + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, -2.0, 4.0, 2.0, NaN ] ); + * var x = new ndarray( 'float32', xbuf, [ 5 ], [ 1 ], 0, 'row-major' ); + * + * var maskbuf = new Uint8Array( [ 0, 0, 1, 0, 0 ] ); + * var mask = new ndarray( 'uint8', maskbuf, [ 5 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.snanmskrange( [ x, mask ] ); + * // returns 4.0 + */ + snanmskrange: typeof snanmskrange; + + /** + * Computes the range of a one-dimensional single-precision floating-point ndarray, ignoring NaN values. + * + * @param arrays - array-like object containing an input ndarray + * @returns range + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * + * var xbuf = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' ); + * + * var v = ns.snanrange( [ x ] ); + * // returns 4.0 + */ + snanrange: typeof snanrange; + /** * Computes the range of a one-dimensional single-precision floating-point ndarray. * @@ -2008,6 +2990,246 @@ interface Namespace { */ srange: typeof srange; + /** + * Computes the standard deviation of a one-dimensional ndarray. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying a degrees of freedom adjustment + * @returns standard deviation + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var opts = { + * 'dtype': 'float32' + * }; + * + * var xbuf = new Float32Array( [ 1.0, -2.0, 2.0 ] ); + * var x = new ndarray( opts.dtype, xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * var correction = scalar2ndarray( 1.0, opts ); + * + * var v = ns.sstdev( [ x, correction ] ); + * // returns ~2.0817 + */ + sstdev: typeof sstdev; + + /** + * Computes the standard deviation of a one-dimensional single-precision floating-point ndarray using a one-pass trial mean algorithm. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying a degrees of freedom adjustment + * @returns standard deviation + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var opts = { + * 'dtype': 'float32' + * }; + * + * var xbuf = new Float32Array( [ 1.0, -2.0, 2.0 ] ); + * var x = new ndarray( opts.dtype, xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * var correction = scalar2ndarray( 1.0, opts ); + * + * var v = ns.sstdevch( [ x, correction ] ); + * // returns ~2.0817 + */ + sstdevch: typeof sstdevch; + + /** + * Computes the standard deviation of a one-dimensional single-precision floating-point ndarray using a two-pass algorithm. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying a degrees of freedom adjustment + * @returns standard deviation + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var opts = { + * 'dtype': 'float32' + * }; + * + * var xbuf = new Float32Array( [ 1.0, -2.0, 2.0 ] ); + * var x = new ndarray( opts.dtype, xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * var correction = scalar2ndarray( 1.0, opts ); + * + * var v = ns.sstdevpn( [ x, correction ] ); + * // returns ~2.0817 + */ + sstdevpn: typeof sstdevpn; + + /** + * Computes the standard deviation of a one-dimensional single-precision floating-point ndarray using Welford's algorithm. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying a degrees of freedom adjustment + * @returns standard deviation + * + * @example + * var ndarray = require( '@stdlib/ndarray/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var opts = { + * 'dtype': 'float32' + * }; + * + * var xbuf = new Float32Array( [ 1.0, -2.0, 2.0 ] ); + * var x = new ndarray( opts.dtype, xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * var correction = scalar2ndarray( 1.0, opts ); + * + * var v = ns.sstdevwd( [ x, correction ] ); + * // returns ~2.0817 + */ + sstdevwd: typeof sstdevwd; + + /** + * Computes the standard deviation of a one-dimensional ndarray. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying a degrees of freedom adjustment + * @returns standard deviation + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var opts = { + * 'dtype': 'float64' + * }; + * + * var xbuf = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * var x = new ndarray( opts.dtype, xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * var correction = scalar2ndarray( 1.0, opts ); + * + * var v = ns.stdev( [ x, correction ] ); + * // returns ~2.0817 + */ + stdev: typeof stdev; + + /** + * Computes the standard deviation of a one-dimensional ndarray using a one-pass trial mean algorithm. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying a degrees of freedom adjustment + * @returns standard deviation + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var opts = { + * 'dtype': 'float64' + * }; + * + * var xbuf = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * var x = new ndarray( opts.dtype, xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * var correction = scalar2ndarray( 1.0, opts ); + * + * var v = ns.stdevch( [ x, correction ] ); + * // returns ~2.0817 + */ + stdevch: typeof stdevch; + + /** + * Computes the standard deviation of a one-dimensional ndarray using a two-pass algorithm. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying a degrees of freedom adjustment + * @returns standard deviation + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var opts = { + * 'dtype': 'float64' + * }; + * + * var xbuf = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * var x = new ndarray( opts.dtype, xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * var correction = scalar2ndarray( 1.0, opts ); + * + * var v = ns.stdevpn( [ x, correction ] ); + * // returns ~2.0817 + */ + stdevpn: typeof stdevpn; + + /** + * Computes the standard deviation of a one-dimensional ndarray using a one-pass textbook algorithm. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying a degrees of freedom adjustment + * @returns standard deviation + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var opts = { + * 'dtype': 'float64' + * }; + * + * var xbuf = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * var x = new ndarray( opts.dtype, xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * var correction = scalar2ndarray( 1.0, opts ); + * + * var v = ns.stdevtk( [ x, correction ] ); + * // returns ~2.0817 + */ + stdevtk: typeof stdevtk; + + /** + * Computes the standard deviation of a one-dimensional ndarray using Welford's algorithm. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying a degrees of freedom adjustment + * @returns standard deviation + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var opts = { + * 'dtype': 'float64' + * }; + * + * var xbuf = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * var x = new ndarray( opts.dtype, xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * var correction = scalar2ndarray( 1.0, opts ); + * + * var v = ns.stdevwd( [ x, correction ] ); + * // returns ~2.0817 + */ + stdevwd: typeof stdevwd; + + /** + * Computes the standard deviation of a one-dimensional ndarray using a one-pass algorithm proposed by Youngs and Cramer. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying a degrees of freedom adjustment + * @returns standard deviation + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var opts = { + * 'dtype': 'float64' + * }; + * + * var xbuf = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * var x = new ndarray( opts.dtype, xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * var correction = scalar2ndarray( 1.0, opts ); + * + * var v = ns.stdevyc( [ x, correction ] ); + * // returns ~2.0817 + */ + stdevyc: typeof stdevyc; + /** * Computes a one-sample Z-test for a one-dimensional single-precision floating-point ndarray. * @@ -2132,6 +3354,78 @@ interface Namespace { */ sztest2: typeof sztest2; + /** + * Computes the variance of a one-dimensional ndarray. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying a degrees of freedom adjustment + * @returns variance + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var opts = { + * 'dtype': 'float64' + * }; + * + * var xbuf = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * var x = new ndarray( opts.dtype, xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * var correction = scalar2ndarray( 1.0, opts ); + * + * var v = ns.variance( [ x, correction ] ); + * // returns ~4.333 + */ + variance: typeof variance; + + /** + * Computes the variance of a one-dimensional ndarray using a one-pass trial mean algorithm. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying a degrees of freedom adjustment + * @returns variance + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var opts = { + * 'dtype': 'float64' + * }; + * + * var xbuf = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * var x = new ndarray( opts.dtype, xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * var correction = scalar2ndarray( 1.0, opts ); + * + * var v = ns.variancech( [ x, correction ] ); + * // returns ~4.333 + */ + variancech: typeof variancech; + + /** + * Computes the variance of a one-dimensional ndarray using Welford's algorithm. + * + * @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying a degrees of freedom adjustment + * @returns variance + * + * @example + * var ndarray = require( '@stdlib/ndarray/base/ctor' ); + * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var opts = { + * 'dtype': 'float64' + * }; + * + * var xbuf = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * var x = new ndarray( opts.dtype, xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); + * var correction = scalar2ndarray( 1.0, opts ); + * + * var v = ns.variancewd( [ x, correction ] ); + * // returns ~4.3333 + */ + variancewd: typeof variancewd; + /** * Computes a one-sample Z-test for a one-dimensional ndarray. *