diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/README.md b/lib/node_modules/@stdlib/blas/base/zaxpy/README.md
index 5f3821466909..12e11b4a6dd3 100644
--- a/lib/node_modules/@stdlib/blas/base/zaxpy/README.md
+++ b/lib/node_modules/@stdlib/blas/base/zaxpy/README.md
@@ -30,43 +30,43 @@ limitations under the License.
 var zaxpy = require( '@stdlib/blas/base/zaxpy' );
 ```
 
-#### zaxpy( N, za, zx, strideX, zy, strideY )
+#### zaxpy( N, alpha, x, strideX, y, strideY )
 
-Scales values from `zx` by `za` and adds the result to `zy`.
+Scales values from `x` by `alpha` and adds the result to `y`.
 
 ```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 ] );
-var zy = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.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 y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var alpha = new Complex128( 2.0, 2.0 );
 
-zaxpy( 3, za, zx, 1, zy, 1 );
-// zy => <Complex128Array>[ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ]
+zaxpy( 3, alpha, x, 1, y, 1 );
+// y => <Complex128Array>[ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ]
 ```
 
 The function has the following parameters:
 
 -   **N**: number of indexed elements.
--   **za**: scalar [`Complex128`][@stdlib/complex/float64/ctor] constant.
--   **zx**: first input [`Complex128Array`][@stdlib/array/complex128].
--   **strideX**: index increment for `zx`.
--   **zy**: second input [`Complex128Array`][@stdlib/array/complex128].
--   **strideY**: index increment for `zy`.
+-   **alpha**: scalar [`Complex128`][@stdlib/complex/float64/ctor] constant.
+-   **x**: first input [`Complex128Array`][@stdlib/array/complex128].
+-   **strideX**: index increment for `x`.
+-   **y**: second input [`Complex128Array`][@stdlib/array/complex128].
+-   **strideY**: index increment for `y`.
 
-The `N` and stride parameters determine how values from `zx` are scaled by `za` and added to `zy`. For example, to scale every other value in `zx` by `za` and add the result to every other value of `zy`,
+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`,
 
 ```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 zy = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.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 y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var alpha = new Complex128( 2.0, 2.0 );
 
-zaxpy( 2, za, zx, 2, zy, 2 );
-// zy => <Complex128Array>[ -1.0, 7.0, 1.0, 1.0, -1.0, 23.0, 1.0, 1.0 ]
+zaxpy( 2, alpha, x, 2, y, 2 );
+// y => <Complex128Array>[ -1.0, 7.0, 1.0, 1.0, -1.0, 23.0, 1.0, 1.0 ]
 ```
 
 Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
@@ -78,41 +78,41 @@ var Complex128Array = require( '@stdlib/array/complex128' );
 var Complex128 = require( '@stdlib/complex/float64/ctor' );
 
 // Initial arrays...
-var zx0 = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
-var zy0 = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var x0 = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+var y0 = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
 
 // Define a scalar constant:
-var za = new Complex128( 2.0, 2.0 );
+var alpha = new Complex128( 2.0, 2.0 );
 
 // Create offset views...
-var zx1 = new Complex128Array( zx0.buffer, zx0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
-var zy1 = new Complex128Array( zy0.buffer, zy0.BYTES_PER_ELEMENT*2 ); // start at 3rd element
+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 `zx0` by `za` starting from second index and add the result to `zy0` starting from third index...
-zaxpy( 2, za, zx1, 1, zy1, 1 );
-// zy0 => <Complex128Array>[ 1.0, 1.0, 1.0, 1.0, -1.0, 15.0, -1.0, 23.0 ]
+// Scales values of `x0` by `alpha` starting from second index and add the result to `y0` starting from third index...
+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 ]
 ```
 
-#### zaxpy.ndarray( N, za, zx, strideX, offsetX, zy, strideY, offsetY )
+#### zaxpy.ndarray( N, alpha, x, strideX, offsetX, y, strideY, offsetY )
 
-Scales values from `zx` by `za` and adds the result to `zy` using alternative indexing semantics.
+Scales values from `x` by `alpha` and adds the result to `y` using alternative indexing semantics.
 
 ```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 ] );
-var zy = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.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 y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var alpha = new Complex128( 2.0, 2.0 );
 
-zaxpy.ndarray( 3, za, zx, 1, 0, zy, 1, 0 );
-// zy => <Complex128Array>[ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ]
+zaxpy.ndarray( 3, alpha, x, 1, 0, y, 1, 0 );
+// y => <Complex128Array>[ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ]
 ```
 
 The function has the following additional parameters:
 
--   **offsetX**: starting index for `zx`.
--   **offsetY**: starting index for `zy`.
+-   **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,
 
@@ -120,12 +120,12 @@ While [`typed array`][mdn-typed-array] views mandate a view offset based on the
 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 zy = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.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 y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var alpha = new Complex128( 2.0, 2.0 );
 
-zaxpy.ndarray( 3, za, zx, 1, 1, zy, 1, 1 );
-// zy => <Complex128Array>[ 1.0, 1.0, -1.0, 15.0, -1.0, 23.0, -1.0, 31.0 ]
+zaxpy.ndarray( 3, alpha, x, 1, 1, y, 1, 1 );
+// y => <Complex128Array>[ 1.0, 1.0, -1.0, 15.0, -1.0, 23.0, -1.0, 31.0 ]
 ```
 
 </section>
@@ -136,7 +136,7 @@ zaxpy.ndarray( 3, za, zx, 1, 1, zy, 1, 1 );
 
 ## Notes
 
--   If `N <= 0`, both functions return `zy` unchanged.
+-   If `N <= 0`, both functions return `y` unchanged.
 -   `zaxpy()` corresponds to the [BLAS][blas] level 1 function [`zaxpy`][zaxpy].
 
 </section>
@@ -162,17 +162,17 @@ function rand() {
     return new Complex128( discreteUniform( 0, 10 ), discreteUniform( -5, 5 ) );
 }
 
-var zx = filledarrayBy( 10, 'complex128', rand );
-var zy = filledarrayBy( 10, 'complex128', rand );
-var zyc = zcopy( zy.length, zy, 1, zeros( zy.length, 'complex128' ), 1 );
+var x = filledarrayBy( 10, 'complex128', rand );
+var y = filledarrayBy( 10, 'complex128', rand );
+var yc = zcopy( y.length, y, 1, zeros( y.length, 'complex128' ), 1 );
 
-var za = new Complex128( 2.0, 2.0 );
+var alpha = new Complex128( 2.0, 2.0 );
 
-// Scale values from `zx` by `za` and add the result to `zy`:
-zaxpy( zx.length, za, zx, 1, zy, 1 );
+// Scale values from `x` by `alpha` and add the result to `y`:
+zaxpy( x.length, alpha, x, 1, y, 1 );
 
 // Print the results:
-logEach( '(%s)*(%s) + (%s) = %s', za, zx, zyc, zy );
+logEach( '(%s)*(%s) + (%s) = %s', alpha, x, yc, y );
 ```
 
 </section>
diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.js
index b6e1b6de0949..e6ff9eb1f27e 100644
--- a/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.js
+++ b/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.js
@@ -49,16 +49,16 @@ var options = {
 */
 function createBenchmark( len ) {
 	var viewY;
-	var za;
-	var zx;
-	var zy;
+	var alpha;
+	var x;
+	var y;
 
-	zx = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) );
-	zy = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) );
+	x = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) );
+	y = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) );
 
-	viewY = reinterpret( zy, 0 );
+	viewY = reinterpret( y, 0 );
 
-	za = 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++ ) {
-			zaxpy( zx.length, za, zx, 1, zy, 1 );
+			zaxpy( x.length, alpha, x, 1, y, 1 );
 			if ( isnan( viewY[ i%(len*2) ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.ndarray.js
index 9e4e6e1d501b..9ddef1da5d8f 100644
--- a/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/base/zaxpy/benchmark/benchmark.ndarray.js
@@ -49,16 +49,16 @@ var options = {
 */
 function createBenchmark( len ) {
 	var viewY;
-	var za;
-	var zx;
-	var zy;
+	var alpha;
+	var x;
+	var y;
 
-	zx = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) );
-	zy = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) );
+	x = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) );
+	y = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) );
 
-	viewY = reinterpret( zy, 0 );
+	viewY = reinterpret( y, 0 );
 
-	za = 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++ ) {
-			zaxpy( zx.length, za, zx, 1, 0, zy, 1, 0 );
+			zaxpy( x.length, alpha, x, 1, 0, y, 1, 0 );
 			if ( isnan( viewY[ i%(len*2) ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/docs/repl.txt b/lib/node_modules/@stdlib/blas/base/zaxpy/docs/repl.txt
index 1d1f9b412990..5d297cc333d8 100644
--- a/lib/node_modules/@stdlib/blas/base/zaxpy/docs/repl.txt
+++ b/lib/node_modules/@stdlib/blas/base/zaxpy/docs/repl.txt
@@ -1,69 +1,69 @@
 
-{{alias}}( N, za, zx, strideX, zy, strideY )
+{{alias}}( N, alpha, x, strideX, y, strideY )
     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.
 
-    The `N` and stride parameters determine how values from `zx` are scaled by
-    `za` and added to `zy`.
+    The `N` and stride parameters determine how values from `x` are scaled by
+    `alpha` and added to `y`.
 
     Indexing is relative to the first index. To introduce an offset, use typed
     array views.
 
-    If `N` is less than or equal to `0`, the function returns `zy` unchanged.
+    If `N` is less than or equal to `0`, the function returns `y` unchanged.
 
     Parameters
     ----------
     N: integer
         Number of indexed elements.
 
-    za: Complex128
+    alpha: Complex128
         Scalar constant.
 
-    zx: Complex128Array
+    x: Complex128Array
         First input array.
 
     strideX: integer
-        Index increment for `zx`.
+        Index increment for `x`.
 
-    zy: Complex128Array
+    y: Complex128Array
         Second input array.
 
     strideY: integer
-        Index increment for `zy`.
+        Index increment for `y`.
 
     Returns
     -------
-    zy: Complex128Array
+    y: Complex128Array
         Second input array.
 
     Examples
     --------
     // Standard usage:
-    > var zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0 ] );
-    > var zy = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0 ] );
-    > var za = new {{alias:@stdlib/complex/float64/ctor}}( 2.0, 2.0 );
-    > {{alias}}( 2, za, zx, 1, zy, 1 )
+    > var x = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0 ] );
+    > var y = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0 ] );
+    > var alpha = new {{alias:@stdlib/complex/float64/ctor}}( 2.0, 2.0 );
+    > {{alias}}( 2, alpha, x, 1, y, 1 )
     <Complex128Array>[ -1.0, 7.0, -1.0, 15.0 ]
 
     // Advanced indexing:
-    > zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
-    > zy = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
-    > {{alias}}( 2, za, zx, -2, zy, 1 )
+    > x = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+    > y = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+    > {{alias}}( 2, alpha, x, -2, y, 1 )
     <Complex128Array>[ -1.0, 23.0, -1.0, 7.0, 1.0, 1.0 ]
 
     // Using typed array views:
-    > var zx0 = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0 ] );
-    > var zy0 = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0 ] );
-    > var zx1 = new {{alias:@stdlib/array/complex128}}( zx0.buffer, zx0.BYTES_PER_ELEMENT*1 );
-    > var zy1 = new {{alias:@stdlib/array/complex128}}( zy0.buffer, zy0.BYTES_PER_ELEMENT*1 );
-    > {{alias}}( 1, za, zx1, 1, zy1, 1 )
+    > var x0 = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0 ] );
+    > var y0 = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0 ] );
+    > var x1 = new {{alias:@stdlib/array/complex128}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 );
+    > var y1 = new {{alias:@stdlib/array/complex128}}( y0.buffer, y0.BYTES_PER_ELEMENT*1 );
+    > {{alias}}( 1, alpha, x1, 1, y1, 1 )
     <Complex128Array>[ -1.0, 15.0 ]
-    > zy0
+    > y0
     <Complex128Array>[ 1.0, 1.0, -1.0, 15.0 ]
 
 
-{{alias}}.ndarray( N, za, zx, strideX, offsetX, zy, strideY, offsetY )
+{{alias}}.ndarray( N, alpha, x, strideX, offsetX, y, strideY, offsetY )
     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 using alternative indexing
@@ -78,45 +78,45 @@
     N: integer
         Number of indexed elements.
 
-    za: Complex128
+    alpha: Complex128
         Scalar constant.
 
-    zx: Complex128Array
+    x: Complex128Array
         First input array.
 
     strideX: integer
-        Index increment for `zx`.
+        Index increment for `x`.
 
     offsetX: integer
-        Starting index for `zx`.
+        Starting index for `x`.
 
-    zy: Complex128Array
+    y: Complex128Array
         Second input array.
 
     strideY: integer
-        Index increment for `zy`.
+        Index increment for `y`.
 
     offsetY: integer
-        Starting index for `zy`.
+        Starting index for `y`.
 
     Returns
     -------
-    zy: Complex128Array
+    y: Complex128Array
         Second input array.
 
     Examples
     --------
     // Standard usage:
-    > var zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0 ] );
-    > var zy = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0 ] );
-    > var za = new {{alias:@stdlib/complex/float64/ctor}}( 2.0, 2.0 );
-    > {{alias}}.ndarray( zx.length, za, zx, 1, 0, zy, 1, 0 )
+    > var x = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0 ] );
+    > var y = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0 ] );
+    > var alpha = new {{alias:@stdlib/complex/float64/ctor}}( 2.0, 2.0 );
+    > {{alias}}.ndarray( x.length, alpha, x, 1, 0, y, 1, 0 )
     <Complex128Array>[ -1.0, 7.0, -1.0, 15.0 ]
 
     // Advanced indexing:
-    > zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
-    > zy = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
-    > {{alias}}.ndarray( 2, za, zx, 1, 1, zy, 1, 1 )
+    > x = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+    > y = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+    > {{alias}}.ndarray( 2, alpha, x, 1, 1, y, 1, 1 )
     <Complex128Array>[ 1.0, 1.0, -1.0, 15.0, -1.0, 23.0 ]
 
     See Also
diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/base/zaxpy/docs/types/index.d.ts
index 9ea53af4357a..94da10e3a9dc 100644
--- a/lib/node_modules/@stdlib/blas/base/zaxpy/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/blas/base/zaxpy/docs/types/index.d.ts
@@ -31,85 +31,85 @@ interface Routine {
 	* 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.
 	*
 	* @param N - number of indexed elements
-	* @param za - scalar constant
-	* @param zx - first input array
-	* @param strideX - `zx` stride length
-	* @param zy - second input array
-	* @param strideY - `zy` stride length
+	* @param alpha - scalar constant
+	* @param x - first input array
+	* @param strideX - `x` stride length
+	* @param y - second input array
+	* @param strideY - `y` stride length
 	* @returns second input array
 	*
 	* @example
 	* 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 ] );
-	* var zy = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.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 y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+	* var alpha = new Complex128( 2.0, 2.0 );
 	*
-	* zaxpy( zx.length, za, zx, 1, zy, 1 );
-	* // zy => <Complex128Array>[ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ]
+	* zaxpy( x.length, alpha, x, 1, y, 1 );
+	* // y => <Complex128Array>[ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ]
 	*/
-	( N: number, za: Complex128, zx: Complex128Array, strideX: number, zy: Complex128Array, strideY: number ): Complex128Array;
+	( N: number, alpha: Complex128, x: Complex128Array, strideX: number, y: Complex128Array, strideY: number ): Complex128Array;
 
 	/**
 	* 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.
 	*
 	* @param N - number of indexed elements
-	* @param za - scalar constant
-	* @param zx - first input array
-	* @param strideX - `zx` stride length
-	* @param offsetX - starting index for `zx`
-	* @param zy - second input array
-	* @param strideY - `zy` stride length
-	* @param offsetY - starting index for `zy`
+	* @param alpha - scalar constant
+	* @param x - first input array
+	* @param strideX - `x` stride length
+	* @param offsetX - starting index for `x`
+	* @param y - second input array
+	* @param strideY - `y` stride length
+	* @param offsetY - starting index for `y`
 	* @returns second input array
 	*
 	* @example
 	* 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 ] );
-	* var zy = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.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 y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+	* var alpha = new Complex128( 2.0, 2.0 );
 	*
-	* zaxpy.ndarray( zx.length, za, zx, 1, 0, zy, 1, 0 );
-	* // zy => <Complex128Array>[ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ]
+	* zaxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, 0 );
+	* // y => <Complex128Array>[ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ]
 	*/
-	ndarray( N: number, za: Complex128, zx: Complex128Array, strideX: number, offsetX: number, zy: Complex128Array, strideY: number, offsetY: number ): Complex128Array;
+	ndarray( N: number, alpha: Complex128, x: Complex128Array, strideX: number, offsetX: number, y: Complex128Array, strideY: number, offsetY: number ): Complex128Array;
 }
 
 /**
 * 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.
 *
 * @param N - number of indexed elements
-* @param za - scalar constant
-* @param zx - first input array
-* @param strideX - `zx` stride length
-* @param zy - second input array
-* @param strideY - `zy` stride length
+* @param alpha - scalar constant
+* @param x - first input array
+* @param strideX - `x` stride length
+* @param y - second input array
+* @param strideY - `y` stride length
 * @returns second input array
 *
 * @example
 * 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 zy = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.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 y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var alpha = new Complex128( 2.0, 2.0 );
 *
-* zaxpy( 2, za, zx, 2, zy, 2 );
-* // zy => <Complex128Array>[ -1.0, 7.0, 1.0, 1.0, -1.0, 23.0, 1.0, 1.0 ]
+* zaxpy( 2, alpha, x, 2, y, 2 );
+* // y => <Complex128Array>[ -1.0, 7.0, 1.0, 1.0, -1.0, 23.0, 1.0, 1.0 ]
 *
 * @example
 * 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 zy = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.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 y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var alpha = new Complex128( 2.0, 2.0 );
 *
-* zaxpy.ndarray( 3, za, zx, 1, 1, zy, 1, 1 );
-* // zy => <Complex128Array>[ 1.0, 1.0, -1.0, 15.0, -1.0, 23.0, -1.0, 31.0 ]
+* zaxpy.ndarray( 3, alpha, x, 1, 1, y, 1, 1 );
+* // y => <Complex128Array>[ 1.0, 1.0, -1.0, 15.0, -1.0, 23.0, -1.0, 31.0 ]
 */
 declare var zaxpy: Routine;
 
diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/docs/types/test.ts b/lib/node_modules/@stdlib/blas/base/zaxpy/docs/types/test.ts
index 828e86270673..d76d65bfdf9a 100644
--- a/lib/node_modules/@stdlib/blas/base/zaxpy/docs/types/test.ts
+++ b/lib/node_modules/@stdlib/blas/base/zaxpy/docs/types/test.ts
@@ -25,276 +25,276 @@ import zaxpy = require( './index' );
 
 // The function returns a Complex128Array...
 {
-	const zx = new Complex128Array( 10 );
-	const zy = new Complex128Array( 10 );
-	const za = new Complex128( 2.0, 2.0 );
+	const x = new Complex128Array( 10 );
+	const y = new Complex128Array( 10 );
+	const alpha = new Complex128( 2.0, 2.0 );
 
-	zaxpy( zx.length, za, zx, 1, zy, 1 ); // $ExpectType Complex128Array
+	zaxpy( x.length, alpha, x, 1, y, 1 ); // $ExpectType Complex128Array
 }
 
 // The compiler throws an error if the function is provided a first argument which is not a number...
 {
-	const zx = new Complex128Array( 10 );
-	const zy = new Complex128Array( 10 );
-	const za = new Complex128( 2.0, 2.0 );
-
-	zaxpy( '10', za, zx, 1, zy, 1 ); // $ExpectError
-	zaxpy( true, za, zx, 1, zy, 1 ); // $ExpectError
-	zaxpy( false, za, zx, 1, zy, 1 ); // $ExpectError
-	zaxpy( null, za, zx, 1, zy, 1 ); // $ExpectError
-	zaxpy( undefined, za, zx, 1, zy, 1 ); // $ExpectError
-	zaxpy( [], za, zx, 1, zy, 1 ); // $ExpectError
-	zaxpy( {}, za, zx, 1, zy, 1 ); // $ExpectError
-	zaxpy( ( zx: number ): number => zx, za, zx, 1, zy, 1 ); // $ExpectError
+	const x = new Complex128Array( 10 );
+	const y = new Complex128Array( 10 );
+	const alpha = new Complex128( 2.0, 2.0 );
+
+	zaxpy( '10', alpha, x, 1, y, 1 ); // $ExpectError
+	zaxpy( true, alpha, x, 1, y, 1 ); // $ExpectError
+	zaxpy( false, alpha, x, 1, y, 1 ); // $ExpectError
+	zaxpy( null, alpha, x, 1, y, 1 ); // $ExpectError
+	zaxpy( undefined, alpha, x, 1, y, 1 ); // $ExpectError
+	zaxpy( [], alpha, x, 1, y, 1 ); // $ExpectError
+	zaxpy( {}, alpha, x, 1, y, 1 ); // $ExpectError
+	zaxpy( ( x: number ): number => x, alpha, x, 1, y, 1 ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided a second argument which is not a complex number...
 {
-	const zx = new Complex128Array( 10 );
-	const zy = new Complex128Array( 10 );
-
-	zaxpy( zx.length, 10, zx, 1, zy, 1 ); // $ExpectError
-	zaxpy( zx.length, '10', zx, 1, zy, 1 ); // $ExpectError
-	zaxpy( zx.length, true, zx, 1, zy, 1 ); // $ExpectError
-	zaxpy( zx.length, false, zx, 1, zy, 1 ); // $ExpectError
-	zaxpy( zx.length, null, zx, 1, zy, 1 ); // $ExpectError
-	zaxpy( zx.length, undefined, zx, 1, zy, 1 ); // $ExpectError
-	zaxpy( zx.length, [ '1' ], zx, 1, zy, 1 ); // $ExpectError
-	zaxpy( zx.length, {}, zx, 1, zy, 1 ); // $ExpectError
-	zaxpy( zx.length, ( zx: number ): number => zx, zx, 1, zy, 1 ); // $ExpectError
+	const x = new Complex128Array( 10 );
+	const y = new Complex128Array( 10 );
+
+	zaxpy( x.length, 10, x, 1, y, 1 ); // $ExpectError
+	zaxpy( x.length, '10', x, 1, y, 1 ); // $ExpectError
+	zaxpy( x.length, true, x, 1, y, 1 ); // $ExpectError
+	zaxpy( x.length, false, x, 1, y, 1 ); // $ExpectError
+	zaxpy( x.length, null, x, 1, y, 1 ); // $ExpectError
+	zaxpy( x.length, undefined, x, 1, y, 1 ); // $ExpectError
+	zaxpy( x.length, [ '1' ], x, 1, y, 1 ); // $ExpectError
+	zaxpy( x.length, {}, x, 1, y, 1 ); // $ExpectError
+	zaxpy( x.length, ( x: number ): number => x, x, 1, y, 1 ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided a third argument which is not a Complex128Array...
 {
-	const zx = new Complex128Array( 10 );
-	const zy = new Complex128Array( 10 );
-	const za = new Complex128( 2.0, 2.0 );
-
-	zaxpy( zx.length, za, 10, 1, zy, 1 ); // $ExpectError
-	zaxpy( zx.length, za, '10', 1, zy, 1 ); // $ExpectError
-	zaxpy( zx.length, za, true, 1, zy, 1 ); // $ExpectError
-	zaxpy( zx.length, za, false, 1, zy, 1 ); // $ExpectError
-	zaxpy( zx.length, za, null, 1, zy, 1 ); // $ExpectError
-	zaxpy( zx.length, za, undefined, 1, zy, 1 ); // $ExpectError
-	zaxpy( zx.length, za, [ '1' ], 1, zy, 1 ); // $ExpectError
-	zaxpy( zx.length, za, {}, 1, zy, 1 ); // $ExpectError
-	zaxpy( zx.length, za, ( zx: number ): number => zx, 1, zy, 1 ); // $ExpectError
+	const x = new Complex128Array( 10 );
+	const y = new Complex128Array( 10 );
+	const alpha = new Complex128( 2.0, 2.0 );
+
+	zaxpy( x.length, alpha, 10, 1, y, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, '10', 1, y, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, true, 1, y, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, false, 1, y, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, null, 1, y, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, undefined, 1, y, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, [ '1' ], 1, y, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, {}, 1, y, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, ( x: number ): number => x, 1, y, 1 ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided a fourth argument which is not a number...
 {
-	const zx = new Complex128Array( 10 );
-	const zy = new Complex128Array( 10 );
-	const za = new Complex128( 2.0, 2.0 );
-
-	zaxpy( zx.length, za, zx, '10', zy, 1 ); // $ExpectError
-	zaxpy( zx.length, za, zx, true, zy, 1 ); // $ExpectError
-	zaxpy( zx.length, za, zx, false, zy, 1 ); // $ExpectError
-	zaxpy( zx.length, za, zx, null, zy, 1 ); // $ExpectError
-	zaxpy( zx.length, za, zx, undefined, zy, 1 ); // $ExpectError
-	zaxpy( zx.length, za, zx, [], zy, 1 ); // $ExpectError
-	zaxpy( zx.length, za, zx, {}, zy, 1 ); // $ExpectError
-	zaxpy( zx.length, za, zx, ( zx: number ): number => zx, zy, 1 ); // $ExpectError
+	const x = new Complex128Array( 10 );
+	const y = new Complex128Array( 10 );
+	const alpha = new Complex128( 2.0, 2.0 );
+
+	zaxpy( x.length, alpha, x, '10', y, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, x, true, y, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, x, false, y, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, x, null, y, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, x, undefined, y, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, x, [], y, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, x, {}, y, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, x, ( x: number ): number => x, y, 1 ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided a fifth argument which is not a Complex128Array...
 {
-	const zx = new Complex128Array( 10 );
-	const za = new Complex128( 2.0, 2.0 );
-
-	zaxpy( zx.length, za, zx, 1, 10, 1 ); // $ExpectError
-	zaxpy( zx.length, za, zx, 1, '10', 1 ); // $ExpectError
-	zaxpy( zx.length, za, zx, 1, true, 1 ); // $ExpectError
-	zaxpy( zx.length, za, zx, 1, false, 1 ); // $ExpectError
-	zaxpy( zx.length, za, zx, 1, null, 1 ); // $ExpectError
-	zaxpy( zx.length, za, zx, 1, undefined, 1 ); // $ExpectError
-	zaxpy( zx.length, za, zx, 1, [ '1' ], 1 ); // $ExpectError
-	zaxpy( zx.length, za, zx, 1, {}, 1 ); // $ExpectError
-	zaxpy( zx.length, za, zx, 1, ( zx: number ): number => zx, 1 ); // $ExpectError
+	const x = new Complex128Array( 10 );
+	const alpha = new Complex128( 2.0, 2.0 );
+
+	zaxpy( x.length, alpha, x, 1, 10, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, x, 1, '10', 1 ); // $ExpectError
+	zaxpy( x.length, alpha, x, 1, true, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, x, 1, false, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, x, 1, null, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, x, 1, undefined, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, x, 1, [ '1' ], 1 ); // $ExpectError
+	zaxpy( x.length, alpha, x, 1, {}, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, x, 1, ( x: number ): number => x, 1 ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided a sixth argument which is not a number...
 {
-	const zx = new Complex128Array( 10 );
-	const zy = new Complex128Array( 10 );
-	const za = new Complex128( 2.0, 2.0 );
-
-	zaxpy( zx.length, za, zx, 1, zy, '10' ); // $ExpectError
-	zaxpy( zx.length, za, zx, 1, zy, true ); // $ExpectError
-	zaxpy( zx.length, za, zx, 1, zy, false ); // $ExpectError
-	zaxpy( zx.length, za, zx, 1, zy, null ); // $ExpectError
-	zaxpy( zx.length, za, zx, 1, zy, undefined ); // $ExpectError
-	zaxpy( zx.length, za, zx, 1, zy, [] ); // $ExpectError
-	zaxpy( zx.length, za, zx, 1, zy, {} ); // $ExpectError
-	zaxpy( zx.length, za, zx, 1, zy, ( zx: number ): number => zx ); // $ExpectError
+	const x = new Complex128Array( 10 );
+	const y = new Complex128Array( 10 );
+	const alpha = new Complex128( 2.0, 2.0 );
+
+	zaxpy( x.length, alpha, x, 1, y, '10' ); // $ExpectError
+	zaxpy( x.length, alpha, x, 1, y, true ); // $ExpectError
+	zaxpy( x.length, alpha, x, 1, y, false ); // $ExpectError
+	zaxpy( x.length, alpha, x, 1, y, null ); // $ExpectError
+	zaxpy( x.length, alpha, x, 1, y, undefined ); // $ExpectError
+	zaxpy( x.length, alpha, x, 1, y, [] ); // $ExpectError
+	zaxpy( x.length, alpha, x, 1, y, {} ); // $ExpectError
+	zaxpy( x.length, alpha, x, 1, y, ( x: number ): number => x ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided an unsupported number of arguments...
 {
-	const zx = new Complex128Array( 10 );
-	const zy = new Complex128Array( 10 );
-	const za = new Complex128( 2.0, 2.0 );
+	const x = new Complex128Array( 10 );
+	const y = new Complex128Array( 10 );
+	const alpha = new Complex128( 2.0, 2.0 );
 
 	zaxpy(); // $ExpectError
-	zaxpy( zx.length ); // $ExpectError
-	zaxpy( zx.length, za ); // $ExpectError
-	zaxpy( zx.length, za, zx ); // $ExpectError
-	zaxpy( zx.length, za, zx, 1 ); // $ExpectError
-	zaxpy( zx.length, za, zx, 1, zy ); // $ExpectError
-	zaxpy( zx.length, za, zx, 1, zy, 1, 10 ); // $ExpectError
+	zaxpy( x.length ); // $ExpectError
+	zaxpy( x.length, alpha ); // $ExpectError
+	zaxpy( x.length, alpha, x ); // $ExpectError
+	zaxpy( x.length, alpha, x, 1 ); // $ExpectError
+	zaxpy( x.length, alpha, x, 1, y ); // $ExpectError
+	zaxpy( x.length, alpha, x, 1, y, 1, 10 ); // $ExpectError
 }
 
 // Attached to main export is an `ndarray` method which returns a Complex128Array...
 {
-	const zx = new Complex128Array( 10 );
-	const zy = new Complex128Array( 10 );
-	const za = new Complex128( 2.0, 2.0 );
+	const x = new Complex128Array( 10 );
+	const y = new Complex128Array( 10 );
+	const alpha = new Complex128( 2.0, 2.0 );
 
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, zy, 1, 0 ); // $ExpectType Complex128Array
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, 0 ); // $ExpectType Complex128Array
 }
 
 // The compiler throws an error if the `ndarray` method is provided a first argument which is not a number...
 {
-	const zx = new Complex128Array( 10 );
-	const zy = new Complex128Array( 10 );
-	const za = new Complex128( 2.0, 2.0 );
-
-	zaxpy.ndarray( '10', za, zx, 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( true, za, zx, 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( false, za, zx, 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( null, za, zx, 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( undefined, za, zx, 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( [], za, zx, 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( {}, za, zx, 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( ( zx: number ): number => zx, za, zx, 1, 0, zy, 1, 0 ); // $ExpectError
+	const x = new Complex128Array( 10 );
+	const y = new Complex128Array( 10 );
+	const alpha = new Complex128( 2.0, 2.0 );
+
+	zaxpy.ndarray( '10', alpha, x, 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( true, alpha, x, 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( false, alpha, x, 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( null, alpha, x, 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( undefined, alpha, x, 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( [], alpha, x, 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( {}, alpha, x, 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( ( x: number ): number => x, alpha, x, 1, 0, y, 1, 0 ); // $ExpectError
 }
 
 // The compiler throws an error if the `ndarray` method is provided a second argument which is not a complex number...
 {
-	const zx = new Complex128Array( 10 );
-	const zy = new Complex128Array( 10 );
-
-	zaxpy.ndarray( zx.length, 10, zx, 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, '10', zx, 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, true, zx, 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, false, zx, 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, null, zx, 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, undefined, zx, 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, [ '1' ], zx, 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, {}, zx, 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, ( zx: number ): number => zx, zx, 1, 0, zy, 1, 0 ); // $ExpectError
+	const x = new Complex128Array( 10 );
+	const y = new Complex128Array( 10 );
+
+	zaxpy.ndarray( x.length, 10, x, 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, '10', x, 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, true, x, 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, false, x, 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, null, x, 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, undefined, x, 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, [ '1' ], x, 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, {}, x, 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, ( x: number ): number => x, x, 1, 0, y, 1, 0 ); // $ExpectError
 }
 
 // The compiler throws an error if the `ndarray` method is provided a third argument which is not a Complex128Array...
 {
-	const zx = new Complex128Array( 10 );
-	const zy = new Complex128Array( 10 );
-	const za = new Complex128( 2.0, 2.0 );
-
-	zaxpy.ndarray( zx.length, za, 10, 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, '10', 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, true, 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, false, 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, null, 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, undefined, 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, [ '1' ], 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, {}, 1, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, ( zx: number ): number => zx, 1, 0, zy, 1, 0 ); // $ExpectError
+	const x = new Complex128Array( 10 );
+	const y = new Complex128Array( 10 );
+	const alpha = new Complex128( 2.0, 2.0 );
+
+	zaxpy.ndarray( x.length, alpha, 10, 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, '10', 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, true, 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, false, 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, null, 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, undefined, 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, [ '1' ], 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, {}, 1, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, ( x: number ): number => x, 1, 0, y, 1, 0 ); // $ExpectError
 }
 
 // The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number...
 {
-	const zx = new Complex128Array( 10 );
-	const zy = new Complex128Array( 10 );
-	const za = new Complex128( 2.0, 2.0 );
-
-	zaxpy.ndarray( zx.length, za, zx, '10', 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, true, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, false, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, null, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, undefined, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, [], 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, {}, 0, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, ( zx: number ): number => zx, 0, zy, 1, 0 ); // $ExpectError
+	const x = new Complex128Array( 10 );
+	const y = new Complex128Array( 10 );
+	const alpha = new Complex128( 2.0, 2.0 );
+
+	zaxpy.ndarray( x.length, alpha, x, '10', 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, true, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, false, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, null, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, undefined, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, [], 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, {}, 0, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, ( x: number ): number => x, 0, y, 1, 0 ); // $ExpectError
 }
 
 // The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a number...
 {
-	const zx = new Complex128Array( 10 );
-	const zy = new Complex128Array( 10 );
-	const za = new Complex128( 2.0, 2.0 );
-
-	zaxpy.ndarray( zx.length, za, zx, 1, '10', zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, true, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, false, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, null, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, undefined, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, [], zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, {}, zy, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, ( zx: number ): number => zx, zy, 1, 0 ); // $ExpectError
+	const x = new Complex128Array( 10 );
+	const y = new Complex128Array( 10 );
+	const alpha = new Complex128( 2.0, 2.0 );
+
+	zaxpy.ndarray( x.length, alpha, x, 1, '10', y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, true, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, false, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, null, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, undefined, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, [], y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, {}, y, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, ( x: number ): number => x, y, 1, 0 ); // $ExpectError
 }
 
 // The compiler throws an error if the `ndarray` method is provided a sixth argument which is not a Complex128Array...
 {
-	const zx = new Complex128Array( 10 );
-	const za = new Complex128( 2.0, 2.0 );
-
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, 10, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, '10', 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, true, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, false, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, null, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, undefined, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, [ '1' ], 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, {}, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, ( zx: number ): number => zx, 1, 0 ); // $ExpectError
+	const x = new Complex128Array( 10 );
+	const alpha = new Complex128( 2.0, 2.0 );
+
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, 10, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, '10', 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, true, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, false, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, null, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, undefined, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, [ '1' ], 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, {}, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, ( x: number ): number => x, 1, 0 ); // $ExpectError
 }
 
 // The compiler throws an error if the `ndarray` method is provided a seventh argument which is not a number...
 {
-	const zx = new Complex128Array( 10 );
-	const zy = new Complex128Array( 10 );
-	const za = new Complex128( 2.0, 2.0 );
-
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, zy, '10', 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, zy, true, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, zy, false, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, zy, null, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, zy, undefined, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, zy, [], 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, zy, {}, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, zy, ( zx: number ): number => zx, 0 ); // $ExpectError
+	const x = new Complex128Array( 10 );
+	const y = new Complex128Array( 10 );
+	const alpha = new Complex128( 2.0, 2.0 );
+
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, y, '10', 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, y, true, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, y, false, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, y, null, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, y, undefined, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, y, [], 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, y, {}, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, y, ( x: number ): number => x, 0 ); // $ExpectError
 }
 
 // The compiler throws an error if the `ndarray` method is provided an eighth argument which is not a number...
 {
-	const zx = new Complex128Array( 10 );
-	const zy = new Complex128Array( 10 );
-	const za = new Complex128( 2.0, 2.0 );
-
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, zy, 1, '10' ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, zy, 1, true ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, zy, 1, false ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, zy, 1, null ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, zy, 1, undefined ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, zy, 1, [] ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, zy, 1, {} ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, zy, 1, ( zx: number ): number => zx ); // $ExpectError
+	const x = new Complex128Array( 10 );
+	const y = new Complex128Array( 10 );
+	const alpha = new Complex128( 2.0, 2.0 );
+
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, '10' ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, true ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, false ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, null ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, undefined ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, [] ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, {} ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, ( x: number ): number => x ); // $ExpectError
 }
 
 // The compiler throws an error if the `ndarray` method is provided an unsupported number of arguments...
 {
-	const zx = new Complex128Array( 10 );
-	const zy = new Complex128Array( 10 );
-	const za = new Complex128( 2.0, 2.0 );
+	const x = new Complex128Array( 10 );
+	const y = new Complex128Array( 10 );
+	const alpha = new Complex128( 2.0, 2.0 );
 
 	zaxpy.ndarray(); // $ExpectError
-	zaxpy.ndarray( zx.length ); // $ExpectError
-	zaxpy.ndarray( zx.length, za ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, zy ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, zy, 1 ); // $ExpectError
-	zaxpy.ndarray( zx.length, za, zx, 1, 0, zy, 1, 0, 10 ); // $ExpectError
+	zaxpy.ndarray( x.length ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, y ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, y, 1 ); // $ExpectError
+	zaxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, 0, 10 ); // $ExpectError
 }
diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/examples/index.js b/lib/node_modules/@stdlib/blas/base/zaxpy/examples/index.js
index c4db1aced342..c1369cdf919f 100644
--- a/lib/node_modules/@stdlib/blas/base/zaxpy/examples/index.js
+++ b/lib/node_modules/@stdlib/blas/base/zaxpy/examples/index.js
@@ -30,14 +30,14 @@ function rand() {
 	return new Complex128( discreteUniform( 0, 10 ), discreteUniform( -5, 5 ) );
 }
 
-var zx = filledarrayBy( 10, 'complex128', rand );
-var zy = filledarrayBy( 10, 'complex128', rand );
-var zyc = zcopy( zy.length, zy, 1, zeros( zy.length, 'complex128' ), 1 );
+var x = filledarrayBy( 10, 'complex128', rand );
+var y = filledarrayBy( 10, 'complex128', rand );
+var yc = zcopy( y.length, y, 1, zeros( y.length, 'complex128' ), 1 );
 
-var za = new Complex128( 2.0, 2.0 );
+var alpha = new Complex128( 2.0, 2.0 );
 
-// Scale values from `zx` by `za` and add the result to `zy`:
-zaxpy( zx.length, za, zx, 1, zy, 1 );
+// Scale values from `x` by `alpha` and add the result to `y`:
+zaxpy( x.length, alpha, x, 1, y, 1 );
 
 // Print the results:
-logEach( '(%s)*(%s) + (%s) = %s', za, zx, zyc, zy );
+logEach( '(%s)*(%s) + (%s) = %s', alpha, x, yc, y );
diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/lib/index.js b/lib/node_modules/@stdlib/blas/base/zaxpy/lib/index.js
index f22e2a5ff337..c09fb28320f3 100644
--- a/lib/node_modules/@stdlib/blas/base/zaxpy/lib/index.js
+++ b/lib/node_modules/@stdlib/blas/base/zaxpy/lib/index.js
@@ -28,24 +28,24 @@
 * var Complex128 = require( '@stdlib/complex/float64/ctor' );
 * var zaxpy = require( '@stdlib/blas/base/zaxpy' );
 *
-* var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
-* var zy = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.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 y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var alpha = new Complex128( 2.0, 2.0 );
 *
-* zaxpy( 3, za, zx, 1, zy, 1 );
-* // zy => <Complex128Array>[ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ]
+* zaxpy( 3, alpha, x, 1, y, 1 );
+* // y => <Complex128Array>[ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ]
 *
 * @example
 * var Complex128Array = require( '@stdlib/array/complex128' );
 * var Complex128 = require( '@stdlib/complex/float64/ctor' );
 * var zaxpy = require( '@stdlib/blas/base/zaxpy' );
 *
-* var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
-* var zy = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.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 y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var alpha = new Complex128( 2.0, 2.0 );
 *
-* zaxpy.ndarray( 3, za, zx, 1, 0, zy, 1, 0 );
-* // zy => <Complex128Array>[ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ]
+* zaxpy.ndarray( 3, alpha, x, 1, 0, y, 1, 0 );
+* // y => <Complex128Array>[ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ]
 */
 
 // MODULES //
diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/lib/ndarray.js b/lib/node_modules/@stdlib/blas/base/zaxpy/lib/ndarray.js
index 5fc2a235521a..5d74eb82f989 100644
--- a/lib/node_modules/@stdlib/blas/base/zaxpy/lib/ndarray.js
+++ b/lib/node_modules/@stdlib/blas/base/zaxpy/lib/ndarray.js
@@ -33,27 +33,27 @@ var dcabs1 = require( '@stdlib/blas/base/dcabs1' );
 * 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.
 *
 * @param {PositiveInteger} N - number of indexed elements
-* @param {Complex128} za - scalar constant
-* @param {Complex128Array} zx - first input array
-* @param {integer} strideX - `zx` stride length
-* @param {integer} offsetX - starting index for `zx`
-* @param {Complex128Array} zy - second input array
-* @param {integer} strideY - `zy` stride length
-* @param {integer} offsetY - starting index for `zy`
+* @param {Complex128} alpha - scalar constant
+* @param {Complex128Array} x - first input array
+* @param {integer} strideX - `x` stride length
+* @param {integer} offsetX - starting index for `x`
+* @param {Complex128Array} y - second input array
+* @param {integer} strideY - `y` stride length
+* @param {integer} offsetY - starting index for `y`
 * @returns {Complex128Array} second input array
 *
 * @example
 * 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 ] );
-* var zy = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.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 y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var alpha = new Complex128( 2.0, 2.0 );
 *
-* zaxpy( 3, za, zx, 1, 0, zy, 1, 0 );
-* // zy => <Complex128Array>[ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ]
+* zaxpy( 3, alpha, x, 1, 0, y, 1, 0 );
+* // y => <Complex128Array>[ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ]
 */
-function zaxpy( N, za, zx, strideX, offsetX, zy, strideY, offsetY ) {
+function zaxpy( N, alpha, x, strideX, offsetX, y, strideY, offsetY ) {
 	var viewX;
 	var viewY;
 	var sx;
@@ -64,13 +64,13 @@ function zaxpy( N, za, zx, strideX, offsetX, zy, strideY, offsetY ) {
 	var im;
 	var i;
 
-	if ( N <= 0 || dcabs1( za ) === 0.0 ) {
-		return zy;
+	if ( N <= 0 || dcabs1( alpha ) === 0.0 ) {
+		return y;
 	}
-	re = real( za );
-	im = imag( za );
-	viewX = reinterpret( zx, 0 );
-	viewY = reinterpret( zy, 0 );
+	re = real( alpha );
+	im = imag( alpha );
+	viewX = reinterpret( x, 0 );
+	viewY = reinterpret( y, 0 );
 	sx = strideX * 2;
 	sy = strideY * 2;
 	ix = offsetX * 2;
@@ -80,7 +80,7 @@ function zaxpy( N, za, zx, strideX, offsetX, zy, strideY, offsetY ) {
 		ix += sx;
 		iy += sy;
 	}
-	return zy;
+	return y;
 }
 
 
diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/lib/zaxpy.js b/lib/node_modules/@stdlib/blas/base/zaxpy/lib/zaxpy.js
index 8442298cc800..b68f04f1470e 100644
--- a/lib/node_modules/@stdlib/blas/base/zaxpy/lib/zaxpy.js
+++ b/lib/node_modules/@stdlib/blas/base/zaxpy/lib/zaxpy.js
@@ -30,28 +30,28 @@ var ndarray = require( './ndarray.js' );
 * 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.
 *
 * @param {PositiveInteger} N - number of indexed elements
-* @param {Complex128} za - scalar constant
-* @param {Complex128Array} zx - first input array
-* @param {integer} strideX - `zx` stride length
-* @param {Complex128Array} zy - second input array
-* @param {integer} strideY - `zy` stride length
+* @param {Complex128} alpha - scalar constant
+* @param {Complex128Array} x - first input array
+* @param {integer} strideX - `x` stride length
+* @param {Complex128Array} y - second input array
+* @param {integer} strideY - `y` stride length
 * @returns {Complex128Array} second input array
 *
 * @example
 * 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 ] );
-* var zy = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.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 y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var alpha = new Complex128( 2.0, 2.0 );
 *
-* zaxpy( 3, za, zx, 1, zy, 1 );
-* // zy => <Complex128Array>[ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ]
+* zaxpy( 3, alpha, x, 1, y, 1 );
+* // y => <Complex128Array>[ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ]
 */
-function zaxpy( N, za, zx, strideX, zy, strideY ) {
+function zaxpy( N, alpha, x, strideX, y, strideY ) {
 	var ix = stride2offset( N, strideX );
 	var iy = stride2offset( N, strideY );
-	return ndarray( N, za, zx, strideX, ix, zy, strideY, iy );
+	return ndarray( N, alpha, x, strideX, ix, y, strideY, iy );
 }
 
 
diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.ndarray.js
index 0e9e16535946..1c1ba2b59427 100644
--- a/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.ndarray.js
@@ -71,14 +71,14 @@ tape( 'the function has an arity of 8', function test( t ) {
 	t.end();
 });
 
-tape( 'the function scales elements from `zx` by `za` and adds the result to `zy`', function test( t ) {
+tape( 'the function scales elements from `x` by `alpha` and adds the result to `y`', function test( t ) {
 	var expected;
 	var viewY;
-	var za;
-	var zx;
-	var zy;
+	var alpha;
+	var x;
+	var y;
 
-	zx = new Complex128Array([
+	x = new Complex128Array([
 		0.7,  // 1
 		-0.8, // 1
 		-0.4, // 2
@@ -94,7 +94,7 @@ tape( 'the function scales elements from `zx` by `za` and adds the result to `zy
 		-0.6,
 		0.6
 	]);
-	zy = new Complex128Array([
+	y = new Complex128Array([
 		0.6,  // 1
 		-0.6, // 1
 		-0.9, // 2
@@ -110,11 +110,11 @@ tape( 'the function scales elements from `zx` by `za` and adds the result to `zy
 		0.8,
 		-0.7
 	]);
-	za = new Complex128( 0.4, -0.7 );
+	alpha = new Complex128( 0.4, -0.7 );
 
-	zaxpy( 4, za, zx, 1, 0, zy, 1, 0 );
+	zaxpy( 4, alpha, x, 1, 0, y, 1, 0 );
 
-	viewY = new Float64Array( zy.buffer );
+	viewY = new Float64Array( y.buffer );
 	expected = new Float64Array([
 		0.32,  // 1
 		-1.41, // 1
@@ -135,14 +135,14 @@ tape( 'the function scales elements from `zx` by `za` and adds the result to `zy
 	t.end();
 });
 
-tape( 'the function supports a `zx` stride', function test( t ) {
+tape( 'the function supports a `x` stride', function test( t ) {
 	var expected;
 	var viewY;
-	var za;
-	var zx;
-	var zy;
+	var alpha;
+	var x;
+	var y;
 
-	zx = new Complex128Array([
+	x = new Complex128Array([
 		0.7,  // 1
 		-0.8, // 1
 		-0.4,
@@ -158,7 +158,7 @@ tape( 'the function supports a `zx` stride', function test( t ) {
 		-0.6, // 4
 		0.6   // 4
 	]);
-	zy = new Complex128Array([
+	y = new Complex128Array([
 		0.6,  // 1
 		-0.6, // 1
 		-0.9, // 2
@@ -174,11 +174,11 @@ tape( 'the function supports a `zx` stride', function test( t ) {
 		0.8,
 		-0.7
 	]);
-	za = new Complex128( 0.4, -0.7 );
+	alpha = new Complex128( 0.4, -0.7 );
 
-	zaxpy( 4, za, zx, 2, 0, zy, 1, 0 );
+	zaxpy( 4, alpha, x, 2, 0, y, 1, 0 );
 
-	viewY = new Float64Array( zy.buffer );
+	viewY = new Float64Array( y.buffer );
 	expected = new Float64Array([
 		0.32,  // 1
 		-1.41, // 1
@@ -199,14 +199,14 @@ tape( 'the function supports a `zx` stride', function test( t ) {
 	t.end();
 });
 
-tape( 'the function supports a `zx` offset', function test( t ) {
+tape( 'the function supports a `x` offset', function test( t ) {
 	var expected;
 	var viewY;
-	var za;
-	var zx;
-	var zy;
+	var alpha;
+	var x;
+	var y;
 
-	zx = new Complex128Array([
+	x = new Complex128Array([
 		0.7,
 		-0.8,
 		-0.4, // 1
@@ -222,7 +222,7 @@ tape( 'the function supports a `zx` offset', function test( t ) {
 		-0.6,
 		0.6
 	]);
-	zy = new Complex128Array([
+	y = new Complex128Array([
 		0.6,  // 1
 		-0.6, // 1
 		-0.9, // 2
@@ -238,11 +238,11 @@ tape( 'the function supports a `zx` offset', function test( t ) {
 		0.8,
 		-0.7
 	]);
-	za = new Complex128( 0.4, -0.7 );
+	alpha = new Complex128( 0.4, -0.7 );
 
-	zaxpy( 3, za, zx, 2, 1, zy, 1, 0 );
+	zaxpy( 3, alpha, x, 2, 1, y, 1, 0 );
 
-	viewY = new Float64Array( zy.buffer );
+	viewY = new Float64Array( y.buffer );
 	expected = new Float64Array([
 		-0.05, // 1
 		-0.6,  // 1
@@ -263,14 +263,14 @@ tape( 'the function supports a `zx` offset', function test( t ) {
 	t.end();
 });
 
-tape( 'the function supports a `zy` stride', function test( t ) {
+tape( 'the function supports a `y` stride', function test( t ) {
 	var expected;
 	var viewY;
-	var za;
-	var zx;
-	var zy;
+	var alpha;
+	var x;
+	var y;
 
-	zx = new Complex128Array([
+	x = new Complex128Array([
 		0.7,  // 1
 		-0.8, // 1
 		-0.4, // 2
@@ -286,7 +286,7 @@ tape( 'the function supports a `zy` stride', function test( t ) {
 		-0.6,
 		0.6
 	]);
-	zy = new Complex128Array([
+	y = new Complex128Array([
 		0.6,  // 1
 		-0.6, // 1
 		-0.9,
@@ -302,11 +302,11 @@ tape( 'the function supports a `zy` stride', function test( t ) {
 		0.8,  // 4
 		-0.7  // 4
 	]);
-	za = new Complex128( 0.4, -0.7 );
+	alpha = new Complex128( 0.4, -0.7 );
 
-	zaxpy( 4, za, zx, 1, 0, zy, 2, 0 );
+	zaxpy( 4, alpha, x, 1, 0, y, 2, 0 );
 
-	viewY = new Float64Array( zy.buffer );
+	viewY = new Float64Array( y.buffer );
 	expected = new Float64Array([
 		0.32,  // 1
 		-1.41, // 1
@@ -327,14 +327,14 @@ tape( 'the function supports a `zy` stride', function test( t ) {
 	t.end();
 });
 
-tape( 'the function supports a `zy` offset', function test( t ) {
+tape( 'the function supports a `y` offset', function test( t ) {
 	var expected;
 	var viewY;
-	var za;
-	var zx;
-	var zy;
+	var alpha;
+	var x;
+	var y;
 
-	zx = new Complex128Array([
+	x = new Complex128Array([
 		0.7,  // 1
 		-0.8, // 1
 		-0.4, // 2
@@ -350,7 +350,7 @@ tape( 'the function supports a `zy` offset', function test( t ) {
 		-0.6,
 		0.6
 	]);
-	zy = new Complex128Array([
+	y = new Complex128Array([
 		0.6,
 		-0.6,
 		-0.9, // 1
@@ -366,11 +366,11 @@ tape( 'the function supports a `zy` offset', function test( t ) {
 		0.8,
 		-0.7
 	]);
-	za = new Complex128( 0.4, -0.7 );
+	alpha = new Complex128( 0.4, -0.7 );
 
-	zaxpy( 3, za, zx, 1, 0, zy, 2, 1 );
+	zaxpy( 3, alpha, x, 1, 0, y, 2, 1 );
 
-	viewY = new Float64Array( zy.buffer );
+	viewY = new Float64Array( y.buffer );
 	expected = new Float64Array([
 		0.6,
 		-0.6,
@@ -392,39 +392,39 @@ tape( 'the function supports a `zy` offset', function test( t ) {
 });
 
 tape( 'the function returns a reference to the output array', function test( t ) {
+	var alpha;
 	var out;
-	var za;
-	var zx;
-	var zy;
+	var x;
+	var y;
 
-	zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
-	zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
-	za = new Complex128( 2.0, 2.0 );
+	x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+	y = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	alpha = new Complex128( 2.0, 2.0 );
 
-	out = zaxpy( zx.length, za, zx, 1, 0, zy, 1, 0 );
+	out = zaxpy( x.length, alpha, x, 1, 0, y, 1, 0 );
 
-	t.strictEqual( out, zy, 'same reference' );
+	t.strictEqual( out, y, 'same reference' );
 	t.end();
 });
 
-tape( 'if provided `za` parameter equal to `0`, the function returns the second input array unchanged', function test( t ) {
+tape( 'if provided `alpha` parameter equal to `0`, the function returns the second input array unchanged', function test( t ) {
 	var expected;
 	var viewY;
-	var za;
-	var zx;
-	var zy;
+	var alpha;
+	var x;
+	var y;
 
-	zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
-	zy = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
-	za = new Complex128( 0.0, 0.0 );
+	x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+	y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+	alpha = new Complex128( 0.0, 0.0 );
 
-	viewY = new Float64Array( zy.buffer );
+	viewY = new Float64Array( y.buffer );
 	expected = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
 
-	zaxpy( -1, za, zx, 1, 0, zy, 1, 0 );
+	zaxpy( -1, alpha, x, 1, 0, y, 1, 0 );
 	t.deepEqual( viewY, expected, 'returns expected value' );
 
-	zaxpy( 0, za, zx, 1, 0, zy, 1, 0 );
+	zaxpy( 0, alpha, x, 1, 0, y, 1, 0 );
 	t.deepEqual( viewY, expected, 'returns expected value' );
 
 	t.end();
@@ -433,34 +433,34 @@ tape( 'if provided `za` parameter equal to `0`, the function returns the second
 tape( 'if provided an `N` parameter less than or equal to `0`, the function returns the second input array unchanged', function test( t ) {
 	var expected;
 	var viewY;
-	var za;
-	var zx;
-	var zy;
+	var alpha;
+	var x;
+	var y;
 
-	zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
-	zy = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
-	za = new Complex128( 2.0, 2.0 );
+	x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+	y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+	alpha = new Complex128( 2.0, 2.0 );
 
-	viewY = new Float64Array( zy.buffer );
+	viewY = new Float64Array( y.buffer );
 	expected = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
 
-	zaxpy( -1, za, zx, 1, 0, zy, 1, 0 );
+	zaxpy( -1, alpha, x, 1, 0, y, 1, 0 );
 	t.deepEqual( viewY, expected, 'returns expected value' );
 
-	zaxpy( 0, za, zx, 1, 0, zy, 1, 0 );
+	zaxpy( 0, alpha, x, 1, 0, y, 1, 0 );
 	t.deepEqual( viewY, expected, 'returns expected value' );
 
 	t.end();
 });
 
-tape( 'the function supports a negative `zx` stride', function test( t ) {
+tape( 'the function supports a negative `x` stride', function test( t ) {
 	var expected;
 	var viewY;
-	var za;
-	var zx;
-	var zy;
+	var alpha;
+	var x;
+	var y;
 
-	zx = new Complex128Array([
+	x = new Complex128Array([
 		0.7,  // 4
 		-0.8, // 4
 		-0.4,
@@ -476,7 +476,7 @@ tape( 'the function supports a negative `zx` stride', function test( t ) {
 		-0.6, // 1
 		0.6   // 1
 	]);
-	zy = new Complex128Array([
+	y = new Complex128Array([
 		0.6,  // 1
 		-0.6, // 1
 		-0.9, // 2
@@ -492,11 +492,11 @@ tape( 'the function supports a negative `zx` stride', function test( t ) {
 		0.8,
 		-0.7
 	]);
-	za = new Complex128( 0.4, -0.7 );
+	alpha = new Complex128( 0.4, -0.7 );
 
-	zaxpy( 4, za, zx, -2, 6, zy, 1, 0 );
+	zaxpy( 4, alpha, x, -2, 6, y, 1, 0 );
 
-	viewY = new Float64Array( zy.buffer );
+	viewY = new Float64Array( y.buffer );
 	expected = new Float64Array([
 		0.78,  // 1
 		0.06,  // 1
@@ -517,14 +517,14 @@ tape( 'the function supports a negative `zx` stride', function test( t ) {
 	t.end();
 });
 
-tape( 'the function supports a negative `zy` stride', function test( t ) {
+tape( 'the function supports a negative `y` stride', function test( t ) {
 	var expected;
 	var viewY;
-	var za;
-	var zx;
-	var zy;
+	var alpha;
+	var x;
+	var y;
 
-	zx = new Complex128Array([
+	x = new Complex128Array([
 		0.7,  // 1
 		-0.8, // 1
 		-0.4,
@@ -540,7 +540,7 @@ tape( 'the function supports a negative `zy` stride', function test( t ) {
 		-0.6, // 4
 		0.6   // 4
 	]);
-	zy = new Complex128Array([
+	y = new Complex128Array([
 		0.6,  // 4
 		-0.6, // 4
 		-0.9,
@@ -556,11 +556,11 @@ tape( 'the function supports a negative `zy` stride', function test( t ) {
 		0.8,  // 1
 		-0.7  // 1
 	]);
-	za = new Complex128( 0.4, -0.7 );
+	alpha = new Complex128( 0.4, -0.7 );
 
-	zaxpy( 4, za, zx, 2, 0, zy, -2, 6 );
+	zaxpy( 4, alpha, x, 2, 0, y, -2, 6 );
 
-	viewY = new Float64Array( zy.buffer );
+	viewY = new Float64Array( y.buffer );
 	expected = new Float64Array([
 		0.78,  // 4
 		0.06,  // 4
@@ -584,11 +584,11 @@ tape( 'the function supports a negative `zy` stride', function test( t ) {
 tape( 'the function supports complex access patterns', function test( t ) {
 	var expected;
 	var viewY;
-	var za;
-	var zx;
-	var zy;
+	var alpha;
+	var x;
+	var y;
 
-	zx = new Complex128Array([
+	x = new Complex128Array([
 		0.7,   // 4
 		-0.8,  // 4
 		-0.4,  // 3
@@ -604,7 +604,7 @@ tape( 'the function supports complex access patterns', function test( t ) {
 		-0.6,
 		0.6
 	]);
-	zy = new Complex128Array([
+	y = new Complex128Array([
 		0.6,  // 4
 		-0.6, // 4
 		-0.9,
@@ -620,11 +620,11 @@ tape( 'the function supports complex access patterns', function test( t ) {
 		0.8,  // 1
 		-0.7  // 1
 	]);
-	za = new Complex128( 0.4, -0.7 );
+	alpha = new Complex128( 0.4, -0.7 );
 
-	zaxpy( 4, za, zx, -1, 3, zy, -2, 6 );
+	zaxpy( 4, alpha, x, -1, 3, y, -2, 6 );
 
-	viewY = new Float64Array( zy.buffer );
+	viewY = new Float64Array( y.buffer );
 	expected = new Float64Array([
 		0.32,  // 4
 		-1.41, // 4
diff --git a/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.zaxpy.js b/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.zaxpy.js
index 04a541815f42..f57382b5a227 100644
--- a/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.zaxpy.js
+++ b/lib/node_modules/@stdlib/blas/base/zaxpy/test/test.zaxpy.js
@@ -71,14 +71,14 @@ tape( 'the function has an arity of 6', function test( t ) {
 	t.end();
 });
 
-tape( 'the function scales elements from `zx` by `za` and adds the result to `zy`', function test( t ) {
+tape( 'the function scales elements from `x` by `alpha` and adds the result to `y`', function test( t ) {
 	var expected;
 	var viewY;
-	var za;
-	var zx;
-	var zy;
+	var alpha;
+	var x;
+	var y;
 
-	zx = new Complex128Array([
+	x = new Complex128Array([
 		0.7,  // 1
 		-0.8, // 1
 		-0.4, // 2
@@ -94,7 +94,7 @@ tape( 'the function scales elements from `zx` by `za` and adds the result to `zy
 		-0.6,
 		0.6
 	]);
-	zy = new Complex128Array([
+	y = new Complex128Array([
 		0.6,  // 1
 		-0.6, // 1
 		-0.9, // 2
@@ -110,11 +110,11 @@ tape( 'the function scales elements from `zx` by `za` and adds the result to `zy
 		0.8,
 		-0.7
 	]);
-	za = new Complex128( 0.4, -0.7 );
+	alpha = new Complex128( 0.4, -0.7 );
 
-	zaxpy( 4, za, zx, 1, zy, 1 );
+	zaxpy( 4, alpha, x, 1, y, 1 );
 
-	viewY = new Float64Array( zy.buffer );
+	viewY = new Float64Array( y.buffer );
 	expected = new Float64Array([
 		0.32,  // 1
 		-1.41, // 1
@@ -135,14 +135,14 @@ tape( 'the function scales elements from `zx` by `za` and adds the result to `zy
 	t.end();
 });
 
-tape( 'the function supports a `zx` stride', function test( t ) {
+tape( 'the function supports a `x` stride', function test( t ) {
 	var expected;
 	var viewY;
-	var za;
-	var zx;
-	var zy;
+	var alpha;
+	var x;
+	var y;
 
-	zx = new Complex128Array([
+	x = new Complex128Array([
 		0.7,  // 1
 		-0.8, // 1
 		-0.4,
@@ -158,7 +158,7 @@ tape( 'the function supports a `zx` stride', function test( t ) {
 		-0.6, // 4
 		0.6   // 4
 	]);
-	zy = new Complex128Array([
+	y = new Complex128Array([
 		0.6,  // 1
 		-0.6, // 1
 		-0.9, // 2
@@ -174,11 +174,11 @@ tape( 'the function supports a `zx` stride', function test( t ) {
 		0.8,
 		-0.7
 	]);
-	za = new Complex128( 0.4, -0.7 );
+	alpha = new Complex128( 0.4, -0.7 );
 
-	zaxpy( 4, za, zx, 2, zy, 1 );
+	zaxpy( 4, alpha, x, 2, y, 1 );
 
-	viewY = new Float64Array( zy.buffer );
+	viewY = new Float64Array( y.buffer );
 	expected = new Float64Array([
 		0.32,  // 1
 		-1.41, // 1
@@ -199,14 +199,14 @@ tape( 'the function supports a `zx` stride', function test( t ) {
 	t.end();
 });
 
-tape( 'the function supports a `zy` stride', function test( t ) {
+tape( 'the function supports a `y` stride', function test( t ) {
 	var expected;
 	var viewY;
-	var za;
-	var zx;
-	var zy;
+	var alpha;
+	var x;
+	var y;
 
-	zx = new Complex128Array([
+	x = new Complex128Array([
 		0.7,  // 1
 		-0.8, // 1
 		-0.4, // 2
@@ -222,7 +222,7 @@ tape( 'the function supports a `zy` stride', function test( t ) {
 		-0.6,
 		0.6
 	]);
-	zy = new Complex128Array([
+	y = new Complex128Array([
 		0.6,  // 1
 		-0.6, // 1
 		-0.9,
@@ -238,11 +238,11 @@ tape( 'the function supports a `zy` stride', function test( t ) {
 		0.8,  // 4
 		-0.7  // 4
 	]);
-	za = new Complex128( 0.4, -0.7 );
+	alpha = new Complex128( 0.4, -0.7 );
 
-	zaxpy( 4, za, zx, 1, zy, 2 );
+	zaxpy( 4, alpha, x, 1, y, 2 );
 
-	viewY = new Float64Array( zy.buffer );
+	viewY = new Float64Array( y.buffer );
 	expected = new Float64Array([
 		0.32,  // 1
 		-1.41, // 1
@@ -264,39 +264,39 @@ tape( 'the function supports a `zy` stride', function test( t ) {
 });
 
 tape( 'the function returns a reference to the output array', function test( t ) {
+	var alpha;
 	var out;
-	var za;
-	var zx;
-	var zy;
+	var x;
+	var y;
 
-	zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
-	zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
-	za = new Complex128( 2.0, 2.0 );
+	x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+	y = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	alpha = new Complex128( 2.0, 2.0 );
 
-	out = zaxpy( zx.length, za, zx, 1, zy, 1 );
+	out = zaxpy( x.length, alpha, x, 1, y, 1 );
 
-	t.strictEqual( out, zy, 'same reference' );
+	t.strictEqual( out, y, 'same reference' );
 	t.end();
 });
 
-tape( 'if provided `za` parameter equal to `0`, the function returns the second input array unchanged', function test( t ) {
+tape( 'if provided `alpha` parameter equal to `0`, the function returns the second input array unchanged', function test( t ) {
 	var expected;
 	var viewY;
-	var za;
-	var zx;
+	var alpha;
 	var cy;
+	var x;
 
-	zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+	x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
 	cy = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
-	za = new Complex128( 0.0, 0.0 );
+	alpha = new Complex128( 0.0, 0.0 );
 
 	viewY = new Float64Array( cy.buffer );
 	expected = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
 
-	zaxpy( -1, za, zx, 1, 0, cy, 1, 0 );
+	zaxpy( -1, alpha, x, 1, 0, cy, 1, 0 );
 	t.deepEqual( viewY, expected, 'returns expected value' );
 
-	zaxpy( 0, za, zx, 1, 0, cy, 1, 0 );
+	zaxpy( 0, alpha, x, 1, 0, cy, 1, 0 );
 	t.deepEqual( viewY, expected, 'returns expected value' );
 
 	t.end();
@@ -305,34 +305,34 @@ tape( 'if provided `za` parameter equal to `0`, the function returns the second
 tape( 'if provided an `N` parameter less than or equal to `0`, the function returns the second input array unchanged', function test( t ) {
 	var expected;
 	var viewY;
-	var za;
-	var zx;
-	var zy;
+	var alpha;
+	var x;
+	var y;
 
-	zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
-	zy = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
-	za = new Complex128( 2.0, 2.0 );
+	x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+	y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+	alpha = new Complex128( 2.0, 2.0 );
 
-	viewY = new Float64Array( zy.buffer );
+	viewY = new Float64Array( y.buffer );
 	expected = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
 
-	zaxpy( -1, za, zx, 1, zy, 1 );
+	zaxpy( -1, alpha, x, 1, y, 1 );
 	t.deepEqual( viewY, expected, 'returns expected value' );
 
-	zaxpy( 0, za, zx, 1, zy, 1 );
+	zaxpy( 0, alpha, x, 1, y, 1 );
 	t.deepEqual( viewY, expected, 'returns expected value' );
 
 	t.end();
 });
 
-tape( 'the function supports negative `zx` strides', function test( t ) {
+tape( 'the function supports negative `x` strides', function test( t ) {
 	var expected;
 	var viewY;
-	var za;
-	var zx;
-	var zy;
+	var alpha;
+	var x;
+	var y;
 
-	zx = new Complex128Array([
+	x = new Complex128Array([
 		0.7,  // 4
 		-0.8, // 4
 		-0.4,
@@ -348,7 +348,7 @@ tape( 'the function supports negative `zx` strides', function test( t ) {
 		-0.6, // 1
 		0.6   // 1
 	]);
-	zy = new Complex128Array([
+	y = new Complex128Array([
 		0.6,  // 1
 		-0.6, // 1
 		-0.9, // 2
@@ -364,11 +364,11 @@ tape( 'the function supports negative `zx` strides', function test( t ) {
 		0.8,
 		-0.7
 	]);
-	za = new Complex128( 0.4, -0.7 );
+	alpha = new Complex128( 0.4, -0.7 );
 
-	zaxpy( 4, za, zx, -2, zy, 1 );
+	zaxpy( 4, alpha, x, -2, y, 1 );
 
-	viewY = new Float64Array( zy.buffer );
+	viewY = new Float64Array( y.buffer );
 	expected = new Float64Array([
 		0.78,  // 1
 		0.06,  // 1
@@ -389,14 +389,14 @@ tape( 'the function supports negative `zx` strides', function test( t ) {
 	t.end();
 });
 
-tape( 'the function supports negative `zy` strides', function test( t ) {
+tape( 'the function supports negative `y` strides', function test( t ) {
 	var expected;
 	var viewY;
-	var za;
-	var zx;
-	var zy;
+	var alpha;
+	var x;
+	var y;
 
-	zx = new Complex128Array([
+	x = new Complex128Array([
 		0.7,  // 1
 		-0.8, // 1
 		-0.4,
@@ -412,7 +412,7 @@ tape( 'the function supports negative `zy` strides', function test( t ) {
 		-0.6, // 4
 		0.6   // 4
 	]);
-	zy = new Complex128Array([
+	y = new Complex128Array([
 		0.6,  // 4
 		-0.6, // 4
 		-0.9,
@@ -428,11 +428,11 @@ tape( 'the function supports negative `zy` strides', function test( t ) {
 		0.8,  // 1
 		-0.7  // 1
 	]);
-	za = new Complex128( 0.4, -0.7 );
+	alpha = new Complex128( 0.4, -0.7 );
 
-	zaxpy( 4, za, zx, 2, zy, -2 );
+	zaxpy( 4, alpha, x, 2, y, -2 );
 
-	viewY = new Float64Array( zy.buffer );
+	viewY = new Float64Array( y.buffer );
 	expected = new Float64Array([
 		0.78,  // 4
 		0.06,  // 4
@@ -456,11 +456,11 @@ tape( 'the function supports negative `zy` strides', function test( t ) {
 tape( 'the function supports complex access patterns', function test( t ) {
 	var expected;
 	var viewY;
-	var za;
-	var zx;
-	var zy;
+	var alpha;
+	var x;
+	var y;
 
-	zx = new Complex128Array([
+	x = new Complex128Array([
 		0.7,   // 4
 		-0.8,  // 4
 		-0.4,  // 3
@@ -476,7 +476,7 @@ tape( 'the function supports complex access patterns', function test( t ) {
 		-0.6,
 		0.6
 	]);
-	zy = new Complex128Array([
+	y = new Complex128Array([
 		0.6,  // 4
 		-0.6, // 4
 		-0.9,
@@ -492,11 +492,11 @@ tape( 'the function supports complex access patterns', function test( t ) {
 		0.8,  // 1
 		-0.7  // 1
 	]);
-	za = new Complex128( 0.4, -0.7 );
+	alpha = new Complex128( 0.4, -0.7 );
 
-	zaxpy( 4, za, zx, -1, zy, -2 );
+	zaxpy( 4, alpha, x, -1, y, -2 );
 
-	viewY = new Float64Array( zy.buffer );
+	viewY = new Float64Array( y.buffer );
 	expected = new Float64Array([
 		0.32,  // 4
 		-1.41, // 4
@@ -520,14 +520,14 @@ tape( 'the function supports complex access patterns', function test( t ) {
 tape( 'the function supports view offsets', function test( t ) {
 	var expected;
 	var viewY;
-	var zx0;
-	var zy0;
-	var zx1;
-	var zy1;
-	var za;
+	var alpha;
+	var x0;
+	var y0;
+	var x1;
+	var y1;
 
 	// Initial arrays...
-	zx0 = new Complex128Array([
+	x0 = new Complex128Array([
 		1.0,
 		2.0,
 		3.0, // 1
@@ -535,7 +535,7 @@ tape( 'the function supports view offsets', function test( t ) {
 		5.0,
 		6.0
 	]);
-	zy0 = new Complex128Array([
+	y0 = new Complex128Array([
 		1.0,
 		1.0,
 		1.0,
@@ -545,15 +545,15 @@ tape( 'the function supports view offsets', function test( t ) {
 	]);
 
 	// Define a scalar constant:
-	za = new Complex128( 2.0, 2.0 );
+	alpha = new Complex128( 2.0, 2.0 );
 
 	// Create offset views...
-	zx1 = new Complex128Array( zx0.buffer, zx0.BYTES_PER_ELEMENT*1 ); // begin at the 2nd element
-	zy1 = new Complex128Array( zy0.buffer, zy0.BYTES_PER_ELEMENT*2 ); // begin at the 3rd element
+	x1 = new Complex128Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // begin at the 2nd element
+	y1 = new Complex128Array( y0.buffer, y0.BYTES_PER_ELEMENT*2 ); // begin at the 3rd element
 
-	zaxpy( 1, za, zx1, 1, zy1, 1 );
+	zaxpy( 1, alpha, x1, 1, y1, 1 );
 
-	viewY = new Float64Array( zy0.buffer );
+	viewY = new Float64Array( y0.buffer );
 	expected = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, -1.0, 15.0 ] );
 
 	t.deepEqual( viewY, expected, 'returns expected value' );