refactor: fix inconsistencies across packages in blas/ext/base*

lib/node_modules/@stdlib/blas/ext/base/cindex-of-column/README.md

@@ -28,6 +28,8 @@ limitations under the License.
 
 <!-- /.intro -->
 
+<!-- Package usage documentation. -->
+
 <section class="usage">
 
 ## Usage
@@ -196,17 +198,20 @@ var out = cindexOfColumn.ndarray( 2, 2, A, 1, 2, 0, x, 1, 0, workspace, 1, 0 );
 
 <!-- /.usage -->
 
+<!-- Package usage notes. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
 <section class="notes">
 
 ## Notes
 
--   If `M <= 0` or `N <= 0`, both functions return `-1`.
 -   When searching for a matching column, the function checks for equality using the strict equality operator `===`. As a consequence, `NaN` values are considered distinct, and `-0` and `+0` are considered the same.
 
 </section>
 
 <!-- /.notes -->
 
+<!-- Package usage examples. -->
+
 <section class="examples">
 
 ## Examples
@@ -220,6 +225,7 @@ var Complex64Array = require( '@stdlib/array/complex64' );
 var Uint8Array = require( '@stdlib/array/uint8' );
 var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
 var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var logEach = require( '@stdlib/console/log-each' );
 var cindexOfColumn = require( '@stdlib/blas/ext/base/cindex-of-column' );
 
 var shape = [ 2, 2 ];
@@ -230,7 +236,7 @@ var A = new Complex64Array( [ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0 ] );
 console.log( ndarray2array( A, shape, strides, 0, order ) );
 
 var x = new Complex64Array( [ 2.0, 0.0, 4.0, 0.0 ] );
-console.log( x );
+logEach( '%s', x );
 
 var workspace = new Uint8Array( shape[ 1 ] );
 

lib/node_modules/@stdlib/blas/ext/base/cindex-of-column/docs/types/test.ts

@@ -16,6 +16,7 @@
 * limitations under the License.
 */
 
+import Complex64Array = require( '@stdlib/array/complex64' );
 import cindexOfColumn = require( './index' );
 
 
@@ -183,7 +184,7 @@ import cindexOfColumn = require( './index' );
 	cindexOfColumn( 'row-major', 2, 2, A, 2, x ); // $ExpectError
 	cindexOfColumn( 'row-major', 2, 2, A, 2, x, 1 ); // $ExpectError
 	cindexOfColumn( 'row-major', 2, 2, A, 2, x, 1, w ); // $ExpectError
-	cindexOfColumn( 'row-major', 2, 2, A, 2, x, 1, w, 1, 0 ); // $ExpectError
+	cindexOfColumn( 'row-major', 2, 2, A, 2, x, 1, w, 1, {} ); // $ExpectError
 }
 
 // Attached to main export is an `ndarray` method which returns a number...
@@ -399,5 +400,5 @@ import cindexOfColumn = require( './index' );
 	cindexOfColumn.ndarray( 2, 2, A, 2, 1, 0, x, 1, 0 ); // $ExpectError
 	cindexOfColumn.ndarray( 2, 2, A, 2, 1, 0, x, 1, 0, w ); // $ExpectError
 	cindexOfColumn.ndarray( 2, 2, A, 2, 1, 0, x, 1, 0, w, 1 ); // $ExpectError
-	cindexOfColumn.ndarray( 2, 2, A, 2, 1, 0, x, 1, 0, w, 1, 0, 0 ); // $ExpectError
+	cindexOfColumn.ndarray( 2, 2, A, 2, 1, 0, x, 1, 0, w, 1, 0, {} ); // $ExpectError
 }

lib/node_modules/@stdlib/blas/ext/base/cindex-of-column/examples/index.js

@@ -22,6 +22,7 @@ var Complex64Array = require( '@stdlib/array/complex64' );
 var Uint8Array = require( '@stdlib/array/uint8' );
 var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
 var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var logEach = require( '@stdlib/console/log-each' );
 var cindexOfColumn = require( './../lib' );
 
 var shape = [ 2, 2 ];
@@ -32,7 +33,7 @@ var A = new Complex64Array( [ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0 ] );
 console.log( ndarray2array( A, shape, strides, 0, order ) );
 
 var x = new Complex64Array( [ 2.0, 0.0, 4.0, 0.0 ] );
-console.log( x );
+logEach( '%s', x );
 
 var workspace = new Uint8Array( shape[ 1 ] );
 

lib/node_modules/@stdlib/blas/ext/base/cindex-of-column/lib/cindex_of_column.js

@@ -76,7 +76,7 @@ function cindexOfColumn( order, M, N, A, LDA, x, strideX, workspace, strideW ) {
 		s = M;
 	}
 	if ( LDA < max( 1, s ) ) {
-		throw new RangeError( format( 'invalid argument. Fifth argument must be greater than or equal to max(1,%d). Value: `%d`.', max( 1, s ), LDA ) );
+		throw new RangeError( format( 'invalid argument. Fifth argument must be greater than or equal to max(1,%d). Value: `%d`.', s, LDA ) );
 	}
 	if ( isColumnMajor( order ) ) {
 		sa1 = 1;

lib/node_modules/@stdlib/blas/ext/base/cindex-of-column/lib/cindex_of_column.native.js

@@ -74,7 +74,7 @@ function cindexOfColumn( order, M, N, A, LDA, x, strideX, workspace, strideW ) {
 		s = M;
 	}
 	if ( LDA < max( 1, s ) ) {
-		throw new RangeError( format( 'invalid argument. Fifth argument must be greater than or equal to max(1,%d). Value: `%d`.', max( 1, s ), LDA ) );
+		throw new RangeError( format( 'invalid argument. Fifth argument must be greater than or equal to max(1,%d). Value: `%d`.', s, LDA ) );
 	}
 	return addon( resolveOrder( order ), M, N, reinterpret( A, 0 ), LDA, reinterpret( x, 0 ), strideX, workspace, strideW ); // eslint-disable-line max-len
 }

lib/node_modules/@stdlib/blas/ext/base/cindex-of-column/src/main.c

@@ -27,16 +27,16 @@
 /**
 * Returns the index of the first column in a single-precision complex floating-point input matrix which has the same elements as a provided search vector.
 *
-* @param order      storage layout
-* @param M          number of rows in `A`
-* @param N          number of columns in `A`
-* @param A          input matrix
-* @param LDA        stride length for the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
-* @param X          search vector
-* @param strideX    stride length for `X`
-* @param workspace  workspace array for tracking column match candidates
-* @param strideW    stride length for `workspace`
-* @return           column index
+* @param order     storage layout
+* @param M         number of rows in `A`
+* @param N         number of columns in `A`
+* @param A         input matrix
+* @param LDA       stride length for the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
+* @param X         search vector
+* @param strideX   stride length for `X`
+* @param workspace workspace array for tracking column match candidates
+* @param strideW   stride length for `workspace`
+* @return          column index
 */
 CBLAS_INT API_SUFFIX(stdlib_strided_cindex_of_column)( const CBLAS_LAYOUT order, const CBLAS_INT M, const CBLAS_INT N, const stdlib_complex64_t *A, const CBLAS_INT LDA, const stdlib_complex64_t *X, const CBLAS_INT strideX, uint8_t *workspace, const CBLAS_INT strideW ) {
 	CBLAS_INT sa1;
@@ -59,19 +59,19 @@ CBLAS_INT API_SUFFIX(stdlib_strided_cindex_of_column)( const CBLAS_LAYOUT order,
 /**
 * Returns the index of the first column in a single-precision complex floating-point input matrix which has the same elements as a provided search vector using alternative indexing semantics.
 *
-* @param M          number of rows in `A`
-* @param N          number of columns in `A`
-* @param A          input matrix
-* @param strideA1   stride length for the first dimension of `A`
-* @param strideA2   stride length for the second dimension of `A`
-* @param offsetA    starting index for `A`
-* @param X          search vector
-* @param strideX    stride length for `X`
-* @param offsetX    starting index for `X`
-* @param workspace  workspace array for tracking column match candidates
-* @param strideW    stride length for `workspace`
-* @param offsetW    starting index for `workspace`
-* @return           column index
+* @param M         number of rows in `A`
+* @param N         number of columns in `A`
+* @param A         input matrix
+* @param strideA1  stride length for the first dimension of `A`
+* @param strideA2  stride length for the second dimension of `A`
+* @param offsetA   starting index for `A`
+* @param X         search vector
+* @param strideX   stride length for `X`
+* @param offsetX   starting index for `X`
+* @param workspace workspace array for tracking column match candidates
+* @param strideW   stride length for `workspace`
+* @param offsetW   starting index for `workspace`
+* @return          column index
 */
 CBLAS_INT API_SUFFIX(stdlib_strided_cindex_of_column_ndarray)( const CBLAS_INT M, const CBLAS_INT N, const stdlib_complex64_t *A, const CBLAS_INT strideA1, const CBLAS_INT strideA2, const CBLAS_INT offsetA, const stdlib_complex64_t *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, uint8_t *workspace, const CBLAS_INT strideW, const CBLAS_INT offsetW ) {
 	stdlib_complex64_t va;

lib/node_modules/@stdlib/blas/ext/base/cindex-of-falsy/README.md

@@ -138,7 +138,6 @@ var idx = cindexOfFalsy.ndarray( 3, x, 1, x.length-3 );
 ## Notes
 
 -   A complex number is falsy when both its real and imaginary components are falsy.
--   If unable to find a falsy element, both functions return `-1`.
 -   Both functions explicitly treat `NaN` values as falsy.
 
 </section>
@@ -257,7 +256,6 @@ CBLAS_INT stdlib_strided_cindex_of_falsy_ndarray( const CBLAS_INT N, const stdli
 ### Notes
 
 -   A complex number is falsy when both its real and imaginary components are falsy.
--   If unable to find a falsy element, both functions return `-1`.
 -   Both functions explicitly treat `NaN` values as falsy.
 
 </section>

lib/node_modules/@stdlib/blas/ext/base/cindex-of-falsy/docs/repl.txt

@@ -14,7 +14,7 @@
     A complex number is falsy when both its real and imaginary components are
     falsy.
 
-    The function treats `NaN` values as falsy.
+    The function explicitly treats `NaN` values as falsy.
 
     Parameters
     ----------
@@ -34,10 +34,22 @@
 
     Examples
     --------
+    // Standard usage:
     > var x = new {{alias:@stdlib/array/complex64}}( [ 1.0, 2.0, 0.0, 0.0 ] );
     > var idx = {{alias}}( x.length, x, 1 )
     1
 
+    // Using `N` and stride parameters:
+    > var x = new {{alias:@stdlib/array/complex64}}( [ 1.0, 2.0, 3.0, 4.0, 0.0, 0.0, 5.0, 6.0 ] );
+    > var idx = {{alias}}( 2, x, 2 )
+    1
+
+    // Using view offsets:
+    > var x0 = new {{alias:@stdlib/array/complex64}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.0, 0.0 ] );
+    > var x1 = new {{alias:@stdlib/array/complex64}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 );
+    > var idx = {{alias}}( 2, x1, 2 )
+    1
+
 
 {{alias}}.ndarray( N, x, strideX, offsetX )
     Returns the index of the first falsy element in a single-precision complex
@@ -47,6 +59,11 @@
     buffer, the offset parameter supports indexing semantics based on a
     starting index.
 
+    A complex number is falsy when both its real and imaginary components are
+    falsy.
+
+    The function explicitly treats `NaN` values as falsy.
+
     Parameters
     ----------
     N: integer
@@ -68,10 +85,15 @@
 
     Examples
     --------
+    // Standard usage:
     > var x = new {{alias:@stdlib/array/complex64}}( [ 1.0, 2.0, 0.0, 0.0 ] );
     > var idx = {{alias}}.ndarray( x.length, x, 1, 0 )
     1
 
+    // Using an index offset:
+    > var x = new {{alias:@stdlib/array/complex64}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 0.0, 0.0 ] );
+    > var idx = {{alias}}.ndarray( 2, x, 2, 1 )
+    1
+
     See Also
     --------
-

lib/node_modules/@stdlib/blas/ext/base/cindex-of-falsy/docs/types/index.d.ts

@@ -30,7 +30,7 @@ interface Routine {
 	* ## Notes
 	*
 	* -   A complex number is falsy when both its real and imaginary components are falsy.
-	* -   If unable to find a falsy element, the function returns `-1`.
+	* -   If the function is unable to find a falsy element, the function returns `-1`.
 	* -   The function explicitly treats `NaN` values as falsy.
 	*
 	* @param N - number of indexed elements
@@ -54,7 +54,7 @@ interface Routine {
 	* ## Notes
 	*
 	* -   A complex number is falsy when both its real and imaginary components are falsy.
-	* -   If unable to find a falsy element, the function returns `-1`.
+	* -   If the function is unable to find a falsy element, the function returns `-1`.
 	* -   The function explicitly treats `NaN` values as falsy.
 	*
 	* @param N - number of indexed elements
@@ -80,7 +80,7 @@ interface Routine {
 * ## Notes
 *
 * -   A complex number is falsy when both its real and imaginary components are falsy.
-* -   If unable to find a falsy element, the function returns `-1`.
+* -   If the function is unable to find a falsy element, the function returns `-1`.
 * -   The function explicitly treats `NaN` values as falsy.
 *
 * @param N - number of indexed elements

lib/node_modules/@stdlib/blas/ext/base/cindex-of-falsy/docs/types/test.ts

@@ -40,6 +40,7 @@ import cindexOfFalsy = require( './index' );
 	cindexOfFalsy( false, x, 1 ); // $ExpectError
 	cindexOfFalsy( null, x, 1 ); // $ExpectError
 	cindexOfFalsy( {}, x, 1 ); // $ExpectError
+	cindexOfFalsy( ( x: number ): number => x, x, 1 ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided a second argument which is not a Complex64Array...
@@ -51,6 +52,7 @@ import cindexOfFalsy = require( './index' );
 	cindexOfFalsy( x.length, false, 1 ); // $ExpectError
 	cindexOfFalsy( x.length, null, 1 ); // $ExpectError
 	cindexOfFalsy( x.length, {}, 1 ); // $ExpectError
+	cindexOfFalsy( x.length, ( x: number ): number => x, 1 ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided a third argument which is not a number...
@@ -62,6 +64,7 @@ import cindexOfFalsy = require( './index' );
 	cindexOfFalsy( x.length, x, false ); // $ExpectError
 	cindexOfFalsy( x.length, x, null ); // $ExpectError
 	cindexOfFalsy( x.length, x, {} ); // $ExpectError
+	cindexOfFalsy( x.length, x, ( x: number ): number => x ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided an unsupported number of arguments...
@@ -88,6 +91,7 @@ import cindexOfFalsy = require( './index' );
 	cindexOfFalsy.ndarray( false, x, 1, 1 ); // $ExpectError
 	cindexOfFalsy.ndarray( null, x, 1, 1 ); // $ExpectError
 	cindexOfFalsy.ndarray( {}, x, 1, 1 ); // $ExpectError
+	cindexOfFalsy.ndarray( ( x: number ): number => x, x, 1, 1 ); // $ExpectError
 }
 
 // The compiler throws an error if the `ndarray` method is provided a second argument which is not a Complex64Array...
@@ -99,6 +103,7 @@ import cindexOfFalsy = require( './index' );
 	cindexOfFalsy.ndarray( x.length, false, 1, 1 ); // $ExpectError
 	cindexOfFalsy.ndarray( x.length, null, 1, 1 ); // $ExpectError
 	cindexOfFalsy.ndarray( x.length, {}, 1, 1 ); // $ExpectError
+	cindexOfFalsy.ndarray( x.length, ( x: number ): number => x, 1, 1 ); // $ExpectError
 }
 
 // The compiler throws an error if the `ndarray` method is provided a third argument which is not a number...
@@ -110,6 +115,7 @@ import cindexOfFalsy = require( './index' );
 	cindexOfFalsy.ndarray( x.length, x, false, 1 ); // $ExpectError
 	cindexOfFalsy.ndarray( x.length, x, null, 1 ); // $ExpectError
 	cindexOfFalsy.ndarray( x.length, x, {}, 1 ); // $ExpectError
+	cindexOfFalsy.ndarray( x.length, x, ( x: number ): number => x, 1 ); // $ExpectError
 }
 
 // The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number...
@@ -121,6 +127,7 @@ import cindexOfFalsy = require( './index' );
 	cindexOfFalsy.ndarray( x.length, x, 1, false ); // $ExpectError
 	cindexOfFalsy.ndarray( x.length, x, 1, null ); // $ExpectError
 	cindexOfFalsy.ndarray( x.length, x, 1, {} ); // $ExpectError
+	cindexOfFalsy.ndarray( x.length, x, 1, ( x: number ): number => x ); // $ExpectError
 }
 
 // The compiler throws an error if the `ndarray` method is provided an unsupported number of arguments...

lib/node_modules/@stdlib/blas/ext/base/cindex-of-falsy/lib/cindex_of_falsy.js

@@ -32,7 +32,7 @@ var ndarray = require( './ndarray.js' );
 * ## Notes
 *
 * -   A complex number is falsy when both its real and imaginary components are falsy.
-* -   If unable to find a falsy element, the function returns `-1`.
+* -   If the function is unable to find a falsy element, the function returns `-1`.
 * -   The function explicitly treats `NaN` values as falsy.
 *
 * @param {PositiveInteger} N - number of indexed elements

lib/node_modules/@stdlib/blas/ext/base/cindex-of-falsy/lib/cindex_of_falsy.native.js

@@ -32,7 +32,7 @@ var addon = require( './../src/addon.node' );
 * ## Notes
 *
 * -   A complex number is falsy when both its real and imaginary components are falsy.
-* -   If unable to find a falsy element, the function returns `-1`.
+* -   If the function is unable to find a falsy element, the function returns `-1`.
 * -   The function explicitly treats `NaN` values as falsy.
 *
 * @param {PositiveInteger} N - number of indexed elements

lib/node_modules/@stdlib/blas/ext/base/cindex-of-falsy/lib/ndarray.js

@@ -31,7 +31,7 @@ var reinterpret = require( '@stdlib/strided/base/reinterpret-complex64' );
 * ## Notes
 *
 * -   A complex number is falsy when both its real and imaginary components are falsy.
-* -   If unable to find a falsy element, the function returns `-1`.
+* -   If the function is unable to find a falsy element, the function returns `-1`.
 * -   The function explicitly treats `NaN` values as falsy.
 *
 * @param {PositiveInteger} N - number of indexed elements

lib/node_modules/@stdlib/blas/ext/base/cindex-of-falsy/lib/ndarray.native.js

@@ -21,7 +21,7 @@
 // MODULES //
 
 var reinterpret = require( '@stdlib/strided/base/reinterpret-complex64' );
 var addon = require( './../src/addon.node' );
 
 
 // MAIN //
@@ -32,7 +32,7 @@
 * ## Notes
 *
 * -   A complex number is falsy when both its real and imaginary components are falsy.
-* -   If unable to find a falsy element, the function returns `-1`.
+* -   If the function is unable to find a falsy element, the function returns `-1`.
 * -   The function explicitly treats `NaN` values as falsy.
 *
 * @param {PositiveInteger} N - number of indexed elements

lib/node_modules/@stdlib/blas/ext/base/cindex-of-falsy/src/main.c

@@ -27,10 +27,10 @@
 /**
 * Returns the index of the first falsy element in a single-precision complex floating-point strided array.
 *
-* @param N        number of indexed elements
-* @param X        input array
-* @param strideX  stride length
-* @return         index
+* @param N       number of indexed elements
+* @param X       input array
+* @param strideX stride length
+* @return        index
 */
 CBLAS_INT API_SUFFIX(stdlib_strided_cindex_of_falsy)( const CBLAS_INT N, const stdlib_complex64_t *X, const CBLAS_INT strideX ) {
 	CBLAS_INT ox = stdlib_strided_stride2offset( N, strideX );
@@ -40,11 +40,11 @@ CBLAS_INT API_SUFFIX(stdlib_strided_cindex_of_falsy)( const CBLAS_INT N, const s
 /**
 * Returns the index of the first falsy element in a single-precision complex floating-point strided array using alternative indexing semantics.
 *
-* @param N        number of indexed elements
-* @param X        input array
-* @param strideX  stride length
-* @param offsetX  starting index
-* @return         index
+* @param N       number of indexed elements
+* @param X       input array
+* @param strideX stride length
+* @param offsetX starting index
+* @return        index
 */
 CBLAS_INT API_SUFFIX(stdlib_strided_cindex_of_falsy_ndarray)( const CBLAS_INT N, const stdlib_complex64_t *X, const CBLAS_INT strideX, const CBLAS_INT offsetX ) {
 	stdlib_complex64_t v;