chore: 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: passed
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: passed
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: missing_dependencies
  - task: lint_c_examples
    status: missing_dependencies
  - task: lint_c_benchmarks
    status: missing_dependencies
  - 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: ShabiShett07

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

@@ -194,15 +194,15 @@ console.log( x );
 #include "stdlib/blas/base/dtrsv.h"
 ```
 
-#### c_dtrsv( order, uplo, trans, diag, N, \*A, LDA, \*X, strideX )
+#### c_dtrsv( order, uplo, trans, diag, N, \*A, LDA, \*X, sx )
 
 Solves one of the systems of equations `A*x = b` or `A^T*x = b` where `b` and `x` are `N` element vectors and `A` is an `N` by `N` unit, or non-unit, upper or lower triangular matrix.
 
 ```c
 #include "stdlib/blas/base/shared.h"
 
-double A[] = { 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 0.0, 0.0, 1.0 };
-const double x[] = { 1.0, 2.0, 3.0 };
+const double A[] = { 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 0.0, 0.0, 1.0 };
+double x[] = { 1.0, 2.0, 3.0 };
 
 c_dtrsv( CblasRowMajor, CblasUpper, CblasNoTrans, CblasUnit, 3, A, 3, x, 1 );
 ```
@@ -214,25 +214,24 @@ The function accepts the following arguments:
 -   **trans**: `[in] CBLAS_TRANSPOSE` specifies whether `A` should be transposed, conjugate-transposed, or not transposed.
 -   **diag**: `[in] CBLAS_DIAG` specifies whether `A` has a unit diagonal.
 -   **N**: `[in] CBLAS_INT` number of elements along each dimension of `A`.
--   **A**: `[inout] double*` input matrix.
+-   **A**: `[in] double*` input matrix.
 -   **LDA**: `[in] CBLAS_INT` stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`).
--   **X**: `[in] double*` input vector.
--   **strideX**: `[in] CBLAS_INT` index increment for `X`.
+-   **X**: `[inout] double*` input vector.
+-   **sx**: `[in] CBLAS_INT` stride length for `X`.
 
 ```c
 void c_dtrsv( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const CBLAS_TRANSPOSE trans, const CBLAS_DIAG diag, const CBLAS_INT N, const double *A, const CBLAS_INT LDA, double *x, const CBLAS_INT strideX )
 ```
 
-<!-- lint disable maximum-heading-length -->
-#### c_dtrsv_ndarray( uplo, trans, diag, N, \*A, strideA1, strideA2, offsetA, \*X, strideX, offsetA )
+#### c_dtrsv_ndarray( uplo, trans, diag, N, \*A, sa1, sa2, oa, \*X, sx, oa )
 
 Performs one of the matrix-vector operations `x = A*x` or `x = A^T*x` using alternative indexing semantics, where `x` is an `N` element vector and `A` is an `N` by `N` unit, or non-unit, upper or lower triangular matrix.
 
 ```c
 #include "stdlib/blas/base/shared.h"
 
-double A[] = { 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 0.0, 0.0, 1.0 };
-const double x[] = { 1.0, 2.0, 3.0 };
+const double A[] = { 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 0.0, 0.0, 1.0 };
+double x[] = { 1.0, 2.0, 3.0 };
 
 c_dtrsv_ndarray( CblasUpper, CblasNoTrans, CblasUnit, 3, A, 3, 1, 0, x, 1, 0 );
 ```
@@ -243,13 +242,13 @@ The function accepts the following arguments:
 -   **trans**: `[in] CBLAS_TRANSPOSE` specifies whether `A` should be transposed, conjugate-transposed, or not transposed.
 -   **diag**: `[in] CBLAS_DIAG` specifies whether `A` has a unit diagonal.
 -   **N**: `[in] CBLAS_INT` number of elements along each dimension of `A`.
--   **A**: `[inout] double*` input matrix.
--   **strideA1**: `[in] CBLAS_INT` stride of the first dimension of `A`.
--   **strideA2**: `[in] CBLAS_INT` stride of the second dimension of `A`.
--   **offsetA**: `[in] CBLAS_INT` starting index for `A`.
--   **X**: `[in] double*` input vector.
--   **strideX**: `[in] CBLAS_INT` index increment for `X`.
--   **offsetX**: `[in] CBLAS_INT` starting index for `X`.
+-   **A**: `[in] double*` input matrix.
+-   **sa1**: `[in] CBLAS_INT` stride of the first dimension of `A`.
+-   **sa2**: `[in] CBLAS_INT` stride of the second dimension of `A`.
+-   **oa**: `[in] CBLAS_INT` starting index for `A`.
+-   **X**: `[inout] double*` input vector.
+-   **sx**: `[in] CBLAS_INT` stride length for `X`.
+-   **ox**: `[in] CBLAS_INT` starting index for `X`.
 
 ```c
 void c_dtrsv_ndarray( const CBLAS_UPLO uplo, const CBLAS_TRANSPOSE trans, const CBLAS_DIAG diag, const CBLAS_INT N, const double *A, const CBLAS_INT strideA1, const CBLAS_INT strideA2, const CBLAS_INT offsetA, double *x, const CBLAS_INT strideX, const CBLAS_INT offsetX )
@@ -279,9 +278,14 @@ void c_dtrsv_ndarray( const CBLAS_UPLO uplo, const CBLAS_TRANSPOSE trans, const
 #include <stdio.h>
 
 int main( void ) {
-    // Create a strided array:
-    const double A[] = { 1.0, 0.0, 0.0, 2.0, 1.0, 0.0, 3.0, 2.0, 1.0 };
-    double X[] = { 1.0, 2.0, 3.0 };
+    // Define a 3x3 matrix stored in row-major order:
+    const double A[ 3*3 ] = {
+        1.0, 0.0, 0.0,
+        2.0, 1.0, 0.0,
+        3.0, 2.0, 1.0
+    };
+    // Define `x` vector:
+    double X[ 3 ] = { 1.0, 2.0, 3.0 };
 
     // Specify the number of elements along each dimension of `A`:
     const int N = 3;
@@ -294,7 +298,7 @@ int main( void ) {
         printf( "X[ %i ] = %f\n", i, X[ i ] );
     }
 
-    // Perform the matrix-vector operations `A*X = b` for `lower` triangular matrix `A`:
+    // Perform the matrix-vector operations `A*X = b` for `lower` triangular matrix `A` using alternative indexing semantics:
     c_dtrsv_ndarray( CblasLower, CblasNoTrans, CblasNonUnit, N, A, N, 1, 0, X, 1, 0 );
 
     // Print the result:

lib/node_modules/@stdlib/blas/base/dtrsv/benchmark/c/benchmark.length.c

@@ -18,7 +18,6 @@
 
 #include "stdlib/blas/base/dtrsv.h"
 #include "stdlib/blas/ext/base/dfill.h"
-#include "stdlib/math/base/special/floorf.h"
 #include <stdlib.h>
 #include <stdio.h>
 #include <math.h>
@@ -93,13 +92,13 @@ static double rand_double( void ) {
 * Runs a benchmark.
 *
 * @param iterations   number of iterations
-* @param len          array length
+* @param N            array dimension size
 * @return elapsed time in seconds
 */
-static double benchmark1( int iterations, int len ) {
+static double benchmark1( int iterations, int N ) {
 	double elapsed;
-	double A[ len*len ];
-	double X[ len ];
+	double A[ N*N ];
+	double X[ N ];
 	double t;
 	int i;
 	int j;
@@ -111,14 +110,14 @@ static double benchmark1( int iterations, int len ) {
 	}
 	t = tic();
 	for ( i = 0; i < iterations; i++ ) {
-		c_dtrsv( CblasRowMajor, CblasLower, CblasNoTrans, CblasUnit, len, A, len, X, 1 );
-		if ( X[ i%len ] != X[ i%len ] ) {
+		c_dtrsv( CblasRowMajor, CblasLower, CblasNoTrans, CblasUnit, N, A, N, X, 1 );
+		if ( X[ i%N ] != X[ i%N ] ) {
 			printf( "should not return NaN\n" );
 			break;
 		}
 	}
 	elapsed = tic() - t;
-	if ( X[ i%len ] != X[ i%len ] ) {
+	if ( X[ i%N ] != X[ i%N ] ) {
 		printf( "should not return NaN\n" );
 	}
 	return elapsed;
@@ -128,13 +127,13 @@ static double benchmark1( int iterations, int len ) {
 * Runs a benchmark.
 *
 * @param iterations   number of iterations
-* @param len          array length
+* @param N            array dimensions size
 * @return elapsed time in seconds
 */
-static double benchmark2( int iterations, int len ) {
+static double benchmark2( int iterations, int N ) {
 	double elapsed;
-	double A[ len*len ];
-	double X[ len ];
+	double A[ N*N ];
+	double X[ N ];
 	double t;
 	int i;
 	int j;
@@ -146,14 +145,14 @@ static double benchmark2( int iterations, int len ) {
 	}
 	t = tic();
 	for ( i = 0; i < iterations; i++ ) {
-		c_dtrsv_ndarray( CblasLower, CblasNoTrans, CblasUnit, len, A, len, 1, 0, X, 1, 0 );
-		if ( X[ i%len ] != X[ i%len ] ) {
+		c_dtrsv_ndarray( CblasLower, CblasNoTrans, CblasUnit, N, A, N, 1, 0, X, 1, 0 );
+		if ( X[ i%N ] != X[ i%N ] ) {
 			printf( "should not return NaN\n" );
 			break;
 		}
 	}
 	elapsed = tic() - t;
-	if ( X[ i%len ] != X[ i%len ] ) {
+	if ( X[ i%N ] != X[ i%N ] ) {
 		printf( "should not return NaN\n" );
 	}
 	return elapsed;
@@ -166,7 +165,7 @@ int main( void ) {
 	double elapsed;
 	int count;
 	int iter;
-	int len;
+	int N;
 	int i;
 	int j;
 
@@ -176,19 +175,19 @@ int main( void ) {
 	print_version();
 	count = 0;
 	for ( i = MIN; i <= MAX; i++ ) {
-		len = stdlib_base_floorf( pow( pow( 10, i ), 1.0/2.0 ) );
+		N = floor( pow( pow( 10, i ), 1.0/2.0 ) );
 		iter = ITERATIONS / pow( 10, i-1 );
 		for ( j = 0; j < REPEATS; j++ ) {
 			count += 1;
-			printf( "# c::%s:len=%d\n", NAME, len );
-			elapsed = benchmark1( iter, len );
+			printf( "# c::%s:size=%d\n", NAME, N*N );
+			elapsed = benchmark1( iter, N );
 			print_results( iter, elapsed );
 			printf( "ok %d benchmark finished\n", count );
 		}
 		for ( j = 0; j < REPEATS; j++ ) {
 			count += 1;
-			printf( "# c::%s:ndarray:len=%d\n", NAME, len );
-			elapsed = benchmark2( iter, len );
+			printf( "# c::%s:ndarray:size=%d\n", NAME, N*N );
+			elapsed = benchmark2( iter, N );
 			print_results( iter, elapsed );
 			printf( "ok %d benchmark finished\n", count );
 		}

lib/node_modules/@stdlib/blas/base/dtrsv/docs/repl.txt

@@ -1,5 +1,5 @@
 
-{{alias}}( ord, uplo, trans, diag, N, A, lda, x, sx )
+{{alias}}( order, uplo, trans, diag, N, A, lda, x, sx )
     Solves one of the systems of equations `A*x = b` or `A^T*x = b` where `b`
     and `x` are `N` element vectors and `A` is an `N` by `N` unit, or non-unit,
     upper or lower triangular matrix.
@@ -11,7 +11,7 @@
 
     Parameters
     ----------
-    ord: string
+    order: string
         Row-major (C-style) or column-major (Fortran-style) order. Must be
         either 'row-major' or 'column-major'.
 
@@ -48,11 +48,25 @@
 
     Examples
     --------
+    // Standard usage:
     > var x = new {{alias:@stdlib/array/float64}}( [ 1.0, 1.0 ] );
     > var A = new {{alias:@stdlib/array/float64}}( [ 1.0, 2.0, 0.0, 1.0 ] );
     > {{alias}}( 'row-major', 'upper', 'no-transpose', 'unit', 2, A, 2, x, 1 )
     <Float64Array>[ -1.0, 1.0 ]
 
+    // Advanced indexing:
+    > x = new {{alias:@stdlib/array/float64}}( [ 1.0, 1.0 ] );
+    > A = new {{alias:@stdlib/array/float64}}( [ 1.0, 2.0, 0.0, 1.0 ] );
+    > {{alias}}( 'row-major', 'upper', 'no-transpose', 'unit', 2, A, 2, x, -1 )
+    <Float64Array>[ 1.0, -1.0 ]
+
+    // Using typed array views:
+    > var x0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 1.0, 1.0 ] );
+    > A = new {{alias:@stdlib/array/float64}}( [ 1.0, 2.0, 0.0, 1.0 ] );
+    > var x1 = new {{alias:@stdlib/array/float64}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 );
+    > {{alias}}( 'row-major', 'upper', 'no-transpose', 'unit', 2, A, 2, x1, 1 )
+    <Float64Array>[ -1.0, 1.0 ]
+
 
 {{alias}}.ndarray( uplo, trans, diag, N, A, sa1, sa2, oa, x, sx, ox )
     Solves one of the systems of equations `A*x = b` or `A^T*x = b`, using

lib/node_modules/@stdlib/blas/base/dtrsv/examples/c/example.c

@@ -22,13 +22,13 @@
 
 int main( void ) {
 	// Define a 3x3 matrix stored in row-major order:
-	const double A[] = {
+	const double A[ 3*3 ] = {
 		1.0, 0.0, 0.0,
 		2.0, 1.0, 0.0,
 		3.0, 2.0, 1.0
 	};
 	// Define `x` vector:
-	double X[] = { 1.0, 2.0, 3.0 };
+	double X[ 3 ] = { 1.0, 2.0, 3.0 };
 
 	// Specify the number of elements along each dimension of `A`:
 	const int N = 3;

lib/node_modules/@stdlib/blas/base/dtrsv/include/stdlib/blas/base/dtrsv.h

@@ -34,7 +34,7 @@ extern "C" {
 /**
 * Solves one of the systems of equations `A*x = b` or `A^T*x = b` where `b` and `x` are `N` element vectors and `A` is an `N` by `N` unit, or non-unit, upper or lower triangular matrix.
 */
-void API_SUFFIX(c_dtrsv)( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const CBLAS_TRANSPOSE trans, const CBLAS_DIAG diag, const CBLAS_INT N, const double *A, const CBLAS_INT LDA, double *X, const CBLAS_INT strideX );
+void API_SUFFIX(c_dtrsv)( const CBLAS_LAYOUT layout, const CBLAS_UPLO uplo, const CBLAS_TRANSPOSE trans, const CBLAS_DIAG diag, const CBLAS_INT N, const double *A, const CBLAS_INT LDA, double *X, const CBLAS_INT strideX );
 
 /**
 * Solves one of the systems of equations `A*x = b` or `A^T*x = b`, using alternative indexing semantics and where `b` and `x` are `N` element vectors and `A` is an `N` by `N` unit, or non-unit, upper or lower triangular matrix.

lib/node_modules/@stdlib/blas/base/dtrsv/include/stdlib/blas/base/dtrsv_cblas.h

@@ -35,7 +35,7 @@ extern "C" {
 /**
 * Solves one of the systems of equations `A*x = b` or `A^T*x = b` where `b` and `x` are `N` element vectors and `A` is an `N` by `N` unit, or non-unit, upper or lower triangular matrix.
 */
-void API_SUFFIX(cblas_dtrsv)( const CBLAS_UPLO uplo, const CBLAS_TRANSPOSE trans, const CBLAS_DIAG diag, const CBLAS_INT N, const double *A, const CBLAS_INT strideA1, const CBLAS_INT strideA2, const CBLAS_INT offsetA, double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX );
+void API_SUFFIX(cblas_dtrsv)( const CBLAS_LAYOUT layout, const CBLAS_UPLO uplo, const CBLAS_TRANSPOSE trans, const CBLAS_DIAG diag, const CBLAS_INT N, const double *A, const CBLAS_INT strideA1, const CBLAS_INT strideA2, const CBLAS_INT offsetA, double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX );
 
 #ifdef __cplusplus
 }

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

@@ -20,13 +20,13 @@
 
 // MODULES //
 
-var max = require( '@stdlib/math/base/special/fast/max' );
+var isColumnMajor = require( '@stdlib/ndarray/base/assert/is-column-major-string' );
 var isLayout = require( '@stdlib/blas/base/assert/is-layout' );
 var isMatrixTriangle = require( '@stdlib/blas/base/assert/is-matrix-triangle' );
 var isTransposeOperation = require( '@stdlib/blas/base/assert/is-transpose-operation' );
 var isDiagonal = require( '@stdlib/blas/base/assert/is-diagonal-type' );
-var isColumnMajor = require( '@stdlib/ndarray/base/assert/is-column-major-string' );
 var stride2offset = require( '@stdlib/strided/base/stride2offset' );
+var max = require( '@stdlib/math/base/special/fast/max' );
 var format = require( '@stdlib/string/format' );
 var base = require( './base.js' );
 
@@ -50,7 +50,7 @@ var base = require( './base.js' );
 * @throws {TypeError} third argument must be a valid transpose operation
 * @throws {TypeError} fourth argument must be a valid diagonal type
 * @throws {RangeError} fifth argument must be a nonnegative integer
-* @throws {RangeError} seventh argument must be greater than or equal to max(1,N)
+* @throws {RangeError} seventh argument must be a valid stride
 * @throws {RangeError} ninth argument must be non-zero
 * @returns {Float64Array} `x`
 *
@@ -89,6 +89,7 @@ function dtrsv( order, uplo, trans, diag, N, A, LDA, x, strideX ) {
 	if ( strideX === 0 ) {
 		throw new RangeError( format( 'invalid argument. Ninth argument must be non-zero. Value: `%d`.', strideX ) );
 	}
+	// Check if we can early return...
 	if ( N === 0 ) {
 		return x;
 	}

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

@@ -20,10 +20,16 @@
 
 // MODULES //
 
+var isLayout = require( '@stdlib/blas/base/assert/is-layout' );
+var isMatrixTriangle = require( '@stdlib/blas/base/assert/is-matrix-triangle' );
+var isTransposeOperation = require( '@stdlib/blas/base/assert/is-transpose-operation' );
+var isDiagonal = require( '@stdlib/blas/base/assert/is-diagonal-type' );
 var resolveOrder = require( '@stdlib/blas/base/layout-resolve-enum' );
 var resolveUplo = require( '@stdlib/blas/base/matrix-triangle-resolve-enum' );
 var resolveTrans = require( '@stdlib/blas/base/transpose-operation-resolve-enum' );
 var resolveDiag = require( '@stdlib/blas/base/diagonal-type-resolve-enum' );
+var max = require( '@stdlib/math/base/special/fast/max' );
+var format = require( '@stdlib/string/format' );
 var addon = require( './../src/addon.node' );
 
 
@@ -41,6 +47,13 @@ var addon = require( './../src/addon.node' );
 * @param {integer} LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
 * @param {Float64Array} x - input vector
 * @param {integer} strideX - `x` stride length
+* @throws {TypeError} first argument must be a valid order
+* @throws {TypeError} second argument must specify whether a lower or upper triangular matrix is supplied
+* @throws {TypeError} third argument must be a valid transpose operation
+* @throws {TypeError} fourth argument must be a valid diagonal type
+* @throws {RangeError} fifth argument must be a nonnegative integer
+* @throws {RangeError} seventh argument must be a valid stride
+* @throws {RangeError} ninth argument must be non-zero
 * @returns {Float64Array} `x`
 *
 * @example
@@ -53,6 +66,31 @@ var addon = require( './../src/addon.node' );
 * // x => <Float64Array>[ 0.0, -4.0, 3.0 ]
 */
 function dtrsv( order, uplo, trans, diag, N, A, LDA, x, strideX ) {
+	if ( !isLayout( order ) ) {
+		throw new TypeError( format( 'invalid argument. First argument must be a valid order. Value: `%s`.', order ) );
+	}
+	if ( !isMatrixTriangle( uplo ) ) {
+		throw new TypeError( format( 'invalid argument. Second argument must specify whether the lower or upper triangular matrix is supplied. Value: `%s`.', uplo ) );
+	}
+	if ( !isTransposeOperation( trans ) ) {
+		throw new TypeError( format( 'invalid argument. Third argument must be a valid transpose operation. Value: `%s`.', trans ) );
+	}
+	if ( !isDiagonal( diag ) ) {
+		throw new TypeError( format( 'invalid argument. Fourth argument must be a valid diagonal type. Value: `%s`.', diag ) );
+	}
+	if ( N < 0 ) {
+		throw new RangeError( format( 'invalid argument. Fifth argument must be a nonnegative integer. Value: `%d`.', N ) );
+	}
+	if ( LDA < max( 1, N ) ) {
+		throw new RangeError( format( 'invalid argument. Seventh argument must be greater than or equal to max(1,%d). Value: `%d`.', N, LDA ) );
+	}
+	if ( strideX === 0 ) {
+		throw new RangeError( format( 'invalid argument. Ninth argument must be non-zero. Value: `%d`.', strideX ) );
+	}
+	// Check if we can early return...
+	if ( N === 0 ) {
+		return x;
+	}
 	addon( resolveOrder( order ), resolveUplo( uplo ), resolveTrans( trans ), resolveDiag( diag ), N, A, LDA, x, strideX ); // eslint-disable-line max-len
 	return x;
 }