diff --git a/lib/node_modules/@stdlib/blas/ext/base/ndarray/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/ext/base/ndarray/docs/types/index.d.ts
index 38db86e0dd84..57ef86ebf5e1 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/ndarray/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/blas/ext/base/ndarray/docs/types/index.d.ts
@@ -23,6 +23,7 @@
 import coneTo = require( '@stdlib/blas/ext/base/ndarray/cone-to' );
 import csum = require( '@stdlib/blas/ext/base/ndarray/csum' );
 import csumkbn = require( '@stdlib/blas/ext/base/ndarray/csumkbn' );
+import cunitspace = require( '@stdlib/blas/ext/base/ndarray/cunitspace' );
 import czeroTo = require( '@stdlib/blas/ext/base/ndarray/czero-to' );
 import dcircshift = require( '@stdlib/blas/ext/base/ndarray/dcircshift' );
 import dcusum = require( '@stdlib/blas/ext/base/ndarray/dcusum' );
@@ -48,6 +49,7 @@ import dsumkbn = require( '@stdlib/blas/ext/base/ndarray/dsumkbn' );
 import dsumkbn2 = require( '@stdlib/blas/ext/base/ndarray/dsumkbn2' );
 import dsumors = require( '@stdlib/blas/ext/base/ndarray/dsumors' );
 import dsumpw = require( '@stdlib/blas/ext/base/ndarray/dsumpw' );
+import dunitspace = require( '@stdlib/blas/ext/base/ndarray/dunitspace' );
 import dzeroTo = require( '@stdlib/blas/ext/base/ndarray/dzero-to' );
 import gcircshift = require( '@stdlib/blas/ext/base/ndarray/gcircshift' );
 import gcusum = require( '@stdlib/blas/ext/base/ndarray/gcusum' );
@@ -75,6 +77,7 @@ import gsumkbn = require( '@stdlib/blas/ext/base/ndarray/gsumkbn' );
 import gsumkbn2 = require( '@stdlib/blas/ext/base/ndarray/gsumkbn2' );
 import gsumors = require( '@stdlib/blas/ext/base/ndarray/gsumors' );
 import gsumpw = require( '@stdlib/blas/ext/base/ndarray/gsumpw' );
+import gunitspace = require( '@stdlib/blas/ext/base/ndarray/gunitspace' );
 import gzeroTo = require( '@stdlib/blas/ext/base/ndarray/gzero-to' );
 import scircshift = require( '@stdlib/blas/ext/base/ndarray/scircshift' );
 import scusum = require( '@stdlib/blas/ext/base/ndarray/scusum' );
@@ -97,10 +100,12 @@ import ssumkbn = require( '@stdlib/blas/ext/base/ndarray/ssumkbn' );
 import ssumkbn2 = require( '@stdlib/blas/ext/base/ndarray/ssumkbn2' );
 import ssumors = require( '@stdlib/blas/ext/base/ndarray/ssumors' );
 import ssumpw = require( '@stdlib/blas/ext/base/ndarray/ssumpw' );
+import sunitspace = require( '@stdlib/blas/ext/base/ndarray/sunitspace' );
 import szeroTo = require( '@stdlib/blas/ext/base/ndarray/szero-to' );
 import zoneTo = require( '@stdlib/blas/ext/base/ndarray/zone-to' );
 import zsum = require( '@stdlib/blas/ext/base/ndarray/zsum' );
 import zsumkbn = require( '@stdlib/blas/ext/base/ndarray/zsumkbn' );
+import zunitspace = require( '@stdlib/blas/ext/base/ndarray/zunitspace' );
 import zzeroTo = require( '@stdlib/blas/ext/base/ndarray/zzero-to' );
 
 /**
@@ -110,15 +115,19 @@ interface Namespace {
 	/**
 	* Fills a one-dimensional single-precision complex floating-point ndarray with linearly spaced numeric elements which increment by `1` starting from one.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns input ndarray
 	*
 	* @example
-	* var Complex64Array = require( '@stdlib/array/complex64' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Complex64Vector = require( '@stdlib/ndarray/vector/complex64' );
 	*
-	* var xbuf = new Complex64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
-	* var x = new ndarray( 'complex64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Complex64Vector( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
 	*
 	* var out = ns.coneTo( [ x ] );
 	* // returns <ndarray>[ <Complex64>[ 1.0, 0.0 ], <Complex64>[ 2.0, 0.0 ], <Complex64>[ 3.0, 0.0 ], <Complex64>[ 4.0, 0.0 ] ]
@@ -128,15 +137,19 @@ interface Namespace {
 	/**
 	* Computes the sum of all elements in a one-dimensional single-precision complex floating-point ndarray.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Complex64Array = require( '@stdlib/array/complex64' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Complex64Vector = require( '@stdlib/ndarray/vector/complex64' );
 	*
-	* var xbuf = new Complex64Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'complex64', xbuf, [ 2 ], [ 1 ], 0, 'row-major' );
+	* var x = new Complex64Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
 	*
 	* var v = ns.csum( [ x ] );
 	* // returns <Complex64>[ 5.0, 5.0 ]
@@ -146,33 +159,70 @@ interface Namespace {
 	/**
 	* Computes the sum of all elements in a one-dimensional single-precision complex floating-point ndarray using an improved Kahan–Babuška algorithm.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Complex64Array = require( '@stdlib/array/complex64' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Complex64Vector = require( '@stdlib/ndarray/vector/complex64' );
 	*
-	* var xbuf = new Complex64Array( [ 1.0, -2.0, 2.0, 3.0 ] );
-	* var x = new ndarray( 'complex64', xbuf, [ 2 ], [ 1 ], 0, 'row-major' );
+	* var x = new Complex64Vector( [ 1.0, -2.0, 2.0, 3.0 ] );
 	*
 	* var v = ns.csumkbn( [ x ] );
 	* // returns <Complex64>[ 3.0, 1.0 ]
 	*/
 	csumkbn: typeof csumkbn;
 
+	/**
+	* Fills a one-dimensional single-precision complex floating-point ndarray with linearly spaced numeric elements which increment by `1` starting from a specified value.
+	*
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray containing a starting value.
+	*
+	* @param arrays - array-like object containing ndarrays
+	* @returns input ndarray
+	*
+	* @example
+	* var Complex64Vector = require( '@stdlib/ndarray/vector/complex64' );
+	* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+	*
+	* var x = new Complex64Vector( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	*
+	* var start = scalar2ndarray( new Complex64( 3.0, 0.0 ), {
+	*     'dtype': 'complex64'
+	* });
+	*
+	* var out = ns.cunitspace( [ x, start ] );
+	* // returns <ndarray>[ <Complex64>[ 3.0, 0.0 ], <Complex64>[ 4.0, 0.0 ], <Complex64>[ 5.0, 0.0 ], <Complex64>[ 6.0, 0.0 ] ]
+	*/
+	cunitspace: typeof cunitspace;
+
 	/**
 	* Fills a one-dimensional single-precision complex floating-point ndarray with linearly spaced numeric elements which increment by `1` starting from zero.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns input ndarray
 	*
 	* @example
-	* var Complex64Array = require( '@stdlib/array/complex64' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Complex64Vector = require( '@stdlib/ndarray/vector/complex64' );
 	*
-	* var xbuf = new Complex64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
-	* var x = new ndarray( 'complex64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Complex64Vector( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
 	*
 	* var out = ns.czeroTo( [ x ] );
 	* // returns <ndarray>[ <Complex64>[ 0.0, 0.0 ], <Complex64>[ 1.0, 0.0 ], <Complex64>[ 2.0, 0.0 ], <Complex64>[ 3.0, 0.0 ] ]
@@ -182,16 +232,21 @@ interface Namespace {
 	/**
 	* Circularly shifts the elements of a one-dimensional double-precision floating-point ndarray by a specified number of positions.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying the number of positions to shift
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray specifying the number of positions to shift.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns input ndarray
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
 	*
-	* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 5 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
 	*
 	* var k = scalar2ndarray( 2, {
 	*    'dtype': 'generic'
@@ -205,26 +260,32 @@ interface Namespace {
 	/**
 	* Computes the cumulative sum of a one-dimensional double-precision floating-point ndarray.
 	*
-	* @param arrays - array-like object containing an input ndarray, an output ndarray, and ndarray containing the initial sum
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a one-dimensional output ndarray.
+	*     -   a zero-dimensional ndarray containing the initial sum.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns output ndarray
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
-	* var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
-	*
-	* var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
+	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var ybuf = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] );
-	* var y = new ndarray( 'float64', ybuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
+	* var y = new Float64Vector( [ 0.0, 0.0, 0.0, 0.0 ] );
 	*
-	* var initial = scalar2ndarray( 0.0, 'float64', 'row-major' );
+	* var initial = scalar2ndarray( 0.0, {
+	*     'dtype': 'float64'
+	* });
 	*
-	* var v = ns.dcusum( [ x, y, initial ] );
+	* var z = ns.dcusum( [ x, y, initial ] );
 	* // returns <ndarray>[ 1.0, 4.0, 8.0, 10.0 ]
 	*
-	* var bool = ( v === y );
+	* var bool = ( z === y );
 	* // returns true
 	*/
 	dcusum: typeof dcusum;
@@ -232,26 +293,32 @@ interface Namespace {
 	/**
 	* Computes the cumulative sum of a one-dimensional double-precision floating-point ndarray using an improved Kahan–Babuška algorithm.
 	*
-	* @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a one-dimensional output ndarray.
+	*     -   a zero-dimensional ndarray containing the initial sum.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns output ndarray
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
-	* var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
-	*
-	* var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
+	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var ybuf = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] );
-	* var y = new ndarray( 'float64', ybuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
+	* var y = new Float64Vector( [ 0.0, 0.0, 0.0, 0.0 ] );
 	*
-	* var initial = scalar2ndarray( 0.0, 'float64', 'row-major' );
+	* var initial = scalar2ndarray( 0.0, {
+	*     'dtype': 'float64'
+	* });
 	*
-	* var v = ns.dcusumkbn( [ x, y, initial ] );
+	* var z = ns.dcusumkbn( [ x, y, initial ] );
 	* // returns <ndarray>[ 1.0, 4.0, 8.0, 10.0 ]
 	*
-	* var bool = ( v === y );
+	* var bool = ( z === y );
 	* // returns true
 	*/
 	dcusumkbn: typeof dcusumkbn;
@@ -259,26 +326,32 @@ interface Namespace {
 	/**
 	* Computes the cumulative sum of a one-dimensional double-precision floating-point ndarray using a second-order iterative Kahan–Babuška algorithm.
 	*
-	* @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a one-dimensional output ndarray.
+	*     -   a zero-dimensional ndarray containing the initial sum.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns output ndarray
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
-	* var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
-	*
-	* var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
+	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var ybuf = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] );
-	* var y = new ndarray( 'float64', ybuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
+	* var y = new Float64Vector( [ 0.0, 0.0, 0.0, 0.0 ] );
 	*
-	* var initial = scalar2ndarray( 0.0, 'float64', 'row-major' );
+	* var initial = scalar2ndarray( 0.0, {
+	*     'dtype': 'float64'
+	* });
 	*
-	* var v = ns.dcusumkbn2( [ x, y, initial ] );
+	* var z = ns.dcusumkbn2( [ x, y, initial ] );
 	* // returns <ndarray>[ 1.0, 4.0, 8.0, 10.0 ]
 	*
-	* var bool = ( v === y );
+	* var bool = ( z === y );
 	* // returns true
 	*/
 	dcusumkbn2: typeof dcusumkbn2;
@@ -286,26 +359,32 @@ interface Namespace {
 	/**
 	* Computes the cumulative sum of a one-dimensional double-precision floating-point ndarray using ordinary recursive summation.
 	*
-	* @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a one-dimensional output ndarray.
+	*     -   a zero-dimensional ndarray containing the initial sum.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns output ndarray
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
-	* var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
-	*
-	* var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
+	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var ybuf = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] );
-	* var y = new ndarray( 'float64', ybuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
+	* var y = new Float64Vector( [ 0.0, 0.0, 0.0, 0.0 ] );
 	*
-	* var initial = scalar2ndarray( 0.0, 'float64', 'row-major' );
+	* var initial = scalar2ndarray( 0.0, {
+	*     'dtype': 'float64'
+	* });
 	*
-	* var v = ns.dcusumors( [ x, y, initial ] );
+	* var z = ns.dcusumors( [ x, y, initial ] );
 	* // returns <ndarray>[ 1.0, 4.0, 8.0, 10.0 ]
 	*
-	* var bool = ( v === y );
+	* var bool = ( z === y );
 	* // returns true
 	*/
 	dcusumors: typeof dcusumors;
@@ -313,26 +392,32 @@ interface Namespace {
 	/**
 	* Computes the cumulative sum of a one-dimensional double-precision floating-point ndarray using pairwise summation.
 	*
-	* @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a one-dimensional output ndarray.
+	*     -   a zero-dimensional ndarray containing the initial sum.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns output ndarray
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
-	* var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
-	*
-	* var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
+	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var ybuf = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] );
-	* var y = new ndarray( 'float64', ybuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
+	* var y = new Float64Vector( [ 0.0, 0.0, 0.0, 0.0 ] );
 	*
-	* var initial = scalar2ndarray( 0.0, 'float64', 'row-major' );
+	* var initial = scalar2ndarray( 0.0, {
+	*     'dtype': 'float64'
+	* });
 	*
-	* var v = ns.dcusumpw( [ x, y, initial ] );
+	* var z = ns.dcusumpw( [ x, y, initial ] );
 	* // returns <ndarray>[ 1.0, 4.0, 8.0, 10.0 ]
 	*
-	* var bool = ( v === y );
+	* var bool = ( z === y );
 	* // returns true
 	*/
 	dcusumpw: typeof dcusumpw;
@@ -340,16 +425,22 @@ interface Namespace {
 	/**
 	* Returns the first index of a search element in a one-dimensional double-precision floating-point ndarray.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray, a zero-dimensional ndarray containing the search element, and a zero-dimensional ndarray containing the index from which to begin searching
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray containing the search element.
+	*     -   a zero-dimensional ndarray containing the index from which to begin searching.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns index
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
 	*
 	* var searchElement = scalar2ndarray( 2.0, {
 	*     'dtype': 'float64'
@@ -367,16 +458,22 @@ interface Namespace {
 	/**
 	* Returns the last index of a search element in a one-dimensional double-precision floating-point ndarray.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray, a zero-dimensional ndarray containing the search element, and a zero-dimensional ndarray containing the index from which to begin searching
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray containing the search element.
+	*     -   a zero-dimensional ndarray containing the index from which to begin searching.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns index
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var xbuf = new Float64Array( [ 1.0, 2.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, 2.0, 4.0, 2.0 ] );
 	*
 	* var searchElement = scalar2ndarray( 2.0, {
 	*     'dtype': 'float64'
@@ -396,7 +493,7 @@ interface Namespace {
 	*
 	* ## Notes
 	*
-	* -   The function expects the following ndarrays in order:
+	* -   The function expects the following ndarrays:
 	*
 	*     -   a one-dimensional input ndarray.
 	*     -   a zero-dimensional ndarray specifying the start of the interval.
@@ -407,12 +504,10 @@ interface Namespace {
 	* @returns input ndarray
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var xbuf = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 6 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
 	*
 	* var start = scalar2ndarray( 0.0, {
 	*    'dtype': 'float64'
@@ -434,15 +529,19 @@ interface Namespace {
 	/**
 	* Computes the sum of a one-dimensional double-precision floating-point ndarray, ignoring NaN values.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
 	*
-	* var xbuf = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, -2.0, NaN, 2.0 ] );
 	*
 	* var v = ns.dnansum( [ x ] );
 	* // returns 1.0
@@ -452,15 +551,19 @@ interface Namespace {
 	/**
 	* Computes the sum of a one-dimensional double-precision floating-point ndarray, ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
 	*
-	* var xbuf = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, -2.0, NaN, 2.0 ] );
 	*
 	* var v = ns.dnansumkbn( [ x ] );
 	* // returns 1.0
@@ -470,15 +573,19 @@ interface Namespace {
 	/**
 	* Computes the sum of a one-dimensional double-precision floating-point ndarray, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
 	*
-	* var xbuf = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, -2.0, NaN, 2.0 ] );
 	*
 	* var v = ns.dnansumkbn2( [ x ] );
 	* // returns 1.0
@@ -488,15 +595,19 @@ interface Namespace {
 	/**
 	* Computes the sum of a one-dimensional double-precision floating-point ndarray, ignoring `NaN` values and using ordinary recursive summation.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
 	*
-	* var xbuf = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, -2.0, NaN, 2.0 ] );
 	*
 	* var v = ns.dnansumors( [ x ] );
 	* // returns 1.0
@@ -506,15 +617,19 @@ interface Namespace {
 	/**
 	* Computes the sum of a one-dimensional double-precision floating-point ndarray, ignoring `NaN` values and using pairwise summation.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
 	*
-	* var xbuf = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, -2.0, NaN, 2.0 ] );
 	*
 	* var v = ns.dnansumpw( [ x ] );
 	* // returns 1.0
@@ -524,15 +639,19 @@ interface Namespace {
 	/**
 	* Fills a one-dimensional double-precision floating-point ndarray with linearly spaced numeric elements which increment by `1` starting from one.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns input ndarray
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
 	*
-	* var xbuf = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 0.0, 0.0, 0.0, 0.0 ] );
 	* // returns <ndarray>[ 0.0, 0.0, 0.0, 0.0 ]
 	*
 	* var out = ns.doneTo( [ x ] );
@@ -545,18 +664,19 @@ interface Namespace {
 	*
 	* ## Notes
 	*
-	* -   When the sort order is less than zero, the input ndarray is sorted in **decreasing** order. When the sort order is greater than zero, the input ndarray is sorted in **increasing** order. When the sort order is equal to zero, the input ndarray is left unchanged.
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray specifying the sort order.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying the sort order
+	* @param arrays - array-like object containing ndarrays
 	* @returns input ndarray
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
 	*
-	* var xbuf = new Float64Array( [ 1.0, -2.0, 3.0, -4.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, -2.0, 3.0, -4.0 ] );
 	*
 	* var ord = scalar2ndarray( 1.0, {
 	*    'dtype': 'generic'
@@ -575,18 +695,19 @@ interface Namespace {
 	*
 	* ## Notes
 	*
-	* -   When the sort order is less than zero, the input ndarray is sorted in **decreasing** order. When the sort order is greater than zero, the input ndarray is sorted in **increasing** order. When the sort order is equal to zero, the input ndarray is left unchanged.
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray specifying the sort order.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying the sort order
+	* @param arrays - array-like object containing ndarrays
 	* @returns input ndarray
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
 	*
-	* var xbuf = new Float64Array( [ 1.0, -2.0, 3.0, -4.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, -2.0, 3.0, -4.0 ] );
 	*
 	* var ord = scalar2ndarray( 1.0, {
 	*    'dtype': 'generic'
@@ -602,18 +723,19 @@ interface Namespace {
 	*
 	* ## Notes
 	*
-	* -   When the sort order is less than zero, the input ndarray is sorted in **decreasing** order. When the sort order is greater than zero, the input ndarray is sorted in **increasing** order. When the sort order is equal to zero, the input ndarray is left unchanged.
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray specifying the sort order.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying the sort order
+	* @param arrays - array-like object containing ndarrays
 	* @returns input ndarray
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
 	*
-	* var xbuf = new Float64Array( [ 1.0, -2.0, 3.0, -4.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, -2.0, 3.0, -4.0 ] );
 	*
 	* var ord = scalar2ndarray( 1.0, {
 	*    'dtype': 'generic'
@@ -629,18 +751,19 @@ interface Namespace {
 	*
 	* ## Notes
 	*
-	* -   When the sort order is less than zero, the input ndarray is sorted in **decreasing** order. When the sort order is greater than zero, the input ndarray is sorted in **increasing** order. When the sort order is equal to zero, the input ndarray is left unchanged.
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray specifying the sort order.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying the sort order
+	* @param arrays - array-like object containing ndarrays
 	* @returns input ndarray
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
 	*
-	* var xbuf = new Float64Array( [ 1.0, -2.0, 3.0, -4.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, -2.0, 3.0, -4.0 ] );
 	*
 	* var ord = scalar2ndarray( 1.0, {
 	*    'dtype': 'generic'
@@ -654,15 +777,19 @@ interface Namespace {
 	/**
 	* Computes the sum of all elements in a one-dimensional double-precision floating-point ndarray.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
 	*
-	* var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
 	*
 	* var v = ns.dsum( [ x ] );
 	* // returns 10.0
@@ -672,15 +799,19 @@ interface Namespace {
 	/**
 	* Computes the sum of all elements in a one-dimensional double-precision floating-point ndarray using an improved Kahan–Babuška algorithm.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
 	*
-	* var xbuf = new Float64Array( [ 1.0, -2.0, 2.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 3 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, -2.0, 2.0 ] );
 	*
 	* var v = ns.dsumkbn( [ x ] );
 	* // returns 1.0
@@ -690,15 +821,19 @@ interface Namespace {
 	/**
 	* Computes the sum of all elements in a one-dimensional double-precision floating-point ndarray using a second-order iterative Kahan–Babuška algorithm.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
 	*
-	* var xbuf = new Float64Array( [ 1.0, -2.0, 2.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 3 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, -2.0, 2.0 ] );
 	*
 	* var v = ns.dsumkbn2( [ x ] );
 	* // returns 1.0
@@ -708,15 +843,19 @@ interface Namespace {
 	/**
 	* Computes the sum of a one-dimensional double-precision floating-point ndarray using ordinary recursive summation.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
 	*
-	* var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
 	*
 	* var v = ns.dsumors( [ x ] );
 	* // returns 10.0
@@ -726,33 +865,70 @@ interface Namespace {
 	/**
 	* Computes the sum of a one-dimensional double-precision floating-point ndarray using pairwise summation.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
 	*
-	* var xbuf = new Float64Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
 	*
 	* var v = ns.dsumpw( [ x ] );
 	* // returns 10.0
 	*/
 	dsumpw: typeof dsumpw;
 
+	/**
+	* Fills a one-dimensional double-precision floating-point ndarray with linearly spaced numeric elements which increment by `1` starting from a specified value.
+	*
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray containing a starting value.
+	*
+	* @param arrays - array-like object containing ndarrays
+	* @returns input ndarray
+	*
+	* @example
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
+	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+	*
+	* var x = new Float64Vector( [ 0.0, 0.0, 0.0, 0.0 ] );
+	* // returns <ndarray>[ 0.0, 0.0, 0.0, 0.0 ]
+	*
+	* var start = scalar2ndarray( 3.0, {
+	*     'dtype': 'float64'
+	* });
+	*
+	* var out = ns.dunitspace( [ x, start ] );
+	* // returns <ndarray>[ 3.0, 4.0, 5.0, 6.0 ]
+	*/
+	dunitspace: typeof dunitspace;
+
 	/**
 	* Fills a one-dimensional double-precision floating-point ndarray with linearly spaced numeric elements which increment by `1` starting from zero.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns input ndarray
 	*
 	* @example
-	* var Float64Array = require( '@stdlib/array/float64' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float64Vector = require( '@stdlib/ndarray/vector/float64' );
 	*
-	* var xbuf = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] );
-	* var x = new ndarray( 'float64', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float64Vector( [ 0.0, 0.0, 0.0, 0.0 ] );
 	* // returns <ndarray>[ 0.0, 0.0, 0.0, 0.0 ]
 	*
 	* var out = ns.dzeroTo( [ x ] );
@@ -763,15 +939,21 @@ interface Namespace {
 	/**
 	* Circularly shifts the elements of a one-dimensional ndarray by a specified number of positions.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying the number of positions to shift
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray specifying the number of positions to shift.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns input ndarray
 	*
 	* @example
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
 	*
-	* var xbuf = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 5 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, 2.0, 3.0, 4.0, 5.0 ], 'generic' );
 	*
 	* var k = scalar2ndarray( 2, {
 	*    'dtype': 'generic'
@@ -785,25 +967,32 @@ interface Namespace {
 	/**
 	* Computes the cumulative sum of a one-dimensional ndarray.
 	*
-	* @param arrays - array-like object containing an input ndarray, an output ndarray, and ndarray containing the initial sum
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a one-dimensional output ndarray.
+	*     -   a zero-dimensional ndarray containing the initial sum.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns output ndarray
 	*
 	* @example
-	* var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
-	*
-	* var xbuf = [ 1.0, 3.0, 4.0, 2.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
+	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var ybuf = [ 0.0, 0.0, 0.0, 0.0 ];
-	* var y = new ndarray( 'generic', ybuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, 3.0, 4.0, 2.0 ], 'generic' );
+	* var y = vector( [ 0.0, 0.0, 0.0, 0.0 ], 'generic' );
 	*
-	* var initial = scalar2ndarray( 0.0, 'generic', 'row-major' );
+	* var initial = scalar2ndarray( 0.0, {
+	*     'dtype': 'generic'
+	* });
 	*
-	* var v = ns.gcusum( [ x, y, initial ] );
+	* var z = ns.gcusum( [ x, y, initial ] );
 	* // returns <ndarray>[ 1.0, 4.0, 8.0, 10.0 ]
 	*
-	* var bool = ( v === y );
+	* var bool = ( z === y );
 	* // returns true
 	*/
 	gcusum: typeof gcusum;
@@ -811,25 +1000,32 @@ interface Namespace {
 	/**
 	* Computes the cumulative sum of a one-dimensional ndarray using an improved Kahan–Babuška algorithm.
 	*
-	* @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a one-dimensional output ndarray.
+	*     -   a zero-dimensional ndarray containing the initial sum.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns output ndarray
 	*
 	* @example
-	* var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
-	*
-	* var xbuf = [ 1.0, 3.0, 4.0, 2.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
+	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var ybuf = [ 0.0, 0.0, 0.0, 0.0 ];
-	* var y = new ndarray( 'generic', ybuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, 3.0, 4.0, 2.0 ], 'generic' );
+	* var y = vector( [ 0.0, 0.0, 0.0, 0.0 ], 'generic' );
 	*
-	* var initial = scalar2ndarray( 0.0, 'generic', 'row-major' );
+	* var initial = scalar2ndarray( 0.0, {
+	*     'dtype': 'generic'
+	* });
 	*
-	* var v = ns.gcusumkbn( [ x, y, initial ] );
+	* var z = ns.gcusumkbn( [ x, y, initial ] );
 	* // returns <ndarray>[ 1.0, 4.0, 8.0, 10.0 ]
 	*
-	* var bool = ( v === y );
+	* var bool = ( z === y );
 	* // returns true
 	*/
 	gcusumkbn: typeof gcusumkbn;
@@ -837,25 +1033,32 @@ interface Namespace {
 	/**
 	* Computes the cumulative sum of a one-dimensional ndarray using a second-order iterative Kahan–Babuška algorithm.
 	*
-	* @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a one-dimensional output ndarray.
+	*     -   a zero-dimensional ndarray containing the initial sum.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns output ndarray
 	*
 	* @example
-	* var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
-	*
-	* var xbuf = [ 1.0, 3.0, 4.0, 2.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
+	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var ybuf = [ 0.0, 0.0, 0.0, 0.0 ];
-	* var y = new ndarray( 'generic', ybuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, 3.0, 4.0, 2.0 ], 'generic' );
+	* var y = vector( [ 0.0, 0.0, 0.0, 0.0 ], 'generic' );
 	*
-	* var initial = scalar2ndarray( 0.0, 'generic', 'row-major' );
+	* var initial = scalar2ndarray( 0.0, {
+	*     'dtype': 'generic'
+	* });
 	*
-	* var v = ns.gcusumkbn2( [ x, y, initial ] );
+	* var z = ns.gcusumkbn2( [ x, y, initial ] );
 	* // returns <ndarray>[ 1.0, 4.0, 8.0, 10.0 ]
 	*
-	* var bool = ( v === y );
+	* var bool = ( z === y );
 	* // returns true
 	*/
 	gcusumkbn2: typeof gcusumkbn2;
@@ -863,25 +1066,32 @@ interface Namespace {
 	/**
 	* Computes the cumulative sum of a one-dimensional ndarray using ordinary recursive summation.
 	*
-	* @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum
-	* @returns output ndarray
+	* ## Notes
 	*
-	* @example
-	* var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a one-dimensional output ndarray.
+	*     -   a zero-dimensional ndarray containing the initial sum.
+	*
+	* @param arrays - array-like object containing ndarrays
+	* @returns output ndarray
 	*
-	* var xbuf = [ 1.0, 3.0, 4.0, 2.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* @example
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
+	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var ybuf = [ 0.0, 0.0, 0.0, 0.0 ];
-	* var y = new ndarray( 'generic', ybuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, 3.0, 4.0, 2.0 ], 'generic' );
+	* var y = vector( [ 0.0, 0.0, 0.0, 0.0 ], 'generic' );
 	*
-	* var initial = scalar2ndarray( 0.0, 'generic', 'row-major' );
+	* var initial = scalar2ndarray( 0.0, {
+	*     'dtype': 'generic'
+	* });
 	*
-	* var v = ns.gcusumors( [ x, y, initial ] );
+	* var z = ns.gcusumors( [ x, y, initial ] );
 	* // returns <ndarray>[ 1.0, 4.0, 8.0, 10.0 ]
 	*
-	* var bool = ( v === y );
+	* var bool = ( z === y );
 	* // returns true
 	*/
 	gcusumors: typeof gcusumors;
@@ -889,25 +1099,32 @@ interface Namespace {
 	/**
 	* Computes the cumulative sum of a one-dimensional ndarray using pairwise summation.
 	*
-	* @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a one-dimensional output ndarray.
+	*     -   a zero-dimensional ndarray containing the initial sum.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns output ndarray
 	*
 	* @example
-	* var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
-	*
-	* var xbuf = [ 1.0, 3.0, 4.0, 2.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
+	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var ybuf = [ 0.0, 0.0, 0.0, 0.0 ];
-	* var y = new ndarray( 'generic', ybuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, 3.0, 4.0, 2.0 ], 'generic' );
+	* var y = vector( [ 0.0, 0.0, 0.0, 0.0 ], 'generic' );
 	*
-	* var initial = scalar2ndarray( 0.0, 'generic', 'row-major' );
+	* var initial = scalar2ndarray( 0.0, {
+	*     'dtype': 'generic'
+	* });
 	*
-	* var v = ns.gcusumpw( [ x, y, initial ] );
+	* var z = ns.gcusumpw( [ x, y, initial ] );
 	* // returns <ndarray>[ 1.0, 4.0, 8.0, 10.0 ]
 	*
-	* var bool = ( v === y );
+	* var bool = ( z === y );
 	* // returns true
 	*/
 	gcusumpw: typeof gcusumpw;
@@ -917,22 +1134,25 @@ interface Namespace {
 	*
 	* ## Notes
 	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
 	* -   If no element passes a test implemented by a predicate function, the function returns `-1`.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* @param arrays - array-like object containing ndarrays
 	* @param clbk - predicate function
 	* @param thisArg - predicate function execution context
 	* @returns index
 	*
 	* @example
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	*
 	* function clbk( v ) {
 	*     return v % 2.0 === 0.0;
 	* }
 	*
-	* var xbuf = [ 1.0, 3.0, 4.0, 2.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, 3.0, 4.0, 2.0 ], 'generic' );
 	*
 	* var v = ns.gfindIndex( [ x ], clbk );
 	* // returns 2
@@ -944,22 +1164,25 @@ interface Namespace {
 	*
 	* ## Notes
 	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
 	* -   If no element passes a test implemented by a predicate function, the function returns `-1`.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* @param arrays - array-like object containing ndarrays
 	* @param clbk - predicate function
 	* @param thisArg - predicate execution context
 	* @returns index
 	*
 	* @example
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	*
 	* function clbk( v ) {
 	*     return v % 2.0 === 0.0;
 	* }
 	*
-	* var xbuf = [ 1.0, 3.0, 4.0, 2.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, 3.0, 4.0, 2.0 ], 'generic' );
 	*
 	* var v = ns.gfindLastIndex( [ x ], clbk );
 	* // returns 3
@@ -969,15 +1192,22 @@ interface Namespace {
 	/**
 	* Returns the first index of a search element in a one-dimensional ndarray.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray, a zero-dimensional ndarray containing the search element, and a zero-dimensional ndarray containing the index from which to begin searching
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray containing the search element.
+	*     -   a zero-dimensional ndarray containing the index from which to begin searching.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns index
 	*
 	* @example
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var xbuf = [ 1.0, 3.0, 4.0, 2.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, 3.0, 4.0, 2.0 ], 'generic' );
 	*
 	* var searchElement = scalar2ndarray( 2.0, {
 	*     'dtype': 'generic'
@@ -995,15 +1225,21 @@ interface Namespace {
 	/**
 	* Returns a string created by joining one-dimensional ndarray elements using a specified separator.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray containing a separator
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray containing a separator.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns joined string
 	*
 	* @example
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var xbuf = [ 1.0, 3.0, 4.0, 2.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, 3.0, 4.0, 2.0 ], 'generic' );
 	*
 	* var separator = scalar2ndarray( ',', {
 	*     'dtype': 'generic'
@@ -1017,15 +1253,23 @@ interface Namespace {
 	/**
 	* Returns a string by joining one-dimensional ndarray elements using a specified separator for each pair of consecutive elements.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray, a zero-dimensional ndarray containing a prefix string, a zero-dimensional ndarray containing a suffix string, and a one-dimensional ndarray containing separator strings
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray containing a prefix string.
+	*     -   a zero-dimensional ndarray containing a suffix string.
+	*     -   a one-dimensional ndarray containing separator strings.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns joined string
 	*
 	* @example
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var xbuf = [ 1, 2, 3, 4 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1, 2, 3, 4 ], 'generic' );
 	*
 	* var prefix = scalar2ndarray( 'op: ', {
 	*     'dtype': 'generic'
@@ -1035,8 +1279,7 @@ interface Namespace {
 	*     'dtype': 'generic'
 	* });
 	*
-	* var sbuf = [ ' + ', ' - ', ' != ' ];
-	* var separators = new ndarray( 'generic', sbuf, [ 3 ], [ 1 ], 0, 'row-major' );
+	* var separators = vector( [ ' + ', ' - ', ' != ' ], 'generic' );
 	*
 	* var v = ns.gjoinBetween( [ x, prefix, suffix, separators ] );
 	* // returns 'op: 1 + 2 - 3 != 4'
@@ -1046,15 +1289,22 @@ interface Namespace {
 	/**
 	* Returns the last index of a search element in a one-dimensional ndarray.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray, a zero-dimensional ndarray containing the search element, and a zero-dimensional ndarray containing the index from which to begin searching
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray containing the search element.
+	*     -   a zero-dimensional ndarray containing the index from which to begin searching.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns index
 	*
 	* @example
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var xbuf = [ 1.0, 2.0, 4.0, 2.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, 2.0, 4.0, 2.0 ], 'generic' );
 	*
 	* var searchElement = scalar2ndarray( 2.0, {
 	*     'dtype': 'generic'
@@ -1074,7 +1324,7 @@ interface Namespace {
 	*
 	* ## Notes
 	*
-	* -   The function expects the following ndarrays in order:
+	* -   The function expects the following ndarrays:
 	*
 	*     -   a one-dimensional input ndarray.
 	*     -   a zero-dimensional ndarray specifying the start of the interval.
@@ -1085,11 +1335,10 @@ interface Namespace {
 	* @returns input ndarray
 	*
 	* @example
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var xbuf = [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 6 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ], 'generic' );
 	*
 	* var start = scalar2ndarray( 0.0, {
 	*    'dtype': 'generic'
@@ -1111,14 +1360,19 @@ interface Namespace {
 	/**
 	* Computes the sum of a one-dimensional ndarray, ignoring `NaN` values.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	*
-	* var xbuf = [ 1.0, -2.0, NaN, 2.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, -2.0, NaN, 2.0 ], 'generic' );
 	*
 	* var v = ns.gnansum( [ x ] );
 	* // returns 1.0
@@ -1128,14 +1382,19 @@ interface Namespace {
 	/**
 	* Computes the sum of a one-dimensional ndarray, ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	*
-	* var xbuf = [ 1.0, -2.0, NaN, 2.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, -2.0, NaN, 2.0 ], 'generic' );
 	*
 	* var v = ns.gnansumkbn( [ x ] );
 	* // returns 1.0
@@ -1145,14 +1404,19 @@ interface Namespace {
 	/**
 	* Computes the sum of a one-dimensional ndarray, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	*
-	* var xbuf = [ 1.0, -2.0, NaN, 2.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, -2.0, NaN, 2.0 ], 'generic' );
 	*
 	* var v = ns.gnansumkbn2( [ x ] );
 	* // returns 1.0
@@ -1162,14 +1426,19 @@ interface Namespace {
 	/**
 	* Computes the sum of a one-dimensional ndarray, ignoring `NaN` values and using ordinary recursive summation.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	*
-	* var xbuf = [ 1.0, -2.0, NaN, 2.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, -2.0, NaN, 2.0 ], 'generic' );
 	*
 	* var v = ns.gnansumors( [ x ] );
 	* // returns 1.0
@@ -1179,14 +1448,19 @@ interface Namespace {
 	/**
 	* Computes the sum of a one-dimensional ndarray, ignoring `NaN` values and using pairwise summation.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	*
-	* var xbuf = [ 1.0, -2.0, NaN, 2.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, -2.0, NaN, 2.0 ], 'generic' );
 	*
 	* var v = ns.gnansumpw( [ x ] );
 	* // returns 1.0
@@ -1196,14 +1470,19 @@ interface Namespace {
 	/**
 	* Fills a one-dimensional ndarray with linearly spaced numeric elements which increment by `1` starting from one.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns input ndarray
 	*
 	* @example
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	*
-	* var xbuf = [ 0.0, 0.0, 0.0, 0.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 0.0, 0.0, 0.0, 0.0 ], 'generic' );
 	* // returns <ndarray>[ 0.0, 0.0, 0.0, 0.0 ]
 	*
 	* var out = ns.goneTo( [ x ] );
@@ -1216,24 +1495,25 @@ interface Namespace {
 	*
 	* ## Notes
 	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray specifying the sort order.
+	*
 	* -   When the sort order is less than zero, the input ndarray is sorted in **decreasing** order. When the sort order is greater than zero, the input ndarray is sorted in **increasing** order. When the sort order is equal to zero, the input ndarray is left unchanged.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying the sort order
+	* @param arrays - array-like object containing ndarrays
 	* @returns input ndarray
 	*
 	* @example
-	* var array = require( '@stdlib/ndarray/array' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var x = array( [ 1.0, -2.0, 3.0, -4.0 ], {
-	*    'dtype': 'generic'
-	* });
-	* // returns <ndarray>[ 1.0, -2.0, 3.0, -4.0 ]
+	* var x = vector( [ 1.0, -2.0, 3.0, -4.0 ], 'generic' );
 	*
 	* var ord = scalar2ndarray( 1.0, {
 	*    'dtype': 'generic'
 	* });
-	* // returns <ndarray>[ 1.0 ]
 	*
 	* var out = ns.gsort( [ x, ord ] );
 	* // returns <ndarray>[ -4.0, -2.0, 1.0, 3.0 ]
@@ -1245,17 +1525,21 @@ interface Namespace {
 	*
 	* ## Notes
 	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray specifying the sort order.
+	*
 	* -   When the sort order is less than zero, the input ndarray is sorted in **decreasing** order. When the sort order is greater than zero, the input ndarray is sorted in **increasing** order. When the sort order is equal to zero, the input ndarray is left unchanged.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying the sort order
+	* @param arrays - array-like object containing ndarrays
 	* @returns input ndarray
 	*
 	* @example
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
 	*
-	* var xbuf = [ 1.0, -2.0, 3.0, -4.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, -2.0, 3.0, -4.0 ], 'generic' );
 	*
 	* var ord = scalar2ndarray( 1.0, {
 	*    'dtype': 'generic'
@@ -1269,14 +1553,19 @@ interface Namespace {
 	/**
 	* Computes the sum of all elements in a one-dimensional ndarray.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	*
-	* var xbuf = [ 1.0, 3.0, 4.0, 2.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, 3.0, 4.0, 2.0 ], 'generic' );
 	*
 	* var v = ns.gsum( [ x ] );
 	* // returns 10.0
@@ -1286,14 +1575,19 @@ interface Namespace {
 	/**
 	* Computes the sum of all elements in a one-dimensional ndarray using an improved Kahan–Babuška algorithm.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	*
-	* var xbuf = [ 1.0, 3.0, 4.0, 2.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, 3.0, 4.0, 2.0 ], 'generic' );
 	*
 	* var v = ns.gsumkbn( [ x ] );
 	* // returns 10.0
@@ -1303,14 +1597,19 @@ interface Namespace {
 	/**
 	* Computes the sum of all elements in a one-dimensional ndarray using a second-order iterative Kahan–Babuška algorithm.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	*
-	* var xbuf = [ 1.0, 3.0, 4.0, 2.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, 3.0, 4.0, 2.0 ], 'generic' );
 	*
 	* var v = ns.gsumkbn2( [ x ] );
 	* // returns 10.0
@@ -1320,14 +1619,19 @@ interface Namespace {
 	/**
 	* Computes the sum of all elements in a one-dimensional ndarray using ordinary recursive summation.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	*
-	* var xbuf = [ 1.0, 3.0, 4.0, 2.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, 3.0, 4.0, 2.0 ], 'generic' );
 	*
 	* var v = ns.gsumors( [ x ] );
 	* // returns 10.0
@@ -1337,31 +1641,70 @@ interface Namespace {
 	/**
 	* Computes the sum of all elements in a one-dimensional ndarray using pairwise summation.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	*
-	* var xbuf = [ 1.0, 3.0, 4.0, 2.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 1.0, 3.0, 4.0, 2.0 ], 'generic' );
 	*
 	* var v = ns.gsumpw( [ x ] );
 	* // returns 10.0
 	*/
 	gsumpw: typeof gsumpw;
 
+	/**
+	* Fills a one-dimensional ndarray with linearly spaced numeric elements which increment by `1` starting from a specified value.
+	*
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray containing a starting value.
+	*
+	* @param arrays - array-like object containing ndarrays
+	* @returns input ndarray
+	*
+	* @example
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
+	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+	*
+	* var x = vector( [ 0.0, 0.0, 0.0, 0.0 ], 'generic' );
+	* // returns <ndarray>[ 0.0, 0.0, 0.0, 0.0 ]
+	*
+	* var start = scalar2ndarray( 3.0, {
+	*     'dtype': 'generic'
+	* });
+	*
+	* var out = ns.gunitspace( [ x, start ] );
+	* // returns <ndarray>[ 3.0, 4.0, 5.0, 6.0 ]
+	*/
+	gunitspace: typeof gunitspace;
+
 	/**
 	* Fills a one-dimensional ndarray with linearly spaced numeric elements which increment by `1` starting from zero.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns input ndarray
 	*
 	* @example
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var vector = require( '@stdlib/ndarray/vector/ctor' );
 	*
-	* var xbuf = [ 0.0, 0.0, 0.0, 0.0 ];
-	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = vector( [ 0.0, 0.0, 0.0, 0.0 ], 'generic' );
 	* // returns <ndarray>[ 0.0, 0.0, 0.0, 0.0 ]
 	*
 	* var out = ns.gzeroTo( [ x ] );
@@ -1372,16 +1715,21 @@ interface Namespace {
 	/**
 	* Circularly shifts the elements of a one-dimensional single-precision floating-point ndarray by a specified number of positions.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying the number of positions to shift
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray specifying the number of positions to shift.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns input ndarray
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
 	*
-	* var xbuf = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 5 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
 	*
 	* var k = scalar2ndarray( 2, {
 	*    'dtype': 'generic'
@@ -1395,26 +1743,32 @@ interface Namespace {
 	/**
 	* Computes the cumulative sum of a one-dimensional single-precision floating-point ndarray.
 	*
-	* @param arrays - array-like object containing an input ndarray, an output ndarray, and ndarray containing the initial sum
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a one-dimensional output ndarray.
+	*     -   a zero-dimensional ndarray containing the initial sum.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns output ndarray
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
-	* var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
-	*
-	* var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
+	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var ybuf = new Float32Array( [ 0.0, 0.0, 0.0, 0.0 ] );
-	* var y = new ndarray( 'float32', ybuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
+	* var y = new Float32Vector( [ 0.0, 0.0, 0.0, 0.0 ] );
 	*
-	* var initial = scalar2ndarray( 0.0, 'float32', 'row-major' );
+	* var initial = scalar2ndarray( 0.0, {
+	*     'dtype': 'float32'
+	* });
 	*
-	* var v = ns.scusum( [ x, y, initial ] );
+	* var z = ns.scusum( [ x, y, initial ] );
 	* // returns <ndarray>[ 1.0, 4.0, 8.0, 10.0 ]
 	*
-	* var bool = ( v === y );
+	* var bool = ( z === y );
 	* // returns true
 	*/
 	scusum: typeof scusum;
@@ -1422,26 +1776,32 @@ interface Namespace {
 	/**
 	* Computes the cumulative sum of a one-dimensional single-precision floating-point ndarray using an improved Kahan–Babuška algorithm.
 	*
-	* @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a one-dimensional output ndarray.
+	*     -   a zero-dimensional ndarray containing the initial sum.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns output ndarray
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
-	* var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
-	*
-	* var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
+	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var ybuf = new Float32Array( [ 0.0, 0.0, 0.0, 0.0 ] );
-	* var y = new ndarray( 'float32', ybuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
+	* var y = new Float32Vector( [ 0.0, 0.0, 0.0, 0.0 ] );
 	*
-	* var initial = scalar2ndarray( 0.0, 'float32', 'row-major' );
+	* var initial = scalar2ndarray( 0.0, {
+	*     'dtype': 'float32'
+	* });
 	*
-	* var v = ns.scusumkbn( [ x, y, initial ] );
+	* var z = ns.scusumkbn( [ x, y, initial ] );
 	* // returns <ndarray>[ 1.0, 4.0, 8.0, 10.0 ]
 	*
-	* var bool = ( v === y );
+	* var bool = ( z === y );
 	* // returns true
 	*/
 	scusumkbn: typeof scusumkbn;
@@ -1449,26 +1809,32 @@ interface Namespace {
 	/**
 	* Computes the cumulative sum of a one-dimensional single-precision floating-point ndarray using a second-order iterative Kahan–Babuška algorithm.
 	*
-	* @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a one-dimensional output ndarray.
+	*     -   a zero-dimensional ndarray containing the initial sum.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns output ndarray
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
-	* var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
-	*
-	* var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
+	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var ybuf = new Float32Array( [ 0.0, 0.0, 0.0, 0.0 ] );
-	* var y = new ndarray( 'float32', ybuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
+	* var y = new Float32Vector( [ 0.0, 0.0, 0.0, 0.0 ] );
 	*
-	* var initial = scalar2ndarray( 0.0, 'float32', 'row-major' );
+	* var initial = scalar2ndarray( 0.0, {
+	*     'dtype': 'float32'
+	* });
 	*
-	* var v = ns.scusumkbn2( [ x, y, initial ] );
+	* var z = ns.scusumkbn2( [ x, y, initial ] );
 	* // returns <ndarray>[ 1.0, 4.0, 8.0, 10.0 ]
 	*
-	* var bool = ( v === y );
+	* var bool = ( z === y );
 	* // returns true
 	*/
 	scusumkbn2: typeof scusumkbn2;
@@ -1476,26 +1842,32 @@ interface Namespace {
 	/**
 	* Computes the cumulative sum of a one-dimensional single-precision floating-point ndarray using ordinary recursive summation.
 	*
-	* @param arrays - array-like object containing an input ndarray, an output ndarray, and an ndarray containing the initial sum
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a one-dimensional output ndarray.
+	*     -   a zero-dimensional ndarray containing the initial sum.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns output ndarray
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
-	* var scalar2ndarray = require( '@stdlib/ndarray/base/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
-	*
-	* var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
+	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var ybuf = new Float32Array( [ 0.0, 0.0, 0.0, 0.0 ] );
-	* var y = new ndarray( 'float32', ybuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
+	* var y = new Float32Vector( [ 0.0, 0.0, 0.0, 0.0 ] );
 	*
-	* var initial = scalar2ndarray( 0.0, 'float32', 'row-major' );
+	* var initial = scalar2ndarray( 0.0, {
+	*     'dtype': 'float32'
+	* });
 	*
-	* var v = ns.scusumors( [ x, y, initial ] );
+	* var z = ns.scusumors( [ x, y, initial ] );
 	* // returns <ndarray>[ 1.0, 4.0, 8.0, 10.0 ]
 	*
-	* var bool = ( v === y );
+	* var bool = ( z === y );
 	* // returns true
 	*/
 	scusumors: typeof scusumors;
@@ -1503,16 +1875,22 @@ interface Namespace {
 	/**
 	* Returns the first index of a search element in a one-dimensional single-precision floating-point ndarray.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray, a zero-dimensional ndarray containing the search element, and a zero-dimensional ndarray containing the index from which to begin searching
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray containing the search element.
+	*     -   a zero-dimensional ndarray containing the index from which to begin searching.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns index
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
 	*
 	* var searchElement = scalar2ndarray( 2.0, {
 	*     'dtype': 'float32'
@@ -1530,16 +1908,22 @@ interface Namespace {
 	/**
 	* Returns the last index of a search element in a one-dimensional single-precision floating-point ndarray.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray, a zero-dimensional ndarray containing the search element, and a zero-dimensional ndarray containing the index from which to begin searching
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray containing the search element.
+	*     -   a zero-dimensional ndarray containing the index from which to begin searching.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns index
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var xbuf = new Float32Array( [ 1.0, 2.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 1.0, 2.0, 4.0, 2.0 ] );
 	*
 	* var searchElement = scalar2ndarray( 2.0, {
 	*     'dtype': 'float32'
@@ -1559,7 +1943,7 @@ interface Namespace {
 	*
 	* ## Notes
 	*
-	* -   The function expects the following ndarrays in order:
+	* -   The function expects the following ndarrays:
 	*
 	*     -   a one-dimensional input ndarray.
 	*     -   a zero-dimensional ndarray specifying the start of the interval.
@@ -1570,12 +1954,10 @@ interface Namespace {
 	* @returns input ndarray
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 	*
-	* var xbuf = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 6 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
 	*
 	* var start = scalar2ndarray( 0.0, {
 	*    'dtype': 'float32'
@@ -1597,15 +1979,19 @@ interface Namespace {
 	/**
 	* Computes the sum of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
 	*
-	* var xbuf = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 1.0, -2.0, NaN, 2.0 ] );
 	*
 	* var v = ns.snansum( [ x ] );
 	* // returns 1.0
@@ -1615,15 +2001,19 @@ interface Namespace {
 	/**
 	* Computes the sum of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
 	*
-	* var xbuf = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 1.0, -2.0, NaN, 2.0 ] );
 	*
 	* var v = ns.snansumkbn( [ x ] );
 	* // returns 1.0
@@ -1633,15 +2023,19 @@ interface Namespace {
 	/**
 	* Computes the sum of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
 	*
-	* var xbuf = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 1.0, -2.0, NaN, 2.0 ] );
 	*
 	* var v = ns.snansumkbn2( [ x ] );
 	* // returns 1.0
@@ -1651,15 +2045,19 @@ interface Namespace {
 	/**
 	* Computes the sum of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values and using ordinary recursive summation.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
 	*
-	* var xbuf = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 1.0, -2.0, NaN, 2.0 ] );
 	*
 	* var v = ns.snansumors( [ x ] );
 	* // returns 1.0
@@ -1669,15 +2067,19 @@ interface Namespace {
 	/**
 	* Computes the sum of a one-dimensional single-precision floating-point ndarray, ignoring `NaN` values and using pairwise summation.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
 	*
-	* var xbuf = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 1.0, -2.0, NaN, 2.0 ] );
 	*
 	* var v = ns.snansumpw( [ x ] );
 	* // returns 1.0
@@ -1687,15 +2089,19 @@ interface Namespace {
 	/**
 	* Fills a one-dimensional single-precision floating-point ndarray with linearly spaced numeric elements which increment by `1` starting from one.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns input ndarray
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
 	*
-	* var xbuf = new Float32Array( [ 0.0, 0.0, 0.0, 0.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 0.0, 0.0, 0.0, 0.0 ] );
 	* // returns <ndarray>[ 0.0, 0.0, 0.0, 0.0 ]
 	*
 	* var out = ns.soneTo( [ x ] );
@@ -1708,18 +2114,21 @@ interface Namespace {
 	*
 	* ## Notes
 	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray specifying the sort order.
+	*
 	* -   When the sort order is less than zero, the input ndarray is sorted in **decreasing** order. When the sort order is greater than zero, the input ndarray is sorted in **increasing** order. When the sort order is equal to zero, the input ndarray is left unchanged.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying the sort order
+	* @param arrays - array-like object containing ndarrays
 	* @returns input ndarray
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
 	*
-	* var xbuf = new Float32Array( [ 1.0, -2.0, 3.0, -4.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 1.0, -2.0, 3.0, -4.0 ] );
 	*
 	* var ord = scalar2ndarray( 1.0, {
 	*    'dtype': 'generic'
@@ -1738,18 +2147,21 @@ interface Namespace {
 	*
 	* ## Notes
 	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray specifying the sort order.
+	*
 	* -   When the sort order is less than zero, the input ndarray is sorted in **decreasing** order. When the sort order is greater than zero, the input ndarray is sorted in **increasing** order. When the sort order is equal to zero, the input ndarray is left unchanged.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying the sort order
+	* @param arrays - array-like object containing ndarrays
 	* @returns input ndarray
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
 	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
 	*
-	* var xbuf = new Float32Array( [ 1.0, -2.0, 3.0, -4.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 1.0, -2.0, 3.0, -4.0 ] );
 	*
 	* var ord = scalar2ndarray( 1.0, {
 	*    'dtype': 'generic'
@@ -1763,15 +2175,19 @@ interface Namespace {
 	/**
 	* Computes the sum of all elements in a one-dimensional single-precision floating-point ndarray.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
 	*
-	* var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
 	*
 	* var v = ns.ssum( [ x ] );
 	* // returns 10.0
@@ -1781,15 +2197,19 @@ interface Namespace {
 	/**
 	* Computes the sum of all elements in a one-dimensional single-precision floating-point ndarray using an improved Kahan–Babuška algorithm.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
 	*
-	* var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
 	*
 	* var v = ns.ssumkbn( [ x ] );
 	* // returns 10.0
@@ -1799,15 +2219,19 @@ interface Namespace {
 	/**
 	* Computes the sum of all elements in a one-dimensional single-precision floating-point ndarray using a second-order iterative Kahan–Babuška algorithm.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
 	*
-	* var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
 	*
 	* var v = ns.ssumkbn2( [ x ] );
 	* // returns 10.0
@@ -1817,15 +2241,19 @@ interface Namespace {
 	/**
 	* Computes the sum of a one-dimensional single-precision floating-point ndarray using ordinary recursive summation.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
 	*
-	* var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
 	*
 	* var v = ns.ssumors( [ x ] );
 	* // returns 10.0
@@ -1835,33 +2263,70 @@ interface Namespace {
 	/**
 	* Computes the sum of all elements in a one-dimensional single-precision floating-point ndarray using pairwise summation.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
 	*
-	* var xbuf = new Float32Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
 	*
 	* var v = ns.ssumpw( [ x ] );
 	* // returns 10.0
 	*/
 	ssumpw: typeof ssumpw;
 
+	/**
+	* Fills a one-dimensional single-precision floating-point ndarray with linearly spaced numeric elements which increment by `1` starting from a specified value.
+	*
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray containing a starting value.
+	*
+	* @param arrays - array-like object containing ndarrays
+	* @returns input ndarray
+	*
+	* @example
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
+	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+	*
+	* var x = new Float32Vector( [ 0.0, 0.0, 0.0, 0.0 ] );
+	* // returns <ndarray>[ 0.0, 0.0, 0.0, 0.0 ]
+	*
+	* var start = scalar2ndarray( 3.0, {
+	*     'dtype': 'float32'
+	* });
+	*
+	* var out = ns.sunitspace( [ x, start ] );
+	* // returns <ndarray>[ 3.0, 4.0, 5.0, 6.0 ]
+	*/
+	sunitspace: typeof sunitspace;
+
 	/**
 	* Fills a one-dimensional single-precision floating-point ndarray with linearly spaced numeric elements which increment by `1` starting from zero.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns input ndarray
 	*
 	* @example
-	* var Float32Array = require( '@stdlib/array/float32' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Float32Vector = require( '@stdlib/ndarray/vector/float32' );
 	*
-	* var xbuf = new Float32Array( [ 0.0, 0.0, 0.0, 0.0 ] );
-	* var x = new ndarray( 'float32', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Float32Vector( [ 0.0, 0.0, 0.0, 0.0 ] );
 	* // returns <ndarray>[ 0.0, 0.0, 0.0, 0.0 ]
 	*
 	* var out = ns.szeroTo( [ x ] );
@@ -1872,15 +2337,19 @@ interface Namespace {
 	/**
 	* Fills a one-dimensional double-precision complex floating-point ndarray with linearly spaced numeric elements which increment by `1` starting from one.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns input ndarray
 	*
 	* @example
-	* var Complex128Array = require( '@stdlib/array/complex128' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Complex128Vector = require( '@stdlib/ndarray/vector/complex128' );
 	*
-	* var xbuf = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
-	* var x = new ndarray( 'complex128', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Complex128Vector( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
 	*
 	* var out = ns.zoneTo( [ x ] );
 	* // returns <ndarray>[ <Complex128>[ 1.0, 0.0 ], <Complex128>[ 2.0, 0.0 ], <Complex128>[ 3.0, 0.0 ], <Complex128>[ 4.0, 0.0 ] ]
@@ -1890,15 +2359,19 @@ interface Namespace {
 	/**
 	* Computes the sum of all elements in a one-dimensional double-precision complex floating-point ndarray.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Complex128Array = require( '@stdlib/array/complex128' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Complex128Vector = require( '@stdlib/ndarray/vector/complex128' );
 	*
-	* var xbuf = new Complex128Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'complex128', xbuf, [ 2 ], [ 1 ], 0, 'row-major' );
+	* var x = new Complex128Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
 	*
 	* var v = ns.zsum( [ x ] );
 	* // returns <Complex128>[ 5.0, 5.0 ]
@@ -1908,33 +2381,70 @@ interface Namespace {
 	/**
 	* Computes the sum of all elements in a one-dimensional double-precision complex floating-point ndarray using an improved Kahan–Babuška algorithm.
 	*
-	* @param arrays - array-like object containing an input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns sum
 	*
 	* @example
-	* var Complex128Array = require( '@stdlib/array/complex128' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Complex128Vector = require( '@stdlib/ndarray/vector/complex128' );
 	*
-	* var xbuf = new Complex128Array( [ 1.0, 3.0, 4.0, 2.0 ] );
-	* var x = new ndarray( 'complex128', xbuf, [ 2 ], [ 1 ], 0, 'row-major' );
+	* var x = new Complex128Vector( [ 1.0, 3.0, 4.0, 2.0 ] );
 	*
 	* var v = ns.zsumkbn( [ x ] );
 	* // returns <Complex128>[ 5.0, 5.0 ]
 	*/
 	zsumkbn: typeof zsumkbn;
 
+	/**
+	* Fills a one-dimensional double-precision complex floating-point ndarray with linearly spaced numeric elements which increment by `1` starting from a specified value.
+	*
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*     -   a zero-dimensional ndarray containing a starting value.
+	*
+	* @param arrays - array-like object containing ndarrays
+	* @returns input ndarray
+	*
+	* @example
+	* var Complex128Vector = require( '@stdlib/ndarray/vector/complex128' );
+	* var Complex128 = require( '@stdlib/complex/float64/ctor' );
+	* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+	*
+	* var x = new Complex128Vector( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	*
+	* var start = scalar2ndarray( new Complex128( 3.0, 0.0 ), {
+	*     'dtype': 'complex128'
+	* });
+	*
+	* var out = ns.zunitspace( [ x, start ] );
+	* // returns <ndarray>[ <Complex128>[ 3.0, 0.0 ], <Complex128>[ 4.0, 0.0 ], <Complex128>[ 5.0, 0.0 ], <Complex128>[ 6.0, 0.0 ] ]
+	*/
+	zunitspace: typeof zunitspace;
+
 	/**
 	* Fills a one-dimensional double-precision complex floating-point ndarray with linearly spaced numeric elements which increment by `1` starting from zero.
 	*
-	* @param arrays - array-like object containing a one-dimensional input ndarray
+	* ## Notes
+	*
+	* -   The function expects the following ndarrays:
+	*
+	*     -   a one-dimensional input ndarray.
+	*
+	* @param arrays - array-like object containing ndarrays
 	* @returns input ndarray
 	*
 	* @example
-	* var Complex128Array = require( '@stdlib/array/complex128' );
-	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	* var Complex128Vector = require( '@stdlib/ndarray/vector/complex128' );
 	*
-	* var xbuf = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
-	* var x = new ndarray( 'complex128', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* var x = new Complex128Vector( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
 	*
 	* var out = ns.zzeroTo( [ x ] );
 	* // returns <ndarray>[ <Complex128>[ 0.0, 0.0 ], <Complex128>[ 1.0, 0.0 ], <Complex128>[ 2.0, 0.0 ], <Complex128>[ 3.0, 0.0 ] ]