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

@@ -51,7 +51,7 @@ The function has the following parameters:
 -   **N**: number of elements along each dimension of `A`.
 -   **α**: scalar constant.
 -   **x**: input [`Float64Array`][mdn-float64array].
--   **sx**: index increment for `x`.
+-   **sx**: stride length for `x`.
 -   **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`).
 
@@ -186,7 +186,7 @@ console.log( A );
 #include "stdlib/blas/base/dsyr.h"
 ```
 
-#### c_dsyr( order, uplo, N, alpha, \*X, strideX, \*A, LDA )
+#### c_dsyr( layout, uplo, N, alpha, \*X, sx, \*A, LDA )
 
 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.
 
@@ -201,20 +201,20 @@ c_dsyr( CblasColMajor, CblasUpper, 3, 1.0, x, 1, A, 3 );
 
 The function accepts the following arguments:
 
--   **order**: `[in] CBLAS_LAYOUT` storage layout.
+-   **layout**: `[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*` input array.
--   **strideX**: `[in] CBLAS_INT` index increment for `X`.
+-   **sx**: `[in] CBLAS_INT` stride length for `X`.
 -   **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`).
 
 ```c
-void 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 )
+void c_dsyr( const CBLAS_LAYOUT layout, const CBLAS_UPLO uplo, const CBLAS_INT N, const double alpha, const double *x, const CBLAS_INT strideX, double *A, const CBLAS_INT LDA )
 ```
 
-#### c_dsyr_ndarray( uplo, N, alpha, \*X, strideX, offsetX, \*A, sa1, sa2, oa )
+#### c_dsyr_ndarray( uplo, N, alpha, \*X, sx, ox, \*A, sa1, sa2, oa )
 
 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.
 
@@ -231,17 +231,17 @@ 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*` input array.
--   **strideX**: `[in] CBLAS_INT` index increment for `X`.
--   **offsetX**: `[in] CBLAS_INT` starting index for `X`.
+-   **sx**: `[in] CBLAS_INT` stride length for `X`.
+-   **ox**: `[in] CBLAS_INT` starting index for `X`.
 -   **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_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 sa1, const CBLAS_INT sa2, const CBLAS_INT oa )
+void 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 )
 ```
 
 </section>
@@ -268,9 +268,15 @@ void c_dsyr_ndarray( const CBLAS_UPLO uplo, const CBLAS_INT N, const double alph
 #include <stdio.h>
 
 int main( void ) {
-    // 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 };
+    // Define a 3x3 symmetric matrix stored in row-major layout:
+    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:
+    const 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/dsyr/benchmark/c/benchmark.c

@@ -83,7 +83,7 @@ static double tic( void ) {
 * Runs a benchmark.
 *
 * @param iterations   number of iterations
-* @param N            number of elements along each dimension
+* @param N            array dimension size
 * @return             elapsed time in seconds
 */
 static double benchmark1( int iterations, int N ) {
@@ -114,7 +114,7 @@ static double benchmark1( int iterations, int N ) {
 * Runs a benchmark.
 *
 * @param iterations   number of iterations
-* @param N            number of elements along each dimension
+* @param N            array dimension size
 * @return             elapsed time in seconds
 */
 static double benchmark2( int iterations, int N ) {

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

@@ -46,11 +46,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, 2.0 ] );
     > {{alias}}( 'row-major', 'upper', 2, 1.0, x, 1, A, 2 )
     <Float64Array>[ 2.0, 3.0, 0.0, 3.0 ]
 
+    // Advanced indexing:
+    > var x = 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, A, 2 )
+    <Float64Array>[ 2.0, 3.0, 0.0, 3.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, 2.0 ] );
+    > var x1 = new {{alias:@stdlib/array/float64}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 );
+    > {{alias}}( 'row-major', 'upper', 2, 1.0, x, 1, A, 2 )
+    <Float64Array>[ 2.0, 3.0, 0.0, 3.0 ]
+
 
 {{alias}}.ndarray( uplo, N, α, x, sx, ox, A, sa1, sa2, oa )
     Performs the symmetric rank 1 operation `A = α*x*x^T + A`, using alternative

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

@@ -21,9 +21,15 @@
 #include <stdio.h>
 
 int main( void ) {
-	// 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 };
+	// Define a 3x3 symmetric matrix stored in row-major layout:
+	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:
+	const 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/dsyr/include/stdlib/blas/base/dsyr.h

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

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

@@ -34,7 +34,7 @@ extern "C" {
 /**
 * 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 );
+void API_SUFFIX(cblas_dsyr)( const CBLAS_LAYOUT layout, const CBLAS_UPLO uplo, const CBLAS_INT N, const double alpha, const double *X, const CBLAS_INT strideX, double *A, const CBLAS_INT LDA );
 
 #ifdef __cplusplus
 }

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

@@ -20,10 +20,10 @@
 
 // MODULES //
 
-var max = require( '@stdlib/math/base/special/fast/max' );
+var stride2offset = require( '@stdlib/strided/base/stride2offset' );
 var isLayout = require( '@stdlib/blas/base/assert/is-layout' );
 var isMatrixTriangle = require( '@stdlib/blas/base/assert/is-matrix-triangle' );
-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' );
 
@@ -45,7 +45,7 @@ var base = require( './base.js' );
 * @throws {TypeError} second argument must specify whether to reference the lower or upper triangular matrix
 * @throws {RangeError} third argument must be a nonnegative integer
 * @throws {RangeError} sixth argument must be non-zero
-* @throws {RangeError} eighth argument must be greater than or equal to max(1,N)
+* @throws {RangeError} eighth argument must be a valid stride
 * @returns {Float64Array} `A`
 *
 * @example
@@ -77,6 +77,7 @@ function dsyr( order, uplo, N, alpha, x, strideX, A, LDA ) {
 	if ( LDA < max( 1, N ) ) {
 		throw new RangeError( format( 'invalid argument. Eighth argument must be greater than or equal to max(1,%d). Value: `%d`.', N, LDA ) );
 	}
+	// Check if we can early return...
 	if ( N === 0 || alpha === 0.0 ) {
 		return A;
 	}

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

@@ -20,8 +20,12 @@
 
 // MODULES //
 
+var isLayout = require( '@stdlib/blas/base/assert/is-layout' );
+var isMatrixTriangle = require( '@stdlib/blas/base/assert/is-matrix-triangle' );
+var max = require( '@stdlib/math/base/special/fast/max' );
 var resolveOrder = require( '@stdlib/blas/base/layout-resolve-enum' );
 var resolveUplo = require( '@stdlib/blas/base/matrix-triangle-resolve-enum' );
+var format = require( '@stdlib/string/format' );
 var addon = require( './../src/addon.node' );
 
 
@@ -38,6 +42,11 @@ var addon = require( './../src/addon.node' );
 * @param {integer} strideX - `x` stride length
 * @param {Float64Array} A - input matrix
 * @param {integer} LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
+* @throws {TypeError} first argument must be a valid order
+* @throws {TypeError} second argument must specify whether to reference the lower or upper triangular matrix
+* @throws {RangeError} third argument must be a nonnegative integer
+* @throws {RangeError} sixth argument must be non-zero
+* @throws {RangeError} eighth argument must be a valid stride
 * @returns {Float64Array} `A`
 *
 * @example
@@ -50,6 +59,25 @@ var addon = require( './../src/addon.node' );
 * // A => <Float64Array>[ 2.0, 4.0, 6.0, 0.0, 5.0, 8.0, 0.0, 0.0, 10.0 ]
 */
 function dsyr( order, uplo, N, alpha, x, strideX, A, LDA ) {
+	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 to reference the lower or upper triangular matrix. Value: `%s`.', uplo ) );
+	}
+	if ( N < 0 ) {
+		throw new RangeError( format( 'invalid argument. Third argument must be a nonnegative integer. Value: `%d`.', N ) );
+	}
+	if ( strideX === 0 ) {
+		throw new RangeError( format( 'invalid argument. Sixth argument must be non-zero. Value: `%d`.', strideX ) );
+	}
+	if ( LDA < max( 1, N ) ) {
+		throw new RangeError( format( 'invalid argument. Eighth argument must be greater than or equal to max(1,%d). Value: `%d`.', N, LDA ) );
+	}
+	// Check if we can early return...
+	if ( N === 0 || alpha === 0.0 ) {
+		return A;
+	}
 	addon( resolveOrder( order ), resolveUplo( uplo ), N, alpha, x, strideX, A, LDA ); // eslint-disable-line max-len
 	return A;
 }

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

@@ -64,6 +64,7 @@ function dsyr( uplo, N, alpha, x, strideX, offsetX, A, strideA1, strideA2, offse
 	if ( strideX === 0 ) {
 		throw new RangeError( format( 'invalid argument. Fifth argument must be non-zero. Value: `%d`.', strideX ) );
 	}
+	// Check if we can early return...
 	if ( N === 0 || alpha === 0.0 ) {
 		return A;
 	}

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

@@ -20,7 +20,9 @@
 
 // MODULES //
 
+var isMatrixTriangle = require( '@stdlib/blas/base/assert/is-matrix-triangle' );
 var resolveUplo = require( '@stdlib/blas/base/matrix-triangle-resolve-enum' );
+var format = require( '@stdlib/string/format' );
 var addon = require( './../src/addon.node' );
 
 
@@ -39,6 +41,9 @@ var addon = require( './../src/addon.node' );
 * @param {integer} strideA1 - stride of the first dimension of `A`
 * @param {integer} strideA2 - stride of the second dimension of `A`
 * @param {NonNegativeInteger} offsetA - starting index for `A`
+* @throws {TypeError} first argument must specify whether to reference the lower or upper triangular matrix
+* @throws {RangeError} second argument must be a nonnegative integer
+* @throws {RangeError} fifth argument must be non-zero
 * @returns {Float64Array} `A`
 *
 * @example
@@ -51,6 +56,19 @@ var addon = require( './../src/addon.node' );
 * // A => <Float64Array>[ 2.0, 4.0, 6.0, 0.0, 5.0, 8.0, 0.0, 0.0, 10.0 ]
 */
 function dsyr( uplo, N, alpha, x, strideX, offsetX, A, strideA1, strideA2, offsetA ) { // eslint-disable-line max-len
+	if ( !isMatrixTriangle( uplo ) ) {
+		throw new TypeError( format( 'invalid argument. First argument must specify whether to reference the lower or upper triangular matrix. Value: `%s`.', uplo ) );
+	}
+	if ( N < 0 ) {
+		throw new RangeError( format( 'invalid argument. Second argument must be a nonnegative integer. Value: `%d`.', N ) );
+	}
+	if ( strideX === 0 ) {
+		throw new RangeError( format( 'invalid argument. Fifth argument must be non-zero. Value: `%d`.', strideX ) );
+	}
+	// Check if we can early return...
+	if ( N === 0 || alpha === 0.0 ) {
+		return A;
+	}
 	addon.ndarray( resolveUplo( uplo ), N, alpha, x, strideX, offsetX, A, strideA1, strideA2, offsetA ); // eslint-disable-line max-len
 	return A;
 }