chore: initial clean-up

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---

Author: kgryte

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

@@ -26,8 +26,9 @@ var isRowMajor = require( '@stdlib/ndarray/base/assert/is-row-major' );
 // MAIN //
 
 /**
-* Performs the rank 1 operation `A = α*x*y^T + A`, where `α` is a scalar, `x` is an `M` element vector, `y` is an `N` element vector and `A` is an `M` by `N` matrix.
+* Performs the rank 1 operation `A = α*x*y^T + A`, where `α` is a scalar, `x` is an `M` element vector, `y` is an `N` element vector, and `A` is an `M` by `N` matrix.
 *
+* @private
 * @param {NonNegativeInteger} M - number of rows in the matrix `A`
 * @param {NonNegativeInteger} N - number of columns in the matrix `A`
 * @param {number} alpha - scalar constant

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

@@ -31,7 +31,7 @@ var base = require( './base.js' );
 // MAIN //
 
 /**
-* Performs the rank 1 operation `A = α*x*y^T + A`, where `α` is a scalar, `x` is an `M` element vector, `y` is an `N` element vector and `A` is an `M` by `N` matrix.
+* Performs the rank 1 operation `A = α*x*y^T + A`, where `α` is a scalar, `x` is an `M` element vector, `y` is an `N` element vector, and `A` is an `M` by `N` matrix.
 *
 * @param {string} order - storage layout
 * @param {NonNegativeInteger} M - number of rows in the matrix `A`
@@ -48,7 +48,7 @@ var base = require( './base.js' );
 * @throws {RangeError} third argument must be a nonnegative integer
 * @throws {RangeError} sixth argument must be non-zero
 * @throws {RangeError} eighth argument must be non-zero
-* @throws {RangeError} tenth argument must be greater than or equal to max(1,M)
+* @throws {RangeError} tenth argument must be a valid stride
 * @returns {Float64Array} `A`
 *
 * @example
@@ -69,7 +69,6 @@ function dger( order, M, N, alpha, x, strideX, y, strideY, A, LDA ) {
 	var ox;
 	var oy;
 
-	iscm = isColumnMajor( order );
 	if ( !isLayout( order ) ) {
 		throw new TypeError( format( 'invalid argument. First argument must be a valid order. Value: `%s`.', order ) );
 	}
@@ -85,6 +84,7 @@ function dger( order, M, N, alpha, x, strideX, y, strideY, A, LDA ) {
 	if ( strideY === 0 ) {
 		throw new RangeError( format( 'invalid argument. Eighth argument must be non-zero.' ) );
 	}
+	iscm = isColumnMajor( order );
 	if ( iscm ) {
 		vala = M;
 	} else {
@@ -99,7 +99,7 @@ function dger( order, M, N, alpha, x, strideX, y, strideY, A, LDA ) {
 	}
 	ox = stride2offset( M, strideX );
 	oy = stride2offset( N, strideY );
-	if ( order === 'column-major' ) {
+	if ( iscm ) {
 		sa1 = 1;
 		sa2 = LDA;
 	} else { // order === 'row-major'

lib/node_modules/@stdlib/blas/base/dger/lib/dger.native.js

@@ -28,39 +28,40 @@ var addon = require( './../src/addon.node' );
 // MAIN //
 
 /**
-* Performs the rank 1 operation `A = alpha*x*y^T + A`.
+* Performs the rank 1 operation `A = alpha*x*y^T + A`, where `α` is a scalar, `x` is an `M` element vector, `y` is an `N` element vector, and `A` is an `M` by `N` matrix.
 *
 * @param {*} order - storage layout
 * @param {NonNegativeInteger} M - number of rows in the matrix `A`
 * @param {NonNegativeInteger} N - number of columns in the matrix `A`
 * @param {number} alpha - scalar constant
-* @param {Float64Array} x - an `M` element vector
+* @param {Float64Array} x - first input vector
 * @param {integer} strideX - `x` stride length
-* @param {Float64Array} y - an `N` element vector
+* @param {Float64Array} y - second input vector
 * @param {integer} strideY - `y` stride length
 * @param {Float64Array} A - matrix of coefficients
 * @param {PositiveInteger} LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
-* @throws {TypeError} first argument must be a supported BLAS memory layout
+* @throws {TypeError} first argument must be a valid order
+* @throws {RangeError} second argument must be a nonnegative integer
+* @throws {RangeError} third argument must be a nonnegative integer
+* @throws {RangeError} sixth argument must be non-zero
+* @throws {RangeError} eighth argument must be non-zero
+* @throws {RangeError} tenth argument must be a valid stride
 * @returns {Float64Array} `A`
 *
 * @example
 * var Float64Array = require( '@stdlib/array/float64' );
 *
-* var M = 4;
-* var N = 3;
+* var A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+* var x = new Float64Array( [ 1.0, 1.0 ] );
+* var y = new Float64Array( [ 1.0, 1.0, 1.0 ] );
 *
-* var B = new Float64Array( M*N );
-*
-* var x = new Float64Array( [ 0.0, 1.0, 2.0, 3.0 ] );
-* var y = new Float64Array( [ 1.0, 4.0, 0.0 ] );
-*
-* dger( 'row-major', N, M, 1.0, y, 1, x, 1, B, M );
-* // B => <Float64Array>[ 0.0, 1.0, 2.0, 3.0, 0.0, 4.0, 8.0, 12.0, 0.0, 0.0, 0.0, 0.0 ]
+* dger( 'row-major', 2, 3, 1.0, x, 1, y, 1, A, 3 );
+* // A => <Float64Array>[ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0 ]
 */
 function dger( order, M, N, alpha, x, strideX, y, strideY, A, LDA ) {
 	var ord = resolve( order );
 	if ( ord === null ) {
-		throw new TypeError( format( 'invalid argument. First argument must be a supported BLAS memory layout. Value: `%s`.', order ) );
+		throw new TypeError( format( 'invalid argument. First argument must be a valid order. Value: `%s`.', order ) );
 	}
 	addon( ord, M, N, alpha, x, strideX, y, strideY, A, LDA );
 	return A;

lib/node_modules/@stdlib/blas/base/dger/lib/index.js

@@ -19,7 +19,7 @@
 'use strict';
 
 /**
-* BLAS level 2 routine to perform the rank 1 operation `A = α*x*y^T + A`, where `α` is a scalar, `x` is an `M` element vector, `y` is an `N` element vector and `A` is an `M` by `N` matrix.
+* BLAS level 2 routine to perform the rank 1 operation `A = α*x*y^T + A`, where `α` is a scalar, `x` is an `M` element vector, `y` is an `N` element vector, and `A` is an `M` by `N` matrix.
 *
 * @module @stdlib/blas/base/dger
 *
@@ -42,7 +42,7 @@
 * var x = new Float64Array( [ 1.0, 1.0 ] );
 * var y = new Float64Array( [ 1.0, 1.0, 1.0 ] );
 *
-* dger.ndarray( 'row-major', 2, 3, 1.0, x, 1, 0, y, 1, 0, A, 3, 1, 0 );
+* dger.ndarray( 2, 3, 1.0, x, 1, 0, y, 1, 0, A, 3, 1, 0 );
 * // A => <Float64Array>[ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0 ]
 */
 

lib/node_modules/@stdlib/blas/base/dger/lib/ndarray.js

@@ -27,7 +27,7 @@ var base = require( './base.js' );
 // MAIN //
 
 /**
-* Performs the rank 1 operation `A = α*x*y^T + A`, where `α` is a scalar, `x` is an `M` element vector, `y` is an `N` element vector and `A` is an `M` by `N` matrix.
+* Performs the rank 1 operation `A = α*x*y^T + A`, where `α` is a scalar, `x` is an `M` element vector, `y` is an `N` element vector, and `A` is an `M` by `N` matrix.
 *
 * @param {NonNegativeInteger} M - number of rows in the matrix `A`
 * @param {NonNegativeInteger} N - number of columns in the matrix `A`

lib/node_modules/@stdlib/blas/base/dger/lib/ndarray.native.js

@@ -20,63 +20,62 @@
 
 // MODULES //
 
-var minViewBufferIndex = require( '@stdlib/strided/base/min-view-buffer-index' );
-var offsetView = require( '@stdlib/strided/base/offset-view' );
-var resolve = require( '@stdlib/blas/base/layout-resolve-enum' );
 var format = require( '@stdlib/string/format' );
-var addon = require( './dger.native.js' );
+var addon = require( './../src/addon.node' );
 
 
 // MAIN //
 
 /**
-* Performs the rank 1 operation `A = alpha*x*y^T + A`.
+* Performs the rank 1 operation `A = alpha*x*y^T + A`, where `α` is a scalar, `x` is an `M` element vector, `y` is an `N` element vector, and `A` is an `M` by `N` matrix.
 *
-* @param {*} order - storage layout
 * @param {NonNegativeInteger} M - number of rows in the matrix `A`
 * @param {NonNegativeInteger} N - number of columns in the matrix `A`
 * @param {number} alpha - scalar constant
-* @param {Float64Array} x - an `M` element vector
+* @param {Float64Array} x - first input vector
 * @param {integer} strideX - `x` stride length
 * @param {NonNegativeInteger} offsetX - starting `x` index
-* @param {Float64Array} y - an `N` element vector
+* @param {Float64Array} y - second input vector
 * @param {integer} strideY - `y` stride length
 * @param {NonNegativeInteger} offsetY - starting `y` index
-* @param {Float64Array} A - matrix of coefficients
-* @param {PositiveInteger} LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
-* @throws {TypeError} first argument must be a supported BLAS memory layout
+* @param {Float64Array} A - input matrix
+* @param {integer} strideA1 - stride of the first dimension of `A`
+* @param {integer} strideA2 - stride of the second dimension of `A`
+* @param {NonNegativeInteger} offsetA - starting index for `A
+* @throws {RangeError} first argument must be a nonnegative integer
+* @throws {RangeError} second argument must be a nonnegative integer
+* @throws {RangeError} fifth argument must be non-zero
+* @throws {RangeError} eighth argument must be non-zero
 * @returns {Float64Array} `A`
 *
 * @example
 * var Float64Array = require( '@stdlib/array/float64' );
 *
-* var M = 4;
-* var N = 3;
+* var A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+* var x = new Float64Array( [ 1.0, 1.0 ] );
+* var y = new Float64Array( [ 1.0, 1.0, 1.0 ] );
 *
-* var B = new Float64Array( M*N );
-*
-* var x = new Float64Array( [ 0.0, 1.0, 2.0, 3.0 ] );
-* var y = new Float64Array( [ 1.0, 4.0, 0.0 ] );
-*
-* dger( 'row-major', N, M, 1.0, y, 1, 0, x, 1, 0, B, M );
-* // B => <Float64Array>[ 0.0, 1.0, 2.0, 3.0, 0.0, 4.0, 8.0, 12.0, 0.0, 0.0, 0.0, 0.0 ]
+* dger( 2, 3, 1.0, x, 1, 0, y, 1, 0, A, 3, 1, 0 );
+* // A => <Float64Array>[ 2.0, 3.0, 4.0, 5.0, 6.0, 7.0 ]
 */
-function dger( order, M, N, alpha, x, strideX, offsetX, y, strideY, offsetY, A, LDA ) { // eslint-disable-line max-len, max-params
-	var viewX;
-	var viewY;
-	var ord;
-
-	ord = resolve( order );
-	if ( ord === null ) {
-		throw new TypeError( format( 'invalid argument. First argument must be a supported BLAS memory layout. Value: `%s`.', order ) );
+function dger( M, N, alpha, x, strideX, offsetX, y, strideY, offsetY, A, strideA1, strideA2, offsetA ) { // eslint-disable-line max-len, max-params
+	if ( M < 0 ) {
+		throw new RangeError( format( 'invalid argument. First argument must be a nonnegative integer. Value: `%d`.', M ) );
 	}
-	offsetX = minViewBufferIndex( N, strideX, offsetX );
-	offsetY = minViewBufferIndex( N, strideY, offsetY );
-
-	viewX = offsetView( x, offsetX );
-	viewY = offsetView( y, offsetY );
-
-	addon( ord, M, N, alpha, viewX, strideX, viewY, strideY, A, LDA );
+	if ( N < 0 ) {
+		throw new RangeError( format( 'invalid argument. Second argument must be a nonnegative integer. Value: `%d`.', N ) );
+	}
+	if ( strideX === 0 ) {
+		throw new RangeError( format( 'invalid argument. Fifth argument must be non-zero.' ) );
+	}
+	if ( strideY === 0 ) {
+		throw new RangeError( format( 'invalid argument. Eighth argument must be non-zero.' ) );
+	}
+	// Check if we can early return...
+	if ( M === 0 || N === 0 || alpha === 0.0 ) {
+		return A;
+	}
+	addon.ndarray( M, N, alpha, x, strideX, offsetX, y, strideY, offsetY, A, strideA1, strideA2, offsetA ); // eslint-disable-line max-len
 	return A;
 }