chore: update description

---
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: 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: missing_dependencies
  - 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
---

---
type: pre_push_report
description: Results of running various checks prior to pushing changes.
report:
  - task: run_javascript_examples
    status: passed
  - task: run_c_examples
    status: passed
  - task: run_cpp_examples
    status: na
  - task: run_javascript_readme_examples
    status: passed
  - task: run_c_benchmarks
    status: na
  - task: run_cpp_benchmarks
    status: na
  - task: run_fortran_benchmarks
    status: na
  - task: run_javascript_benchmarks
    status: na
  - task: run_julia_benchmarks
    status: na
  - task: run_python_benchmarks
    status: na
  - task: run_r_benchmarks
    status: na
  - task: run_javascript_tests
    status: na
---

Author: aman-095

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

@@ -30,22 +30,22 @@ limitations under the License.
 var zscal = require( '@stdlib/blas/base/zscal' );
 ```
 
-#### zscal( N, za, zx, strideX )
+#### zscal( 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' );
 var real = require( '@stdlib/complex/float64/real' );
 var imag = require( '@stdlib/complex/float64/imag' );
 
-var zx = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
-var za = new Complex128( 2.0, 0.0 );
+var x = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var alpha = new Complex128( 2.0, 0.0 );
 
-zscal( 3, za, zx, 1 );
+zscal( 3, alpha, x, 1 );
 
-var z = zx.get( 0 );
+var z = x.get( 0 );
 // returns <Complex128>
 
 var re = real( z );
@@ -58,24 +58,24 @@ var im = imag( z );
 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 how values from `zx` are scaled by `za`. For example, to scale every other value in `zx` by `za`,
+The `N` and stride parameters determine how values from `x` are scaled by `alpha`. 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' );
 var real = require( '@stdlib/complex/float64/real' );
 var imag = require( '@stdlib/complex/float64/imag' );
 
-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, 0.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, 0.0 );
 
-zscal( 2, za, zx, 2 );
+zscal( 2, alpha, x, 2 );
 
-var z = zx.get( 2 );
+var z = x.get( 2 );
 // returns <Complex128>
 
 var re = real( z );
@@ -96,18 +96,18 @@ var real = require( '@stdlib/complex/float64/real' );
 var imag = require( '@stdlib/complex/float64/imag' );
 
 // 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( 3, za, zx1, 1 );
+// Scales every other value from `x1` by `alpha`...
+zscal( 3, alpha, x1, 1 );
 
-var z = zx0.get( 1 );
+var z = x0.get( 1 );
 // returns <Complex128>
 
 var re = real( z );
@@ -117,22 +117,22 @@ var im = imag( z );
 // returns 14.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' );
 var real = require( '@stdlib/complex/float64/real' );
 var imag = require( '@stdlib/complex/float64/imag' );
 
-var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.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 ] );
+var alpha = new Complex128( 2.0, 2.0 );
 
-zscal.ndarray( 3, za, zx, 1, 0 );
+zscal.ndarray( 3, alpha, x, 1, 0 );
 
-var z = zx.get( 0 );
+var z = x.get( 0 );
 // returns <Complex128>
 
 var re = real( z );
@@ -144,7 +144,7 @@ var im = imag( z );
 
 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,
 
@@ -154,12 +154,12 @@ var Complex128 = require( '@stdlib/complex/float64/ctor' );
 var real = require( '@stdlib/complex/float64/real' );
 var imag = require( '@stdlib/complex/float64/imag' );
 
-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 );
+zscal.ndarray( 2, alpha, x, 2, 1 );
 
-var z = zx.get( 3 );
+var z = x.get( 3 );
 // returns <Complex128>
 
 var re = real( z );
@@ -177,7 +177,7 @@ var im = imag( z );
 
 ## Notes
 
--   If `N <= 0` or `strideX <= 0` , both functions return `zx` unchanged.
+-   If `N <= 0` or `strideX <= 0` , both functions return `x` unchanged.
 -   `zscal()` corresponds to the [BLAS][blas] level 1 function [`zscal`][zscal].
 
 </section>
@@ -200,15 +200,15 @@ function rand() {
     return new Complex128( discreteUniform( 0, 10 ), discreteUniform( -5, 5 ) );
 }
 
-var zx = filledarrayBy( 10, 'complex128', rand );
-console.log( zx.toString() );
+var x = filledarrayBy( 10, 'complex128', rand );
+console.log( x.toString() );
 
-var za = new Complex128( 2.0, 2.0 );
-console.log( za.toString() );
+var alpha = new Complex128( 2.0, 2.0 );
+console.log( alpha.toString() );
 
-// Scales elements from `zx` by `za`:
-zscal( zx.length, za, zx, 1 );
-console.log( zx.get( zx.length-1 ).toString() );
+// Scales elements from `x` by `alpha`:
+zscal( x.length, alpha, x, 1 );
+console.log( x.get( x.length-1 ).toString() );
 ```
 
 </section>
@@ -241,53 +241,53 @@ console.log( zx.get( zx.length-1 ).toString() );
 #include "stdlib/blas/base/zscal.h"
 ```
 
-#### c_zscal( N, za, \*ZX, strideX )
+#### c_zscal( N, alpha, \*X, strideX )
 
-Scales values from `ZX` by `za`.
+Scales values from `X` by `alpha`.
 
 ```c
 #include "stdlib/complex/float64/ctor.h"
 
-double zx[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 };
-const stdlib_complex128_t za = stdlib_complex128( 2.0, 2.0 );
+double x[] = { 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_zscal( 4, za, (void *)zx, 1 );
+c_zscal( 4, alpha, (void *)x, 1 );
 ```
 
 The function accepts the following arguments:
 
 -   **N**: `[in] CBLAS_INT` number of indexed elements.
--   **za**: `[in] stdlib_complex128_t` scalar constant.
--   **ZX**: `[inout] void*` input array.
--   **strideX**: `[in] CBLAS_INT` index increment for `ZX`.
+-   **alpha**: `[in] stdlib_complex128_t` scalar constant.
+-   **X**: `[inout] void*` input array.
+-   **strideX**: `[in] CBLAS_INT` index increment for `X`.
 
 ```c
-void c_zscal( const CBLAS_INT N, const stdlib_complex128_t za, void *ZX, const CBLAS_INT strideX );
+void c_zscal( const CBLAS_INT N, const stdlib_complex128_t alpha, void *X, const CBLAS_INT strideX );
 ```
 
-#### c_zscal_ndarray( N, za, \*ZX, strideX, offsetX )
+#### c_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.
 
 ```c
 #include "stdlib/complex/float64/ctor.h"
 
-double zx[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 };
-const stdlib_complex128_t za = stdlib_complex128( 2.0, 2.0 );
+double x[] = { 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_zscal_ndarray( 4, za, (void *)zx, 1, 0 );
+c_zscal_ndarray( 4, alpha, (void *)x, 1, 0 );
 ```
 
 The function accepts the following arguments:
 
 -   **N**: `[in] CBLAS_INT` number of indexed elements.
--   **za**: `[in] stdlib_complex128_t` scalar constant.
--   **ZX**: `[inout] void*` input array.
--   **strideX**: `[in] CBLAS_INT` index increment for `ZX`.
--   **offsetX**: `[in] CBLAS_INT` starting index for `ZX`.
+-   **alpha**: `[in] stdlib_complex128_t` scalar constant.
+-   **X**: `[inout] void*` input array.
+-   **strideX**: `[in] CBLAS_INT` index increment for `X`.
+-   **offsetX**: `[in] CBLAS_INT` starting index for `X`.
 
 ```c
-void c_zscal_ndarray( const CBLAS_INT N, const stdlib_complex128_t za, void *ZX, const CBLAS_INT strideX, const CBLAS_INT offsetX );
+void c_zscal_ndarray( const CBLAS_INT N, const stdlib_complex128_t alpha, void *X, const CBLAS_INT strideX, const CBLAS_INT offsetX );
 ```
 
 </section>
@@ -315,10 +315,10 @@ void c_zscal_ndarray( const CBLAS_INT N, const stdlib_complex128_t za, void *ZX,
 
 int main( void ) {
     // Create a strided array of interleaved real and imaginary components:
-    double zx[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 };
+    double x[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 };
 
     // Create a complex scalar:
-    const stdlib_complex128_t ca = stdlib_complex128( 2.0, 2.0 );
+    const stdlib_complex128_t alpha = stdlib_complex128( 2.0, 2.0 );
 
     // Specify the number of elements:
     const int N = 4;
@@ -327,19 +327,19 @@ int main( void ) {
     const int strideX = 1;
 
     // Scale the elements of the array:
-    c_zscal( N, za, (void *)zx, strideX );
+    c_zscal( N, alpha, (void *)x, strideX );
 
     // Print the result:
     for ( int i = 0; i < N; i++ ) {
-        printf( "zx[ %i ] = %lf + %lfj\n", i, zx[ i*2 ], zx[ (i*2)+1 ] );
+        printf( "x[ %i ] = %lf + %lfj\n", i, x[ i*2 ], x[ (i*2)+1 ] );
     }
 
     // Scale the elements of the array using alternative indexing semantics:
-    c_zscal_ndarray( N, za, (void *)zx, -strideX, N-1 );
+    c_zscal_ndarray( N, alpha, (void *)x, -strideX, N-1 );
 
     // Print the result:
     for ( int i = 0; i < N; i++ ) {
-        printf( "zx[ %i ] = %lf + %lfj\n", i, zx[ i*2 ], zx[ (i*2)+1 ] );
+        printf( "x[ %i ] = %lf + %lfj\n", i, x[ i*2 ], x[ (i*2)+1 ] );
     }
 }
 ```