feat: update namespace TypeScript declarations

lib/node_modules/@stdlib/assert/docs/types/index.d.ts

@@ -108,8 +108,14 @@ import isComplexTypedArray = require( '@stdlib/assert/is-complex-typed-array' );
 import isComplexTypedArrayLike = require( '@stdlib/assert/is-complex-typed-array-like' );
 import isComplex64 = require( '@stdlib/assert/is-complex64' );
 import isComplex64Array = require( '@stdlib/assert/is-complex64array' );
+import isComplex64MatrixLike = require( '@stdlib/assert/is-complex64matrix-like' );
+import isComplex64ndarrayLike = require( '@stdlib/assert/is-complex64ndarray-like' );
+import isComplex64VectorLike = require( '@stdlib/assert/is-complex64vector-like' );
 import isComplex128 = require( '@stdlib/assert/is-complex128' );
 import isComplex128Array = require( '@stdlib/assert/is-complex128array' );
+import isComplex128MatrixLike = require( '@stdlib/assert/is-complex128matrix-like' );
+import isComplex128ndarrayLike = require( '@stdlib/assert/is-complex128ndarray-like' );
+import isComplex128VectorLike = require( '@stdlib/assert/is-complex128vector-like' );
 import isComposite = require( '@stdlib/assert/is-composite' );
 import isConfigurableProperty = require( '@stdlib/assert/is-configurable-property' );
 import isConfigurablePropertyIn = require( '@stdlib/assert/is-configurable-property-in' );
@@ -2093,6 +2099,66 @@ interface Namespace {
 	*/
 	isComplex64Array: typeof isComplex64Array;
 
+	/**
+	* Tests if a value is a 2-dimensional ndarray-like object whose underlying data type is `complex64`.
+	*
+	* @param v - value to test
+	* @returns boolean indicating if a value is a 2-dimensional ndarray-like object whose underlying data type is `complex64`
+	*
+	* @example
+	* var Complex64Array = require( `@stdlib/array/complex64` );
+	* var ndarray = require( `@stdlib/ndarray/ctor` );
+	*
+	* var arr = ndarray( 'complex64', new Complex64Array( [ 0, 0, 0, 0, 0, 0, 0, 0 ] ), [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+	*
+	* var bool = ns.isComplex64MatrixLike( arr );
+	* // returns true
+	*
+	* bool = ns.isComplex64MatrixLike( [] );
+	* // returns false
+	*/
+	isComplex64MatrixLike: typeof isComplex64MatrixLike;
+
+	/**
+	* Tests if a value is an ndarray-like object whose underlying data type is `complex64`.
+	*
+	* @param v - value to test
+	* @returns boolean indicating if a value is an ndarray-like object whose underlying data type is `complex64`
+	*
+	* @example
+	* var Complex64Array = require( `@stdlib/array/complex64` );
+	* var ndarray = require( `@stdlib/ndarray/ctor` );
+	*
+	* var arr = ndarray( 'complex64', new Complex64Array( [ 0, 0, 0, 0, 0, 0, 0, 0 ] ), [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+	*
+	* var bool = ns.isComplex64ndarrayLike( arr );
+	* // returns true
+	*
+	* bool = ns.isComplex64ndarrayLike( [] );
+	* // returns false
+	*/
+	isComplex64ndarrayLike: typeof isComplex64ndarrayLike;
+
+	/**
+	* Tests if a value is a 1-dimensional ndarray-like object whose underlying data type is `complex64`.
+	*
+	* @param v - value to test
+	* @returns boolean indicating if a value is a 1-dimensional ndarray-like object whose underlying data type is `complex64`
+	*
+	* @example
+	* var Complex64Array = require( `@stdlib/array/complex64` );
+	* var ndarray = require( `@stdlib/ndarray/ctor` );
+	*
+	* var arr = ndarray( 'complex64', new Complex64Array( [ 0, 0, 0, 0, 0, 0, 0, 0 ] ), [ 4 ], [ 1 ], 0, 'row-major' );
+	*
+	* var bool = ns.isComplex64VectorLike( arr );
+	* // returns true
+	*
+	* bool = ns.isComplex64VectorLike( [] );
+	* // returns false
+	*/
+	isComplex64VectorLike: typeof isComplex64VectorLike;
+
 	/**
 	* Tests if a value is a 128-bit complex number.
 	*
@@ -2125,6 +2191,66 @@ interface Namespace {
 	*/
 	isComplex128Array: typeof isComplex128Array;
 
+	/**
+	* Tests if a value is a 2-dimensional ndarray-like object whose underlying data type is `complex128`.
+	*
+	* @param v - value to test
+	* @returns boolean indicating if a value is a 2-dimensional ndarray-like object whose underlying data type is `complex128`
+	*
+	* @example
+	* var Complex128Array = require( `@stdlib/array/complex128` );
+	* var ndarray = require( `@stdlib/ndarray/ctor` );
+	*
+	* var arr = ndarray( 'complex128', new Complex128Array( [ 0, 0, 0, 0, 0, 0, 0, 0 ] ), [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+	*
+	* var bool = ns.isComplex128MatrixLike( arr );
+	* // returns true
+	*
+	* bool = ns.isComplex128MatrixLike( [] );
+	* // returns false
+	*/
+	isComplex128MatrixLike: typeof isComplex128MatrixLike;
+
+	/**
+	* Tests if a value is an ndarray-like object whose underlying data type is `complex128`.
+	*
+	* @param v - value to test
+	* @returns boolean indicating if a value is an ndarray-like object whose underlying data type is `complex128`
+	*
+	* @example
+	* var Complex128Array = require( `@stdlib/array/complex128` );
+	* var ndarray = require( `@stdlib/ndarray/ctor` );
+	*
+	* var arr = ndarray( 'complex128', new Complex128Array( [ 0, 0, 0, 0, 0, 0, 0, 0 ] ), [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+	*
+	* var bool = ns.isComplex128ndarrayLike( arr );
+	* // returns true
+	*
+	* bool = ns.isComplex128ndarrayLike( [] );
+	* // returns false
+	*/
+	isComplex128ndarrayLike: typeof isComplex128ndarrayLike;
+
+	/**
+	* Tests if a value is a 1-dimensional ndarray-like object whose underlying data type is `complex128`.
+	*
+	* @param v - value to test
+	* @returns boolean indicating if a value is a 1-dimensional ndarray-like object whose underlying data type is `complex128`
+	*
+	* @example
+	* var Complex128Array = require( `@stdlib/array/complex128` );
+	* var ndarray = require( `@stdlib/ndarray/ctor` );
+	*
+	* var arr = ndarray( 'complex128', new Complex128Array( [ 0, 0, 0, 0, 0, 0, 0, 0 ] ), [ 4 ], [ 1 ], 0, 'row-major' );
+	*
+	* var bool = ns.isComplex128VectorLike( arr );
+	* // returns true
+	*
+	* bool = ns.isComplex128VectorLike( [] );
+	* // returns false
+	*/
+	isComplex128VectorLike: typeof isComplex128VectorLike;
+
 	/**
 	* Tests if a value is a composite number.
 	*

lib/node_modules/@stdlib/blas/base/docs/types/index.d.ts

@@ -264,7 +264,7 @@ interface Namespace {
 	* @param strideX - `x` stride length
 	* @param y - second input array
 	* @param strideY - `y` stride length
-	* @returns dot product of `x` and `y`
+	* @returns dot product
 	*
 	* @example
 	* var Float64Array = require( `@stdlib/array/float64` );
@@ -319,7 +319,7 @@ interface Namespace {
 	* @param alpha - constant
 	* @param x - input array
 	* @param stride - stride length
-	* @returns `x`
+	* @returns input array
 	*
 	* @example
 	* var Float64Array = require( `@stdlib/array/float64` );
@@ -347,7 +347,7 @@ interface Namespace {
 	* @param strideX - `x` stride length
 	* @param y - second input array
 	* @param strideY - `y` stride length
-	* @returns dot product of `x` and `y`
+	* @returns dot product
 	*
 	* @example
 	* var Float32Array = require( `@stdlib/array/float32` );
@@ -430,9 +430,9 @@ interface Namespace {
 	* @param alpha - constant
 	* @param x - input array
 	* @param strideX - `x` stride length
-	* @param y - destination array
+	* @param y - output array
 	* @param strideY - `y` stride length
-	* @returns `y`
+	* @returns output array
 	*
 	* @example
 	* var x = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];
@@ -456,9 +456,9 @@ interface Namespace {
 	* @param N - number of indexed elements
 	* @param x - input array
 	* @param strideX - `x` stride length
-	* @param y - destination array
+	* @param y - output array
 	* @param strideY - `y` stride length
-	* @returns `y`
+	* @returns output array
 	*
 	* @example
 	* var x = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];
@@ -484,7 +484,7 @@ interface Namespace {
 	* @param strideX - `x` stride length
 	* @param y - second input array
 	* @param strideY - `y` stride length
-	* @returns dot product of `x` and `y`
+	* @returns dot product
 	*
 	* @example
 	* var x = [ 4.0, 2.0, -3.0, 5.0, -1.0 ];
@@ -531,7 +531,7 @@ interface Namespace {
 	* @param alpha - constant
 	* @param x - input array
 	* @param stride - stride length
-	* @returns `x`
+	* @returns input array
 	*
 	* @example
 	* var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ];
@@ -779,7 +779,7 @@ interface Namespace {
 	* @param alpha - constant
 	* @param x - input array
 	* @param stride - stride length
-	* @returns `x`
+	* @returns input array
 	*
 	* @example
 	* var Float32Array = require( `@stdlib/array/float32` );

lib/node_modules/@stdlib/math/base/napi/docs/types/index.d.ts

@@ -21,6 +21,8 @@
 /* eslint-disable max-lines */
 
 import binary = require( '@stdlib/math/base/napi/binary' );
+import quaternary = require( '@stdlib/math/base/napi/quaternary' );
+import quinary = require( '@stdlib/math/base/napi/quinary' );
 import ternary = require( '@stdlib/math/base/napi/ternary' );
 import unary = require( '@stdlib/math/base/napi/unary' );
 
@@ -37,6 +39,24 @@ interface Namespace {
 	*/
 	binary: typeof binary;
 
+	/**
+	* Absolute file path for the directory containing header files for C APIs.
+	*
+	* @example
+	* var dir = ns.quaternary;
+	* // returns <string>
+	*/
+	quaternary: typeof quaternary;
+
+	/**
+	* Absolute file path for the directory containing header files for C APIs.
+	*
+	* @example
+	* var dir = ns.quinary;
+	* // returns <string>
+	*/
+	quinary: typeof quinary;
+
 	/**
 	* Absolute file path for the directory containing header files for C APIs.
 	*

lib/node_modules/@stdlib/math/base/ops/docs/types/index.d.ts

@@ -22,6 +22,8 @@
 
 import add = require( '@stdlib/math/base/ops/add' );
 import add3 = require( '@stdlib/math/base/ops/add3' );
+import add4 = require( '@stdlib/math/base/ops/add4' );
+import add5 = require( '@stdlib/math/base/ops/add5' );
 import addf = require( '@stdlib/math/base/ops/addf' );
 import cadd = require( '@stdlib/math/base/ops/cadd' );
 import caddf = require( '@stdlib/math/base/ops/caddf' );
@@ -106,6 +108,69 @@ interface Namespace {
 	*/
 	add3: typeof add3;
 
+	/**
+	* Computes the sum of four double-precision floating-point numbers.
+	*
+	* @param x - first input value
+	* @param y - second input value
+	* @param z - third input value
+	* @param w - fourth input value
+	* @returns sum
+	*
+	* @example
+	* var v = ns.add4( -1.0, 5.0, 2.0, -3.0 );
+	* // returns 3.0
+	*
+	* @example
+	* var v = ns.add4( 2.0, 5.0, 2.0, -3.0 );
+	* // returns 6.0
+	*
+	* @example
+	* var v = ns.add4( 0.0, 5.0, 2.0, -3.0 );
+	* // returns 4.0
+	*
+	* @example
+	* var v = ns.add4( -0.0, 0.0, -0.0, -0.0 );
+	* // returns 0.0
+	*
+	* @example
+	* var v = ns.add4( NaN, NaN, NaN, NaN );
+	* // returns NaN
+	*/
+	add4: typeof add4;
+
+	/**
+	* Computes the sum of five double-precision floating-point numbers.
+	*
+	* @param x - first input value
+	* @param y - second input value
+	* @param z - third input value
+	* @param w - fourth input value
+	* @param u - fifth input value
+	* @returns sum
+	*
+	* @example
+	* var v = ns.add5( -1.0, 5.0, 2.0, -3.0, 4.0 );
+	* // returns 7.0
+	*
+	* @example
+	* var v = ns.add5( 2.0, 5.0, 2.0, -3.0, 4.0 );
+	* // returns 10.0
+	*
+	* @example
+	* var v = ns.add5( 0.0, 5.0, 2.0, -3.0, 4.0 );
+	* // returns 8.0
+	*
+	* @example
+	* var v = ns.add5( -0.0, 0.0, -0.0, -0.0, -0.0 );
+	* // returns 0.0
+	*
+	* @example
+	* var v = ns.add5( NaN, NaN, NaN, NaN, NaN );
+	* // returns NaN
+	*/
+	add5: typeof add5;
+
 	/**
 	* Computes the sum of two single-precision floating-point numbers `x` and `y`.
 	*