diff --git a/lib/node_modules/@stdlib/stats/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/docs/types/index.d.ts
index 4943630dc863..d3d7bb6f1c9e 100644
--- a/lib/node_modules/@stdlib/stats/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/stats/docs/types/index.d.ts
@@ -40,16 +40,39 @@ import lowess = require( '@stdlib/stats/lowess' );
 import max = require( '@stdlib/stats/max' );
 import maxBy = require( '@stdlib/stats/max-by' );
 import maxabs = require( '@stdlib/stats/maxabs' );
+import maxsorted = require( '@stdlib/stats/maxsorted' );
 import mean = require( '@stdlib/stats/mean' );
+import meankbn = require( '@stdlib/stats/meankbn' );
+import meankbn2 = require( '@stdlib/stats/meankbn2' );
+import meanors = require( '@stdlib/stats/meanors' );
+import meanpn = require( '@stdlib/stats/meanpn' );
+import meanpw = require( '@stdlib/stats/meanpw' );
+import meanwd = require( '@stdlib/stats/meanwd' );
+import mediansorted = require( '@stdlib/stats/mediansorted' );
+import midrange = require( '@stdlib/stats/midrange' );
+import midrangeBy = require( '@stdlib/stats/midrange-by' );
 import min = require( '@stdlib/stats/min' );
 import minBy = require( '@stdlib/stats/min-by' );
 import minabs = require( '@stdlib/stats/minabs' );
+import minsorted = require( '@stdlib/stats/minsorted' );
 import nanmax = require( '@stdlib/stats/nanmax' );
+import nanmaxBy = require( '@stdlib/stats/nanmax-by' );
+import nanmaxabs = require( '@stdlib/stats/nanmaxabs' );
 import nanmean = require( '@stdlib/stats/nanmean' );
+import nanmeanors = require( '@stdlib/stats/nanmeanors' );
+import nanmeanpn = require( '@stdlib/stats/nanmeanpn' );
+import nanmeanwd = require( '@stdlib/stats/nanmeanwd' );
+import nanmidrangeBy = require( '@stdlib/stats/nanmidrange-by' );
 import nanmin = require( '@stdlib/stats/nanmin' );
+import nanminBy = require( '@stdlib/stats/nanmin-by' );
+import nanminabs = require( '@stdlib/stats/nanminabs' );
+import nanrange = require( '@stdlib/stats/nanrange' );
+import nanrangeBy = require( '@stdlib/stats/nanrange-by' );
 import padjust = require( '@stdlib/stats/padjust' );
 import pcorrtest = require( '@stdlib/stats/pcorrtest' );
 import range = require( '@stdlib/stats/range' );
+import rangeBy = require( '@stdlib/stats/range-by' );
+import rangeabs = require( '@stdlib/stats/rangeabs' );
 import ranks = require( '@stdlib/stats/ranks' );
 import strided = require( '@stdlib/stats/strided' );
 import ttest = require( '@stdlib/stats/ttest' );
@@ -443,6 +466,36 @@ interface Namespace {
 	*/
 	maxabs: typeof maxabs;
 
+	/**
+	* Computes the maximum value along one or more sorted ndarray dimensions.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ 1.0, 2.0, 3.0 ] );
+	*
+	* var y = ns.maxsorted( x );
+	* // returns <ndarray>[ 3.0 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ 1.0, 2.0, 3.0 ] );
+	* var y = zeros( [] );
+	*
+	* var out = ns.maxsorted.assign( x, y );
+	* // returns <ndarray>[ 3.0 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	maxsorted: typeof maxsorted;
+
 	/**
 	* Computes the arithmetic mean along one or more ndarray dimensions.
 	*
@@ -453,28 +506,568 @@ interface Namespace {
 	* @example
 	* var array = require( '@stdlib/ndarray/array' );
 	*
-	* var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+	* var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+	*
+	* var y = ns.mean( x );
+	* // returns <ndarray>[ 1.25 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+	* var y = zeros( [] );
+	*
+	* var out = ns.mean.assign( x, y );
+	* // returns <ndarray>[ 1.25 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	mean: typeof mean;
+
+	/**
+	* Computes the arithmetic mean along one or more ndarray dimensions using an improved Kahan–Babuška algorithm.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+	*
+	* var y = ns.meankbn( x );
+	* // returns <ndarray>[ 1.25 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+	* var y = zeros( [] );
+	*
+	* var out = ns.meankbn.assign( x, y );
+	* // returns <ndarray>[ 1.25 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	meankbn: typeof meankbn;
+
+	/**
+	* Computes the arithmetic mean along one or more ndarray dimensions using a second-order iterative Kahan-Babuska algorithm.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+	*
+	* var y = ns.meankbn2( x );
+	* // returns <ndarray>[ 1.25 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+	* var y = zeros( [] );
+	*
+	* var out = ns.meankbn2.assign( x, y );
+	* // returns <ndarray>[ 1.25 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	meankbn2: typeof meankbn2;
+
+	/**
+	* Computes the arithmetic mean along one or more ndarray dimensions using ordinary recursive summation.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+	*
+	* var y = ns.meanors( x );
+	* // returns <ndarray>[ 1.25 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+	* var y = zeros( [] );
+	*
+	* var out = ns.meanors.assign( x, y );
+	* // returns <ndarray>[ 1.25 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	meanors: typeof meanors;
+
+	/**
+	* Computes the arithmetic mean along one or more ndarray dimensions using a two-pass error correction algorithm.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+	*
+	* var y = ns.meanpn( x );
+	* // returns <ndarray>[ 1.25 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+	* var y = zeros( [] );
+	*
+	* var out = ns.meanpn.assign( x, y );
+	* // returns <ndarray>[ 1.25 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	meanpn: typeof meanpn;
+
+	/**
+	* Computes the arithmetic mean along one or more ndarray dimensions using pairwise summation.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+	*
+	* var y = ns.meanpw( x );
+	* // returns <ndarray>[ 1.25 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+	* var y = zeros( [] );
+	*
+	* var out = ns.meanpw.assign( x, y );
+	* // returns <ndarray>[ 1.25 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	meanpw: typeof meanpw;
+
+	/**
+	* Computes the arithmetic mean along one or more ndarray dimensions using Welford's algorithm.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+	*
+	* var y = ns.meanwd( x );
+	* // returns <ndarray>[ 1.25 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+	* var y = zeros( [] );
+	*
+	* var out = ns.meanwd.assign( x, y );
+	* // returns <ndarray>[ 1.25 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	meanwd: typeof meanwd;
+
+	/**
+	* Computes the median value along one or more sorted ndarray dimensions.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ 1.0, 2.0, 3.0 ] );
+	*
+	* var y = ns.mediansorted( x );
+	* // returns <ndarray>[ 2.0 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ 1.0, 2.0, 3.0, 4.0 ] );
+	* var y = zeros( [] );
+	*
+	* var out = ns.mediansorted.assign( x, y );
+	* // returns <ndarray>[ 2.5 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	mediansorted: typeof mediansorted;
+
+	/**
+	* Computes the mid-range along one or more ndarray dimensions.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ -1.0, 2.0, -3.0 ] );
+	*
+	* var y = ns.midrange( x );
+	* // returns <ndarray>[ -0.5 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ -1.0, 2.0, -3.0 ] );
+	* var y = zeros( [] );
+	*
+	* var out = ns.midrange.assign( x, y );
+	* // returns <ndarray>[ -0.5 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	midrange: typeof midrange;
+
+	/**
+	* Computes the mid-range along one or more ndarray dimensions according to a callback function.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @param clbk - callback function
+	* @param thisArg - callback execution context
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ -1.0, 2.0, -3.0 ] );
+	*
+	* function clbk( value ) {
+	*     return value * 2.0;
+	* }
+	*
+	* var y = ns.midrangeBy( x, clbk );
+	* // returns <ndarray>[ -1.0 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ -1.0, 2.0, -3.0 ] );
+	* var y = zeros( [] );
+	*
+	* function clbk( value ) {
+	*     return value * 2.0;
+	* }
+	*
+	* var out = ns.midrangeBy.assign( x, y, clbk );
+	* // returns <ndarray>[ -1.0 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	midrangeBy: typeof midrangeBy;
+
+	/**
+	* Computes the minimum value along one or more ndarray dimensions.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ -1.0, 2.0, -3.0 ] );
+	*
+	* var y = ns.min( x );
+	* // returns <ndarray>[ -3.0 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ -1.0, 2.0, -3.0 ] );
+	* var y = zeros( [] );
+	*
+	* var out = ns.min.assign( x, y );
+	* // returns <ndarray>[ -3.0 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	min: typeof min;
+
+	/**
+	* Computes the minimum value along one or more ndarray dimensions according to a callback function.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @param clbk - callback function
+	* @param thisArg - callback execution context
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ -1.0, 2.0, -3.0 ] );
+	*
+	* function clbk( value ) {
+	*     return value * 2.0;
+	* }
+	*
+	* var y = ns.minBy( x, clbk );
+	* // returns <ndarray>[ -6.0 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ -1.0, 2.0, -3.0 ] );
+	* var y = zeros( [] );
+	*
+	* function clbk( value ) {
+	*     return value * 2.0;
+	* }
+	*
+	* var out = ns.minBy.assign( x, y, clbk );
+	* // returns <ndarray>[ -6.0 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	minBy: typeof minBy;
+
+	/**
+	* Computes the minimum absolute value along one or more ndarray dimensions.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ -1.0, 2.0, -3.0 ] );
+	*
+	* var y = ns.minabs( x );
+	* // returns <ndarray>[ 1.0 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ -1.0, 2.0, -3.0 ] );
+	* var y = zeros( [] );
+	*
+	* var out = ns.minabs.assign( x, y );
+	* // returns <ndarray>[ 1.0 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	minabs: typeof minabs;
+
+	/**
+	* Computes the minimum value along one or more sorted ndarray dimensions.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ 1.0, 2.0, 3.0 ] );
+	*
+	* var y = ns.minsorted( x );
+	* // returns <ndarray>[ 1.0 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ 1.0, 2.0, 3.0 ] );
+	* var y = zeros( [] );
+	*
+	* var out = ns.minsorted.assign( x, y );
+	* // returns <ndarray>[ 1.0 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	minsorted: typeof minsorted;
+
+	/**
+	* Computes the maximum value along one or more ndarray dimensions, ignoring `NaN` values.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ -1.0, 2.0, NaN ] );
+	*
+	* var y = ns.nanmax( x );
+	* // returns <ndarray>[ 2.0 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ -1.0, 2.0, NaN ] );
+	* var y = zeros( [] );
+	*
+	* var out = ns.nanmax.assign( x, y );
+	* // returns <ndarray>[ 2.0 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	nanmax: typeof nanmax;
+
+	/**
+	* Computes the maximum value along one or more ndarray dimensions according to a callback function, ignoring NaN values.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @param clbk - callback function
+	* @param thisArg - callback execution context
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ -1.0, 2.0, NaN ] );
+	*
+	* function clbk( value ) {
+	*     return value * 2.0;
+	* }
+	*
+	* var y = ns.nanmaxBy( x, clbk );
+	* // returns <ndarray>[ 4.0 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ -1.0, 2.0, NaN ] );
+	* var y = zeros( [] );
+	*
+	* function clbk( value ) {
+	*     return value * 2.0;
+	* }
+	*
+	* var out = ns.nanmaxBy.assign( x, y, clbk );
+	* // returns <ndarray>[ 4.0 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	nanmaxBy: typeof nanmaxBy;
+
+	/**
+	* Computes the maximum absolute value along one or more ndarray dimensions, ignoring `NaN` values.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ -1.0, 2.0, NaN ] );
+	*
+	* var y = ns.nanmaxabs( x );
+	* // returns <ndarray>[ 2.0 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ -1.0, 2.0, NaN ] );
+	* var y = zeros( [] );
+	*
+	* var out = ns.nanmaxabs.assign( x, y );
+	* // returns <ndarray>[ 2.0 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	nanmaxabs: typeof nanmaxabs;
+
+	/**
+	* Computes the arithmetic mean along one or more ndarray dimensions, ignoring `NaN` values.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ 1.0, NaN, -2.0, 4.0 ] );
 	*
-	* var y = ns.mean( x );
-	* // returns <ndarray>[ 1.25 ]
+	* var y = ns.nanmean( x );
+	* // returns <ndarray>[ 1.0 ]
 	*
 	* @example
 	* var array = require( '@stdlib/ndarray/array' );
 	* var zeros = require( '@stdlib/ndarray/zeros' );
 	*
-	* var x = array( [ 1.0, 2.0, -2.0, 4.0 ] );
+	* var x = array( [ 1.0, NaN, -2.0, 4.0 ] );
 	* var y = zeros( [] );
 	*
-	* var out = ns.mean.assign( x, y );
-	* // returns <ndarray>[ 1.25 ]
+	* var out = ns.nanmean.assign( x, y );
+	* // returns <ndarray>[ 1.0 ]
 	*
 	* var bool = ( out === y );
 	* // returns true
 	*/
-	mean: typeof mean;
+	nanmean: typeof nanmean;
 
 	/**
-	* Computes the minimum value along one or more ndarray dimensions.
+	* Computes the arithmetic mean along one or more ndarray dimensions, ignoring `NaN` values using ordinary recursive summation.
 	*
 	* @param x - input ndarray
 	* @param options - function options
@@ -483,28 +1076,88 @@ interface Namespace {
 	* @example
 	* var array = require( '@stdlib/ndarray/array' );
 	*
-	* var x = array( [ -1.0, 2.0, -3.0 ] );
+	* var x = array( [ 1.0, NaN, -2.0, 4.0 ] );
 	*
-	* var y = ns.min( x );
-	* // returns <ndarray>[ -3.0 ]
+	* var y = ns.nanmeanors( x );
+	* // returns <ndarray>[ 1.0 ]
 	*
 	* @example
 	* var array = require( '@stdlib/ndarray/array' );
 	* var zeros = require( '@stdlib/ndarray/zeros' );
 	*
-	* var x = array( [ -1.0, 2.0, -3.0 ] );
+	* var x = array( [ 1.0, NaN, -2.0, 4.0 ] );
 	* var y = zeros( [] );
 	*
-	* var out = ns.min.assign( x, y );
-	* // returns <ndarray>[ -3.0 ]
+	* var out = ns.nanmeanors.assign( x, y );
+	* // returns <ndarray>[ 1.0 ]
 	*
 	* var bool = ( out === y );
 	* // returns true
 	*/
-	min: typeof min;
+	nanmeanors: typeof nanmeanors;
 
 	/**
-	* Computes the minimum value along one or more ndarray dimensions according to a callback function.
+	* Computes the arithmetic mean along one or more ndarray dimensions, ignoring `NaN` values and using a two-pass error correction algorithm.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ 1.0, NaN, -2.0, 4.0 ] );
+	*
+	* var y = ns.nanmeanpn( x );
+	* // returns <ndarray>[ 1.0 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ 1.0, NaN, -2.0, 4.0 ] );
+	* var y = zeros( [] );
+	*
+	* var out = ns.nanmeanpn.assign( x, y );
+	* // returns <ndarray>[ 1.0 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	nanmeanpn: typeof nanmeanpn;
+
+	/**
+	* Computes the arithmetic mean along one or more ndarray dimensions, ignoring `NaN` values and using Welford's algorithm.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ 1.0, NaN, -2.0, 4.0 ] );
+	*
+	* var y = ns.nanmeanwd( x );
+	* // returns <ndarray>[ 1.0 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ 1.0, NaN, -2.0, 4.0 ] );
+	* var y = zeros( [] );
+	*
+	* var out = ns.nanmeanwd.assign( x, y );
+	* // returns <ndarray>[ 1.0 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	nanmeanwd: typeof nanmeanwd;
+
+	/**
+	* Computes the mid-range along one or more ndarray dimensions according to a callback function, ignoring NaN values.
 	*
 	* @param x - input ndarray
 	* @param options - function options
@@ -515,36 +1168,36 @@ interface Namespace {
 	* @example
 	* var array = require( '@stdlib/ndarray/array' );
 	*
-	* var x = array( [ -1.0, 2.0, -3.0 ] );
+	* var x = array( [ -1.0, 2.0, NaN ] );
 	*
 	* function clbk( value ) {
 	*     return value * 2.0;
 	* }
 	*
-	* var y = ns.minBy( x, clbk );
-	* // returns <ndarray>[ -6.0 ]
+	* var y = ns.nanmidrangeBy( x, clbk );
+	* // returns <ndarray>[ 1.0 ]
 	*
 	* @example
 	* var array = require( '@stdlib/ndarray/array' );
 	* var zeros = require( '@stdlib/ndarray/zeros' );
 	*
-	* var x = array( [ -1.0, 2.0, -3.0 ] );
+	* var x = array( [ -1.0, 2.0, NaN ] );
 	* var y = zeros( [] );
 	*
 	* function clbk( value ) {
 	*     return value * 2.0;
 	* }
 	*
-	* var out = ns.minBy.assign( x, y, clbk );
-	* // returns <ndarray>[ -6.0 ]
+	* var out = ns.nanmidrangeBy.assign( x, y, clbk );
+	* // returns <ndarray>[ 1.0 ]
 	*
 	* var bool = ( out === y );
 	* // returns true
 	*/
-	minBy: typeof minBy;
+	nanmidrangeBy: typeof nanmidrangeBy;
 
 	/**
-	* Computes the minimum absolute value along one or more ndarray dimensions.
+	* Computes the minimum value along one or more ndarray dimensions, ignoring `NaN` values.
 	*
 	* @param x - input ndarray
 	* @param options - function options
@@ -553,31 +1206,33 @@ interface Namespace {
 	* @example
 	* var array = require( '@stdlib/ndarray/array' );
 	*
-	* var x = array( [ -1.0, 2.0, -3.0 ] );
+	* var x = array( [ -1.0, 2.0, NaN ] );
 	*
-	* var y = ns.minabs( x );
-	* // returns <ndarray>[ 1.0 ]
+	* var y = ns.nanmin( x );
+	* // returns <ndarray>[ -1.0 ]
 	*
 	* @example
 	* var array = require( '@stdlib/ndarray/array' );
 	* var zeros = require( '@stdlib/ndarray/zeros' );
 	*
-	* var x = array( [ -1.0, 2.0, -3.0 ] );
+	* var x = array( [ -1.0, 2.0, NaN ] );
 	* var y = zeros( [] );
 	*
-	* var out = ns.minabs.assign( x, y );
-	* // returns <ndarray>[ 1.0 ]
+	* var out = ns.nanmin.assign( x, y );
+	* // returns <ndarray>[ -1.0 ]
 	*
 	* var bool = ( out === y );
 	* // returns true
 	*/
-	minabs: typeof minabs;
+	nanmin: typeof nanmin;
 
 	/**
-	* Computes the maximum value along one or more ndarray dimensions, ignoring `NaN` values.
+	* Computes the minimum value along one or more ndarray dimensions according to a callback function, ignoring NaN values.
 	*
 	* @param x - input ndarray
 	* @param options - function options
+	* @param clbk - callback function
+	* @param thisArg - callback execution context
 	* @returns output ndarray
 	*
 	* @example
@@ -585,8 +1240,12 @@ interface Namespace {
 	*
 	* var x = array( [ -1.0, 2.0, NaN ] );
 	*
-	* var y = ns.nanmax( x );
-	* // returns <ndarray>[ 2.0 ]
+	* function clbk( value ) {
+	*     return value * 2.0;
+	* }
+	*
+	* var y = ns.nanminBy( x, clbk );
+	* // returns <ndarray>[ -2.0 ]
 	*
 	* @example
 	* var array = require( '@stdlib/ndarray/array' );
@@ -595,16 +1254,20 @@ interface Namespace {
 	* var x = array( [ -1.0, 2.0, NaN ] );
 	* var y = zeros( [] );
 	*
-	* var out = ns.nanmax.assign( x, y );
-	* // returns <ndarray>[ 2.0 ]
+	* function clbk( value ) {
+	*     return value * 2.0;
+	* }
+	*
+	* var out = ns.nanminBy.assign( x, y, clbk );
+	* // returns <ndarray>[ -2.0 ]
 	*
 	* var bool = ( out === y );
 	* // returns true
 	*/
-	nanmax: typeof nanmax;
+	nanminBy: typeof nanminBy;
 
 	/**
-	* Computes the arithmetic mean along one or more ndarray dimensions, ignoring `NaN` values.
+	* Computes the minimum absolute value along one or more ndarray dimensions, ignoring `NaN` values.
 	*
 	* @param x - input ndarray
 	* @param options - function options
@@ -613,28 +1276,28 @@ interface Namespace {
 	* @example
 	* var array = require( '@stdlib/ndarray/array' );
 	*
-	* var x = array( [ 1.0, NaN, -2.0, 4.0 ] );
+	* var x = array( [ -1.0, 2.0, NaN ] );
 	*
-	* var y = ns.nanmean( x );
+	* var y = ns.nanminabs( x );
 	* // returns <ndarray>[ 1.0 ]
 	*
 	* @example
 	* var array = require( '@stdlib/ndarray/array' );
 	* var zeros = require( '@stdlib/ndarray/zeros' );
 	*
-	* var x = array( [ 1.0, NaN, -2.0, 4.0 ] );
+	* var x = array( [ -1.0, 2.0, NaN ] );
 	* var y = zeros( [] );
 	*
-	* var out = ns.nanmean.assign( x, y );
+	* var out = ns.nanminabs.assign( x, y );
 	* // returns <ndarray>[ 1.0 ]
 	*
 	* var bool = ( out === y );
 	* // returns true
 	*/
-	nanmean: typeof nanmean;
+	nanminabs: typeof nanminabs;
 
 	/**
-	* Computes the minimum value along one or more ndarray dimensions, ignoring `NaN` values.
+	* Computes the range along one or more ndarray dimensions, ignoring `NaN` values.
 	*
 	* @param x - input ndarray
 	* @param options - function options
@@ -645,8 +1308,8 @@ interface Namespace {
 	*
 	* var x = array( [ -1.0, 2.0, NaN ] );
 	*
-	* var y = ns.nanmin( x );
-	* // returns <ndarray>[ -1.0 ]
+	* var y = ns.nanrange( x );
+	* // returns <ndarray>[ 3.0 ]
 	*
 	* @example
 	* var array = require( '@stdlib/ndarray/array' );
@@ -655,13 +1318,53 @@ interface Namespace {
 	* var x = array( [ -1.0, 2.0, NaN ] );
 	* var y = zeros( [] );
 	*
-	* var out = ns.nanmin.assign( x, y );
-	* // returns <ndarray>[ -1.0 ]
+	* var out = ns.nanrange.assign( x, y );
+	* // returns <ndarray>[ 3.0 ]
 	*
 	* var bool = ( out === y );
 	* // returns true
 	*/
-	nanmin: typeof nanmin;
+	nanrange: typeof nanrange;
+
+	/**
+	* Computes the range along one or more ndarray dimensions according to a callback function, ignoring NaN values.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @param clbk - callback function
+	* @param thisArg - callback execution context
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ -1.0, 2.0, NaN ] );
+	*
+	* function clbk( value ) {
+	*     return value * 2.0;
+	* }
+	*
+	* var y = ns.nanrangeBy( x, clbk );
+	* // returns <ndarray>[ 6.0 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ -1.0, 2.0, NaN ] );
+	* var y = zeros( [] );
+	*
+	* function clbk( value ) {
+	*     return value * 2.0;
+	* }
+	*
+	* var out = ns.nanrangeBy.assign( x, y, clbk );
+	* // returns <ndarray>[ 6.0 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	nanrangeBy: typeof nanrangeBy;
 
 	/**
 	* Adjusts supplied p-values for multiple comparisons via a specified method.
@@ -767,6 +1470,76 @@ interface Namespace {
 	*/
 	range: typeof range;
 
+	/**
+	* Computes the range along one or more ndarray dimensions according to a callback function.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @param clbk - callback function
+	* @param thisArg - callback execution context
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ -1.0, 2.0, -3.0 ] );
+	*
+	* function clbk( value ) {
+	*     return value * 2.0;
+	* }
+	*
+	* var y = ns.rangeBy( x, clbk );
+	* // returns <ndarray>[ 10.0 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ -1.0, 2.0, -3.0 ] )
+	* var y = zeros( [] );
+	*
+	* function clbk( value ) {
+	*     return value * 2.0;
+	* }
+	*
+	* var out = ns.rangeBy.assign( x, y, clbk );
+	* // returns <ndarray>[ 10.0 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	rangeBy: typeof rangeBy;
+
+	/**
+	* Computes the range of absolute values along one or more ndarray dimensions.
+	*
+	* @param x - input ndarray
+	* @param options - function options
+	* @returns output ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	*
+	* var x = array( [ -1.0, 2.0, -3.0 ] );
+	*
+	* var y = ns.rangeabs( x );
+	* // returns <ndarray>[ 2.0 ]
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray/array' );
+	* var zeros = require( '@stdlib/ndarray/zeros' );
+	*
+	* var x = array( [ -1.0, 2.0, -3.0 ] );
+	* var y = zeros( [] );
+	*
+	* var out = ns.rangeabs.assign( x, y );
+	* // returns <ndarray>[ 2.0 ]
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*/
+	rangeabs: typeof rangeabs;
+
 	/**
 	* Computes the sample ranks for the values of an array-like object.
 	*