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: 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: 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/dsyr2/README.md

@@ -48,7 +48,7 @@ dsyr2( 'row-major', 'upper', 3, 1.0, x, 1, y, 1, A, 3 );
 The function has the following parameters:
 
 -   **order**: storage layout.
--   **uplo**: specifies whether the upper or lower triangular part of the symmetric matrix `A` should be referenced.
+-   **uplo**: specifies whether the upper or lower triangular part of the symmetric matrix `A` is supplied.
 -   **N**: number of elements along each dimension of `A`.
 -   **α**: scalar constant.
 -   **x**: first input [`Float64Array`][mdn-float64array].
@@ -198,7 +198,7 @@ console.log( A );
 
 #### c_dsyr2( order, uplo, N, alpha, \*X, strideX, \*Y, strideY, \*A, LDA )
 
-Performs the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A`.
+Performs the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A` where `α` is a scalar, `x` and `y` are `N` element vectors, and `A` is an `N` by `N` symmetric matrix.
 
 ```c
 #include "stdlib/blas/base/shared.h"
@@ -213,7 +213,7 @@ c_dsyr2( CblasColMajor, CblasUpper, 3, 1.0, x, 1, y, 1, A, 3 );
 The function accepts the following arguments:
 
 -   **order**: `[in] CBLAS_LAYOUT` storage layout.
--   **uplo**: `[in] CBLAS_UPLO` specifies whether the upper or lower triangular part of the symmetric matrix `A` should be referenced.
+-   **uplo**: `[in] CBLAS_UPLO` specifies whether the upper or lower triangular part of the symmetric matrix `A` is supplied.
 -   **N**: `[in] CBLAS_INT` number of elements along each dimension of `A`.
 -   **alpha**: `[in] double` scalar.
 -   **X**: `[in] double*` first input array.
@@ -231,7 +231,7 @@ void c_dsyr2( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const CBLAS_INT N
 
 #### c_dsyr2_ndarray( uplo, N, alpha, \*X, strideX, offsetX, \*Y, strideY, offsetY, \*A, sa1, sa2, oa )
 
-Performs the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A` using alternative indexing semantics.
+Performs the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A`, using alternative indexing semantics and where `α` is a scalar, `x` and `y` are `N` element vectors, and `A` is an `N` by `N` symmetric matrix.
 
 ```c
 #include "stdlib/blas/base/shared.h"
@@ -245,7 +245,7 @@ c_dsyr2_ndarray( CblasUpper, 3, 1.0, x, 1, 0, y, 1, 0, A, 3, 1, 0 );
 
 The function accepts the following arguments:
 
--   **uplo**: `[in] CBLAS_UPLO` specifies whether the upper or lower triangular part of the symmetric matrix `A` should be referenced.
+-   **uplo**: `[in] CBLAS_UPLO` specifies whether the upper or lower triangular part of the symmetric matrix `A` is supplied.
 -   **N**: `[in] CBLAS_INT` number of elements along each dimension of `A`.
 -   **alpha**: `[in] double` scalar.
 -   **X**: `[in] double*` first input array.
@@ -287,23 +287,29 @@ void c_dsyr2_ndarray( const CBLAS_UPLO uplo, const CBLAS_INT N, const double alp
 #include <stdio.h>
 
 int main( void ) {
+    // Define a 3x3 symmetric matrix stored in row-major order:
+    double A[] = {
+        1.0, 0.0, 0.0,
+        2.0, 1.0, 0.0,
+        3.0, 2.0, 1.0
+    };
+
     // Create strided arrays:
-    double A[] = { 1.0, 0.0, 0.0, 2.0, 1.0, 0.0, 3.0, 2.0, 1.0 };
     const double x[] = { 1.0, 2.0, 3.0 };
     const double y[] = { 1.0, 2.0, 3.0 };
 
     // Specify the number of elements along each dimension of `A`:
     const int N = 3;
 
-    // Perform the symmetric rank 1 operation `A = α*x*x^T + A`:
-    c_dsyr2( CblasColMajor, CblasUpper, N, 1.0, x, 1, y, 1 A, N );
+    // Perform the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A`:
+    c_dsyr2( CblasColMajor, CblasUpper, N, 1.0, x, 1, y, 1, A, N );
 
     // Print the result:
     for ( int i = 0; i < N*N; i++ ) {
         printf( "A[ %i ] = %f\n", i, A[ i ] );
     }
 
-    // Perform the symmetric rank 1 operation `A = α*x*x^T + A`:
+    // Perform the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A` using alternative semantics indexing:
     c_dsyr2_ndarray( CblasUpper, N, 1.0, x, 1, 0, y, 1, 0, A, N, 1, 0 );
 
     // Print the result:

lib/node_modules/@stdlib/blas/base/dsyr2/benchmark/c/benchmark.c

@@ -83,30 +83,30 @@ static double tic( void ) {
 * Runs a benchmark.
 *
 * @param iterations   number of iterations
-* @param N            number of elements along each dimension
+* @param len            number of elements along each dimension
 * @return             elapsed time in seconds
 */
-static double benchmark1( int iterations, int N ) {
+static double benchmark1( int iterations, int len ) {
 	double elapsed;
-	double A[ N*N ];
-	double x[ N ];
-	double y[ N ];
+	double A[ len*len ];
+	double x[ len ];
+	double y[ len ];
 	double t;
 	int i;
 
-	stdlib_strided_dfill( N, 0.5, x, 1 );
-	stdlib_strided_dfill( N, 0.5, y, 1 );
-	stdlib_strided_dfill( N*N, 1.0, A, 1 );
+	stdlib_strided_dfill( len, 1.0, x, 1 );
+	stdlib_strided_dfill( len, 1.0, y, 1 );
+	stdlib_strided_dfill( len*len, 1.0, A, 1 );
 	t = tic();
 	for ( i = 0; i < iterations; i++ ) {
-		c_dsyr2( CblasRowMajor, CblasUpper, N, 1.0, x, 1, y, 1, A, N );
-		if ( A[ 0 ] != A[ 0 ] ) {
+		c_dsyr2( CblasRowMajor, CblasUpper, len, 1.0, x, 1, y, 1, A, len );
+		if ( A[ i%len ] != A[ i%len ] ) {
 			printf( "should not return NaN\n" );
 			break;
 		}
 	}
 	elapsed = tic() - t;
-	if ( A[ 0 ] != A[ 0 ] ) {
+	if ( A[ i%len ] != A[ i%len ] ) {
 		printf( "should not return NaN\n" );
 	}
 	return elapsed;
@@ -116,30 +116,30 @@ static double benchmark1( int iterations, int N ) {
 * Runs a benchmark.
 *
 * @param iterations   number of iterations
-* @param N            number of elements along each dimension
+* @param len            number of elements along each dimension
 * @return             elapsed time in seconds
 */
-static double benchmark2( int iterations, int N ) {
+static double benchmark2( int iterations, int len ) {
 	double elapsed;
-	double A[ N*N ];
-	double x[ N ];
-	double y[ N ];
+	double A[ len*len ];
+	double x[ len ];
+	double y[ len ];
 	double t;
 	int i;
 
-	stdlib_strided_dfill( N, 0.5, x, 1 );
-	stdlib_strided_dfill( N, 0.5, y, 1 );
-	stdlib_strided_dfill( N*N, 1.0, A, 1 );
+	stdlib_strided_dfill( len, 1.0, x, 1 );
+	stdlib_strided_dfill( len, 1.0, y, 1 );
+	stdlib_strided_dfill( len*len, 1.0, A, 1 );
 	t = tic();
 	for ( i = 0; i < iterations; i++ ) {
-		c_dsyr2_ndarray( CblasUpper, N, 1.0, x, 1, 0, y, 1, 0, A, N, 1, 0 );
-		if ( A[ 0 ] != A[ 0 ] ) {
+		c_dsyr2_ndarray( CblasUpper, len, 1.0, x, 1, 0, y, 1, 0, A, len, 1, 0 );
+		if ( A[ i%len ] != A[ i%len ] ) {
 			printf( "should not return NaN\n" );
 			break;
 		}
 	}
 	elapsed = tic() - t;
-	if ( A[ 0 ] != A[ 0 ] ) {
+	if ( A[ i%len ] != A[ i%len ] ) {
 		printf( "should not return NaN\n" );
 	}
 	return elapsed;
@@ -154,27 +154,27 @@ int main( void ) {
 	int iter;
 	int i;
 	int j;
-	int N;
+	int len;
 
 	// Use the current time to seed the random number generator:
 	srand( time( NULL ) );
 
 	print_version();
 	count = 0;
 	for ( i = MIN; i <= MAX; i++ ) {
-		N = floor( pow( pow( 10, i ), 1.0/2.0 ) );
+		len = 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:size=%d\n", NAME, N*N );
-			elapsed = benchmark1( iter, N );
+			printf( "# c::%s:size=%d\n", NAME, len*len );
+			elapsed = benchmark1( iter, len );
 			print_results( iter, elapsed );
 			printf( "ok %d benchmark finished\n", count );
 		}
 		for ( j = 0; j < REPEATS; j++ ) {
 			count += 1;
-			printf( "# c::%s:ndarray:size=%d\n", NAME, N*N );
-			elapsed = benchmark2( iter, N );
+			printf( "# c::%s:ndarray:size=%d\n", NAME, len*len );
+			elapsed = benchmark2( iter, len );
 			print_results( iter, elapsed );
 			printf( "ok %d benchmark finished\n", count );
 		}

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

@@ -21,8 +21,14 @@
 #include <stdio.h>
 
 int main( void ) {
+	// Define a 3x3 symmetric matrix stored in row-major order:
+	double A[] = {
+		1.0, 0.0, 0.0,
+		2.0, 1.0, 0.0,
+		3.0, 2.0, 1.0
+	};
+
 	// Create strided arrays:
-	double A[] = { 1.0, 0.0, 0.0, 2.0, 1.0, 0.0, 3.0, 2.0, 1.0 };
 	const double x[] = { 1.0, 2.0, 3.0 };
 	const double y[] = { 1.0, 2.0, 3.0 };
 
@@ -37,7 +43,7 @@ int main( void ) {
 		printf( "A[ %i ] = %f\n", i, A[ i ] );
 	}
 
-	// Perform the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A`:
+	// Perform the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A` using alternative semantics indexing:
 	c_dsyr2_ndarray( CblasUpper, N, 1.0, x, 1, 0, y, 1, 0, A, N, 1, 0 );
 
 	// Print the result:

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

@@ -32,12 +32,12 @@ extern "C" {
 #endif
 
 /**
-* Performs the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A`.
+* Performs the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A` where `α` is a scalar, `x` and `y` are `N` element vectors, and `A` is an `N` by `N` symmetric matrix.
 */
 void API_SUFFIX(c_dsyr2)( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const CBLAS_INT N, const double alpha, const double *X, const CBLAS_INT strideX, const double *Y, const CBLAS_INT strideY, double *A, const CBLAS_INT LDA );
 
 /**
-* Performs the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A` using alternative indexing semantics.
+* Performs the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A`, using alternative indexing semantics and where `α` is a scalar, `x` and `y` are `N` element vectors, and `A` is an `N` by `N` symmetric matrix.
 */
 void API_SUFFIX(c_dsyr2_ndarray)( const CBLAS_UPLO uplo, const CBLAS_INT N, const double alpha, const double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, const double *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY, double *A, const CBLAS_INT strideA1, const CBLAS_INT strideA2, const CBLAS_INT offsetA );
 

lib/node_modules/@stdlib/blas/base/dsyr2/include/stdlib/blas/base/dsyr2_cblas.h

@@ -32,7 +32,7 @@ extern "C" {
 #endif
 
 /**
-* Performs the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A`.
+* Performs the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A` where `α` is a scalar, `x` and `y` are `N` element vectors, and `A` is an `N` by `N` symmetric matrix.
 */
 void API_SUFFIX(cblas_dsyr2)( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const CBLAS_INT N, const double alpha, const double *X, const CBLAS_INT strideX, const double *Y, const CBLAS_INT strideY, double *A, const CBLAS_INT LDA );
 

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

@@ -28,10 +28,10 @@ var addon = require( './../src/addon.node' );
 // MAIN //
 
 /**
-* Performs the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A`.
+* Performs the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A` where `α` is a scalar, `x` and `y` are `N` element vectors, and `A` is an `N` by `N` symmetric matrix.
 *
 * @param {string} order - storage layout
-* @param {string} uplo - specifies whether the upper or lower triangular part of the symmetric matrix `A` should be referenced
+* @param {string} uplo - specifies whether the upper or lower triangular part of the symmetric matrix `A` is supplied
 * @param {NonNegativeInteger} N - number of elements along each dimension of `A`
 * @param {number} alpha - scalar
 * @param {Float64Array} x - first input vector

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

@@ -27,9 +27,9 @@ var addon = require( './../src/addon.node' );
 // MAIN //
 
 /**
-* Performs the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A`.
+* Performs the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A` where `α` is a scalar, `x` and `y` are `N` element vectors, and `A` is an `N` by `N` symmetric matrix.
 *
-* @param {string} uplo - specifies whether the upper or lower triangular part of the symmetric matrix `A` should be referenced
+* @param {string} uplo - specifies whether the upper or lower triangular part of the symmetric matrix `A` is supplied
 * @param {NonNegativeInteger} N - number of elements along each dimension of `A`
 * @param {number} alpha - scalar
 * @param {Float64Array} x - first input vector

lib/node_modules/@stdlib/blas/base/dsyr2/src/addon.c

@@ -35,6 +35,9 @@
 * @return       Node-API value
 */
 static napi_value addon( napi_env env, napi_callback_info info ) {
+	CBLAS_INT sa1;
+	CBLAS_INT sa2;
+
 	STDLIB_NAPI_ARGV( env, info, argv, argc, 10 );
 
 	STDLIB_NAPI_ARGV_INT32( env, order, argv, 0 );
@@ -47,9 +50,17 @@ static napi_value addon( napi_env env, napi_callback_info info ) {
 
 	STDLIB_NAPI_ARGV_DOUBLE( env, alpha, argv, 3 );
 
+	if ( order == CblasColMajor ) {
+		sa1 = 1;
+		sa2 = LDA;
+	} else { // order === CblasRowMajor
+		sa1 = LDA;
+		sa2 = 1;
+	}
+
 	STDLIB_NAPI_ARGV_STRIDED_FLOAT64ARRAY( env, X, N, strideX, argv, 4 );
 	STDLIB_NAPI_ARGV_STRIDED_FLOAT64ARRAY( env, Y, N, strideY, argv, 6 );
-	STDLIB_NAPI_ARGV_STRIDED_FLOAT64ARRAY( env, A, ((N-1)*LDA) + N, 1, argv, 8 );
+	STDLIB_NAPI_ARGV_STRIDED_FLOAT64ARRAY2D( env, A, M, N, sa1, sa2, argv, 8 );
 
 	API_SUFFIX(c_dsyr2)( order, uplo, N, alpha, X, strideX, Y, strideY, A, LDA );
 

lib/node_modules/@stdlib/blas/base/dsyr2/src/dsyr2.c

@@ -21,10 +21,10 @@
 #include "stdlib/strided/base/stride2offset.h"
 
 /**
-* Performs the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A`.
+* Performs the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A` where `α` is a scalar, `x` and `y` are `N` element vectors, and `A` is an `N` by `N` symmetric matrix.
 *
 * @param order    storage layout
-* @param uplo     specifies whether the upper or lower triangular part of the symmetric matrix `A` should be referenced
+* @param uplo     specifies whether the upper or lower triangular part of the symmetric matrix `A` is supplied
 * @param N        number of elements along each dimension of `A`
 * @param alpha    scalar
 * @param X        first input vector
@@ -46,7 +46,7 @@ void API_SUFFIX(c_dsyr2)( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const
 	if ( order == CblasColMajor ) {
 		sa1 = 1;
 		sa2 = LDA;
-	} else { // order === 'row-major'
+	} else { // order === CblasRowMajor
 		sa1 = LDA;
 		sa2 = 1;
 	}

lib/node_modules/@stdlib/blas/base/dsyr2/src/dsyr2_cblas.c

@@ -23,10 +23,10 @@
 #include "stdlib/ndarray/base/min_view_buffer_index.h"
 
 /**
-* Performs the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A`.
+* Performs the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A` where `α` is a scalar, `x` and `y` are `N` element vectors, and `A` is an `N` by `N` symmetric matrix.
 *
 * @param order    storage layout
-* @param uplo     specifies whether the upper or lower triangular part of the symmetric matrix `A` should be referenced
+* @param uplo     specifies whether the upper or lower triangular part of the symmetric matrix `A` is supplied
 * @param N        number of elements along each dimension of `A`
 * @param alpha    scalar
 * @param x        first input vector
@@ -45,9 +45,9 @@ void API_SUFFIX(c_dsyr2)( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const
 }
 
 /**
-* Performs the symmetric rank 2 operation `A = α*x*x^T + A` using alternative indexing semantics.
+* Performs the symmetric rank 2 operation `A = α*x*x^T + A`, using alternative indexing semantics and where `α` is a scalar, `x` and `y` are `N` element vectors, and `A` is an `N` by `N` symmetric matrix.
 *
-* @param uplo      specifies whether the upper or lower triangular part of the symmetric matrix `A` should be referenced
+* @param uplo      specifies whether the upper or lower triangular part of the symmetric matrix `A` is supplied
 * @param N         number of elements along each dimension of `A`
 * @param alpha     scalar
 * @param X         input vector