From f3ff4e48dd6bf83ea032ddabd16d4e9248ef6fa0 Mon Sep 17 00:00:00 2001
From: Ricky Reusser <572717+rreusser@users.noreply.github.com>
Date: Wed, 15 Jan 2025 19:45:10 -0800
Subject: [PATCH 1/5] feat: add blas/base/zrot

---
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: passed
  - 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
---
---
 .../@stdlib/blas/base/zrot/README.md          | 299 ++++++++
 .../blas/base/zrot/benchmark/benchmark.js     | 113 ++++
 .../base/zrot/benchmark/benchmark.ndarray.js  | 113 ++++
 .../@stdlib/blas/base/zrot/docs/repl.txt      | 171 +++++
 .../blas/base/zrot/docs/types/index.d.ts      | 189 ++++++
 .../@stdlib/blas/base/zrot/docs/types/test.ts | 312 +++++++++
 .../@stdlib/blas/base/zrot/examples/index.js  |  46 ++
 .../@stdlib/blas/base/zrot/lib/index.js       | 111 +++
 .../@stdlib/blas/base/zrot/lib/main.js        |  35 +
 .../@stdlib/blas/base/zrot/lib/ndarray.js     | 125 ++++
 .../@stdlib/blas/base/zrot/lib/zrot.js        |  80 +++
 .../@stdlib/blas/base/zrot/package.json       |  77 +++
 .../@stdlib/blas/base/zrot/test/test.js       |  82 +++
 .../blas/base/zrot/test/test.ndarray.js       | 563 +++++++++++++++
 .../@stdlib/blas/base/zrot/test/test.zrot.js  | 639 ++++++++++++++++++
 15 files changed, 2955 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/blas/base/zrot/README.md
 create mode 100644 lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.ndarray.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/zrot/docs/repl.txt
 create mode 100644 lib/node_modules/@stdlib/blas/base/zrot/docs/types/index.d.ts
 create mode 100644 lib/node_modules/@stdlib/blas/base/zrot/docs/types/test.ts
 create mode 100644 lib/node_modules/@stdlib/blas/base/zrot/examples/index.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/zrot/lib/index.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/zrot/lib/main.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/zrot/lib/ndarray.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/zrot/lib/zrot.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/zrot/package.json
 create mode 100644 lib/node_modules/@stdlib/blas/base/zrot/test/test.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/zrot/test/test.ndarray.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/zrot/test/test.zrot.js

diff --git a/lib/node_modules/@stdlib/blas/base/zrot/README.md b/lib/node_modules/@stdlib/blas/base/zrot/README.md
new file mode 100644
index 000000000000..d95a9f704911
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/zrot/README.md
@@ -0,0 +1,299 @@
+<!--
+
+@license Apache-2.0
+
+Copyright (c) 2024 The Stdlib Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+-->
+
+# zrot
+
+> Applies a plane rotation with real cosine and complex sine to a pair of complex vectors.
+
+<section class="usage">
+
+## Usage
+
+```javascript
+var zrot = require( '@stdlib/blas/base/zrot' );
+```
+
+#### zrot( N, zx, strideX, zy, strideY, c, s )
+
+Applies a plane rotation with real cosine and complex sine.
+
+```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 zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+var s = new Complex128( 0.0, 0.75 );
+
+zrot( zx.length, zx, 1, zy, 1, 1.25, s );
+
+var z = zy.get( 0 );
+// returns <Complex128>
+
+var re = real( z );
+// returns ~-1.5
+
+var im = imag( z );
+// returns ~0.75
+
+z = zx.get( 0 );
+// returns <Complex128>
+
+re = real( z );
+// returns ~1.25
+
+im = imag( z );
+// returns ~2.5
+```
+
+The function has the following parameters:
+
+-   **N**: number of indexed elements.
+-   **zx**: first input [`Complex128Array`][@stdlib/array/complex128].
+-   **strideX**: index increment for `zx`.
+-   **zy**: second input [`Complex128Array`][@stdlib/array/complex128].
+-   **strideY**: index increment for `zy`.
+
+The `N` and stride parameters determine how values from `zx` and `zy` are accessed at runtime. For example, to apply a plane rotation to every other element,
+
+```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 zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+var s = new Complex128( 0.0, 0.75 );
+
+zrot( 2, zx, 2, zy, 2, 1.25, s );
+
+var z = zy.get( 0 );
+// returns <Complex128>
+
+var re = real( z );
+// returns ~-1.5
+
+var im = imag( z );
+// returns ~0.75
+
+z = zx.get( 0 );
+// returns <Complex128>
+
+re = real( z );
+// returns ~1.25
+
+im = imag( z );
+// returns ~2.5
+```
+
+Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
+
+<!-- eslint-disable stdlib/capitalized-comments -->
+
+```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' );
+
+// 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( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.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 s = new Complex128( 0.0, 0.75 );
+
+zrot( 2, zx1, -2, zy1, 1, 1.25, s );
+
+var z = zy0.get( 2 );
+// returns <Complex128>
+
+var re = real( z );
+// returns ~-6
+
+var im = imag( z );
+// returns ~5.25
+
+z = zx0.get( 3 );
+// returns <Complex128>
+
+re = real( z );
+// returns ~8.75
+
+im = imag( z );
+// returns ~10
+```
+
+#### zrot.ndarray( N, zx, strideX, offsetX, zy, strideY, offsetY, c, s )
+
+Applies a plane rotation with real cosine and complex sine 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 zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+var s = new Complex128( 0.0, 0.75 );
+
+zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 1.25, s );
+
+var z = zy.get( 0 );
+// returns <Complex128>
+
+var re = real( z );
+// returns ~-1.5
+
+var im = imag( z );
+// returns ~0.75
+
+z = zx.get( 0 );
+// returns <Complex128>
+
+re = real( z );
+// returns ~1.25
+
+im = imag( z );
+// returns ~2.5
+```
+
+The function has the following additional parameters:
+
+-   **offsetX**: starting index for `zx`.
+-   **offsetY**: starting index for `zy`.
+
+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 apply a plane rotation to every other element starting from the second element,
+
+```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 zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+var s = new Complex128( 0.0, 0.75 );
+
+zrot.ndarray( 2, zx, 2, 1, zy, 2, 1, 1.25, s );
+
+var z = zy.get( 3 );
+// returns <Complex128>
+
+var re = real( z );
+// returns ~-6.0
+
+var im = imag( z );
+// returns ~5.25
+
+z = zx.get( 1 );
+// returns <Complex128>
+
+re = real( z );
+// returns ~3.75
+
+im = imag( z );
+// returns ~5.0
+```
+
+</section>
+
+<!-- /.usage -->
+
+<section class="notes">
+
+## Notes
+
+-   If `N <= 0`, both functions leave `zx` and `zy` unchanged.
+-   `zrot()` corresponds to the [BLAS][blas] level 1 function [`zrot`][zrot].
+
+</section>
+
+<!-- /.notes -->
+
+<section class="examples">
+
+## Examples
+
+<!-- eslint no-undef: "error" -->
+
+```javascript
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var zcopy = require( '@stdlib/blas/base/zcopy' );
+var zeros = require( '@stdlib/array/zeros' );
+var logEach = require( '@stdlib/console/log-each' );
+var zrot = require( '@stdlib/blas/base/zrot' );
+
+function rand() {
+    return new Complex128( discreteUniform( 0, 10 ), discreteUniform( -5, 5 ) );
+}
+
+// Generate random input arrays:
+var zx = filledarrayBy( 10, 'complex128', rand );
+var zxc = zcopy( zx.length, zx, 1, zeros( zx.length, 'complex128' ), 1 );
+
+var zy = filledarrayBy( 10, 'complex128', rand );
+var zyc = zcopy( zy.length, zy, 1, zeros( zy.length, 'complex128' ), 1 );
+
+var s = new Complex128( 0.0, 0.75 );
+
+// Apply a plane rotation:
+zrot( zx.length, zx, 1, zy, 1, 1.25, s );
+
+// Print the results:
+logEach( '(%s,%s) => (%s,%s)', zxc, zyc, zx, zy );
+```
+
+</section>
+
+<!-- /.examples -->
+
+<!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
+
+<section class="related">
+
+</section>
+
+<!-- /.related -->
+
+<!-- Section for all links. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="links">
+
+[blas]: http://www.netlib.org/blas
+
+[zrot]: https://netlib.org/lapack/explore-html/d1/d45/group__rot_gaac9d54e7408105ad6f4c810902e75b7a.html#gaac9d54e7408105ad6f4c810902e75b7a
+
+[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
+
+[@stdlib/array/complex128]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/complex128
+
+</section>
+
+<!-- /.links -->
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.js
new file mode 100644
index 000000000000..231b27a078d7
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.js
@@ -0,0 +1,113 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2024 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var reinterpret = require( '@stdlib/strided/base/reinterpret-complex128' );
+var pkg = require( './../package.json' ).name;
+var zrot = require( './../lib/zrot.js' );
+
+
+// VARIABLES //
+
+var options = {
+	'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+	var zx;
+	var zy;
+	var s;
+
+	zx = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) );
+	zy = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) );
+	s = new Complex128( 0.6, 0 );
+
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var viewX;
+		var i;
+
+		viewX = reinterpret( zx, 0 );
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			zrot( zx.length, zx, 1, zy, 1, 0.8, s );
+			if ( isnan( viewX[ i%(len*2) ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( viewX[ i%(len*2) ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var f;
+	var i;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( i = min; i <= max; i++ ) {
+		len = pow( 10, i );
+		f = createBenchmark( len );
+		bench( pkg+':len='+len, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.ndarray.js
new file mode 100644
index 000000000000..434caebdec9e
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.ndarray.js
@@ -0,0 +1,113 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2024 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var reinterpret = require( '@stdlib/strided/base/reinterpret-complex128' );
+var pkg = require( './../package.json' ).name;
+var zrot = require( './../lib/ndarray.js' );
+
+
+// VARIABLES //
+
+var options = {
+	'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+	var zx;
+	var zy;
+	var s;
+
+	zx = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) );
+	zy = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) );
+	s = new Complex128( 0.6, 0 );
+
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var viewX;
+		var i;
+
+		viewX = reinterpret( zx, 0 );
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			zrot( zx.length, zx, 1, 0, zy, 1, 0, 0.8, s );
+			if ( isnan( viewX[ i%(len*2) ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( viewX[ i%(len*2) ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var f;
+	var i;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( i = min; i <= max; i++ ) {
+		len = pow( 10, i );
+		f = createBenchmark( len );
+		bench( pkg+':ndarray:len='+len, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/docs/repl.txt b/lib/node_modules/@stdlib/blas/base/zrot/docs/repl.txt
new file mode 100644
index 000000000000..b5dc25626ef9
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/zrot/docs/repl.txt
@@ -0,0 +1,171 @@
+
+{{alias}}( N, zx, strideX, zy, strideY, c, s )
+    Applies a plane rotation.
+
+    The `N` and stride parameters determine how values in the strided arrays are
+    accessed at runtime.
+
+    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 vectors are unchanged.
+
+    Parameters
+    ----------
+    N: integer
+        Number of indexed elements.
+
+    zx: Complex128Array
+        First input array.
+
+    strideX: integer
+        Index increment for `zx`.
+
+    zy: Complex128Array
+        Second input array.
+
+    strideY: integer
+        Index increment for `zy`.
+
+    c: number
+        Cosine of the angle of rotation.
+
+    s: Complex128
+        Sine of the angle of rotation.
+
+    Returns
+    -------
+    zy: Complex128Array
+        Input array `zy`.
+
+    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}}( [ 0.0, 0.0, 0.0, 0.0 ] );
+    > var s = new {{alias:@stdlib/complex/float64/ctor}}( 0.3, 0.4 );
+    > {{alias}}( zx.length, zx, 1, zy, 1, 0.8, s );
+    > var z = zy.get( 0 );
+    > var re = {{alias:@stdlib/complex/float64/real}}( z )
+    ~-1.1
+    > var im = {{alias:@stdlib/complex/float64/imag}}( z )
+    ~-0.2
+    > z = zx.get( 0 );
+    > re = {{alias:@stdlib/complex/float64/real}}( z )
+    ~0.8
+    > im = {{alias:@stdlib/complex/float64/imag}}( z )
+    ~1.6
+
+    // Advanced indexing:
+    > zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+    > zy = new {{alias:@stdlib/array/complex128}}( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+    > var s = new {{alias:@stdlib/complex/float64/ctor}}( 0.3, 0.4 );
+    > {{alias}}( 2, zx, -2, zy, 1, 0.8, s );
+    > z = zy.get( 0 );
+    > re = {{alias:@stdlib/complex/float64/real}}( z )
+    ~-3.9
+    > im = {{alias:@stdlib/complex/float64/imag}}( z )
+    ~0.2
+    > z = zx.get( 2 );
+    > re = {{alias:@stdlib/complex/float64/real}}( z )
+    ~4.0
+    > im = {{alias:@stdlib/complex/float64/imag}}( z )
+    ~4.8
+
+    // Using typed array views:
+    > var zx0 = new {{alias:@stdlib/array/complex128}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+    > var zy0 = new {{alias:@stdlib/array/complex128}}( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.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*2 );
+    > var s = new {{alias:@stdlib/complex/float64/ctor}}( 0.3, 0.4 );
+    > {{alias}}( 1, zx1, 1, zy1, 1, 0.8, s );
+    > z = zy0.get( 2 );
+    > re = {{alias:@stdlib/complex/float64/real}}( z )
+    ~-2.5
+    > im = {{alias:@stdlib/complex/float64/imag}}( z )
+    ~0.0
+    > z = zx0.get( 1 );
+    > re = {{alias:@stdlib/complex/float64/real}}( z )
+    ~2.4
+    > im = {{alias:@stdlib/complex/float64/imag}}( z )
+    ~3.2
+
+
+{{alias}}.ndarray( N, zx, strideX, offsetX, zy, strideY, offsetY, c, s )
+    Applies a plane rotation using alternative indexing semantics.
+
+    While typed array views mandate a view offset based on the underlying
+    buffer, the offset parameters support indexing semantics based on starting
+    indices.
+
+    Parameters
+    ----------
+    N: integer
+        Number of indexed elements.
+
+    zx: Complex128Array
+        First input array.
+
+    strideX: integer
+        Index increment for `zx`.
+
+    offsetX: integer
+        Starting index for `zx`.
+
+    zy: Complex128Array
+        Second input array.
+
+    strideY: integer
+        Index increment for `zy`.
+
+    offsetY: integer
+        Starting index for `zy`.
+
+    c: number
+        Cosine of the angle of rotation.
+
+    s: Complex128
+        Sine of the angle of rotation.
+
+    Returns
+    -------
+    zy: Complex128Array
+        Input array `zy`.
+
+    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}}( [ 0.0, 0.0, 0.0, 0.0 ] );
+    > var s = new {{alias:@stdlib/complex/float64/ctor}}( 0.3, 0.4 );
+    > {{alias}}.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, s );
+    > var z = zy.get( 0 );
+    > var re = {{alias:@stdlib/complex/float64/real}}( z )
+    ~-1.1
+    > var im = {{alias:@stdlib/complex/float64/imag}}( z )
+    ~-0.2
+    > z = zx.get( 0 );
+    > re = {{alias:@stdlib/complex/float64/real}}( z )
+    ~0.8
+    > im = {{alias:@stdlib/complex/float64/imag}}( z )
+    ~1.6
+
+    // 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}}( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+    > var s = new {{alias:@stdlib/complex/float64/ctor}}( 0.3, 0.4 );
+    > {{alias}}.ndarray( 1, zx, 2, 1, zy, 2, 1, 0.8, s );
+    > z = zy.get( 1 );
+    > re = {{alias:@stdlib/complex/float64/real}}( z )
+    ~-2.5
+    > im = {{alias:@stdlib/complex/float64/imag}}( z )
+    ~0.0
+    > z = zx.get( 1 );
+    > re = {{alias:@stdlib/complex/float64/real}}( z )
+    ~2.4
+    > im = {{alias:@stdlib/complex/float64/imag}}( z )
+    ~3.2
+
+    See Also
+    --------
+
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/base/zrot/docs/types/index.d.ts
new file mode 100644
index 000000000000..5ed7d267606d
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/zrot/docs/types/index.d.ts
@@ -0,0 +1,189 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2024 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+// TypeScript Version: 4.1
+
+/// <reference types="@stdlib/types"/>
+
+import { Complex128Array } from '@stdlib/types/array';
+
+/**
+* Interface describing `zdrot`.
+*/
+interface Routine {
+	/**
+	* Applies a plane rotation.
+	*
+	* @param N - number of indexed elements
+	* @param zx - first input array
+	* @param strideX - `zx` stride length
+	* @param zy - second input array
+	* @param strideY - `zy` stride length
+	* @param c - cosine of the angle of rotation
+	* @param s - sine of the angle of rotation
+	* @returns `zy`
+	*
+	* @example
+	* var Complex128Array = require( '@stdlib/array/complex128' );
+	* 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 zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	*
+	* zdrot( zx.length, zx, 1, zy, 1, 0.8, 0.6 );
+	*
+	* var z = zy.get( 0 );
+	* // returns <Complex128>
+	*
+	* var re = real( z );
+	* // returns -0.6
+	*
+	* var im = imag( z );
+	* // returns -1.2
+	*
+	* z = zx.get( 0 );
+	* // returns <Complex128>
+	*
+	* re = real( z );
+	* // returns 0.8
+	*
+	* im = imag( z );
+	* // returns 1.6
+	*/
+	( N: number, zx: Complex128Array, strideX: number, zy: Complex128Array, strideY: number, c: number, s: number ): Complex128Array;
+
+	/**
+	* Applies a plane rotation using alternative indexing semantics.
+	*
+	* @param N - number of indexed elements
+	* @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 c - cosine of the angle of rotation
+	* @param s - sine of the angle of rotation
+	* @returns `zy`
+	*
+	* @example
+	* var Complex128Array = require( '@stdlib/array/complex128' );
+	* 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 zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	*
+	* zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, 0.6 );
+	*
+	* var z = zy.get( 0 );
+	* // returns <Complex128>
+	*
+	* var re = real( z );
+	* // returns -0.6
+	*
+	* var im = imag( z );
+	* // returns -1.2
+	*
+	* z = zx.get( 0 );
+	* // returns <Complex128>
+	*
+	* re = real( z );
+	* // returns 0.8
+	*
+	* im = imag( z );
+	* // returns 1.6
+	*/
+	ndarray( N: number, zx: Complex128Array, strideX: number, offsetX: number, zy: Complex128Array, strideY: number, offsetY: number, c: number, s: number ): Complex128Array;
+}
+
+/**
+* Applies a plane rotation.
+*
+* @param N - number of indexed elements
+* @param zx - first input array
+* @param strideX - `zx` stride length
+* @param zy - second input array
+* @param strideY - `zy` stride length
+* @param c - cosine of the angle of rotation
+* @param s - sine of the angle of rotation
+* @returns `zy`
+*
+* @example
+* var Complex128Array = require( '@stdlib/array/complex128' );
+* 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 zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+*
+* zdrot( 2, zx, 2, zy, 1, 0.8, 0.6 );
+*
+* var z = zy.get( 0 );
+* // returns <Complex128>
+*
+* var re = real( z );
+* // returns -0.6
+*
+* var im = imag( z );
+* // returns -1.2
+*
+* z = zx.get( 0 );
+* // returns <Complex128>
+*
+* re = real( z );
+* // returns 0.8
+*
+* im = imag( z );
+* // returns 1.6
+*
+* @example
+* var Complex128Array = require( '@stdlib/array/complex128' );
+* 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 zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+*
+* zdrot.ndarray( 2, zx, 2, 0, zy, 1, 0, 0.8, 0.6 );
+*
+* var z = zy.get( 0 );
+* // returns <Complex128>
+*
+* var re = real( z );
+* // returns -0.6
+*
+* var im = imag( z );
+* // returns -1.2
+*
+* z = zx.get( 0 );
+* // returns <Complex128>
+*
+* re = real( z );
+* // returns 0.8
+*
+* im = imag( z );
+* // returns 1.6
+*/
+declare var zdrot: Routine;
+
+
+// EXPORTS //
+
+export = zdrot;
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/docs/types/test.ts b/lib/node_modules/@stdlib/blas/base/zrot/docs/types/test.ts
new file mode 100644
index 000000000000..73eb674da514
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/zrot/docs/types/test.ts
@@ -0,0 +1,312 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2024 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+import Complex128Array = require( '@stdlib/array/complex128' );
+import zdrot = require( './index' );
+
+
+// TESTS //
+
+// The function returns a Complex128Array...
+{
+	const zx = new Complex128Array( 10 );
+	const zy = new Complex128Array( 10 );
+
+	zdrot( zx.length, zx, 1, zy, 1, 0.8, 0.6 ); // $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 );
+
+	zdrot( '10', zx, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( true, zx, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( false, zx, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( null, zx, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( undefined, zx, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( [], zx, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( {}, zx, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( ( zx: number ): number => zx, zx, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not a Complex128Array...
+{
+	const zx = new Complex128Array( 10 );
+	const zy = new Complex128Array( 10 );
+
+	zdrot( zx.length, 10, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, '10', 1, zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, true, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, false, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, null, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, undefined, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, [ '1' ], 1, zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, {}, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, ( zx: number ): number => zx, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a third argument which is not a number...
+{
+	const zx = new Complex128Array( 10 );
+	const zy = new Complex128Array( 10 );
+
+	zdrot( zx.length, zx, '10', zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, true, zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, false, zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, null, zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, undefined, zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, [], zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, {}, zy, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, ( zx: number ): number => zx, zy, 1, 0.8, 0.6 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fourth argument which is not a Complex128Array...
+{
+	const zx = new Complex128Array( 10 );
+
+	zdrot( zx.length, zx, 1, 10, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, 1, '10', 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, 1, true, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, 1, false, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, 1, null, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, 1, undefined, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, 1, [ '1' ], 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, 1, {}, 1, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, 1, ( zx: number ): number => zx, 1, 0.8, 0.6 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fifth argument which is not a number...
+{
+	const zx = new Complex128Array( 10 );
+	const zy = new Complex128Array( 10 );
+
+	zdrot( zx.length, zx, 1, zy, '10', 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, true, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, false, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, null, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, undefined, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, [], 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, {}, 0.8, 0.6 ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, ( zx: number ): number => zx, 0.8, 0.6 ); // $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 );
+
+	zdrot( zx.length, zx, 1, zy, 1, '10', 0.8 ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, 1, true, 0.8 ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, 1, false, 0.8 ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, 1, null, 0.8 ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, 1, undefined, 0.8 ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, 1, [], 0.8 ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, 1, {}, 0.8 ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, 1, ( zx: number ): number => zx, 0.8 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a seventh argument which is not a number...
+{
+	const zx = new Complex128Array( 10 );
+	const zy = new Complex128Array( 10 );
+
+	zdrot( zx.length, zx, 1, zy, 1, 0.8, '10' ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, 1, 0.8, true ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, 1, 0.8, false ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, 1, 0.8, null ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, 1, 0.8, undefined ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, 1, 0.8, [] ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, 1, 0.8, {} ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, 1, 0.8, ( zx: number ): number => zx ); // $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 );
+
+	zdrot(); // $ExpectError
+	zdrot( zx.length ); // $ExpectError
+	zdrot( zx.length, zx ); // $ExpectError
+	zdrot( zx.length, zx, 1 ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, 1, 0.8 ); // $ExpectError
+	zdrot( zx.length, zx, 1, zy, 1, 0.8, 0.6, 10 ); // $ExpectError
+}
+
+// Attached to main export is an `ndarray` method which returns a Complex128Array...
+{
+	const zx = new Complex128Array( 10 );
+	const zy = new Complex128Array( 10 );
+
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $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 );
+
+	zdrot.ndarray( '10', zx, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( true, zx, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( false, zx, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( null, zx, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( undefined, zx, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( [], zx, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( {}, zx, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( ( zx: number ): number => zx, zx, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a second argument which is not a Complex128Array...
+{
+	const zx = new Complex128Array( 10 );
+	const zy = new Complex128Array( 10 );
+
+	zdrot.ndarray( zx.length, 10, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, '10', 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, true, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, false, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, null, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, undefined, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, [ '1' ], 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, {}, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, ( zx: number ): number => zx, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a third argument which is not a number...
+{
+	const zx = new Complex128Array( 10 );
+	const zy = new Complex128Array( 10 );
+
+	zdrot.ndarray( zx.length, zx, '10', 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, true, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, false, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, null, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, undefined, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, [], 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, {}, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, ( zx: number ): number => zx, 0, zy, 1, 0, 0.8, 0.6 ); // $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 );
+
+	zdrot.ndarray( zx.length, zx, 1, '10', zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, true, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, false, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, null, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, undefined, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, [], zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, {}, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, ( zx: number ): number => zx, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a Complex128Array...
+{
+	const zx = new Complex128Array( 10 );
+
+	zdrot.ndarray( zx.length, zx, 1, 0, 10, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, '10', 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, true, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, false, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, null, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, undefined, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, [ '1' ], 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, {}, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, ( zx: number ): number => zx, 1, 0, 0.8, 0.6 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a sixth argument which is not a number...
+{
+	const zx = new Complex128Array( 10 );
+	const zy = new Complex128Array( 10 );
+
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, '10', 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, true, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, false, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, null, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, undefined, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, [], 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, {}, 0, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, ( zx: number ): number => zx, 0, 0.8, 0.6 ); // $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 );
+
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, '10', 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, true, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, false, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, null, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, undefined, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, [], 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, {}, 0.8, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, ( zx: number ): number => zx, 0.8, 0.6 ); // $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 );
+
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, '10', 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, true, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, false, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, null, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, undefined, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, [], 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, {}, 0.6 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, ( zx: number ): number => zx, 0.6 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a ninth argument which is not a number...
+{
+	const zx = new Complex128Array( 10 );
+	const zy = new Complex128Array( 10 );
+
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, '10' ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, true ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, false ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, null ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, undefined ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, [] ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, {} ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, ( zx: number ): number => zx ); // $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 );
+
+	zdrot.ndarray(); // $ExpectError
+	zdrot.ndarray( zx.length ); // $ExpectError
+	zdrot.ndarray( zx.length, zx ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8 ); // $ExpectError
+	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, 0.6, 10 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/examples/index.js b/lib/node_modules/@stdlib/blas/base/zrot/examples/index.js
new file mode 100644
index 000000000000..5f1a13fe5399
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/zrot/examples/index.js
@@ -0,0 +1,46 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2024 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var zcopy = require( '@stdlib/blas/base/zcopy' );
+var zeros = require( '@stdlib/array/zeros' );
+var logEach = require( '@stdlib/console/log-each' );
+var zdrot = require( './../lib' );
+
+function rand() {
+	return new Complex128( discreteUniform( 0, 10 ), discreteUniform( -5, 5 ) );
+}
+
+// Generate random input arrays:
+var zx = filledarrayBy( 10, 'complex128', rand );
+var zxc = zcopy( zx.length, zx, 1, zeros( zx.length, 'complex128' ), 1 );
+
+var zy = filledarrayBy( 10, 'complex128', rand );
+var zyc = zcopy( zy.length, zy, 1, zeros( zy.length, 'complex128' ), 1 );
+
+var s = new Complex128( 0.0, 0.75 );
+
+// Apply a plane rotation:
+zdrot( zx.length, zx, 1, zy, 1, 1.25, s );
+
+// Print the results:
+logEach( '(%s,%s) => (%s,%s)', zxc, zyc, zx, zy );
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/lib/index.js b/lib/node_modules/@stdlib/blas/base/zrot/lib/index.js
new file mode 100644
index 000000000000..5f3c2c758b35
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/zrot/lib/index.js
@@ -0,0 +1,111 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2024 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+/**
+* BLAS level 1 routine to apply a plane rotation with real cosine and complex sine.
+*
+* @module @stdlib/blas/base/zrot
+*
+* @example
+* var Complex128Array = require( '@stdlib/array/complex128' );
+* var Complex128 = require( '@stdlib/complex/float64' );
+* var real = require( '@stdlib/complex/float64/real' );
+* var imag = require( '@stdlib/complex/float64/imag' );
+* var zrot = require( '@stdlib/blas/base/zrot' );
+*
+* var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+* var zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+* var s = new Complex128( 0.6, 0 );
+*
+* zrot( zx.length, zx, 1, zy, 1, 0.8, s );
+*
+* var z = zy.get( 0 );
+* // returns <Complex128>
+*
+* var re = real( z );
+* // returns ~-0.6
+*
+* var im = imag( z );
+* // returns ~-1.2
+*
+* z = zx.get( 0 );
+* // returns <Complex128>
+*
+* re = real( z );
+* // returns ~0.8
+*
+* im = imag( z );
+* // returns ~1.6
+*
+* @example
+* var Complex128Array = require( '@stdlib/array/complex128' );
+* var real = require( '@stdlib/complex/float64/real' );
+* var imag = require( '@stdlib/complex/float64/imag' );
+* var zrot = require( '@stdlib/blas/base/zrot' );
+*
+* var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+* var zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+* var s = new Complex128( 0.6, 0 );
+*
+* zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, s );
+*
+* var z = zy.get( 0 );
+* // returns <Complex128>
+*
+* var re = real( z );
+* // returns ~-0.6
+*
+* var im = imag( z );
+* // returns ~-1.2
+*
+* z = zx.get( 0 );
+* // returns <Complex128>
+*
+* re = real( z );
+* // returns ~0.8
+*
+* im = imag( z );
+* // returns ~1.6
+*/
+
+// MODULES //
+
+var join = require( 'path' ).join;
+var tryRequire = require( '@stdlib/utils/try-require' );
+var isError = require( '@stdlib/assert/is-error' );
+var main = require( './main.js' );
+
+
+// MAIN //
+
+var zrot;
+var tmp = tryRequire( join( __dirname, './native.js' ) );
+if ( isError( tmp ) ) {
+	zrot = main;
+} else {
+	zrot = tmp;
+}
+
+
+// EXPORTS //
+
+module.exports = zrot;
+
+// exports: { "ndarray": "zrot.ndarray" }
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/lib/main.js b/lib/node_modules/@stdlib/blas/base/zrot/lib/main.js
new file mode 100644
index 000000000000..c6615707a1b9
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/zrot/lib/main.js
@@ -0,0 +1,35 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2024 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var zdrot = require( './zrot.js' );
+var ndarray = require( './ndarray.js' );
+
+
+// MAIN //
+
+setReadOnly( zdrot, 'ndarray', ndarray );
+
+
+// EXPORTS //
+
+module.exports = zdrot;
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/lib/ndarray.js b/lib/node_modules/@stdlib/blas/base/zrot/lib/ndarray.js
new file mode 100644
index 000000000000..d5e656fbee45
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/zrot/lib/ndarray.js
@@ -0,0 +1,125 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2024 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var reinterpret = require( '@stdlib/strided/base/reinterpret-complex128' );
+
+
+// MAIN //
+
+/**
+* Applies a plane rotation with real cosine and complex sine.
+*
+* @param {PositiveInteger} N - number of indexed elements
+* @param {Complex128Array} zx - first input array
+* @param {integer} strideX - `zx` stride length
+* @param {NonNegativeInteger} offsetX - starting `zx` index
+* @param {Complex128Array} zy - second input array
+* @param {integer} strideY - `zy` stride length
+* @param {NonNegativeInteger} offsetY - starting `zy` index
+* @param {number} c - cosine of the angle of rotation
+* @param {Complex128} s - sine of the angle of rotation
+* @returns {Complex128Array} `zy`
+*
+* @example
+* 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 zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+* var s = new Complex128( 0.3, 0.4 );
+*
+* zrot( zx.length, zx, 1, 0, zy, 1, 0, 0.8, s );
+*
+* var z = zy.get( 0 );
+* // returns <Complex128>
+*
+* var re = real( z );
+* // returns ~-1.1
+*
+* var im = imag( z );
+* // returns ~-0.2
+*
+* z = zx.get( 0 );
+* // returns <Complex128>
+*
+* re = real( z );
+* // returns ~0.8
+*
+* im = imag( z );
+* // returns ~1.6
+*/
+function zrot( N, zx, strideX, offsetX, zy, strideY, offsetY, c, s ) {
+	var viewX;
+	var viewY;
+	var sr;
+	var si;
+	var sx;
+	var sy;
+	var ix;
+	var iy;
+	var yr;
+	var yi;
+	var xr;
+	var xi;
+	var i;
+
+	if ( N <= 0 ) {
+		return zy;
+	}
+	viewX = reinterpret( zx, 0 );
+	viewY = reinterpret( zy, 0 );
+
+	ix = offsetX * 2;
+	iy = offsetY * 2;
+
+	sx = strideX * 2;
+	sy = strideY * 2;
+
+	sr = s.re;
+	si = s.im;
+
+	for ( i = 0; i < N; i++ ) {
+		yr = viewY[ iy ];
+		yi = viewY[ iy+1 ];
+		xr = viewX[ ix ];
+		xi = viewX[ ix+1 ];
+
+		// Compute tmp = c * zx[ ix ] + s * zy[ iy ]
+		viewX[ ix ] = ( c*xr ) + ( ( sr*yr ) - ( si*yi ) );
+		viewX[ ix+1 ] = ( c*xi ) + ( ( sr*yi ) + ( si*yr ) );
+
+		// Compute zy[ iy ] = c * zy[ iy ] - conj(s) * zx[ ix ]
+		viewY[ iy ] = ( c*yr ) - ( ( sr*xr ) + ( si*xi ) );
+		viewY[ iy+1 ] = ( c*yi ) - ( ( sr*xi ) - ( si*xr ) );
+
+		ix += sx;
+		iy += sy;
+	}
+	return zy;
+}
+
+
+// EXPORTS //
+
+module.exports = zrot;
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/lib/zrot.js b/lib/node_modules/@stdlib/blas/base/zrot/lib/zrot.js
new file mode 100644
index 000000000000..2bb50d62704c
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/zrot/lib/zrot.js
@@ -0,0 +1,80 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2024 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var stride2offset = require( '@stdlib/strided/base/stride2offset' );
+var ndarray = require( './ndarray.js' );
+
+
+// MAIN //
+
+/**
+* Applies a plane rotation with real cosine and complex sine.
+*
+* @param {PositiveInteger} N - number of indexed elements
+* @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 {number} c - cosine of the angle of rotation
+* @param {Complex128} s - sine of the angle of rotation
+* @returns {Complex128Array} `zy`
+*
+* @example
+* 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 zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+* var s = new Complex128( 0.3, 0.4 );
+*
+* zdrot( zx.length, zx, 1, zy, 1, 0.8, s );
+*
+* var z = zy.get( 0 );
+* // returns <Complex128>
+*
+* var re = real( z );
+* // returns ~-1.1
+*
+* var im = imag( z );
+* // returns ~-0.2
+*
+* z = zx.get( 0 );
+* // returns <Complex128>
+*
+* re = real( z );
+* // returns ~0.8
+*
+* im = imag( z );
+* // returns ~1.6
+*/
+function zdrot( N, zx, strideX, zy, strideY, c, s ) {
+	var ix = stride2offset( N, strideX );
+	var iy = stride2offset( N, strideY );
+	return ndarray( N, zx, strideX, ix, zy, strideY, iy, c, s );
+}
+
+
+// EXPORTS //
+
+module.exports = zdrot;
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/package.json b/lib/node_modules/@stdlib/blas/base/zrot/package.json
new file mode 100644
index 000000000000..830b0e01c6ce
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/zrot/package.json
@@ -0,0 +1,77 @@
+{
+  "name": "@stdlib/blas/base/zrot",
+  "version": "0.0.0",
+  "description": "Apply a plane rotation with real cosine and complex sine.",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "The Stdlib Authors",
+    "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+  },
+  "contributors": [
+    {
+      "name": "The Stdlib Authors",
+      "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+    }
+  ],
+  "main": "./lib",
+  "browser": "./lib/main.js",
+  "directories": {
+    "benchmark": "./benchmark",
+    "doc": "./docs",
+    "example": "./examples",
+    "lib": "./lib",
+    "test": "./test"
+  },
+  "types": "./docs/types",
+  "scripts": {},
+  "homepage": "https://github.com/stdlib-js/stdlib",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/stdlib-js/stdlib.git"
+  },
+  "bugs": {
+    "url": "https://github.com/stdlib-js/stdlib/issues"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "engines": {
+    "node": ">=0.10.0",
+    "npm": ">2.7.0"
+  },
+  "os": [
+    "aix",
+    "darwin",
+    "freebsd",
+    "linux",
+    "macos",
+    "openbsd",
+    "sunos",
+    "win32",
+    "windows"
+  ],
+  "keywords": [
+    "stdlib",
+    "stdmath",
+    "mathematics",
+    "math",
+    "blas",
+    "level 1",
+    "linear",
+    "algebra",
+    "subroutines",
+    "zrot",
+    "rotation",
+    "vector",
+    "typed",
+    "array",
+    "ndarray",
+    "complex",
+    "complex128",
+    "double",
+    "float64",
+    "float64array"
+  ],
+  "__stdlib__": {
+    "wasm": false
+  }
+}
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/test/test.js b/lib/node_modules/@stdlib/blas/base/zrot/test/test.js
new file mode 100644
index 000000000000..4e20b3371044
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/zrot/test/test.js
@@ -0,0 +1,82 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2024 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var proxyquire = require( 'proxyquire' );
+var isBrowser = require( '@stdlib/assert/is-browser' );
+var zrot = require( './../lib' );
+
+
+// VARIABLES //
+
+var opts = {
+	'skip': isBrowser
+};
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof zrot, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'attached to the main export is a method providing an ndarray interface', function test( t ) {
+	t.strictEqual( typeof zrot.ndarray, 'function', 'method is a function' );
+	t.end();
+});
+
+tape( 'if a native implementation is available, the main export is the native implementation', opts, function test( t ) {
+	var zrot = proxyquire( './../lib', {
+		'@stdlib/utils/try-require': tryRequire
+	});
+
+	t.strictEqual( zrot, mock, 'returns native implementation' );
+	t.end();
+
+	function tryRequire() {
+		return mock;
+	}
+
+	function mock() {
+		// Mock...
+	}
+});
+
+tape( 'if a native implementation is not available, the main export is a JavaScript implementation', opts, function test( t ) {
+	var zrot;
+	var main;
+
+	main = require( './../lib/zrot.js' );
+
+	zrot = proxyquire( './../lib', {
+		'@stdlib/utils/try-require': tryRequire
+	});
+
+	t.strictEqual( zrot, main, 'returns JavaScript implementation' );
+	t.end();
+
+	function tryRequire() {
+		return new Error( 'Cannot find module' );
+	}
+});
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/zrot/test/test.ndarray.js
new file mode 100644
index 000000000000..f0ecc21dab9b
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/zrot/test/test.ndarray.js
@@ -0,0 +1,563 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2024 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var Float64Array = require( '@stdlib/array/float64' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var EPS = require( '@stdlib/constants/float64/eps' );
+var abs = require( '@stdlib/math/base/special/abs' );
+var zrot = require( './../lib/ndarray.js' );
+
+
+// FUNCTIONS //
+
+/**
+* Tests for element-wise approximate equality.
+*
+* @private
+* @param {Object} t - test object
+* @param {Collection} actual - actual values
+* @param {Collection} expected - expected values
+* @param {number} rtol - relative tolerance
+* @param {number} atol - absolute tolerance
+*/
+function isApprox( t, actual, expected, rtol, atol ) {
+	var absTol;
+	var relTol;
+	var delta;
+	var i;
+
+	t.strictEqual( actual.length, expected.length, 'returns expected value' );
+	for ( i = 0; i < expected.length; i++ ) {
+		if ( actual[ i ] === expected[ i ] ) {
+			t.strictEqual( actual[ i ], expected[ i ], 'returns expected value' );
+		} else {
+			delta = abs( actual[ i ] - expected[ i ] );
+			relTol = rtol * EPS * abs( expected[ i ] );
+			absTol = atol * EPS;
+			t.ok( delta <= relTol || delta < absTol, 'within tolerance. actual: '+actual[ i ]+'. expected: '+expected[ i ]+'. delta: '+delta+'. relative tol: '+relTol+'. absolute tol: '+absTol+'.' );
+		}
+	}
+}
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof zrot, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 9', function test( t ) {
+	t.strictEqual( zrot.length, 9, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function applies a plane rotation', function test( t ) {
+	var viewX;
+	var viewY;
+	var cxe;
+	var cye;
+	var out;
+	var cx;
+	var cy;
+	var s;
+
+	s = new Complex128( 0.6, 0 );
+
+	cx = new Complex128Array([
+		1.0, // 1
+		2.0, // 1
+		3.0, // 2
+		4.0, // 2
+		5.0, // 3
+		6.0, // 3
+		7.0, // 4
+		8.0  // 4
+	]);
+	cy = new Complex128Array([
+		0.0, // 1
+		0.0, // 1
+		0.0, // 2
+		0.0, // 2
+		0.0, // 3
+		0.0, // 3
+		0.0, // 4
+		0.0  // 4
+	]);
+
+	viewX = new Float64Array( cx.buffer );
+	viewY = new Float64Array( cy.buffer );
+
+	cxe = new Float64Array([
+		0.8, // 1
+		1.6, // 1
+		2.4, // 2
+		3.2, // 2
+		4.0, // 3
+		4.8, // 3
+		5.6, // 4
+		6.4  // 4
+	]);
+	cye = new Float64Array([
+		-0.6, // 1
+		-1.2, // 1
+		-1.8, // 2
+		-2.4, // 2
+		-3.0, // 3
+		-3.6, // 3
+		-4.2, // 4
+		-4.8  // 4
+	]);
+
+	out = zrot( cx.length, cx, 1, 0, cy, 1, 0, 0.8, s );
+	isApprox( t, viewX, cxe, 2.0, 0.0 );
+	isApprox( t, viewY, cye, 2.0, 0.0 );
+	t.strictEqual( out, cy, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports an `x` stride', function test( t ) {
+	var viewX;
+	var viewY;
+	var cxe;
+	var cye;
+	var out;
+	var cx;
+	var cy;
+	var s;
+
+	s = new Complex128( 0, 0.6 );
+	cx = new Complex128Array([
+		1.0, // 1
+		2.0, // 1
+		3.0,
+		4.0,
+		5.0, // 2
+		6.0, // 2
+		7.0,
+		8.0
+	]);
+	cy = new Complex128Array([
+		0.0, // 1
+		0.0, // 1
+		0.0, // 2
+		0.0, // 2
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+
+	viewX = new Float64Array( cx.buffer );
+	viewY = new Float64Array( cy.buffer );
+
+	cxe = new Float64Array([
+		0.8, // 1
+		1.6, // 1
+		3.0,
+		4.0,
+		4.0, // 2
+		4.8, // 2
+		7.0,
+		8.0
+	]);
+	cye = new Float64Array([
+		-1.2, // 1
+		0.6,  // 1
+		-3.6, // 2
+		3.0, // 2
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+
+	out = zrot( 2, cx, 2, 0, cy, 1, 0, 0.8, s );
+	isApprox( t, viewX, cxe, 2.0, 0.0 );
+	isApprox( t, viewY, cye, 2.0, 0.0 );
+	t.strictEqual( out, cy, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports an `x` offset', function test( t ) {
+	var viewX;
+	var viewY;
+	var cxe;
+	var cye;
+	var out;
+	var cx;
+	var cy;
+	var s;
+
+	s = new Complex128( 0.3, 0.4 );
+	cx = new Complex128Array([
+		1.0,
+		2.0,
+		3.0, // 1
+		4.0, // 1
+		5.0, // 2
+		6.0, // 2
+		7.0, // 3
+		8.0  // 3
+	]);
+	cy = new Complex128Array([
+		0.0, // 1
+		0.0, // 1
+		0.0, // 2
+		0.0, // 2
+		0.0, // 3
+		0.0, // 3
+		0.0,
+		0.0
+	]);
+
+	viewX = new Float64Array( cx.buffer );
+	viewY = new Float64Array( cy.buffer );
+
+	cxe = new Float64Array([
+		1.0,
+		2.0,
+		2.4, // 1
+		3.2, // 1
+		4.0, // 2
+		4.8, // 2
+		5.6, // 3
+		6.4  // 3
+	]);
+	cye = new Float64Array([
+		-2.5, // 1
+		0.0,  // 1
+		-3.9, // 2
+		0.2,  // 2
+		-5.3, // 3
+		0.4,  // 3
+		0.0,
+		0.0
+	]);
+
+	out = zrot( 3, cx, 1, 1, cy, 1, 0, 0.8, s );
+	isApprox( t, viewX, cxe, 2.0, 0.0 );
+	isApprox( t, viewY, cye, 2.0, 2.0 );
+	t.strictEqual( out, cy, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports a `y` stride', function test( t ) {
+	var viewX;
+	var viewY;
+	var cxe;
+	var cye;
+	var out;
+	var cx;
+	var cy;
+	var s;
+
+	s = new Complex128( 0.3, 0.4 );
+	cx = new Complex128Array([
+		1.0, // 1
+		2.0, // 1
+		3.0, // 2
+		4.0, // 2
+		5.0,
+		6.0,
+		7.0,
+		8.0
+	]);
+	cy = new Complex128Array([
+		0.0, // 1
+		0.0, // 1
+		0.0,
+		0.0,
+		0.0, // 2
+		0.0, // 2
+		0.0,
+		0.0
+	]);
+
+	viewX = new Float64Array( cx.buffer );
+	viewY = new Float64Array( cy.buffer );
+
+	cxe = new Float64Array([
+		0.8, // 1
+		1.6, // 1
+		2.4, // 2
+		3.2, // 2
+		5.0,
+		6.0,
+		7.0,
+		8.0
+	]);
+	cye = new Float64Array([
+		-1.1, // 1
+		-0.2, // 1
+		0.0,
+		0.0,
+		-2.5, // 2
+		0.0,  // 2
+		0.0,
+		0.0
+	]);
+
+	out = zrot( 2, cx, 1, 0, cy, 2, 0, 0.8, s );
+	isApprox( t, viewX, cxe, 2.0, 0.0 );
+	isApprox( t, viewY, cye, 2.0, 2.0 );
+	t.strictEqual( out, cy, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports a `y` offset', function test( t ) {
+	var viewX;
+	var viewY;
+	var cxe;
+	var cye;
+	var out;
+	var cx;
+	var cy;
+	var s;
+
+	s = new Complex128( 0.3, 0.4 );
+	cx = new Complex128Array([
+		1.0, // 1
+		2.0, // 1
+		3.0,
+		4.0,
+		5.0, // 2
+		6.0, // 2
+		7.0,
+		8.0
+	]);
+	cy = new Complex128Array([
+		0.0, // 2
+		0.0, // 2
+		0.0, // 1
+		0.0, // 1
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+
+	viewX = new Float64Array( cx.buffer );
+	viewY = new Float64Array( cy.buffer );
+
+	cxe = new Float64Array([
+		0.8, // 1
+		1.6, // 1
+		3.0,
+		4.0,
+		4.0, // 2
+		4.8, // 2
+		7.0,
+		8.0
+	]);
+	cye = new Float64Array([
+		-3.9, // 2
+		0.2,  // 2
+		-1.1, // 1
+		-0.2, // 1
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+
+	out = zrot( 2, cx, 2, 0, cy, -1, 1, 0.8, s );
+	isApprox( t, viewX, cxe, 2.0, 0.0 );
+	isApprox( t, viewY, cye, 4.0, 0.0 );
+	t.strictEqual( out, cy, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns a reference to the destination array', function test( t ) {
+	var out;
+	var cx;
+	var cy;
+	var s;
+
+	cx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+	cy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	s = new Complex128( 0.3, 0.4 );
+
+	out = zrot( cx.length, cx, 1, 0, cy, 1, 0, 0.8, s );
+
+	t.strictEqual( out, cy, 'returns expected value' );
+	t.end();
+});
+
+tape( 'if provided an `N` parameter less than or equal to `0`, the function returns both vectors unchanged', function test( t ) {
+	var viewX;
+	var viewY;
+	var cxe;
+	var cye;
+	var cx;
+	var cy;
+	var s;
+
+	cx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+	cy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	s = new Complex128( 0.3, 0.4 );
+
+	viewX = new Float64Array( cx.buffer );
+	viewY = new Float64Array( cy.buffer );
+
+	cxe = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+	cye = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+	zrot( -1, cx, 1, 0, cy, 1, 0, 0.8, s );
+	t.deepEqual( viewX, cxe, 'returns expected value' );
+	t.deepEqual( viewY, cye, 'returns expected value' );
+
+	zrot( 0, cx, 1, 0, cy, 1, 0, 0.8, s );
+	t.deepEqual( viewX, cxe, 'returns expected value' );
+	t.deepEqual( viewY, cye, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports negative strides', function test( t ) {
+	var viewX;
+	var viewY;
+	var cxe;
+	var cye;
+	var out;
+	var cx;
+	var cy;
+	var s;
+
+	s = new Complex128( 0.3, 0.4 );
+	cx = new Complex128Array([
+		1.0, // 2
+		2.0, // 2
+		3.0, // 1
+		4.0, // 1
+		5.0,
+		6.0,
+		7.0,
+		8.0
+	]);
+	cy = new Complex128Array([
+		0.0, // 2
+		0.0, // 2
+		0.0,
+		0.0,
+		0.0, // 1
+		0.0, // 1
+		0.0,
+		0.0
+	]);
+
+	viewX = new Float64Array( cx.buffer );
+	viewY = new Float64Array( cy.buffer );
+
+	cxe = new Float64Array([
+		0.8, // 2
+		1.6, // 2
+		2.4, // 1
+		3.2, // 1
+		5.0,
+		6.0,
+		7.0,
+		8.0
+	]);
+	cye = new Float64Array([
+		-1.1, // 2
+		-0.2, // 2
+		0.0,
+		0.0,
+		-2.5, // 1
+		0.0,  // 1
+		0.0,
+		0.0
+	]);
+
+	out = zrot( 2, cx, -1, 1, cy, -2, 2, 0.8, s );
+	isApprox( t, viewX, cxe, 2.0, 0.0 );
+	isApprox( t, viewY, cye, 2.0, 2.0 );
+	t.strictEqual( out, cy, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports complex access patterns', function test( t ) {
+	var viewX;
+	var viewY;
+	var cxe;
+	var cye;
+	var out;
+	var cx;
+	var cy;
+	var s;
+
+	s = new Complex128( 0.3, 0.4 );
+	cx = new Complex128Array([
+		1.0, // 1
+		2.0, // 1
+		3.0,
+		4.0,
+		5.0, // 2
+		6.0, // 2
+		7.0,
+		8.0
+	]);
+	cy = new Complex128Array([
+		0.0, // 1
+		0.0, // 1
+		0.0, // 2
+		0.0, // 2
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+
+	viewX = new Float64Array( cx.buffer );
+	viewY = new Float64Array( cy.buffer );
+
+	cxe = new Float64Array([
+		1.0,
+		2.0,
+		2.4, // 1
+		3.2, // 1
+		5.0,
+		6.0,
+		5.6, // 2
+		6.4  // 2
+	]);
+	cye = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		-2.5, // 1
+		0.0,  // 1
+		-5.3, // 2
+		0.4   // 2
+	]);
+
+	out = zrot( 2, cx, 2, 1, cy, 1, 2, 0.8, s );
+	isApprox( t, viewX, cxe, 2.0, 0.0 );
+	isApprox( t, viewY, cye, 2.0, 2.0 );
+	t.strictEqual( out, cy, 'returns expected value' );
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/test/test.zrot.js b/lib/node_modules/@stdlib/blas/base/zrot/test/test.zrot.js
new file mode 100644
index 000000000000..d02f6f58a728
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/zrot/test/test.zrot.js
@@ -0,0 +1,639 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2024 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var Float64Array = require( '@stdlib/array/float64' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var EPS = require( '@stdlib/constants/float64/eps' );
+var abs = require( '@stdlib/math/base/special/abs' );
+var zrot = require( './../lib/zrot.js' );
+
+
+// FUNCTIONS //
+
+/**
+* Tests for element-wise approximate equality.
+*
+* @private
+* @param {Object} t - test object
+* @param {Collection} actual - actual values
+* @param {Collection} expected - expected values
+* @param {number} rtol - relative tolerance
+* @param {number} atol - absolute tolerance
+*/
+function isApprox( t, actual, expected, rtol, atol ) {
+	var absTol;
+	var relTol;
+	var delta;
+	var i;
+
+	t.strictEqual( actual.length, expected.length, 'returns expected value' );
+	for ( i = 0; i < expected.length; i++ ) {
+		if ( actual[ i ] === expected[ i ] ) {
+			t.strictEqual( actual[ i ], expected[ i ], 'returns expected value' );
+		} else {
+			delta = abs( actual[ i ] - expected[ i ] );
+			relTol = rtol * EPS * abs( expected[ i ] );
+			absTol = atol * EPS;
+			t.ok( delta <= relTol || delta < absTol, 'within tolerance. actual: '+actual[ i ]+'. expected: '+expected[ i ]+'. delta: '+delta+'. relative tol: '+relTol+'. absolute tol: '+absTol+'.' );
+		}
+	}
+}
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof zrot, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 7', function test( t ) {
+	t.strictEqual( zrot.length, 7, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function applies a plane rotation', function test( t ) {
+	var viewX;
+	var viewY;
+	var cxe;
+	var cye;
+	var out;
+	var cx;
+	var cy;
+	var s;
+
+	// Verify in octave with [0.8 0.6; -0.6 0.8] * [1+2i, 3+4i, 5+6i, 7+8i; 0 0 0 0]
+
+	s = new Complex128( 0.6, 0 );
+	cx = new Complex128Array([
+		1.0, // 1
+		2.0, // 1
+		3.0, // 2
+		4.0, // 2
+		5.0, // 3
+		6.0, // 3
+		7.0, // 4
+		8.0  // 4
+	]);
+	cy = new Complex128Array([
+		0.0, // 1
+		0.0, // 1
+		0.0, // 2
+		0.0, // 2
+		0.0, // 3
+		0.0, // 3
+		0.0, // 4
+		0.0  // 4
+	]);
+
+	viewX = new Float64Array( cx.buffer );
+	viewY = new Float64Array( cy.buffer );
+
+	cxe = new Float64Array([
+		0.8, // 1
+		1.6, // 1
+		2.4, // 2
+		3.2, // 2
+		4.0, // 3
+		4.8, // 3
+		5.6, // 4
+		6.4  // 4
+	]);
+	cye = new Float64Array([
+		-0.6, // 1
+		-1.2, // 1
+		-1.8, // 2
+		-2.4, // 2
+		-3.0, // 3
+		-3.6, // 3
+		-4.2, // 4
+		-4.8  // 4
+	]);
+
+	out = zrot( cx.length, cx, 1, cy, 1, 0.8, s );
+	isApprox( t, viewX, cxe, 2.0, 0.0 );
+	isApprox( t, viewY, cye, 2.0, 0.0 );
+	t.strictEqual( out, cy, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function applies a plane rotation', function test( t ) {
+	var viewX;
+	var viewY;
+	var cxe;
+	var cye;
+	var out;
+	var cx;
+	var cy;
+	var s;
+
+	// Verify in octave with [1.25 0.75i; .75i 1.25] * [1+2i, 3+4i, 5+6i, 7+8i; 0 0 0 0]
+
+	s = new Complex128( 0, 0.75 );
+	cx = new Complex128Array([
+		1.0, // 1
+		2.0, // 1
+		3.0, // 2
+		4.0, // 2
+		5.0, // 3
+		6.0, // 3
+		7.0, // 4
+		8.0  // 4
+	]);
+	cy = new Complex128Array([
+		0.0, // 1
+		0.0, // 1
+		0.0, // 2
+		0.0, // 2
+		0.0, // 3
+		0.0, // 3
+		0.0, // 4
+		0.0  // 4
+	]);
+
+	viewX = new Float64Array( cx.buffer );
+	viewY = new Float64Array( cy.buffer );
+
+	cxe = new Float64Array([
+		1.25, // 1
+		2.5,  // 1
+		3.75, // 2
+		5.0,  // 2
+		6.25, // 3
+		7.5,  // 3
+		8.75, // 4
+		10.0  // 4
+	]);
+	cye = new Float64Array([
+		-1.5, // 1
+		0.75, // 1
+		-3.0, // 2
+		2.25, // 2
+		-4.5, // 3
+		3.75, // 3
+		-6.0, // 4
+		5.25  // 4
+	]);
+
+	out = zrot( cx.length, cx, 1, cy, 1, 1.25, s );
+	isApprox( t, viewX, cxe, 2.0, 0.0 );
+	isApprox( t, viewY, cye, 2.0, 0.0 );
+	t.strictEqual( out, cy, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function applies a plane rotation', function test( t ) {
+	var viewX;
+	var viewY;
+	var cxe;
+	var cye;
+	var out;
+	var cx;
+	var cy;
+	var s;
+
+	// Verify in octave with [1.25 0.3+0.4i; -0.3+0.4i 1.25] * [1+2i, 3+4i, 5+6i, 7+8i; 0 0 0 0]
+
+	s = new Complex128( 0.3, 0.4 );
+	cx = new Complex128Array([
+		1.0, // 1
+		2.0, // 1
+		3.0, // 2
+		4.0, // 2
+		5.0, // 3
+		6.0, // 3
+		7.0, // 4
+		8.0  // 4
+	]);
+	cy = new Complex128Array([
+		0.0, // 1
+		0.0, // 1
+		0.0, // 2
+		0.0, // 2
+		0.0, // 3
+		0.0, // 3
+		0.0, // 4
+		0.0  // 4
+	]);
+
+	viewX = new Float64Array( cx.buffer );
+	viewY = new Float64Array( cy.buffer );
+
+	cxe = new Float64Array([
+		1.25, // 1
+		2.5,  // 1
+		3.75, // 2
+		5.0,  // 2
+		6.25, // 3
+		7.5,  // 3
+		8.75, // 4
+		10.0  // 4
+	]);
+	cye = new Float64Array([
+		-1.1, // 1
+		-0.2, // 1
+		-2.5, // 2
+		0.0,  // 2
+		-3.9, // 3
+		0.2,  // 3
+		-5.3, // 4
+		0.4   // 4
+	]);
+
+	out = zrot( cx.length, cx, 1, cy, 1, 1.25, s );
+	isApprox( t, viewX, cxe, 2.0, 0.0 );
+	isApprox( t, viewY, cye, 4.0, 2.0 );
+	t.strictEqual( out, cy, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports an `x` stride', function test( t ) {
+	var viewX;
+	var viewY;
+	var cxe;
+	var cye;
+	var out;
+	var cx;
+	var cy;
+	var s;
+
+	s = new Complex128( 0.3, 0.4 );
+	cx = new Complex128Array([
+		1.0, // 1
+		2.0, // 1
+		3.0,
+		4.0,
+		5.0, // 2
+		6.0, // 2
+		7.0,
+		8.0
+	]);
+	cy = new Complex128Array([
+		0.0, // 1
+		0.0, // 1
+		0.0, // 2
+		0.0, // 2
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+
+	viewX = new Float64Array( cx.buffer );
+	viewY = new Float64Array( cy.buffer );
+
+	cxe = new Float64Array([
+		0.8, // 1
+		1.6, // 1
+		3.0,
+		4.0,
+		4.0, // 2
+		4.8, // 2
+		7.0,
+		8.0
+	]);
+	cye = new Float64Array([
+		-1.1, // 1
+		-0.2, // 1
+		-3.9, // 2
+		0.2,  // 2
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+
+	out = zrot( 2, cx, 2, cy, 1, 0.8, s );
+	isApprox( t, viewX, cxe, 2.0, 0.0 );
+	isApprox( t, viewY, cye, 4.0, 0.0 );
+	t.strictEqual( out, cy, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports a `y` stride', function test( t ) {
+	var viewX;
+	var viewY;
+	var cxe;
+	var cye;
+	var out;
+	var cx;
+	var cy;
+	var s;
+
+	s = new Complex128( 0.3, 0.4 );
+	cx = new Complex128Array([
+		1.0, // 1
+		2.0, // 1
+		3.0, // 2
+		4.0, // 2
+		5.0,
+		6.0,
+		7.0,
+		8.0
+	]);
+	cy = new Complex128Array([
+		0.0, // 1
+		0.0, // 1
+		0.0,
+		0.0,
+		0.0, // 2
+		0.0, // 2
+		0.0,
+		0.0
+	]);
+
+	viewX = new Float64Array( cx.buffer );
+	viewY = new Float64Array( cy.buffer );
+
+	cxe = new Float64Array([
+		0.8, // 1
+		1.6, // 1
+		2.4, // 2
+		3.2, // 2
+		5.0,
+		6.0,
+		7.0,
+		8.0
+	]);
+	cye = new Float64Array([
+		-1.1, // 1
+		-0.2, // 1
+		0.0,
+		0.0,
+		-2.5, // 2
+		0.0,  // 2
+		0.0,
+		0.0
+	]);
+
+	out = zrot( 2, cx, 1, cy, 2, 0.8, s );
+	isApprox( t, viewX, cxe, 2.0, 0.0 );
+	isApprox( t, viewY, cye, 2.0, 2.0 );
+	t.strictEqual( out, cy, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns a reference to the destination array', function test( t ) {
+	var out;
+	var cx;
+	var cy;
+	var s;
+
+	s = new Complex128( 0.3, 0.4 );
+	cx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+	cy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+	out = zrot( cx.length, cx, 1, cy, 1, 0.8, s );
+
+	t.strictEqual( out, cy, 'returns expected value' );
+	t.end();
+});
+
+tape( 'if provided an `N` parameter less than or equal to `0`, the function returns both vectors unchanged', function test( t ) {
+	var viewX;
+	var viewY;
+	var cxe;
+	var cye;
+	var cx;
+	var cy;
+	var s;
+
+	s = new Complex128( 0.3, 0.4 );
+	cx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+	cy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+	viewX = new Float64Array( cx.buffer );
+	viewY = new Float64Array( cy.buffer );
+
+	cxe = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+	cye = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+	zrot( -1, cx, 1, cy, 1, 0.8, s );
+	t.deepEqual( viewX, cxe, 'returns expected value' );
+	t.deepEqual( viewY, cye, 'returns expected value' );
+
+	zrot( 0, cx, 1, cy, 1, 0.8, s );
+	t.deepEqual( viewX, cxe, 'returns expected value' );
+	t.deepEqual( viewY, cye, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports negative strides', function test( t ) {
+	var viewX;
+	var viewY;
+	var cxe;
+	var cye;
+	var out;
+	var cx;
+	var cy;
+	var s;
+
+	s = new Complex128( 0.3, 0.4 );
+	cx = new Complex128Array([
+		1.0, // 2
+		2.0, // 2
+		3.0, // 1
+		4.0, // 1
+		5.0,
+		6.0,
+		7.0,
+		8.0
+	]);
+	cy = new Complex128Array([
+		0.0, // 2
+		0.0, // 2
+		0.0,
+		0.0,
+		0.0, // 1
+		0.0, // 1
+		0.0,
+		0.0
+	]);
+
+	viewX = new Float64Array( cx.buffer );
+	viewY = new Float64Array( cy.buffer );
+
+	cxe = new Float64Array([
+		0.8, // 2
+		1.6, // 2
+		2.4, // 1
+		3.2, // 1
+		5.0,
+		6.0,
+		7.0,
+		8.0
+	]);
+	cye = new Float64Array([
+		-1.1, // 2
+		-0.2, // 2
+		0.0,
+		0.0,
+		-2.5, // 1
+		0.0,  // 1
+		0.0,
+		0.0
+	]);
+
+	out = zrot( 2, cx, -1, cy, -2, 0.8, s );
+	isApprox( t, viewX, cxe, 2.0, 0.0 );
+	isApprox( t, viewY, cye, 2.0, 2.0 );
+	t.strictEqual( out, cy, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports complex access patterns', function test( t ) {
+	var viewX;
+	var viewY;
+	var cxe;
+	var cye;
+	var out;
+	var cx;
+	var cy;
+	var s;
+
+	s = new Complex128( 0.3, 0.4 );
+	cx = new Complex128Array([
+		1.0, // 1
+		2.0, // 1
+		3.0,
+		4.0,
+		5.0, // 2
+		6.0, // 2
+		7.0,
+		8.0
+	]);
+	cy = new Complex128Array([
+		0.0, // 2
+		0.0, // 2
+		0.0, // 1
+		0.0, // 1
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+
+	viewX = new Float64Array( cx.buffer );
+	viewY = new Float64Array( cy.buffer );
+
+	cxe = new Float64Array([
+		0.8, // 1
+		1.6, // 1
+		3.0,
+		4.0,
+		4.0, // 2
+		4.8, // 2
+		7.0,
+		8.0
+	]);
+	cye = new Float64Array([
+		-3.9, // 2
+		0.2,  // 2
+		-1.1, // 1
+		-0.2, // 1
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+
+	out = zrot( 2, cx, 2, cy, -1, 0.8, s );
+	isApprox( t, viewX, cxe, 2.0, 0.0 );
+	isApprox( t, viewY, cye, 4.0, 0.0 );
+	t.strictEqual( out, cy, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports view offsets', function test( t ) {
+	var viewX;
+	var viewY;
+	var cx0;
+	var cy0;
+	var cx1;
+	var cy1;
+	var cxe;
+	var cye;
+	var out;
+	var s;
+
+	s = new Complex128( 0.3, 0.4 );
+
+	// Initial arrays...
+	cx0 = new Complex128Array([
+		1.0,
+		2.0,
+		3.0, // 2
+		4.0, // 2
+		5.0,
+		6.0,
+		7.0, // 1
+		8.0  // 1
+	]);
+	cy0 = new Complex128Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0, // 1
+		0.0, // 1
+		0.0, // 2
+		0.0  // 2
+	]);
+
+	// Create offset views...
+	cx1 = new Complex128Array( cx0.buffer, cx0.BYTES_PER_ELEMENT*1 ); // begin at the 2nd element
+	cy1 = new Complex128Array( cy0.buffer, cy0.BYTES_PER_ELEMENT*2 ); // begin at the 3rd element
+
+	viewX = new Float64Array( cx0.buffer );
+	viewY = new Float64Array( cy0.buffer );
+
+	cxe = new Float64Array([
+		1.0,
+		2.0,
+		2.4, // 2
+		3.2, // 2
+		5.0,
+		6.0,
+		5.6, // 1
+		6.4  // 1
+	]);
+	cye = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		-5.3, // 1
+		0.4, // 1
+		-2.5, // 2
+		0  // 2
+	]);
+
+	out = zrot( 2, cx1, -2, cy1, 1, 0.8, s );
+	isApprox( t, viewX, cxe, 2.0, 0.0 );
+	isApprox( t, viewY, cye, 2.0, 2.0 );
+	t.strictEqual( out, cy1, 'returns expected value' );
+	t.end();
+});

From 650d5ca554975422087f6e04eebbce54b2db0f73 Mon Sep 17 00:00:00 2001
From: Ricky Reusser <572717+rreusser@users.noreply.github.com>
Date: Wed, 15 Jan 2025 20:05:37 -0800
Subject: [PATCH 2/5] fix: fix TypeScript definitions for zrot

---
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: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - 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: 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
---
---
 .../blas/base/zrot/docs/types/index.d.ts      |  43 ++-
 .../@stdlib/blas/base/zrot/docs/types/test.ts | 359 +++++++++---------
 2 files changed, 216 insertions(+), 186 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/base/zrot/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/base/zrot/docs/types/index.d.ts
index 5ed7d267606d..8cfa860ea47c 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/blas/base/zrot/docs/types/index.d.ts
@@ -21,9 +21,10 @@
 /// <reference types="@stdlib/types"/>
 
 import { Complex128Array } from '@stdlib/types/array';
+import { Complex128 } from '@stdlib/types/complex';
 
 /**
-* Interface describing `zdrot`.
+* Interface describing `zrot`.
 */
 interface Routine {
 	/**
@@ -40,22 +41,24 @@ interface Routine {
 	*
 	* @example
 	* var Complex128Array = require( '@stdlib/array/complex128' );
+	* var Complex128 = require( '@stdlib/complex/float64' );
 	* 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 zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	* var s = new Complex128( 0.3, 0.4 );
 	*
-	* zdrot( zx.length, zx, 1, zy, 1, 0.8, 0.6 );
+	* zrot( zx.length, zx, 1, zy, 1, 0.8, s );
 	*
 	* var z = zy.get( 0 );
 	* // returns <Complex128>
 	*
 	* var re = real( z );
-	* // returns -0.6
+	* // returns -1.1
 	*
 	* var im = imag( z );
-	* // returns -1.2
+	* // returns -0.2
 	*
 	* z = zx.get( 0 );
 	* // returns <Complex128>
@@ -66,7 +69,7 @@ interface Routine {
 	* im = imag( z );
 	* // returns 1.6
 	*/
-	( N: number, zx: Complex128Array, strideX: number, zy: Complex128Array, strideY: number, c: number, s: number ): Complex128Array;
+	( N: number, zx: Complex128Array, strideX: number, zy: Complex128Array, strideY: number, c: number, s: Complex128 ): Complex128Array;
 
 	/**
 	* Applies a plane rotation using alternative indexing semantics.
@@ -84,22 +87,24 @@ interface Routine {
 	*
 	* @example
 	* var Complex128Array = require( '@stdlib/array/complex128' );
+	* var Complex128 = require( '@stdlib/complex/float64' );
 	* 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 zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	* var s = new Complex128( 0.3, 0.4 );
 	*
-	* zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, 0.6 );
+	* zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, s );
 	*
 	* var z = zy.get( 0 );
 	* // returns <Complex128>
 	*
 	* var re = real( z );
-	* // returns -0.6
+	* // returns -1.1
 	*
 	* var im = imag( z );
-	* // returns -1.2
+	* // returns -0.2
 	*
 	* z = zx.get( 0 );
 	* // returns <Complex128>
@@ -110,7 +115,7 @@ interface Routine {
 	* im = imag( z );
 	* // returns 1.6
 	*/
-	ndarray( N: number, zx: Complex128Array, strideX: number, offsetX: number, zy: Complex128Array, strideY: number, offsetY: number, c: number, s: number ): Complex128Array;
+	ndarray( N: number, zx: Complex128Array, strideX: number, offsetX: number, zy: Complex128Array, strideY: number, offsetY: number, c: number, s: Complex128 ): Complex128Array;
 }
 
 /**
@@ -127,22 +132,24 @@ interface Routine {
 *
 * @example
 * var Complex128Array = require( '@stdlib/array/complex128' );
+* var Complex128 = require( '@stdlib/complex/float64' );
 * 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 zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+* var s = new Complex128( 0.3, 0.4 );
 *
-* zdrot( 2, zx, 2, zy, 1, 0.8, 0.6 );
+* zrot( 2, zx, 2, zy, 1, 0.8, s );
 *
 * var z = zy.get( 0 );
 * // returns <Complex128>
 *
 * var re = real( z );
-* // returns -0.6
+* // returns -1.1
 *
 * var im = imag( z );
-* // returns -1.2
+* // returns -0.2
 *
 * z = zx.get( 0 );
 * // returns <Complex128>
@@ -155,22 +162,24 @@ interface Routine {
 *
 * @example
 * var Complex128Array = require( '@stdlib/array/complex128' );
+* var Complex128 = require( '@stdlib/complex/float64' );
 * 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 zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+* var s = new Complex128( 0.3, 0.4 );
 *
-* zdrot.ndarray( 2, zx, 2, 0, zy, 1, 0, 0.8, 0.6 );
+* zrot.ndarray( 2, zx, 2, 0, zy, 1, 0, 0.8, s );
 *
 * var z = zy.get( 0 );
 * // returns <Complex128>
 *
 * var re = real( z );
-* // returns -0.6
+* // returns -1.1
 *
 * var im = imag( z );
-* // returns -1.2
+* // returns -0.2
 *
 * z = zx.get( 0 );
 * // returns <Complex128>
@@ -181,9 +190,9 @@ interface Routine {
 * im = imag( z );
 * // returns 1.6
 */
-declare var zdrot: Routine;
+declare var zrot: Routine;
 
 
 // EXPORTS //
 
-export = zdrot;
+export = zrot;
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/docs/types/test.ts b/lib/node_modules/@stdlib/blas/base/zrot/docs/types/test.ts
index 73eb674da514..9ace1c7e058b 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/docs/types/test.ts
+++ b/lib/node_modules/@stdlib/blas/base/zrot/docs/types/test.ts
@@ -17,7 +17,8 @@
 */
 
 import Complex128Array = require( '@stdlib/array/complex128' );
-import zdrot = require( './index' );
+import Complex128 = require( '@stdlib/complex/float64/ctor' );
+import zrot = require( './index' );
 
 
 // TESTS //
@@ -26,257 +27,275 @@ import zdrot = require( './index' );
 {
 	const zx = new Complex128Array( 10 );
 	const zy = new Complex128Array( 10 );
+	const s = new Complex128( 0.3, 0.4 );
 
-	zdrot( zx.length, zx, 1, zy, 1, 0.8, 0.6 ); // $ExpectType Complex128Array
+	zrot( zx.length, zx, 1, zy, 1, 0.8, s ); // $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 );
-
-	zdrot( '10', zx, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( true, zx, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( false, zx, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( null, zx, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( undefined, zx, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( [], zx, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( {}, zx, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( ( zx: number ): number => zx, zx, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
+	const s = new Complex128( 0.3, 0.4 );
+
+	zrot( '10', zx, 1, zy, 1, 0.8, s ); // $ExpectError
+	zrot( true, zx, 1, zy, 1, 0.8, s ); // $ExpectError
+	zrot( false, zx, 1, zy, 1, 0.8, s ); // $ExpectError
+	zrot( null, zx, 1, zy, 1, 0.8, s ); // $ExpectError
+	zrot( undefined, zx, 1, zy, 1, 0.8, s ); // $ExpectError
+	zrot( [], zx, 1, zy, 1, 0.8, s ); // $ExpectError
+	zrot( {}, zx, 1, zy, 1, 0.8, s ); // $ExpectError
+	zrot( ( zx: number ): number => zx, zx, 1, zy, 1, 0.8, s ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided a second argument which is not a Complex128Array...
 {
 	const zx = new Complex128Array( 10 );
 	const zy = new Complex128Array( 10 );
-
-	zdrot( zx.length, 10, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, '10', 1, zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, true, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, false, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, null, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, undefined, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, [ '1' ], 1, zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, {}, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, ( zx: number ): number => zx, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
+	const s = new Complex128( 0.3, 0.4 );
+
+	zrot( zx.length, 10, 1, zy, 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, '10', 1, zy, 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, true, 1, zy, 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, false, 1, zy, 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, null, 1, zy, 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, undefined, 1, zy, 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, [ '1' ], 1, zy, 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, {}, 1, zy, 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, ( zx: number ): number => zx, 1, zy, 1, 0.8, s ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided a third argument which is not a number...
 {
 	const zx = new Complex128Array( 10 );
 	const zy = new Complex128Array( 10 );
-
-	zdrot( zx.length, zx, '10', zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, true, zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, false, zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, null, zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, undefined, zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, [], zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, {}, zy, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, ( zx: number ): number => zx, zy, 1, 0.8, 0.6 ); // $ExpectError
+	const s = new Complex128( 0.3, 0.4 );
+
+	zrot( zx.length, zx, '10', zy, 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, zx, true, zy, 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, zx, false, zy, 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, zx, null, zy, 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, zx, undefined, zy, 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, zx, [], zy, 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, zx, {}, zy, 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, zx, ( zx: number ): number => zx, zy, 1, 0.8, s ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided a fourth argument which is not a Complex128Array...
 {
 	const zx = new Complex128Array( 10 );
-
-	zdrot( zx.length, zx, 1, 10, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, 1, '10', 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, 1, true, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, 1, false, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, 1, null, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, 1, undefined, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, 1, [ '1' ], 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, 1, {}, 1, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, 1, ( zx: number ): number => zx, 1, 0.8, 0.6 ); // $ExpectError
+	const s = new Complex128( 0.3, 0.4 );
+
+	zrot( zx.length, zx, 1, 10, 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, zx, 1, '10', 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, zx, 1, true, 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, zx, 1, false, 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, zx, 1, null, 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, zx, 1, undefined, 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, zx, 1, [ '1' ], 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, zx, 1, {}, 1, 0.8, s ); // $ExpectError
+	zrot( zx.length, zx, 1, ( zx: number ): number => zx, 1, 0.8, s ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided a fifth argument which is not a number...
 {
 	const zx = new Complex128Array( 10 );
 	const zy = new Complex128Array( 10 );
-
-	zdrot( zx.length, zx, 1, zy, '10', 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, true, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, false, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, null, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, undefined, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, [], 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, {}, 0.8, 0.6 ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, ( zx: number ): number => zx, 0.8, 0.6 ); // $ExpectError
+	const s = new Complex128( 0.3, 0.4 );
+
+	zrot( zx.length, zx, 1, zy, '10', 0.8, 0.6 ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, true, 0.8, s ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, false, 0.8, s ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, null, 0.8, s ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, undefined, 0.8, s ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, [], 0.8, s ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, {}, 0.8, s ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, ( zx: number ): number => zx, 0.8, s ); // $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 );
-
-	zdrot( zx.length, zx, 1, zy, 1, '10', 0.8 ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, 1, true, 0.8 ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, 1, false, 0.8 ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, 1, null, 0.8 ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, 1, undefined, 0.8 ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, 1, [], 0.8 ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, 1, {}, 0.8 ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, 1, ( zx: number ): number => zx, 0.8 ); // $ExpectError
+	const s = new Complex128( 0.3, 0.4 );
+
+	zrot( zx.length, zx, 1, zy, 1, '10', s ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, 1, true, s ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, 1, false, s ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, 1, null, s ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, 1, undefined, s ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, 1, [], s ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, 1, {}, s ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, 1, ( zx: number ): number => zx, s ); // $ExpectError
 }
 
-// The compiler throws an error if the function is provided a seventh argument which is not a number...
+// The compiler throws an error if the function is provided a seventh argument which is not a Complex128...
 {
 	const zx = new Complex128Array( 10 );
 	const zy = new Complex128Array( 10 );
 
-	zdrot( zx.length, zx, 1, zy, 1, 0.8, '10' ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, 1, 0.8, true ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, 1, 0.8, false ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, 1, 0.8, null ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, 1, 0.8, undefined ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, 1, 0.8, [] ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, 1, 0.8, {} ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, 1, 0.8, ( zx: number ): number => zx ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, 1, 0.8, 0.6 ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, 1, 0.8, '10' ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, 1, 0.8, true ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, 1, 0.8, false ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, 1, 0.8, null ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, 1, 0.8, undefined ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, 1, 0.8, [] ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, 1, 0.8, {} ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, 1, 0.8, ( zx: number ): number => zx ); // $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 );
-
-	zdrot(); // $ExpectError
-	zdrot( zx.length ); // $ExpectError
-	zdrot( zx.length, zx ); // $ExpectError
-	zdrot( zx.length, zx, 1 ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, 1, 0.8 ); // $ExpectError
-	zdrot( zx.length, zx, 1, zy, 1, 0.8, 0.6, 10 ); // $ExpectError
+	const s = new Complex128( 0.3, 0.4 );
+
+	zrot(); // $ExpectError
+	zrot( zx.length ); // $ExpectError
+	zrot( zx.length, zx ); // $ExpectError
+	zrot( zx.length, zx, 1 ); // $ExpectError
+	zrot( zx.length, zx, 1, zy ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, 1, 0.8 ); // $ExpectError
+	zrot( zx.length, zx, 1, zy, 1, 0.8, s, 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 s = new Complex128( 0.3, 0.4 );
 
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectType Complex128Array
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, s ); // $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 );
-
-	zdrot.ndarray( '10', zx, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( true, zx, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( false, zx, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( null, zx, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( undefined, zx, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( [], zx, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( {}, zx, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( ( zx: number ): number => zx, zx, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	const s = new Complex128( 0.3, 0.4 );
+
+	zrot.ndarray( '10', zx, 1, 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( true, zx, 1, 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( false, zx, 1, 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( null, zx, 1, 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( undefined, zx, 1, 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( [], zx, 1, 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( {}, zx, 1, 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( ( zx: number ): number => zx, zx, 1, 0, zy, 1, 0, 0.8, s ); // $ExpectError
 }
 
 // The compiler throws an error if the `ndarray` method is provided a second argument which is not a Complex128Array...
 {
 	const zx = new Complex128Array( 10 );
 	const zy = new Complex128Array( 10 );
-
-	zdrot.ndarray( zx.length, 10, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, '10', 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, true, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, false, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, null, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, undefined, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, [ '1' ], 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, {}, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, ( zx: number ): number => zx, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	const s = new Complex128( 0.3, 0.4 );
+
+	zrot.ndarray( zx.length, 10, 1, 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, '10', 1, 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, true, 1, 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, false, 1, 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, null, 1, 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, undefined, 1, 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, [ '1' ], 1, 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, {}, 1, 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, ( zx: number ): number => zx, 1, 0, zy, 1, 0, 0.8, s ); // $ExpectError
 }
 
 // The compiler throws an error if the `ndarray` method is provided a third argument which is not a number...
 {
 	const zx = new Complex128Array( 10 );
 	const zy = new Complex128Array( 10 );
-
-	zdrot.ndarray( zx.length, zx, '10', 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, true, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, false, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, null, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, undefined, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, [], 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, {}, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, ( zx: number ): number => zx, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	const s = new Complex128( 0.3, 0.4 );
+
+	zrot.ndarray( zx.length, zx, '10', 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, true, 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, false, 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, null, 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, undefined, 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, [], 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, {}, 0, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, ( zx: number ): number => zx, 0, zy, 1, 0, 0.8, s ); // $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 );
-
-	zdrot.ndarray( zx.length, zx, 1, '10', zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, true, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, false, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, null, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, undefined, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, [], zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, {}, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, ( zx: number ): number => zx, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	const s = new Complex128( 0.3, 0.4 );
+
+	zrot.ndarray( zx.length, zx, 1, '10', zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, true, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, false, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, null, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, undefined, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, [], zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, {}, zy, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, ( zx: number ): number => zx, zy, 1, 0, 0.8, s ); // $ExpectError
 }
 
 // The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a Complex128Array...
 {
 	const zx = new Complex128Array( 10 );
-
-	zdrot.ndarray( zx.length, zx, 1, 0, 10, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, '10', 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, true, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, false, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, null, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, undefined, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, [ '1' ], 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, {}, 1, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, ( zx: number ): number => zx, 1, 0, 0.8, 0.6 ); // $ExpectError
+	const s = new Complex128( 0.3, 0.4 );
+
+	zrot.ndarray( zx.length, zx, 1, 0, 10, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, '10', 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, true, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, false, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, null, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, undefined, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, [ '1' ], 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, {}, 1, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, ( zx: number ): number => zx, 1, 0, 0.8, s ); // $ExpectError
 }
 
 // The compiler throws an error if the `ndarray` method is provided a sixth argument which is not a number...
 {
 	const zx = new Complex128Array( 10 );
 	const zy = new Complex128Array( 10 );
-
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, '10', 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, true, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, false, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, null, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, undefined, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, [], 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, {}, 0, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, ( zx: number ): number => zx, 0, 0.8, 0.6 ); // $ExpectError
+	const s = new Complex128( 0.3, 0.4 );
+
+	zrot.ndarray( zx.length, zx, 1, 0, zy, '10', 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, true, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, false, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, null, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, undefined, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, [], 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, {}, 0, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, ( zx: number ): number => zx, 0, 0.8, s ); // $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 );
-
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, '10', 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, true, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, false, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, null, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, undefined, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, [], 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, {}, 0.8, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, ( zx: number ): number => zx, 0.8, 0.6 ); // $ExpectError
+	const s = new Complex128( 0.3, 0.4 );
+
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, '10', 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, true, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, false, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, null, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, undefined, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, [], 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, {}, 0.8, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, ( zx: number ): number => zx, 0.8, s ); // $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 );
-
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, '10', 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, true, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, false, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, null, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, undefined, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, [], 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, {}, 0.6 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, ( zx: number ): number => zx, 0.6 ); // $ExpectError
+	const s = new Complex128( 0.3, 0.4 );
+
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, '10', s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, true, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, false, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, null, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, undefined, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, [], s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, {}, s ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, ( zx: number ): number => zx, s ); // $ExpectError
 }
 
 // The compiler throws an error if the `ndarray` method is provided a ninth argument which is not a number...
@@ -284,29 +303,31 @@ import zdrot = require( './index' );
 	const zx = new Complex128Array( 10 );
 	const zy = new Complex128Array( 10 );
 
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, '10' ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, true ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, false ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, null ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, undefined ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, [] ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, {} ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, ( zx: number ): number => zx ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, 0.6 ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, '10' ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, true ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, false ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, null ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, undefined ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, [] ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, {} ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, ( zx: number ): number => zx ); // $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 );
-
-	zdrot.ndarray(); // $ExpectError
-	zdrot.ndarray( zx.length ); // $ExpectError
-	zdrot.ndarray( zx.length, zx ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8 ); // $ExpectError
-	zdrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, 0.6, 10 ); // $ExpectError
+	const s = new Complex128( 0.3, 0.4 );
+
+	zrot.ndarray(); // $ExpectError
+	zrot.ndarray( zx.length ); // $ExpectError
+	zrot.ndarray( zx.length, zx ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1 ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0 ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1 ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0 ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8 ); // $ExpectError
+	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, 0.8, s, 10 ); // $ExpectError
 }

From 6e918fbe831972976ac3782d5090a8c48332f60c Mon Sep 17 00:00:00 2001
From: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com>
Date: Thu, 16 Jan 2025 17:22:04 +0000
Subject: [PATCH 3/5] chore: update copyright years

---
 lib/node_modules/@stdlib/blas/base/zrot/README.md               | 2 +-
 lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.js  | 2 +-
 .../@stdlib/blas/base/zrot/benchmark/benchmark.ndarray.js       | 2 +-
 lib/node_modules/@stdlib/blas/base/zrot/docs/types/index.d.ts   | 2 +-
 lib/node_modules/@stdlib/blas/base/zrot/docs/types/test.ts      | 2 +-
 lib/node_modules/@stdlib/blas/base/zrot/examples/index.js       | 2 +-
 lib/node_modules/@stdlib/blas/base/zrot/lib/index.js            | 2 +-
 lib/node_modules/@stdlib/blas/base/zrot/lib/main.js             | 2 +-
 lib/node_modules/@stdlib/blas/base/zrot/lib/ndarray.js          | 2 +-
 lib/node_modules/@stdlib/blas/base/zrot/lib/zrot.js             | 2 +-
 lib/node_modules/@stdlib/blas/base/zrot/test/test.js            | 2 +-
 lib/node_modules/@stdlib/blas/base/zrot/test/test.ndarray.js    | 2 +-
 lib/node_modules/@stdlib/blas/base/zrot/test/test.zrot.js       | 2 +-
 13 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/base/zrot/README.md b/lib/node_modules/@stdlib/blas/base/zrot/README.md
index d95a9f704911..79225d5f5c78 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/README.md
+++ b/lib/node_modules/@stdlib/blas/base/zrot/README.md
@@ -2,7 +2,7 @@
 
 @license Apache-2.0
 
-Copyright (c) 2024 The Stdlib Authors.
+Copyright (c) 2025 The Stdlib Authors.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.js
index 231b27a078d7..53e9b0764e8e 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.js
+++ b/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2024 The Stdlib Authors.
+* Copyright (c) 2025 The Stdlib Authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.ndarray.js
index 434caebdec9e..f413c2eb9995 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.ndarray.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2024 The Stdlib Authors.
+* Copyright (c) 2025 The Stdlib Authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/base/zrot/docs/types/index.d.ts
index 8cfa860ea47c..ed2afac3eb50 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/blas/base/zrot/docs/types/index.d.ts
@@ -1,7 +1,7 @@
 /*
 * @license Apache-2.0
 *
-* Copyright (c) 2024 The Stdlib Authors.
+* Copyright (c) 2025 The Stdlib Authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/docs/types/test.ts b/lib/node_modules/@stdlib/blas/base/zrot/docs/types/test.ts
index 9ace1c7e058b..3f676d725e7d 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/docs/types/test.ts
+++ b/lib/node_modules/@stdlib/blas/base/zrot/docs/types/test.ts
@@ -1,7 +1,7 @@
 /*
 * @license Apache-2.0
 *
-* Copyright (c) 2024 The Stdlib Authors.
+* Copyright (c) 2025 The Stdlib Authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/examples/index.js b/lib/node_modules/@stdlib/blas/base/zrot/examples/index.js
index 5f1a13fe5399..a4f495ccd0c4 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/examples/index.js
+++ b/lib/node_modules/@stdlib/blas/base/zrot/examples/index.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2024 The Stdlib Authors.
+* Copyright (c) 2025 The Stdlib Authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/lib/index.js b/lib/node_modules/@stdlib/blas/base/zrot/lib/index.js
index 5f3c2c758b35..9bf00294023d 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/lib/index.js
+++ b/lib/node_modules/@stdlib/blas/base/zrot/lib/index.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2024 The Stdlib Authors.
+* Copyright (c) 2025 The Stdlib Authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/lib/main.js b/lib/node_modules/@stdlib/blas/base/zrot/lib/main.js
index c6615707a1b9..f98e4d25c4fe 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/lib/main.js
+++ b/lib/node_modules/@stdlib/blas/base/zrot/lib/main.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2024 The Stdlib Authors.
+* Copyright (c) 2025 The Stdlib Authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/lib/ndarray.js b/lib/node_modules/@stdlib/blas/base/zrot/lib/ndarray.js
index d5e656fbee45..679088663b5a 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/lib/ndarray.js
+++ b/lib/node_modules/@stdlib/blas/base/zrot/lib/ndarray.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2024 The Stdlib Authors.
+* Copyright (c) 2025 The Stdlib Authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/lib/zrot.js b/lib/node_modules/@stdlib/blas/base/zrot/lib/zrot.js
index 2bb50d62704c..ff97bda16817 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/lib/zrot.js
+++ b/lib/node_modules/@stdlib/blas/base/zrot/lib/zrot.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2024 The Stdlib Authors.
+* Copyright (c) 2025 The Stdlib Authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/test/test.js b/lib/node_modules/@stdlib/blas/base/zrot/test/test.js
index 4e20b3371044..d5a2b3ddef8a 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/test/test.js
+++ b/lib/node_modules/@stdlib/blas/base/zrot/test/test.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2024 The Stdlib Authors.
+* Copyright (c) 2025 The Stdlib Authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/zrot/test/test.ndarray.js
index f0ecc21dab9b..aa35139a8bc2 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/base/zrot/test/test.ndarray.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2024 The Stdlib Authors.
+* Copyright (c) 2025 The Stdlib Authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/test/test.zrot.js b/lib/node_modules/@stdlib/blas/base/zrot/test/test.zrot.js
index d02f6f58a728..e4bb74572b68 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/test/test.zrot.js
+++ b/lib/node_modules/@stdlib/blas/base/zrot/test/test.zrot.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2024 The Stdlib Authors.
+* Copyright (c) 2025 The Stdlib Authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.

From fd286df04c20726c04bf2f451a8c443ae79ebb13 Mon Sep 17 00:00:00 2001
From: Athan Reines <kgryte@gmail.com>
Date: Fri, 17 Jan 2025 17:51:30 -0800
Subject: [PATCH 4/5] chore: clean-up

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - 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
---
---
 .../blas/base/zrot/benchmark/benchmark.js     |  3 +-
 .../base/zrot/benchmark/benchmark.ndarray.js  |  3 +-
 .../@stdlib/blas/base/zrot/docs/repl.txt      |  5 ++-
 .../blas/base/zrot/docs/types/index.d.ts      | 38 +++++++++----------
 .../@stdlib/blas/base/zrot/docs/types/test.ts |  4 +-
 .../@stdlib/blas/base/zrot/examples/index.js  |  4 +-
 .../@stdlib/blas/base/zrot/lib/main.js        |  6 +--
 .../@stdlib/blas/base/zrot/lib/ndarray.js     |  6 ++-
 .../@stdlib/blas/base/zrot/lib/zrot.js        |  6 +--
 .../blas/base/zrot/test/test.ndarray.js       |  8 ++--
 .../@stdlib/blas/base/zrot/test/test.zrot.js  | 10 ++---
 11 files changed, 49 insertions(+), 44 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.js
index 53e9b0764e8e..0bac7ae7b0f2 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.js
+++ b/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.js
@@ -54,7 +54,7 @@ function createBenchmark( len ) {
 
 	zx = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) );
 	zy = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) );
-	s = new Complex128( 0.6, 0 );
+	s = new Complex128( 0.6, 0.0 );
 
 	return benchmark;
 
@@ -69,6 +69,7 @@ function createBenchmark( len ) {
 		var i;
 
 		viewX = reinterpret( zx, 0 );
+
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
 			zrot( zx.length, zx, 1, zy, 1, 0.8, s );
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.ndarray.js
index f413c2eb9995..1e55a28db4cc 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.ndarray.js
@@ -54,7 +54,7 @@ function createBenchmark( len ) {
 
 	zx = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) );
 	zy = new Complex128Array( uniform( len*2, -100.0, 100.0, options ) );
-	s = new Complex128( 0.6, 0 );
+	s = new Complex128( 0.6, 0.0 );
 
 	return benchmark;
 
@@ -69,6 +69,7 @@ function createBenchmark( len ) {
 		var i;
 
 		viewX = reinterpret( zx, 0 );
+
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
 			zrot( zx.length, zx, 1, 0, zy, 1, 0, 0.8, s );
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/docs/repl.txt b/lib/node_modules/@stdlib/blas/base/zrot/docs/repl.txt
index b5dc25626ef9..e4c4ec8d333f 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/docs/repl.txt
+++ b/lib/node_modules/@stdlib/blas/base/zrot/docs/repl.txt
@@ -1,6 +1,6 @@
 
 {{alias}}( N, zx, strideX, zy, strideY, c, s )
-    Applies a plane rotation.
+    Applies a plane rotation with real cosine and complex sine.
 
     The `N` and stride parameters determine how values in the strided arrays are
     accessed at runtime.
@@ -92,7 +92,8 @@
 
 
 {{alias}}.ndarray( N, zx, strideX, offsetX, zy, strideY, offsetY, c, s )
-    Applies a plane rotation using alternative indexing semantics.
+    Applies a plane rotation with real cosine and complex sine using alternative
+    indexing semantics.
 
     While typed array views mandate a view offset based on the underlying
     buffer, the offset parameters support indexing semantics based on starting
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/base/zrot/docs/types/index.d.ts
index ed2afac3eb50..3e8b67a2c342 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/blas/base/zrot/docs/types/index.d.ts
@@ -28,7 +28,7 @@ import { Complex128 } from '@stdlib/types/complex';
 */
 interface Routine {
 	/**
-	* Applies a plane rotation.
+	* Applies a plane rotation with real cosine and complex sine.
 	*
 	* @param N - number of indexed elements
 	* @param zx - first input array
@@ -55,24 +55,24 @@ interface Routine {
 	* // returns <Complex128>
 	*
 	* var re = real( z );
-	* // returns -1.1
+	* // returns ~-1.1
 	*
 	* var im = imag( z );
-	* // returns -0.2
+	* // returns ~-0.2
 	*
 	* z = zx.get( 0 );
 	* // returns <Complex128>
 	*
 	* re = real( z );
-	* // returns 0.8
+	* // returns ~0.8
 	*
 	* im = imag( z );
-	* // returns 1.6
+	* // returns ~1.6
 	*/
 	( N: number, zx: Complex128Array, strideX: number, zy: Complex128Array, strideY: number, c: number, s: Complex128 ): Complex128Array;
 
 	/**
-	* Applies a plane rotation using alternative indexing semantics.
+	* Applies a plane rotation with real cosine and complex sine using alternative indexing semantics.
 	*
 	* @param N - number of indexed elements
 	* @param zx - first input array
@@ -101,25 +101,25 @@ interface Routine {
 	* // returns <Complex128>
 	*
 	* var re = real( z );
-	* // returns -1.1
+	* // returns ~-1.1
 	*
 	* var im = imag( z );
-	* // returns -0.2
+	* // returns ~-0.2
 	*
 	* z = zx.get( 0 );
 	* // returns <Complex128>
 	*
 	* re = real( z );
-	* // returns 0.8
+	* // returns ~0.8
 	*
 	* im = imag( z );
-	* // returns 1.6
+	* // returns ~1.6
 	*/
 	ndarray( N: number, zx: Complex128Array, strideX: number, offsetX: number, zy: Complex128Array, strideY: number, offsetY: number, c: number, s: Complex128 ): Complex128Array;
 }
 
 /**
-* Applies a plane rotation.
+* Applies a plane rotation with real cosine and complex sine.
 *
 * @param N - number of indexed elements
 * @param zx - first input array
@@ -146,19 +146,19 @@ interface Routine {
 * // returns <Complex128>
 *
 * var re = real( z );
-* // returns -1.1
+* // returns ~-1.1
 *
 * var im = imag( z );
-* // returns -0.2
+* // returns ~-0.2
 *
 * z = zx.get( 0 );
 * // returns <Complex128>
 *
 * re = real( z );
-* // returns 0.8
+* // returns ~0.8
 *
 * im = imag( z );
-* // returns 1.6
+* // returns ~1.6
 *
 * @example
 * var Complex128Array = require( '@stdlib/array/complex128' );
@@ -176,19 +176,19 @@ interface Routine {
 * // returns <Complex128>
 *
 * var re = real( z );
-* // returns -1.1
+* // returns ~-1.1
 *
 * var im = imag( z );
-* // returns -0.2
+* // returns ~-0.2
 *
 * z = zx.get( 0 );
 * // returns <Complex128>
 *
 * re = real( z );
-* // returns 0.8
+* // returns ~0.8
 *
 * im = imag( z );
-* // returns 1.6
+* // returns ~1.6
 */
 declare var zrot: Routine;
 
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/docs/types/test.ts b/lib/node_modules/@stdlib/blas/base/zrot/docs/types/test.ts
index 3f676d725e7d..9233650e4bad 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/docs/types/test.ts
+++ b/lib/node_modules/@stdlib/blas/base/zrot/docs/types/test.ts
@@ -129,7 +129,7 @@ import zrot = require( './index' );
 	zrot( zx.length, zx, 1, zy, 1, ( zx: number ): number => zx, s ); // $ExpectError
 }
 
-// The compiler throws an error if the function is provided a seventh argument which is not a Complex128...
+// The compiler throws an error if the function is provided a seventh argument which is not a complex number...
 {
 	const zx = new Complex128Array( 10 );
 	const zy = new Complex128Array( 10 );
@@ -298,7 +298,7 @@ import zrot = require( './index' );
 	zrot.ndarray( zx.length, zx, 1, 0, zy, 1, 0, ( zx: number ): number => zx, s ); // $ExpectError
 }
 
-// The compiler throws an error if the `ndarray` method is provided a ninth argument which is not a number...
+// The compiler throws an error if the `ndarray` method is provided a ninth argument which is not a complex number...
 {
 	const zx = new Complex128Array( 10 );
 	const zy = new Complex128Array( 10 );
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/examples/index.js b/lib/node_modules/@stdlib/blas/base/zrot/examples/index.js
index a4f495ccd0c4..6919a098b7eb 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/examples/index.js
+++ b/lib/node_modules/@stdlib/blas/base/zrot/examples/index.js
@@ -24,7 +24,7 @@ var Complex128 = require( '@stdlib/complex/float64/ctor' );
 var zcopy = require( '@stdlib/blas/base/zcopy' );
 var zeros = require( '@stdlib/array/zeros' );
 var logEach = require( '@stdlib/console/log-each' );
-var zdrot = require( './../lib' );
+var zrot = require( './../lib' );
 
 function rand() {
 	return new Complex128( discreteUniform( 0, 10 ), discreteUniform( -5, 5 ) );
@@ -40,7 +40,7 @@ var zyc = zcopy( zy.length, zy, 1, zeros( zy.length, 'complex128' ), 1 );
 var s = new Complex128( 0.0, 0.75 );
 
 // Apply a plane rotation:
-zdrot( zx.length, zx, 1, zy, 1, 1.25, s );
+zrot( zx.length, zx, 1, zy, 1, 1.25, s );
 
 // Print the results:
 logEach( '(%s,%s) => (%s,%s)', zxc, zyc, zx, zy );
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/lib/main.js b/lib/node_modules/@stdlib/blas/base/zrot/lib/main.js
index f98e4d25c4fe..3a6c265d46a3 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/lib/main.js
+++ b/lib/node_modules/@stdlib/blas/base/zrot/lib/main.js
@@ -21,15 +21,15 @@
 // MODULES //
 
 var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
-var zdrot = require( './zrot.js' );
+var zrot = require( './zrot.js' );
 var ndarray = require( './ndarray.js' );
 
 
 // MAIN //
 
-setReadOnly( zdrot, 'ndarray', ndarray );
+setReadOnly( zrot, 'ndarray', ndarray );
 
 
 // EXPORTS //
 
-module.exports = zdrot;
+module.exports = zrot;
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/lib/ndarray.js b/lib/node_modules/@stdlib/blas/base/zrot/lib/ndarray.js
index 679088663b5a..d6361de71951 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/lib/ndarray.js
+++ b/lib/node_modules/@stdlib/blas/base/zrot/lib/ndarray.js
@@ -21,6 +21,8 @@
 // MODULES //
 
 var reinterpret = require( '@stdlib/strided/base/reinterpret-complex128' );
+var real = require( '@stdlib/complex/float64/real' );
+var imag = require( '@stdlib/complex/float64/imag' );
 
 
 // MAIN //
@@ -96,8 +98,8 @@ function zrot( N, zx, strideX, offsetX, zy, strideY, offsetY, c, s ) {
 	sx = strideX * 2;
 	sy = strideY * 2;
 
-	sr = s.re;
-	si = s.im;
+	sr = real( s );
+	si = imag( s );
 
 	for ( i = 0; i < N; i++ ) {
 		yr = viewY[ iy ];
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/lib/zrot.js b/lib/node_modules/@stdlib/blas/base/zrot/lib/zrot.js
index ff97bda16817..ebaec7db55df 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/lib/zrot.js
+++ b/lib/node_modules/@stdlib/blas/base/zrot/lib/zrot.js
@@ -48,7 +48,7 @@ var ndarray = require( './ndarray.js' );
 * var zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
 * var s = new Complex128( 0.3, 0.4 );
 *
-* zdrot( zx.length, zx, 1, zy, 1, 0.8, s );
+* zrot( zx.length, zx, 1, zy, 1, 0.8, s );
 *
 * var z = zy.get( 0 );
 * // returns <Complex128>
@@ -68,7 +68,7 @@ var ndarray = require( './ndarray.js' );
 * im = imag( z );
 * // returns ~1.6
 */
-function zdrot( N, zx, strideX, zy, strideY, c, s ) {
+function zrot( N, zx, strideX, zy, strideY, c, s ) {
 	var ix = stride2offset( N, strideX );
 	var iy = stride2offset( N, strideY );
 	return ndarray( N, zx, strideX, ix, zy, strideY, iy, c, s );
@@ -77,4 +77,4 @@ function zdrot( N, zx, strideX, zy, strideY, c, s ) {
 
 // EXPORTS //
 
-module.exports = zdrot;
+module.exports = zrot;
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/zrot/test/test.ndarray.js
index aa35139a8bc2..17f7c6ffb85c 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/base/zrot/test/test.ndarray.js
@@ -84,7 +84,7 @@ tape( 'the function applies a plane rotation', function test( t ) {
 	var cy;
 	var s;
 
-	s = new Complex128( 0.6, 0 );
+	s = new Complex128( 0.6, 0.0 );
 
 	cx = new Complex128Array([
 		1.0, // 1
@@ -148,7 +148,7 @@ tape( 'the function supports an `x` stride', function test( t ) {
 	var cy;
 	var s;
 
-	s = new Complex128( 0, 0.6 );
+	s = new Complex128( 0.0, 0.6 );
 	cx = new Complex128Array([
 		1.0, // 1
 		2.0, // 1
@@ -187,7 +187,7 @@ tape( 'the function supports an `x` stride', function test( t ) {
 		-1.2, // 1
 		0.6,  // 1
 		-3.6, // 2
-		3.0, // 2
+		3.0,  // 2
 		0.0,
 		0.0,
 		0.0,
@@ -390,7 +390,7 @@ tape( 'the function supports a `y` offset', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns a reference to the destination array', function test( t ) {
+tape( 'the function returns a reference to the second array', function test( t ) {
 	var out;
 	var cx;
 	var cy;
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/test/test.zrot.js b/lib/node_modules/@stdlib/blas/base/zrot/test/test.zrot.js
index e4bb74572b68..2a3e99643d42 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/test/test.zrot.js
+++ b/lib/node_modules/@stdlib/blas/base/zrot/test/test.zrot.js
@@ -86,7 +86,7 @@ tape( 'the function applies a plane rotation', function test( t ) {
 
 	// Verify in octave with [0.8 0.6; -0.6 0.8] * [1+2i, 3+4i, 5+6i, 7+8i; 0 0 0 0]
 
-	s = new Complex128( 0.6, 0 );
+	s = new Complex128( 0.6, 0.0 );
 	cx = new Complex128Array([
 		1.0, // 1
 		2.0, // 1
@@ -151,7 +151,7 @@ tape( 'the function applies a plane rotation', function test( t ) {
 
 	// Verify in octave with [1.25 0.75i; .75i 1.25] * [1+2i, 3+4i, 5+6i, 7+8i; 0 0 0 0]
 
-	s = new Complex128( 0, 0.75 );
+	s = new Complex128( 0.0, 0.75 );
 	cx = new Complex128Array([
 		1.0, // 1
 		2.0, // 1
@@ -395,7 +395,7 @@ tape( 'the function supports a `y` stride', function test( t ) {
 	t.end();
 });
 
-tape( 'the function returns a reference to the destination array', function test( t ) {
+tape( 'the function returns a reference to the second array', function test( t ) {
 	var out;
 	var cx;
 	var cy;
@@ -626,9 +626,9 @@ tape( 'the function supports view offsets', function test( t ) {
 		0.0,
 		0.0,
 		-5.3, // 1
-		0.4, // 1
+		0.4,  // 1
 		-2.5, // 2
-		0  // 2
+		0.0   // 2
 	]);
 
 	out = zrot( 2, cx1, -2, cy1, 1, 0.8, s );

From e2732ae293e5cddcf9dd601fb12962c9dc003210 Mon Sep 17 00:00:00 2001
From: Athan Reines <kgryte@gmail.com>
Date: Fri, 17 Jan 2025 18:18:57 -0800
Subject: [PATCH 5/5] refactor: move package to LAPACK namespace

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

---
type: pre_push_report
description: Results of running various checks prior to pushing changes.
report:
  - task: run_javascript_examples
    status: na
  - task: run_c_examples
    status: na
  - task: run_cpp_examples
    status: na
  - task: run_javascript_readme_examples
    status: na
  - 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
---
---
 .../@stdlib/{blas => lapack}/base/zrot/README.md       | 10 +++++-----
 .../{blas => lapack}/base/zrot/benchmark/benchmark.js  |  0
 .../base/zrot/benchmark/benchmark.ndarray.js           |  0
 .../@stdlib/{blas => lapack}/base/zrot/docs/repl.txt   |  0
 .../{blas => lapack}/base/zrot/docs/types/index.d.ts   |  0
 .../{blas => lapack}/base/zrot/docs/types/test.ts      |  0
 .../{blas => lapack}/base/zrot/examples/index.js       |  0
 .../@stdlib/{blas => lapack}/base/zrot/lib/index.js    |  8 ++++----
 .../@stdlib/{blas => lapack}/base/zrot/lib/main.js     |  0
 .../@stdlib/{blas => lapack}/base/zrot/lib/ndarray.js  |  0
 .../@stdlib/{blas => lapack}/base/zrot/lib/zrot.js     |  0
 .../@stdlib/{blas => lapack}/base/zrot/package.json    |  6 +++---
 .../@stdlib/{blas => lapack}/base/zrot/test/test.js    |  0
 .../{blas => lapack}/base/zrot/test/test.ndarray.js    |  0
 .../{blas => lapack}/base/zrot/test/test.zrot.js       |  0
 15 files changed, 12 insertions(+), 12 deletions(-)
 rename lib/node_modules/@stdlib/{blas => lapack}/base/zrot/README.md (96%)
 rename lib/node_modules/@stdlib/{blas => lapack}/base/zrot/benchmark/benchmark.js (100%)
 rename lib/node_modules/@stdlib/{blas => lapack}/base/zrot/benchmark/benchmark.ndarray.js (100%)
 rename lib/node_modules/@stdlib/{blas => lapack}/base/zrot/docs/repl.txt (100%)
 rename lib/node_modules/@stdlib/{blas => lapack}/base/zrot/docs/types/index.d.ts (100%)
 rename lib/node_modules/@stdlib/{blas => lapack}/base/zrot/docs/types/test.ts (100%)
 rename lib/node_modules/@stdlib/{blas => lapack}/base/zrot/examples/index.js (100%)
 rename lib/node_modules/@stdlib/{blas => lapack}/base/zrot/lib/index.js (91%)
 rename lib/node_modules/@stdlib/{blas => lapack}/base/zrot/lib/main.js (100%)
 rename lib/node_modules/@stdlib/{blas => lapack}/base/zrot/lib/ndarray.js (100%)
 rename lib/node_modules/@stdlib/{blas => lapack}/base/zrot/lib/zrot.js (100%)
 rename lib/node_modules/@stdlib/{blas => lapack}/base/zrot/package.json (89%)
 rename lib/node_modules/@stdlib/{blas => lapack}/base/zrot/test/test.js (100%)
 rename lib/node_modules/@stdlib/{blas => lapack}/base/zrot/test/test.ndarray.js (100%)
 rename lib/node_modules/@stdlib/{blas => lapack}/base/zrot/test/test.zrot.js (100%)

diff --git a/lib/node_modules/@stdlib/blas/base/zrot/README.md b/lib/node_modules/@stdlib/lapack/base/zrot/README.md
similarity index 96%
rename from lib/node_modules/@stdlib/blas/base/zrot/README.md
rename to lib/node_modules/@stdlib/lapack/base/zrot/README.md
index 79225d5f5c78..0f3fe74f75a1 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/README.md
+++ b/lib/node_modules/@stdlib/lapack/base/zrot/README.md
@@ -20,14 +20,14 @@ limitations under the License.
 
 # zrot
 
-> Applies a plane rotation with real cosine and complex sine to a pair of complex vectors.
+> Apply a plane rotation with real cosine and complex sine to a pair of complex vectors.
 
 <section class="usage">
 
 ## Usage
 
 ```javascript
-var zrot = require( '@stdlib/blas/base/zrot' );
+var zrot = require( '@stdlib/lapack/base/zrot' );
 ```
 
 #### zrot( N, zx, strideX, zy, strideY, c, s )
@@ -229,7 +229,7 @@ im = imag( z );
 ## Notes
 
 -   If `N <= 0`, both functions leave `zx` and `zy` unchanged.
--   `zrot()` corresponds to the [BLAS][blas] level 1 function [`zrot`][zrot].
+-   `zrot()` corresponds to the [LAPACK][lapack] routine [`zrot`][zrot].
 
 </section>
 
@@ -248,7 +248,7 @@ var Complex128 = require( '@stdlib/complex/float64/ctor' );
 var zcopy = require( '@stdlib/blas/base/zcopy' );
 var zeros = require( '@stdlib/array/zeros' );
 var logEach = require( '@stdlib/console/log-each' );
-var zrot = require( '@stdlib/blas/base/zrot' );
+var zrot = require( '@stdlib/lapack/base/zrot' );
 
 function rand() {
     return new Complex128( discreteUniform( 0, 10 ), discreteUniform( -5, 5 ) );
@@ -286,7 +286,7 @@ logEach( '(%s,%s) => (%s,%s)', zxc, zyc, zx, zy );
 
 <section class="links">
 
-[blas]: http://www.netlib.org/blas
+[lapack]: http://www.netlib.org/lapack
 
 [zrot]: https://netlib.org/lapack/explore-html/d1/d45/group__rot_gaac9d54e7408105ad6f4c810902e75b7a.html#gaac9d54e7408105ad6f4c810902e75b7a
 
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.js b/lib/node_modules/@stdlib/lapack/base/zrot/benchmark/benchmark.js
similarity index 100%
rename from lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.js
rename to lib/node_modules/@stdlib/lapack/base/zrot/benchmark/benchmark.js
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/lapack/base/zrot/benchmark/benchmark.ndarray.js
similarity index 100%
rename from lib/node_modules/@stdlib/blas/base/zrot/benchmark/benchmark.ndarray.js
rename to lib/node_modules/@stdlib/lapack/base/zrot/benchmark/benchmark.ndarray.js
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/zrot/docs/repl.txt
similarity index 100%
rename from lib/node_modules/@stdlib/blas/base/zrot/docs/repl.txt
rename to lib/node_modules/@stdlib/lapack/base/zrot/docs/repl.txt
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/zrot/docs/types/index.d.ts
similarity index 100%
rename from lib/node_modules/@stdlib/blas/base/zrot/docs/types/index.d.ts
rename to lib/node_modules/@stdlib/lapack/base/zrot/docs/types/index.d.ts
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/docs/types/test.ts b/lib/node_modules/@stdlib/lapack/base/zrot/docs/types/test.ts
similarity index 100%
rename from lib/node_modules/@stdlib/blas/base/zrot/docs/types/test.ts
rename to lib/node_modules/@stdlib/lapack/base/zrot/docs/types/test.ts
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/examples/index.js b/lib/node_modules/@stdlib/lapack/base/zrot/examples/index.js
similarity index 100%
rename from lib/node_modules/@stdlib/blas/base/zrot/examples/index.js
rename to lib/node_modules/@stdlib/lapack/base/zrot/examples/index.js
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/lib/index.js b/lib/node_modules/@stdlib/lapack/base/zrot/lib/index.js
similarity index 91%
rename from lib/node_modules/@stdlib/blas/base/zrot/lib/index.js
rename to lib/node_modules/@stdlib/lapack/base/zrot/lib/index.js
index 9bf00294023d..f24890134508 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/lib/index.js
+++ b/lib/node_modules/@stdlib/lapack/base/zrot/lib/index.js
@@ -19,16 +19,16 @@
 'use strict';
 
 /**
-* BLAS level 1 routine to apply a plane rotation with real cosine and complex sine.
+* LAPACK auxiliary routine to apply a plane rotation with real cosine and complex sine.
 *
-* @module @stdlib/blas/base/zrot
+* @module @stdlib/lapack/base/zrot
 *
 * @example
 * var Complex128Array = require( '@stdlib/array/complex128' );
 * var Complex128 = require( '@stdlib/complex/float64' );
 * var real = require( '@stdlib/complex/float64/real' );
 * var imag = require( '@stdlib/complex/float64/imag' );
-* var zrot = require( '@stdlib/blas/base/zrot' );
+* var zrot = require( '@stdlib/lapack/base/zrot' );
 *
 * var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
 * var zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
@@ -58,7 +58,7 @@
 * var Complex128Array = require( '@stdlib/array/complex128' );
 * var real = require( '@stdlib/complex/float64/real' );
 * var imag = require( '@stdlib/complex/float64/imag' );
-* var zrot = require( '@stdlib/blas/base/zrot' );
+* var zrot = require( '@stdlib/lapack/base/zrot' );
 *
 * var zx = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
 * var zy = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/lib/main.js b/lib/node_modules/@stdlib/lapack/base/zrot/lib/main.js
similarity index 100%
rename from lib/node_modules/@stdlib/blas/base/zrot/lib/main.js
rename to lib/node_modules/@stdlib/lapack/base/zrot/lib/main.js
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/zrot/lib/ndarray.js
similarity index 100%
rename from lib/node_modules/@stdlib/blas/base/zrot/lib/ndarray.js
rename to lib/node_modules/@stdlib/lapack/base/zrot/lib/ndarray.js
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/lib/zrot.js b/lib/node_modules/@stdlib/lapack/base/zrot/lib/zrot.js
similarity index 100%
rename from lib/node_modules/@stdlib/blas/base/zrot/lib/zrot.js
rename to lib/node_modules/@stdlib/lapack/base/zrot/lib/zrot.js
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/package.json b/lib/node_modules/@stdlib/lapack/base/zrot/package.json
similarity index 89%
rename from lib/node_modules/@stdlib/blas/base/zrot/package.json
rename to lib/node_modules/@stdlib/lapack/base/zrot/package.json
index 830b0e01c6ce..214784a4f948 100644
--- a/lib/node_modules/@stdlib/blas/base/zrot/package.json
+++ b/lib/node_modules/@stdlib/lapack/base/zrot/package.json
@@ -1,7 +1,7 @@
 {
-  "name": "@stdlib/blas/base/zrot",
+  "name": "@stdlib/lapack/base/zrot",
   "version": "0.0.0",
-  "description": "Apply a plane rotation with real cosine and complex sine.",
+  "description": "LAPACK auxiliary routine to apply a plane rotation with real cosine and complex sine.",
   "license": "Apache-2.0",
   "author": {
     "name": "The Stdlib Authors",
@@ -54,8 +54,8 @@
     "stdmath",
     "mathematics",
     "math",
+    "lapack",
     "blas",
-    "level 1",
     "linear",
     "algebra",
     "subroutines",
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/test/test.js b/lib/node_modules/@stdlib/lapack/base/zrot/test/test.js
similarity index 100%
rename from lib/node_modules/@stdlib/blas/base/zrot/test/test.js
rename to lib/node_modules/@stdlib/lapack/base/zrot/test/test.js
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/zrot/test/test.ndarray.js
similarity index 100%
rename from lib/node_modules/@stdlib/blas/base/zrot/test/test.ndarray.js
rename to lib/node_modules/@stdlib/lapack/base/zrot/test/test.ndarray.js
diff --git a/lib/node_modules/@stdlib/blas/base/zrot/test/test.zrot.js b/lib/node_modules/@stdlib/lapack/base/zrot/test/test.zrot.js
similarity index 100%
rename from lib/node_modules/@stdlib/blas/base/zrot/test/test.zrot.js
rename to lib/node_modules/@stdlib/lapack/base/zrot/test/test.zrot.js