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: passed
  - 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

@@ -52,9 +52,9 @@ The function has the following parameters:
 -   **N**: number of elements along each dimension of `A`.
 -   **α**: scalar constant.
 -   **x**: first input [`Float64Array`][mdn-float64array].
--   **sx**: index increment for `x`.
+-   **sx**: stride length for `x`.
 -   **y**: second input [`Float64Array`][mdn-float64array].
--   **sy**: index increment for `y`.
+-   **sy**: stride length for `y`.
 -   **A**: input matrix stored in linear memory as a [`Float64Array`][mdn-float64array].
 -   **lda**: stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`).
 
@@ -196,7 +196,7 @@ console.log( A );
 #include "stdlib/blas/base/dsyr2.h"
 ```
 
-#### c_dsyr2( order, uplo, N, alpha, \*X, strideX, \*Y, strideY, \*A, LDA )
+#### c_dsyr2( order, uplo, N, alpha, \*X, sx, \*Y, sy, \*A, LDA )
 
 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.
 
@@ -215,11 +215,11 @@ 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` is supplied.
 -   **N**: `[in] CBLAS_INT` number of elements along each dimension of `A`.
--   **alpha**: `[in] double` scalar.
+-   **alpha**: `[in] double` scalar constant.
 -   **X**: `[in] double*` first input array.
--   **strideX**: `[in] CBLAS_INT` index increment for `X`.
+-   **strideX**: `[in] CBLAS_INT` stride length for `X`.
 -   **Y**: `[in] double*` second input array.
--   **strideY**: `[in] CBLAS_INT` index increment for `Y`.
+-   **strideY**: `[in] CBLAS_INT` stride length for `Y`.
 -   **A**: `[inout] double*` input matrix.
 -   **LDA**: `[in] CBLAS_INT` stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`).
 
@@ -229,7 +229,7 @@ void c_dsyr2( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const CBLAS_INT N
 
 <!-- lint disable maximum-heading-length -->
 
-#### c_dsyr2_ndarray( uplo, N, alpha, \*X, strideX, offsetX, \*Y, strideY, offsetY, \*A, sa1, sa2, oa )
+#### c_dsyr2_ndarray( uplo, N, alpha, \*X, sx, ox, \*Y, sy, oy, \*A, sa1, sa2, oa )
 
 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.
 
@@ -247,20 +247,20 @@ The function accepts the following arguments:
 
 -   **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.
+-   **alpha**: `[in] double` scalar constant.
 -   **X**: `[in] double*` first input array.
--   **strideX**: `[in] CBLAS_INT` index increment for `X`.
+-   **strideX**: `[in] CBLAS_INT` stride length for `X`.
 -   **offsetX**: `[in] CBLAS_INT` starting index for `X`.
 -   **Y**: `[in] double` second input array.
--   **strideY**: `[in] CBLAS_INT` index increment for `Y`.
+-   **strideY**: `[in] CBLAS_INT` stride length for `Y`.
 -   **offsetY**: `[in] CBLAS_INT` starting index for `Y`.
 -   **A**: `[inout] 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`.
 
 ```c
-void 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, CBLAS_INT strideY, const CBLAS_INT offsetY, double *A, const CBLAS_INT sa1, const CBLAS_INT sa2, const CBLAS_INT oa )
+void 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, CBLAS_INT strideY, const CBLAS_INT offsetY, double *A, const CBLAS_INT strideA1, const CBLAS_INT strideA2, const CBLAS_INT offsetA )
 ```
 
 </section>
@@ -294,7 +294,7 @@ int main( void ) {
         3.0, 2.0, 1.0
     };
 
-    // Create strided arrays:
+    // Define `x` and `y` vectors:
     const double x[] = { 1.0, 2.0, 3.0 };
     const double y[] = { 1.0, 2.0, 3.0 };
 

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

@@ -42,7 +42,7 @@ var options = {
 * Creates a benchmark function.
 *
 * @private
-* @param {PositiveInteger} N - number of elements along each dimension
+* @param {PositiveInteger} N - array length
 * @returns {Function} benchmark function
 */
 function createBenchmark( N ) {

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

@@ -47,7 +47,7 @@ var options = {
 * Creates a benchmark function.
 *
 * @private
-* @param {PositiveInteger} N - number of elements along each dimension
+* @param {PositiveInteger} N - array length
 * @returns {Function} benchmark function
 */
 function createBenchmark( N ) {

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

@@ -42,7 +42,7 @@ var options = {
 * Creates a benchmark function.
 *
 * @private
-* @param {PositiveInteger} N - number of elements along each dimension
+* @param {PositiveInteger} N - array length
 * @returns {Function} benchmark function
 */
 function createBenchmark( N ) {

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

@@ -47,7 +47,7 @@ var options = {
 * Creates a benchmark function.
 *
 * @private
-* @param {PositiveInteger} N - number of elements along each dimension
+* @param {PositiveInteger} N - array length
 * @returns {Function} benchmark function
 */
 function createBenchmark( N ) {

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

@@ -52,12 +52,29 @@
 
     Examples
     --------
+    // Standard usage:
     > var x = new {{alias:@stdlib/array/float64}}( [ 1.0, 1.0 ] );
     > var y = new {{alias:@stdlib/array/float64}}( [ 1.0, 1.0 ] );
     > var A = new {{alias:@stdlib/array/float64}}( [ 1.0, 2.0, 0.0, 2.0 ] );
     > {{alias}}( 'row-major', 'upper', 2, 1.0, x, 1, y, 1, A, 2 )
     <Float64Array>[ 3.0, 4.0, 0.0, 4.0 ]
 
+    // Advanced indexing:
+    > x = new {{alias:@stdlib/array/float64}}( [ 1.0, 1.0 ] );
+    > y = new {{alias:@stdlib/array/float64}}( [ 1.0, 1.0 ] );
+    > A = new {{alias:@stdlib/array/float64}}( [ 1.0, 2.0, 0.0, 2.0 ] );
+    > {{alias}}( 'row-major', 'upper', 2, 1.0, x, -1, y, -1, A, 2 )
+    <Float64Array>[ 3.0, 4.0, 0.0, 4.0 ]
+
+    // Using typed array views:
+    > var x0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 1.0, 1.0 ] );
+    > var y0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 1.0, 1.0 ] );
+    > A = new {{alias:@stdlib/array/float64}}( [ 1.0, 2.0, 0.0, 2.0 ] );
+    > var x1 = new {{alias:@stdlib/array/float64}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 );
+    > var y1 = new {{alias:@stdlib/array/float64}}( y0.buffer, y0.BYTES_PER_ELEMENT*1 );
+    > {{alias}}( 'row-major', 'upper', 2, 1.0, x, 1, y, 1, A, 2 )
+    <Float64Array>[ 3.0, 4.0, 0.0, 4.0 ]
+
 
 {{alias}}.ndarray( uplo, N, α, x, sx, ox, y, sy, oy, A, sa1, sa2, oa )
     Performs the symmetric rank 2 operation `A = α*x*y^T + α*y*x^T + A`, using

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

@@ -22,15 +22,15 @@
 
 int main( void ) {
 	// Define a 3x3 symmetric matrix stored in row-major order:
-	double A[] = {
+	double A[ 3*3 ] = {
 		1.0, 0.0, 0.0,
 		2.0, 1.0, 0.0,
 		3.0, 2.0, 1.0
 	};
 
-	// Create strided arrays:
-	const double x[] = { 1.0, 2.0, 3.0 };
-	const double y[] = { 1.0, 2.0, 3.0 };
+	// Define `x` and `y` vectors:
+	const double x[ 3 ] = { 1.0, 2.0, 3.0 };
+	const double y[ 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/dsyr2/include/stdlib/blas/base/dsyr2.h

@@ -34,7 +34,7 @@ extern "C" {
 /**
 * 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 );
+void API_SUFFIX(c_dsyr2)( const CBLAS_LAYOUT layout, 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 and where `α` is a scalar, `x` and `y` are `N` element vectors, and `A` is an `N` by `N` symmetric matrix.

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

@@ -34,7 +34,7 @@ extern "C" {
 /**
 * 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 );
+void API_SUFFIX(cblas_dsyr2)( const CBLAS_LAYOUT layout, 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 );
 
 #ifdef __cplusplus
 }