Merge branch 'develop' into blas/nd-joinbetween

Author: headlessNode

.github/workflows/lint_changed_files.yml

@@ -274,7 +274,7 @@ jobs:
         # Pin action to full length commit SHA
         uses: r-lib/actions/setup-r@6f6e5bc62fba3a704f74e7ad7ef7676c5c6a2590 # v2.11.4
         with:
-          r-version: '3.5.3'
+          r-version: '4.2.0'
 
       # Lint R files:
       - name: 'Lint R files'

.github/workflows/lint_random_files.yml

@@ -374,7 +374,7 @@ jobs:
         # Pin action to full length commit SHA
         uses: r-lib/actions/setup-r@6f6e5bc62fba3a704f74e7ad7ef7676c5c6a2590 # v2.11.4
         with:
-          r-version: '4.3.3'
+          r-version: '4.2.0'
 
       # Lint R files:
       - name: 'Lint R files'

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

@@ -105,12 +105,12 @@ interface Routine {
 * @param K - number of columns in the matrix `op(A)` and number of rows in the matrix `op(B)`
 * @param alpha - scalar constant
 * @param A - first matrix
-* @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
+* @param LDA - stride between successive contiguous vectors of the matrix `A` (a.k.a., leading dimension of the matrix `A`)
 * @param B - second matrix
-* @param LDB - stride of the first dimension of `B` (a.k.a., leading dimension of the matrix `B`)
+* @param LDB - stride between successive contiguous vectors of the matrix `B` (a.k.a., leading dimension of the matrix `B`)
 * @param beta - scalar constant
 * @param C - third matrix
-* @param LDC - stride of the first dimension of `C` (a.k.a., leading dimension of the matrix `C`)
+* @param LDC - stride between successive contiguous vectors of the matrix `C` (a.k.a., leading dimension of the matrix `C`)
 * @returns `C`
 *
 * @example

lib/node_modules/@stdlib/blas/base/dgemm/lib/dgemm.js

@@ -95,7 +95,7 @@ function dgemm( order, transA, transB, M, N, K, alpha, A, LDA, B, LDB, beta, C,
 		throw new RangeError( format( 'invalid argument. Fourth argument must be a nonnegative integer. Value: `%d`.', M ) );
 	}
 	if ( N < 0 ) {
-		throw new RangeError( format( 'invalid argument. Fifth argument must be a nonnegative integer. Value: `%d`.', M ) );
+		throw new RangeError( format( 'invalid argument. Fifth argument must be a nonnegative integer. Value: `%d`.', N ) );
 	}
 	if ( K < 0 ) {
 		throw new RangeError( format( 'invalid argument. Sixth argument must be a nonnegative integer. Value: `%d`.', K ) );

lib/node_modules/@stdlib/blas/ext/base/README.md

@@ -45,6 +45,7 @@ var o = ns;
 
 -   <span class="signature">[`cfill( N, alpha, x, strideX )`][@stdlib/blas/ext/base/cfill]</span><span class="delimiter">: </span><span class="description">fill a single-precision complex floating-point strided array with a specified scalar constant.</span>
 -   <span class="signature">[`cindexOfRow( order, M, N, A, LDA, x, strideX, workspace, strideW )`][@stdlib/blas/ext/base/cindex-of-row]</span><span class="delimiter">: </span><span class="description">return the index of the first row in a single-precision complex floating-point input matrix which has the same elements as a provided search vector.</span>
+-   <span class="signature">[`coneTo( N, x, strideX )`][@stdlib/blas/ext/base/cone-to]</span><span class="delimiter">: </span><span class="description">fill a single-precision complex floating-point strided array with linearly spaced numeric elements which increment by `1` starting from one.</span>
 -   <span class="signature">[`csum( N, x, strideX )`][@stdlib/blas/ext/base/csum]</span><span class="delimiter">: </span><span class="description">calculate the sum of single-precision complex floating-point strided array elements.</span>
 -   <span class="signature">[`csumkbn( N, x, strideX )`][@stdlib/blas/ext/base/csumkbn]</span><span class="delimiter">: </span><span class="description">calculate the sum of single-precision complex floating-point strided array elements using an improved Kahan–Babuška algorithm.</span>
 -   <span class="signature">[`czeroTo( N, x, strideX )`][@stdlib/blas/ext/base/czero-to]</span><span class="delimiter">: </span><span class="description">fill a single-precision complex floating-point strided array with linearly spaced numeric elements which increment by `1` starting from zero.</span>
@@ -259,6 +260,8 @@ console.log( objectKeys( ns ) );
 
 [@stdlib/blas/ext/base/cindex-of-row]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/ext/base/cindex-of-row
 
+[@stdlib/blas/ext/base/cone-to]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/ext/base/cone-to
+
 [@stdlib/blas/ext/base/csum]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/ext/base/csum
 
 [@stdlib/blas/ext/base/csumkbn]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/ext/base/csumkbn

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

@@ -21,6 +21,8 @@
 /* eslint-disable max-lines */
 
 import cfill = require( '@stdlib/blas/ext/base/cfill' );
+import cindexOfRow = require( '@stdlib/blas/ext/base/cindex-of-row' );
+import coneTo = require( '@stdlib/blas/ext/base/cone-to' );
 import csum = require( '@stdlib/blas/ext/base/csum' );
 import csumkbn = require( '@stdlib/blas/ext/base/csumkbn' );
 import czeroTo = require( '@stdlib/blas/ext/base/czero-to' );
@@ -115,6 +117,7 @@ import gnansumkbn = require( '@stdlib/blas/ext/base/gnansumkbn' );
 import gnansumkbn2 = require( '@stdlib/blas/ext/base/gnansumkbn2' );
 import gnansumors = require( '@stdlib/blas/ext/base/gnansumors' );
 import gnansumpw = require( '@stdlib/blas/ext/base/gnansumpw' );
+import goneTo = require( '@stdlib/blas/ext/base/gone-to' );
 import grev = require( '@stdlib/blas/ext/base/grev' );
 import gsort = require( '@stdlib/blas/ext/base/gsort' );
 import gsort2hp = require( '@stdlib/blas/ext/base/gsort2hp' );
@@ -176,6 +179,7 @@ import szeroTo = require( '@stdlib/blas/ext/base/szero-to' );
 import wasm = require( '@stdlib/blas/ext/base/wasm' );
 import zfill = require( '@stdlib/blas/ext/base/zfill' );
 import zindexOfRow = require( '@stdlib/blas/ext/base/zindex-of-row' );
+import zoneTo = require( '@stdlib/blas/ext/base/zone-to' );
 import zsum = require( '@stdlib/blas/ext/base/zsum' );
 import zsumkbn = require( '@stdlib/blas/ext/base/zsumkbn' );
 import zzeroTo = require( '@stdlib/blas/ext/base/zzero-to' );
@@ -217,6 +221,75 @@ interface Namespace {
 	*/
 	cfill: typeof cfill;
 
+	/**
+	* Returns the index of the first row in a single-precision complex floating-point input matrix which has the same elements as a provided search vector.
+	*
+	* ## Notes
+	*
+	* -   If the function is provided an empty matrix or if the function is unable to find a search vector, the function returns `-1` (i.e., an invalid index).
+	* -   The `workspace` array is only applicable when an input matrix is stored in column-major order. When the matrix is stored in row-major order, the workspace array is ignored.
+	*
+	* @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 of 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 row match candidates
+	* @param strideW - stride length for `workspace`
+	* @returns row index
+	*
+	* @example
+	* var Complex64Array = require( `@stdlib/array/complex64` );
+	* var Uint8Array = require( `@stdlib/array/uint8` );
+	*
+	* var A = new Complex64Array( [ 1.0, 0.0, 2.0, 0.0, 0.0, 0.0, 3.0, 0.0, 4.0, 0.0, 0.0, 0.0 ] );
+	* var x = new Complex64Array( [ 2.0, 0.0, 4.0, 0.0 ] );
+	* var workspace = new Uint8Array( 3 );
+	*
+	* var out = ns.cindexOfRow( 'column-major', 3, 2, A, 3, x, 1, workspace, 1 );
+	* // returns 1
+	*
+	* @example
+	* var Complex64Array = require( `@stdlib/array/complex64` );
+	* var Uint8Array = require( `@stdlib/array/uint8` );
+	*
+	* var A = new Complex64Array( [ 1.0, 0.0, 2.0, 0.0, 0.0, 0.0, 3.0, 0.0, 4.0, 0.0, 0.0, 0.0 ] );
+	* var x = new Complex64Array( [ 2.0, 0.0, 4.0, 0.0 ] );
+	* var workspace = new Uint8Array( 3 );
+	*
+	* var out = ns.cindexOfRow.ndarray( 3, 2, A, 1, 3, 0, x, 1, 0, workspace, 1, 0 );
+	* // returns 1
+	*/
+	cindexOfRow: typeof cindexOfRow;
+
+	/**
+	* Fills a single-precision complex floating-point strided array with linearly spaced numeric elements which increment by `1` starting from one.
+	*
+	* @param N - number of indexed elements
+	* @param x - input array
+	* @param strideX - stride length
+	* @returns input array
+	*
+	* @example
+	* var Complex64Array = require( '@stdlib/array/complex64' );
+	*
+	* var x = new Complex64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	*
+	* ns.coneTo( x.length, x, 1 );
+	* // x => <Complex64Array>[ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0 ]
+	*
+	* @example
+	* var Complex64Array = require( '@stdlib/array/complex64' );
+	*
+	* var x = new Complex64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	*
+	* ns.coneTo.ndarray( x.length, x, 1, 0 );
+	* // x => <Complex64Array>[ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0 ]
+	*/
+	coneTo: typeof coneTo;
+
 	/**
 	* Computes the sum of single-precision complex floating-point strided array elements.
 	*
@@ -2870,6 +2943,28 @@ interface Namespace {
 	*/
 	gnansumpw: typeof gnansumpw;
 
+	/**
+	* Fills a strided array with linearly spaced numeric elements which increment by `1` starting from one.
+	*
+	* @param N - number of indexed elements
+	* @param x - input array
+	* @param strideX - stride length
+	* @returns input array
+	*
+	* @example
+	* var x = [ 0.0, 0.0, 0.0, 0.0 ];
+	*
+	* ns.goneTo( x.length, x, 1 );
+	* // x => [ 1.0, 2.0, 3.0, 4.0 ]
+	*
+	* @example
+	* var x = [ 0.0, 0.0, 0.0, 0.0 ];
+	*
+	* ns.goneTo.ndarray( x.length, x, 1, 0 );
+	* // x => [ 1.0, 2.0, 3.0, 4.0 ]
+	*/
+	goneTo: typeof goneTo;
+
 	/**
 	* Reverses a strided array in-place.
 	*
@@ -4553,6 +4648,32 @@ interface Namespace {
 	*/
 	zindexOfRow: typeof zindexOfRow;
 
+	/**
+	* Fills a double-precision complex floating-point strided array with linearly spaced numeric elements which increment by `1` starting from one.
+	*
+	* @param N - number of indexed elements
+	* @param x - input array
+	* @param strideX - stride length
+	* @returns input array
+	*
+	* @example
+	* var Complex128Array = require( '@stdlib/array/complex128' );
+	*
+	* var x = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	*
+	* ns.zoneTo( x.length, x, 1 );
+	* // x => <Complex128Array>[ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0 ]
+	*
+	* @example
+	* var Complex128Array = require( '@stdlib/array/complex128' );
+	*
+	* var x = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	*
+	* ns.zoneTo.ndarray( x.length, x, 1, 0 );
+	* // x => <Complex128Array>[ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0 ]
+	*/
+	zoneTo: typeof zoneTo;
+
 	/**
 	* Computes the sum of double-precision complex floating-point strided array elements.
 	*

lib/node_modules/@stdlib/blas/ext/base/ndarray/README.md

@@ -90,6 +90,7 @@ The namespace exposes the following APIs:
 -   <span class="signature">[`gnansumkbn2( arrays )`][@stdlib/blas/ext/base/ndarray/gnansumkbn2]</span><span class="delimiter">: </span><span class="description">compute the sum of a one-dimensional ndarray, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.</span>
 -   <span class="signature">[`gnansumors( arrays )`][@stdlib/blas/ext/base/ndarray/gnansumors]</span><span class="delimiter">: </span><span class="description">compute the sum of a one-dimensional ndarray, ignoring `NaN` values and using ordinary recursive summation.</span>
 -   <span class="signature">[`gnansumpw( arrays )`][@stdlib/blas/ext/base/ndarray/gnansumpw]</span><span class="delimiter">: </span><span class="description">compute the sum of a one-dimensional ndarray, ignoring `NaN` values and using pairwise summation.</span>
+-   <span class="signature">[`goneTo( arrays )`][@stdlib/blas/ext/base/ndarray/gone-to]</span><span class="delimiter">: </span><span class="description">fill a one-dimensional ndarray with linearly spaced numeric elements which increment by `1` starting from one.</span>
 -   <span class="signature">[`gsort( arrays )`][@stdlib/blas/ext/base/ndarray/gsort]</span><span class="delimiter">: </span><span class="description">sort a one-dimensional ndarray.</span>
 -   <span class="signature">[`gsorthp( arrays )`][@stdlib/blas/ext/base/ndarray/gsorthp]</span><span class="delimiter">: </span><span class="description">sort a one-dimensional ndarray using heapsort.</span>
 -   <span class="signature">[`gsum( arrays )`][@stdlib/blas/ext/base/ndarray/gsum]</span><span class="delimiter">: </span><span class="description">compute the sum of all elements in a one-dimensional ndarray.</span>
@@ -254,6 +255,8 @@ console.log( objectKeys( ns ) );
 
 [@stdlib/blas/ext/base/ndarray/gnansumpw]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/ext/base/ndarray/gnansumpw
 
+[@stdlib/blas/ext/base/ndarray/gone-to]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/ext/base/ndarray/gone-to
+
 [@stdlib/blas/ext/base/ndarray/gsort]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/ext/base/ndarray/gsort
 
 [@stdlib/blas/ext/base/ndarray/gsorthp]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/ext/base/ndarray/gsorthp

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

@@ -65,6 +65,7 @@ import gnansumkbn = require( '@stdlib/blas/ext/base/ndarray/gnansumkbn' );
 import gnansumkbn2 = require( '@stdlib/blas/ext/base/ndarray/gnansumkbn2' );
 import gnansumors = require( '@stdlib/blas/ext/base/ndarray/gnansumors' );
 import gnansumpw = require( '@stdlib/blas/ext/base/ndarray/gnansumpw' );
+import goneTo = require( '@stdlib/blas/ext/base/ndarray/gone-to' );
 import gsort = require( '@stdlib/blas/ext/base/ndarray/gsort' );
 import gsorthp = require( '@stdlib/blas/ext/base/ndarray/gsorthp' );
 import gsum = require( '@stdlib/blas/ext/base/ndarray/gsum' );
@@ -1176,6 +1177,24 @@ interface Namespace {
 	*/
 	gnansumpw: typeof gnansumpw;
 
+	/**
+	* 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
+	* @returns input ndarray
+	*
+	* @example
+	* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+	*
+	* var xbuf = [ 0.0, 0.0, 0.0, 0.0 ];
+	* var x = new ndarray( 'generic', xbuf, [ 4 ], [ 1 ], 0, 'row-major' );
+	* // returns <ndarray>[ 0.0, 0.0, 0.0, 0.0 ]
+	*
+	* var out = ns.goneTo( [ x ] );
+	* // returns <ndarray>[ 1.0, 2.0, 3.0, 4.0 ]
+	*/
+	goneTo: typeof goneTo;
+
 	/**
 	* Sorts a one-dimensional ndarray.
 	*

lib/node_modules/@stdlib/blas/ext/cusum/lib/assign.js

@@ -30,6 +30,7 @@ var nonCoreShape = require( '@stdlib/ndarray/base/complement-shape' );
 var getDType = require( '@stdlib/ndarray/dtype' );
 var getShape = require( '@stdlib/ndarray/shape' );
 var getOrder = require( '@stdlib/ndarray/order' );
+var ndims = require( '@stdlib/ndarray/base/ndims' );
 var format = require( '@stdlib/string/format' );
 var base = require( './base.js' ).assign;
 
@@ -43,7 +44,7 @@ var base = require( './base.js' ).assign;
 * @param {(ndarrayLike|number|ComplexLike)} [initial] - initial value
 * @param {ndarrayLike} out - output ndarray
 * @param {Options} [options] - function options
-* @param {integer} [options.dims] - list of dimensions over which to perform operation
+* @param {IntegerArray} [options.dims] - list of dimensions over which to perform operation
 * @throws {TypeError} first argument must be an ndarray-like object
 * @throws {TypeError} initial value argument must be either an ndarray-like object or a numeric value
 * @throws {TypeError} output argument must be an ndarray-like object
@@ -112,6 +113,9 @@ function assign( x ) {
 			// Case: assign( x, initial_ndarray, out )
 			if ( isndarrayLike( v ) ) {
 				// As the operation is performed across all dimensions, `v` is assumed to be a zero-dimensional ndarray...
+				if ( ndims( v ) !== 0 ) {
+					throw new TypeError( format( 'invalid argument. Second argument must be a zero-dimensional ndarray.' ) );
+				}
 				return base( x, v, out );
 			}
 			// When computing the sum, initial values must be numeric...
@@ -134,9 +138,11 @@ function assign( x ) {
 	}
 	// Case: assign( x, initial_ndarray, out, opts )
 	if ( isndarrayLike( v ) ) {
-		// When not provided `dims`, the operation is performed across all dimensions and `v` is assumed to be a zero-dimensional ndarray; when `dims` is provided, we need to broadcast `v` to match the shape of the non-core dimensions...
+		// When not provided `dims`, the operation is performed across all dimensions and `v` must be a zero-dimensional ndarray; when `dims` is provided, we need to broadcast `v` to match the shape of the non-core dimensions...
 		if ( hasOwnProp( opts, 'dims' ) ) {
 			v = maybeBroadcastArray( v, nonCoreShape( getShape( x ), opts.dims ) ); // eslint-disable-line max-len
+		} else if ( ndims( v ) !== 0 ) {
+			throw new TypeError( format( 'invalid argument. Second argument must be a zero-dimensional ndarray.' ) );
 		}
 	}
 	// Case: assign( x, initial_scalar, out, opts )

lib/node_modules/@stdlib/blas/ext/cusum/lib/main.js

@@ -30,6 +30,7 @@ var nonCoreShape = require( '@stdlib/ndarray/base/complement-shape' );
 var getDType = require( '@stdlib/ndarray/dtype' );
 var getShape = require( '@stdlib/ndarray/shape' );
 var getOrder = require( '@stdlib/ndarray/order' );
+var ndims = require( '@stdlib/ndarray/base/ndims' );
 var format = require( '@stdlib/string/format' );
 var base = require( './base.js' );
 
@@ -99,7 +100,10 @@ function cusum( x ) {
 	if ( nargs === 2 ) {
 		// Case: cusum( x, initial_ndarray )
 		if ( isndarrayLike( v ) ) {
-			// As the operation is performed across all dimensions, `v` is assumed to be a zero-dimensional ndarray...
+			// As the operation is performed across all dimensions, `v` must be a zero-dimensional ndarray...
+			if ( ndims( v ) !== 0 ) {
+				throw new TypeError( format( 'invalid argument. Second argument must be a zero-dimensional ndarray.' ) );
+			}
 			return base( x, v );
 		}
 		// Case: cusum( x, initial_scalar )
@@ -118,9 +122,11 @@ function cusum( x ) {
 	}
 	// Case: cusum( x, initial_ndarray, opts )
 	if ( isndarrayLike( v ) ) {
-		// When not provided `dims`, the operation is performed across all dimensions and `v` is assumed to be a zero-dimensional ndarray; when `dims` is provided, we need to broadcast `v` to match the shape of the non-core dimensions...
+		// When not provided `dims`, the operation is performed across all dimensions and `v` must be a zero-dimensional ndarray; when `dims` is provided, we need to broadcast `v` to match the shape of the non-core dimensions...
 		if ( hasOwnProp( opts, 'dims' ) ) {
 			v = maybeBroadcastArray( v, nonCoreShape( getShape( x ), opts.dims ) ); // eslint-disable-line max-len
+		} else if ( ndims( v ) !== 0 ) {
+			throw new TypeError( format( 'invalid argument. Second argument must be a zero-dimensional ndarray.' ) );
 		}
 	}
 	// Case: cusum( x, initial_scalar, opts )