@stdlib/ndarray-base 0.0.6 → 0.1.0

package/docs/types/index.d.ts

@@ -16,32 +16,58 @@
 * limitations under the License.
 */
 
-// TypeScript Version: 2.0
+// TypeScript Version: 4.1
 
 /* tslint:disable:max-line-length */
 /* tslint:disable:max-file-line-count */
 
 import assert = require( '@stdlib/ndarray-base-assert' );
+import binaryLoopOrder = require( '@stdlib/ndarray-base-binary-loop-interchange-order' );
+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 broadcastScalar = require( '@stdlib/ndarray-base-broadcast-scalar' );
 import broadcastShapes = require( '@stdlib/ndarray-base-broadcast-shapes' );
 import buffer = require( '@stdlib/ndarray-base-buffer' );
 import bufferCtors = require( '@stdlib/ndarray-base-buffer-ctors' );
 import bufferDataType = require( '@stdlib/ndarray-base-buffer-dtype' );
 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 ndarray = require( '@stdlib/ndarray-base-ctor' );
 import dtypeChar = require( '@stdlib/ndarray-base-dtype-char' );
+import dtypeDesc = require( '@stdlib/ndarray-base-dtype-desc' );
+import dtypeEnum2Str = require( '@stdlib/ndarray-base-dtype-enum2str' );
+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 dtype2c = require( '@stdlib/ndarray-base-dtype2c' );
 import dtypes2signatures = require( '@stdlib/ndarray-base-dtypes2signatures' );
+import empty = require( '@stdlib/ndarray-base-empty' );
+import emptyLike = require( '@stdlib/ndarray-base-empty-like' );
+import expandDimensions = require( '@stdlib/ndarray-base-expand-dimensions' );
+import scalar2ndarray = require( '@stdlib/ndarray-base-from-scalar' );
 import ind = require( '@stdlib/ndarray-base-ind' );
 import ind2sub = require( '@stdlib/ndarray-base-ind2sub' );
 import iterationOrder = require( '@stdlib/ndarray-base-iteration-order' );
 import maxViewBufferIndex = require( '@stdlib/ndarray-base-max-view-buffer-index' );
+import maybeBroadcastArray = require( '@stdlib/ndarray-base-maybe-broadcast-array' );
+import metaDataProps = require( '@stdlib/ndarray-base-meta-data-props' );
 import minViewBufferIndex = require( '@stdlib/ndarray-base-min-view-buffer-index' );
 import minmaxViewBufferIndex = require( '@stdlib/ndarray-base-minmax-view-buffer-index' );
+import ndarraylike2object = require( '@stdlib/ndarray-base-ndarraylike2object' );
 import nonsingletonDimensions = require( '@stdlib/ndarray-base-nonsingleton-dimensions' );
+import nullary = require( '@stdlib/ndarray-base-nullary' );
+import nullaryLoopOrder = require( '@stdlib/ndarray-base-nullary-loop-interchange-order' );
+import nullaryBlockSize = require( '@stdlib/ndarray-base-nullary-tiling-block-size' );
 import numel = require( '@stdlib/ndarray-base-numel' );
+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 prependSingletonDimensions = require( '@stdlib/ndarray-base-prepend-singleton-dimensions' );
+import removeSingletonDimensions = require( '@stdlib/ndarray-base-remove-singleton-dimensions' );
 import serializeMetaData = require( '@stdlib/ndarray-base-serialize-meta-data' );
 import shape2strides = require( '@stdlib/ndarray-base-shape2strides' );
 import singletonDimensions = require( '@stdlib/ndarray-base-singleton-dimensions' );
@@ -49,8 +75,16 @@ import strides2offset = require( '@stdlib/ndarray-base-strides2offset' );
 import strides2order = require( '@stdlib/ndarray-base-strides2order' );
 import sub2ind = require( '@stdlib/ndarray-base-sub2ind' );
 import ndarray2array = require( '@stdlib/ndarray-base-to-array' );
+import transpose = require( '@stdlib/ndarray-base-transpose' );
+import unary = require( '@stdlib/ndarray-base-unary' );
+import unaryBy = require( '@stdlib/ndarray-base-unary-by' );
+import unaryLoopOrder = require( '@stdlib/ndarray-base-unary-loop-interchange-order' );
+import unaryOutputDataType = require( '@stdlib/ndarray-base-unary-output-dtype' );
+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' );
 
 /**
 * Interface describing the `base` namespace.
@@ -61,6 +95,70 @@ interface Namespace {
 	*/
 	assert: typeof assert;
 
+	/**
+	* 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**: 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 sh - array dimensions
+	* @param sx - first input array stride lengths
+	* @param sy - second input array stride lengths
+	* @param sz - 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, -2, 6 ]; // column-major
+	*
+	* var o = loopOrder( sh, sx, sy, sz );
+	* // 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 [ 6, -2, 1 ]
+	*/
+	binaryLoopOrder: typeof binaryLoopOrder;
+
+	/**
+	* 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 - output array data type
+	* @returns block size (in units of elements)
+	*
+	* @example
+	* var bsize = ns.binaryBlockSize( 'float64', 'float64', 'float64' );
+	* // returns <number>
+	*/
+	binaryBlockSize: typeof binaryBlockSize;
+
 	/**
 	* Converts a linear index in an underlying data buffer to a linear index in an array view.
 	*
@@ -136,6 +234,30 @@ interface Namespace {
 	*/
 	broadcastArray: typeof broadcastArray;
 
+	/**
+	* Broadcasts a scalar value to an ndarray having a specified shape.
+	*
+	* @param value - scalar value
+	* @param dtype - array data type
+	* @param shape - array shape
+	* @param order - array order
+	* @returns ndarray
+	*
+	* @example
+	* var x = ns.broadcastScalar( 1.0, 'generic', [ 2, 2 ], 'row-major' );
+	* // returns <ndarray>
+	*
+	* var sh = x.shape;
+	* // returns [ 2, 2 ]
+	*
+	* var dt = x.dtype;
+	* // returns 'generic'
+	*
+	* var v = x.get( 0, 1 );
+	* // returns 1.0
+	*/
+	broadcastScalar: typeof broadcastScalar;
+
 	/**
 	* Broadcasts array shapes to a single shape.
 	*
@@ -360,6 +482,17 @@ interface Namespace {
 	*/
 	bytesPerElement: typeof bytesPerElement;
 
+	/**
+	* Returns an object mapping single letter character abbreviations to data type strings.
+	*
+	* @returns object mapping single letter character abbreviations to data type strings
+	*
+	* @example
+	* var out = ns.char2dtype();
+	* // returns {...}
+	*/
+	char2dtype: typeof char2dtype;
+
 	/**
 	* Restricts an index to the interval `[0,max]`.
 	*
@@ -414,27 +547,112 @@ interface Namespace {
 	ndarray: typeof ndarray;
 
 	/**
-	* Returns the single letter character abbreviation for an underlying array data type.
+	* Returns an object mapping data type strings to single letter character abbreviations.
 	*
-	* @param dtype - data type
-	* @returns single letter character abbreviation
+	* @returns object mapping data type strings to single letter character abbreviations
 	*
 	* @example
-	* var ch = ns.dtypeChar( 'float64' );
-	* // returns 'd'
-	*
-	* ch = ns.dtypeChar( 'generic' );
-	* // returns 'o'
+	* var obj = ns.dtypeChar();
+	* // returns {...}
 	*/
 	dtypeChar: typeof dtypeChar;
 
+	/**
+	* Returns an object mapping data type strings to descriptions.
+	*
+	* @returns object mapping data type strings to descriptions
+	*
+	* @example
+	* var obj = ns.dtypeDesc();
+	* // returns {...}
+	*/
+	dtypeDesc: typeof dtypeDesc;
+
+	/**
+	* Returns the data type string associated with an ndarray data type enumeration constant.
+	*
+	* @param dtype - data type enumeration constant
+	* @returns data type string
+	*
+	* @example
+	* var str2enum = require( `@stdlib/ndarray/base/dtype-str2enum` );
+	*
+	* var v = str2enum( 'float64' );
+	* // returns <number>
+	*
+	* var dt = ns.dtypeEnum2Str( v );
+	* // returns 'float64'
+	*/
+	dtypeEnum2Str: typeof dtypeEnum2Str;
+
+	/**
+	* Returns the enumeration constant associated with an ndarray data type value.
+	*
+	* ## Notes
+	*
+	* -   Downstream consumers of this function should **not** rely on specific integer values (e.g., `INT8 == 0`). Instead, the function should be used in an opaque manner.
+	*
+	* @param dtype - data type value
+	* @returns enumeration constant
+	*
+	* @example
+	* var v = ns.dtypeResolveEnum( 'float64' );
+	* // returns <number>
+	*/
+	dtypeResolveEnum: typeof dtypeResolveEnum;
+
+	/**
+	* Returns the data type string associated with an ndarray data type value.
+	*
+	* @param dtype - data type value
+	* @returns data type string
+	*
+	* @example
+	* var str2enum = require( `@stdlib/ndarray/base/dtype-str2enum` );
+	*
+	* var v = ns.dtypeResolveStr( str2enum( 'float64' ) );
+	* // returns 'float64'
+	*/
+	dtypeResolveStr: typeof dtypeResolveStr;
+
+	/**
+	* Returns the enumeration constant associated with a ndarray data type string.
+	*
+	* ## Notes
+	*
+	* -   Downstream consumers of this function should **not** rely on specific integer values (e.g., `INT8 == 0`). Instead, the function should be used in an opaque manner.
+	*
+	* @param dtype - data type string
+	* @returns enumeration constant
+	*
+	* @example
+	* var v = ns.dtypeStr2Enum( 'float64' );
+	* // returns <number>
+	*/
+	dtypeStr2Enum: typeof dtypeStr2Enum;
+
+	/**
+	* Returns the C data type associated with a provided data type value.
+	*
+	* @param dtype - data type value
+	* @returns C data type (or null)
+	*
+	* @example
+	* var out = ns.dtype2c( 'float64' );
+	* // returns 'double'
+	*
+	* out = ns.dtype2c( 'generic' );
+	* // returns null
+	*/
+	dtype2c: typeof dtype2c;
+
 	/**
 	* Transforms a list of array argument data types into a list of signatures.
 	*
 	* @param dtypes - list of array argument data types
 	* @param nin - number of input array arguments
 	* @param nout - number of output array arguments
-	* @throws first argument must be an array-like object containing strings
+	* @throws first argument must be an array-like object
 	* @throws second argument must be a nonnegative integer
 	* @throws third argument must be a nonnegative integer
 	* @throws first argument must have at least one element
@@ -452,6 +670,118 @@ interface Namespace {
 	*/
 	dtypes2signatures: typeof dtypes2signatures;
 
+	/**
+	* Creates an uninitialized array having a specified shape and data type.
+	*
+	* @param dtype - underlying data type
+	* @param shape - array shape
+	* @param order - specifies whether an array is row-major (C-style) or column-major (Fortran-style)
+	* @returns output array
+	*
+	* @example
+	* var arr = ns.empty( 'float32', [ 2, 2 ], 'row-major' );
+	* // returns <ndarray>
+	*
+	* var sh = arr.shape;
+	* // returns [ 2, 2 ]
+	*
+	* var dt = arr.dtype;
+	* // returns 'float32'
+	*/
+	empty: typeof empty;
+
+	/**
+	* Creates an uninitialized array having the same shape and data type as a provided input ndarray.
+	*
+	* @param x - input array
+	* @returns output array
+	*
+	* @example
+	* var zeros = require( `@stdlib/ndarray/base/zeros` );
+	*
+	* var x = zeros( 'generic', [ 2, 2 ], 'row-major' );
+	* // returns <ndarray>
+	*
+	* var sh = x.shape;
+	* // returns [ 2, 2 ]
+	*
+	* var dt = x.dtype;
+	* // returns 'generic'
+	*
+	* var y = ns.emptyLike( x );
+	* // returns <ndarray>
+	*
+	* sh = y.shape;
+	* // returns [ 2, 2 ]
+	*
+	* dt = y.dtype;
+	* // returns 'generic'
+	*/
+	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).
+	*
+	* @param x - input array
+	* @param axis - axis at which to insert a singleton dimension
+	* @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.expandDimensions( x, 1 );
+	* // returns <ndarray>
+	*
+	* var shy = y.shape;
+	* // returns [ 2, 1, 2 ]
+	*
+	* var v = y.get( 0, 0, 0 );
+	* // returns 1
+	*
+	* v = y.get( 0, 0, 1 );
+	* // returns 2
+	*
+	* v = y.get( 1, 0, 0 );
+	* // returns 3
+	*
+	* v = y.get( 1, 0, 1 );
+	* // returns 4
+	*/
+	expandDimensions: typeof expandDimensions;
+
+	/**
+	* Returns a zero-dimensional ndarray containing a provided scalar value.
+	*
+	* @param value - scalar value
+	* @param dtype - array data type
+	* @param order - memory layout (row-major or column-major)
+	* @returns zero-dimensional ndarray
+	*
+	* @example
+	* var x = ns.scalar2ndarray( 1.0, 'generic', 'row-major' );
+	* // returns <ndarray>
+	*
+	* var sh = x.shape;
+	* // returns []
+	*
+	* var dt = x.dtype;
+	* // returns 'generic'
+	*
+	* var v = x.get();
+	* // returns 1.0
+	*/
+	scalar2ndarray: typeof scalar2ndarray;
+
 	/**
 	* Returns an index given an index mode.
 	*
@@ -663,6 +993,92 @@ interface Namespace {
 	*/
 	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.
+	* -   If a provided ndarray has a different (broadcast compatible) shape than the specified shape, the function returns a new (base) ndarray view of the provided ndarray's data. 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.
+	* -   A returned array view is a "base" ndarray, and, thus, a returned array view 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.
+	*
+	* @param arr - input array
+	* @param shape - desired shape
+	* @throws input array cannot have more dimensions than the desired shape
+	* @throws input array dimension sizes must be `1` or equal to the corresponding dimension in the provided shape
+	* @throws input array and desired shape must be broadcast compatible
+	* @returns broadcasted 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.maybeBroadcastArray( x, [ 3, 2, 2 ] );
+	* // returns <ndarray>
+	*
+	* var shy = y.shape;
+	* // returns [ 3, 2, 2 ]
+	*
+	* var v = y.get( 0, 0, 0 );
+	* // returns 1
+	*
+	* v = y.get( 0, 0, 1 );
+	* // returns 2
+	*
+	* v = y.get( 1, 0, 0 );
+	* // returns 1
+	*
+	* v = y.get( 1, 1, 0 );
+	* // returns 3
+	*
+	* v = y.get( 2, 0, 0 );
+	* // returns 1
+	*
+	* v = y.get( 2, 1, 1 );
+	* // returns 4
+	*/
+	maybeBroadcastArray: typeof maybeBroadcastArray;
+
+	/**
+	* Defines non-enumerable read-only properties which expose ndarray function meta data.
+	*
+	* @param meta - function meta data
+	* @param meta.nargs - total number of arguments
+	* @param meta.nin - total number of input arrays
+	* @param meta.nout - total number of output arrays
+	* @param dtypes - list of ndarray data types
+	* @param obj - object on which to define properties
+	* @returns object on which properties were defined
+	*
+	* @example
+	* // Define ndarray function meta data:
+	* var meta = {
+	*     'nargs': 2,
+	*     'nin': 1,
+	*     'nout': 1
+	* };
+	*
+	* // Define the list of ndarray data types:
+	* var dtypes = [
+	*     'float64', 'float64',
+	*     'float32', 'float32',
+	*     'generic', 'generic'
+	* ];
+	*
+	* // Define an object/function on which to set the properties:
+	* var obj = {};
+	*
+	* // Set the properties:
+	* ns.metaDataProps( meta, dtypes, obj );
+	*/
+	metaDataProps: typeof metaDataProps;
+
 	/**
 	* Computes the minimum linear index in an underlying data buffer accessible to an array view.
 	*
@@ -747,6 +1163,26 @@ interface Namespace {
 	*/
 	minmaxViewBufferIndex: typeof minmaxViewBufferIndex;
 
+	/**
+	* Converts an ndarray-like to an object likely to have the same "shape".
+	*
+	* ## Notes
+	*
+	* -   This function is intended as a potential performance optimization. In V8, for example, even if two objects share common properties, if those properties were added in different orders or if one object has additional properties not shared by the other object, then those objects will have different "hidden" classes. If a function is provided many objects having different "shapes", some JavaScript VMs (e.g., V8) will consider the function "megamorphic" and fail to perform various runtime optimizations. Accordingly, the intent of this function is to standardize the "shape" of the object holding ndarray meta data to ensure that internal functions operating on ndarrays are provided consistent argument "shapes".
+	*
+	* @param x - input ndarray
+	* @returns object containing ndarray data
+	*
+	* @example
+	* var array = require( `@stdlib/ndarray/array` );
+	*
+	* var x = array( [ [ 1, 2, 3 ], [ 4, 5, 6 ] ] );
+	*
+	* var obj = ns.ndarraylike2object( x );
+	* // returns {...}
+	*/
+	ndarraylike2object: typeof ndarraylike2object;
+
 	/**
 	* Returns the number of non-singleton dimensions.
 	*
@@ -767,6 +1203,89 @@ interface Namespace {
 	*/
 	nonsingletonDimensions: typeof nonsingletonDimensions;
 
+	/**
+	* Applies a nullary callback and assigns results to elements in an output ndarray.
+	*
+	* @param arrays - array-like object containing an output ndarray
+	* @param fcn - nullary callback
+	*
+	* @example
+	* var Float64Array = require( `@stdlib/array/float64` );
+	* var ndarray = require( `@stdlib/ndarray/ctor` );
+	*
+	* function fcn() {
+	*     return 10.0;
+	* }
+	*
+	* // Create data buffers:
+	* var xbuf = new Float64Array( 12 );
+	*
+	* // Define the shape of the output array:
+	* var shape = [ 3, 1, 2 ];
+	*
+	* // Define the array strides:
+	* var sx = [ 4, 4, 1 ];
+	*
+	* // Define the index offset:
+	* var ox = 1;
+	*
+	* // Create the output ndarray:
+	* var x = ndarray( 'float64', xbuf, shape, sx, ox, 'row-major' );
+	*
+	* // Apply the ns.nullary function:
+	* ns.nullary( [ x ], fcn );
+	*
+	* console.log( x.data );
+	* // => <Float64Array>[ 0.0, 10.0, 10.0, 0.0, 0.0, 10.0, 10.0, 0.0, 0.0, 10.0, 10.0, 0.0 ]
+	*/
+	nullary: typeof nullary;
+
+	/**
+	* Reorders ndarray dimensions and associated strides for loop interchange.
+	*
+	* ## Notes
+	*
+	* -   The returned object has the following properties:
+	*
+	*     -   **sh**: dimensions sorted in loop order.
+	*     -   **sx**: 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.
+	*
+	* @param sh - array dimensions
+	* @param sx - array stride lengths
+	* @returns loop interchange data
+	*
+	* @example
+	* var sh = [ 2, 3, 4 ];
+	*
+	* var sx = [ 12, 4, 1 ]; // row-major
+	*
+	* var o = ns.nullaryLoopOrder( sh, sx );
+	* // returns {...}
+	*
+	* var ssh = o.sh;
+	* // returns [ 4, 3, 2 ]
+	*
+	* var ssx = o.sx;
+	* // returns [ 1, 4, 12 ]
+	*/
+	nullaryLoopOrder: typeof nullaryLoopOrder;
+
+	/**
+	* Returns a loop block size for multi-dimensional array tiled loops.
+	*
+	* @param dtypeX - array data type
+	* @returns block size (in units of elements)
+	*
+	* @example
+	* var bsize = ns.nullaryBlockSize( 'float64' );
+	* // returns <number>
+	*/
+	nullaryBlockSize: typeof nullaryBlockSize;
+
 	/**
 	* Returns the number of elements in an array.
 	*
@@ -779,6 +1298,147 @@ interface Namespace {
 	*/
 	numel: typeof numel;
 
+	/**
+	* Returns the policy string associated with an output ndarray data type policy enumeration constant.
+	*
+	* @param policy - policy enumeration constant
+	* @returns policy string
+	*
+	* @example
+	* var str2enum = require( `@stdlib/ndarray/base/output-policy-str2enum` );
+	*
+	* var v = str2enum( 'same' );
+	* // returns <number>
+	*
+	* var policy = ns.outputPolicyEnum2Str( v );
+	* // returns 'same'
+	*/
+	outputPolicyEnum2Str: typeof outputPolicyEnum2Str;
+
+	/**
+	* Returns the enumeration constant associated with an ndarray data type policy value.
+	*
+	* ## Notes
+	*
+	* -   Downstream consumers of this function should **not** rely on specific integer values (e.g., `SAME == 0`). Instead, the function should be used in an opaque manner.
+	*
+	* @param policy - policy value
+	* @returns enumeration constant
+	*
+	* @example
+	* var v = ns.outputPolicyResolveEnum( 'same' );
+	* // returns <number>
+	*/
+	outputPolicyResolveEnum: typeof outputPolicyResolveEnum;
+
+	/**
+	* Returns the policy string associated with an output ndarray data type policy value.
+	*
+	* @param policy - policy value
+	* @returns policy string
+	*
+	* @example
+	* var str2enum = require( `@stdlib/ndarray/base/output-policy-str2enum` );
+	*
+	* var v = ns.outputPolicyResolveStr( str2enum( 'same' ) );
+	* // returns 'same'
+	*/
+	outputPolicyResolveStr: typeof outputPolicyResolveStr;
+
+	/**
+	* Returns the enumeration constant associated with an output ndarray data type policy string.
+	*
+	* ## Notes
+	*
+	* -   Downstream consumers of this function should **not** rely on specific integer values (e.g., `SAME == 0`). Instead, the function should be used in an opaque manner.
+	*
+	* @param policy - policy string
+	* @returns enumeration constant
+	*
+	* @example
+	* var v = ns.outputPolicyStr2Enum( 'same' );
+	* // returns <number>
+	*/
+	outputPolicyStr2Enum: typeof outputPolicyStr2Enum;
+
+	/**
+	* Returns an array with a specified number of prepended singleton dimensions.
+	*
+	* @param x - input array
+	* @param n - number of singleton dimensions to prepend
+	* @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.prependSingletonDimensions( x, 3 );
+	* // returns <ndarray>
+	*
+	* var shy = y.shape;
+	* // returns [ 1, 1, 1, 2, 2 ]
+	*
+	* var v = y.get( 0, 0, 0, 0, 0 );
+	* // returns 1
+	*
+	* v = y.get( 0, 0, 0, 0, 1 );
+	* // returns 2
+	*
+	* v = y.get( 0, 0, 0, 1, 0 );
+	* // returns 3
+	*
+	* v = y.get( 0, 0, 0, 1, 1 );
+	* // returns 4
+	*/
+	prependSingletonDimensions: typeof prependSingletonDimensions;
+
+	/**
+	* 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 );
+	* // returns <ndarray>
+	*
+	* var shy = y.shape;
+	* // returns [ 2, 2 ]
+	*
+	* var v = y.get( 0, 0 );
+	* // returns 1
+	*
+	* v = y.get( 0, 1 );
+	* // returns 2
+	*
+	* v = y.get( 1, 0 );
+	* // returns 3
+	*
+	* v = y.get( 1, 1 );
+	* // returns 4
+	*/
+	removeSingletonDimensions: typeof removeSingletonDimensions;
+
 	/**
 	* Serializes ndarray meta data.
 	*
@@ -789,7 +1449,7 @@ interface Namespace {
 	* -   Meta data format:
 	*
 	*     ```text
-	*     | <endianness> (1 byte) | <dtype> (2 bytes) | <ndims> (8 bytes) | <shape> (ndims*8 bytes) | <strides> (ndims*8 bytes) | <offset> (8 bytes) | <order> (1 byte) | <mode> (1 byte) | <nsubmodes> (8 bytes) | <submodes> (nsubmodes*1 bytes) |
+	*     | <endianness> (1 byte) | <dtype> (2 bytes) | <ndims> (8 bytes) | <shape> (ndims*8 bytes) | <strides> (ndims*8 bytes) | <offset> (8 bytes) | <order> (1 byte) | <mode> (1 byte) | <nsubmodes> (8 bytes) | <submodes> (nsubmodes*1 bytes) | <flags> (4 bytes) |
 	*     ```
 	*
 	*     which translates to the following `ArrayBuffer` layout:
@@ -806,6 +1466,7 @@ interface Namespace {
 	*         <mode>[int8],
 	*         <nsubmodes>[int64],
 	*         <submodes>[nsubmodes*int8]
+	*         <flags>[int32]
 	*     ]
 	*     ```
 	*
@@ -816,13 +1477,13 @@ interface Namespace {
 	* -   Buffer length:
 	*
 	*     ```text
-	*     1 + 2 + 8 + (ndims*8) + (ndims*8) + 8 + 1 + 1 + 8 + (nsubmodes*1) = 29 + (ndims*16) + nsubmodes
+	*     1 + 2 + 8 + (ndims*8) + (ndims*8) + 8 + 1 + 1 + 8 + (nsubmodes*1) + 4 = 33 + (ndims*16) + nsubmodes
 	*     ```
 	*
 	*     For example, consider a three-dimensional ndarray with one subscript index mode (submode):
 	*
 	*     ```text
-	*     29 + (3*16) + 1 = 78 bytes
+	*     33 + (3*16) + 1 = 82 bytes
 	*     ```
 	*
 	* -   Views:
@@ -837,6 +1498,7 @@ interface Namespace {
 	*     -   mode: `Int8Array( buf, 20+(ndims*16), 1 )`
 	*     -   nsubmodes: `Int64Array( buf, 21+(ndims*16), 1 )`
 	*     -   submodes: `Int8Array( buf, 29+(ndims*16), nsubmodes )`
+	*     -   flags: `Int32Array( buf, 29+(ndims*16)+nsubmodes, 1)`
 	*
 	* @param x - input ndarray
 	* @returns serialized meta data
@@ -1051,6 +1713,196 @@ interface Namespace {
 	*/
 	ndarray2array: typeof ndarray2array;
 
+	/**
+	* Transposes a matrix (or a stack of matrices).
+	*
+	* @param x - input array
+	* @returns ndarray view
+	*
+	* @example
+	* var array = require( `@stdlib/ndarray/array` );
+	*
+	* var x = array( [ [ 1, 2, 3 ], [ 4, 5, 6 ] ], {
+	*     'dtype': 'generic'
+	* });
+	* // returns <ndarray>
+	*
+	* var sh = x.shape;
+	* // returns [ 2, 3 ]
+	*
+	* var y = ns.transpose( x );
+	* // returns <ndarray>
+	*
+	* sh = y.shape;
+	* // returns [ 3, 2 ]
+	*
+	* var bool = ( x.get( 0, 1 ) === y.get( 1, 0 ) );
+	* // returns true
+	*
+	* bool = ( x.data === y.data );
+	* // returns true
+	*/
+	transpose: typeof transpose;
+
+	/**
+	* Applies a unary callback to elements in an ndarray and assigns results to elements in an ndarray.
+	*
+	* @param arrays - array-like object containing one input ndarray and one output ndarray
+	* @param fcn - unary 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` );
+	*
+	* 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 the ns.unary function:
+	* ns.unary( [ x, y ], scale );
+	*
+	* console.log( y.data );
+	* // => <Float64Array>[ 20.0, 30.0, 60.0, 70.0, 100.0, 110.0 ]
+	*/
+	unary: typeof unary;
+
+	/**
+	* Applies a unary function to elements in an ndarray and assigns results to elements in an ndarray.
+	*
+	* @param arrays - array-like object containing one input ndarray and one output ndarray
+	* @param fcn - unary function to apply to callback return values
+	* @param clbk - callback function
+	* @param thisArg - callback execution context
+	* @throws arrays must have the same number of dimensions
+	* @throws arrays must have the same shape
+	*
+	* @example
+	* var identity = require( `@stdlib/math/base/special/identity` );
+	* var Float64Array = require( `@stdlib/array/float64` );
+	* 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 the unary function:
+	* ns.unaryBy( [ x, y ], scale, identity );
+	*
+	* console.log( y.data );
+	* // => <Float64Array>[ 20.0, 30.0, 60.0, 70.0, 100.0, 110.0 ]
+	*/
+	unaryBy: typeof unaryBy;
+
+	/**
+	* Reorders ndarray dimensions and associated strides for loop interchange.
+	*
+	* ## Notes
+	*
+	* -   The returned object has the following properties:
+	*
+	*     -   **sh**: dimensions sorted in loop order.
+	*     -   **sx**: input ndarray strides sorted in loop order.
+	*     -   **sy**: 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 **input 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 input ndarray. If the output ndarray has a different layout order (e.g., if the input ndarray is 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 sh - array dimensions
+	* @param sx - input array stride lengths
+	* @param sy - output array stride lengths
+	* @returns loop interchange data
+	*
+	* @example
+	* var sh = [ 2, 3, 4 ];
+	*
+	* var sx = [ 12, 4, 1 ]; // row-major
+	* var sy = [ 1, -2, 6 ]; // column-major
+	*
+	* var o = ns.unaryLoopOrder( sh, sx, sy );
+	* // returns {...}
+	*
+	* var ssh = o.sh;
+	* // returns [ 4, 3, 2 ]
+	*
+	* var ssx = o.sx;
+	* // returns [ 1, 4, 12 ]
+	*
+	* var ssy = o.sy;
+	* // returns [ 6, -2, 1 ]
+	*/
+	unaryLoopOrder: typeof unaryLoopOrder;
+
+	/**
+	* Resolves the output ndarray data type for a unary function.
+	*
+	* @param dtype - input ndarray data type
+	* @param policy - output ndarray data type policy
+	* @returns output ndarray data type
+	*
+	* @example
+	* var dt = ns.unaryOutputDataType( 'float64', 'complex_floating_point' );
+	* // returns <string>
+	*/
+	unaryOutputDataType: typeof unaryOutputDataType;
+
+	/**
+	* Returns a loop block size for multi-dimensional array tiled loops.
+	*
+	* @param dtypeX - input array data type
+	* @param dtypeY - output array data type
+	* @returns block size (in units of elements)
+	*
+	* @example
+	* var bsize = ns.unaryBlockSize( 'float64', 'float64' );
+	* // returns <number>
+	*/
+	unaryBlockSize: typeof unaryBlockSize;
+
 	/**
 	* Converts a linear index in an array view to a linear index in an underlying data buffer.
 	*
@@ -1093,6 +1945,55 @@ interface Namespace {
 	* // returns 6
 	*/
 	wrapIndex: typeof wrapIndex;
+
+	/**
+	* Creates a zero-filled array having a specified shape and data type.
+	*
+	* @param dtype - underlying data type
+	* @param shape - array shape
+	* @param order - specifies whether an array is row-major (C-style) or column-major (Fortran-style)
+	* @returns zero-filled array
+	*
+	* @example
+	* var arr = ns.zeros( 'float32', [ 2, 2 ], 'row-major' );
+	* // returns <ndarray>
+	*
+	* var sh = arr.shape;
+	* // returns [ 2, 2 ]
+	*
+	* var dt = arr.dtype;
+	* // returns 'float32'
+	*/
+	zeros: typeof zeros;
+
+	/**
+	* Creates a zero-filled array having the same shape and data type as a provided input ndarray.
+	*
+	* @param x - input array
+	* @returns zero-filled array
+	*
+	* @example
+	* var zeros = require( `@stdlib/ndarray/base/zeros` );
+	*
+	* var x = zeros( 'generic', [ 2, 2 ], 'row-major' );
+	* // returns <ndarray>
+	*
+	* var sh = x.shape;
+	* // returns [ 2, 2 ]
+	*
+	* var dt = x.dtype;
+	* // returns 'generic'
+	*
+	* var y = ns.zerosLike( x );
+	* // returns <ndarray>
+	*
+	* sh = y.shape;
+	* // returns [ 2, 2 ]
+	*
+	* dt = y.dtype;
+	* // returns 'generic'
+	*/
+	zerosLike: typeof zerosLike;
 }
 
 /**