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: passed
  - 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: passed
  - task: lint_c_examples
    status: passed
  - task: lint_c_benchmarks
    status: passed
  - 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: kgryte

lib/node_modules/@stdlib/blas/base/zaxpy/README.md

@@ -55,7 +55,7 @@ The function has the following parameters:
 -   **y**: second input [`Complex128Array`][@stdlib/array/complex128].
 -   **strideY**: stride length for `y`.
 
-The `N` and stride parameters determine how values from `x` are scaled by `alpha` and added to `y`. For example, to scale every other value in `x` by `alpha` and add the result to every other value of `y`,
+The `N` and stride parameters determine how elements from `x` are scaled by `alpha` and added to `y`. For example, to scale every other element in `x` by `alpha` and add the result to every other element of `y`,
 
 ```javascript
 var Complex128Array = require( '@stdlib/array/complex128' );
@@ -88,7 +88,7 @@ var alpha = new Complex128( 2.0, 2.0 );
 var x1 = new Complex128Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
 var y1 = new Complex128Array( y0.buffer, y0.BYTES_PER_ELEMENT*2 ); // start at 3rd element
 
-// Scales values of `x0` by `alpha` starting from second index and add the result to `y0` starting from third index...
+// Perform operation:
 zaxpy( 2, alpha, x1, 1, y1, 1 );
 // y0 => <Complex128Array>[ 1.0, 1.0, 1.0, 1.0, -1.0, 15.0, -1.0, 23.0 ]
 ```
@@ -114,7 +114,7 @@ The function has the following additional parameters:
 -   **offsetX**: starting index for `x`.
 -   **offsetY**: starting index for `y`.
 
-While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameters support indexing semantics based on starting indices. For example, to scale values in the first input strided array starting from the second element and add the result to the second input array starting from the second element,
+While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameters support indexing semantics based on starting indices. For example, to scale elements in the first input strided array starting from the second element and add the result to the second input array starting from the second element,
 
 ```javascript
 var Complex128Array = require( '@stdlib/array/complex128' );
@@ -136,8 +136,7 @@ zaxpy.ndarray( 3, alpha, x, 1, 1, y, 1, 1 );
 
 ## Notes
 
--   If `N <= 0`, both functions return `y` unchanged.
--   If `alpha === 0`, both functions return `y` unchanged.
+-   If `N <= 0` or `alpha == 0`, both functions return `y` unchanged.
 -   `zaxpy()` corresponds to the [BLAS][blas] level 1 function [`zaxpy`][zaxpy].
 
 </section>
@@ -169,19 +168,19 @@ var yc1 = zcopy( y.length, y, 1, zeros( y.length, 'complex128' ), 1 );
 
 var alpha = new Complex128( 2.0, 2.0 );
 
-// Scale values from `x` by `alpha` and add the result to `y`:
-zaxpy( x.length, alpha, x, 1, y, 1 );
+// Perform operation:
+zaxpy( x.length, alpha, x, 1, yc1, 1 );
 
 // Print the results:
-logEach( '(%s)*(%s) + (%s) = %s', alpha, x, yc1, y );
+logEach( '(%s)*(%s) + (%s) = %s', alpha, x, y, yc1 );
 
-var yc2 = zcopy( yc1.length, yc1, 1, zeros( yc1.length, 'complex128' ), 1 );
+var yc2 = zcopy( y.length, y, 1, zeros( y.length, 'complex128' ), 1 );
 
-// Scale values from `x` by `alpha` and add the result to `y` using alternative indexing semantics:
-zaxpy.ndarray( x.length, alpha, x, 1, 0, yc1, 1, 0 );
+// Perform operation using alternative indexing semantics:
+zaxpy.ndarray( x.length, alpha, x, 1, 0, yc2, 1, 0 );
 
 // Print the results:
-logEach( '(%s)*(%s) + (%s) = %s', alpha, x, yc2, yc1 );
+logEach( '(%s)*(%s) + (%s) = %s', alpha, x, y, yc2 );
 ```
 
 </section>
@@ -219,10 +218,10 @@ logEach( '(%s)*(%s) + (%s) = %s', alpha, x, yc2, yc1 );
 Scales values from `X` by `alpha` and adds the result to `Y`.
 
 ```c
-#include "stdlib/complex/float32/ctor.h"
+#include "stdlib/complex/float64/ctor.h"
 
-const float x[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 };
-float y[] = { -1.0, -2.0, -3.0, -4.0, -5.0, -6.0, -7.0, -8.0 };
+const double x[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 };
+double y[] = { -1.0, -2.0, -3.0, -4.0, -5.0, -6.0, -7.0, -8.0 };
 const stdlib_complex128_t alpha = stdlib_complex128( 2.0, 2.0 );
 
 c_zaxpy( 4, alpha, (void *)x, 1, (void *)y, 1 );
@@ -238,18 +237,18 @@ The function accepts the following arguments:
 -   **strideY**: `[in] CBLAS_INT` stride length for `Y`.
 
 ```c
-void c_zaxpy( const CBLAS_INT N, const stdlib_complex128_t alpha, const void *x, const CBLAS_INT strideX, void *y, const CBLAS_INT strideY );
+void c_zaxpy( const CBLAS_INT N, const stdlib_complex128_t alpha, const void *X, const CBLAS_INT strideX, void *Y, const CBLAS_INT strideY );
 ```
 
 #### c_zaxpy_ndarray( N, alpha, \*X, strideX, offsetX, \*Y, strideY, offsetY )
 
 Scales values from `X` by `alpha` and adds the result to `Y` using alternative indexing semantics.
 
 ```c
-#include "stdlib/complex/float32/ctor.h"
+#include "stdlib/complex/float64/ctor.h"
 
-const float x[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 };
-float y[] = { -1.0, -2.0, -3.0, -4.0, -5.0, -6.0, -7.0, -8.0 };
+const double x[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 };
+double y[] = { -1.0, -2.0, -3.0, -4.0, -5.0, -6.0, -7.0, -8.0 };
 const stdlib_complex128_t alpha = stdlib_complex128( 2.0, 2.0 );
 
 c_zaxpy_ndarray( 4, alpha, (void *)x, 1, 0, (void *)y, 1, 0 );
@@ -267,7 +266,7 @@ The function accepts the following arguments:
 -   **offsetY**: `[in] CBLAS_INT` starting index for `Y`.
 
 ```c
-void c_zaxpy_ndarray( const CBLAS_INT N, const stdlib_complex128_t alpha, const void *x, const CBLAS_INT strideX, const CBLAS_INT offsetX, void *y, const CBLAS_INT strideY, const CBLAS_INT offsetY );
+void c_zaxpy_ndarray( const CBLAS_INT N, const stdlib_complex128_t alpha, const void *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, void *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY );
 ```
 
 </section>
@@ -290,7 +289,7 @@ void c_zaxpy_ndarray( const CBLAS_INT N, const stdlib_complex128_t alpha, const
 
 ```c
 #include "stdlib/blas/base/zaxpy.h"
-#include "stdlib/complex/float32/ctor.h"
+#include "stdlib/complex/float64/ctor.h"
 #include <stdio.h>
 
 int main( void ) {
@@ -308,20 +307,20 @@ int main( void ) {
     const int strideX = 1;
     const int strideY = 1;
 
-    // Scale values from `x` by `alpha` and add the result to `y`:
+    // Perform operation:
     c_zaxpy( N, alpha, (void *)x, strideX, (void *)y, strideY );
 
     // Print the result:
     for ( int i = 0; i < N; i++ ) {
-        printf( "zaxpy[ %i ] = %lf + %lfj\n", i, y[ i * 2 ], y[ ( i * 2 ) + 1 ] );
+        printf( "zaxpy[ %i ] = %lf + %lfj\n", i, y[ i*2 ], y[ (i*2)+1 ] );
     }
 
-    // Scale values from `x` by `alpha` and add the result to `y` using alternative indexing semantics:
+    // Perform operation using alternative indexing semantics:
     c_zaxpy_ndarray( N, alpha, (void *)x, strideX, 0, (void *)y, strideY, 0 );
 
     // Print the result:
     for ( int i = 0; i < N; i++ ) {
-        printf( "zaxpy[ %i ] = %lf + %lfj\n", i, y[ i * 2 ], y[ ( i * 2 ) + 1 ] );
+        printf( "zaxpy[ %i ] = %lf + %lfj\n", i, y[ i*2 ], y[ (i*2)+1 ] );
     }
 }
 ```

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

@@ -108,7 +108,7 @@ function main() {
 	for ( i = min; i <= max; i++ ) {
 		N = pow( 10, i );
 		f = createBenchmark( N );
-		bench( pkg+':size='+N, f );
+		bench( pkg+':len='+N, f );
 	}
 }
 

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

@@ -113,7 +113,7 @@ function main() {
 	for ( i = min; i <= max; i++ ) {
 		N = pow( 10, i );
 		f = createBenchmark( N );
-		bench( pkg+'::native:size='+N, opts, f );
+		bench( pkg+'::native:len='+N, opts, f );
 	}
 }
 

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

@@ -113,7 +113,7 @@ function main() {
 	for ( i = min; i <= max; i++ ) {
 		N = pow( 10, i );
 		f = createBenchmark( N );
-		bench( pkg+'::native:ndarray:size='+N, opts, f );
+		bench( pkg+'::native:ndarray:len='+N, opts, f );
 	}
 }
 

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

@@ -108,7 +108,7 @@ function main() {
 	for ( i = min; i <= max; i++ ) {
 		N = pow( 10, i );
 		f = createBenchmark( N );
-		bench( pkg+':ndarray:size='+N, f );
+		bench( pkg+':ndarray:len='+N, f );
 	}
 }
 

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

@@ -183,7 +183,7 @@ int main( void ) {
 		iter = ITERATIONS / pow( 10, i-1 );
 		for ( j = 0; j < REPEATS; j++ ) {
 			count += 1;
-			printf( "# c::%s:size=%d\n", NAME, N*N );
+			printf( "# c::%s:len=%d\n", NAME, N*N );
 			elapsed = benchmark1( iter, N );
 			print_results( iter, elapsed );
 			printf( "ok %d benchmark finished\n", count );
@@ -194,7 +194,7 @@ int main( void ) {
 		iter = ITERATIONS / pow( 10, i-1 );
 		for ( j = 0; j < REPEATS; j++ ) {
 			count += 1;
-			printf( "# c::%s:ndarray:size=%d\n", NAME, N*N );
+			printf( "# c::%s:ndarray:len=%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/zaxpy/examples/c/example.c

@@ -36,19 +36,19 @@ int main( void ) {
 	const int strideX = 1;
 	const int strideY = 1;
 
-	// Scale values from `x` by `alpha` and add the result to `y`:
+	// Perform operation:
 	c_zaxpy( N, alpha, (void *)x, strideX, (void *)y, strideY );
 
 	// Print the result:
 	for ( int i = 0; i < N; i++ ) {
-		printf( "zaxpy[ %i ] = %lf + %lfj\n", i, y[ i * 2 ], y[ ( i * 2 ) + 1 ] );
+		printf( "zaxpy[ %i ] = %lf + %lfj\n", i, y[ i*2 ], y[ (i*2)+1 ] );
 	}
 
-	// Scale values from `x` by `alpha` and add the result to `y` using alternative indexing semantics:
+	// Perform operation using alternative indexing semantics:
 	c_zaxpy_ndarray( N, alpha, (void *)x, strideX, 0, (void *)y, strideY, 0 );
 
 	// Print the result:
 	for ( int i = 0; i < N; i++ ) {
-		printf( "zaxpy[ %i ] = %lf + %lfj\n", i, y[ i * 2 ], y[ ( i * 2 ) + 1 ] );
+		printf( "zaxpy[ %i ] = %lf + %lfj\n", i, y[ i*2 ], y[ (i*2)+1 ] );
 	}
 }

lib/node_modules/@stdlib/blas/base/zaxpy/examples/index.js

@@ -36,16 +36,16 @@ var yc1 = zcopy( y.length, y, 1, zeros( y.length, 'complex128' ), 1 );
 
 var alpha = new Complex128( 2.0, 2.0 );
 
-// Scale values from `x` by `alpha` and add the result to `y`:
-zaxpy( x.length, alpha, x, 1, y, 1 );
+// Perform operation:
+zaxpy( x.length, alpha, x, 1, yc1, 1 );
 
 // Print the results:
-logEach( '(%s)*(%s) + (%s) = %s', alpha, x, yc1, y );
+logEach( '(%s)*(%s) + (%s) = %s', alpha, x, y, yc1 );
 
-var yc2 = zcopy( yc1.length, yc1, 1, zeros( yc1.length, 'complex128' ), 1 );
+var yc2 = zcopy( y.length, y, 1, zeros( y.length, 'complex128' ), 1 );
 
-// Scale values from `x` by `alpha` and add the result to `y` using alternative indexing semantics:
-zaxpy.ndarray( x.length, alpha, x, 1, 0, yc1, 1, 0 );
+// Perform operation using alternative indexing semantics:
+zaxpy.ndarray( x.length, alpha, x, 1, 0, yc2, 1, 0 );
 
 // Print the results:
-logEach( '(%s)*(%s) + (%s) = %s', alpha, x, yc2, yc1 );
+logEach( '(%s)*(%s) + (%s) = %s', alpha, x, y, yc2 );

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

@@ -19,8 +19,8 @@
 /**
 * Header file containing function declarations for the C interface to the BLAS Level 1 routine `zaxpy`.
 */
-#ifndef ZAXPY_H
-#define ZAXPY_H
+#ifndef STDLIB_BLAS_BASE_ZAXPY_H
+#define STDLIB_BLAS_BASE_ZAXPY_H
 
 #include "stdlib/blas/base/shared.h"
 #include "stdlib/complex/float64/ctor.h"
@@ -46,4 +46,4 @@ void API_SUFFIX(c_zaxpy_ndarray)( const CBLAS_INT N, const stdlib_complex128_t a
 }
 #endif
 
-#endif // !ZAXPY_H
+#endif // !STDLIB_BLAS_BASE_ZAXPY_H

lib/node_modules/@stdlib/blas/base/zaxpy/include/stdlib/blas/base/zaxpy_cblas.h

@@ -19,8 +19,8 @@
 /**
 * Header file containing function declarations for the C interface to the CBLAS Level 1 routine `cblas_zaxpy`.
 */
-#ifndef ZAXPY_CBLAS_H
-#define ZAXPY_CBLAS_H
+#ifndef STDLIB_BLAS_BASE_ZAXPY_CBLAS_H
+#define STDLIB_BLAS_BASE_ZAXPY_CBLAS_H
 
 #include "stdlib/blas/base/shared.h"
 #include "stdlib/complex/float64/ctor.h"
@@ -33,12 +33,12 @@ extern "C" {
 #endif
 
 /**
-* Scale a double-precision complex floating-point vector by a double-precision complex floating-point constant and add the result to a double-precision complex floating-point vector.
+* Scales a double-precision complex floating-point vector by a double-precision complex floating-point constant and adds the result to a double-precision complex floating-point vector.
 */
 void API_SUFFIX(cblas_zaxpy)( const CBLAS_INT N, const stdlib_complex128_t alpha, void *X, const CBLAS_INT strideX, void *Y, const CBLAS_INT strideY );
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif // !ZAXPY_CBLAS_H
+#endif // !STDLIB_BLAS_BASE_ZAXPY_CBLAS_H