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

@@ -188,7 +188,7 @@ console.log( A );
 
 #### c_dsyr( order, uplo, N, alpha, \*X, strideX, \*A, LDA )
 
-Performs the symmetric rank 1 operation `A = α*x*x^T + A`.
+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.
 
 ```c
 #include "stdlib/blas/base/shared.h"
@@ -216,7 +216,7 @@ void c_dsyr( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const CBLAS_INT N,
 
 #### c_dsyr_ndarray( uplo, N, alpha, \*X, strideX, offsetX, \*A, sa1, sa2, oa )
 
-Performs the symmetric rank 1 operation `A = α*x*x^T + A` 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.
 
 ```c
 #include "stdlib/blas/base/shared.h"

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

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

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

@@ -32,12 +32,12 @@ extern "C" {
 #endif
 
 /**
-* Performs the symmetric rank 1 operation `A = α*x*x^T + A`.
+* 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.
 */
 void API_SUFFIX(c_dsyr)( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const CBLAS_INT N, const double alpha, const double *X, const CBLAS_INT strideX, double *A, const CBLAS_INT LDA );
 
 /**
-* Performs the symmetric rank 1 operation `A = α*x*x^T + A` 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.
 */
 void API_SUFFIX(c_dsyr_ndarray)( const CBLAS_UPLO uplo, const CBLAS_INT N, const double alpha, const double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, double *A, const CBLAS_INT strideA1, const CBLAS_INT strideA2, const CBLAS_INT offsetA );
 

lib/node_modules/@stdlib/blas/base/dsyr/include/stdlib/blas/base/dsyr_cblas.h

@@ -32,7 +32,7 @@ extern "C" {
 #endif
 
 /**
-* Performs the symmetric rank 1 operation `A = α*x*x^T + A`.
+* 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.
 */
 void API_SUFFIX(cblas_dsyr)( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const CBLAS_INT N, const double alpha, const double *X, const CBLAS_INT strideX, double *A, const CBLAS_INT LDA );
 

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

@@ -28,10 +28,10 @@ var addon = require( './../src/addon.node' );
 // MAIN //
 
 /**
-* Performs the symmetric rank 1 operation `A = α*x*x^T + A`.
+* 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.
 *
 * @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 - input vector

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

@@ -27,9 +27,9 @@ var addon = require( './../src/addon.node' );
 // MAIN //
 
 /**
-* Performs the symmetric rank 1 operation `A = α*x*x^T + A`.
+* 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.
 *
-* @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 - input vector

lib/node_modules/@stdlib/blas/base/dsyr/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, 8 );
 
 	STDLIB_NAPI_ARGV_INT32( env, order, argv, 0 );
@@ -46,8 +49,16 @@ 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 === 'row-major'
+		sa1 = LDA;
+		sa2 = 1;
+	}
+
 	STDLIB_NAPI_ARGV_STRIDED_FLOAT64ARRAY( env, X, N, strideX, argv, 4 );
-	STDLIB_NAPI_ARGV_STRIDED_FLOAT64ARRAY( env, A, ((N-1)*LDA) + N, 1, argv, 6 );
+	STDLIB_NAPI_ARGV_STRIDED_FLOAT64ARRAY2D( env, A, N, N, sa1, sa2, argv, 6 );
 
 	API_SUFFIX(c_dsyr)( order, uplo, N, alpha, X, strideX, A, LDA );
 

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

@@ -21,10 +21,10 @@
 #include "stdlib/strided/base/stride2offset.h"
 
 /**
-* Performs the symmetric rank 1 operation `A = α*x*x^T + A`.
+* 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.
 *
 * @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/dsyr/src/dsyr_cblas.c

@@ -23,10 +23,10 @@
 #include "stdlib/ndarray/base/min_view_buffer_index.h"
 
 /**
-* Performs the symmetric rank 1 operation `A = α*x*x^T + A`.
+* 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.
 *
 * @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
@@ -35,35 +35,5 @@
 * @param LDA      stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
 */
 void API_SUFFIX(c_dsyr)( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const CBLAS_INT N, const double alpha, const double *X, const CBLAS_INT strideX, double *A, const CBLAS_INT LDA ) {
-	CBLAS_INT sx = strideX;
-	if ( sx < 0 ) {
-		sx = -sx;
-	}
-	API_SUFFIX(cblas_dsyr)( order, uplo, N, alpha, X, sx, A, LDA );
-}
-
-/**
-* Performs the symmetric rank 1 operation `A = α*x*x^T + A` using alternative indexing semantics.
-*
-* @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 A         input matrix
-* @param strideA1  stride of the first dimension of `A`
-* @param strideA2  stride of the second dimension of `A`
-* @param offsetA   starting index for `A`
-*/
-void API_SUFFIX(c_dsyr_ndarray)( const CBLAS_UPLO uplo, const CBLAS_INT N, const float alpha, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, float *A, const CBLAS_INT strideA1, const CBLAS_INT strideA2, const CBLAS_INT offsetA ) {
-	CBLAS_INT sx = strideX;
-	X += stdlib_strided_min_view_buffer_index( N, strideX, offsetX ); // adjust array pointer
-	const int64_t shape[] = { N, N };
-	const int64_t strides[] = { strideA1, strideA2 };
-	A += stdlib_ndarray_min_view_buffer_index( 2, shape, strides, offsetA ); // adjust array pointer
-	if ( sx < 0 ) {
-		sx = -sx;
-	}
-	API_SUFFIX(cblas_dsyr)( order, uplo, N, alpha, X, sx, A, LDA );
+	API_SUFFIX(cblas_dsyr)( order, uplo, N, alpha, X, strideX, A, LDA );
 }

lib/node_modules/@stdlib/blas/base/dsyr/src/dsyr_ndarray.c

@@ -21,9 +21,9 @@
 #include "stdlib/ndarray/base/assert/is_row_major.h"
 
 /**
-* Performs the symmetric rank 1 operation `A = α*x*x^T + A` 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.
 *
-* @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