@stdlib/ndarray-base 0.1.0 → 0.2.0

package/docs/types/index.d.ts

@@ -18,14 +18,15 @@
 
 // TypeScript Version: 4.1
 
-/* tslint:disable:max-line-length */
-/* tslint:disable:max-file-line-count */
+/* eslint-disable max-lines */
 
 import assert = require( '@stdlib/ndarray-base-assert' );
+import assign = require( '@stdlib/ndarray-base-assign' );
 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 broadcastArrays = require( '@stdlib/ndarray-base-broadcast-arrays' );
 import broadcastScalar = require( '@stdlib/ndarray-base-broadcast-scalar' );
 import broadcastShapes = require( '@stdlib/ndarray-base-broadcast-shapes' );
 import buffer = require( '@stdlib/ndarray-base-buffer' );
@@ -36,6 +37,8 @@ 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 data = require( '@stdlib/ndarray-base-data-buffer' );
+import dtype = require( '@stdlib/ndarray-base-dtype' );
 import dtypeChar = require( '@stdlib/ndarray-base-dtype-char' );
 import dtypeDesc = require( '@stdlib/ndarray-base-dtype-desc' );
 import dtypeEnum2Str = require( '@stdlib/ndarray-base-dtype-enum2str' );
@@ -47,30 +50,53 @@ 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 flag = require( '@stdlib/ndarray-base-flag' );
+import flags = require( '@stdlib/ndarray-base-flags' );
+import fliplr = require( '@stdlib/ndarray-base-fliplr' );
+import flipud = require( '@stdlib/ndarray-base-flipud' );
 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 maybeBroadcastArrays = require( '@stdlib/ndarray-base-maybe-broadcast-arrays' );
 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 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 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 numelDimension = require( '@stdlib/ndarray-base-numel-dimension' );
+import offset = require( '@stdlib/ndarray-base-offset' );
+import order = require( '@stdlib/ndarray-base-order' );
 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 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 singletonDimensions = require( '@stdlib/ndarray-base-singleton-dimensions' );
+import slice = require( '@stdlib/ndarray-base-slice' );
+import sliceAssign = require( '@stdlib/ndarray-base-slice-assign' );
+import sliceDimension = require( '@stdlib/ndarray-base-slice-dimension' );
+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 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' );
@@ -95,6 +121,44 @@ interface Namespace {
 	*/
 	assert: typeof assert;
 
+	/**
+	* Assigns elements in an ndarray to elements in an ndarray.
+	*
+	* @param arrays - array-like object containing one input ndarray and one output ndarray
+	* @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' );
+	*
+	* // 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' );
+	*
+	* // Copy elements:
+	* ns.assign( [ x, y ] );
+	*
+	* console.log( y.data );
+	* // => <Float64Array>[ 2.0, 3.0, 6.0, 7.0, 10.0, 11.0 ]
+	*/
+	assign: typeof assign;
+
 	/**
 	* Reorders ndarray dimensions and associated strides for loop interchange.
 	*
@@ -200,7 +264,7 @@ interface Namespace {
 	* @returns broadcasted array
 	*
 	* @example
-	* var array = require( `@stdlib/ndarray/array` );
+	* var array = require( '@stdlib/ndarray-array' );
 	*
 	* var x = array( [ [ 1, 2 ], [ 3, 4 ] ] );
 	* // returns <ndarray>
@@ -234,6 +298,83 @@ interface Namespace {
 	*/
 	broadcastArray: typeof broadcastArray;
 
+	/**
+	* Broadcasts ndarrays to a common shape.
+	*
+	* ## Notes
+	*
+	* -   The function throws an error if provided broadcast-incompatible ndarrays.
+	* -   The returned arrays are views on their respective underlying array data buffers. The views are typically **not** contiguous. As more than one element of a returned view may refer to the same memory location, writing to a view may affect multiple elements. If you need to write to a returned array, copy the array before performing operations which may mutate elements.
+	* -   The returned arrays are "base" ndarrays, and, thus, returned arrays do 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 ndarray-like objects within internal implementations and to do so with minimal overhead.
+	* -   The function always returns new ndarray instances even if an input ndarray shape and the broadcasted shape are the same.
+	*
+	* @param arrays - input arrays
+	* @throws input arrays must be broadcast compatible
+	* @returns list of broadcasted arrays
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray-array' );
+	* var zeros = require( '@stdlib/ndarray-zeros' );
+	*
+	* var x1 = array( [ [ 1, 2 ], [ 3, 4 ] ] );
+	* // returns <ndarray>
+	*
+	* var shx = x1.shape;
+	* // returns [ 2, 2 ]
+	*
+	* var y1 = zeros( [ 3, 2, 2 ] );
+	* // returns <ndarray>
+	*
+	* var shy = y1.shape;
+	* // returns [ 3, 2, 2 ]
+	*
+	* var out = ns.broadcastArrays( [ x1, y1 ] );
+	* // returns <ndarray>
+	*
+	* var x2 = out[ 0 ];
+	* // returns <ndarray>
+	*
+	* var y2 = out[ 1 ];
+	* // returns <ndarray>
+	*
+	* shx = x2.shape;
+	* // returns [ 3, 2, 2 ]
+	*
+	* shy = y2.shape;
+	* // returns [ 3, 2, 2 ]
+	*
+	* var v = x2.get( 0, 0, 0 );
+	* // returns 1
+	*
+	* v = x2.get( 0, 0, 1 );
+	* // returns 2
+	*
+	* v = x2.get( 1, 0, 0 );
+	* // returns 1
+	*
+	* v = x2.get( 1, 1, 0 );
+	* // returns 3
+	*
+	* v = x2.get( 2, 0, 0 );
+	* // returns 1
+	*
+	* v = x2.get( 2, 1, 1 );
+	* // returns 4
+	*
+	* @example
+	* var zeros = require( '@stdlib/ndarray-zeros' );
+	*
+	* var x = zeros( [ 2, 2 ] );
+	* // returns <ndarray>
+	*
+	* var y = zeros( [ 4, 2 ] );
+	* // returns <ndarray>
+	*
+	* var out = ns.broadcastArrays( [ x, y ] );
+	* // throws <Error>
+	*/
+	broadcastArrays: typeof broadcastArrays;
+
 	/**
 	* Broadcasts a scalar value to an ndarray having a specified shape.
 	*
@@ -458,7 +599,7 @@ interface Namespace {
 	* @returns data type enumeration constant or null
 	*
 	* @example
-	* var Float64Array = require( `@stdlib/array/float64` );
+	* var Float64Array = require( '@stdlib/array-float64' );
 	*
 	* var x = new Float64Array( 10 );
 	*
@@ -546,6 +687,42 @@ interface Namespace {
 	*/
 	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 single letter character abbreviations.
 	*
@@ -575,7 +752,7 @@ interface Namespace {
 	* @returns data type string
 	*
 	* @example
-	* var str2enum = require( `@stdlib/ndarray/base/dtype-str2enum` );
+	* var str2enum = require( '@stdlib/ndarray-base-dtype-str2enum' );
 	*
 	* var v = str2enum( 'float64' );
 	* // returns <number>
@@ -608,7 +785,7 @@ interface Namespace {
 	* @returns data type string
 	*
 	* @example
-	* var str2enum = require( `@stdlib/ndarray/base/dtype-str2enum` );
+	* var str2enum = require( '@stdlib/ndarray-base-dtype-str2enum' );
 	*
 	* var v = ns.dtypeResolveStr( str2enum( 'float64' ) );
 	* // returns 'float64'
@@ -697,7 +874,7 @@ interface Namespace {
 	* @returns output array
 	*
 	* @example
-	* var zeros = require( `@stdlib/ndarray/base/zeros` );
+	* var zeros = require( '@stdlib/ndarray-base-zeros' );
 	*
 	* var x = zeros( 'generic', [ 2, 2 ], 'row-major' );
 	* // returns <ndarray>
@@ -731,7 +908,7 @@ interface Namespace {
 	* @returns output array
 	*
 	* @example
-	* var array = require( `@stdlib/ndarray/array` );
+	* var array = require( '@stdlib/ndarray-array' );
 	*
 	* var x = array( [ [ 1, 2 ], [ 3, 4 ] ] );
 	* // returns <ndarray>
@@ -759,6 +936,114 @@ interface Namespace {
 	*/
 	expandDimensions: typeof expandDimensions;
 
+	/**
+	* 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;
+
+	/**
+	* Returns a view of an input ndarray in which the order of elements along the last dimension is reversed.
+	*
+	* @param x - input array
+	* @param writable - boolean indicating whether a returned array should be writable
+	* @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 = [ 1, 2, 3, 4, 5, 6 ];
+	* var shape = [ 3, 2 ];
+	* var strides = [ 2, 1 ];
+	* var offset = 0;
+	*
+	* var x = ndarray( 'generic', 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 ] ]
+	*
+	* var y = ns.fliplr( x, false );
+	* // returns <ndarray>
+	*
+	* sh = y.shape;
+	* // returns [ 3, 2 ]
+	*
+	* arr = ndarray2array( y );
+	* // returns [ [ 2, 1 ], [ 4, 3 ], [ 6, 5 ] ]
+	*/
+	fliplr: typeof fliplr;
+
+	/**
+	* Returns a view of an input ndarray in which the order of elements along the second-to-last dimension is reversed.
+	*
+	* @param x - input array
+	* @param writable - boolean indicating whether a returned array should be writable
+	* @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 = [ 1, 2, 3, 4, 5, 6 ];
+	* var shape = [ 3, 2 ];
+	* var strides = [ 2, 1 ];
+	* var offset = 0;
+	*
+	* var x = ndarray( 'generic', 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 ] ]
+	*
+	* var y = ns.flipud( x, false );
+	* // returns <ndarray>
+	*
+	* sh = y.shape;
+	* // returns [ 3, 2 ]
+	*
+	* arr = ndarray2array( y );
+	* // returns [ [ 5, 6 ], [ 3, 4 ], [ 1, 2 ] ]
+	*/
+	flipud: typeof flipud;
+
 	/**
 	* Returns a zero-dimensional ndarray containing a provided scalar value.
 	*
@@ -788,7 +1073,6 @@ interface Namespace {
 	* @param idx - index
 	* @param max - maximum index
 	* @param mode - specifies how to handle an index outside the interval `[0,max]`
-	* @throws index out-of-bounds
 	* @returns index
 	*
 	* @example
@@ -820,6 +1104,28 @@ interface Namespace {
 	*
 	* idx = ns.ind( -1, 9, 'throw' );
 	* // throws <RangeError>
+	*
+	* @example
+	* var idx = ns.ind( 2, 9, 'normalize' );
+	* // returns 2
+	*
+	* idx = ns.ind( -5, 9, 'normalize' );
+	* // returns 5
+	*
+	* idx = ns.ind( -20, 9, '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;
 
@@ -830,9 +1136,10 @@ interface Namespace {
 	*
 	* -   The function accepts the following "modes":
 	*
-	*     -   `throw`: throws an error when a linear index exceeds array dimensions.
-	*     -   `wrap`: wrap around a linear index exceeding array dimensions using modulo arithmetic.
-	*     -   `clamp`: set a linear index exceeding array dimensions to either `0` (minimum linear index) or the maximum linear index.
+	*     -   **throw**: throw an error when a linear index exceeds array dimensions.
+	*     -   **normalize**: normalize negative indices and throw an error when a linear index exceeds array dimensions.
+	*     -   **wrap**: wrap around a linear index exceeding array dimensions using modulo arithmetic.
+	*     -   **clamp**: set a linear index exceeding array dimensions to either `0` (minimum linear index) or the maximum linear index.
 	*
 	* -   When provided a stride array containing negative strides, if an `offset` is greater than `0`, the function interprets the linear index as an index into the underlying data buffer for the array, thus returning subscripts from the perspective of that buffer. If an `offset` is equal to `0`, the function treats the linear index as an index into an array view, thus returning subscripts from the perspective of that view.
 	*
@@ -1011,7 +1318,7 @@ interface Namespace {
 	* @returns broadcasted array
 	*
 	* @example
-	* var array = require( `@stdlib/ndarray/array` );
+	* var array = require( '@stdlib/ndarray-array' );
 	*
 	* var x = array( [ [ 1, 2 ], [ 3, 4 ] ] );
 	* // returns <ndarray>
@@ -1045,6 +1352,71 @@ interface Namespace {
 	*/
 	maybeBroadcastArray: typeof maybeBroadcastArray;
 
+	/**
+	* Broadcasts ndarrays to a common shape.
+	*
+	* ## Notes
+	*
+	* -   The function throws an error if a provided broadcast-incompatible ndarrays.
+	* -   If a provided ndarray has a shape matching the common shape, the function returns the provided ndarray.
+	* -   If a provided ndarray has a different (broadcast compatible) shape than the common 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 a view may affect multiple elements. If you need to write to a 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 ndarray-like objects within internal implementations and to do so with minimal overhead.
+	*
+	* @param arrays - input arrays
+	* @throws input arrays must be broadcast compatible
+	* @returns list of broadcasted arrays
+	*
+	* @example
+	* var array = require( '@stdlib/ndarray-array' );
+	* var zeros = require( '@stdlib/ndarray-zeros' );
+	*
+	* var x = array( [ [ 1, 2 ], [ 3, 4 ] ] );
+	* // returns <ndarray>
+	*
+	* var shx = x.shape;
+	* // returns [ 2, 2 ]
+	*
+	* var y1 = zeros( [ 3, 2, 2 ] );
+	* // returns <ndarray>
+	*
+	* var shy = y1.shape;
+	* // returns [ 3, 2, 2 ]
+	*
+	* var out = ns.maybeBroadcastArrays( [ x, y ] );
+	* // returns <ndarray>
+	*
+	* var x2 = out[ 0 ];
+	* // returns <ndarray>
+	*
+	* var y2 = out[ 1 ];
+	* // returns <ndarray>
+	*
+	* shx = x2.shape;
+	* // returns [ 3, 2, 2 ]
+	*
+	* shy = y2.shape;
+	* // returns [ 3, 2, 2 ]
+	*
+	* var v = x2.get( 0, 0, 0 );
+	* // returns 1
+	*
+	* v = x2.get( 0, 0, 1 );
+	* // returns 2
+	*
+	* v = x2.get( 1, 0, 0 );
+	* // returns 1
+	*
+	* v = x2.get( 1, 1, 0 );
+	* // returns 3
+	*
+	* v = x2.get( 2, 0, 0 );
+	* // returns 1
+	*
+	* v = x2.get( 2, 1, 1 );
+	* // returns 4
+	*/
+	maybeBroadcastArrays: typeof maybeBroadcastArrays;
+
 	/**
 	* Defines non-enumerable read-only properties which expose ndarray function meta data.
 	*
@@ -1174,7 +1546,7 @@ interface Namespace {
 	* @returns object containing ndarray data
 	*
 	* @example
-	* var array = require( `@stdlib/ndarray/array` );
+	* var array = require( '@stdlib/ndarray-array' );
 	*
 	* var x = array( [ [ 1, 2, 3 ], [ 4, 5, 6 ] ] );
 	*
@@ -1184,44 +1556,138 @@ interface Namespace {
 	ndarraylike2object: typeof ndarraylike2object;
 
 	/**
-	* Returns the number of non-singleton dimensions.
+	* Returns the number of ndarray dimensions.
+	*
+	* @param x - input ndarray
+	* @returns number of dimensions
+	*
+	* @example
+	* var zeros = require( '@stdlib/ndarray-zeros' );
+	*
+	* var n = ns.ndims( zeros( [ 3, 3, 3 ] ) );
+	* // returns 3
+	*/
+	ndims: typeof ndims;
+
+	/**
+	* Returns the next Cartesian index (i.e., set of subscripts/dimension indices).
 	*
 	* ## Notes
 	*
-	* -   A singleton dimension is a dimension whose size is equal to `1`.
+	* -   The function does not check whether the current index is the "last" index. Instead, if the function is provided dimension indices corresponding to the last element, the function will cycle back to the "first" index.
+	* -   If provided an empty shape (i.e., a shape corresponding to a zero-dimensional ndarray) or a dimension index `dim` which is out-of-bounds, the function returns `null`.
 	*
 	* @param shape - array shape
-	* @returns number of non-singleton dimensions
+	* @param order - iteration order
+	* @param idx - current dimension indices
+	* @param dim - index of the dimension from which to start incrementing (inclusive)
+	* @returns updated dimension indices
 	*
 	* @example
-	* var n = ns.nonsingletonDimensions( [ 3, 3, 1, 2 ] );
-	* // returns 3
+	* var shape = [ 12 ];
+	* var idx = ns.nextCartesianIndex( shape, 'row-major', [ 2 ], 0 );
+	* // returns [ 3 ]
 	*
 	* @example
-	* var n = ns.nonsingletonDimensions( [ 1, 1 ] );
-	* // returns 0
-	*/
-	nonsingletonDimensions: typeof nonsingletonDimensions;
-
-	/**
-	* Applies a nullary callback and assigns results to elements in an output ndarray.
+	* var shape = [ 2, 2, 2 ];
 	*
-	* @param arrays - array-like object containing an output ndarray
-	* @param fcn - nullary callback
+	* var idx = ns.nextCartesianIndex( shape, 'row-major', [ 0, 0, 1 ], -1 );
+	* // returns [ 0, 1, 0 ]
 	*
-	* @example
-	* var Float64Array = require( `@stdlib/array/float64` );
-	* var ndarray = require( `@stdlib/ndarray/ctor` );
+	* idx = ns.nextCartesianIndex( shape, 'row-major', idx, -1 );
+	* // returns [ 0, 1, 1 ]
 	*
-	* function fcn() {
-	*     return 10.0;
-	* }
+	* idx = ns.nextCartesianIndex( shape, 'row-major', idx, -1 );
+	* // returns [ 1, 0, 0 ]
 	*
-	* // Create data buffers:
-	* var xbuf = new Float64Array( 12 );
+	* idx = ns.nextCartesianIndex( shape, 'row-major', idx, -1 );
+	* // returns [ 1, 0, 1 ]
 	*
-	* // Define the shape of the output array:
-	* var shape = [ 3, 1, 2 ];
+	* idx = ns.nextCartesianIndex( shape, 'row-major', idx, -1 );
+	* // returns [ 1, 1, 0 ]
+	*
+	* idx = ns.nextCartesianIndex( shape, 'row-major', idx, -1 );
+	* // returns [ 1, 1, 1 ]
+	*
+	* @example
+	* var shape = [];
+	* var idx = ns.nextCartesianIndex( shape, 'row-major', [], 0 );
+	* // returns null
+	*
+	* @example
+	* var shape = [ 12 ];
+	* var idx = ns.nextCartesianIndex( shape, 'row-major', [ 2 ], -10 );
+	* // returns null
+	*
+	* @example
+	* var shape = [ 12 ];
+	* var idx = ns.nextCartesianIndex( shape, 'column-major', [ 2 ], 10 );
+	* // returns null
+	*/
+	nextCartesianIndex: typeof nextCartesianIndex;
+
+	/**
+	* Returns the number of non-singleton dimensions.
+	*
+	* ## Notes
+	*
+	* -   A singleton dimension is a dimension whose size is equal to `1`.
+	*
+	* @param shape - array shape
+	* @returns number of non-singleton dimensions
+	*
+	* @example
+	* var n = ns.nonsingletonDimensions( [ 3, 3, 1, 2 ] );
+	* // returns 3
+	*
+	* @example
+	* var n = ns.nonsingletonDimensions( [ 1, 1 ] );
+	* // returns 0
+	*/
+	nonsingletonDimensions: typeof nonsingletonDimensions;
+
+	/**
+	* Normalizes an index to the interval `[0,max]`.
+	*
+	* ## Notes
+	*
+	* -   If provided an out-of-bounds index, the function returns `-1`.
+	*
+	* @param idx - index
+	* @param max - maximum index
+	* @returns index
+	*
+	* @example
+	* var idx = ns.normalizeIndex( -2, 10 );
+	* // returns 9
+	*
+	* idx = ns.normalizeIndex( 15, 10 );
+	* // returns -1
+	*
+	* idx = ns.normalizeIndex( 5, 10 );
+	* // returns 5
+	*/
+	normalizeIndex: typeof normalizeIndex;
+
+	/**
+	* 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 ];
@@ -1249,6 +1715,7 @@ interface Namespace {
 	*
 	*     -   **sh**: dimensions sorted in loop order.
 	*     -   **sx**: 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.
 	*
@@ -1271,6 +1738,9 @@ interface Namespace {
 	*
 	* var ssx = o.sx;
 	* // returns [ 1, 4, 12 ]
+	*
+	* var idx = o.idx;
+	* // returns [ 2, 1, 0 ]
 	*/
 	nullaryLoopOrder: typeof nullaryLoopOrder;
 
@@ -1298,6 +1768,57 @@ interface Namespace {
 	*/
 	numel: typeof numel;
 
+	/**
+	* Returns the size (i.e., number of elements) of a specified dimension for a provided ndarray.
+	*
+	* @param x - input ndarray
+	* @param dim - dimension index
+	* @returns dimension size
+	*
+	* @example
+	* var zeros = require( '@stdlib/ndarray-zeros' );
+	*
+	* var d = ns.numelDimension( zeros( [ 4, 2, 3 ] ), 0 );
+	* // returns 4
+	*/
+	numelDimension: typeof numelDimension;
+
+	/**
+	* Returns the index offset specifying the underlying buffer index of the first iterated ndarray element.
+	*
+	* @param x - input ndarray
+	* @returns index offset
+	*
+	* @example
+	* var zeros = require( '@stdlib/ndarray-zeros' );
+	*
+	* var n = ns.offset( zeros( [ 3, 3, 3 ] ) );
+	* // returns 0
+	*/
+	offset: typeof offset;
+
+	/**
+	* Returns the layout order of a provided ndarray.
+	*
+	* ## Notes
+	*
+	* -   If unable to resolve a layout order, the function returns `null`.
+	*
+	* @param x - input ndarray
+	* @returns layout order (or null)
+	*
+	* @example
+	* var zeros = require( '@stdlib/ndarray-zeros' );
+	*
+	* var x = zeros( [ 3, 3, 3 ], {
+	*     'ns.order': 'row-major'
+	* });
+	*
+	* var o = ns.order( x );
+	* // returns 'row-major'
+	*/
+	order: typeof order;
+
 	/**
 	* Returns the policy string associated with an output ndarray data type policy enumeration constant.
 	*
@@ -1305,7 +1826,7 @@ interface Namespace {
 	* @returns policy string
 	*
 	* @example
-	* var str2enum = require( `@stdlib/ndarray/base/output-policy-str2enum` );
+	* var str2enum = require( '@stdlib/ndarray-base-output-policy-str2enum' );
 	*
 	* var v = str2enum( 'same' );
 	* // returns <number>
@@ -1338,7 +1859,7 @@ interface Namespace {
 	* @returns policy string
 	*
 	* @example
-	* var str2enum = require( `@stdlib/ndarray/base/output-policy-str2enum` );
+	* var str2enum = require( '@stdlib/ndarray-base-output-policy-str2enum' );
 	*
 	* var v = ns.outputPolicyResolveStr( str2enum( 'same' ) );
 	* // returns 'same'
@@ -1369,7 +1890,7 @@ interface Namespace {
 	* @returns output array
 	*
 	* @example
-	* var array = require( `@stdlib/ndarray/array` );
+	* var array = require( '@stdlib/ndarray-array' );
 	*
 	* var x = array( [ [ 1, 2 ], [ 3, 4 ] ] );
 	* // returns <ndarray>
@@ -1409,7 +1930,7 @@ interface Namespace {
 	* @returns squeezed array
 	*
 	* @example
-	* var array = require( `@stdlib/ndarray/array` );
+	* var array = require( '@stdlib/ndarray-array' );
 	*
 	* var x = array( [ [ 1, 2 ], [ 3, 4 ] ], {
 	*     'ndmin': 5
@@ -1439,6 +1960,81 @@ interface Namespace {
 	*/
 	removeSingletonDimensions: typeof removeSingletonDimensions;
 
+	/**
+	* Returns a view of an input ndarray in which the order of elements along each dimension is reversed.
+	*
+	* @param x - input array
+	* @param writable - boolean indicating whether a returned array should be writable
+	* @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 = [ 1, 2, 3, 4, 5, 6 ];
+	* var shape = [ 3, 2 ];
+	* var strides = [ 2, 1 ];
+	* var offset = 0;
+	*
+	* var x = ndarray( 'generic', 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 ] ]
+	*
+	* var y = ns.reverse( x, false );
+	* // returns <ndarray>
+	*
+	* sh = y.shape;
+	* // returns [ 3, 2 ]
+	*
+	* arr = ndarray2array( y );
+	* // returns [ [ 6, 5 ], [ 4, 3 ], [ 2, 1 ] ]
+	*/
+	reverse: typeof reverse;
+
+	/**
+	* Returns a view of an input ndarray in which the order of elements along a specified dimension is reversed.
+	*
+	* @param x - input array
+	* @param dim - index of dimension to reverse
+	* @param writable - boolean indicating whether a returned array should be writable
+	* @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 = [ 1, 2, 3, 4, 5, 6 ];
+	* var shape = [ 3, 2 ];
+	* var strides = [ 2, 1 ];
+	* var offset = 0;
+	*
+	* var x = ndarray( 'generic', 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 ] ]
+	*
+	* var y = ns.reverseDimension( x, 0, false );
+	* // returns <ndarray>
+	*
+	* sh = y.shape;
+	* // returns [ 3, 2 ]
+	*
+	* arr = ndarray2array( y );
+	* // returns [ [ 5, 6 ], [ 3, 4 ], [ 1, 2 ] ]
+	*/
+	reverseDimension: typeof reverseDimension;
+
 	/**
 	* Serializes ndarray meta data.
 	*
@@ -1504,7 +2100,7 @@ interface Namespace {
 	* @returns serialized meta data
 	*
 	* @example
-	* var array = require( `@stdlib/ndarray/array` );
+	* var array = require( '@stdlib/ndarray-array' );
 	*
 	* var x = array( [ [ 1, 2 ], [ 3, 4 ] ] );
 	*
@@ -1513,6 +2109,25 @@ interface Namespace {
 	*/
 	serializeMetaData: typeof serializeMetaData;
 
+	/**
+	* Returns the shape of a provided ndarray.
+	*
+	* ## Notes
+	*
+	* -   When `copy` is `false`, changes to the returned shape array may mutate the input ndarray shape. If there is a chance that the returned shape 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 `shape` property
+	* @returns shape
+	*
+	* @example
+	* var zeros = require( '@stdlib/ndarray-zeros' );
+	*
+	* var sh = ns.shape( zeros( [ 3, 3, 3 ] ), false );
+	* // returns [ 3, 3, 3 ]
+	*/
+	shape: typeof shape;
+
 	/**
 	* Generates a stride array from an array shape.
 	*
@@ -1549,6 +2164,344 @@ interface Namespace {
 	*/
 	singletonDimensions: typeof singletonDimensions;
 
+	/**
+	* Returns a view of an input ndarray.
+	*
+	* @param x - input array
+	* @param s - multi-slice object
+	* @param strict - boolean indicating whether to enforce strict bounds checking
+	* @param writable - boolean indicating whether a returned array should be writable
+	* @returns output array
+	*
+	* @example
+	* var Slice = require( '@stdlib/ns.slice-ctor' );
+	* var MultiSlice = require( '@stdlib/ns.slice-multi' );
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
+	* var ndarray2array = require( '@stdlib/ndarray-to-array' );
+	*
+	* var buffer = [ 1, 2, 3, 4, 5, 6 ];
+	* var shape = [ 3, 2 ];
+	* var strides = [ 2, 1 ];
+	* var offset = 0;
+	*
+	* var x = ndarray( 'generic', 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 ] ]
+	*
+	* var s = new MultiSlice( new Slice( null, null, -2 ), new Slice( null, null, -1 ) );
+	* // returns <MultiSlice>
+	*
+	* var y = ns.slice( x, s, false, false );
+	* // returns <ndarray>
+	*
+	* sh = y.shape;
+	* // returns [ 2, 2 ]
+	*
+	* arr = ndarray2array( y );
+	* // returns [ [ 6, 5 ], [ 2, 1 ] ]
+	*/
+	slice: typeof slice;
+
+	/**
+	* Assigns element values from a broadcasted input ndarray to corresponding elements in an output ndarray view.
+	*
+	* ## Notes
+	*
+	* -   The input array must be broadcast compatible with the output array view to which elements will be assigned.
+	* -   The input array must have a data type which can be safely cast to the output array data type. Floating-point data types (both real and complex) are allowed to downcast to a lower precision data type of the same kind (e.g., element values from a `'float64'` input array can be assigned to corresponding elements in a `'float32'` output array).
+	*
+	* @param x - input array
+	* @param y - output array
+	* @param s - multi-slice object for the output array
+	* @param strict - boolean indicating whether to enforce strict bounds checking
+	* @returns output array
+	*
+	* @example
+	* var Slice = require( '@stdlib/slice-ctor' );
+	* var MultiSlice = require( '@stdlib/slice-multi' );
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
+	* var ndzeros = require( '@stdlib/ndarray-zeros' );
+	* var ndarray2array = require( '@stdlib/ndarray-to-array' );
+	*
+	* // Define an input array:
+	* var buffer = [ 1, 2, 3, 4, 5, 6 ];
+	* var shape = [ 3, 2 ];
+	* var strides = [ 2, 1 ];
+	* var offset = 0;
+	*
+	* var x = ndarray( 'generic', 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 ] ]
+	*
+	* // Define an output array:
+	* var y = ndzeros( [ 2, 3, 2 ], {
+	*     'dtype': x.dtype
+	* });
+	*
+	* // Create a slice:
+	* var s0 = null;
+	* var s1 = new Slice( null, null, -1 );
+	* var s2 = new Slice( null, null, -1 );
+	* var s = new MultiSlice( s0, s1, s2 );
+	* // returns <MultiSlice>
+	*
+	* // Perform assignment:
+	* var out = ns.sliceAssign( x, y, s, false );
+	* // returns <ndarray>
+	*
+	* var bool = ( out === y );
+	* // returns true
+	*
+	* arr = ndarray2array( y );
+	* // returns [ [ [ 6, 5 ], [ 4, 3 ], [ 2, 1 ] ], [ [ 6, 5 ], [ 4, 3 ], [ 2, 1 ] ] ]
+	*/
+	sliceAssign: typeof sliceAssign;
+
+	/**
+	* Returns a view of an input ndarray when sliced along a specified dimension.
+	*
+	* @param x - input array
+	* @param dim - index of dimension to slice
+	* @param s - slice object or an integer
+	* @param strict - boolean indicating whether to enforce strict bounds checking
+	* @param writable - boolean indicating whether a returned array should be writable
+	* @returns output array
+	*
+	* @example
+	* var Slice = require( '@stdlib/slice-ctor' );
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
+	* var ndarray2array = require( '@stdlib/ndarray-to-array' );
+	*
+	* var buffer = [ 1, 2, 3, 4, 5, 6 ];
+	* var shape = [ 3, 2 ];
+	* var strides = [ 2, 1 ];
+	* var offset = 0;
+	*
+	* var x = ndarray( 'generic', 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 ] ]
+	*
+	* var s = new Slice( null, null, -1 );
+	* // returns <Slice>
+	*
+	* var y = ns.sliceDimension( x, 0, s, false, false );
+	* // returns <ndarray>
+	*
+	* sh = y.shape;
+	* // returns [ 3, 2 ]
+	*
+	* arr = ndarray2array( y );
+	* // returns [ [ 5, 6 ], [ 3, 4 ], [ 1, 2 ] ]
+	*/
+	sliceDimension: typeof sliceDimension;
+
+	/**
+	* Returns a shifted view of an input ndarray along a specified dimension.
+	*
+	* @param x - input array
+	* @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
+	* @returns output array
+	*
+	* @example
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
+	* var ndarray2array = require( '@stdlib/ndarray-to-array' );
+	*
+	* var buffer = [ 1, 2, 3, 4, 5, 6 ];
+	* var shape = [ 3, 2 ];
+	* var strides = [ 2, 1 ];
+	* var offset = 0;
+	*
+	* var x = ndarray( 'generic', 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 ] ]
+	*
+	* var y = ns.sliceDimensionFrom( x, 0, 1, false, false );
+	* // returns <ndarray>
+	*
+	* sh = y.shape;
+	* // returns [ 2, 2 ]
+	*
+	* arr = ndarray2array( y );
+	* // returns [ [ 3, 4 ], [ 5, 6 ] ]
+	*/
+	sliceDimensionFrom: typeof sliceDimensionFrom;
+
+	/**
+	* Returns a truncated view of an input ndarray along a specified dimension.
+	*
+	* @param x - input array
+	* @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
+	* @returns output array
+	*
+	* @example
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
+	* var ndarray2array = require( '@stdlib/ndarray-to-array' );
+	*
+	* var buffer = [ 1, 2, 3, 4, 5, 6 ];
+	* var shape = [ 3, 2 ];
+	* var strides = [ 2, 1 ];
+	* var offset = 0;
+	*
+	* var x = ndarray( 'generic', 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 ] ]
+	*
+	* var y = ns.sliceDimensionTo( x, 0, 2, false, false );
+	* // returns <ndarray>
+	*
+	* sh = y.shape;
+	* // returns [ 2, 2 ]
+	*
+	* arr = ndarray2array( y );
+	* // returns [ [ 1, 2 ], [ 3, 4 ] ]
+	*/
+	sliceDimensionTo: typeof sliceDimensionTo;
+
+	/**
+	* Returns a shifted view of an input ndarray.
+	*
+	* @param x - input array
+	* @param start - starting indices (inclusive)
+	* @param strict - boolean indicating whether to enforce strict bounds checking
+	* @param writable - boolean indicating whether a returned array should be writable
+	* @returns output array
+	*
+	* @example
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
+	* var ndarray2array = require( '@stdlib/ndarray-to-array' );
+	*
+	* var buffer = [ 1, 2, 3, 4, 5, 6 ];
+	* var shape = [ 3, 2 ];
+	* var strides = [ 2, 1 ];
+	* var offset = 0;
+	*
+	* var x = ndarray( 'generic', 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 ] ]
+	*
+	* var s = [ 1, null ];
+	* var y = ns.sliceFrom( x, s, false, false );
+	* // returns <ndarray>
+	*
+	* sh = y.shape;
+	* // returns [ 2, 2 ]
+	*
+	* arr = ndarray2array( y );
+	* // returns [ [ 3, 4 ], [ 5, 6 ] ]
+	*/
+	sliceFrom: typeof sliceFrom;
+
+	/**
+	* Returns a truncated view of an input ndarray.
+	*
+	* @param x - input array
+	* @param stop - ending indices (exclusive)
+	* @param strict - boolean indicating whether to enforce strict bounds checking
+	* @param writable - boolean indicating whether a returned array should be writable
+	* @returns output array
+	*
+	* @example
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
+	* var ndarray2array = require( '@stdlib/ndarray-to-array' );
+	*
+	* var buffer = [ 1, 2, 3, 4, 5, 6 ];
+	* var shape = [ 3, 2 ];
+	* var strides = [ 2, 1 ];
+	* var offset = 0;
+	*
+	* var x = ndarray( 'generic', 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 ] ]
+	*
+	* var s = [ 2, null ];
+	* var y = ns.sliceTo( x, s, false, false );
+	* // returns <ndarray>
+	*
+	* sh = y.shape;
+	* // returns [ 2, 2 ]
+	*
+	* arr = ndarray2array( y );
+	* // returns [ [ 1, 2 ], [ 3, 4 ] ]
+	*/
+	sliceTo: typeof sliceTo;
+
+	/**
+	* Returns the stride along a specified dimension for a provided ndarray.
+	*
+	* ## Notes
+	*
+	* -   A "stride" is the linear distance (i.e., number of elements) between adjacent elements along a specified dimension.
+	*
+	* @param x - input ndarray
+	* @param dim - dimension index
+	* @returns stride
+	*
+	* @example
+	* var zeros = require( '@stdlib/ndarray-zeros' );
+	*
+	* var st = ns.stride( zeros( [ 3, 3, 3 ] ), 0 );
+	* // returns 9
+	*/
+	stride: typeof stride;
+
+	/**
+	* Returns the strides of a provided ndarray.
+	*
+	* ## Notes
+	*
+	* -   When `copy` is `false`, changes to the returned strides array may mutate the input ndarray strides. If there is a chance that the returned strides 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 `strides` property
+	* @returns strides
+	*
+	* @example
+	* var zeros = require( '@stdlib/ndarray-zeros' );
+	*
+	* var st = ns.strides( zeros( [ 3, 3, 3 ] ), false );
+	* // returns [ 9, 3, 1 ]
+	*/
+	strides: typeof strides;
+
 	/**
 	* Returns the index offset which specifies the location of the first indexed value in a multidimensional array based on a stride array.
 	*
@@ -1596,9 +2549,10 @@ interface Namespace {
 	*
 	* -   The function accepts the following "modes":
 	*
-	*     -   `throw`: throws an error when a subscript exceeds array dimensions.
-	*     -   `wrap`: wrap around subscripts exceeding array dimensions using modulo arithmetic.
-	*     -   `clamp`: set subscripts exceeding array dimensions to either `0` (minimum index) or the maximum index along a particular dimension.
+	*     -   **throw**: throw an error when a subscript exceeds array dimensions.
+	*     -   **normalize**: normalize negative subscripts and throw an error when a subscript exceeds array dimensions.
+	*     -   **wrap**: wrap around subscripts exceeding array dimensions using modulo arithmetic.
+	*     -   **clamp**: set subscripts exceeding array dimensions to either `0` (minimum index) or the maximum index along a particular dimension.
 	*
 	* -   When provided fewer modes than dimensions, the function recycles modes using modulo arithmetic.
 	*
@@ -1720,7 +2674,7 @@ interface Namespace {
 	* @returns ndarray view
 	*
 	* @example
-	* var array = require( `@stdlib/ndarray/array` );
+	* var array = require( '@stdlib/ndarray-array' );
 	*
 	* var x = array( [ [ 1, 2, 3 ], [ 4, 5, 6 ] ], {
 	*     'dtype': 'generic'
@@ -1753,8 +2707,8 @@ interface Namespace {
 	* @throws arrays must have the same shape
 	*
 	* @example
-	* var Float64Array = require( `@stdlib/array/float64` );
-	* var ndarray = require( `@stdlib/ndarray/ctor` );
+	* var Float64Array = require( '@stdlib/array-float64' );
+	* var ndarray = require( '@stdlib/ndarray-ctor' );
 	*
 	* function scale( x ) {
 	*     return x * 10.0;
@@ -1798,9 +2752,9 @@ interface Namespace {
 	* @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` );
+	* 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;
@@ -1973,7 +2927,7 @@ interface Namespace {
 	* @returns zero-filled array
 	*
 	* @example
-	* var zeros = require( `@stdlib/ndarray/base/zeros` );
+	* var zeros = require( '@stdlib/ndarray-base-zeros' );
 	*
 	* var x = zeros( 'generic', [ 2, 2 ], 'row-major' );
 	* // returns <ndarray>