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

@@ -215,7 +215,7 @@ void c_dspr( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const CBLAS_INT N,
 
 #### c_dspr_ndarray( order, uplo, N, alpha, \*X, strideX, \*AP, strideAP, offsetAP )
 
-Performs the symmetric rank 1 operation `A = α*x*x^T + A` where `α` is a scalar, `x` is an `N` element vector, and `A` is an `N` by `N` symmetric matrix supplied in packed form using alternative indexing semantics.
+Performs the symmetric rank 1 operation `A = α*x*x^T + A`, using alternative indexing semantics and where `α` is a scalar, `x` is an `N` element vector, and `A` is an `N` by `N` symmetric matrix supplied in packed form.
 
 ```c
 #include "stdlib/blas/base/shared.h"

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

@@ -93,18 +93,18 @@ static double benchmark1( int iterations, int len ) {
 	double t;
 	int i;
 
-	stdlib_strided_dfill( len, 0.5, x, 1 );
+	stdlib_strided_dfill( len, 1.0, x, 1 );
 	stdlib_strided_dfill( len*(len+1)/2, 1.0, AP, 1 );
 	t = tic();
 	for ( i = 0; i < iterations; i++ ) {
 		c_dspr( CblasRowMajor, CblasUpper, len, 1.0, x, 1, AP );
-		if ( AP[ 0 ] != AP[ 0 ] ) {
+		if ( AP[ i%len ] != AP[ i%len ] ) {
 			printf( "should not return NaN\n" );
 			break;
 		}
 	}
 	elapsed = tic() - t;
-	if ( AP[ 0 ] != AP[ 0 ] ) {
+	if ( AP[ i%len ] != AP[ i%len ] ) {
 		printf( "should not return NaN\n" );
 	}
 	return elapsed;
@@ -124,18 +124,18 @@ static double benchmark2( int iterations, int len ) {
 	double t;
 	int i;
 
-	stdlib_strided_dfill( len, 0.5, x, 1 );
+	stdlib_strided_dfill( len, 1.0, x, 1 );
 	stdlib_strided_dfill( len*(len+1)/2, 1.0, AP, 1 );
 	t = tic();
 	for ( i = 0; i < iterations; i++ ) {
 		c_dspr_ndarray( CblasRowMajor, CblasUpper, len, 1.0, x, 1, 0, AP, 1, 0 );
-		if ( AP[ 0 ] != AP[ 0 ] ) {
+		if ( AP[ i%len ] != AP[ i%len ] ) {
 			printf( "should not return NaN\n" );
 			break;
 		}
 	}
 	elapsed = tic() - t;
-	if ( AP[ 0 ] != AP[ 0 ] ) {
+	if ( AP[ i%len ] != AP[ i%len ] ) {
 		printf( "should not return NaN\n" );
 	}
 	return elapsed;

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

@@ -37,7 +37,7 @@ extern "C" {
 void API_SUFFIX(c_dspr)( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const CBLAS_INT N, const double alpha, const double *X, const CBLAS_INT strideX, double *AP );
 
 /**
-* Performs the symmetric rank 1 operation `A = α*x*x^T + A` where `α` is a scalar, `x` is an `N` element vector, and `A` is an `N` by `N` symmetric matrix supplied in packed form using alternative indexing semantics.
+* Performs the symmetric rank 1 operation `A = α*x*x^T + A`, using alternative indexing semantics and where `α` is a scalar, `x` is an `N` element vector, and `A` is an `N` by `N` symmetric matrix supplied in packed form.
 */
 void API_SUFFIX(c_dspr_ndarray)( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const CBLAS_INT N, const double alpha, const double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, double *AP, const CBLAS_INT strideAP, const CBLAS_INT offsetAP );
 

lib/node_modules/@stdlib/blas/base/dspr/src/dspr_cblas.c

@@ -24,48 +24,22 @@
 * Performs the symmetric rank 1 operation `A = α*x*x^T + A` where `α` is a scalar, `x` is an `N` element vector, and `A` is an `N` by `N` symmetric matrix supplied in packed form.
 *
 * @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        input vector
 * @param strideX  `x` stride length
 * @param AP       packed form of a symmetric matrix `A`
 */
 void API_SUFFIX(c_dspr)( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const CBLAS_INT N, const double alpha, const double *X, const CBLAS_INT strideX, double *AP ) {
-	CBLAS_INT sx = strideX;
-	if ( sx < 0 ) {
-		sx = -sx;
-	}
-	API_SUFFIX(cblas_dspr)( order, uplo, N, alpha, X, sx, AP );
-}
-
-/**
-* Performs the symmetric rank 1 operation `A = α*x*x^T + A` where `α` is a scalar, `x` is an `N` element vector, and `A` is an `N` by `N` symmetric matrix supplied in packed form using alternative indexing semantics.
-*
-* @param order     storage layout
-* @param uplo      specifies whether the upper or lower triangular part of the symmetric matrix `A` should be referenced
-* @param N         number of elements along each dimension of `A`
-* @param alpha     scalar
-* @param X         input vector
-* @param strideX   `x` stride length
-* @param offsetX   starting index for `x`
-* @param AP        packed form of a symmetric matrix `A`
-* @param strideAP  `AP` stride length
-* @param offsetAP  starting index for `AP`
-*/
-void API_SUFFIX(c_dspr)( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const CBLAS_INT N, const double alpha, const double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, double *AP, const CBLAS_INT strideAP, const CBLAS_INT offsetAP ) {
-	CBLAS_INT sx = strideX;
-	if ( sx < 0 ) {
-		sx = -sx;
-	}
 	API_SUFFIX(cblas_dspr)( order, uplo, N, alpha, X, sx, AP );
 }
 
 /**
-* Performs the symmetric rank 1 operation `A = α*x*x^T + A` where `α` is a scalar, `x` is an `N` element vector, and `A` is an `N` by `N` symmetric matrix supplied in packed form using alternative indexing semantics.
+* Performs the symmetric rank 1 operation `A = α*x*x^T + A`, using alternative indexing semantics and where `α` is a scalar, `x` is an `N` element vector, and `A` is an `N` by `N` symmetric matrix supplied in packed form.
 *
 * @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         input vector

lib/node_modules/@stdlib/blas/base/dspr/src/dspr_ndarray.c

@@ -20,9 +20,9 @@
 #include "stdlib/blas/base/shared.h"
 
 /**
-* Performs the symmetric rank 1 operation `A = α*x*x^T + A` where `α` is a scalar, `x` is an `N` element vector, and `A` is an `N` by `N` symmetric matrix supplied in packed form using alternative indexing semantics.
+* Performs the symmetric rank 1 operation `A = α*x*x^T + A`, using alternative indexing semantics and where `α` is a scalar, `x` is an `N` element vector, and `A` is an `N` by `N` symmetric matrix supplied in packed form.
 *
-* @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
@@ -42,7 +42,7 @@ void API_SUFFIX(c_dspr_ndarray)( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo
 	CBLAS_INT ox;
 	double tmp;
 
-	if ( N == 0 || alpha == 0.0f ) {
+	if ( N == 0 || alpha == 0.0 ) {
 		return;
 	}
 	ox = offsetX;
@@ -53,7 +53,7 @@ void API_SUFFIX(c_dspr_ndarray)( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo
 	) {
 		ix1 = ox;
 		for ( i1 = 0; i1 < N; i1++ ) {
-			if ( X[ ix1 ] != 0.0f ) {
+			if ( X[ ix1 ] != 0.0 ) {
 				tmp = alpha * X[ ix1 ];
 				ix0 = ox;
 				iap = kk;
@@ -71,7 +71,7 @@ void API_SUFFIX(c_dspr_ndarray)( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo
 	// ( order == CblasColMajor && uplo == CblasLower ) || ( order == CblasRowMajor && uplo == CblasUpper )
 	ix1 = ox;
 	for ( i1 = 0; i1 < N; i1++ ) {
-		if ( X[ ix1 ] != 0.0f ) {
+		if ( X[ ix1 ] != 0.0 ) {
 			tmp = alpha * X[ ix1 ];
 			ix0 = ix1;
 			iap = kk;