@stdlib/ndarray-base 0.3.0 → 0.4.0

package/docs/types/index.d.ts

@@ -20,14 +20,23 @@
 
 /* eslint-disable max-lines */
 
+import any = require( '@stdlib/ndarray-base-any' );
+import anyBy = require( '@stdlib/ndarray-base-any-by' );
 import assert = require( '@stdlib/ndarray-base-assert' );
 import assign = require( '@stdlib/ndarray-base-assign' );
+import binary = require( '@stdlib/ndarray-base-binary' );
+import binaryInputCastingDataType = require( '@stdlib/ndarray-base-binary-input-casting-dtype' );
 import binaryLoopOrder = require( '@stdlib/ndarray-base-binary-loop-interchange-order' );
+import binaryOutputDataType = require( '@stdlib/ndarray-base-binary-output-dtype' );
+import binaryReduceStrided1dDispatch = require( '@stdlib/ndarray-base-binary-reduce-strided1d-dispatch' );
+import binaryReduceStrided1dDispatchFactory = require( '@stdlib/ndarray-base-binary-reduce-strided1d-dispatch-factory' );
 import binaryBlockSize = require( '@stdlib/ndarray-base-binary-tiling-block-size' );
 import bind2vind = require( '@stdlib/ndarray-base-bind2vind' );
 import broadcastArray = require( '@stdlib/ndarray-base-broadcast-array' );
+import broadcastArrayExceptDimensions = require( '@stdlib/ndarray-base-broadcast-array-except-dimensions' );
 import broadcastArrays = require( '@stdlib/ndarray-base-broadcast-arrays' );
 import broadcastScalar = require( '@stdlib/ndarray-base-broadcast-scalar' );
+import broadcastScalarLike = require( '@stdlib/ndarray-base-broadcast-scalar-like' );
 import broadcastShapes = require( '@stdlib/ndarray-base-broadcast-shapes' );
 import buffer = require( '@stdlib/ndarray-base-buffer' );
 import bufferCtors = require( '@stdlib/ndarray-base-buffer-ctors' );
@@ -36,58 +45,97 @@ import bufferDataTypeEnum = require( '@stdlib/ndarray-base-buffer-dtype-enum' );
 import bytesPerElement = require( '@stdlib/ndarray-base-bytes-per-element' );
 import char2dtype = require( '@stdlib/ndarray-base-char2dtype' );
 import clampIndex = require( '@stdlib/ndarray-base-clamp-index' );
+import complementShape = require( '@stdlib/ndarray-base-complement-shape' );
+import copy = require( '@stdlib/ndarray-base-copy' );
+import countFalsy = require( '@stdlib/ndarray-base-count-falsy' );
+import countIf = require( '@stdlib/ndarray-base-count-if' );
+import countTruthy = require( '@stdlib/ndarray-base-count-truthy' );
 import ndarray = require( '@stdlib/ndarray-base-ctor' );
 import data = require( '@stdlib/ndarray-base-data-buffer' );
 import dtype = require( '@stdlib/ndarray-base-dtype' );
+import dtypeAlignment = require( '@stdlib/ndarray-base-dtype-alignment' );
 import dtypeChar = require( '@stdlib/ndarray-base-dtype-char' );
+import dtypeChars = require( '@stdlib/ndarray-base-dtype-chars' );
 import dtypeDesc = require( '@stdlib/ndarray-base-dtype-desc' );
 import dtypeEnum2Str = require( '@stdlib/ndarray-base-dtype-enum2str' );
+import dtypeEnums = require( '@stdlib/ndarray-base-dtype-enums' );
+import dtypeObjects = require( '@stdlib/ndarray-base-dtype-objects' );
 import dtypeResolveEnum = require( '@stdlib/ndarray-base-dtype-resolve-enum' );
 import dtypeResolveStr = require( '@stdlib/ndarray-base-dtype-resolve-str' );
 import dtypeStr2Enum = require( '@stdlib/ndarray-base-dtype-str2enum' );
+import dtypeStrings = require( '@stdlib/ndarray-base-dtype-strings' );
 import dtype2c = require( '@stdlib/ndarray-base-dtype2c' );
+import dtypes2enums = require( '@stdlib/ndarray-base-dtypes2enums' );
 import dtypes2signatures = require( '@stdlib/ndarray-base-dtypes2signatures' );
+import dtypes2strings = require( '@stdlib/ndarray-base-dtypes2strings' );
 import empty = require( '@stdlib/ndarray-base-empty' );
 import emptyLike = require( '@stdlib/ndarray-base-empty-like' );
+import every = require( '@stdlib/ndarray-base-every' );
+import everyBy = require( '@stdlib/ndarray-base-every-by' );
 import expandDimensions = require( '@stdlib/ndarray-base-expand-dimensions' );
+import fill = require( '@stdlib/ndarray-base-fill' );
+import fillBy = require( '@stdlib/ndarray-base-fill-by' );
+import find = require( '@stdlib/ndarray-base-find' );
 import flag = require( '@stdlib/ndarray-base-flag' );
 import flags = require( '@stdlib/ndarray-base-flags' );
+import flattenShape = require( '@stdlib/ndarray-base-flatten-shape' );
+import flattenShapeFrom = require( '@stdlib/ndarray-base-flatten-shape-from' );
 import fliplr = require( '@stdlib/ndarray-base-fliplr' );
 import flipud = require( '@stdlib/ndarray-base-flipud' );
 import forEach = require( '@stdlib/ndarray-base-for-each' );
+import array2ndarray = require( '@stdlib/ndarray-base-from-array' );
 import scalar2ndarray = require( '@stdlib/ndarray-base-from-scalar' );
+import scalar2ndarrayLike = require( '@stdlib/ndarray-base-from-scalar-like' );
+import includes = require( '@stdlib/ndarray-base-includes' );
 import ind = require( '@stdlib/ndarray-base-ind' );
 import ind2sub = require( '@stdlib/ndarray-base-ind2sub' );
 import iterationOrder = require( '@stdlib/ndarray-base-iteration-order' );
+import loopOrder = require( '@stdlib/ndarray-base-loop-interchange-order' );
+import map = require( '@stdlib/ndarray-base-map' );
 import maxViewBufferIndex = require( '@stdlib/ndarray-base-max-view-buffer-index' );
 import maybeBroadcastArray = require( '@stdlib/ndarray-base-maybe-broadcast-array' );
 import maybeBroadcastArrays = require( '@stdlib/ndarray-base-maybe-broadcast-arrays' );
 import metaDataProps = require( '@stdlib/ndarray-base-meta-data-props' );
+import minSignedIntegerDataType = require( '@stdlib/ndarray-base-min-signed-integer-dtype' );
+import minUnsignedIntegerDataType = require( '@stdlib/ndarray-base-min-unsigned-integer-dtype' );
 import minViewBufferIndex = require( '@stdlib/ndarray-base-min-view-buffer-index' );
 import minmaxViewBufferIndex = require( '@stdlib/ndarray-base-minmax-view-buffer-index' );
+import ndarraylike2ndarray = require( '@stdlib/ndarray-base-ndarraylike2ndarray' );
 import ndarraylike2object = require( '@stdlib/ndarray-base-ndarraylike2object' );
+import ndarraylike2scalar = require( '@stdlib/ndarray-base-ndarraylike2scalar' );
 import ndims = require( '@stdlib/ndarray-base-ndims' );
 import nextCartesianIndex = require( '@stdlib/ndarray-base-next-cartesian-index' );
 import nonsingletonDimensions = require( '@stdlib/ndarray-base-nonsingleton-dimensions' );
 import normalizeIndex = require( '@stdlib/ndarray-base-normalize-index' );
+import normalizeIndices = require( '@stdlib/ndarray-base-normalize-indices' );
 import nullary = require( '@stdlib/ndarray-base-nullary' );
 import nullaryLoopOrder = require( '@stdlib/ndarray-base-nullary-loop-interchange-order' );
+import nullaryStrided1dDispatch = require( '@stdlib/ndarray-base-nullary-strided1d-dispatch' );
+import nullaryStrided1dDispatchFactory = require( '@stdlib/ndarray-base-nullary-strided1d-dispatch-factory' );
 import nullaryBlockSize = require( '@stdlib/ndarray-base-nullary-tiling-block-size' );
 import numel = require( '@stdlib/ndarray-base-numel' );
 import numelDimension = require( '@stdlib/ndarray-base-numel-dimension' );
 import offset = require( '@stdlib/ndarray-base-offset' );
 import order = require( '@stdlib/ndarray-base-order' );
+import outputDataType = require( '@stdlib/ndarray-base-output-dtype' );
 import outputPolicyEnum2Str = require( '@stdlib/ndarray-base-output-policy-enum2str' );
 import outputPolicyResolveEnum = require( '@stdlib/ndarray-base-output-policy-resolve-enum' );
 import outputPolicyResolveStr = require( '@stdlib/ndarray-base-output-policy-resolve-str' );
 import outputPolicyStr2Enum = require( '@stdlib/ndarray-base-output-policy-str2enum' );
+import pop = require( '@stdlib/ndarray-base-pop' );
 import prependSingletonDimensions = require( '@stdlib/ndarray-base-prepend-singleton-dimensions' );
+import promoteDataTypes = require( '@stdlib/ndarray-base-promote-dtypes' );
+import quaternaryLoopOrder = require( '@stdlib/ndarray-base-quaternary-loop-interchange-order' );
+import quaternaryBlockSize = require( '@stdlib/ndarray-base-quaternary-tiling-block-size' );
+import quinaryLoopOrder = require( '@stdlib/ndarray-base-quinary-loop-interchange-order' );
+import quinaryBlockSize = require( '@stdlib/ndarray-base-quinary-tiling-block-size' );
 import removeSingletonDimensions = require( '@stdlib/ndarray-base-remove-singleton-dimensions' );
 import reverse = require( '@stdlib/ndarray-base-reverse' );
 import reverseDimension = require( '@stdlib/ndarray-base-reverse-dimension' );
 import serializeMetaData = require( '@stdlib/ndarray-base-serialize-meta-data' );
 import shape = require( '@stdlib/ndarray-base-shape' );
 import shape2strides = require( '@stdlib/ndarray-base-shape2strides' );
+import shift = require( '@stdlib/ndarray-base-shift' );
 import singletonDimensions = require( '@stdlib/ndarray-base-singleton-dimensions' );
 import slice = require( '@stdlib/ndarray-base-slice' );
 import sliceAssign = require( '@stdlib/ndarray-base-slice-assign' );
@@ -96,27 +144,120 @@ import sliceDimensionFrom = require( '@stdlib/ndarray-base-slice-dimension-from'
 import sliceDimensionTo = require( '@stdlib/ndarray-base-slice-dimension-to' );
 import sliceFrom = require( '@stdlib/ndarray-base-slice-from' );
 import sliceTo = require( '@stdlib/ndarray-base-slice-to' );
+import some = require( '@stdlib/ndarray-base-some' );
+import someBy = require( '@stdlib/ndarray-base-some-by' );
+import spreadDimensions = require( '@stdlib/ndarray-base-spread-dimensions' );
 import stride = require( '@stdlib/ndarray-base-stride' );
 import strides = require( '@stdlib/ndarray-base-strides' );
 import strides2offset = require( '@stdlib/ndarray-base-strides2offset' );
 import strides2order = require( '@stdlib/ndarray-base-strides2order' );
 import sub2ind = require( '@stdlib/ndarray-base-sub2ind' );
+import ternary = require( '@stdlib/ndarray-base-ternary' );
+import ternaryLoopOrder = require( '@stdlib/ndarray-base-ternary-loop-interchange-order' );
+import ternaryOutputDataType = require( '@stdlib/ndarray-base-ternary-output-dtype' );
+import ternaryBlockSize = require( '@stdlib/ndarray-base-ternary-tiling-block-size' );
+import blockSize = require( '@stdlib/ndarray-base-tiling-block-size' );
 import ndarray2array = require( '@stdlib/ndarray-base-to-array' );
+import toFlippedlr = require( '@stdlib/ndarray-base-to-flippedlr' );
+import toFlippedud = require( '@stdlib/ndarray-base-to-flippedud' );
+import toNormalizedIndices = require( '@stdlib/ndarray-base-to-normalized-indices' );
+import toReversed = require( '@stdlib/ndarray-base-to-reversed' );
+import toReversedDimension = require( '@stdlib/ndarray-base-to-reversed-dimension' );
+import toUniqueNormalizedIndices = require( '@stdlib/ndarray-base-to-unique-normalized-indices' );
 import transpose = require( '@stdlib/ndarray-base-transpose' );
 import unary = require( '@stdlib/ndarray-base-unary' );
+import unaryAccumulate = require( '@stdlib/ndarray-base-unary-accumulate' );
+import unaryAddonDispatch = require( '@stdlib/ndarray-base-unary-addon-dispatch' );
 import unaryBy = require( '@stdlib/ndarray-base-unary-by' );
+import unaryInputCastingDataType = require( '@stdlib/ndarray-base-unary-input-casting-dtype' );
 import unaryLoopOrder = require( '@stdlib/ndarray-base-unary-loop-interchange-order' );
 import unaryOutputDataType = require( '@stdlib/ndarray-base-unary-output-dtype' );
+import unaryReduceStrided1dDispatch = require( '@stdlib/ndarray-base-unary-reduce-strided1d-dispatch' );
+import unaryReduceStrided1dDispatchBy = require( '@stdlib/ndarray-base-unary-reduce-strided1d-dispatch-by' );
+import unaryReduceStrided1dDispatchByFactory = require( '@stdlib/ndarray-base-unary-reduce-strided1d-dispatch-by-factory' );
+import unaryReduceStrided1dDispatchFactory = require( '@stdlib/ndarray-base-unary-reduce-strided1d-dispatch-factory' );
+import unaryReduceSubarrayBy = require( '@stdlib/ndarray-base-unary-reduce-subarray-by' );
+import unaryStrided1dDispatch = require( '@stdlib/ndarray-base-unary-strided1d-dispatch' );
+import unaryStrided1dDispatchFactory = require( '@stdlib/ndarray-base-unary-strided1d-dispatch-factory' );
 import unaryBlockSize = require( '@stdlib/ndarray-base-unary-tiling-block-size' );
 import vind2bind = require( '@stdlib/ndarray-base-vind2bind' );
 import wrapIndex = require( '@stdlib/ndarray-base-wrap-index' );
 import zeros = require( '@stdlib/ndarray-base-zeros' );
 import zerosLike = require( '@stdlib/ndarray-base-zeros-like' );
+import zip2views1d = require( '@stdlib/ndarray-base-zip2views1d' );
 
 /**
 * Interface describing the `base` namespace.
 */
 interface Namespace {
+	/**
+	* Tests whether at least one element in an ndarray is truthy.
+	*
+	* @param arrays - array-like object containing an input ndarray
+	* @returns boolean indicating whether at least one element is truthy
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array-float64' );
+	* var ndarray = require( '@stdlib/ndarray-base-ctor' );
+	*
+	* // Create a data buffer:
+	* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+	*
+	* // Define the shape of the array:
+	* var shape = [ 3, 1, 2 ];
+	*
+	* // Define the array strides:
+	* var sx = [ 4, 4, 1 ];
+	*
+	* // Define the index offset:
+	* var ox = 1;
+	*
+	* // Create the input ndarray:
+	* var x = ndarray( 'float64', xbuf, shape, sx, ox, 'row-major' );
+	*
+	* // Test elements:
+	* var out = ns.any( [ x ] );
+	* // returns true
+	*/
+	any: typeof any;
+
+	/**
+	* Tests whether at least one element in an ndarray passes a test implemented by a predicate function.
+	*
+	* @param arrays - array-like object containing an input ndarray
+	* @param predicate - predicate function
+	* @param thisArg - predicate function execution context
+	* @returns boolean indicating whether at least one element passes a test
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array-float64' );
+	* var ndarray = require( '@stdlib/ndarray-base-ctor' );
+	*
+	* function predicate( value ) {
+	*    return value > 0.0;
+	* }
+	*
+	* // Create a data buffer:
+	* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+	*
+	* // Define the shape of the array:
+	* var shape = [ 3, 1, 2 ];
+	*
+	* // Define the array strides:
+	* var sx = [ 4, 4, 1 ];
+	*
+	* // Define the index offset:
+	* var ox = 1;
+	*
+	* // Create the input ndarray:
+	* var x = ndarray( 'float64', xbuf, shape, sx, ox, 'row-major' );
+	*
+	* // Test elements:
+	* var out = ns.anyBy( [ x ], predicate );
+	* // returns true
+	*/
+	anyBy: typeof anyBy;
+
 	/**
 	* Base ndarray assertion utilities.
 	*/
@@ -160,6 +301,69 @@ interface Namespace {
 	*/
 	assign: typeof assign;
 
+	/**
+	* Applies a binary callback to elements in input ndarrays and assigns results to elements in an output ndarray.
+	*
+	* @param arrays - array-like object containing two input ndarrays and one output ndarray
+	* @param fcn - binary callback
+	* @throws arrays must have the same number of dimensions
+	* @throws arrays must have the same shape
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array-float64' );
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
+	* var getData = require( '@stdlib/ndarray-data-buffer' );
+	*
+	* function add( a, b ) {
+	*     return a + b;
+	* }
+	*
+	* // Create data buffers:
+	* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+	* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+	* var zbuf = new Float64Array( 6 );
+	*
+	* // Define the shape of the input and output arrays:
+	* var shape = [ 3, 1, 2 ];
+	*
+	* // Define the array strides:
+	* var sx = [ 2, 2, 1 ];
+	* var sy = [ 2, 2, 1 ];
+	* var sz = [ 2, 2, 1 ];
+	*
+	* // Define the index offsets:
+	* var ox = 0;
+	* var oy = 0;
+	* var oz = 0;
+	*
+	* // Create the input and output ndarrays:
+	* var x = new ndarray( 'float64', xbuf, shape, sx, ox, 'row-major' );
+	* var y = new ndarray( 'float64', ybuf, shape, sy, oy, 'row-major' );
+	* var z = new ndarray( 'float64', zbuf, shape, sz, oz, 'row-major' );
+	*
+	* // Apply the ns.binary function:
+	* ns.binary( [ x, y, z ], add );
+	*
+	* console.log( getData( z ) );
+	* // => <Float64Array>[ 2.0, 4.0, 6.0, 8.0, 10.0, 12.0 ]
+	*/
+	binary: typeof binary;
+
+	/**
+	* Resolves the casting data type for an input ndarray provided to a binary function.
+	*
+	* @param idtype1 - input ndarray data type
+	* @param idtype2 - additional input ndarray data type
+	* @param odtype - output ndarray data type
+	* @param policy - input ndarray casting data type policy
+	* @returns input ndarray casting data type
+	*
+	* @example
+	* var dt = ns.binaryInputCastingDataType( 'float64', 'float64', 'float64', 'none' );
+	* // returns <string>
+	*/
+	binaryInputCastingDataType: typeof binaryInputCastingDataType;
+
 	/**
 	* Reorders ndarray dimensions and associated strides for loop interchange.
 	*
@@ -180,10 +384,10 @@ interface Namespace {
 	*
 	* -   The function assumes that the input and output ndarrays have the same shape. Hence, loop interchange order should only be determined **after** broadcasting.
 	*
-	* @param sh - array dimensions
-	* @param sx - first input array stride lengths
-	* @param sy - second input array stride lengths
-	* @param sz - output array stride lengths
+	* @param shape - array dimensions
+	* @param stridesX - first input array stride lengths
+	* @param stridesY - second input array stride lengths
+	* @param stridesZ - output array stride lengths
 	* @returns loop interchange data
 	*
 	* @example
@@ -193,7 +397,7 @@ interface Namespace {
 	* var sy = [ 24, 8, 1 ]; // row-major
 	* var sz = [ 1, -2, 6 ]; // column-major
 	*
-	* var o = loopOrder( sh, sx, sy, sz );
+	* var o = ns.binaryLoopOrder( sh, sx, sy, sz );
 	* // returns {...}
 	*
 	* var ssh = o.sh;
@@ -210,6 +414,94 @@ interface Namespace {
 	*/
 	binaryLoopOrder: typeof binaryLoopOrder;
 
+	/**
+	* Resolves the output ndarray data type for a binary function.
+	*
+	* @param xdtype - first input ndarray data type
+	* @param ydtype - second input ndarray data type
+	* @param policy - output ndarray data type policy
+	* @returns output ndarray data type
+	*
+	* @example
+	* var dt = ns.binaryOutputDataType( 'float64', 'float32', 'complex_floating_point' );
+	* // returns <DataType>
+	*/
+	binaryOutputDataType: typeof binaryOutputDataType;
+
+	/**
+	* Constructor for performing a reduction on two input ndarrays.
+	*
+	* @param table - dispatch table
+	* @param idtypes - list containing lists of supported input data types for each ndarray argument
+	* @param odtypes - list of supported output data types
+	* @param policies - dispatch policies
+	* @returns instance
+	*
+	* @example
+	* var base = require( '@stdlib/blas-base-ndarray-gdot' );
+	* var dtypes = require( '@stdlib/ndarray-dtypes' );
+	* var ndarray = require( '@stdlib/ndarray-base-ctor' );
+	*
+	* var idt = dtypes( 'real_and_generic' );
+	* var odt = idt;
+	* var policies = {
+	*     'output': 'promoted',
+	*     'casting': 'promoted'
+	* };
+	*
+	* var table = {
+	*     'default': base
+	* };
+	* var dot = new ns.binaryReduceStrided1dDispatch( table, [ idt, idt ], odt, policies );
+	*
+	* var xbuf = [ 4.0, 2.0, -3.0, 5.0, -1.0 ];
+	* var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+	*
+	* var ybuf = [ 2.0, 6.0, -1.0, -4.0, 8.0 ];
+	* var y = new ndarray( 'generic', ybuf, [ ybuf.length ], [ 1 ], 0, 'row-major' );
+	*
+	* var z = dot.apply( x, y );
+	* // returns <ndarray>[ -5.0 ]
+	*/
+	binaryReduceStrided1dDispatch: typeof binaryReduceStrided1dDispatch;
+
+	/**
+	* Creates a function for performing a reduction on two input ndarrays.
+	*
+	* @param table - dispatch table
+	* @param idtypes - list containing lists of supported input data types for each ndarray argument
+	* @param odtypes - list of supported output data types
+	* @param policies - dispatch policies
+	* @returns function for applying a function
+	*
+	* @example
+	* var base = require( '@stdlib/blas-base-ndarray-gdot' );
+	* var dtypes = require( '@stdlib/ndarray-dtypes' );
+	* var ndarray = require( '@stdlib/ndarray-base-ctor' );
+	*
+	* var idt = dtypes( 'real_and_generic' );
+	* var odt = idt;
+	* var policies = {
+	*     'output': 'promoted',
+	*     'casting': 'promoted'
+	* };
+	*
+	* var table = {
+	*     'default': base
+	* };
+	* var dot = ns.binaryReduceStrided1dDispatchFactory( table, [ idt, idt ], odt, policies );
+	*
+	* var xbuf = [ 4.0, 2.0, -3.0, 5.0, -1.0 ];
+	* var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+	*
+	* var ybuf = [ 2.0, 6.0, -1.0, -4.0, 8.0 ];
+	* var y = new ndarray( 'generic', ybuf, [ ybuf.length ], [ 1 ], 0, 'row-major' );
+	*
+	* var z = dot( x, y );
+	* // returns <ndarray>[ -5.0 ]
+	*/
+	binaryReduceStrided1dDispatchFactory: typeof binaryReduceStrided1dDispatchFactory;
+
 	/**
 	* Returns a loop block size for multi-dimensional array tiled loops.
 	*
@@ -299,6 +591,62 @@ interface Namespace {
 	*/
 	broadcastArray: typeof broadcastArray;
 
+	/**
+	* Broadcasts an input ndarray to a target shape while keeping a list of specified dimensions unchanged.
+	*
+	* ## Notes
+	*
+	* -   The function expects that each index in the list of dimensions is negative in order to ensure that indices correspond to the same relative position in the output ndarray shape. For example, given an input ndarray shape `[2,X1,X2]` and a desired shape `[6,7,2,Y1,Y2]`, a list of negative dimensions `[-2,-1]` correctly maps the unchanged dimensions `X` in the input ndarray to ignored dimensions `Y` in the provided target shape. Nonnegative indices, however, afford no such mapping. For example, the list of dimensions `[1,2]` corresponds to `[X1,X2]` in the input ndarray shape, but to `[7,2]` in the target shape, which is not desired. By expecting negative indices, we avoid confusion and ensure that users always refer to dimensions relative to the last broadcasted dimension.
+	* -   The function throws an error if a provided ndarray is incompatible with a provided shape.
+	* -   The returned array is a view on the input array data buffer. The view is typically **not** contiguous. As more than one element of a returned view may refer to the same memory location, writing to the view may affect multiple elements. If you need to write to the returned array, copy the array before performing operations which may mutate elements.
+	* -   The returned array is a "base" ndarray, and, thus, the returned array does not perform bounds checking or afford any of the guarantees of the non-base ndarray constructor. The primary intent of this function is to broadcast an ndarray-like object within internal implementations and to do so with minimal overhead.
+	* -   The function always returns a new ndarray instance even if the input ndarray shape and the desired shape are the same.
+	*
+	* @param arr - input array
+	* @param shape - desired shape
+	* @param dims - list of dimensions to exclude from broadcasting
+	* @throws input array cannot have more dimensions than the desired shape
+	* @throws broadcasted dimensions in the input array and desired shape must be broadcast compatible
+	* @throws dimension indices must not exceed desired shape bounds
+	* @throws must provide unique dimension indices
+	* @returns broadcasted array
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray-array' );
+	* var getShape = require( '@stdlib/ndarray-shape' );
+	*
+	* var x = array( [ [ 1, 2, 3 ] ] );
+	* // returns <ndarray>
+	*
+	* var shx = getShape( x );
+	* // returns [ 1, 3 ]
+	*
+	* var y = ns.broadcastArrayExceptDimensions( x, [ 2, 2, 3 ], [ -2 ] );
+	* // returns <ndarray>
+	*
+	* var shy = getShape( y );
+	* // returns [ 2, 1, 3 ]
+	*
+	* var v = y.get( 0, 0, 0 );
+	* // returns 1
+	*
+	* v = y.get( 0, 0, 1 );
+	* // returns 2
+	*
+	* v = y.get( 0, 0, 2 );
+	* // returns 3
+	*
+	* v = y.get( 1, 0, 0 );
+	* // returns 1
+	*
+	* v = y.get( 1, 0, 1 );
+	* // returns 2
+	*
+	* v = y.get( 1, 0, 2 );
+	* // returns 3
+	*/
+	broadcastArrayExceptDimensions: typeof broadcastArrayExceptDimensions;
+
 	/**
 	* Broadcasts ndarrays to a common shape.
 	*
@@ -330,7 +678,7 @@ interface Namespace {
 	* // returns [ 3, 2, 2 ]
 	*
 	* var out = ns.broadcastArrays( [ x1, y1 ] );
-	* // returns <ndarray>
+	* // returns [ <ndarray>, <ndarray> ]
 	*
 	* var x2 = out[ 0 ];
 	* // returns <ndarray>
@@ -386,13 +734,16 @@ interface Namespace {
 	* @returns ndarray
 	*
 	* @example
+	* var getShape = require( '@stdlib/ndarray-shape' );
+	* var getDType = require( '@stdlib/ndarray-dtype' );
+	*
 	* var x = ns.broadcastScalar( 1.0, 'generic', [ 2, 2 ], 'row-major' );
 	* // returns <ndarray>
 	*
-	* var sh = x.shape;
+	* var sh = getShape( x );
 	* // returns [ 2, 2 ]
 	*
-	* var dt = x.dtype;
+	* var dt = String( getDType( x ) );
 	* // returns 'generic'
 	*
 	* var v = x.get( 0, 1 );
@@ -400,6 +751,28 @@ interface Namespace {
 	*/
 	broadcastScalar: typeof broadcastScalar;
 
+	/**
+	* Broadcasts a scalar value to an ndarray having the same shape and data type as a provided input ndarray.
+	*
+	* @param x - input array
+	* @param value - scalar value
+	* @returns output ndarray
+	*
+	* @example
+	* var zeros = require( '@stdlib/ndarray-base-zeros' );
+	* var getDType = require( '@stdlib/ndarray-dtype' );
+	*
+	* var x = zeros( 'float64', [ 2, 2 ], 'row-major' );
+	* // returns <ndarray>[ [ 0.0, 0.0 ], [ 0.0, 0.0 ] ]
+	*
+	* var y = ns.broadcastScalarLike( x, 1.0 );
+	* // returns <ndarray>[ [ 1.0, 1.0 ], [ 1.0, 1.0 ] ]
+	*
+	* var dt = String( getDType( y ) );
+	* // returns 'float64'
+	*/
+	broadcastScalarLike: typeof broadcastScalarLike;
+
 	/**
 	* Broadcasts array shapes to a single shape.
 	*
@@ -610,7 +983,7 @@ interface Namespace {
 	bufferDataTypeEnum: typeof bufferDataTypeEnum;
 
 	/**
-	* Returns the number of bytes per element provided an underlying array data type.
+	* Returns the number of bytes per element for a provided underlying ndarray data type.
 	*
 	* @param dtype - data type
 	* @returns number of bytes per element
@@ -655,88 +1028,268 @@ interface Namespace {
 	clampIndex: typeof clampIndex;
 
 	/**
-	* ndarray constructor.
-	*
-	* ## Notes
+	* Returns the shape defined by the dimensions which are not included in a list of dimensions.
 	*
-	* -   To create a zero-dimensional array,
+	* @param shape - array shape
+	* @param dims - list of dimensions
+	* @returns output shape
 	*
-	*     ```javascript
-	*     var buffer = [ 1 ];
-	*     var shape = [];
-	*     var strides = [ 0 ];
-	*     var offset = 0;
+	* @example
+	* var sh = ns.complementShape( [ 3, 2 ], [ -1 ] );
+	* // returns [ 3 ]
 	*
-	*     var out = ndarray( 'generic', buffer, shape, strides, offset, 'row-major' );
-	*     ```
+	* sh = ns.complementShape( [ 3, 2, 1 ], [ -2 ] );
+	* // returns [ 3, 1 ]
 	*
-	* @param dtype - data type
-	* @param buffer - data buffer
-	* @param shape - array shape
-	* @param strides - array strides
-	* @param offset - index offset
-	* @param order - specifies whether an array is row-major (C-style) or column-major (Fortran-style)
-	* @returns ndarray instance
+	* sh = ns.complementShape( [ 3 ], [ 0 ] );
+	* // returns []
 	*
-	* @example
-	* var buffer = [ 1, 2, 3, 4, 5, 6 ];
-	* var shape = [ 3, 2 ];
-	* var strides = [ 2, 1 ];
-	* var offset = 0;
+	* sh = ns.complementShape( [ 3, 2 ], [ 0 ] );
+	* // returns [ 2 ]
 	*
-	* var out = ns.ndarray( 'generic', buffer, shape, strides, offset, 'row-major' );
+	* sh = ns.complementShape( [], [] );
+	* // returns []
 	*/
-	ndarray: typeof ndarray;
+	complementShape: typeof complementShape;
 
 	/**
-	* Returns the underlying data buffer of a provided ndarray.
+	* Copies an input ndarray to a new ndarray having the same shape and data type.
 	*
-	* @param x - input ndarray
-	* @returns underlying data buffer
+	* ## Notes
+	*
+	* -   The function performs a full copy in which an ndarray's underlying data is copied to a new underlying data buffer.
+	*
+	* @param x - input array
+	* @returns output array
 	*
 	* @example
-	* var zeros = require( '@stdlib/ndarray-zeros' );
+	* var getShape = require( '@stdlib/ndarray-shape' );
+	* var getDType = require( '@stdlib/ndarray-dtype' );
+	* var zeros = require( '@stdlib/ndarray-base-zeros' );
 	*
-	* var x = zeros( [ 3, 3, 3 ], {
-	*     'dtype': 'float64'
-	* });
+	* var x = zeros( 'float64', [ 2, 2 ], 'row-major' );
+	* // returns <ndarray>
 	*
-	* var out = ns.data( x );
-	* // returns <Float64Array>
+	* var sh = getShape( x );
+	* // returns [ 2, 2 ]
+	*
+	* var y = ns.copy( x );
+	* // returns <ndarray>
+	*
+	* sh = getShape( y );
+	* // returns [ 2, 2 ]
 	*/
-	data: typeof data;
+	copy: typeof copy;
 
 	/**
-	* Returns the data type of a provided ndarray.
+	* Counts the number of falsy elements in an ndarray.
 	*
-	* @param x - input ndarray
-	* @returns data type
+	* @param arrays - array-like object containing an input ndarray
+	* @returns number of falsy elements
 	*
 	* @example
-	* var zeros = require( '@stdlib/ndarray-zeros' );
+	* var Float64Array = require( '@stdlib/array-float64' );
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
 	*
-	* var x = zeros( [ 3, 3, 3 ], {
-	*     'ns.dtype': 'float64'
-	* });
+	* // Create a data buffer:
+	* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 0.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
 	*
-	* var dt = ns.dtype( x );
-	* // returns 'float64'
-	*/
-	dtype: typeof dtype;
-
-	/**
-	* Returns an object mapping data type strings to single letter character abbreviations.
+	* // Define the shape of the input array:
+	* var shape = [ 3, 1, 2 ];
 	*
-	* @returns object mapping data type strings to single letter character abbreviations
+	* // Define the array strides:
+	* var sx = [ 4, 4, 1 ];
 	*
-	* @example
-	* var obj = ns.dtypeChar();
-	* // returns {...}
+	* // Define the index offset:
+	* var ox = 1;
+	*
+	* // Create the input ndarray:
+	* var x = ndarray( 'float64', xbuf, shape, sx, ox, 'row-major' );
+	*
+	* // Perform operation:
+	* var out = ns.countFalsy( [ x ] );
+	* // returns 1
 	*/
-	dtypeChar: typeof dtypeChar;
+	countFalsy: typeof countFalsy;
 
 	/**
-	* Returns an object mapping data type strings to descriptions.
+	* Counts the number of elements in an ndarray which pass a test implemented by a predicate function.
+	*
+	* @param arrays - array-like object containing an input ndarray
+	* @param predicate - predicate function
+	* @param thisArg - predicate function execution context
+	* @returns result
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array-float64' );
+	* var ndarray = require( '@stdlib/ndarray-base-ctor' );
+	*
+	* function predicate( value ) {
+	*    return value > 0.0;
+	* }
+	*
+	* // Create a data buffer:
+	* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 0.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+	*
+	* // Define the shape of the array:
+	* var shape = [ 3, 1, 2 ];
+	*
+	* // Define the array strides:
+	* var sx = [ 4, 4, 1 ];
+	*
+	* // Define the index offset:
+	* var ox = 1;
+	*
+	* // Create the input ndarray:
+	* var x = ndarray( 'float64', xbuf, shape, sx, ox, 'row-major' );
+	*
+	* // Perform operation:
+	* var out = ns.countIf( [ x ], predicate );
+	* // returns 5
+	*/
+	countIf: typeof countIf;
+
+	/**
+	* Counts the number of truthy elements in an ndarray.
+	*
+	* @param arrays - array-like object containing an input ndarray
+	* @returns number of truthy elements
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array-float64' );
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
+	*
+	* // Create a data buffer:
+	* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+	*
+	* // Define the shape of the input array:
+	* var shape = [ 3, 1, 2 ];
+	*
+	* // Define the array strides:
+	* var sx = [ 4, 4, 1 ];
+	*
+	* // Define the index offset:
+	* var ox = 1;
+	*
+	* // Create the input ndarray:
+	* var x = ndarray( 'float64', xbuf, shape, sx, ox, 'row-major' );
+	*
+	* // Perform operation:
+	* var out = ns.countTruthy( [ x ] );
+	* // returns 6
+	*/
+	countTruthy: typeof countTruthy;
+
+	/**
+	* ndarray constructor.
+	*
+	* ## Notes
+	*
+	* -   To create a zero-dimensional array,
+	*
+	*     ```javascript
+	*     var buffer = [ 1 ];
+	*     var shape = [];
+	*     var strides = [ 0 ];
+	*     var offset = 0;
+	*
+	*     var out = ndarray( 'generic', buffer, shape, strides, offset, 'row-major' );
+	*     ```
+	*
+	* @param dtype - data type
+	* @param buffer - data buffer
+	* @param shape - array shape
+	* @param strides - array strides
+	* @param offset - index offset
+	* @param order - specifies whether an array is row-major (C-style) or column-major (Fortran-style)
+	* @returns ndarray instance
+	*
+	* @example
+	* var buffer = [ 1, 2, 3, 4, 5, 6 ];
+	* var shape = [ 3, 2 ];
+	* var strides = [ 2, 1 ];
+	* var offset = 0;
+	*
+	* var out = ns.ndarray( 'generic', buffer, shape, strides, offset, 'row-major' );
+	*/
+	ndarray: typeof ndarray;
+
+	/**
+	* Returns the underlying data buffer of a provided ndarray.
+	*
+	* @param x - input ndarray
+	* @returns underlying data buffer
+	*
+	* @example
+	* var zeros = require( '@stdlib/ndarray-zeros' );
+	*
+	* var x = zeros( [ 3, 3, 3 ], {
+	*     'dtype': 'float64'
+	* });
+	*
+	* var out = ns.data( x );
+	* // returns <Float64Array>
+	*/
+	data: typeof data;
+
+	/**
+	* Returns the data type of a provided ndarray.
+	*
+	* @param x - input ndarray
+	* @returns data type
+	*
+	* @example
+	* var zeros = require( '@stdlib/ndarray-zeros' );
+	*
+	* var x = zeros( [ 3, 3, 3 ], {
+	*     'ns.dtype': 'float64'
+	* });
+	*
+	* var dt = ns.dtype( x );
+	* // returns 'float64'
+	*/
+	dtype: typeof dtype;
+
+	/**
+	* Returns an object mapping data type strings to alignments.
+	*
+	* @returns object mapping data type strings to alignments
+	*
+	* @example
+	* var obj = ns.dtypeAlignment();
+	* // returns {...}
+	*/
+	dtypeAlignment: typeof dtypeAlignment;
+
+	/**
+	* Returns an object mapping data type strings to single letter character abbreviations.
+	*
+	* @returns object mapping data type strings to single letter character abbreviations
+	*
+	* @example
+	* var obj = ns.dtypeChar();
+	* // returns {...}
+	*/
+	dtypeChar: typeof dtypeChar;
+
+	/**
+	* Returns a list of ndarray data type single letter character abbreviations.
+	*
+	* @param kind - data type kind
+	* @returns list of ndarray data type single letter character abbreviations
+	*
+	* @example
+	* var list = ns.dtypeChars();
+	* // returns [...]
+	*
+	* @example
+	* var list = ns.dtypeChars( 'floating_point' );
+	* // returns [...]
+	*/
+	dtypeChars: typeof dtypeChars;
+
+	/**
+	* Returns an object mapping data type strings to descriptions.
 	*
 	* @returns object mapping data type strings to descriptions
 	*
@@ -763,6 +1316,33 @@ interface Namespace {
 	*/
 	dtypeEnum2Str: typeof dtypeEnum2Str;
 
+	/**
+	* Returns an object mapping supported data type strings to enumeration constants.
+	*
+	* ## Notes
+	*
+	* -   Downstream consumers of this mapping should **not** rely on specific integer values (e.g., `INT8 == 0`). Instead, the object should be used in an opaque manner.
+	* -   The main purpose of this function is JavaScript and C inter-operation of ndarray objects.
+	*
+	* @returns object mapping supported data type strings to enumeration constants
+	*
+	* @example
+	* var o = ns.dtypeEnums();
+	* // returns {...}
+	*/
+	dtypeEnums: typeof dtypeEnums;
+
+	/**
+	* Returns an object mapping supported data type strings to data type objects.
+	*
+	* @returns object mapping supported data type strings to data type objects
+	*
+	* @example
+	* var o = ns.dtypeObjects();
+	* // returns {...}
+	*/
+	dtypeObjects: typeof dtypeObjects;
+
 	/**
 	* Returns the enumeration constant associated with an ndarray data type value.
 	*
@@ -809,6 +1389,22 @@ interface Namespace {
 	*/
 	dtypeStr2Enum: typeof dtypeStr2Enum;
 
+	/**
+	* Returns a list of ndarray data type strings.
+	*
+	* @param kind - data type kind
+	* @returns list of ndarray data type strings
+	*
+	* @example
+	* var list = ns.dtypeStrings();
+	* // returns [...]
+	*
+	* @example
+	* var list = ns.dtypeStrings( 'floating_point' );
+	* // returns [...]
+	*/
+	dtypeStrings: typeof dtypeStrings;
+
 	/**
 	* Returns the C data type associated with a provided data type value.
 	*
@@ -824,6 +1420,26 @@ interface Namespace {
 	*/
 	dtype2c: typeof dtype2c;
 
+	/**
+	* Resolves a list of data type enumeration constants.
+	*
+	* ## Notes
+	*
+	* -   If the function is unable to resolve an enumeration constant for a provided data type, the corresponding element in the returned array will be `null`.
+	*
+	* @param dtypes - list of data types
+	* @returns results
+	*
+	* @example
+	* var out = ns.dtypes2enums( [ 'float32', 'float64' ] );
+	* // returns [...]
+	*
+	* @example
+	* var out = ns.dtypes2enums( [ 'foo', 'bar' ] );
+	* // returns [ null, null ]
+	*/
+	dtypes2enums: typeof dtypes2enums;
+
 	/**
 	* Transforms a list of array argument data types into a list of signatures.
 	*
@@ -848,6 +1464,26 @@ interface Namespace {
 	*/
 	dtypes2signatures: typeof dtypes2signatures;
 
+	/**
+	* Resolves a list of data type strings.
+	*
+	* ## Notes
+	*
+	* -   If the function is unable to resolve a data type string for a provided data type, the corresponding element in the returned array will be `null`.
+	*
+	* @param dtypes - list of data types
+	* @returns results
+	*
+	* @example
+	* var out = ns.dtypes2strings( [ 'float32', 'float64' ] );
+	* // returns [...]
+	*
+	* @example
+	* var out = ns.dtypes2strings( [ 'foo', 'bar' ] );
+	* // returns [ null, null ]
+	*/
+	dtypes2strings: typeof dtypes2strings;
+
 	/**
 	* Creates an uninitialized array having a specified shape and data type.
 	*
@@ -898,79 +1534,320 @@ interface Namespace {
 	emptyLike: typeof emptyLike;
 
 	/**
-	* Expands the shape of an array by inserting a new dimension of size one at a specified axis.
-	*
-	* ## Notes
-	*
-	* -   A provided axis must reside on the interval `[-N-1, N]`, where `N` is the rank (i.e., number of dimensions) of the provided input array. If provided a negative `axis`, the axis position at which to insert a singleton dimension is computed as `N + axis + 1`. Hence, if provided `-1`, the resolved axis position is `N` (i.e., a singleton dimension is appended to the input array).
+	* Tests whether every element in an ndarray is truthy.
 	*
-	* @param x - input array
-	* @param axis - axis at which to insert a singleton dimension
-	* @returns output array
+	* @param arrays - array-like object containing an input ndarray
+	* @returns boolean indicating whether every element is truthy
 	*
 	* @example
-	* var array = require( '@stdlib/ndarray-array' );
-	*
-	* var x = array( [ [ 1, 2 ], [ 3, 4 ] ] );
-	* // returns <ndarray>
-	*
-	* var shx = x.shape;
-	* // returns [ 2, 2 ]
+	* var Float64Array = require( '@stdlib/array-float64' );
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
 	*
-	* var y = ns.expandDimensions( x, 1 );
-	* // returns <ndarray>
+	* // Create a data buffer:
+	* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
 	*
-	* var shy = y.shape;
-	* // returns [ 2, 1, 2 ]
+	* // Define the shape of the input array:
+	* var shape = [ 3, 1, 2 ];
 	*
-	* var v = y.get( 0, 0, 0 );
-	* // returns 1
+	* // Define the array strides:
+	* var sx = [ 4, 4, 1 ];
 	*
-	* v = y.get( 0, 0, 1 );
-	* // returns 2
+	* // Define the index offset:
+	* var ox = 1;
 	*
-	* v = y.get( 1, 0, 0 );
-	* // returns 3
+	* // Create the input ndarray:
+	* var x = ndarray( 'float64', xbuf, shape, sx, ox, 'row-major' );
 	*
-	* v = y.get( 1, 0, 1 );
-	* // returns 4
+	* // Test elements:
+	* var out = ns.every( [ x ] );
+	* // returns true
 	*/
-	expandDimensions: typeof expandDimensions;
+	every: typeof every;
 
 	/**
-	* Returns a specified flag for a provided ndarray.
+	* Tests whether all elements in an ndarray pass a test implemented by a predicate function.
 	*
-	* @param x - input ndarray
-	* @param name - flag name
-	* @returns flag value
+	* @param arrays - array-like object containing an input ndarray
+	* @param predicate - predicate function
+	* @param thisArg - predicate function execution context
+	* @returns boolean indicating whether all elements pass a test
 	*
 	* @example
-	* var zeros = require( '@stdlib/ndarray-zeros' );
+	* var Float64Array = require( '@stdlib/array-float64' );
+	* var ndarray = require( '@stdlib/ndarray-base-ctor' );
 	*
-	* var o = ns.flag( zeros( [ 3, 3, 3 ] ), 'READONLY' );
-	* // returns <boolean>
+	* function predicate( value ) {
+	*    return value > 0.0;
+	* }
+	*
+	* // Create a data buffer:
+	* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+	*
+	* // Define the shape of the array:
+	* var shape = [ 3, 1, 2 ];
+	*
+	* // Define the array strides:
+	* var sx = [ 4, 4, 1 ];
+	*
+	* // Define the index offset:
+	* var ox = 1;
+	*
+	* // Create the input ndarray:
+	* var x = ndarray( 'float64', xbuf, shape, sx, ox, 'row-major' );
+	*
+	* // Test elements:
+	* var out = ns.everyBy( [ x ], predicate );
+	* // returns true
 	*/
-	flag: typeof flag;
+	everyBy: typeof everyBy;
 
 	/**
-	* Returns the flags of a provided ndarray.
+	* Expands the shape of an array by inserting a new dimension of size one at a specified dimension index.
 	*
 	* ## Notes
 	*
-	* -   When `copy` is `false`, changes to the returned object may mutate the input ndarray flags. If there is a chance that the returned object will be mutated (either directly or by downstream consumers), set `copy` to `true` to prevent unintended side effects.
+	* -   A provided dimension index must reside on the interval `[-N-1, N]`, where `N` is the rank (i.e., number of dimensions) of the provided input array. If provided a negative dimension index, the position at which to insert a singleton dimension is computed as `N + dim + 1`. Hence, if provided `-1`, the resolved position is `N` (i.e., a singleton dimension is appended to the input array).
 	*
-	* @param x - input ndarray
-	* @param copy - boolean indicating whether to explicitly copy the value assigned to the input ndarray's `flags` property
-	* @returns flags
+	* @param x - input array
+	* @param dim - dimension index at which to insert a singleton dimension
+	* @param writable - boolean indicating whether the returned ndarray should be writable
+	* @returns output array
 	*
 	* @example
-	* var zeros = require( '@stdlib/ndarray-zeros' );
+	* var array = require( '@stdlib/ndarray-array' );
+	*
+	* var x = array( [ [ 1, 2 ], [ 3, 4 ] ] );
+	* // returns <ndarray>[ [ 1, 2 ], [ 3, 4 ] ]
+	*
+	* var y = ns.expandDimensions( x, 1, false );
+	* // returns <ndarray>[ [ [ 1, 2 ] ], [ [ 3, 4 ] ] ]
+	*/
+	expandDimensions: typeof expandDimensions;
+
+	/**
+	* Fills an input ndarray with a specified value.
+	*
+	* ## Notes
+	*
+	* -   A `value` must be able to safely cast to the input ndarray data type. Scalar values having floating-point data types (both real and complex) are allowed to downcast to a lower precision data type of the same kind (e.g., a scalar double-precision floating-point number can be used to fill a `'float32'` input ndarray).
+	*
+	* @param x - input ndarray
+	* @param value - scalar value
+	* @returns input ndarray
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array-float64' );
+	*
+	* // Create a data buffer:
+	* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+	*
+	* // Define the shape of the input array:
+	* var shape = [ 3, 1, 2 ];
+	*
+	* // Define the array strides:
+	* var sx = [ 2, 2, 1 ];
+	*
+	* // Define the index offset:
+	* var ox = 0;
+	*
+	* // Create the input ndarray-like object:
+	* var x = {
+	*     'dtype': 'float64',
+	*     'data': xbuf,
+	*     'shape': shape,
+	*     'strides': sx,
+	*     'offset': ox,
+	*     'order': 'row-major'
+	* };
+	*
+	* var out = ns.fill( x, 10.0 );
+	*
+	* console.log( x.data );
+	* // => <Float64Array>[ 10.0, 10.0, 10.0, 10.0, 10.0, 10.0 ]
+	*
+	* var bool = ( out === x );
+	* // returns true
+	*/
+	fill: typeof fill;
+
+	/**
+	* Fills an input ndarray according to a callback function.
+	*
+	* @param x - input ndarray
+	* @param fcn - callback function
+	* @param thisArg - callback function execution context
+	* @returns input ndarray
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array-float64' );
+	*
+	* function fcn() {
+	*     return 10.0;
+	* }
+	*
+	* // Create a data buffer:
+	* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+	*
+	* // Define the shape of the input array:
+	* var shape = [ 3, 1, 2 ];
+	*
+	* // Define the array strides:
+	* var sx = [ 2, 2, 1 ];
+	*
+	* // Define the index offset:
+	* var ox = 0;
+	*
+	* // Create the input ndarray-like object:
+	* var x = {
+	*     'dtype': 'float64',
+	*     'data': xbuf,
+	*     'shape': shape,
+	*     'strides': sx,
+	*     'offset': ox,
+	*     'order': 'row-major'
+	* };
+	*
+	* var out = ns.fillBy( x, fcn );
+	*
+	* console.log( x.data );
+	* // => <Float64Array>[ 10.0, 10.0, 10.0, 10.0, 10.0, 10.0 ]
+	*
+	* var bool = ( out === x );
+	* // returns true
+	*/
+	fillBy: typeof fillBy;
+
+	/**
+	* Returns the first element in an ndarray which passes a test implemented by a predicate function.
+	*
+	* ## Notes
+	*
+	* -   The function returns the sentinel value if no element in an input ndarray passes a test implemented by a predicate function.
+	*
+	* @param arrays - array-like object containing an input ndarray and a zero-dimensional ndarray containing a sentinel value
+	* @param predicate - predicate function
+	* @param thisArg - predicate function execution context
+	* @returns result
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array-float64' );
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
+	* var scalar2ndarray = require( '@stdlib/ndarray-from-scalar' );
+	*
+	* function predicate( value ) {
+	*    return value % 2.0 === 0.0;
+	* }
+	*
+	* // Create data buffers:
+	* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+	*
+	* // Define the shape of the input array:
+	* var shape = [ 3, 1, 2 ];
+	*
+	* // Define the array strides:
+	* var sx = [ 4, 4, 1 ];
+	*
+	* // Define the index offset:
+	* var ox = 0;
+	*
+	* // Create the input ndarray:
+	* var x = ndarray( 'float64', xbuf, shape, sx, ox, 'row-major' );
+	*
+	* // Create a zero-dimensional ndarray containing a sentinel value:
+	* var sv = scalar2ndarray( NaN, {
+	*     'dtype': 'float64'
+	* });
+	*
+	* // Perform reduction:
+	* var out = ns.find( [ x, sv ], predicate );
+	* // returns 2.0
+	*/
+	find: typeof find;
+
+	/**
+	* Returns a specified flag for a provided ndarray.
+	*
+	* @param x - input ndarray
+	* @param name - flag name
+	* @returns flag value
+	*
+	* @example
+	* var zeros = require( '@stdlib/ndarray-zeros' );
+	*
+	* var o = ns.flag( zeros( [ 3, 3, 3 ] ), 'READONLY' );
+	* // returns <boolean>
+	*/
+	flag: typeof flag;
+
+	/**
+	* Returns the flags of a provided ndarray.
+	*
+	* ## Notes
+	*
+	* -   When `copy` is `false`, changes to the returned object may mutate the input ndarray flags. If there is a chance that the returned object will be mutated (either directly or by downstream consumers), set `copy` to `true` to prevent unintended side effects.
+	*
+	* @param x - input ndarray
+	* @param copy - boolean indicating whether to explicitly copy the value assigned to the input ndarray's `flags` property
+	* @returns flags
+	*
+	* @example
+	* var zeros = require( '@stdlib/ndarray-zeros' );
 	*
 	* var o = ns.flags( zeros( [ 3, 3, 3 ] ), false );
 	* // returns {...}
 	*/
 	flags: typeof flags;
 
+	/**
+	* Flattens a shape to a specified depth.
+	*
+	* @param shape - array shape
+	* @param depth - maximum depth to flatten
+	* @returns flattened shape
+	*
+	* @example
+	* var sh = ns.flattenShape( [ 3, 2 ], 1 );
+	* // returns [ 6 ]
+	*
+	* sh = ns.flattenShape( [ 3, 2, 1 ], 1 );
+	* // returns [ 6, 1 ]
+	*
+	* sh = ns.flattenShape( [ 3 ], 0 );
+	* // returns [ 3 ]
+	*
+	* sh = ns.flattenShape( [ 3, 2 ], 0 );
+	* // returns [ 3, 2 ]
+	*
+	* sh = ns.flattenShape( [ 3 ], 1 );
+	* // returns [ 3 ]
+	*
+	* sh = ns.flattenShape( [], 1 );
+	* // returns []
+	*/
+	flattenShape: typeof flattenShape;
+
+	/**
+	* Flattens a shape starting from a specified dimension.
+	*
+	* @param shape - array shape
+	* @param dim - dimension to start flattening from
+	* @returns flattened shape
+	*
+	* @example
+	* var sh = ns.flattenShapeFrom( [ 3, 3, 2 ], 1 );
+	* // returns [ 3, 6 ]
+	*
+	* sh = ns.flattenShapeFrom( [ 3, 2, 1 ], 1 );
+	* // returns [ 3, 2 ]
+	*
+	* sh = ns.flattenShapeFrom( [ 3 ], 0 );
+	* // returns [ 3 ]
+	*
+	* sh = ns.flattenShapeFrom( [ 3, 2 ], 0 );
+	* // returns [ 6 ]
+	*/
+	flattenShapeFrom: typeof flattenShapeFrom;
+
 	/**
 	* Returns a view of an input ndarray in which the order of elements along the last dimension is reversed.
 	*
@@ -981,6 +1858,7 @@ interface Namespace {
 	* @example
 	* var typedarray = require( '@stdlib/array-typed' );
 	* var ndarray = require( '@stdlib/ndarray-ctor' );
+	* var getShape = require( '@stdlib/ndarray-shape' );
 	* var ndarray2array = require( '@stdlib/ndarray-to-array' );
 	*
 	* var buffer = [ 1, 2, 3, 4, 5, 6 ];
@@ -991,7 +1869,7 @@ interface Namespace {
 	* var x = ndarray( 'generic', buffer, shape, strides, offset, 'row-major' );
 	* // returns <ndarray>
 	*
-	* var sh = x.shape;
+	* var sh = getShape( x );
 	* // returns [ 3, 2 ]
 	*
 	* var arr = ndarray2array( x );
@@ -1000,7 +1878,7 @@ interface Namespace {
 	* var y = ns.fliplr( x, false );
 	* // returns <ndarray>
 	*
-	* sh = y.shape;
+	* sh = getShape( y );
 	* // returns [ 3, 2 ]
 	*
 	* arr = ndarray2array( y );
@@ -1050,10 +1928,12 @@ interface Namespace {
 	*
 	* @param arrays - array-like object containing an output ndarray
 	* @param fcn - callback function
+	* @param thisArg - callback function execution context
 	*
 	* @example
 	* var Float64Array = require( '@stdlib/array-float64' );
 	* var naryFunction = require( '@stdlib/utils-nary-function' );
+	* var ndarray = require( '@stdlib/ndarray-base-ctor' );
 	* var log = require( '@stdlib/console-log' );
 	*
 	* // Create data buffers:
@@ -1076,6 +1956,24 @@ interface Namespace {
 	*/
 	forEach: typeof forEach;
 
+	/**
+	* Converts an array to a one-dimensional ndarray.
+	*
+	* @param buf - input array
+	* @param order - memory layout (row-major or column-major)
+	* @returns one-dimensional ndarray
+	*
+	* @example
+	* var arr = [ 1, 2, 3, 4 ];
+	*
+	* var x = ns.array2ndarray( arr, 'row-major' );
+	* // returns <ndarray>
+	*
+	* var dt = x.dtype;
+	* // returns 'generic'
+	*/
+	array2ndarray: typeof array2ndarray;
+
 	/**
 	* Returns a zero-dimensional ndarray containing a provided scalar value.
 	*
@@ -1099,6 +1997,70 @@ interface Namespace {
 	*/
 	scalar2ndarray: typeof scalar2ndarray;
 
+	/**
+	* Returns a zero-dimensional ndarray containing a provided scalar value and having the same data type as a provided input ndarray.
+	*
+	* @param x - input array
+	* @param value - scalar value
+	* @returns zero-dimensional ndarray
+	*
+	* @example
+	* var zeros = require( '@stdlib/ndarray-base-zeros' );
+	*
+	* var x = zeros( 'float64', [ 2, 2 ], 'row-major' );
+	* // returns <ndarray>
+	*
+	* var y = ns.scalar2ndarrayLike( x, 1.0 );
+	* // returns <ndarray>
+	*
+	* var sh = y.shape;
+	* // returns []
+	*
+	* var dt = y.dtype;
+	* // returns 'float64'
+	*
+	* var v = y.get();
+	* // returns 1.0
+	*/
+	scalar2ndarrayLike: typeof scalar2ndarrayLike;
+
+	/**
+	* Tests whether an ndarray contains a specified value.
+	*
+	* @param arrays - array-like object containing an input ndarray and a zero-dimensional search element ndarray
+	* @returns boolean indicating whether an ndarray contains a specified value
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array-float64' );
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
+	* var scalar2ndarray = require( '@stdlib/ndarray-from-scalar' );
+	*
+	* // Create data buffers:
+	* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+	*
+	* // Define the shape of the input array:
+	* var shape = [ 3, 1, 2 ];
+	*
+	* // Define the array strides:
+	* var sx = [ 4, 4, 1 ];
+	*
+	* // Define the index offset:
+	* var ox = 0;
+	*
+	* // Create the input ndarray:
+	* var x = ndarray( 'float64', xbuf, shape, sx, ox, 'row-major' );
+	*
+	* // Create a zero-dimensional ndarray containing a search element:
+	* var v = scalar2ndarray( 6.0, {
+	*     'dtype': 'float64'
+	* });
+	*
+	* // Perform reduction:
+	* var out = ns.includes( [ x, v ] );
+	* // returns true
+	*/
+	includes: typeof includes;
+
 	/**
 	* Returns an index given an index mode.
 	*
@@ -1138,26 +2100,14 @@ interface Namespace {
 	* // throws <RangeError>
 	*
 	* @example
-	* var idx = ns.ind( 2, 9, 'normalize' );
-	* // returns 2
+	* var idx = ns.ind( 1, 10, 'normalize' );
+	* // returns 1
 	*
-	* idx = ns.ind( -5, 9, 'normalize' );
-	* // returns 5
+	* idx = ns.ind( -4, 10, 'normalize' );
+	* // returns 7
 	*
-	* idx = ns.ind( -20, 9, 'normalize' );
+	* idx = ns.ind( -100, 10, 'normalize' );
 	* // throws <RangeError>
-	*
-	* @example
-	* var fcn = ns.ind.factory( 'clamp' );
-	*
-	* var idx = fcn( 2, 9 );
-	* // returns 2
-	*
-	* idx = fcn( 10, 9 );
-	* // returns 9
-	*
-	* idx = fcn( -1, 9 );
-	* // returns 0
 	*/
 	ind: typeof ind;
 
@@ -1291,51 +2241,148 @@ interface Namespace {
 	iterationOrder: typeof iterationOrder;
 
 	/**
-	* Computes the maximum linear index in an underlying data buffer accessible to an array view.
+	* Reorders ndarray dimensions and associated strides for loop interchange.
 	*
-	* @param shape - array shape
-	* @param strides - stride array
-	* @param offset - index offset
-	* @returns linear index
+	* ## Notes
 	*
-	* @example
-	* var shape = [ 10, 10 ];
-	* var strides = [ 10, 1 ];
-	* var offset = 0;
+	* -   The returned array has the following elements:
 	*
-	* var idx = ns.maxViewBufferIndex( shape, strides, offset );
-	* // returns 99
+	*     ```text
+	*     [ <shape>, ...<strides> ]
+	*     ```
 	*
-	* @example
-	* var shape = [ 10, 10 ];
-	* var strides = [ -10, -1 ];
-	* var offset = 99;
+	*     where
 	*
-	* var idx = ns.maxViewBufferIndex( shape, strides, offset );
-	* // returns 99
+	*     -   **shape**: dimensions sorted in loop order.
+	*     -   **...strides**: strides for each respective ndarray sorted in loop order.
 	*
-	* @example
-	* var shape = [ 10, 10 ];
-	* var strides = [ 1, 10 ];
-	* var offset = 0;
+	* -   When iterating over the elements of a multi-dimensional array, accessing elements which are closer in memory can improve performance. To this end, loop interchange is a technique used in loop nest optimization to improve locality of reference and take advantage of CPU cache.
 	*
-	* var idx = ns.maxViewBufferIndex( shape, strides, offset );
-	* // returns 99
+	*     The purpose of this function is to order ndarray dimensions according to the magnitude of array strides. By using the ordered dimensions and associated strides, one can construct nested loops (one for each dimension) such that the innermost loop iterates over the dimension in which array elements are closest in memory and the outermost loop iterates over the dimension in which array elements are farthest apart in memory. As a consequence, element iteration is optimized to minimize cache misses and ensure locality of reference.
 	*
-	* @example
-	* var shape = [ 10, 10 ];
-	* var strides = [ -1, -10 ];
-	* var offset = 99;
+	* -   Cache performance may be degraded if the layout order (i.e., row-major or column-major) differs for the input and output ndarrays. This function is intended to optimize cache performance for the most common layout order. Accordingly, if the output ndarray has a different layout order (e.g., if the input ndarrays are row-major and the output ndarray is column-major), cache misses are likely for the output ndarray. In general, to ensure best performance, input and output ndarrays should have the same layout order.
 	*
-	* var idx = ns.maxViewBufferIndex( shape, strides, offset );
-	* // returns 99
-	*/
-	maxViewBufferIndex: typeof maxViewBufferIndex;
-
-	/**
-	* Broadcasts an ndarray to a specified shape if and only if the specified shape differs from the provided ndarray's shape.
+	* -   The function assumes that the input and output ndarrays have the same shape. Hence, loop interchange order should only be determined **after** broadcasting.
 	*
-	* ## Notes
+	* @param shape - array dimensions
+	* @param strides - list of stride arrays containing the stride lengths for each input and output ndarray
+	* @returns loop interchange data
+	*
+	* @example
+	* var sh = [ 2, 3, 4 ];
+	*
+	* var sx = [ 12, 4, 1 ]; // row-major
+	* var sy = [ 24, 8, 1 ]; // row-major
+	* var sz = [ 1, -2, 6 ]; // column-major
+	*
+	* var o = ns.loopOrder( sh, [ sx, sy, sz ] );
+	* // returns [...]
+	*
+	* var ssh = o[ 0 ];
+	* // returns [ 4, 3, 2 ]
+	*
+	* var ssx = o[ 1 ];
+	* // returns [ 1, 4, 12 ]
+	*
+	* var ssy = o[ 2 ];
+	* // returns [ 1, 8, 24 ]
+	*
+	* var ssz = o[ 3 ];
+	* // returns [ 6, -2, 1 ]
+	*/
+	loopOrder: typeof loopOrder;
+
+	/**
+	* Applies a callback function to elements in an input ndarray and assigns results to elements in an output ndarray.
+	*
+	* @param arrays - array-like object containing one input ndarray and one output ndarray
+	* @param fcn - callback function
+	* @param thisArg - callback function execution context
+	* @throws arrays must have the same number of dimensions
+	* @throws arrays must have the same shape
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array-float64' );
+	* var getData = require( '@stdlib/ndarray-data-buffer' );
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
+	*
+	* function scale( x ) {
+	*     return x * 10.0;
+	* }
+	*
+	* // Create data buffers:
+	* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+	* var ybuf = new Float64Array( 6 );
+	*
+	* // Define the shape of the input and output arrays:
+	* var shape = [ 3, 1, 2 ];
+	*
+	* // Define the array strides:
+	* var sx = [ 4, 4, 1 ];
+	* var sy = [ 2, 2, 1 ];
+	*
+	* // Define the index offsets:
+	* var ox = 1;
+	* var oy = 0;
+	*
+	* // Create the input and output ndarrays:
+	* var x = ndarray( 'float64', xbuf, shape, sx, ox, 'row-major' );
+	* var y = ndarray( 'float64', ybuf, shape, sy, oy, 'row-major' );
+	*
+	* // Apply function:
+	* ns.map( [ x, y ], scale );
+	*
+	* console.log( getData( y ) );
+	* // => <Float64Array>[ 20.0, 30.0, 60.0, 70.0, 100.0, 110.0 ]
+	*/
+	map: typeof map;
+
+	/**
+	* Computes the maximum linear index in an underlying data buffer accessible to an array view.
+	*
+	* @param shape - array shape
+	* @param strides - stride array
+	* @param offset - index offset
+	* @returns linear index
+	*
+	* @example
+	* var shape = [ 10, 10 ];
+	* var strides = [ 10, 1 ];
+	* var offset = 0;
+	*
+	* var idx = ns.maxViewBufferIndex( shape, strides, offset );
+	* // returns 99
+	*
+	* @example
+	* var shape = [ 10, 10 ];
+	* var strides = [ -10, -1 ];
+	* var offset = 99;
+	*
+	* var idx = ns.maxViewBufferIndex( shape, strides, offset );
+	* // returns 99
+	*
+	* @example
+	* var shape = [ 10, 10 ];
+	* var strides = [ 1, 10 ];
+	* var offset = 0;
+	*
+	* var idx = ns.maxViewBufferIndex( shape, strides, offset );
+	* // returns 99
+	*
+	* @example
+	* var shape = [ 10, 10 ];
+	* var strides = [ -1, -10 ];
+	* var offset = 99;
+	*
+	* var idx = ns.maxViewBufferIndex( shape, strides, offset );
+	* // returns 99
+	*/
+	maxViewBufferIndex: typeof maxViewBufferIndex;
+
+	/**
+	* Broadcasts an ndarray to a specified shape if and only if the specified shape differs from the provided ndarray's shape.
+	*
+	* ## Notes
 	*
 	* -   The function throws an error if a provided ndarray is incompatible with a provided shape.
 	* -   If a provided ndarray has the same shape as the specified shape, the function returns the provided ndarray.
@@ -1414,8 +2461,8 @@ interface Namespace {
 	* var shy = y1.shape;
 	* // returns [ 3, 2, 2 ]
 	*
-	* var out = ns.maybeBroadcastArrays( [ x, y ] );
-	* // returns <ndarray>
+	* var out = ns.maybeBroadcastArrays( [ x, y1 ] );
+	* // returns [ <ndarray>, <ndarray> ]
 	*
 	* var x2 = out[ 0 ];
 	* // returns <ndarray>
@@ -1483,6 +2530,38 @@ interface Namespace {
 	*/
 	metaDataProps: typeof metaDataProps;
 
+	/**
+	* Returns the minimum ndarray data type for storing a provided signed integer value.
+	*
+	* @param value - scalar value
+	* @returns ndarray data type
+	*
+	* @example
+	* var dt = ns.minSignedIntegerDataType( 1280 );
+	* // returns 'int16'
+	*
+	* @example
+	* var dt = ns.minSignedIntegerDataType( 3 );
+	* // returns 'int8'
+	*/
+	minSignedIntegerDataType: typeof minSignedIntegerDataType;
+
+	/**
+	* Returns the minimum ndarray data type for storing a provided unsigned integer value.
+	*
+	* @param value - scalar value
+	* @returns ndarray data type
+	*
+	* @example
+	* var dt = ns.minUnsignedIntegerDataType( 1280 );
+	* // returns 'uint16'
+	*
+	* @example
+	* var dt = ns.minUnsignedIntegerDataType( 3 );
+	* // returns 'uint8'
+	*/
+	minUnsignedIntegerDataType: typeof minUnsignedIntegerDataType;
+
 	/**
 	* Computes the minimum linear index in an underlying data buffer accessible to an array view.
 	*
@@ -1568,7 +2647,23 @@ interface Namespace {
 	minmaxViewBufferIndex: typeof minmaxViewBufferIndex;
 
 	/**
-	* Converts an ndarray-like to an object likely to have the same "shape".
+	* Converts an ndarray-like object to an ndarray.
+	*
+	* @param x - input ndarray
+	* @returns ndarray
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray-array' );
+	*
+	* var x = array( [ [ 1, 2, 3 ], [ 4, 5, 6 ] ] );
+	*
+	* var out = ns.ndarraylike2ndarray( x );
+	* // returns <ndarray>
+	*/
+	ndarraylike2ndarray: typeof ndarraylike2ndarray;
+
+	/**
+	* Converts an ndarray-like object to an object likely to have the same "shape".
 	*
 	* ## Notes
 	*
@@ -1587,6 +2682,23 @@ interface Namespace {
 	*/
 	ndarraylike2object: typeof ndarraylike2object;
 
+	/**
+	* Converts an ndarray-like object to a scalar value.
+	*
+	* @param x - input ndarray
+	* @returns scalar value
+	*
+	* @example
+	* var scalar2ndarray = require( '@stdlib/ndarray-from-scalar' );
+	*
+	* var x = scalar2ndarray( 1.0 );
+	* // returns <ndarray>
+	*
+	* var out = ns.ndarraylike2scalar( x );
+	* // returns 1.0
+	*/
+	ndarraylike2scalar: typeof ndarraylike2scalar;
+
 	/**
 	* Returns the number of ndarray dimensions.
 	*
@@ -1701,6 +2813,27 @@ interface Namespace {
 	*/
 	normalizeIndex: typeof normalizeIndex;
 
+	/**
+	* Normalizes a list of indices to the interval `[0,max]`.
+	*
+	* ## Notes
+	*
+	* -   If provided an out-of-bounds index, the function returns `null`.
+	* -   The function mutates the input array, even when provided an out-of-bounds index.
+	*
+	* @param indices - indices
+	* @param max - maximum index
+	* @returns normalized indices or null
+	*
+	* @example
+	* var indices = ns.normalizeIndices( [ -2, 5 ], 10 );
+	* // returns [ 9, 5 ]
+	*
+	* indices = ns.normalizeIndices( [ -2, 15 ], 10 );
+	* // returns null
+	*/
+	normalizeIndices: typeof normalizeIndices;
+
 	/**
 	* Applies a nullary callback and assigns results to elements in an output ndarray.
 	*
@@ -1776,6 +2909,90 @@ interface Namespace {
 	*/
 	nullaryLoopOrder: typeof nullaryLoopOrder;
 
+	/**
+	* Constructor for applying a strided function to an ndarray.
+	*
+	* @param table - dispatch table
+	* @param idtypes - list containing lists of supported input data types for each ndarray argument
+	* @param odtypes - list of supported output data types
+	* @param options - function options
+	* @returns instance
+	*
+	* @example
+	* var base = require( '@stdlib/blas-ext-base-ndarray-gsorthp' );
+	* var dtypes = require( '@stdlib/ndarray-dtypes' );
+	* var scalar2ndarray = require( '@stdlib/ndarray-from-scalar' );
+	* var ndarray2array = require( '@stdlib/ndarray-to-array' );
+	* var ndarray = require( '@stdlib/ndarray-base-ctor' );
+	*
+	* var idt = dtypes( 'real_and_generic' );
+	* var odt = dtypes( 'all' );
+	*
+	* var table = {
+	*     'default': base
+	* };
+	* var sorthp = new ns.nullaryStrided1dDispatch( table, [ idt ], odt );
+	*
+	* var xbuf = [ -1.0, 2.0, -3.0 ];
+	* var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+	*
+	* var order = scalar2ndarray( 1.0, {
+	*      'dtype': 'generic'
+	* });
+	*
+	* var out = sorthp.assign( x, order );
+	* // returns <ndarray>
+	*
+	* var arr = ndarray2array( x );
+	* // returns [ -3.0, -1.0, 2.0 ]
+	*
+	* var bool = ( out === x );
+	* // returns true
+	*/
+	nullaryStrided1dDispatch: typeof nullaryStrided1dDispatch;
+
+	/**
+	* Creates a function for applying a strided function to an output ndarray.
+	*
+	* @param table - dispatch table
+	* @param idtypes - list containing lists of supported input data types for each ndarray argument
+	* @param odtypes - list of supported output data types
+	* @param options - function options
+	* @returns function for applying a nullary function
+	*
+	* @example
+	* var base = require( '@stdlib/blas-ext-base-ndarray-gsorthp' );
+	* var dtypes = require( '@stdlib/ndarray-dtypes' );
+	* var scalar2ndarray = require( '@stdlib/ndarray-from-scalar' );
+	* var ndarray2array = require( '@stdlib/ndarray-to-array' );
+	* var ndarray = require( '@stdlib/ndarray-base-ctor' );
+	*
+	* var idt = dtypes( 'real_and_generic' );
+	* var odt = dtypes( 'all' );
+	*
+	* var table = {
+	*     'default': base
+	* };
+	* var sorthp = ns.nullaryStrided1dDispatchFactory( table, [ idt ], odt );
+	*
+	* var xbuf = [ -1.0, 2.0, -3.0 ];
+	* var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+	*
+	* var order = scalar2ndarray( 1.0, {
+	*      'dtype': 'generic'
+	* });
+	*
+	* var out = sorthp( x, order );
+	* // returns <ndarray>
+	*
+	* var arr = ndarray2array( out );
+	* // returns [ -3.0, -1.0, 2.0 ]
+	*
+	* var bool = ( out === x );
+	* // returns true
+	*/
+	nullaryStrided1dDispatchFactory: typeof nullaryStrided1dDispatchFactory;
+
 	/**
 	* Returns a loop block size for multi-dimensional array tiled loops.
 	*
@@ -1851,6 +3068,19 @@ interface Namespace {
 	*/
 	order: typeof order;
 
+	/**
+	* Resolves the output data type from a list of input ndarray data types.
+	*
+	* @param dtypes - input ndarray data types
+	* @param policy - output ndarray data type policy
+	* @returns output ndarray data type
+	*
+	* @example
+	* var dt = ns.outputDataType( [ 'float64' ], 'complex_floating_point' );
+	* // returns <string>
+	*/
+	outputDataType: typeof outputDataType;
+
 	/**
 	* Returns the policy string associated with an output ndarray data type policy enumeration constant.
 	*
@@ -1915,61 +3145,266 @@ interface Namespace {
 	outputPolicyStr2Enum: typeof outputPolicyStr2Enum;
 
 	/**
-	* Returns an array with a specified number of prepended singleton dimensions.
+	* Returns an array containing a truncated view of an input ndarray and a view of the last element(s) along a specified dimension.
+	*
+	* ## Notes
+	*
+	* -   The input array must have one or more dimensions.
 	*
 	* @param x - input array
-	* @param n - number of singleton dimensions to prepend
-	* @returns output array
+	* @param dim - dimension along which to perform the operation
+	* @param writable - boolean indicating whether returned arrays should be writable
+	* @returns a list of ndarrays
 	*
 	* @example
-	* var array = require( '@stdlib/ndarray-array' );
+	* var Float64Array = require( '@stdlib/array-float64' );
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
+	* var ndarray2array = require( '@stdlib/ndarray-to-array' );
 	*
-	* var x = array( [ [ 1, 2 ], [ 3, 4 ] ] );
+	* var buffer = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+	* var shape = [ 3, 2 ];
+	* var strides = [ 2, 1 ];
+	* var offset = 0;
+	*
+	* var x = ndarray( 'float64', buffer, shape, strides, offset, 'row-major' );
 	* // returns <ndarray>
 	*
-	* var shx = x.shape;
-	* // returns [ 2, 2 ]
+	* var arr = ndarray2array( x );
+	* // returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 5.0, 6.0 ] ]
 	*
-	* var y = ns.prependSingletonDimensions( x, 3 );
-	* // returns <ndarray>
+	* var y = ns.pop( x, 0, false );
+	* // returns [ <ndarray>, <ndarray> ]
 	*
-	* var shy = y.shape;
-	* // returns [ 1, 1, 1, 2, 2 ]
+	* arr = ndarray2array( y[ 0 ] );
+	* // returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ]
 	*
-	* var v = y.get( 0, 0, 0, 0, 0 );
-	* // returns 1
+	* arr = ndarray2array( y[ 1 ] );
+	* // returns [ [ 5.0, 6.0 ] ]
+	*/
+	pop: typeof pop;
+
+	/**
+	* Returns an array with a specified number of prepended singleton dimensions.
 	*
-	* v = y.get( 0, 0, 0, 0, 1 );
-	* // returns 2
+	* @param x - input array
+	* @param n - number of singleton dimensions to prepend
+	* @param writable - boolean indicating whether a returned array should be writable
+	* @returns output array
 	*
-	* v = y.get( 0, 0, 0, 1, 0 );
-	* // returns 3
+	* @example
+	* var array = require( '@stdlib/ndarray-array' );
 	*
-	* v = y.get( 0, 0, 0, 1, 1 );
-	* // returns 4
+	* var x = array( [ [ 1, 2 ], [ 3, 4 ] ] );
+	* // returns <ndarray>[ [ 1, 2 ], [ 3, 4 ] ]
+	*
+	* var y = ns.prependSingletonDimensions( x, 3, false );
+	* // returns <ndarray>[ [ [ [ [ 1, 2 ], [ 3, 4 ] ] ] ] ]
 	*/
 	prependSingletonDimensions: typeof prependSingletonDimensions;
 
 	/**
-	* Returns an array without singleton dimensions.
+	* Returns a data type that results from applying promotion rules to a provided list of data types.
 	*
 	* ## Notes
 	*
-	* -   If a provided ndarray does not have any singleton dimensions, the function returns the provided ndarray unchanged.
-	* -   If a provided ndarray does have singleton dimensions, the function returns a new ndarray view.
+	* -   The function returns `null` if provided data types which cannot be safely cast to a promoted data type.
 	*
-	* @param x - input array
-	* @returns squeezed array
+	* @param dtypes - list of data types
+	* @returns result
 	*
 	* @example
-	* var array = require( '@stdlib/ndarray-array' );
-	*
-	* var x = array( [ [ 1, 2 ], [ 3, 4 ] ], {
-	*     'ndmin': 5
-	* });
-	* // returns <ndarray>
+	* var dt = ns.promoteDataTypes( [ 'float32', 'float64' ] );
+	* // returns 'float64'
 	*
-	* var shx = x.shape;
+	* @example
+	* var dt = ns.promoteDataTypes( [ 'binary', 'complex128' ] );
+	* // returns null
+	*/
+	promoteDataTypes: typeof promoteDataTypes;
+
+	/**
+	* Reorders ndarray dimensions and associated strides for loop interchange.
+	*
+	* ## Notes
+	*
+	* -   The returned object has the following properties:
+	*
+	*     -   **sh**: dimensions sorted in loop order.
+	*     -   **sx**: first input ndarray strides sorted in loop order.
+	*     -   **sy**: second input ndarray strides sorted in loop order.
+	*     -   **sz**: third input ndarray strides sorted in loop order.
+	*     -   **sw**: fourth input ndarray strides sorted in loop order.
+	*     -   **su**: output ndarray strides sorted in loop order.
+	*
+	* -   When iterating over the elements of a multi-dimensional array, accessing elements which are closer in memory can improve performance. To this end, loop interchange is a technique used in loop nest optimization to improve locality of reference and take advantage of CPU cache.
+	*
+	*     The purpose of this function is to order ndarray dimensions according to the magnitude of array strides. By using the ordered dimensions and associated strides, one can construct nested loops (one for each dimension) such that the innermost loop iterates over the dimension in which array elements are closest in memory and the outermost loop iterates over the dimension in which array elements are farthest apart in memory. As a consequence, element iteration is optimized to minimize cache misses and ensure locality of reference.
+	*
+	* -   Cache performance may be degraded if the layout order (i.e., row-major or column-major) differs for the input and output ndarrays. This function is intended to optimize cache performance for the most common layout order. Accordingly, if the output ndarray has a different layout order (e.g., if the input ndarrays are row-major and the output ndarray is column-major), cache misses are likely for the output ndarray. In general, to ensure best performance, input and output ndarrays should have the same layout order.
+	*
+	* -   The function assumes that the input and output ndarrays have the same shape. Hence, loop interchange order should only be determined **after** broadcasting.
+	*
+	* @param shape - array dimensions
+	* @param stridesX - first input array stride lengths
+	* @param stridesY - second input array stride lengths
+	* @param stridesZ - third input array stride lengths
+	* @param stridesW - fourth input array stride lengths
+	* @param stridesU - output array stride lengths
+	* @returns loop interchange data
+	*
+	* @example
+	* var sh = [ 2, 3, 4 ];
+	*
+	* var sx = [ 12, 4, 1 ]; // row-major
+	* var sy = [ 24, 8, 1 ]; // row-major
+	* var sz = [ 1, 4, 12 ]; // column-major
+	* var sw = [ 1, -2, 6 ]; // column-major
+	* var su = [ 1, -2, 6 ]; // column-major
+	*
+	* var o = ns.quaternaryLoopOrder( sh, sx, sy, sz, sw, su );
+	* // returns {...}
+	*
+	* var ssh = o.sh;
+	* // returns [ 2, 3, 4 ]
+	*
+	* var ssx = o.sx;
+	* // returns [ 12, 4, 1 ]
+	*
+	* var ssy = o.sy;
+	* // returns [ 24, 8, 1 ]
+	*
+	* var ssz = o.sz;
+	* // returns [ 1, 4, 12 ]
+	*
+	* var ssw = o.sw;
+	* // returns [ 1, -2, 6 ]
+	*
+	* var ssu = o.su;
+	* // returns [ 1, -2, 6 ]
+	*/
+	quaternaryLoopOrder: typeof quaternaryLoopOrder;
+
+	/**
+	* Returns a loop block size for multi-dimensional array tiled loops.
+	*
+	* @param dtypeX - first input array data type
+	* @param dtypeY - second input array data type
+	* @param dtypeZ - third input array data type
+	* @param dtypeW - fourth input array data type
+	* @param dtypeU - output array data type
+	* @returns block size (in units of elements)
+	*
+	* @example
+	* var bsize = ns.quaternaryBlockSize( 'float64', 'float64', 'float64', 'float64', 'float64' );
+	* // returns <number>
+	*/
+	quaternaryBlockSize: typeof quaternaryBlockSize;
+
+	/**
+	* Reorders ndarray dimensions and associated strides for loop interchange.
+	*
+	* ## Notes
+	*
+	* -   The returned object has the following properties:
+	*
+	*     -   **sh**: dimensions sorted in loop order.
+	*     -   **sx**: first input ndarray strides sorted in loop order.
+	*     -   **sy**: second input ndarray strides sorted in loop order.
+	*     -   **sz**: third input ndarray strides sorted in loop order.
+	*     -   **sw**: fourth input ndarray strides sorted in loop order.
+	*     -   **su**: fifth input ndarray strides sorted in loop order.
+	*     -   **sv**: output ndarray strides sorted in loop order.
+	*
+	* -   When iterating over the elements of a multi-dimensional array, accessing elements which are closer in memory can improve performance. To this end, loop interchange is a technique used in loop nest optimization to improve locality of reference and take advantage of CPU cache.
+	*
+	*     The purpose of this function is to order ndarray dimensions according to the magnitude of array strides. By using the ordered dimensions and associated strides, one can construct nested loops (one for each dimension) such that the innermost loop iterates over the dimension in which array elements are closest in memory and the outermost loop iterates over the dimension in which array elements are farthest apart in memory. As a consequence, element iteration is optimized to minimize cache misses and ensure locality of reference.
+	*
+	* -   Cache performance may be degraded if the layout order (i.e., row-major or column-major) differs for the input and output ndarrays. This function is intended to optimize cache performance for the most common layout order. Accordingly, if the output ndarray has a different layout order (e.g., if the input ndarrays are row-major and the output ndarray is column-major), cache misses are likely for the output ndarray. In general, to ensure best performance, input and output ndarrays should have the same layout order.
+	*
+	* -   The function assumes that the input and output ndarrays have the same shape. Hence, loop interchange order should only be determined **after** broadcasting.
+	*
+	* @param shape - array dimensions
+	* @param stridesX - first input array stride lengths
+	* @param stridesY - second input array stride lengths
+	* @param stridesZ - third input array stride lengths
+	* @param stridesW - fourth input array stride lengths
+	* @param stridesU - fifth input array stride lengths
+	* @param stridesV - output array stride lengths
+	* @returns loop interchange data
+	*
+	* @example
+	* var sh = [ 2, 3, 4 ];
+	*
+	* var sx = [ 12, 4, 1 ]; // row-major
+	* var sy = [ 24, 8, 1 ]; // row-major
+	* var sz = [ 12, 4, 1 ]; // row-major
+	* var sw = [ 24, 8, 1 ]; // row-major
+	* var su = [ 1, 4, 12 ]; // column-major
+	* var sv = [ 1, -2, 6 ]; // column-major
+	*
+	* var o = ns.quinaryLoopOrder( sh, sx, sy, sz, sw, su, sv );
+	* // returns {...}
+	*
+	* var ssh = o.sh;
+	* // returns [ 4, 3, 2 ]
+	*
+	* var ssx = o.sx;
+	* // returns [ 1, 4, 12 ]
+	*
+	* var ssy = o.sy;
+	* // returns [ 1, 8, 24 ]
+	*
+	* var ssz = o.sz;
+	* // returns [ 1, 4, 12 ]
+	*
+	* var ssw = o.sw;
+	* // returns [ 1, 8, 24 ]
+	*
+	* var ssu = o.su;
+	* // returns [ 12, 4, 1 ]
+	*
+	* var ssv = o.sv;
+	* // returns [ 6, -2, 1 ]
+	*/
+	quinaryLoopOrder: typeof quinaryLoopOrder;
+
+	/**
+	* Returns a loop block size for multi-dimensional array tiled loops.
+	*
+	* @param dtypeX - first input array data type
+	* @param dtypeY - second input array data type
+	* @param dtypeZ - third input array data type
+	* @param dtypeW - fourth input array data type
+	* @param dtypeU - fifth input array data type
+	* @param dtypeV - output array data type
+	* @returns block size (in units of elements)
+	*
+	* @example
+	* var bsize = ns.quinaryBlockSize( 'float64', 'float64', 'float64', 'float64', 'float64', 'float64' );
+	* // returns <number>
+	*/
+	quinaryBlockSize: typeof quinaryBlockSize;
+
+	/**
+	* Returns an array without singleton dimensions.
+	*
+	* ## Notes
+	*
+	* -   If a provided ndarray does not have any singleton dimensions, the function returns the provided ndarray unchanged.
+	* -   If a provided ndarray does have singleton dimensions, the function returns a new ndarray view.
+	*
+	* @param x - input array
+	* @returns squeezed array
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray-array' );
+	*
+	* var x = array( [ [ 1, 2 ], [ 3, 4 ] ], {
+	*     'ndmin': 5
+	* });
+	* // returns <ndarray>
+	*
+	* var shx = x.shape;
 	* // returns [ 1, 1, 1, 2, 2 ]
 	*
 	* var y = ns.removeSingletonDimensions( x );
@@ -2004,19 +3439,19 @@ interface Namespace {
 	* var ndarray = require( '@stdlib/ndarray-ctor' );
 	* var ndarray2array = require( '@stdlib/ndarray-to-array' );
 	*
-	* var buffer = [ 1, 2, 3, 4, 5, 6 ];
+	* var buffer = typedarray( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ], 'float64' );
 	* var shape = [ 3, 2 ];
 	* var strides = [ 2, 1 ];
 	* var offset = 0;
 	*
-	* var x = ndarray( 'generic', buffer, shape, strides, offset, 'row-major' );
+	* var x = ndarray( 'float64', buffer, shape, strides, offset, 'row-major' );
 	* // returns <ndarray>
 	*
 	* var sh = x.shape;
 	* // returns [ 3, 2 ]
 	*
 	* var arr = ndarray2array( x );
-	* // returns [ [ 1, 2 ], [ 3, 4 ], [ 5, 6 ] ]
+	* // returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 5.0, 6.0 ] ]
 	*
 	* var y = ns.reverse( x, false );
 	* // returns <ndarray>
@@ -2025,7 +3460,7 @@ interface Namespace {
 	* // returns [ 3, 2 ]
 	*
 	* arr = ndarray2array( y );
-	* // returns [ [ 6, 5 ], [ 4, 3 ], [ 2, 1 ] ]
+	* // returns [ [ 6.0, 5.0 ], [ 4.0, 3.0 ], [ 2.0, 1.0 ] ]
 	*/
 	reverse: typeof reverse;
 
@@ -2176,6 +3611,45 @@ interface Namespace {
 	*/
 	shape2strides: typeof shape2strides;
 
+	/**
+	* Returns an array containing a truncated view of an input ndarray and a view of the first element(s) along a specified dimension.
+	*
+	* ## Notes
+	*
+	* -   The input array must have one or more dimensions.
+	*
+	* @param x - input array
+	* @param dim - dimension along which to perform the operation
+	* @param writable - boolean indicating whether returned arrays should be writable
+	* @returns a list of ndarrays
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array-float64' );
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
+	* var ndarray2array = require( '@stdlib/ndarray-to-array' );
+	*
+	* var buffer = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+	* var shape = [ 3, 2 ];
+	* var strides = [ 2, 1 ];
+	* var offset = 0;
+	*
+	* var x = ndarray( 'float64', buffer, shape, strides, offset, 'row-major' );
+	* // returns <ndarray>
+	*
+	* var arr = ndarray2array( x );
+	* // returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 5.0, 6.0 ] ]
+	*
+	* var y = ns.shift( x, 0, false );
+	* // returns [ <ndarray>, <ndarray> ]
+	*
+	* arr = ndarray2array( y[ 0 ] );
+	* // returns [ [ 3.0, 4.0 ], [ 5.0, 6.0 ] ]
+	*
+	* arr = ndarray2array( y[ 1 ] );
+	* // returns [ [ 1.0, 2.0 ] ]
+	*/
+	shift: typeof shift;
+
 	/**
 	* Returns the number of singleton dimensions.
 	*
@@ -2206,8 +3680,8 @@ interface Namespace {
 	* @returns output array
 	*
 	* @example
-	* var Slice = require( '@stdlib/ns.slice-ctor' );
-	* var MultiSlice = require( '@stdlib/ns.slice-multi' );
+	* var Slice = require( '@stdlib/slice-ctor' );
+	* var MultiSlice = require( '@stdlib/slice-multi' );
 	* var ndarray = require( '@stdlib/ndarray-ctor' );
 	* var ndarray2array = require( '@stdlib/ndarray-to-array' );
 	*
@@ -2346,6 +3820,7 @@ interface Namespace {
 	* Returns a shifted view of an input ndarray along a specified dimension.
 	*
 	* @param x - input array
+	* @param dim - index of dimension to slice
 	* @param start - starting index (inclusive)
 	* @param strict - boolean indicating whether to enforce strict bounds checking
 	* @param writable - boolean indicating whether a returned array should be writable
@@ -2384,6 +3859,7 @@ interface Namespace {
 	* Returns a truncated view of an input ndarray along a specified dimension.
 	*
 	* @param x - input array
+	* @param dim - index of dimension to slice
 	* @param stop - ending index (exclusive)
 	* @param strict - boolean indicating whether to enforce strict bounds checking
 	* @param writable - boolean indicating whether a returned array should be writable
@@ -2496,6 +3972,125 @@ interface Namespace {
 	*/
 	sliceTo: typeof sliceTo;
 
+	/**
+	* Tests whether at least `n` elements in an ndarray are truthy.
+	*
+	* @param arrays - array-like object containing an input ndarray and a zero-dimensional ndarray specifying the minimum number of elements in the input ndarray that must be truthy
+	* @returns boolean indicating whether `n` elements pass a test
+	*
+	* @example
+	* var scalar2ndarray = require( '@stdlib/ndarray-from-scalar' );
+	* var Float64Array = require( '@stdlib/array-float64' );
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
+	*
+	* // Create a data buffer:
+	* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+	*
+	* // Define the shape of the array:
+	* var shape = [ 3, 1, 2 ];
+	*
+	* // Define the array strides:
+	* var sx = [ 4, 4, 1 ];
+	*
+	* // Define the index offset:
+	* var ox = 1;
+	*
+	* // Create the input ndarray:
+	* var x = ndarray( 'float64', xbuf, shape, sx, ox, 'row-major' );
+	* var n = scalar2ndarray( 3, {
+	*     'dtype': 'generic'
+	* });
+	*
+	* // Test elements:
+	* var out = ns.some( [ x, n ] );
+	* // returns true
+	*/
+	some: typeof some;
+
+	/**
+	* Tests whether at least `n` elements in an ndarray pass a test implemented by a predicate function.
+	*
+	* @param arrays - array-like object containing an input ndarray and a zero-dimensional ndarray specifying the minimum number of elements in the input ndarray that must satisfy the predicate function
+	* @param predicate - predicate function
+	* @param thisArg - predicate function execution context
+	* @returns boolean indicating whether `n` elements pass a test
+	*
+	* @example
+	* var scalar2ndarray = require( '@stdlib/ndarray-from-scalar' );
+	* var Float64Array = require( '@stdlib/array-float64' );
+	* var ndarray = require( '@stdlib/ndarray-base-ctor' );
+	*
+	* function predicate( value ) {
+	*    return value > 0.0;
+	* }
+	*
+	* // Create data buffers:
+	* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+	*
+	* // Define the shape of the array:
+	* var shape = [ 3, 1, 2 ];
+	*
+	* // Define the array strides:
+	* var sx = [ 4, 4, 1 ];
+	*
+	* // Define the index offset:
+	* var ox = 1;
+	*
+	* // Create the input ndarray:
+	* var x = ndarray( 'float64', xbuf, shape, sx, ox, 'row-major' );
+	* var n = scalar2ndarray( 3, {
+	*     'dtype': 'generic'
+	* });
+	*
+	* // Test elements:
+	* var out = ns.someBy( [ x, n ], predicate );
+	* // returns true
+	*/
+	someBy: typeof someBy;
+
+	/**
+	* Expands the shape of an array to a specified dimensionality by spreading its dimensions to specified dimension indices and inserting dimensions of size one for the remaining dimensions.
+	*
+	* ## Notes
+	*
+	* -   Each provided dimension index must reside on the interval `[-ndims, ndims-1]`. If provided a negative dimension index, the position at which to place a respective dimension is computed as `ndims + index`.
+	* -   Provided dimension indices must resolve to normalized dimension indices arranged in ascending order.
+	*
+	* @param ndims - number of dimensions in the output array
+	* @param x - input array
+	* @param dims - dimension indices
+	* @param writable - boolean indicating whether a returned array should be writable
+	* @returns output array
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray-array' );
+	*
+	* var x = array( [ [ 1, 2 ], [ 3, 4 ] ] );
+	* // returns <ndarray>
+	*
+	* var shx = x.shape;
+	* // returns [ 2, 2 ]
+	*
+	* var y = ns.spreadDimensions( 5, x, [ 1, 3 ], false );
+	* // returns <ndarray>
+	*
+	* var shy = y.shape;
+	* // returns [ 1, 2, 1, 2, 1 ]
+	*
+	* var v = y.get( 0, 0, 0, 0, 0 );
+	* // returns 1
+	*
+	* v = y.get( 0, 0, 0, 1, 0 );
+	* // returns 2
+	*
+	* v = y.get( 0, 1, 0, 0, 0 );
+	* // returns 3
+	*
+	* v = y.get( 0, 1, 0, 1, 0 );
+	* // returns 4
+	*/
+	spreadDimensions: typeof spreadDimensions;
+
 	/**
 	* Returns the stride along a specified dimension for a provided ndarray.
 	*
@@ -2638,66 +4233,398 @@ interface Namespace {
 	*     idx = sub2ind( shape, strides, 0, 1, 0, mode );
 	*     // returns 2
 	*
-	*     idx = sub2ind( shape, strides, 0, 1, 1, mode );
-	*     // returns 3
+	*     idx = sub2ind( shape, strides, 0, 1, 1, mode );
+	*     // returns 3
+	*
+	*     // From the perspective of an underlying buffer...
+	*     idx = sub2ind( shape, strides, offset, 0, 0, mode );
+	*     // returns 2
+	*
+	*     idx = sub2ind( shape, strides, offset, 0, 1, mode );
+	*     // returns 3
+	*
+	*     idx = sub2ind( shape, strides, offset, 1, 0, mode );
+	*     // returns 0
+	*
+	*     idx = sub2ind( shape, strides, offset, 1, 1, mode );
+	*     // returns 1
+	*     ```
+	*
+	*     In short, from the perspective of a view, view data is always ordered.
+	*
+	*
+	* @param shape - array shape
+	* @param strides - stride array
+	* @param offset - location of the first indexed value **based** on the stride array
+	* @param args - subscripts followed by a `mode` specifying how to handle subscripts which exceed array dimensions
+	* @param mode - specifies how to handle subscripts which exceed array dimensions
+	* @throws must provide subscripts which do not exceed array dimensions
+	* @returns linear index
+	*
+	* @example
+	* var shape = [ 3, 3, 3 ];
+	* var strides = [ 9, 3, 1 ];
+	* var offset = 0;
+	* var mode = [ 'throw' ];
+	*
+	* var idx = ns.sub2ind( shape, strides, offset, 1, 2, 2, mode );
+	* // returns 17
+	*/
+	sub2ind: typeof sub2ind;
+
+	/**
+	* Applies a ternary callback to elements in input ndarrays and assigns results to elements in an output ndarray.
+	*
+	* @param arrays - array-like object containing three input ndarrays and one output ndarray
+	* @param fcn - ternary callback
+	* @throws arrays must have the same number of dimensions
+	* @throws arrays must have the same shape
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array-float64' );
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
+	* var getData = require( '@stdlib/ndarray-data-buffer' );
+	* var add3 = require( '@stdlib/number-float64-base-add3' );
+	*
+	* // Create data buffers:
+	* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+	* var ybuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+	* var zbuf = new Float64Array( [ 0.5, 0.5, 0.5, 0.5, 0.5, 0.5 ] );
+	* var wbuf = new Float64Array( 6 );
+	*
+	* // Define the shape of the input and output arrays:
+	* var shape = [ 3, 1, 2 ];
+	*
+	* // Define the array strides:
+	* var sx = [ 2, 2, 1 ];
+	* var sy = [ 2, 2, 1 ];
+	* var sz = [ 2, 2, 1 ];
+	* var sw = [ 2, 2, 1 ];
+	*
+	* // Define the index offsets:
+	* var ox = 0;
+	* var oy = 0;
+	* var oz = 0;
+	* var ow = 0;
+	*
+	* // Create the input and output ndarrays:
+	* var x = new ndarray( 'float64', xbuf, shape, sx, ox, 'row-major' );
+	* var y = new ndarray( 'float64', ybuf, shape, sy, oy, 'row-major' );
+	* var z = new ndarray( 'float64', zbuf, shape, sz, oz, 'row-major' );
+	* var w = new ndarray( 'float64', wbuf, shape, sw, ow, 'row-major' );
+	*
+	* // Apply the ns.ternary function:
+	* ns.ternary( [ x, y, z, w ], add3 );
+	*
+	* console.log( getData( w ) );
+	* // => <Float64Array>[ 2.5, 4.5, 6.5, 8.5, 10.5, 12.5 ]
+	*/
+	ternary: typeof ternary;
+
+	/**
+	* Reorders ndarray dimensions and associated strides for loop interchange.
+	*
+	* ## Notes
+	*
+	* -   The returned object has the following properties:
+	*
+	*     -   **sh**: dimensions sorted in loop order.
+	*     -   **sx**: first input ndarray strides sorted in loop order.
+	*     -   **sy**: second input ndarray strides sorted in loop order.
+	*     -   **sz**: third input ndarray strides sorted in loop order.
+	*     -   **sw**: output ndarray strides sorted in loop order.
+	*
+	* -   When iterating over the elements of a multi-dimensional array, accessing elements which are closer in memory can improve performance. To this end, loop interchange is a technique used in loop nest optimization to improve locality of reference and take advantage of CPU cache.
+	*
+	*     The purpose of this function is to order ndarray dimensions according to the magnitude of array strides. By using the ordered dimensions and associated strides, one can construct nested loops (one for each dimension) such that the innermost loop iterates over the dimension in which array elements are closest in memory and the outermost loop iterates over the dimension in which array elements are farthest apart in memory. As a consequence, element iteration is optimized to minimize cache misses and ensure locality of reference.
+	*
+	* -   Cache performance may be degraded if the layout order (i.e., row-major or column-major) differs for the input and output ndarrays. This function is intended to optimize cache performance for the most common layout order. Accordingly, if the output ndarray has a different layout order (e.g., if the input ndarrays are row-major and the output ndarray is column-major), cache misses are likely for the output ndarray. In general, to ensure best performance, input and output ndarrays should have the same layout order.
+	*
+	* -   The function assumes that the input and output ndarrays have the same shape. Hence, loop interchange order should only be determined **after** broadcasting.
+	*
+	* @param shape - array dimensions
+	* @param stridesX - first input array stride lengths
+	* @param stridesY - second input array stride lengths
+	* @param stridesZ - third input array stride lengths
+	* @param stridesW - output array stride lengths
+	* @returns loop interchange data
+	*
+	* @example
+	* var sh = [ 2, 3, 4 ];
+	*
+	* var sx = [ 12, 4, 1 ]; // row-major
+	* var sy = [ 24, 8, 1 ]; // row-major
+	* var sz = [ 1, 4, 12 ]; // column-major
+	* var sw = [ 1, -2, 6 ]; // column-major
+	*
+	* var o = ns.ternaryLoopOrder( sh, sx, sy, sz, sw );
+	* // returns {...}
+	*
+	* var ssh = o.sh;
+	* // returns [ 2, 3, 4 ]
+	*
+	* var ssx = o.sx;
+	* // returns [ 12, 4, 1 ]
+	*
+	* var ssy = o.sy;
+	* // returns [ 24, 8, 1 ]
+	*
+	* var ssz = o.sz;
+	* // returns [ 1, 4, 12 ]
+	*
+	* var ssw = o.sw;
+	* // returns [ 1, -2, 6 ]
+	*/
+	ternaryLoopOrder: typeof ternaryLoopOrder;
+
+	/**
+	* Resolves the output ndarray data type for a ternary function.
+	*
+	* @param xdtype - first input ndarray data type
+	* @param ydtype - second input ndarray data type
+	* @param zdtype - third input ndarray data type
+	* @param policy - output ndarray data type policy
+	* @returns output ndarray data type
+	*
+	* @example
+	* var dt = ns.ternaryOutputDataType( 'float64', 'float32', 'float32', 'complex_floating_point' );
+	* // returns <DataType>
+	*/
+	ternaryOutputDataType: typeof ternaryOutputDataType;
+
+	/**
+	* Returns a loop block size for multi-dimensional array tiled loops.
+	*
+	* @param dtypeX - first input array data type
+	* @param dtypeY - second input array data type
+	* @param dtypeZ - third input array data type
+	* @param dtypeW - output array data type
+	* @returns block size (in units of elements)
+	*
+	* @example
+	* var bsize = ns.ternaryBlockSize( 'float64', 'float64', 'float64', 'float64' );
+	* // returns <number>
+	*/
+	ternaryBlockSize: typeof ternaryBlockSize;
+
+	/**
+	* Returns a loop block size for multi-dimensional array tiled loops.
+	*
+	* @param dtypes - list of input and output ndarray data types
+	* @returns block size (in units of elements)
+	*
+	* @example
+	* var bsize = ns.blockSize( [ 'float64', 'float64', 'float64', 'float64' ] );
+	* // returns <number>
+	*/
+	blockSize: typeof blockSize;
+
+	/**
+	* Converts an ndarray buffer to a generic array (which may include nested arrays).
+	*
+	* @param buffer - data buffer
+	* @param shape - array shape
+	* @param strides - array strides
+	* @param offset - index offset
+	* @param order - specifies whether an array is row-major (C-style) or column-major (Fortran-style)
+	* @returns array (which may include nested arrays)
+	*
+	* @example
+	* var buffer = [ 1, 2, 3, 4 ];
+	* var shape = [ 2, 2 ];
+	* var order = 'row-major';
+	* var strides = [ 2, 1 ];
+	* var offset = 0;
+	*
+	* var out = ns.ndarray2array( buffer, shape, strides, offset, order );
+	* // returns [ [ 1, 2 ], [ 3, 4 ] ]
+	*/
+	ndarray2array: typeof ndarray2array;
+
+	/**
+	* Returns a new ndarray where the order of elements along the last dimension of an input ndarray is reversed.
+	*
+	* @param x - input array
+	* @returns output array
+	*
+	* @example
+	* var typedarray = require( '@stdlib/array-typed' );
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
+	* var ndarray2array = require( '@stdlib/ndarray-to-array' );
+	*
+	* var buffer = typedarray( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ], 'float64' );
+	* var shape = [ 3, 2 ];
+	* var strides = [ 2, 1 ];
+	* var offset = 0;
+	*
+	* var x = ndarray( 'float64', buffer, shape, strides, offset, 'row-major' );
+	* // returns <ndarray>
+	*
+	* var sh = x.shape;
+	* // returns [ 3, 2 ]
+	*
+	* var arr = ndarray2array( x );
+	* // returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 5.0, 6.0 ] ]
+	*
+	* var y = ns.toFlippedlr( x );
+	* // returns <ndarray>
+	*
+	* sh = y.shape;
+	* // returns [ 3, 2 ]
+	*
+	* arr = ndarray2array( y );
+	* // returns [ [ 2.0, 1.0 ], [ 4.0, 3.0 ], [ 6.0, 5.0 ] ]
+	*/
+	toFlippedlr: typeof toFlippedlr;
+
+	/**
+	* Returns a new ndarray where the order of elements along the second-to-last dimension of an input ndarray is reversed.
+	*
+	* @param x - input array
+	* @returns output array
+	*
+	* @example
+	* var typedarray = require( '@stdlib/array-typed' );
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
+	* var ndarray2array = require( '@stdlib/ndarray-to-array' );
+	*
+	* var buffer = typedarray( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ], 'float64' );
+	* var shape = [ 3, 2 ];
+	* var strides = [ 2, 1 ];
+	* var offset = 0;
+	*
+	* var x = ndarray( 'float64', buffer, shape, strides, offset, 'row-major' );
+	* // returns <ndarray>
+	*
+	* var sh = x.shape;
+	* // returns [ 3, 2 ]
+	*
+	* var arr = ndarray2array( x );
+	* // returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 5.0, 6.0 ] ]
+	*
+	* var y = ns.toFlippedud( x );
+	* // returns <ndarray>
+	*
+	* sh = y.shape;
+	* // returns [ 3, 2 ]
+	*
+	* arr = ndarray2array( y );
+	* // returns [ [ 5.0, 6.0 ], [ 3.0, 4.0 ], [ 1.0, 2.0 ] ]
+	*/
+	toFlippedud: typeof toFlippedud;
+
+	/**
+	* Normalizes a list of indices to the interval `[0,max]`.
+	*
+	* ## Notes
+	*
+	* -   If provided an out-of-bounds index, the function normalizes the index to `-1`.
+	*
+	* @param indices - indices
+	* @param max - maximum index
+	* @returns normalized indices
+	*
+	* @example
+	* var indices = ns.toNormalizedIndices( [ -2, 5 ], 10 );
+	* // returns [ 9, 5 ]
+	*
+	* indices = ns.toNormalizedIndices( [ -2, 15 ], 10 );
+	* // returns [ 9, -1 ]
+	*/
+	toNormalizedIndices: typeof toNormalizedIndices;
+
+	/**
+	* Returns a new ndarray where the order of elements of an input ndarray is reversed along each dimension.
+	*
+	* @param x - input array
+	* @returns output array
+	*
+	* @example
+	* var typedarray = require( '@stdlib/array-typed' );
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
+	* var ndarray2array = require( '@stdlib/ndarray-to-array' );
+	*
+	* var buffer = typedarray( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ], 'float64' );
+	* var shape = [ 3, 2 ];
+	* var strides = [ 2, 1 ];
+	* var offset = 0;
+	*
+	* var x = ndarray( 'float64', buffer, shape, strides, offset, 'row-major' );
+	* // returns <ndarray>
+	*
+	* var sh = x.shape;
+	* // returns [ 3, 2 ]
+	*
+	* var arr = ndarray2array( x );
+	* // returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 5.0, 6.0 ] ]
+	*
+	* var y = ns.toReversed( x );
+	* // returns <ndarray>
+	*
+	* sh = y.shape;
+	* // returns [ 3, 2 ]
+	*
+	* arr = ndarray2array( y );
+	* // returns [ [ 6.0, 5.0 ], [ 4.0, 3.0 ], [ 2.0, 1.0 ] ]
+	*/
+	toReversed: typeof toReversed;
+
+	/**
+	* Returns a new ndarray where the order of elements of an input ndarray along a specified dimension is reversed.
 	*
-	*     // From the perspective of an underlying buffer...
-	*     idx = sub2ind( shape, strides, offset, 0, 0, mode );
-	*     // returns 2
+	* @param x - input array
+	* @param dim - index of dimension to reverse
+	* @returns output array
 	*
-	*     idx = sub2ind( shape, strides, offset, 0, 1, mode );
-	*     // returns 3
+	* @example
+	* var typedarray = require( '@stdlib/array-typed' );
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
+	* var ndarray2array = require( '@stdlib/ndarray-to-array' );
 	*
-	*     idx = sub2ind( shape, strides, offset, 1, 0, mode );
-	*     // returns 0
+	* var buffer = typedarray( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ], 'float64' );
+	* var shape = [ 3, 2 ];
+	* var strides = [ 2, 1 ];
+	* var offset = 0;
 	*
-	*     idx = sub2ind( shape, strides, offset, 1, 1, mode );
-	*     // returns 1
-	*     ```
+	* var x = ndarray( 'float64', buffer, shape, strides, offset, 'row-major' );
+	* // returns <ndarray>
 	*
-	*     In short, from the perspective of a view, view data is always ordered.
+	* var sh = x.shape;
+	* // returns [ 3, 2 ]
 	*
+	* var arr = ndarray2array( x );
+	* // returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 5.0, 6.0 ] ]
 	*
-	* @param shape - array shape
-	* @param strides - stride array
-	* @param offset - location of the first indexed value **based** on the stride array
-	* @param args - subscripts followed by a `mode` specifying how to handle subscripts which exceed array dimensions
-	* @param mode - specifies how to handle subscripts which exceed array dimensions
-	* @throws must provide subscripts which do not exceed array dimensions
-	* @returns linear index
+	* var y = ns.toReversedDimension( x, 0 );
+	* // returns <ndarray>
 	*
-	* @example
-	* var shape = [ 3, 3, 3 ];
-	* var strides = [ 9, 3, 1 ];
-	* var offset = 0;
-	* var mode = [ 'throw' ]
+	* sh = y.shape;
+	* // returns [ 3, 2 ]
 	*
-	* var idx = ns.sub2ind( shape, strides, offset, 1, 2, 2, mode );
-	* // returns 17
+	* arr = ndarray2array( y );
+	* // returns [ [ 5.0, 6.0 ], [ 3.0, 4.0 ], [ 1.0, 2.0 ] ]
 	*/
-	sub2ind: typeof sub2ind;
+	toReversedDimension: typeof toReversedDimension;
 
 	/**
-	* Converts an ndarray buffer to a generic array (which may include nested arrays).
+	* Returns a list of unique indices after normalizing to the interval `[0,max]`.
 	*
-	* @param buffer - data buffer
-	* @param shape - array shape
-	* @param strides - array strides
-	* @param offset - index offset
-	* @param order - specifies whether an array is row-major (C-style) or column-major (Fortran-style)
-	* @returns array (which may include nested arrays)
+	* ## Notes
+	*
+	* -   If provided an out-of-bounds index, the function returns `null`.
+	*
+	* @param indices - indices
+	* @param max - maximum index
+	* @returns normalized indices (or null)
 	*
 	* @example
-	* var buffer = [ 1, 2, 3, 4 ];
-	* var shape = [ 2, 2 ];
-	* var order = 'row-major';
-	* var strides = [ 2, 1 ];
-	* var offset = 0;
+	* var indices = ns.toUniqueNormalizedIndices( [ -2, 5 ], 10 );
+	* // returns [ 9, 5 ]
 	*
-	* var out = ns.ndarray2array( buffer, shape, strides, offset, order );
-	* // returns [ [ 1, 2 ], [ 3, 4 ] ]
+	* indices = ns.toUniqueNormalizedIndices( [ -2, 15 ], 10 );
+	* // returns null
 	*/
-	ndarray2array: typeof ndarray2array;
+	toUniqueNormalizedIndices: typeof toUniqueNormalizedIndices;
 
 	/**
 	* Transposes a matrix (or a stack of matrices).
@@ -2773,6 +4700,80 @@ interface Namespace {
 	*/
 	unary: typeof unary;
 
+	/**
+	* Performs a reduction over elements in an ndarray.
+	*
+	* @param arrays - array-like object containing one input ndarray
+	* @param initial - initial value
+	* @param clbk - callback function
+	* @returns accumulated result
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array-float64' );
+	*
+	* function add( acc, x ) {
+	*     return acc + x;
+	* }
+	*
+	* // Create a data buffer:
+	* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+	*
+	* // Define the shape of the input array:
+	* var shape = [ 3, 1, 2 ];
+	*
+	* // Define the array strides:
+	* var sx = [ 4, 4, 1 ];
+	*
+	* // Define the index offset:
+	* var ox = 1;
+	*
+	* // Create the input ndarray-like object:
+	* var x = {
+	*     'dtype': 'float64',
+	*     'data': xbuf,
+	*     'shape': shape,
+	*     'strides': sx,
+	*     'offset': ox,
+	*     'order': 'row-major'
+	* };
+	*
+	* // Compute the sum:
+	* var v = ns.unaryAccumulate( [ x ], 0.0, add );
+	* // returns 39.0
+	*/
+	unaryAccumulate: typeof unaryAccumulate;
+
+	/**
+	* Returns a function which dispatches to a native add-on applying a unary function to an input ndarray.
+	*
+	* @param addon - add-on function
+	* @param fallback - fallback function
+	* @returns dispatch function
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray-array' );
+	* var zeros = require( '@stdlib/ndarray-zeros' );
+	*
+	* function addon( x, metaX, y, metaY ) {
+	*     // Call into native add-on...
+	* }
+	*
+	* function fallback( x, y ) {
+	*     // Fallback JavaScript implementation...
+	* }
+	*
+	* // Create a ns.unaryAddonDispatch function:
+	* var f = ns.unaryAddonDispatch( addon, fallback );
+	*
+	* // ...
+	*
+	* // Invoke the ns.unaryAddonDispatch function with ndarray arguments:
+	* var x = array( [ [ 1, 2], [ 3, 4 ] ] );
+	* var y = zeros( [ 2, 2 ] );
+	* f( x, y );
+	*/
+	unaryAddonDispatch: typeof unaryAddonDispatch;
+
 	/**
 	* Applies a unary function to elements in an ndarray and assigns results to elements in an ndarray.
 	*
@@ -2784,7 +4785,7 @@ interface Namespace {
 	* @throws arrays must have the same shape
 	*
 	* @example
-	* var identity = require( '@stdlib/math-base-special-identity' );
+	* var identity = require( '@stdlib/number-float64-base-identity' );
 	* var Float64Array = require( '@stdlib/array-float64' );
 	* var ndarray = require( '@stdlib/ndarray-ctor' );
 	*
@@ -2819,6 +4820,20 @@ interface Namespace {
 	*/
 	unaryBy: typeof unaryBy;
 
+	/**
+	* Resolves the input ndarray casting data type for a unary function.
+	*
+	* @param idtype - input ndarray data type
+	* @param odtype - output ndarray data type
+	* @param policy - input ndarray casting data type policy
+	* @returns input ndarray casting data type
+	*
+	* @example
+	* var dt = ns.unaryInputCastingDataType( 'float64', 'float64', 'none' );
+	* // returns <string>
+	*/
+	unaryInputCastingDataType: typeof unaryInputCastingDataType;
+
 	/**
 	* Reorders ndarray dimensions and associated strides for loop interchange.
 	*
@@ -2829,6 +4844,7 @@ interface Namespace {
 	*     -   **sh**: dimensions sorted in loop order.
 	*     -   **sx**: input ndarray strides sorted in loop order.
 	*     -   **sy**: output ndarray strides sorted in loop order.
+	*     -   **idx**: dimension indices sorted in loop order.
 	*
 	* -   When iterating over the elements of a multi-dimensional array, accessing elements which are closer in memory can improve performance. To this end, loop interchange is a technique used in loop nest optimization to improve locality of reference and take advantage of CPU cache.
 	*
@@ -2838,9 +4854,9 @@ interface Namespace {
 	*
 	* -   The function assumes that the input and output ndarrays have the same shape. Hence, loop interchange order should only be determined **after** broadcasting.
 	*
-	* @param sh - array dimensions
-	* @param sx - input array stride lengths
-	* @param sy - output array stride lengths
+	* @param shape - array dimensions
+	* @param stridesX - input array stride lengths
+	* @param stridesY - output array stride lengths
 	* @returns loop interchange data
 	*
 	* @example
@@ -2860,6 +4876,9 @@ interface Namespace {
 	*
 	* var ssy = o.sy;
 	* // returns [ 6, -2, 1 ]
+	*
+	* var idx = o.idx;
+	* // returns [ 2, 1, 0 ]
 	*/
 	unaryLoopOrder: typeof unaryLoopOrder;
 
@@ -2872,10 +4891,308 @@ interface Namespace {
 	*
 	* @example
 	* var dt = ns.unaryOutputDataType( 'float64', 'complex_floating_point' );
-	* // returns <string>
+	* // returns <DataType>
 	*/
 	unaryOutputDataType: typeof unaryOutputDataType;
 
+	/**
+	* Constructor for performing a reduction on an input ndarray.
+	*
+	* @param table - dispatch table
+	* @param idtypes - list containing lists of supported input data types for each ndarray argument
+	* @param odtypes - list of supported output data types
+	* @param policies - dispatch policies
+	* @returns instance
+	*
+	* @example
+	* var base = require( '@stdlib/stats-base-ndarray-max' );
+	* var dtypes = require( '@stdlib/ndarray-dtypes' );
+	* var ndarray = require( '@stdlib/ndarray-base-ctor' );
+	*
+	* var idt = dtypes( 'real_and_generic' );
+	* var odt = idt;
+	* var policies = {
+	*     'output': 'same',
+	*     'casting': 'none'
+	* };
+	*
+	* var table = {
+	*     'default': base
+	* };
+	* var max = new ns.unaryReduceStrided1dDispatch( table, [ idt ], odt, policies );
+	*
+	* var xbuf = [ -1.0, 2.0, -3.0 ];
+	* var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+	*
+	* var y = max.apply( x );
+	* // returns <ndarray>
+	*
+	* var v = y.get();
+	* // returns 2.0
+	*/
+	unaryReduceStrided1dDispatch: typeof unaryReduceStrided1dDispatch;
+
+	/**
+	* Constructor for performing a reduction on an input ndarray according to a callback function.
+	*
+	* @param table - dispatch table
+	* @param idtypes - list containing lists of supported input data types for each ndarray argument
+	* @param odtypes - list of supported output data types
+	* @param policies - dispatch policies
+	* @returns instance
+	*
+	* @example
+	* var base = require( '@stdlib/stats-base-ndarray-max-by' );
+	* var dtypes = require( '@stdlib/ndarray-dtypes' );
+	* var ndarray = require( '@stdlib/ndarray-base-ctor' );
+	*
+	* var idt = dtypes( 'real_and_generic' );
+	* var odt = idt;
+	* var policies = {
+	*     'output': 'same',
+	*     'casting': 'none'
+	* };
+	*
+	* var table = {
+	*     'default': base
+	* };
+	* var maxBy = new ns.unaryReduceStrided1dDispatchBy( table, [ idt ], odt, policies );
+	*
+	* var xbuf = [ -1.0, 2.0, -3.0 ];
+	* var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+	*
+	* function clbk( v ) {
+	*     return v * 2.0;
+	* }
+	*
+	* var y = maxBy.apply( x, clbk );
+	* // returns <ndarray>
+	*
+	* var v = y.get();
+	* // returns 4.0
+	*/
+	unaryReduceStrided1dDispatchBy: typeof unaryReduceStrided1dDispatchBy;
+
+	/**
+	* Creates a function for performing a reduction on a provided ndarray according to a callback function.
+	*
+	* @param table - dispatch table
+	* @param idtypes - list containing lists of supported input data types for each ndarray argument
+	* @param odtypes - list of supported output data types
+	* @param policies - dispatch policies
+	* @returns function for applying a unary function
+	*
+	* @example
+	* var base = require( '@stdlib/stats-base-ndarray-max-by' );
+	* var dtypes = require( '@stdlib/ndarray-dtypes' );
+	* var ndarray = require( '@stdlib/ndarray-base-ctor' );
+	*
+	* var idt = dtypes( 'real_and_generic' );
+	* var odt = idt;
+	* var policies = {
+	*     'output': 'same',
+	*     'casting': 'none'
+	* };
+	*
+	* var table = {
+	*     'default': base
+	* };
+	* var maxBy = ns.unaryReduceStrided1dDispatchByFactory( table, [ idt ], odt, policies );
+	*
+	* var xbuf = [ -1.0, 2.0, -3.0 ];
+	* var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+	*
+	* function clbk( v ) {
+	*     return v * 2.0;
+	* }
+	*
+	* var y = maxBy( x, clbk );
+	* // returns <ndarray>
+	*
+	* var v = y.get();
+	* // returns 4.0
+	*/
+	unaryReduceStrided1dDispatchByFactory: typeof unaryReduceStrided1dDispatchByFactory;
+
+	/**
+	* Creates a function for performing a reduction on a provided ndarray.
+	*
+	* @param table - dispatch table
+	* @param idtypes - list containing lists of supported input data types for each ndarray argument
+	* @param odtypes - list of supported output data types
+	* @param policies - dispatch policies
+	* @returns function for applying a unary function
+	*
+	* @example
+	* var base = require( '@stdlib/stats-base-ndarray-max' );
+	* var dtypes = require( '@stdlib/ndarray-dtypes' );
+	* var ndarray = require( '@stdlib/ndarray-base-ctor' );
+	*
+	* var idt = dtypes( 'real_and_generic' );
+	* var odt = idt;
+	* var policies = {
+	*     'output': 'same',
+	*     'casting': 'none'
+	* };
+	*
+	* var table = {
+	*     'default': base
+	* };
+	* var max = ns.unaryReduceStrided1dDispatchFactory( table, [ idt ], odt, policies );
+	*
+	* var xbuf = [ -1.0, 2.0, -3.0 ];
+	* var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+	*
+	* var y = max( x );
+	* // returns <ndarray>
+	*
+	* var v = y.get();
+	* // returns 2.0
+	*/
+	unaryReduceStrided1dDispatchFactory: typeof unaryReduceStrided1dDispatchFactory;
+
+	/**
+	* Performs a reduction over a list of specified dimensions in an input ndarray according to a callback function and assigns results to a provided output ndarray.
+	*
+	* @param fcn - reduction function
+	* @param arrays - array-like object containing ndarrays
+	* @param dims - list of dimensions over which to perform a reduction
+	* @param options - function options
+	* @param clbk - callback function
+	* @param thisArg - callback execution context
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array-float64' );
+	* var filled = require( '@stdlib/array-base-filled' );
+	* var ndarray2array = require( '@stdlib/ndarray-base-to-array' );
+	* var everyBy = require( '@stdlib/ndarray-base-every-by' );
+	*
+	* function clbk( value ) {
+	*     return value > 0.0;
+	* }
+	*
+	* // Create data buffers:
+	* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 0.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+	* var ybuf = filled( false, 3 );
+	*
+	* // Define the array shapes:
+	* var xsh = [ 1, 3, 2, 2 ];
+	* var ysh = [ 1, 3 ];
+	*
+	* // Define the array strides:
+	* var sx = [ 12, 4, 2, 1 ];
+	* var sy = [ 3, 1 ];
+	*
+	* // Define the index offsets:
+	* var ox = 0;
+	* var oy = 0;
+	*
+	* // Create an input ndarray-like object:
+	* var x = {
+	*     'dtype': 'float64',
+	*     'data': xbuf,
+	*     'shape': xsh,
+	*     'strides': sx,
+	*     'offset': ox,
+	*     'order': 'row-major'
+	* };
+	*
+	* // Create an output ndarray-like object:
+	* var y = {
+	*     'dtype': 'generic',
+	*     'data': ybuf,
+	*     'shape': ysh,
+	*     'strides': sy,
+	*     'offset': oy,
+	*     'order': 'row-major'
+	* };
+	*
+	* // Perform a reduction:
+	* ns.unaryReduceSubarrayBy( everyBy, [ x, y ], [ 2, 3 ], clbk );
+	*
+	* var arr = ndarray2array( y.data, y.shape, y.strides, y.offset, y.order );
+	* // returns [ [ true, false, true ] ]
+	*/
+	unaryReduceSubarrayBy: typeof unaryReduceSubarrayBy;
+
+	/**
+	* Constructor for applying a strided function to an input ndarray.
+	*
+	* @param table - dispatch table
+	* @param idtypes - list containing lists of supported input data types for each ndarray argument
+	* @param odtypes - list of supported output data types
+	* @param policies - dispatch policies
+	* @param options - function options
+	* @returns instance
+	*
+	* @example
+	* var base = require( '@stdlib/stats-base-ndarray-cumax' );
+	* var dtypes = require( '@stdlib/ndarray-dtypes' );
+	* var ndarray2array = require( '@stdlib/ndarray-to-array' );
+	* var ndarray = require( '@stdlib/ndarray-base-ctor' );
+	*
+	* var idt = dtypes( 'real_and_generic' );
+	* var odt = idt;
+	* var policies = {
+	*     'output': 'same',
+	*     'casting': 'none'
+	* };
+	*
+	* var table = {
+	*     'default': base
+	* };
+	* var cumax = new ns.unaryStrided1dDispatch( table, [ idt ], odt, policies );
+	*
+	* var xbuf = [ -1.0, 2.0, -3.0 ];
+	* var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+	*
+	* var y = cumax.apply( x );
+	* // returns <ndarray>
+	*
+	* var arr = ndarray2array( y );
+	* // returns [ -1.0, 2.0, 2.0 ]
+	*/
+	unaryStrided1dDispatch: typeof unaryStrided1dDispatch;
+
+	/**
+	* Creates a function for applying a strided function to a provided ndarray.
+	*
+	* @param table - dispatch table
+	* @param idtypes - list containing lists of supported input data types for each ndarray argument
+	* @param odtypes - list of supported output data types
+	* @param policies - dispatch policies
+	* @param options - function options
+	* @returns function for applying a unary function
+	*
+	* @example
+	* var base = require( '@stdlib/stats-base-ndarray-cumax' );
+	* var dtypes = require( '@stdlib/ndarray-dtypes' );
+	* var ndarray2array = require( '@stdlib/ndarray-to-array' );
+	* var ndarray = require( '@stdlib/ndarray-base-ctor' );
+	*
+	* var idt = dtypes( 'real_and_generic' );
+	* var odt = idt;
+	* var policies = {
+	*     'output': 'same',
+	*     'casting': 'none'
+	* };
+	*
+	* var table = {
+	*     'default': base
+	* };
+	* var cumax = ns.unaryStrided1dDispatchFactory( table, [ idt ], odt, policies );
+	*
+	* var xbuf = [ -1.0, 2.0, -3.0 ];
+	* var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+	*
+	* var y = cumax( x );
+	* // returns <ndarray>
+	*
+	* var arr = ndarray2array( y );
+	* // returns [ -1.0, 2.0, 2.0 ]
+	*/
+	unaryStrided1dDispatchFactory: typeof unaryStrided1dDispatchFactory;
+
 	/**
 	* Returns a loop block size for multi-dimensional array tiled loops.
 	*
@@ -2980,6 +5297,56 @@ interface Namespace {
 	* // returns 'generic'
 	*/
 	zerosLike: typeof zerosLike;
+
+	/**
+	* Zips one or more one-dimensional ndarrays to an array of composite views.
+	*
+	* ## Notes
+	*
+	* -   The function assumes that the list of ndarrays to be zipped all have the same length.
+	* -   The list of provided labels should equal the number of ndarrays to be zipped.
+	* -   Each view in the returned array shares the same memory as the corresponding elements in the input ndarrays. Accordingly, mutation of either an input ndarray or a view will mutate the other.
+	*
+	* @param arrays - list of ndarrays to be zipped
+	* @param labels - list of labels
+	* @returns output array
+	*
+	* @example
+	* var array2ndarray = require( '@stdlib/ndarray-base-from-array' );
+	*
+	* var x = array2ndarray( [ 1, 2, 3 ], 'row-major' );
+	* var y = array2ndarray( [ 'a', 'b', 'c' ], 'row-major' );
+	*
+	* var labels = [ 'x', 'y' ];
+	*
+	* var z = ns.zip2views1d( [ x, y ], labels );
+	* // returns [ <Object>, <Object>, <Object> ]
+	*
+	* var v0 = z[ 0 ].toJSON();
+	* // returns { 'x': 1, 'y': 'a' }
+	*
+	* var v1 = z[ 1 ].toJSON();
+	* // returns { 'x': 2, 'y': 'b' }
+	*
+	* var v2 = z[ 2 ].toJSON();
+	* // returns { 'x': 3, 'y': 'c' }
+	*
+	* // Mutate one of the input arrays:
+	* x.set( 0, 5 );
+	*
+	* v0 = z[ 0 ].toJSON();
+	* // returns { 'x': 5, 'y': 'a' }
+	*
+	* // Set a view property:
+	* z[ 1 ].y = 'beep';
+	*
+	* v1 = z[ 1 ].toJSON();
+	* // returns { 'x': 2, 'y': 'beep' }
+	*
+	* var v = y.get( 1 );
+	* // returns 'beep'
+	*/
+	zip2views1d: typeof zip2views1d;
 }
 
 /**