chore: update variable names

---
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: 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: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: passed
  - task: lint_license_headers
    status: passed
---

Author: ShabiShett07

lib/node_modules/@stdlib/blas/base/wasm/zscal/README.md

@@ -30,47 +30,47 @@ limitations under the License.
 var zscal = require( '@stdlib/blas/base/wasm/zscal' );
 ```
 
-#### zscal.main( N, za, zx, strideX )
+#### zscal.main( N, alpha, x, strideX )
 
-Scales values from `zx` by `za`.
+Scales values from `x` by `alpha`.
 
 ```javascript
 var Complex128Array = require( '@stdlib/array/complex128' );
 var Complex128 = require( '@stdlib/complex/float64/ctor' );
 
 // Define a strided array:
-var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
 
 // Define a scalar constant:
-var za = new Complex128( 2.0, 2.0 );
+var alpha = new Complex128( 2.0, 2.0 );
 
 // Perform operation:
-zscal.main( zx.length, za, zx, 1 );
-// zx => <Complex128Array>[ -2.0, 6.0, -2.0, 14.0, -2.0, 22.0 ]
+zscal.main( x.length, alpha, x, 1 );
+// x => <Complex128Array>[ -2.0, 6.0, -2.0, 14.0, -2.0, 22.0 ]
 ```
 
 The function has the following parameters:
 
 -   **N**: number of indexed elements.
--   **za**: scalar [`Complex128`][@stdlib/complex/float64/ctor] constant.
--   **zx**: input [`Complex128Array`][@stdlib/array/complex128].
--   **strideX**: index increment for `zx`.
+-   **alpha**: scalar [`Complex128`][@stdlib/complex/float64/ctor] constant.
+-   **x**: input [`Complex128Array`][@stdlib/array/complex128].
+-   **strideX**: index increment for `x`.
 
-The `N` and stride parameters determine which elements in the input strided array are accessed at runtime. For example, to scale every other value in `zx` by `za`,
+The `N` and stride parameters determine which elements in the input strided array are accessed at runtime. For example, to scale every other value in `x` by `alpha`,
 
 ```javascript
 var Complex128Array = require( '@stdlib/array/complex128' );
 var Complex128 = require( '@stdlib/complex/float64/ctor' );
 
 // Define a strided array:
-var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
 
 // Define a scalar constant:
-var za = new Complex128( 2.0, 2.0 );
+var alpha = new Complex128( 2.0, 2.0 );
 
 // Perform operation:
-zscal.main( 2, za, zx, 2 );
-// zx => <Complex128Array>[ -2.0, 6.0, 3.0, 4.0, -2.0, 22.0 ]
+zscal.main( 2, alpha, x, 2 );
+// x => <Complex128Array>[ -2.0, 6.0, 3.0, 4.0, -2.0, 22.0 ]
 ```
 
 Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
@@ -82,53 +82,53 @@ var Complex128Array = require( '@stdlib/array/complex128' );
 var Complex128 = require( '@stdlib/complex/float64/ctor' );
 
 // Initial array:
-var zx0 = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+var x0 = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
 
 // Define a scalar constant:
-var za = new Complex128( 2.0, 2.0 );
+var alpha = new Complex128( 2.0, 2.0 );
 
 // Create an offset view:
-var zx1 = new Complex128Array( zx0.buffer, zx0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+var x1 = new Complex128Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
 
-// Scales every other value from `zx1` by `za`...
-zscal.main( 3, za, zx1, 1 );
-// zx0 => <Complex128Array>[ 1.0, 2.0, -2.0, 14.0, -2.0, 22.0, -2.0, 30.0 ]
+// Scales every other value from `x1` by `alpha`...
+zscal.main( 3, alpha, x1, 1 );
+// x0 => <Complex128Array>[ 1.0, 2.0, -2.0, 14.0, -2.0, 22.0, -2.0, 30.0 ]
 ```
 
-#### zscal.ndarray( N, za, zx, strideX, offsetX )
+#### zscal.ndarray( N, alpha, x, strideX, offsetX )
 
-Scales values from `zx` by `za` using alternative indexing semantics.
+Scales values from `x` by `alpha` using alternative indexing semantics.
 
 ```javascript
 var Complex128Array = require( '@stdlib/array/complex128' );
 var Complex128 = require( '@stdlib/complex/float64/ctor' );
 
 // Define a strided array:
-var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
 
 // Define a scalar constant:
-var za = new Complex128( 2.0, 2.0 );
+var alpha = new Complex128( 2.0, 2.0 );
 
 // Perform operation:
-zscal.ndarray( zx.length, za, zx, 1, 0 );
-// zx => <Complex128Array>[ -2.0, 6.0, -2.0, 14.0, -2.0, 22.0 ]
+zscal.ndarray( x.length, alpha, x, 1, 0 );
+// x => <Complex128Array>[ -2.0, 6.0, -2.0, 14.0, -2.0, 22.0 ]
 ```
 
 The function has the following additional parameters:
 
--   **offsetX**: starting index for `zx`.
+-   **offsetX**: starting index for `x`.
 
 While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameter supports indexing semantics based on a starting index. For example, to scale every other value in the input strided array starting from the second element,
 
 ```javascript
 var Complex128Array = require( '@stdlib/array/complex128' );
 var Complex128 = require( '@stdlib/complex/float64/ctor' );
 
-var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
-var za = new Complex128( 2.0, 2.0 );
+var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+var alpha = new Complex128( 2.0, 2.0 );
 
-zscal.ndarray( 2, za, zx, 2, 1 );
-// zx => <Complex128Array>[ 1.0, 2.0, -2.0, 14.0, 5.0, 6.0, -2.0, 30.0 ]
+zscal.ndarray( 2, alpha, x, 2, 1 );
+// x => <Complex128Array>[ 1.0, 2.0, -2.0, 14.0, 5.0, 6.0, -2.0, 30.0 ]
 ```
 
 * * *
@@ -160,7 +160,7 @@ mod.initializeSync();
 
 #### zscal.Module.prototype.main( N, zap, zxp, sx )
 
-Scales values from `zx` by `za` .
+Scales values from `x` by `alpha` .
 
 <!-- eslint-disable node/no-sync -->
 
@@ -224,11 +224,11 @@ The function has the following parameters:
 -   **N**: number of indexed elements.
 -   **zap**: pointer (i.e., byte offset) to a scalar [`Complex128`][@stdlib/complex/float64/ctor] constant.
 -   **zxp**: input [`Complex128Array`][@stdlib/array/complex128] pointer (i.e., byte offset).
--   **sx**: index increment for `zx`.
+-   **sx**: index increment for `x`.
 
 #### zscal.Module.prototype.ndarray( N, zap, zxp, sx, ox )
 
-Scales values from `zx` by `za`  using alternative indexing semantics.
+Scales values from `x` by `alpha`  using alternative indexing semantics.
 
 <!-- eslint-disable node/no-sync -->
 
@@ -301,7 +301,7 @@ The function has the following additional parameters:
 
 ## Notes
 
--   If `N <= 0`, `zx` is left unchanged.
+-   If `N <= 0`, `x` is left unchanged.
 -   This package implements routines using WebAssembly. When provided arrays which are not allocated on a `zscal` module memory instance, data must be explicitly copied to module memory prior to computation. Data movement may entail a performance cost, and, thus, if you are using arrays external to module memory, you should prefer using [`@stdlib/blas/base/zscal`][@stdlib/blas/base/zscal]. However, if working with arrays which are allocated and explicitly managed on module memory, you can achieve better performance when compared to the pure JavaScript implementations found in [`@stdlib/blas/base/zscal`][@stdlib/blas/base/zscal]. Beware that such performance gains may come at the cost of additional complexity when having to perform manual memory management. Choosing between implementations depends heavily on the particular needs and constraints of your application, with no one choice universally better than the other.
 -   `zscal()` corresponds to the [BLAS][blas] level 1 function [`zscal`][zscal].
 
@@ -333,10 +333,10 @@ var xbuf = oneTo( N*2, 'float64' );
 var x = new Complex128Array( xbuf.buffer );
 
 // Create a complex number:
-var z = new Complex128( 2.0, 2.0 );
+var alpha = new Complex128( 2.0, 2.0 );
 
 // Perform computation:
-zscal.ndarray( N, z, x, 1, 0 );
+zscal.ndarray( N, alpha, x, 1, 0 );
 
 // Print the results:
 console.log( reinterpretComplex64( x, 0 ) );

lib/node_modules/@stdlib/blas/base/wasm/zscal/benchmark/benchmark.js

@@ -51,14 +51,14 @@ var options = {
 * @returns {Function} benchmark function
 */
 function createBenchmark( len ) {
+	var alpha;
 	var xbuf;
 	var x;
-	var z;
 
 	xbuf = uniform( len*2, -100.0, 100.0, options );
 	x = new Complex128Array( xbuf.buffer );
 
-	z = new Complex128( 1.0, 0.0 );
+	alpha = new Complex128( 1.0, 0.0 );
 
 	return benchmark;
 
@@ -73,7 +73,7 @@ function createBenchmark( len ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			zscal.main( x.length, z, x, 1 );
+			zscal.main( x.length, alpha, x, 1 );
 			if ( isnan( xbuf[ i%(len*2) ] ) ) {
 				b.fail( 'should not return NaN' );
 			}

lib/node_modules/@stdlib/blas/base/wasm/zscal/benchmark/benchmark.ndarray.js

@@ -51,14 +51,14 @@ var options = {
 * @returns {Function} benchmark function
 */
 function createBenchmark( len ) {
+	var alpha;
 	var xbuf;
 	var x;
-	var z;
 
 	xbuf = uniform( len*2, -100.0, 100.0, options );
 	x = new Complex128Array( xbuf.buffer );
 
-	z = new Complex128( 1.0, 0.0 );
+	alpha = new Complex128( 1.0, 0.0 );
 
 	return benchmark;
 
@@ -73,7 +73,7 @@ function createBenchmark( len ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			zscal.ndarray( x.length, z, x, 1, 0 );
+			zscal.ndarray( x.length, alpha, x, 1, 0 );
 			if ( isnan( xbuf[ i%(len*2) ] ) ) {
 				b.fail( 'should not return NaN' );
 			}

lib/node_modules/@stdlib/blas/base/wasm/zscal/docs/repl.txt

@@ -1,5 +1,5 @@
 
-{{alias}}.main( N, za, zx, strideX )
+{{alias}}.main( N, alpha, x, strideX )
     Scales a double-precision complex floating-point vector by a double-
     precision complex floating-point constant.
 
@@ -9,52 +9,52 @@
     Indexing is relative to the first index. To introduce an offset, use typed
     array views.
 
-    If `N <= 0`, the function returns `zx` unchanged.
+    If `N <= 0`, the function returns `x` unchanged.
 
     Parameters
     ----------
     N: integer
         Number of indexed elements.
 
-    za: Complex128
+    alpha: Complex128
         Complex constant.
 
-    zx: Complex128Array
+    x: Complex128Array
         Input array.
 
     strideX: integer
-        Index increment for `zx`.
+        Index increment for `x`.
 
     Returns
     -------
-    zx: Complex128Array
+    x: Complex128Array
         Input array.
 
     Examples
     --------
     // Standard usage:
-    > var zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0 ] );
-    > var za = new {{alias:@stdlib/complex/float64/ctor}}( 1.0, 2.0 );
-    > {{alias}}.main( 2, za, zx, 1 )
+    > var x = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0 ] );
+    > var alpha = new {{alias:@stdlib/complex/float64/ctor}}( 1.0, 2.0 );
+    > {{alias}}.main( 2, alpha, x, 1 )
     <Complex128Array>[ -3.0, 4.0, -5.0, 10.0 ]
 
     // Advanced indexing:
-    > zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
-    > za = new {{alias:@stdlib/complex/float64/ctor}}( 1.0, 1.0 );
-    > {{alias}}.main( 2, za, zx, 2 )
+    > x = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+    > alpha = new {{alias:@stdlib/complex/float64/ctor}}( 1.0, 1.0 );
+    > {{alias}}.main( 2, alpha, x, 2 )
     <Complex128Array>[ -1.0, 3.0, 3.0, 4.0, -1.0, 11.0 ]
 
     // Using typed array views:
-    > var zx0 = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
-    > var zx1 = new {{alias:@stdlib/array/complex128}}( zx0.buffer, zx0.BYTES_PER_ELEMENT*1 );
-    > var za = new {{alias:@stdlib/complex/float64/ctor}}( 2.0, 2.0 );
-    > {{alias}}.main( 2, za, zx1, 1 )
+    > var x0 = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+    > var x1 = new {{alias:@stdlib/array/complex128}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 );
+    > var alpha = new {{alias:@stdlib/complex/float64/ctor}}( 2.0, 2.0 );
+    > {{alias}}.main( 2, alpha, x1, 1 )
     <Complex128Array>[ -2.0, 14.0, -2.0, 22.0 ]
-    > zx0
+    > x0
     <Complex128Array>[ 1.0, 2.0, -2.0, 14.0, -2.0, 22.0 ]
 
 
-{{alias}}.ndarray( N, za, zx, strideX, offsetX )
+{{alias}}.ndarray( N, alpha, x, strideX, offsetX )
     Scales a double-precision complex floating-point vector by a double-
     precision complex floating-point constant using alternative indexing
     semantics.
@@ -68,35 +68,35 @@
     N: integer
         Number of indexed elements.
 
-    za: Complex128
+    alpha: Complex128
         Complex constant.
 
-    zx: Complex128Array
+    x: Complex128Array
         Input array.
 
     strideX: integer
-        Index increment for `zx`.
+        Index increment for `x`.
 
     offsetX: integer
-        Starting index for `zx`.
+        Starting index for `x`.
 
     Returns
     -------
-    zx: Complex128Array
+    x: Complex128Array
         Input array.
 
     Examples
     --------
     // Standard usage:
-    > var zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0 ] );
-    > var za = new {{alias:@stdlib/complex/float64/ctor}}( 2.0, 2.0 );
-    > {{alias}}.ndarray( 2, za, zx, 1, 0 )
+    > var x = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0 ] );
+    > var alpha = new {{alias:@stdlib/complex/float64/ctor}}( 2.0, 2.0 );
+    > {{alias}}.ndarray( 2, alpha, x, 1, 0 )
     <Complex128Array>[ -2.0, 6.0, -2.0, 14.0 ]
 
     // Advanced indexing:
-    > zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
-    > za = new {{alias:@stdlib/complex/float64/ctor}}( 1.0, 2.0 );
-    > {{alias}}.ndarray( 2, za, zx, 1, 2 )
+    > x = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+    > alpha = new {{alias:@stdlib/complex/float64/ctor}}( 1.0, 2.0 );
+    > {{alias}}.ndarray( 2, alpha, x, 1, 2 )
     <Complex128Array>[ 1.0, 2.0, 3.0, 4.0, -7.0, 16.0, -9.0, 22.0 ]
 
 
@@ -447,7 +447,7 @@
         Input array pointer (i.e., byte offset).
 
     dx: integer
-        Index increment for `zx`.
+        Index increment for `x`.
 
     Returns
     -------
@@ -503,10 +503,10 @@
         Input array pointer (i.e., byte offset).
 
     dx: integer
-        Index increment for `zx`.
+        Index increment for `x`.
 
     ox: integer
-        Starting index for `zx`.
+        Starting index for `x`.
 
     Returns
     -------