diff --git a/lib/node_modules/@stdlib/stats/strided/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/strided/docs/types/index.d.ts index 874bcb3f4a8e..a7b9296f8c52 100644 --- a/lib/node_modules/@stdlib/stats/strided/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/stats/strided/docs/types/index.d.ts @@ -27,6 +27,7 @@ import dcumax = require( '@stdlib/stats/strided/dcumax' ); import dcumaxabs = require( '@stdlib/stats/strided/dcumaxabs' ); import dcumin = require( '@stdlib/stats/strided/dcumin' ); import dcuminabs = require( '@stdlib/stats/strided/dcuminabs' ); +import distances = require( '@stdlib/stats/strided/distances' ); import dmax = require( '@stdlib/stats/strided/dmax' ); import dmaxabs = require( '@stdlib/stats/strided/dmaxabs' ); import dmaxabssorted = require( '@stdlib/stats/strided/dmaxabssorted' ); @@ -50,6 +51,7 @@ import dmin = require( '@stdlib/stats/strided/dmin' ); import dminabs = require( '@stdlib/stats/strided/dminabs' ); import dminsorted = require( '@stdlib/stats/strided/dminsorted' ); import dmskmax = require( '@stdlib/stats/strided/dmskmax' ); +import dmskmidrange = require( '@stdlib/stats/strided/dmskmidrange' ); import dmskmin = require( '@stdlib/stats/strided/dmskmin' ); import dmskrange = require( '@stdlib/stats/strided/dmskrange' ); import dnanmax = require( '@stdlib/stats/strided/dnanmax' ); @@ -59,9 +61,11 @@ import dnanmeanors = require( '@stdlib/stats/strided/dnanmeanors' ); import dnanmeanpn = require( '@stdlib/stats/strided/dnanmeanpn' ); import dnanmeanpw = require( '@stdlib/stats/strided/dnanmeanpw' ); import dnanmeanwd = require( '@stdlib/stats/strided/dnanmeanwd' ); +import dnanmidrange = require( '@stdlib/stats/strided/dnanmidrange' ); import dnanmin = require( '@stdlib/stats/strided/dnanmin' ); import dnanminabs = require( '@stdlib/stats/strided/dnanminabs' ); import dnanmskmax = require( '@stdlib/stats/strided/dnanmskmax' ); +import dnanmskmidrange = require( '@stdlib/stats/strided/dnanmskmidrange' ); import dnanmskmin = require( '@stdlib/stats/strided/dnanmskmin' ); import dnanmskrange = require( '@stdlib/stats/strided/dnanmskrange' ); import dnanrange = require( '@stdlib/stats/strided/dnanrange' ); @@ -78,6 +82,7 @@ import dnanvariancetk = require( '@stdlib/stats/strided/dnanvariancetk' ); import dnanvariancewd = require( '@stdlib/stats/strided/dnanvariancewd' ); import dnanvarianceyc = require( '@stdlib/stats/strided/dnanvarianceyc' ); import drange = require( '@stdlib/stats/strided/drange' ); +import drangeabs = require( '@stdlib/stats/strided/drangeabs' ); import dsem = require( '@stdlib/stats/strided/dsem' ); import dsemch = require( '@stdlib/stats/strided/dsemch' ); import dsempn = require( '@stdlib/stats/strided/dsempn' ); @@ -124,11 +129,15 @@ import meanpn = require( '@stdlib/stats/strided/meanpn' ); import meanpw = require( '@stdlib/stats/strided/meanpw' ); import meanwd = require( '@stdlib/stats/strided/meanwd' ); import mediansorted = require( '@stdlib/stats/strided/mediansorted' ); +import midrange = require( '@stdlib/stats/strided/midrange' ); +import midrangeBy = require( '@stdlib/stats/strided/midrange-by' ); import min = require( '@stdlib/stats/strided/min' ); import minBy = require( '@stdlib/stats/strided/min-by' ); import minabs = require( '@stdlib/stats/strided/minabs' ); import minsorted = require( '@stdlib/stats/strided/minsorted' ); import mskmax = require( '@stdlib/stats/strided/mskmax' ); +import mskmaxabs = require( '@stdlib/stats/strided/mskmaxabs' ); +import mskmidrange = require( '@stdlib/stats/strided/mskmidrange' ); import mskmin = require( '@stdlib/stats/strided/mskmin' ); import mskrange = require( '@stdlib/stats/strided/mskrange' ); import nanmax = require( '@stdlib/stats/strided/nanmax' ); @@ -138,10 +147,13 @@ import nanmean = require( '@stdlib/stats/strided/nanmean' ); import nanmeanors = require( '@stdlib/stats/strided/nanmeanors' ); import nanmeanpn = require( '@stdlib/stats/strided/nanmeanpn' ); import nanmeanwd = require( '@stdlib/stats/strided/nanmeanwd' ); +import nanmidrange = require( '@stdlib/stats/strided/nanmidrange' ); +import nanmidrangeBy = require( '@stdlib/stats/strided/nanmidrange-by' ); import nanmin = require( '@stdlib/stats/strided/nanmin' ); import nanminBy = require( '@stdlib/stats/strided/nanmin-by' ); import nanminabs = require( '@stdlib/stats/strided/nanminabs' ); import nanmskmax = require( '@stdlib/stats/strided/nanmskmax' ); +import nanmskmidrange = require( '@stdlib/stats/strided/nanmskmidrange' ); import nanmskmin = require( '@stdlib/stats/strided/nanmskmin' ); import nanmskrange = require( '@stdlib/stats/strided/nanmskrange' ); import nanrange = require( '@stdlib/stats/strided/nanrange' ); @@ -160,6 +172,7 @@ import nanvariancewd = require( '@stdlib/stats/strided/nanvariancewd' ); import nanvarianceyc = require( '@stdlib/stats/strided/nanvarianceyc' ); import range = require( '@stdlib/stats/strided/range' ); import rangeBy = require( '@stdlib/stats/strided/range-by' ); +import rangeabs = require( '@stdlib/stats/strided/rangeabs' ); import scovarmtk = require( '@stdlib/stats/strided/scovarmtk' ); import scumax = require( '@stdlib/stats/strided/scumax' ); import scumaxabs = require( '@stdlib/stats/strided/scumaxabs' ); @@ -187,6 +200,8 @@ import smin = require( '@stdlib/stats/strided/smin' ); import sminabs = require( '@stdlib/stats/strided/sminabs' ); import sminsorted = require( '@stdlib/stats/strided/sminsorted' ); import smskmax = require( '@stdlib/stats/strided/smskmax' ); +import smskmaxabs = require( '@stdlib/stats/strided/smskmaxabs' ); +import smskmidrange = require( '@stdlib/stats/strided/smskmidrange' ); import smskmin = require( '@stdlib/stats/strided/smskmin' ); import smskrange = require( '@stdlib/stats/strided/smskrange' ); import snanmax = require( '@stdlib/stats/strided/snanmax' ); @@ -195,13 +210,16 @@ import snanmean = require( '@stdlib/stats/strided/snanmean' ); import snanmeanors = require( '@stdlib/stats/strided/snanmeanors' ); import snanmeanpn = require( '@stdlib/stats/strided/snanmeanpn' ); import snanmeanwd = require( '@stdlib/stats/strided/snanmeanwd' ); +import snanmidrange = require( '@stdlib/stats/strided/snanmidrange' ); import snanmin = require( '@stdlib/stats/strided/snanmin' ); import snanminabs = require( '@stdlib/stats/strided/snanminabs' ); import snanmskmax = require( '@stdlib/stats/strided/snanmskmax' ); +import snanmskmidrange = require( '@stdlib/stats/strided/snanmskmidrange' ); import snanmskmin = require( '@stdlib/stats/strided/snanmskmin' ); import snanmskrange = require( '@stdlib/stats/strided/snanmskrange' ); import snanrange = require( '@stdlib/stats/strided/snanrange' ); import srange = require( '@stdlib/stats/strided/srange' ); +import srangeabs = require( '@stdlib/stats/strided/srangeabs' ); import sstdev = require( '@stdlib/stats/strided/sstdev' ); import sstdevch = require( '@stdlib/stats/strided/sstdevch' ); import sstdevpn = require( '@stdlib/stats/strided/sstdevpn' ); @@ -494,6 +512,11 @@ interface Namespace { */ dcuminabs: typeof dcuminabs; + /** + * Distance metrics for strided arrays. + */ + distances: typeof distances; + /** * Computes the maximum value of a double-precision floating-point strided array. * @@ -1118,6 +1141,38 @@ interface Namespace { */ dmskmax: typeof dmskmax; + /** + * Computes the mid-range of a double-precision floating-point strided array according to a mask. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - `x` stride length + * @param mask - mask array + * @param strideMask - `mask` stride length + * @returns mid-range + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * var x = new Float64Array( [ 1.0, -2.0, 4.0, 2.0 ] ); + * var mask = new Uint8Array( [ 0, 0, 1, 0 ] ); + * + * var v = ns.dmskmidrange( x.length, x, 1, mask, 1 ); + * // returns 0.0 + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * var x = new Float64Array( [ 1.0, -2.0, 4.0, 2.0 ] ); + * var mask = new Uint8Array( [ 0, 0, 1, 0 ] ); + * + * var v = ns.dmskmidrange.ndarray( x.length, x, 1, 0, mask, 1, 0 ); + * // returns 0.0 + */ + dmskmidrange: typeof dmskmidrange; + /** * Computes the minimum value of a double-precision floating-point strided array according to a mask. * @@ -1364,6 +1419,32 @@ interface Namespace { */ dnanmeanwd: typeof dnanmeanwd; + /** + * Computes the mid-range of a double-precision floating-point strided array, ignoring `NaN` values. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length + * @returns mid-range + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * + * var v = ns.dnanmidrange( x.length, x, 1 ); + * // returns 0.0 + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * + * var v = ns.dnanmidrange.ndarray( x.length, x, 1, 0 ); + * // returns 0.0 + */ + dnanmidrange: typeof dnanmidrange; + /** * Computes the minimum value of a double-precision floating-point strided array, ignoring `NaN` values. * @@ -1448,6 +1529,38 @@ interface Namespace { */ dnanmskmax: typeof dnanmskmax; + /** + * Computes the mid-range of a double-precision floating-point strided array according to a mask, ignoring `NaN` values. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - `x` stride length + * @param mask - mask array + * @param strideMask - `mask` stride length + * @returns mid-range + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * var x = new Float64Array( [ 1.0, -2.0, 4.0, 2.0, NaN ] ); + * var mask = new Uint8Array( [ 0, 0, 1, 0, 0 ] ); + * + * var v = ns.dnanmskmidrange( x.length, x, 1, mask, 1 ); + * // returns 0.0 + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * var x = new Float64Array( [ 1.0, -2.0, 4.0, 2.0, NaN ] ); + * var mask = new Uint8Array( [ 0, 0, 1, 0, 0 ] ); + * + * var v = ns.dnanmskmidrange.ndarray( x.length, x, 1, 0, mask, 1, 0 ); + * // returns 0.0 + */ + dnanmskmidrange: typeof dnanmskmidrange; + /** * Computes the minimum value of a double-precision floating-point strided array according to a mask, ignoring `NaN` values. * @@ -1888,6 +2001,32 @@ interface Namespace { */ drange: typeof drange; + /** + * Computes the range of absolute values of a double-precision floating-point strided array. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length + * @returns range + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * + * var v = ns.drangeabs( x.length, x, 1 ); + * // returns 1.0 + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * + * var v = ns.drangeabs.ndarray( x.length, x, 1, 0 ); + * // returns 1.0 + */ + drangeabs: typeof drangeabs; + /** * Computes the standard error of the mean for a double-precision floating-point strided array. * @@ -3119,6 +3258,71 @@ interface Namespace { */ mediansorted: typeof mediansorted; + /** + * Computes the mid-range of a strided array. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length + * @returns mid-range + * + * @example + * var x = [ 1.0, -2.0, 2.0 ]; + * + * var v = ns.midrange( x.length, x, 1 ); + * // returns 0.0 + * + * @example + * var x = [ 1.0, -2.0, 2.0 ]; + * + * var v = ns.midrange.ndarray( x.length, x, 1, 0 ); + * // returns 0.0 + */ + midrange: typeof midrange; + + /** + * Computes the mid-range of a strided array via a callback function. + * + * ## Notes + * + * - The callback function is provided four arguments: + * + * - `value`: array element + * - `aidx`: array index + * - `sidx`: strided index (offset + aidx*stride) + * - `array`: input array + * + * - The callback function should return a numeric value. If the callback function does not return any value (or equivalently, explicitly returns `undefined`), the value is ignored. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length + * @param clbk - callback + * @param thisArg - execution context + * @returns mid-range + * + * @example + * var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ]; + * + * function accessor( v ) { + * return v * 2.0; + * } + * + * var v = ns.midrangeBy( x.length, x, 1, accessor ); + * // returns -1.0 + * + * @example + * var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ]; + * + * function accessor( v ) { + * return v * 2.0; + * } + * + * var v = ns.midrangeBy.ndarray( x.length, x, 1, 0, accessor ); + * // returns -1.0 + */ + midrangeBy: typeof midrangeBy; + /** * Computes the minimum value of a strided array. * @@ -3254,6 +3458,58 @@ interface Namespace { */ mskmax: typeof mskmax; + /** + * Computes the maximum absolute value of a strided array according to a mask. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length for `x` + * @param mask - mask array + * @param strideMask - stride length for `mask` + * @returns maximum absolute value + * + * @example + * var x = [ 1.0, -2.0, 4.0, 2.0 ]; + * var mask = [ 0, 0, 1, 0 ]; + * + * var v = ns.mskmaxabs( x.length, x, 1, mask, 1 ); + * // returns 2.0 + * + * @example + * var x = [ 1.0, -2.0, 4.0, 2.0 ]; + * var mask = [ 0, 0, 1, 0 ]; + * + * var v = ns.mskmaxabs.ndarray( x.length, x, 1, 0, mask, 1, 0 ); + * // returns 2.0 + */ + mskmaxabs: typeof mskmaxabs; + + /** + * Computes the mid-range of a strided array according to a mask. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length for `x` + * @param mask - mask array + * @param strideMask - stride length for `mask` + * @returns mid-range + * + * @example + * var x = [ 1.0, -2.0, 4.0, 2.0 ]; + * var mask = [ 0, 0, 1, 0 ]; + * + * var v = ns.mskmidrange( x.length, x, 1, mask, 1 ); + * // returns 0.0 + * + * @example + * var x = [ 1.0, -2.0, 4.0, 2.0 ]; + * var mask = [ 0, 0, 1, 0 ]; + * + * var v = ns.mskmidrange.ndarray( x.length, x, 1, 0, mask, 1, 0 ); + * // returns 0.0 + */ + mskmidrange: typeof mskmidrange; + /** * Computes the minimum value of a strided array according to a mask. * @@ -3485,6 +3741,71 @@ interface Namespace { */ nanmeanwd: typeof nanmeanwd; + /** + * Computes the mid-range of a strided array, ignoring `NaN` values. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length + * @returns mid-range + * + * @example + * var x = [ 1.0, -2.0, 2.0, NaN ]; + * + * var v = ns.nanmidrange( x.length, x, 1 ); + * // returns 0.0 + * + * @example + * var x = [ 1.0, -2.0, 2.0, NaN ]; + * + * var v = ns.nanmidrange.ndarray( x.length, x, 1, 0 ); + * // returns 0.0 + */ + nanmidrange: typeof nanmidrange; + + /** + * Computes the mid-range of a strided array via a callback function, ignoring `NaN` values. + * + * ## Notes + * + * - The callback function is provided four arguments: + * + * - `value`: array element + * - `aidx`: array index + * - `sidx`: strided index (offset + aidx*stride) + * - `array`: input array + * + * - The callback function should return a numeric value. If the callback function does not return any value (or equivalently, explicitly returns `undefined`), the value is ignored. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length + * @param clbk - callback + * @param thisArg - execution context + * @returns mid-range + * + * @example + * var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ]; + * + * function accessor( v ) { + * return v * 2.0; + * } + * + * var v = ns.nanmidrangeBy( x.length, x, 1, accessor ); + * // returns -1.0 + * + * @example + * var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ]; + * + * function accessor( v ) { + * return v * 2.0; + * } + * + * var v = ns.nanmidrangeBy.ndarray( x.length, x, 1, 0, accessor ); + * // returns -1.0 + */ + nanmidrangeBy: typeof nanmidrangeBy; + /** * Computes the minimum value of a strided array, ignoring `NaN` values. * @@ -3602,6 +3923,32 @@ interface Namespace { */ nanmskmax: typeof nanmskmax; + /** + * Computes the mid-range of a strided array according to a mask, ignoring `NaN` values. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length for `x` + * @param mask - mask array + * @param strideMask - stride length for `mask` + * @returns mid-range + * + * @example + * var x = [ 1.0, -2.0, NaN, 4.0, 2.0 ]; + * var mask = [ 0, 0, 0, 1, 0 ]; + * + * var v = ns.nanmskmidrange( x.length, x, 1, mask, 1 ); + * // returns 0.0 + * + * @example + * var x = [ 1.0, -2.0, NaN, 4.0, 2.0 ]; + * var mask = [ 0, 0, 0, 1, 0 ]; + * + * var v = ns.nanmskmidrange.ndarray( x.length, x, 1, 0, mask, 1, 0 ); + * // returns 0.0 + */ + nanmskmidrange: typeof nanmskmidrange; + /** * Computes the minimum value of a strided array according to a mask, ignoring `NaN` values. * @@ -4064,6 +4411,28 @@ interface Namespace { */ rangeBy: typeof rangeBy; + /** + * Computes the range of absolute values of a strided array. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length + * @returns range of absolute values + * + * @example + * var x = [ 1.0, -2.0, 2.0 ]; + * + * var v = ns.rangeabs( x.length, x, 1 ); + * // returns 1.0 + * + * @example + * var x = [ 1.0, -2.0, 2.0 ]; + * + * var v = ns.rangeabs.ndarray( x.length, x, 1, 0 ); + * // returns 1.0 + */ + rangeabs: typeof rangeabs; + /** * Computes the covariance of two single-precision floating-point strided arrays provided known means and using a one-pass textbook algorithm. * @@ -4795,6 +5164,70 @@ interface Namespace { */ smskmax: typeof smskmax; + /** + * Computes the maximum absolute value of a single-precision floating-point strided array according to a mask. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - `x` stride length + * @param mask - mask array + * @param strideMask - `mask` stride length + * @returns maximum absolute value + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * var x = new Float32Array( [ 1.0, -2.0, 4.0, 2.0 ] ); + * var mask = new Uint8Array( [ 0, 0, 1, 0 ] ); + * + * var v = ns.smskmaxabs( x.length, x, 1, mask, 1 ); + * // returns 2.0 + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * var x = new Float32Array( [ 1.0, -2.0, 4.0, 2.0 ] ); + * var mask = new Uint8Array( [ 0, 0, 1, 0 ] ); + * + * var v = ns.smskmaxabs.ndarray( x.length, x, 1, 0, mask, 1, 0 ); + * // returns 2.0 + */ + smskmaxabs: typeof smskmaxabs; + + /** + * Computes the mid-range of a single-precision floating-point strided array according to a mask. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - `x` stride length + * @param mask - mask array + * @param strideMask - `mask` stride length + * @returns mid-range + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * var x = new Float32Array( [ 1.0, -2.0, 4.0, 2.0 ] ); + * var mask = new Uint8Array( [ 0, 0, 1, 0 ] ); + * + * var v = ns.smskmidrange( x.length, x, 1, mask, 1 ); + * // returns 0.0 + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * var x = new Float32Array( [ 1.0, -2.0, 4.0, 2.0 ] ); + * var mask = new Uint8Array( [ 0, 0, 1, 0 ] ); + * + * var v = ns.smskmidrange.ndarray( x.length, x, 1, 0, mask, 1, 0 ); + * // returns 0.0 + */ + smskmidrange: typeof smskmidrange; + /** * Computes the minimum value of a single-precision floating-point strided array according to a mask. * @@ -5015,6 +5448,32 @@ interface Namespace { */ snanmeanwd: typeof snanmeanwd; + /** + * Computes the mid-range of a single-precision floating-point strided array, ignoring `NaN` values. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length + * @returns mid-range + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * + * var v = ns.snanmidrange( x.length, x, 1 ); + * // returns 0.0 + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * + * var v = ns.snanmidrange.ndarray( x.length, x, 1, 0 ); + * // returns 0.0 + */ + snanmidrange: typeof snanmidrange; + /** * Computes the minimum value of a single-precision floating-point strided array, ignoring `NaN` values. * @@ -5099,6 +5558,38 @@ interface Namespace { */ snanmskmax: typeof snanmskmax; + /** + * Computes the mid-range of a single-precision floating-point strided array according to a mask, ignoring `NaN` values. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - `x` stride length + * @param mask - mask array + * @param strideMask - `mask` stride length + * @returns mid-range + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * var x = new Float32Array( [ 1.0, -2.0, 4.0, 2.0, NaN ] ); + * var mask = new Uint8Array( [ 0, 0, 1, 0, 0 ] ); + * + * var v = ns.snanmskmidrange( x.length, x, 1, mask, 1 ); + * // returns 0.0 + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * var Uint8Array = require( '@stdlib/array/uint8' ); + * + * var x = new Float32Array( [ 1.0, -2.0, 4.0, 2.0, NaN ] ); + * var mask = new Uint8Array( [ 0, 0, 1, 0, 0 ] ); + * + * var v = ns.snanmskmidrange.ndarray( x.length, x, 1, 0, mask, 1, 0 ); + * // returns 0.0 + */ + snanmskmidrange: typeof snanmskmidrange; + /** * Computes the minimum value of a single-precision floating-point strided array according to a mask, ignoring `NaN` values. * @@ -5215,6 +5706,32 @@ interface Namespace { */ srange: typeof srange; + /** + * Computes the range of absolute values of a single-precision floating-point strided array. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length + * @returns range + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, -2.0, 2.0 ] ); + * + * var v = ns.srangeabs( x.length, x, 1 ); + * // returns 1.0 + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, -2.0, 2.0 ] ); + * + * var v = ns.srangeabs.ndarray( x.length, x, 1, 0 ); + * // returns 1.0 + */ + srangeabs: typeof srangeabs; + /** * Computes the standard deviation of a single-precision floating-point strided array. *