From bb65398024f06c64579a478158c8b5559bff0dba Mon Sep 17 00:00:00 2001
From: aman-095 <bhansali.1@iitj.ac.in>
Date: Mon, 27 May 2024 16:33:17 +0530
Subject: [PATCH 01/16] feat: add BLAS Level 1 routine for dznmr2

---
 .../@stdlib/blas/base/dznrm2/README.md        | 172 +++++++++++++++
 .../blas/base/dznrm2/benchmark/benchmark.js   |  93 ++++++++
 .../dznrm2/benchmark/benchmark.ndarray.js     |  93 ++++++++
 .../@stdlib/blas/base/dznrm2/docs/repl.txt    |  90 ++++++++
 .../blas/base/dznrm2/docs/types/index.d.ts    |  96 +++++++++
 .../blas/base/dznrm2/docs/types/test.ts       | 158 ++++++++++++++
 .../blas/base/dznrm2/examples/index.js        |  35 +++
 .../@stdlib/blas/base/dznrm2/lib/dznrm2.js    |  86 ++++++++
 .../@stdlib/blas/base/dznrm2/lib/index.js     |  68 ++++++
 .../@stdlib/blas/base/dznrm2/lib/main.js      |  35 +++
 .../@stdlib/blas/base/dznrm2/lib/ndarray.js   |  87 ++++++++
 .../@stdlib/blas/base/dznrm2/package.json     |  75 +++++++
 .../blas/base/dznrm2/test/test.dznrm2.js      | 199 ++++++++++++++++++
 .../@stdlib/blas/base/dznrm2/test/test.js     |  82 ++++++++
 .../blas/base/dznrm2/test/test.ndarray.js     | 196 +++++++++++++++++
 15 files changed, 1565 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/README.md
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.ndarray.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/docs/repl.txt
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/docs/types/index.d.ts
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/docs/types/test.ts
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/examples/index.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/lib/dznrm2.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/lib/index.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/lib/main.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/lib/ndarray.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/package.json
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/test/test.dznrm2.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/test/test.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/test/test.ndarray.js

diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/README.md b/lib/node_modules/@stdlib/blas/base/dznrm2/README.md
new file mode 100644
index 000000000000..d2555a075aaa
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/README.md
@@ -0,0 +1,172 @@
+<!--
+
+@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.
+
+-->
+
+# dznrm2
+
+> Find the euclidean norm of a complex double-precision floating-point vector.
+
+<section class="usage">
+
+## Usage
+
+```javascript
+var dznrm2 = require( '@stdlib/blas/base/dznrm2' );
+```
+
+#### dznrm2( N, zx, strideX )
+
+Finds the euclidean norm of a complex double-precision floating-point vector.
+
+```javascript
+var Complex128Array = require( '@stdlib/array/complex128' );
+
+var zx = new Complex128Array( [ 0.3, 0.1, 0.5, 0.0, 0.0, 0.5, 0.0, 0.2 ] );
+
+var norm = dznrm2( 4, zx, 1 );
+// returns ~0.8
+```
+
+The function has the following parameters:
+
+-   **N**: number of indexed elements.
+-   **zx**: input [`Complex128Array`][@stdlib/array/complex128].
+-   **strideX**: index increment for `zx`.
+
+The `N` and `strideX` parameters determine which elements in `zx` are accessed at runtime. For example, to traverse every other value,
+
+```javascript
+var Complex128Array = require( '@stdlib/array/complex128' );
+
+var zx = new Complex128Array( [ -2.0, 1.0, 3.0, -5.0, 4.0, 0.0, -1.0, -3.0 ] );
+
+var norm = dznrm2( 2, zx, 2 );
+// returns ~4.6
+```
+
+Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
+
+```javascript
+var Complex128Array = require( '@stdlib/array/complex128' );
+
+// Initial array:
+var zx0 = new Complex128Array( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );
+
+// Create an offset view:
+var zx1 = new Complex128Array( zx0.buffer, zx0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+
+// Find euclidean norm:
+var norm = dznrm2( 2, zx1, 1 );
+// returns ~9.3
+```
+
+#### dznrm2.ndarray( N, zx, strideX, offset )
+
+Finds the euclidean norm of a complex double-precision floating-point vector using alternative indexing semantics.
+
+```javascript
+var Complex128Array = require( '@stdlib/array/complex128' );
+
+var zx = new Complex128Array( [ 0.3, 0.1, 0.5, 0.0, 0.0, 0.5, 0.0, 0.2 ] );
+
+var norm = dznrm2.ndarray( 4, zx, 1, 0 );
+// returns ~0.8
+```
+
+The function has the following additional parameters:
+
+-   **offsetX**: starting index.
+
+While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the `offset` parameter supports indexing semantics based on a starting index. For example, to start from the second index,
+
+```javascript
+var Complex128Array = require( '@stdlib/array/complex128' );
+
+var zx = new Complex128Array( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );
+
+var norm = dznrm2.ndarray( 3, zx, 1, 1 );
+// returns ~9.3
+```
+
+</section>
+
+<!-- /.usage -->
+
+<section class="notes">
+
+## Notes
+
+-   If `N < 1` or `strideX < 0`, both functions return `0.0`.
+-   `dznrm2()` corresponds to the [BLAS][blas] level 1 function [`dznrm2`][dznrm2].
+
+</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/float32' );
+var dznrm2 = require( '@stdlib/blas/base/dznrm2' );
+
+function rand() {
+    return new Complex128( discreteUniform( 0, 10 ), discreteUniform( -5, 5 ) );
+}
+
+var zx = filledarrayBy( 10, 'complex128', rand );
+console.log( zx.toString() );
+
+// Finds the euclidean norm:
+var norm = dznrm2( zx.length, zx, 1 );
+console.log( norm );
+```
+
+</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
+
+[dznrm2]: http://www.netlib.org/lapack/explore-html/de/da4/group__double__blas__level1.html
+
+[@stdlib/array/complex128]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/complex128
+
+[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
+
+</section>
+
+<!-- /.links -->
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.js
new file mode 100644
index 000000000000..b6cbe29e6f14
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.js
@@ -0,0 +1,93 @@
+/**
+* @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 pkg = require( './../package.json' ).name;
+var dznrm2 = require( './../lib/dznrm2.js' );
+
+
+// VARIABLES //
+
+var options = {
+	'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Create a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+	var cx = uniform( len, -10.0, 10.0, options );
+	cx = new Complex128Array( cx.buffer );
+	return benchmark;
+
+	function benchmark( b ) {
+		var norm;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			norm = dznrm2( cx.length, cx, 1 );
+			if ( isnan( norm ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( norm ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+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/dznrm2/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.ndarray.js
new file mode 100644
index 000000000000..3d97028d378e
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.ndarray.js
@@ -0,0 +1,93 @@
+/**
+* @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 pkg = require( './../package.json' ).name;
+var dznrm2 = require( './../lib/ndarray.js' );
+
+
+// VARIABLES //
+
+var options = {
+	'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Create a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+	var zx = uniform( len, -10.0, 10.0, options );
+	zx = new Complex128Array( zx.buffer );
+	return benchmark;
+
+	function benchmark( b ) {
+		var norm;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			norm = dznrm2( zx.length, zx, 1, 0 );
+			if ( isnan( norm ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( norm ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+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/dznrm2/docs/repl.txt b/lib/node_modules/@stdlib/blas/base/dznrm2/docs/repl.txt
new file mode 100644
index 000000000000..1f1cc455d59c
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/docs/repl.txt
@@ -0,0 +1,90 @@
+
+{{alias}}( N, zx, strideX )
+    Finds the the euclidean norm of a complex double-precision floating-point
+    vector.
+
+    The `N` and `strideX` parameters determine which elements in `zx` are
+    accessed at runtime.
+
+    Indexing is relative to the first index. To introduce an offset, use typed
+    array views.
+
+    If `N < 1` or `strideX < 0`, the function returns `0.0`.
+
+    Parameters
+    ----------
+    N: integer
+        Number of indexed elements.
+
+    zx: Complex64Array
+        Input array.
+
+    strideX: integer
+        Index increment for `zx`.
+
+    Returns
+    -------
+    norm: number
+        Euclidean norm.
+
+    Examples
+    --------
+    // Standard Usage:
+    > var zx = new {{alias:@stdlib/array/complex128}}( [ 0.3, 0.1, 0.5, 0.0, 0.0, 0.5 ] );
+    > var norm = {{alias}}( 3, zx, 1 )
+    ~0.77
+
+    // Using `N` and stride parameters:
+    > zx = new {{alias:@stdlib/array/complex128}}( [ -2.0, 1.0, 3.0, -5.0 ] );
+    > norm = {{alias}}( 1, zx, 2 )
+    ~2.2
+
+    // Using view offsets:
+    > var zx0 = new {{alias:@stdlib/array/complex128}}( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );
+    > var zx1 = new {{alias:@stdlib/array/complex128}}( zx0.buffer, zx0.BYTES_PER_ELEMENT*1 );
+    > norm = {{alias}}( 2, zx1, 1 )
+    ~9.3
+
+
+{{alias}}.ndarray( N, zx, strideX, offsetX )
+    Finds the euclidean norm of a complex double-precision floating-point
+    vector using alternative indexing semantics.
+
+    While typed array views mandate a view offset based on the underlying
+    buffer, the `offsetX` parameter supports indexing semantics based on a
+    starting index.
+
+    Parameters
+    ----------
+    N: integer
+        Number of indexed elements.
+
+    zx: Complex64Array
+        Input array.
+
+    strideX: integer
+        Index increment for `zx`.
+
+    offsetX: integer
+        Starting index of `zx`.
+
+    Returns
+    -------
+    norm: number
+        Euclidean norm.
+
+    Examples
+    --------
+    // Standard Usage:
+    > var zx = new {{alias:@stdlib/array/complex128}}( [ -2.0, 1.0, 3.0, -5.0 ] );
+    > var norm = {{alias}}.ndarray( 1, zx, 2, 0 )
+    ~2.2
+
+    // Using an index offset:
+    > zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );
+    > norm = {{alias}}.ndarray( 3, zx, 1, 1 )
+    ~9.3
+
+    See Also
+    --------
+
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/base/dznrm2/docs/types/index.d.ts
new file mode 100644
index 000000000000..a9b756ea1c47
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/docs/types/index.d.ts
@@ -0,0 +1,96 @@
+/*
+* @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 `dznrm2`.
+*/
+interface Routine {
+	/**
+	* Finds the euclidean norm of a complex double-precision floating-point vector.
+	*
+	* @param N - number of indexed elements
+	* @param zx - input array
+	* @param strideX - stride length for `zx`
+	* @returns euclidean norm
+	*
+	* @example
+	* var Complex128Array = require( '@stdlib/array/complex128' );
+	*
+	* var zx = new Complex128Array( [ 0.3, 0.1, 0.5, 0.0, 0.0, 0.5, 0.0, 0.2, 2.0, 3.0 ] );
+	*
+	* var norm = dznrm2( 4, zx, 1 );
+	* // returns ~0.8
+	*/
+	( N: number, x: Complex128Array, strideX: number ): number;
+
+	/**
+	* Finds the euclidean norm of a complex double-precision floating-point vector using alternative indexing semantics.
+	*
+	* @param N - number of indexed elements
+	* @param zx - input array
+	* @param strideX - stride length for `zx`
+	* @param offsetX - starting index for `zx`
+	* @returns index value
+	*
+	* @example
+	* var Complex128Array = require( '@stdlib/array/complex128' );
+	*
+	* var zx = new Complex128Array( [ 0.3, 0.1, 0.5, 0.0, 0.0, 0.5, 0.0, 0.2, 2.0, 3.0 ] );
+	*
+	* var norm = dznrm2.ndarray( 4, zx, 1, 0 );
+	* // returns ~0.8
+	*/
+	ndarray( N: number, x: Complex128Array, strideX: number, offsetX: number ): number;
+}
+
+/**
+* Finds the euclidean norm of a complex double-precision floating-point vector.
+*
+* @param N - number of indexed elements
+* @param zx - input array
+* @param strideX - stride length for `zx`
+* @returns index value
+*
+* @example
+* var Complex128Array = require( '@stdlib/array/complex128' );
+*
+* var x = new Complex128Array( [ -2.0, 1.0, 3.0, -5.0 ] );
+*
+* var norm = dznrm2( 1, zx, 2 );
+* // returns ~2.2
+*
+* @example
+* var Complex128Array = require( '@stdlib/array/complex128' );
+*
+* var x = new Complex128Array( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );
+*
+* var norm = dznrm2.ndarray( 2, zx, 1, 1 );
+* // returns ~9.3
+*/
+declare var dznrm2: Routine;
+
+
+// EXPORTS //
+
+export = dznrm2;
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/docs/types/test.ts b/lib/node_modules/@stdlib/blas/base/dznrm2/docs/types/test.ts
new file mode 100644
index 000000000000..4327f535c2f3
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/docs/types/test.ts
@@ -0,0 +1,158 @@
+/*
+* @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 dznrm2 = require( './index' );
+
+
+// TESTS //
+
+// The function returns a number...
+{
+	const zx = new Complex128Array( 10 );
+
+	dznrm2( zx.length, zx, 1 ); // $ExpectType number
+}
+
+// The compiler throws an error if the function is provided a first argument which is not a number...
+{
+	const zx = new Complex128Array( 10 );
+
+	dznrm2( '10', zx, 1 ); // $ExpectError
+	dznrm2( true, zx, 1 ); // $ExpectError
+	dznrm2( false, zx, 1 ); // $ExpectError
+	dznrm2( null, zx, 1 ); // $ExpectError
+	dznrm2( undefined, zx, 1 ); // $ExpectError
+	dznrm2( [], zx, 1 ); // $ExpectError
+	dznrm2( {}, zx, 1 ); // $ExpectError
+	dznrm2( ( zx: number ): number => zx, zx, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not a Complex128Array...
+{
+	const zx = new Complex128Array( 10 );
+
+	dznrm2( zx.length, 10, 1 ); // $ExpectError
+	dznrm2( zx.length, '10', 1 ); // $ExpectError
+	dznrm2( zx.length, true, 1 ); // $ExpectError
+	dznrm2( zx.length, false, 1 ); // $ExpectError
+	dznrm2( zx.length, null, 1 ); // $ExpectError
+	dznrm2( zx.length, undefined, 1 ); // $ExpectError
+	dznrm2( zx.length, [], 1 ); // $ExpectError
+	dznrm2( zx.length, {}, 1 ); // $ExpectError
+	dznrm2( zx.length, ( zx: number ): number => zx, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a third argument which is not a number...
+{
+	const zx = new Complex128Array( 10 );
+
+	dznrm2( zx.length, zx, '10' ); // $ExpectError
+	dznrm2( zx.length, zx, true ); // $ExpectError
+	dznrm2( zx.length, zx, false ); // $ExpectError
+	dznrm2( zx.length, zx, null ); // $ExpectError
+	dznrm2( zx.length, zx, undefined ); // $ExpectError
+	dznrm2( zx.length, zx, [] ); // $ExpectError
+	dznrm2( zx.length, zx, {} ); // $ExpectError
+	dznrm2( zx.length, zx, ( 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 );
+
+	dznrm2(); // $ExpectError
+	dznrm2( zx.length ); // $ExpectError
+	dznrm2( zx.length, zx ); // $ExpectError
+	dznrm2( zx.length, zx, 1, 10 ); // $ExpectError
+}
+
+// Attached to main export is an `ndarray` method which returns a number...
+{
+	const zx = new Complex128Array( 10 );
+
+	dznrm2.ndarray( zx.length, zx, 1, 0 ); // $ExpectType number
+}
+
+// The compiler throws an error if the `ndarray` method is provided a first argument which is not a number...
+{
+	const zx = new Complex128Array( 10 );
+
+	dznrm2.ndarray( '10', zx, 1, 0 ); // $ExpectError
+	dznrm2.ndarray( true, zx, 1, 0 ); // $ExpectError
+	dznrm2.ndarray( false, zx, 1, 0 ); // $ExpectError
+	dznrm2.ndarray( null, zx, 1, 0 ); // $ExpectError
+	dznrm2.ndarray( undefined, zx, 1, 0 ); // $ExpectError
+	dznrm2.ndarray( [], zx, 1, 0 ); // $ExpectError
+	dznrm2.ndarray( {}, zx, 1, 0 ); // $ExpectError
+	dznrm2.ndarray( ( zx: number ): number => zx, zx, 1, 0 ); // $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 );
+
+	dznrm2.ndarray( zx.length, 10, 1, 0 ); // $ExpectError
+	dznrm2.ndarray( zx.length, '10', 1, 0 ); // $ExpectError
+	dznrm2.ndarray( zx.length, true, 1, 0 ); // $ExpectError
+	dznrm2.ndarray( zx.length, false, 1, 0 ); // $ExpectError
+	dznrm2.ndarray( zx.length, null, 1, 0 ); // $ExpectError
+	dznrm2.ndarray( zx.length, undefined, 1, 0 ); // $ExpectError
+	dznrm2.ndarray( zx.length, [], 1, 0 ); // $ExpectError
+	dznrm2.ndarray( zx.length, {}, 1, 0 ); // $ExpectError
+	dznrm2.ndarray( zx.length, ( zx: number ): number => zx, 1, 0 ); // $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 );
+
+	dznrm2.ndarray( zx.length, zx, '10', 0 ); // $ExpectError
+	dznrm2.ndarray( zx.length, zx, true, 0 ); // $ExpectError
+	dznrm2.ndarray( zx.length, zx, false, 0 ); // $ExpectError
+	dznrm2.ndarray( zx.length, zx, null, 0 ); // $ExpectError
+	dznrm2.ndarray( zx.length, zx, undefined, 0 ); // $ExpectError
+	dznrm2.ndarray( zx.length, zx, [], 0 ); // $ExpectError
+	dznrm2.ndarray( zx.length, zx, {}, 0 ); // $ExpectError
+	dznrm2.ndarray( zx.length, zx, ( zx: number ): number => zx, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number...
+{
+	const zx = new Complex128Array( 10 );
+
+	dznrm2.ndarray( zx.length, zx, 1, '10' ); // $ExpectError
+	dznrm2.ndarray( zx.length, zx, 1, true ); // $ExpectError
+	dznrm2.ndarray( zx.length, zx, 1, false ); // $ExpectError
+	dznrm2.ndarray( zx.length, zx, 1, null ); // $ExpectError
+	dznrm2.ndarray( zx.length, zx, 1, undefined ); // $ExpectError
+	dznrm2.ndarray( zx.length, zx, 1, [] ); // $ExpectError
+	dznrm2.ndarray( zx.length, zx, 1, {} ); // $ExpectError
+	dznrm2.ndarray( zx.length, zx, 1, ( 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 );
+
+	dznrm2.ndarray(); // $ExpectError
+	dznrm2.ndarray( zx.length ); // $ExpectError
+	dznrm2.ndarray( zx.length, zx ); // $ExpectError
+	dznrm2.ndarray( zx.length, zx, 1 ); // $ExpectError
+	dznrm2.ndarray( zx.length, zx, 1, 0, 10 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/examples/index.js b/lib/node_modules/@stdlib/blas/base/dznrm2/examples/index.js
new file mode 100644
index 000000000000..211248525ffb
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/examples/index.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';
+
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var Complex128 = require( '@stdlib/complex/float64' );
+var dznrm2 = require( '@stdlib/blas/base/dznrm2' );
+
+function rand() {
+	return new Complex128( discreteUniform( 0, 10 ), discreteUniform( -5, 5 ) );
+}
+
+var zx = filledarrayBy( 10, 'complex64', rand );
+console.log( zx.toString() );
+
+// Finds the euclidean norm:
+var norm = dznrm2( zx.length, zx, 1 );
+console.log( norm );
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/lib/dznrm2.js b/lib/node_modules/@stdlib/blas/base/dznrm2/lib/dznrm2.js
new file mode 100644
index 000000000000..ff63ec71b59a
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/lib/dznrm2.js
@@ -0,0 +1,86 @@
+/**
+* @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 abs = require( '@stdlib/math/base/special/abs' );
+var imag = require( '@stdlib/complex/imag' );
+var real = require( '@stdlib/complex/real' );
+var sqrt = require( '@stdlib/math/base/special/sqrt' );
+
+
+// MAIN //
+
+/**
+* Finds the euclidean norm of a complex double-precision floating-point vector.
+*
+* @param {PositiveInteger} N - number of indexed elements
+* @param {Complex128Array} zx - input array
+* @param {NonNegativeInteger} strideX - `zx` stride length
+* @returns {number} index value
+*
+* @example
+* var Complex128Array = require( '@stdlib/array/complex128' );
+*
+* var zx = new Complex128Array( [ 0.3, 0.1, 0.5, 0.0, 0.0, 0.5, 0.0, 0.2, 2.0, 3.0 ] );
+*
+* var norm = dznrm2( 4, zx, 1 );
+* // returns ~0.8
+*/
+function dznrm2( N, zx, strideX ) {
+	var scale;
+	var norm;
+	var temp;
+	var ssq;
+	var ix;
+
+	if ( N < 1 || strideX < 0 ) {
+		return 0.0;
+	}
+	scale = 0.0;
+	ssq = 1.0;
+	for ( ix = 0; ix <= ( N - 1 ) * strideX; ix += strideX ) {
+		if ( real( zx.get( ix ) ) !== 0.0 ) {
+			temp = abs( real( zx.get( ix ) ) );
+			if ( scale < temp ) {
+				ssq = 1.0 + ( ssq * ( ( scale / temp ) * ( scale / temp ) ) );
+				scale = temp;
+			} else {
+				ssq += ( ( temp / scale ) * ( temp / scale ) );
+			}
+		}
+		if ( imag( zx.get( ix ) ) !== 0.0 ) {
+			temp = abs( imag( zx.get( ix ) ) );
+			if ( scale < temp ) {
+				ssq = 1.0 + ( ssq * ( ( scale / temp ) * ( scale / temp ) ) );
+				scale = temp;
+			} else {
+				ssq += ( ( temp / scale ) * ( temp / scale ) );
+			}
+		}
+		norm = scale * sqrt( ssq );
+	}
+	return norm;
+}
+
+
+// EXPORTS //
+
+module.exports = dznrm2;
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/lib/index.js b/lib/node_modules/@stdlib/blas/base/dznrm2/lib/index.js
new file mode 100644
index 000000000000..8dd07a5fa14e
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/lib/index.js
@@ -0,0 +1,68 @@
+/**
+* @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 find the euclidean norm of a complex double-precision floating-point vector.
+*
+* @module @stdlib/blas/base/dznrm2
+*
+* @example
+* var Complex128Array = require( '@stdlib/array/complex128' );
+* var dznrm2 = require( '@stdlib/blas/base/dznrm2' );
+*
+* var zx = new Complex128Array( [ 0.3, 0.1, 0.5, 0.0, 0.0, 0.5, 0.0, 0.2, 2.0, 3.0 ] );
+*
+* var norm = dznrm2( 4, zx, 1 );
+* // returns ~0.8
+*
+* @example
+* var Complex128Array = require( '@stdlib/array/complex128' );
+* var dznrm2 = require( '@stdlib/blas/base/dznrm2' );
+*
+* var zx = new Complex128Array( [ 0.3, 0.1, 0.5, 0.0, 0.0, 0.5, 0.0, 0.2, 2.0, 3.0 ] );
+*
+* var norm = dznrm2.ndarray( 4, zx, 1, 0 );
+* // returns ~0.8
+*/
+
+// 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 dznrm2;
+var tmp = tryRequire( join( __dirname, './native.js' ) );
+if ( isError( tmp ) ) {
+	dznrm2 = main;
+} else {
+	dznrm2 = tmp;
+}
+
+
+// EXPORTS //
+
+module.exports = dznrm2;
+
+// exports: { "ndarray": "dznrm2.ndarray" }
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/lib/main.js b/lib/node_modules/@stdlib/blas/base/dznrm2/lib/main.js
new file mode 100644
index 000000000000..bbe7ec871d2e
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/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 dznrm2 = require( './dznrm2.js' );
+var ndarray = require( './ndarray.js' );
+
+
+// MAIN //
+
+setReadOnly( dznrm2, 'ndarray', ndarray );
+
+
+// EXPORTS //
+
+module.exports = dznrm2;
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/lib/ndarray.js b/lib/node_modules/@stdlib/blas/base/dznrm2/lib/ndarray.js
new file mode 100644
index 000000000000..fa4e1d05d8bd
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/lib/ndarray.js
@@ -0,0 +1,87 @@
+/**
+* @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 abs = require( '@stdlib/math/base/special/abs' );
+var imag = require( '@stdlib/complex/imag' );
+var real = require( '@stdlib/complex/real' );
+var sqrt = require( '@stdlib/math/base/special/sqrt' );
+
+
+// MAIN //
+
+/**
+* Finds the euclidean norm of a complex double-precision floating-point vector.
+*
+* @param {PositiveInteger} N - number of indexed elements
+* @param {Complex128Array} zx - input array
+* @param {NonNegativeInteger} strideX - `zx` stride length
+* @param {NonNegativeInteger} offsetX - starting index for `zx`
+* @returns {number} index value
+*
+* @example
+* var Complex128Array = require( '@stdlib/array/complex128' );
+*
+* var zx = new Complex128Array( [ 0.3, 0.1, 0.5, 0.0, 0.0, 0.5, 0.0, 0.2, 2.0, 3.0 ] );
+*
+* var norm = dznrm2( 4, zx, 1, 0 );
+* // returns ~0.8
+*/
+function dznrm2( N, zx, strideX, offsetX ) {
+	var scale;
+	var norm;
+	var temp;
+	var ssq;
+	var ix;
+
+	if ( N < 1 || strideX < 0 ) {
+		return 0.0;
+	}
+	scale = 0.0;
+	ssq = 1.0;
+	for ( ix = offsetX; ix <= ( N - 1 ) * strideX; ix += strideX ) {
+		if ( real( zx.get( ix ) ) !== 0.0 ) {
+			temp = abs( real( zx.get( ix ) ) );
+			if ( scale < temp ) {
+				ssq = 1.0 + ( ssq * ( scale / temp ) * ( scale / temp ) );
+				scale = temp;
+			} else {
+				ssq += ( ( temp / scale ) * ( temp / scale ) );
+			}
+		}
+		if ( imag( zx.get( ix ) ) !== 0.0 ) {
+			temp = abs( imag( zx.get( ix ) ) );
+			if ( scale < temp ) {
+				ssq = 1.0 + ( ssq * ( scale / temp ) * ( scale / temp ) );
+				scale = temp;
+			} else {
+				ssq += ( ( temp / scale ) * ( temp / scale ) );
+			}
+		}
+		norm = scale * sqrt( ssq );
+	}
+	return norm;
+}
+
+
+// EXPORTS //
+
+module.exports = dznrm2;
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/package.json b/lib/node_modules/@stdlib/blas/base/dznrm2/package.json
new file mode 100644
index 000000000000..0e70208f73f0
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/package.json
@@ -0,0 +1,75 @@
+{
+  "name": "@stdlib/blas/base/dznrm2",
+  "version": "0.0.0",
+  "description": "Find the euclidean norm of a complex double-precision floating-point vector.",
+  "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",
+  "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",
+    "dznrm2",
+    "euclidean",
+    "norm",
+    "euclidean-norm",
+    "linear",
+    "algebra",
+    "subroutines",
+    "vector",
+    "array",
+    "ndarray",
+    "complex",
+    "complex128",
+    "float64",
+    "float",
+    "single",
+    "float64array"
+  ]
+}
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.dznrm2.js b/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.dznrm2.js
new file mode 100644
index 000000000000..f548f53a1ce4
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.dznrm2.js
@@ -0,0 +1,199 @@
+/**
+* @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 Complex128Array = require( '@stdlib/array/complex128' );
+var EPS = require( '@stdlib/constants/float64/eps' );
+var abs = require( '@stdlib/math/base/special/abs' );
+var dznrm2 = require( './../lib/dznrm2.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
+*/
+function isApprox( t, actual, expected, rtol ) {
+	var delta;
+	var tol;
+	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 ] );
+			tol = rtol * EPS * abs( expected[ i ] );
+			t.ok( delta <= tol, 'within tolerance. actual: '+actual[ i ]+'. expected: '+expected[ i ]+'. delta: '+delta+'. tol: '+tol+'.' );
+		}
+	}
+}
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof dznrm2, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 3', function test( t ) {
+	t.strictEqual( dznrm2.length, 3, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function finds the euclidean norm', function test( t ) {
+	var expected;
+	var norm;
+	var zx;
+
+	zx = new Complex128Array([
+		0.3, // 1
+		0.1, // 1
+		0.5, // 2
+		0.0, // 2
+		0.0, // 3
+		0.5, // 3
+		0.0, // 4
+		0.2, // 4
+		2.0,
+		3.0
+	]);
+	expected = 0.8;
+
+	norm = dznrm2( 4, zx, 1 );
+	isApprox( t, norm, expected, 2 );
+
+	zx = new Complex128Array( [
+		0.1,  // 1
+		0.1,  // 1
+		-0.6, // 2
+		0.1,  // 2
+		0.1,  // 3
+		-0.3, // 3
+		7.0,
+		8.0
+	] );
+	expected = 0.7;
+
+	norm = dznrm2( 3, zx, 1 );
+	isApprox( t, norm, expected, 2 );
+	t.end();
+});
+
+tape( 'if provided an `N` parameter less than `1`, the function returns `0.0`', function test( t ) {
+	var expected;
+	var norm;
+	var zx;
+
+	zx = new Complex128Array( [
+		1.0,
+		2.0,
+		3.0,
+		4.0
+	] );
+	expected = 0.0;
+
+	norm = dznrm2( 0, zx, 1 );
+	t.strictEqual( norm, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided a `strideX` parameter less than `0`, the function returns `0.0`', function test( t ) {
+	var expected;
+	var norm;
+	var zx;
+
+	zx = new Complex128Array( [ 3.0, -4.0, 1.0, 15.0, 4.0, 3.0 ] );
+	expected = 0.0;
+
+	norm = dznrm2( zx.length, zx, -1 );
+	t.strictEqual( norm, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports specifying a stride', function test( t ) {
+	var expected;
+	var norm;
+	var zx;
+
+	zx = new Complex128Array([
+		0.3, // 1
+		0.1, // 1
+		5.0,
+		8.0,
+		0.5, // 2
+		0.0, // 2
+		6.0,
+		9.0,
+		0.0, // 3
+		0.5, // 3
+		8.0,
+		3.0,
+		0.0, // 4
+		0.2, // 4
+		9.0,
+		4.0
+	]);
+	expected = 0.8;
+
+	norm = dznrm2( 4, zx, 2 );
+	isApprox( t, norm, expected, 2 );
+	t.end();
+});
+
+tape( 'the function supports view offsets', function test( t ) {
+	var expected;
+	var norm;
+	var zx0;
+	var zx1;
+
+	zx0 = new Complex128Array([
+		1.0,
+		2.0,
+		3.0, // 1
+		4.0, // 1
+		5.0, // 2
+		6.0, // 2
+		7.0, // 3
+		8.0, // 3
+		9.0,
+		10.0
+	]);
+	expected = 14.1;
+
+	zx1 = new Complex128Array( zx0.buffer, zx0.BYTES_PER_ELEMENT*1 );
+
+	norm = dznrm2( 3, zx1, 1 );
+	isApprox( t, norm, expected, 2 );
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.js b/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.js
new file mode 100644
index 000000000000..4b5a50893221
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/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 dznrm2 = require( './../lib' );
+
+
+// VARIABLES //
+
+var opts = {
+	'skip': isBrowser
+};
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof dznrm2, '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 dznrm2.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 dznrm2 = proxyquire( './../lib', {
+		'@stdlib/utils/try-require': tryRequire
+	});
+
+	t.strictEqual( dznrm2, 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 dznrm2;
+	var main;
+
+	main = require( './../lib/dznrm2.js' );
+
+	dznrm2 = proxyquire( './../lib', {
+		'@stdlib/utils/try-require': tryRequire
+	});
+
+	t.strictEqual( dznrm2, main, 'returns JavaScript implementation' );
+	t.end();
+
+	function tryRequire() {
+		return new Error( 'Cannot find module' );
+	}
+});
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.ndarray.js
new file mode 100644
index 000000000000..a8f0a660da88
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.ndarray.js
@@ -0,0 +1,196 @@
+/**
+* @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 Complex128Array = require( '@stdlib/array/complex128' );
+var EPS = require( '@stdlib/constants/float64/eps' );
+var abs = require( '@stdlib/math/base/special/abs' );
+var dznrm2 = 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
+*/
+function isApprox( t, actual, expected, rtol ) {
+	var delta;
+	var tol;
+	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 ] );
+			tol = rtol * EPS * abs( expected[ i ] );
+			t.ok( delta <= tol, 'within tolerance. actual: '+actual[ i ]+'. expected: '+expected[ i ]+'. delta: '+delta+'. tol: '+tol+'.' );
+		}
+	}
+}
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof dznrm2, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 4', function test( t ) {
+	t.strictEqual( dznrm2.length, 4, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function finds the euclidean norm', function test( t ) {
+	var expected;
+	var norm;
+	var zx;
+
+	zx = new Complex128Array([
+		0.3, // 1
+		0.1, // 1
+		0.5, // 2
+		0.0, // 2
+		0.0, // 3
+		0.5, // 3
+		0.0, // 4
+		0.2, // 4
+		2.0,
+		3.0
+	]);
+	expected = 0.8;
+
+	norm = dznrm2( 4, zx, 1, 0 );
+	isApprox( t, norm, expected, 2 );
+
+	zx = new Complex128Array( [
+		0.1,  // 1
+		0.1,  // 1
+		-0.6, // 2
+		0.1,  // 2
+		0.1,  // 3
+		-0.3, // 3
+		7.0,
+		8.0
+	] );
+	expected = 0.7;
+
+	norm = dznrm2( 3, zx, 1, 0 );
+	isApprox( t, norm, expected, 2 );
+	t.end();
+});
+
+tape( 'if provided an `N` parameter less than `1`, the function returns `0.0`', function test( t ) {
+	var expected;
+	var norm;
+	var zx;
+
+	zx = new Complex128Array( [
+		1.0,
+		2.0,
+		3.0,
+		4.0
+	] );
+	expected = 0.0;
+
+	norm = dznrm2( 0, zx, 1, 0 );
+	t.strictEqual( norm, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided a `strideX` parameter less than `0`, the function returns `0.0`', function test( t ) {
+	var expected;
+	var norm;
+	var zx;
+
+	zx = new Complex128Array( [ 3.0, -4.0, 1.0, 15.0, 4.0, 3.0 ] );
+	expected = 0.0;
+
+	norm = dznrm2( zx.length, zx, -1, 0 );
+	t.strictEqual( norm, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports specifying a stride', function test( t ) {
+	var expected;
+	var norm;
+	var zx;
+
+	zx = new Complex128Array([
+		0.3, // 1
+		0.1, // 1
+		5.0,
+		8.0,
+		0.5, // 2
+		0.0, // 2
+		6.0,
+		9.0,
+		0.0, // 3
+		0.5, // 3
+		8.0,
+		3.0,
+		0.0, // 4
+		0.2, // 4
+		9.0,
+		4.0
+	]);
+	expected = 0.8;
+
+	norm = dznrm2( 4, zx, 2, 0 );
+	isApprox( t, norm, expected, 2 );
+	t.end();
+});
+
+tape( 'the function supports specifying an offset', function test( t ) {
+	var expected;
+	var norm;
+	var zx;
+
+	zx = new Complex128Array([
+		1.0,
+		2.0,
+		3.0, // 1
+		4.0, // 1
+		5.0, // 2
+		6.0, // 2
+		7.0, // 3
+		8.0, // 3
+		9.0,
+		10.0
+	]);
+	expected = 14.1;
+
+	norm = dznrm2( 3, zx, 1, 1 );
+	isApprox( t, norm, expected, 2 );
+	t.end();
+});

From 150dce776a58a0703a8c5da4fe26d1ce0cbefcda Mon Sep 17 00:00:00 2001
From: aman-095 <bhansali.1@iitj.ac.in>
Date: Tue, 25 Jun 2024 12:49:28 +0530
Subject: [PATCH 02/16] refactor: update implementation and descriptions

---
 .../@stdlib/blas/base/dznrm2/README.md        | 115 +++++++++++++++--
 .../blas/base/dznrm2/benchmark/benchmark.js   |   5 +-
 .../dznrm2/benchmark/benchmark.ndarray.js     |   3 +-
 .../@stdlib/blas/base/dznrm2/docs/repl.txt    |  32 ++---
 .../blas/base/dznrm2/docs/types/index.d.ts    |  18 +--
 .../blas/base/dznrm2/examples/index.js        |   6 +-
 .../@stdlib/blas/base/dznrm2/lib/dznrm2.js    |  48 ++-----
 .../@stdlib/blas/base/dznrm2/lib/ndarray.js   | 122 ++++++++++++++----
 8 files changed, 241 insertions(+), 108 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/README.md b/lib/node_modules/@stdlib/blas/base/dznrm2/README.md
index d2555a075aaa..c7ffa367638f 100644
--- a/lib/node_modules/@stdlib/blas/base/dznrm2/README.md
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/README.md
@@ -20,7 +20,7 @@ limitations under the License.
 
 # dznrm2
 
-> Find the euclidean norm of a complex double-precision floating-point vector.
+> Compute the L2-norm of a complex double-precision floating-point vector.
 
 <section class="usage">
 
@@ -32,7 +32,7 @@ var dznrm2 = require( '@stdlib/blas/base/dznrm2' );
 
 #### dznrm2( N, zx, strideX )
 
-Finds the euclidean norm of a complex double-precision floating-point vector.
+Computes the L2-norm of a complex double-precision floating-point vector.
 
 ```javascript
 var Complex128Array = require( '@stdlib/array/complex128' );
@@ -49,7 +49,7 @@ The function has the following parameters:
 -   **zx**: input [`Complex128Array`][@stdlib/array/complex128].
 -   **strideX**: index increment for `zx`.
 
-The `N` and `strideX` parameters determine which elements in `zx` are accessed at runtime. For example, to traverse every other value,
+The `N` and stride parameters determine which elements in the strided array are accessed at runtime. For example, to traverse every other value,
 
 ```javascript
 var Complex128Array = require( '@stdlib/array/complex128' );
@@ -71,14 +71,14 @@ var zx0 = new Complex128Array( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );
 // Create an offset view:
 var zx1 = new Complex128Array( zx0.buffer, zx0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
 
-// Find euclidean norm:
+// Compute the L2-norm:
 var norm = dznrm2( 2, zx1, 1 );
 // returns ~9.3
 ```
 
 #### dznrm2.ndarray( N, zx, strideX, offset )
 
-Finds the euclidean norm of a complex double-precision floating-point vector using alternative indexing semantics.
+Computes the L2-norm of a complex double-precision floating-point vector using alternative indexing semantics.
 
 ```javascript
 var Complex128Array = require( '@stdlib/array/complex128' );
@@ -100,7 +100,7 @@ var Complex128Array = require( '@stdlib/array/complex128' );
 
 var zx = new Complex128Array( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );
 
-var norm = dznrm2.ndarray( 3, zx, 1, 1 );
+var norm = dznrm2.ndarray( 2, zx, 1, 1 );
 // returns ~9.3
 ```
 
@@ -112,7 +112,7 @@ var norm = dznrm2.ndarray( 3, zx, 1, 1 );
 
 ## Notes
 
--   If `N < 1` or `strideX < 0`, both functions return `0.0`.
+-   If `N <= 0`, both functions return `0.0`.
 -   `dznrm2()` corresponds to the [BLAS][blas] level 1 function [`dznrm2`][dznrm2].
 
 </section>
@@ -128,7 +128,7 @@ var norm = dznrm2.ndarray( 3, zx, 1, 1 );
 ```javascript
 var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
 var filledarrayBy = require( '@stdlib/array/filled-by' );
-var Complex128 = require( '@stdlib/complex/float32' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
 var dznrm2 = require( '@stdlib/blas/base/dznrm2' );
 
 function rand() {
@@ -138,7 +138,7 @@ function rand() {
 var zx = filledarrayBy( 10, 'complex128', rand );
 console.log( zx.toString() );
 
-// Finds the euclidean norm:
+// Computes the L2-norm:
 var norm = dznrm2( zx.length, zx, 1 );
 console.log( norm );
 ```
@@ -147,6 +147,101 @@ console.log( norm );
 
 <!-- /.examples -->
 
+<!-- C interface documentation. -->
+
+* * *
+
+<section class="c">
+
+## C APIs
+
+<!-- Section to include introductory text. Make sure to keep an empty line after the intro `section` element and another before the `/section` close. -->
+
+<section class="intro">
+
+</section>
+
+<!-- /.intro -->
+
+<!-- C usage documentation. -->
+
+<section class="usage">
+
+### Usage
+
+```c
+#include "stdlib/blas/base/dznrm2.h"
+```
+
+#### c_dznrm2( N, \*ZX, strideX )
+
+Computes the L2-norm of a complex double-precision floating-point vector.
+
+```c
+const double zx[] = { 0.3, 0.1, 0.5, 0.0, 0.0, 0.5, 0.0, 0.2 };
+
+double norm = c_dznrm2( 4, (void *)zx, 1 );
+// returns 0.8
+```
+
+The function accepts the following arguments:
+
+-   **N**: `[in] CBLAS_INT` number of indexed elements.
+-   **ZX**: `[in] void*` input array.
+-   **strideX**: `[in] CBLAS_INT` index increment for `ZX`.
+
+```c
+double c_dznrm2( const CBLAS_INT N, const void *ZX, const CBLAS_INT strideX );
+```
+
+</section>
+
+<!-- /.usage -->
+
+<!-- C API usage notes. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="notes">
+
+</section>
+
+<!-- /.notes -->
+
+<!-- C API usage examples. -->
+
+<section class="examples">
+
+### Examples
+
+```c
+#include "stdlib/blas/base/dznrm2.h"
+#include <stdio.h>
+
+int main( void ) {
+    // Create a strided array of interleaved real and imaginary components:
+    const double zx[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 };
+
+    // Specify the number of elements:
+    const int N = 4;
+
+    // Specify stride length:
+    const int strideX = 1;
+
+    // Compute the L2-norm:
+    c_dznrm2( N, (void *)zx, strideX );
+
+    // Print the result:
+    printf( "L2-norm: %lf\n", norm );
+}
+```
+
+</section>
+
+<!-- /.examples -->
+
+</section>
+
+<!-- /.c -->
+
 <!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
 
 <section class="related">
@@ -161,7 +256,7 @@ console.log( norm );
 
 [blas]: http://www.netlib.org/blas
 
-[dznrm2]: http://www.netlib.org/lapack/explore-html/de/da4/group__double__blas__level1.html
+[dznrm2]: https://netlib.org/lapack/explore-html//d1/d2a/group__nrm2_ga7f9f9febc6dc1836c9f5e7c1aa00b743.html
 
 [@stdlib/array/complex128]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/complex128
 
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.js
index b6cbe29e6f14..eb73b9f0b2e0 100644
--- a/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.js
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.js
@@ -46,8 +46,7 @@ var options = {
 * @returns {Function} benchmark function
 */
 function createBenchmark( len ) {
-	var cx = uniform( len, -10.0, 10.0, options );
-	cx = new Complex128Array( cx.buffer );
+	var zx = new Complex128Array( uniform( len*2, -10.0, 10.0, options ) );
 	return benchmark;
 
 	function benchmark( b ) {
@@ -56,7 +55,7 @@ function createBenchmark( len ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			norm = dznrm2( cx.length, cx, 1 );
+			norm = dznrm2( zx.length, zx, 1 );
 			if ( isnan( norm ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.ndarray.js
index 3d97028d378e..d4960e769858 100644
--- a/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.ndarray.js
@@ -46,8 +46,7 @@ var options = {
 * @returns {Function} benchmark function
 */
 function createBenchmark( len ) {
-	var zx = uniform( len, -10.0, 10.0, options );
-	zx = new Complex128Array( zx.buffer );
+	var zx = new Complex128Array( uniform( len*2, -10.0, 10.0, options ) );
 	return benchmark;
 
 	function benchmark( b ) {
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/docs/repl.txt b/lib/node_modules/@stdlib/blas/base/dznrm2/docs/repl.txt
index 1f1cc455d59c..6885dc313541 100644
--- a/lib/node_modules/@stdlib/blas/base/dznrm2/docs/repl.txt
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/docs/repl.txt
@@ -1,22 +1,22 @@
 
 {{alias}}( N, zx, strideX )
-    Finds the the euclidean norm of a complex double-precision floating-point
+    Computes the L2-norm of a complex double-precision floating-point
     vector.
 
-    The `N` and `strideX` parameters determine which elements in `zx` are
-    accessed at runtime.
+    The `N` and stride parameters determine which elements in the strided array
+    are accessed at runtime.
 
     Indexing is relative to the first index. To introduce an offset, use typed
     array views.
 
-    If `N < 1` or `strideX < 0`, the function returns `0.0`.
+    If `N <= 0`, the function returns `0.0`.
 
     Parameters
     ----------
     N: integer
         Number of indexed elements.
 
-    zx: Complex64Array
+    zx: Complex128Array
         Input array.
 
     strideX: integer
@@ -25,7 +25,7 @@
     Returns
     -------
     norm: number
-        Euclidean norm.
+        L2-norm.
 
     Examples
     --------
@@ -35,9 +35,9 @@
     ~0.77
 
     // Using `N` and stride parameters:
-    > zx = new {{alias:@stdlib/array/complex128}}( [ -2.0, 1.0, 3.0, -5.0 ] );
-    > norm = {{alias}}( 1, zx, 2 )
-    ~2.2
+    > zx = new {{alias:@stdlib/array/complex128}}( [ 3.0, -4.0, 0.0, 0.0, 5.0, -6.0 ] );
+    > out = {{alias}}( 2, zx, 2 )
+    ~9.3
 
     // Using view offsets:
     > var zx0 = new {{alias:@stdlib/array/complex128}}( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );
@@ -47,7 +47,7 @@
 
 
 {{alias}}.ndarray( N, zx, strideX, offsetX )
-    Finds the euclidean norm of a complex double-precision floating-point
+    Computes the L2-norm of a complex double-precision floating-point
     vector using alternative indexing semantics.
 
     While typed array views mandate a view offset based on the underlying
@@ -59,7 +59,7 @@
     N: integer
         Number of indexed elements.
 
-    zx: Complex64Array
+    zx: Complex128Array
         Input array.
 
     strideX: integer
@@ -71,18 +71,18 @@
     Returns
     -------
     norm: number
-        Euclidean norm.
+        L2-norm.
 
     Examples
     --------
     // Standard Usage:
-    > var zx = new {{alias:@stdlib/array/complex128}}( [ -2.0, 1.0, 3.0, -5.0 ] );
-    > var norm = {{alias}}.ndarray( 1, zx, 2, 0 )
-    ~2.2
+    > var zx = new {{alias:@stdlib/array/complex128}}( [ 3.0, -4.0, 0.0, 0.0, 5.0, -6.0 ] );
+    > var out = {{alias}}.ndarray( 2, zx, 2, 0 )
+    ~9.3
 
     // Using an index offset:
     > zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );
-    > norm = {{alias}}.ndarray( 3, zx, 1, 1 )
+    > norm = {{alias}}.ndarray( 2, zx, 1, 1 )
     ~9.3
 
     See Also
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/base/dznrm2/docs/types/index.d.ts
index a9b756ea1c47..76c7073965e2 100644
--- a/lib/node_modules/@stdlib/blas/base/dznrm2/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/docs/types/index.d.ts
@@ -27,12 +27,12 @@ import { Complex128Array } from '@stdlib/types/array';
 */
 interface Routine {
 	/**
-	* Finds the euclidean norm of a complex double-precision floating-point vector.
+	* Computes the L2-norm of a complex double-precision floating-point vector.
 	*
 	* @param N - number of indexed elements
 	* @param zx - input array
 	* @param strideX - stride length for `zx`
-	* @returns euclidean norm
+	* @returns L2-norm
 	*
 	* @example
 	* var Complex128Array = require( '@stdlib/array/complex128' );
@@ -45,13 +45,13 @@ interface Routine {
 	( N: number, x: Complex128Array, strideX: number ): number;
 
 	/**
-	* Finds the euclidean norm of a complex double-precision floating-point vector using alternative indexing semantics.
+	* Computes the L2-norm of a complex double-precision floating-point vector using alternative indexing semantics.
 	*
 	* @param N - number of indexed elements
 	* @param zx - input array
 	* @param strideX - stride length for `zx`
 	* @param offsetX - starting index for `zx`
-	* @returns index value
+	* @returns L2-norm
 	*
 	* @example
 	* var Complex128Array = require( '@stdlib/array/complex128' );
@@ -65,20 +65,20 @@ interface Routine {
 }
 
 /**
-* Finds the euclidean norm of a complex double-precision floating-point vector.
+* Computes the L2-norm of a complex double-precision floating-point vector.
 *
 * @param N - number of indexed elements
 * @param zx - input array
 * @param strideX - stride length for `zx`
-* @returns index value
+* @returns L2-norm
 *
 * @example
 * var Complex128Array = require( '@stdlib/array/complex128' );
 *
-* var x = new Complex128Array( [ -2.0, 1.0, 3.0, -5.0 ] );
+* var x = new Complex128Array( [ 3.0, -4.0, 0.0, 0.0, 5.0, -6.0 ] );
 *
-* var norm = dznrm2( 1, zx, 2 );
-* // returns ~2.2
+* var norm = dznrm2( 2, zx, 2 );
+* // returns ~9.3
 *
 * @example
 * var Complex128Array = require( '@stdlib/array/complex128' );
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/examples/index.js b/lib/node_modules/@stdlib/blas/base/dznrm2/examples/index.js
index 211248525ffb..781b52d6c6a9 100644
--- a/lib/node_modules/@stdlib/blas/base/dznrm2/examples/index.js
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/examples/index.js
@@ -20,16 +20,16 @@
 
 var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
 var filledarrayBy = require( '@stdlib/array/filled-by' );
-var Complex128 = require( '@stdlib/complex/float64' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
 var dznrm2 = require( '@stdlib/blas/base/dznrm2' );
 
 function rand() {
 	return new Complex128( discreteUniform( 0, 10 ), discreteUniform( -5, 5 ) );
 }
 
-var zx = filledarrayBy( 10, 'complex64', rand );
+var zx = filledarrayBy( 10, 'complex128', rand );
 console.log( zx.toString() );
 
-// Finds the euclidean norm:
+// Computes the L2-norm:
 var norm = dznrm2( zx.length, zx, 1 );
 console.log( norm );
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/lib/dznrm2.js b/lib/node_modules/@stdlib/blas/base/dznrm2/lib/dznrm2.js
index ff63ec71b59a..832556fd9e6a 100644
--- a/lib/node_modules/@stdlib/blas/base/dznrm2/lib/dznrm2.js
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/lib/dznrm2.js
@@ -20,21 +20,18 @@
 
 // MODULES //
 
-var abs = require( '@stdlib/math/base/special/abs' );
-var imag = require( '@stdlib/complex/imag' );
-var real = require( '@stdlib/complex/real' );
-var sqrt = require( '@stdlib/math/base/special/sqrt' );
+var ndarray = require( './ndarray.js' );
 
 
 // MAIN //
 
 /**
-* Finds the euclidean norm of a complex double-precision floating-point vector.
+* Computes the L2-norm of a complex double-precision floating-point vector.
 *
 * @param {PositiveInteger} N - number of indexed elements
 * @param {Complex128Array} zx - input array
-* @param {NonNegativeInteger} strideX - `zx` stride length
-* @returns {number} index value
+* @param {integer} strideX - `zx` stride length
+* @returns {number} L2-norm
 *
 * @example
 * var Complex128Array = require( '@stdlib/array/complex128' );
@@ -45,39 +42,16 @@ var sqrt = require( '@stdlib/math/base/special/sqrt' );
 * // returns ~0.8
 */
 function dznrm2( N, zx, strideX ) {
-	var scale;
-	var norm;
-	var temp;
-	var ssq;
-	var ix;
-
-	if ( N < 1 || strideX < 0 ) {
+	var ox;
+	if ( N <= 0 ) {
 		return 0.0;
 	}
-	scale = 0.0;
-	ssq = 1.0;
-	for ( ix = 0; ix <= ( N - 1 ) * strideX; ix += strideX ) {
-		if ( real( zx.get( ix ) ) !== 0.0 ) {
-			temp = abs( real( zx.get( ix ) ) );
-			if ( scale < temp ) {
-				ssq = 1.0 + ( ssq * ( ( scale / temp ) * ( scale / temp ) ) );
-				scale = temp;
-			} else {
-				ssq += ( ( temp / scale ) * ( temp / scale ) );
-			}
-		}
-		if ( imag( zx.get( ix ) ) !== 0.0 ) {
-			temp = abs( imag( zx.get( ix ) ) );
-			if ( scale < temp ) {
-				ssq = 1.0 + ( ssq * ( ( scale / temp ) * ( scale / temp ) ) );
-				scale = temp;
-			} else {
-				ssq += ( ( temp / scale ) * ( temp / scale ) );
-			}
-		}
-		norm = scale * sqrt( ssq );
+	if ( strideX < 0 ) {
+		ox = ( 1 - N ) * strideX;
+	} else {
+		ox = 0;
 	}
-	return norm;
+	return ndarray( N, zx, strideX, ox );
 }
 
 
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/lib/ndarray.js b/lib/node_modules/@stdlib/blas/base/dznrm2/lib/ndarray.js
index fa4e1d05d8bd..2873ef15e6a5 100644
--- a/lib/node_modules/@stdlib/blas/base/dznrm2/lib/ndarray.js
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/lib/ndarray.js
@@ -20,22 +20,32 @@
 
 // MODULES //
 
+var FLOAT64_MAX = require( '@stdlib/constants/float64/max' );
 var abs = require( '@stdlib/math/base/special/abs' );
-var imag = require( '@stdlib/complex/imag' );
-var real = require( '@stdlib/complex/real' );
+var abs2 = require( '@stdlib/math/base/special/abs2' );
 var sqrt = require( '@stdlib/math/base/special/sqrt' );
+var reinterpret = require( '@stdlib/strided/base/reinterpret-complex128' );
+
+
+// VARIABLES //
+
+// Blue's scaling constants:
+var tsml = 1.4916681462400413E-154;
+var tbig = 1.9979190722022350E+146;
+var ssml = 4.4989137945431964E+161;
+var sbig = 1.1113793747425387E-162;
 
 
 // MAIN //
 
 /**
-* Finds the euclidean norm of a complex double-precision floating-point vector.
+* Computes the L2-norm of a complex single-precision floating-point vector.
 *
 * @param {PositiveInteger} N - number of indexed elements
 * @param {Complex128Array} zx - input array
-* @param {NonNegativeInteger} strideX - `zx` stride length
+* @param {integer} strideX - `zx` stride length
 * @param {NonNegativeInteger} offsetX - starting index for `zx`
-* @returns {number} index value
+* @returns {number} L2-norm
 *
 * @example
 * var Complex128Array = require( '@stdlib/array/complex128' );
@@ -46,39 +56,95 @@ var sqrt = require( '@stdlib/math/base/special/sqrt' );
 * // returns ~0.8
 */
 function dznrm2( N, zx, strideX, offsetX ) {
-	var scale;
-	var norm;
-	var temp;
-	var ssq;
+	var notbig;
+	var sumsq;
+	var viewX;
+	var abig;
+	var amed;
+	var asml;
+	var ymax;
+	var ymin;
+	var scl;
+	var ax;
 	var ix;
+	var sx;
+	var i;
 
-	if ( N < 1 || strideX < 0 ) {
+	if ( N <= 0 ) {
 		return 0.0;
 	}
-	scale = 0.0;
-	ssq = 1.0;
-	for ( ix = offsetX; ix <= ( N - 1 ) * strideX; ix += strideX ) {
-		if ( real( zx.get( ix ) ) !== 0.0 ) {
-			temp = abs( real( zx.get( ix ) ) );
-			if ( scale < temp ) {
-				ssq = 1.0 + ( ssq * ( scale / temp ) * ( scale / temp ) );
-				scale = temp;
-			} else {
-				ssq += ( ( temp / scale ) * ( temp / scale ) );
+	// Reinterpret the input array as a real-valued array comprised of interleaved real and imaginary components:
+	viewX = reinterpret( zx, 0 );
+	sx = strideX * 2;
+	ix = offsetX * 2;
+
+	// Initialize loop values for accumulation:
+	notbig = true;
+
+	sumsq = 0.0;
+	abig = 0.0;
+	amed = 0.0;
+	asml = 0.0;
+	scl = 1.0;
+
+	// Compute the sum of squares using 3 accumulators--`abig` (sum of squares scaled down to avoid overflow), `asml` (sum of squares scaled up to avoid underflow), `amed` (sum of squares that do not require scaling)--and thresholds and multipliers--`tbig` (values bigger than this are scaled down by `sbig`) and `tsml` (values smaller than this are scaled up by `ssml`)...
+	for ( i = 0; i < N; i++ ) {
+		ax = abs( viewX[ ix ] );
+		if ( ax > tbig ) {
+			abig += abs2( ax * sbig );
+			notbig = false;
+		} else if ( ax < tsml ) {
+			if ( notbig ) {
+				asml += abs2( ax * ssml );
+			}
+		} else {
+			amed += ( ax * ax );
+		}
+		ax = abs( viewX[ ix + 1 ] );
+		if ( ax > tbig ) {
+			abig += abs2( ax * sbig );
+			notbig = false;
+		} else if ( ax < tsml ) {
+			if ( notbig ) {
+				asml += abs2( ax * ssml );
 			}
+		} else {
+			amed += ( ax * ax );
+		}
+		ix += sx;
+	}
+	// Combine `abig` and `amed` or `amed` and `asml` if more than one accumulator was used...
+	if ( abig > 0.0 ) {
+		// Combine `abig` and `amed` if `abig` > 0...
+		if ( amed > 0.0 || ( amed > FLOAT64_MAX ) || ( amed !== amed ) ) {
+			abig += ( ( amed * sbig ) * sbig );
 		}
-		if ( imag( zx.get( ix ) ) !== 0.0 ) {
-			temp = abs( imag( zx.get( ix ) ) );
-			if ( scale < temp ) {
-				ssq = 1.0 + ( ssq * ( scale / temp ) * ( scale / temp ) );
-				scale = temp;
+		scl = ( 1.0 / sbig );
+		sumsq = abig;
+	} else if ( asml > 0.0 ) {
+		// Combine `amed` and `asml` if `asml` > 0...
+		if ( amed > 0.0 || amed > FLOAT64_MAX || ( amed !== amed ) ) {
+			amed = sqrt( amed );
+			asml = sqrt( asml ) / ssml;
+			if ( asml > amed ) {
+				ymin = amed;
+				ymax = asml;
 			} else {
-				ssq += ( ( temp / scale ) * ( temp / scale ) );
+				ymin = asml;
+				ymax = amed;
 			}
+			scl = 1.0;
+			sumsq = ( ymax * ymax ) * ( 1.0 + abs2( ymin / ymax ) );
+		} else {
+			scl = ( 1.0 / ssml );
+			sumsq = asml;
 		}
-		norm = scale * sqrt( ssq );
+	} else {
+		// All values are mid-range...
+		scl = 1.0;
+		sumsq = amed;
 	}
-	return norm;
+	return sqrt( sumsq ) * scl;
 }
 
 

From de2f447ad76479bf4b35f7b83a12b082dc12e5e4 Mon Sep 17 00:00:00 2001
From: aman-095 <bhansali.1@iitj.ac.in>
Date: Tue, 25 Jun 2024 12:56:33 +0530
Subject: [PATCH 03/16] test: update test cases based on implementation

---
 .../blas/base/dznrm2/test/test.dznrm2.js      | 72 +++++++++++--------
 .../blas/base/dznrm2/test/test.ndarray.js     | 72 +++++++++++--------
 2 files changed, 88 insertions(+), 56 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.dznrm2.js b/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.dznrm2.js
index f548f53a1ce4..5c4e27abfd35 100644
--- a/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.dznrm2.js
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.dznrm2.js
@@ -69,9 +69,9 @@ tape( 'the function has an arity of 3', function test( t ) {
 	t.end();
 });
 
-tape( 'the function finds the euclidean norm', function test( t ) {
+tape( 'the function computes the L2-norm', function test( t ) {
 	var expected;
-	var norm;
+	var actual;
 	var zx;
 
 	zx = new Complex128Array([
@@ -88,10 +88,10 @@ tape( 'the function finds the euclidean norm', function test( t ) {
 	]);
 	expected = 0.8;
 
-	norm = dznrm2( 4, zx, 1 );
-	isApprox( t, norm, expected, 2 );
+	actual = dznrm2( 4, zx, 1 );
+	isApprox( t, actual, expected, 2.0 );
 
-	zx = new Complex128Array( [
+	zx = new Complex128Array([
 		0.1,  // 1
 		0.1,  // 1
 		-0.6, // 2
@@ -100,50 +100,66 @@ tape( 'the function finds the euclidean norm', function test( t ) {
 		-0.3, // 3
 		7.0,
 		8.0
-	] );
+	]);
 	expected = 0.7;
 
-	norm = dznrm2( 3, zx, 1 );
-	isApprox( t, norm, expected, 2 );
+	actual = dznrm2( 3, zx, 1 );
+	isApprox( t, actual, expected, 2.0 );
 	t.end();
 });
 
-tape( 'if provided an `N` parameter less than `1`, the function returns `0.0`', function test( t ) {
+tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `0.0`', function test( t ) {
 	var expected;
-	var norm;
+	var actual;
 	var zx;
 
-	zx = new Complex128Array( [
+	zx = new Complex128Array([
 		1.0,
 		2.0,
 		3.0,
 		4.0
-	] );
+	]);
 	expected = 0.0;
 
-	norm = dznrm2( 0, zx, 1 );
-	t.strictEqual( norm, expected, 'returns expected value' );
+	actual = dznrm2( 0, zx, 1 );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
 
-tape( 'if provided a `strideX` parameter less than `0`, the function returns `0.0`', function test( t ) {
+tape( 'the function supports specifying a stride', function test( t ) {
 	var expected;
-	var norm;
+	var actual;
 	var zx;
 
-	zx = new Complex128Array( [ 3.0, -4.0, 1.0, 15.0, 4.0, 3.0 ] );
-	expected = 0.0;
-
-	norm = dznrm2( zx.length, zx, -1 );
-	t.strictEqual( norm, expected, 'returns expected value' );
+	zx = new Complex128Array([
+		0.3, // 1
+		0.1, // 1
+		5.0,
+		8.0,
+		0.5, // 2
+		0.0, // 2
+		6.0,
+		9.0,
+		0.0, // 3
+		0.5, // 3
+		8.0,
+		3.0,
+		0.0, // 4
+		0.2, // 4
+		9.0,
+		4.0
+	]);
+	expected = 0.8;
 
+	actual = dznrm2( 4, zx, 2 );
+	isApprox( t, actual, expected, 2.0 );
 	t.end();
 });
 
-tape( 'the function supports specifying a stride', function test( t ) {
+tape( 'the function supports specifying a negative stride', function test( t ) {
 	var expected;
-	var norm;
+	var actual;
 	var zx;
 
 	zx = new Complex128Array([
@@ -166,14 +182,14 @@ tape( 'the function supports specifying a stride', function test( t ) {
 	]);
 	expected = 0.8;
 
-	norm = dznrm2( 4, zx, 2 );
-	isApprox( t, norm, expected, 2 );
+	actual = dznrm2( 4, zx, -2 );
+	isApprox( t, actual, expected, 2.0 );
 	t.end();
 });
 
 tape( 'the function supports view offsets', function test( t ) {
 	var expected;
-	var norm;
+	var actual;
 	var zx0;
 	var zx1;
 
@@ -193,7 +209,7 @@ tape( 'the function supports view offsets', function test( t ) {
 
 	zx1 = new Complex128Array( zx0.buffer, zx0.BYTES_PER_ELEMENT*1 );
 
-	norm = dznrm2( 3, zx1, 1 );
-	isApprox( t, norm, expected, 2 );
+	actual = dznrm2( 3, zx1, 1 );
+	isApprox( t, actual, expected, 2.0 );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.ndarray.js
index a8f0a660da88..d1b7b4acd2c0 100644
--- a/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.ndarray.js
@@ -69,9 +69,9 @@ tape( 'the function has an arity of 4', function test( t ) {
 	t.end();
 });
 
-tape( 'the function finds the euclidean norm', function test( t ) {
+tape( 'the function computes the L2-norm', function test( t ) {
 	var expected;
-	var norm;
+	var actual;
 	var zx;
 
 	zx = new Complex128Array([
@@ -88,10 +88,10 @@ tape( 'the function finds the euclidean norm', function test( t ) {
 	]);
 	expected = 0.8;
 
-	norm = dznrm2( 4, zx, 1, 0 );
-	isApprox( t, norm, expected, 2 );
+	actual = dznrm2( 4, zx, 1, 0 );
+	isApprox( t, actual, expected, 2.0 );
 
-	zx = new Complex128Array( [
+	zx = new Complex128Array([
 		0.1,  // 1
 		0.1,  // 1
 		-0.6, // 2
@@ -100,50 +100,66 @@ tape( 'the function finds the euclidean norm', function test( t ) {
 		-0.3, // 3
 		7.0,
 		8.0
-	] );
+	]);
 	expected = 0.7;
 
-	norm = dznrm2( 3, zx, 1, 0 );
-	isApprox( t, norm, expected, 2 );
+	actual = dznrm2( 3, zx, 1, 0 );
+	isApprox( t, actual, expected, 2.0 );
 	t.end();
 });
 
-tape( 'if provided an `N` parameter less than `1`, the function returns `0.0`', function test( t ) {
+tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `0.0`', function test( t ) {
 	var expected;
-	var norm;
+	var actual;
 	var zx;
 
-	zx = new Complex128Array( [
+	zx = new Complex128Array([
 		1.0,
 		2.0,
 		3.0,
 		4.0
-	] );
+	]);
 	expected = 0.0;
 
-	norm = dznrm2( 0, zx, 1, 0 );
-	t.strictEqual( norm, expected, 'returns expected value' );
+	actual = dznrm2( 0, zx, 1, 0 );
+	t.strictEqual( actual, expected, 'returns expected value' );
 
 	t.end();
 });
 
-tape( 'if provided a `strideX` parameter less than `0`, the function returns `0.0`', function test( t ) {
+tape( 'the function supports specifying a stride', function test( t ) {
 	var expected;
-	var norm;
+	var actual;
 	var zx;
 
-	zx = new Complex128Array( [ 3.0, -4.0, 1.0, 15.0, 4.0, 3.0 ] );
-	expected = 0.0;
-
-	norm = dznrm2( zx.length, zx, -1, 0 );
-	t.strictEqual( norm, expected, 'returns expected value' );
+	zx = new Complex128Array([
+		0.3, // 1
+		0.1, // 1
+		5.0,
+		8.0,
+		0.5, // 2
+		0.0, // 2
+		6.0,
+		9.0,
+		0.0, // 3
+		0.5, // 3
+		8.0,
+		3.0,
+		0.0, // 4
+		0.2, // 4
+		9.0,
+		4.0
+	]);
+	expected = 0.8;
 
+	actual = dznrm2( 4, zx, 2, 0 );
+	isApprox( t, actual, expected, 2.0 );
 	t.end();
 });
 
-tape( 'the function supports specifying a stride', function test( t ) {
+tape( 'the function supports specifying a negative stride', function test( t ) {
 	var expected;
-	var norm;
+	var actual;
 	var zx;
 
 	zx = new Complex128Array([
@@ -166,14 +182,14 @@ tape( 'the function supports specifying a stride', function test( t ) {
 	]);
 	expected = 0.8;
 
-	norm = dznrm2( 4, zx, 2, 0 );
-	isApprox( t, norm, expected, 2 );
+	actual = dznrm2( 4, zx, -2, 6 );
+	isApprox( t, actual, expected, 2.0 );
 	t.end();
 });
 
 tape( 'the function supports specifying an offset', function test( t ) {
 	var expected;
-	var norm;
+	var actual;
 	var zx;
 
 	zx = new Complex128Array([
@@ -190,7 +206,7 @@ tape( 'the function supports specifying an offset', function test( t ) {
 	]);
 	expected = 14.1;
 
-	norm = dznrm2( 3, zx, 1, 1 );
-	isApprox( t, norm, expected, 2 );
+	actual = dznrm2( 3, zx, 1, 1 );
+	isApprox( t, actual, expected, 2.0 );
 	t.end();
 });

From 3f4d8b4757a27660ac5e6d4b855639d645a82636 Mon Sep 17 00:00:00 2001
From: aman-095 <bhansali.1@iitj.ac.in>
Date: Tue, 25 Jun 2024 14:13:24 +0530
Subject: [PATCH 04/16] feat: add C / Fortran implementation for dznrm2

---
 .../base/dznrm2/benchmark/benchmark.native.js |  97 ++++
 .../benchmark/benchmark.ndarray.native.js     |  97 ++++
 .../blas/base/dznrm2/benchmark/c/Makefile     | 146 ++++++
 .../dznrm2/benchmark/c/benchmark.length.c     | 155 ++++++
 .../base/dznrm2/benchmark/fortran/Makefile    | 141 ++++++
 .../benchmark/fortran/benchmark.length.f      | 220 +++++++++
 .../@stdlib/blas/base/dznrm2/binding.gyp      | 265 ++++++++++
 .../blas/base/dznrm2/examples/c/Makefile      | 146 ++++++
 .../blas/base/dznrm2/examples/c/example.c     |  37 ++
 .../@stdlib/blas/base/dznrm2/include.gypi     |  70 +++
 .../dznrm2/include/stdlib/blas/base/dznrm2.h  |  43 ++
 .../include/stdlib/blas/base/dznrm2_cblas.h   |  43 ++
 .../include/stdlib/blas/base/dznrm2_fortran.h |  41 ++
 .../blas/base/dznrm2/lib/dznrm2.native.js     |  54 +++
 .../@stdlib/blas/base/dznrm2/lib/native.js    |  35 ++
 .../blas/base/dznrm2/lib/ndarray.native.js    |  58 +++
 .../@stdlib/blas/base/dznrm2/manifest.json    | 451 ++++++++++++++++++
 .../@stdlib/blas/base/dznrm2/package.json     |  10 +-
 .../@stdlib/blas/base/dznrm2/src/Makefile     |  70 +++
 .../@stdlib/blas/base/dznrm2/src/addon.c      |  45 ++
 .../@stdlib/blas/base/dznrm2/src/dznrm2.c     | 127 +++++
 .../@stdlib/blas/base/dznrm2/src/dznrm2.f     | 165 +++++++
 .../blas/base/dznrm2/src/dznrm2_cblas.c       |  32 ++
 .../@stdlib/blas/base/dznrm2/src/dznrm2_f.c   |  35 ++
 .../@stdlib/blas/base/dznrm2/src/dznrm2sub.f  |  47 ++
 .../base/dznrm2/test/test.dznrm2.native.js    | 224 +++++++++
 .../base/dznrm2/test/test.ndarray.native.js   | 221 +++++++++
 27 files changed, 3070 insertions(+), 5 deletions(-)
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.native.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.ndarray.native.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/c/Makefile
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/c/benchmark.length.c
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/fortran/Makefile
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/fortran/benchmark.length.f
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/binding.gyp
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/examples/c/Makefile
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/examples/c/example.c
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/include.gypi
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/include/stdlib/blas/base/dznrm2.h
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/include/stdlib/blas/base/dznrm2_cblas.h
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/include/stdlib/blas/base/dznrm2_fortran.h
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/lib/dznrm2.native.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/lib/native.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/lib/ndarray.native.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/manifest.json
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/src/Makefile
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/src/addon.c
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2.c
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2.f
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2_cblas.c
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2_f.c
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2sub.f
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/test/test.dznrm2.native.js
 create mode 100644 lib/node_modules/@stdlib/blas/base/dznrm2/test/test.ndarray.native.js

diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.native.js
new file mode 100644
index 000000000000..165592cd971c
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.native.js
@@ -0,0 +1,97 @@
+/**
+* @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 resolve = require( 'path' ).resolve;
+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 tryRequire = require( '@stdlib/utils/try-require' );
+var pkg = require( './../package.json' ).name;
+
+
+// VARIABLES //
+
+var dznrm2 = tryRequire( resolve( __dirname, './../lib/dznrm2.native.js' ) );
+var opts = {
+	'skip': ( dznrm2 instanceof Error )
+};
+var options = {
+	'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Create a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+	var zx = new Complex128Array( uniform( len*2, -10.0, 10.0, options ) );
+	return benchmark;
+
+	function benchmark( b ) {
+		var norm;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			norm = dznrm2( zx.length, zx, 1 );
+			if ( isnan( norm ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( norm ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+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+'::native:len='+len, opts, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.ndarray.native.js b/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.ndarray.native.js
new file mode 100644
index 000000000000..6ad40f056a17
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/benchmark.ndarray.native.js
@@ -0,0 +1,97 @@
+/**
+* @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 resolve = require( 'path' ).resolve;
+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 tryRequire = require( '@stdlib/utils/try-require' );
+var pkg = require( './../package.json' ).name;
+
+
+// VARIABLES //
+
+var dznrm2 = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) );
+var opts = {
+	'skip': ( dznrm2 instanceof Error )
+};
+var options = {
+	'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Create a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+	var zx = new Complex128Array( uniform( len*2, -10.0, 10.0, options ) );
+	return benchmark;
+
+	function benchmark( b ) {
+		var norm;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			norm = dznrm2( zx.length, zx, 1, 0 );
+			if ( isnan( norm ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( norm ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+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+'::native:ndarray:len='+len, opts, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/c/Makefile b/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/c/Makefile
new file mode 100644
index 000000000000..9f97140e7cb0
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/c/Makefile
@@ -0,0 +1,146 @@
+#/
+# @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.
+#/
+
+# VARIABLES #
+
+ifndef VERBOSE
+	QUIET := @
+else
+	QUIET :=
+endif
+
+# Determine the OS ([1][1], [2][2]).
+#
+# [1]: https://en.wikipedia.org/wiki/Uname#Examples
+# [2]: http://stackoverflow.com/a/27776822/2225624
+OS ?= $(shell uname)
+ifneq (, $(findstring MINGW,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring MSYS,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring CYGWIN,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring Windows_NT,$(OS)))
+	OS := WINNT
+endif
+endif
+endif
+endif
+
+# Define the program used for compiling C source files:
+ifdef C_COMPILER
+	CC := $(C_COMPILER)
+else
+	CC := gcc
+endif
+
+# Define the command-line options when compiling C files:
+CFLAGS ?= \
+	-std=c99 \
+	-O3 \
+	-Wall \
+	-pedantic
+
+# Determine whether to generate position independent code ([1][1], [2][2]).
+#
+# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options
+# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option
+ifeq ($(OS), WINNT)
+	fPIC ?=
+else
+	fPIC ?= -fPIC
+endif
+
+# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`):
+INCLUDE ?=
+
+# List of source files:
+SOURCE_FILES ?=
+
+# List of libraries (e.g., `-lopenblas -lpthread`):
+LIBRARIES ?=
+
+# List of library paths (e.g., `-L /foo/bar -L /beep/boop`):
+LIBPATH ?=
+
+# List of C targets:
+c_targets := benchmark.length.out
+
+
+# RULES #
+
+#/
+# Compiles source files.
+#
+# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`)
+# @param {string} [CFLAGS] - C compiler options
+# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`)
+# @param {string} [SOURCE_FILES] - list of source files
+# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`)
+# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`)
+#
+# @example
+# make
+#
+# @example
+# make all
+#/
+all: $(c_targets)
+
+.PHONY: all
+
+#/
+# Compiles C source files.
+#
+# @private
+# @param {string} CC - C compiler (e.g., `gcc`)
+# @param {string} CFLAGS - C compiler options
+# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`)
+# @param {string} SOURCE_FILES - list of source files
+# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`)
+# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`)
+#/
+$(c_targets): %.out: %.c
+	$(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES)
+
+#/
+# Runs compiled benchmarks.
+#
+# @example
+# make run
+#/
+run: $(c_targets)
+	$(QUIET) ./$<
+
+.PHONY: run
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean:
+	$(QUIET) -rm -f *.o *.out
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/c/benchmark.length.c b/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/c/benchmark.length.c
new file mode 100644
index 000000000000..2bc0f3896d9d
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/c/benchmark.length.c
@@ -0,0 +1,155 @@
+/**
+* @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.
+*/
+
+/**
+* Benchmark `dznrm2`.
+*/
+#include "stdlib/blas/base/dznrm2.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+#include <time.h>
+#include <sys/time.h>
+
+#define NAME "dznrm2"
+#define ITERATIONS 10000000
+#define REPEATS 3
+#define MIN 1
+#define MAX 6
+
+/**
+* Prints the TAP version.
+*/
+void print_version( void ) {
+	printf( "TAP version 13\n" );
+}
+
+/**
+* Prints the TAP summary.
+*
+* @param total     total number of tests
+* @param passing   total number of passing tests
+*/
+void print_summary( int total, int passing ) {
+	printf( "#\n" );
+	printf( "1..%d\n", total ); // TAP plan
+	printf( "# total %d\n", total );
+	printf( "# pass  %d\n", passing );
+	printf( "#\n" );
+	printf( "# ok\n" );
+}
+
+/**
+* Prints benchmarks results.
+*
+* @param iterations   number of iterations
+* @param elapsed      elapsed time in seconds
+*/
+void print_results( int iterations, double elapsed ) {
+	double rate = (double)iterations / elapsed;
+	printf( "  ---\n" );
+	printf( "  iterations: %d\n", iterations );
+	printf( "  elapsed: %0.9f\n", elapsed );
+	printf( "  rate: %0.9f\n", rate );
+	printf( "  ...\n" );
+}
+
+/**
+* Returns a clock time.
+*
+* @return clock time
+*/
+double tic( void ) {
+	struct timeval now;
+	gettimeofday( &now, NULL );
+	return (double)now.tv_sec + (double)now.tv_usec/1.0e6;
+}
+
+/**
+* Generates a random number on the interval [0,1].
+*
+* @return random number
+*/
+double rand_double( void ) {
+	int r = rand();
+	return (double)r / ( (double)RAND_MAX + 1.0 );
+}
+
+/**
+* Runs a benchmark.
+*
+* @param iterations   number of iterations
+* @param len          array length
+* @return elapsed time in seconds
+*/
+double benchmark( int iterations, int len ) {
+	double zx[ len*2 ];
+	double elapsed;
+	double norm;
+	double t;
+	int i;
+
+	for ( i = 0; i < len*2; i += 2 ) {
+		zx[ i ] = ( rand_double()*10000.0 ) - 5000.0;
+		zx[ i+1 ] = ( rand_double()*10000.0 ) - 5000.0;
+	}
+	norm = 0.0;
+	t = tic();
+	for ( i = 0; i < iterations; i++ ) {
+		norm = c_dznrm2( len, (void *)zx, 1 );
+		if ( norm != norm ) {
+			printf( "should not return NaN\n" );
+			break;
+		}
+	}
+	elapsed = tic() - t;
+	if ( norm != norm ) {
+		printf( "should not return NaN\n" );
+	}
+	return elapsed;
+}
+
+/**
+* Main execution sequence.
+*/
+int main( void ) {
+	double elapsed;
+	int count;
+	int iter;
+	int len;
+	int i;
+	int j;
+
+	// Use the current time to seed the random number generator:
+	srand( time( NULL ) );
+
+	print_version();
+	count = 0;
+	for ( i = MIN; i <= MAX; i++ ) {
+		len = pow( 10, i );
+		iter = ITERATIONS / pow( 10, i-1 );
+		for ( j = 0; j < REPEATS; j++ ) {
+			count += 1;
+			printf( "# c::%s:len=%d\n", NAME, len );
+			elapsed = benchmark( iter, len );
+			print_results( iter, elapsed );
+			printf( "ok %d benchmark finished\n", count );
+		}
+	}
+	print_summary( count, count );
+}
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/fortran/Makefile b/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/fortran/Makefile
new file mode 100644
index 000000000000..ea0bd243d7ef
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/fortran/Makefile
@@ -0,0 +1,141 @@
+#/
+# @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.
+#/
+
+# VARIABLES #
+
+ifndef VERBOSE
+	QUIET := @
+else
+	QUIET :=
+endif
+
+# Determine the OS ([1][1], [2][]2).
+#
+# [1]: https://en.wikipedia.org/wiki/Uname#Examples
+# [2]: http://stackoverflow.com/a/27776822/2225624
+OS ?= $(shell uname)
+ifneq (, $(findstring MINGW,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring MSYS,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring CYGWIN,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring Windows_NT,$(OS)))
+	OS := WINNT
+endif
+endif
+endif
+endif
+
+# Define the program used for compiling Fortran source files:
+ifdef FORTRAN_COMPILER
+	FC := $(FORTRAN_COMPILER)
+else
+	FC := gfortran
+endif
+
+# Define the command-line options when compiling Fortran files:
+FFLAGS ?= \
+	-std=f95 \
+	-ffree-form \
+	-O3 \
+	-Wall \
+	-Wextra \
+	-Wno-compare-reals \
+	-Wimplicit-interface \
+	-fno-underscoring \
+	-pedantic
+
+# Determine whether to generate position independent code ([1][1], [2][2]).
+#
+# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options
+# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option
+ifeq ($(OS), WINNT)
+	fPIC ?=
+else
+	fPIC ?= -fPIC
+endif
+
+# List of includes (e.g., `-I /foo/bar -I /beep/boop`):
+INCLUDE ?=
+
+# List of Fortran source files:
+SOURCE_FILES ?= ../../src/dznrm2.f
+
+# List of Fortran targets:
+f_targets := benchmark.length.out
+
+
+# RULES #
+
+#/
+# Compiles Fortran source files.
+#
+# @param {string} SOURCE_FILES - list of Fortran source files
+# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop`)
+# @param {string} [FORTRAN_COMPILER] - Fortran compiler
+# @param {string} [FFLAGS] - Fortran compiler flags
+# @param {(string|void)} [fPIC] - compiler flag indicating whether to generate position independent code
+#
+# @example
+# make
+#
+# @example
+# make all
+#/
+all: $(f_targets)
+
+.PHONY: all
+
+#/
+# Compiles Fortran source files.
+#
+# @private
+# @param {string} SOURCE_FILES - list of Fortran source files
+# @param {(string|void)} INCLUDE - list of includes (e.g., `-I /foo/bar -I /beep/boop`)
+# @param {string} FC - Fortran compiler
+# @param {string} FFLAGS - Fortran compiler flags
+# @param {(string|void)} fPIC - compiler flag indicating whether to generate position independent code
+#/
+$(f_targets): %.out: %.f
+	$(QUIET) $(FC) $(FFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $<
+
+#/
+# Runs compiled benchmarks.
+#
+# @example
+# make run
+#/
+run: $(f_targets)
+	$(QUIET) ./$<
+
+.PHONY: run
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean:
+	$(QUIET) -rm -f *.o *.out
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/fortran/benchmark.length.f b/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/fortran/benchmark.length.f
new file mode 100644
index 000000000000..3bdc20ee667e
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/benchmark/fortran/benchmark.length.f
@@ -0,0 +1,220 @@
+!>
+! @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.
+!<
+
+!> Benchmark `dznrm2`.
+!
+! ## Notes
+!
+! -   Written in "free form" Fortran 95.
+!
+!<
+program bench
+  implicit none
+  ! ..
+  ! Local constants:
+  character(6), parameter :: name = 'dznrm2' ! if changed, be sure to adjust length
+  integer, parameter :: iterations = 10000000
+  integer, parameter :: repeats = 3
+  integer, parameter :: min = 1
+  integer, parameter :: max = 6
+  ! ..
+  ! Run the benchmarks:
+  call main()
+  ! ..
+  ! Functions:
+contains
+  ! ..
+  ! Prints the TAP version.
+  ! ..
+  subroutine print_version()
+    print '(A)', 'TAP version 13'
+  end subroutine print_version
+  ! ..
+  ! Prints the TAP summary.
+  !
+  ! @param {integer} total - total number of tests
+  ! @param {integer} passing - total number of passing tests
+  ! ..
+  subroutine print_summary( total, passing )
+    ! ..
+    ! Scalar arguments:
+    integer, intent(in) :: total, passing
+    ! ..
+    ! Local variables:
+    character(len=999) :: str, tmp
+    ! ..
+    ! Intrinsic functions:
+    intrinsic adjustl, trim
+    ! ..
+    print '(A)', '#'
+    ! ..
+    write (str, '(I15)') total ! TAP plan
+    tmp = adjustl( str )
+    print '(A,A)', '1..', trim( tmp )
+    ! ..
+    print '(A,A)', '# total ', trim( tmp )
+    ! ..
+    write (str, '(I15)') passing
+    tmp = adjustl( str )
+    print '(A,A)', '# pass  ', trim( tmp )
+    ! ..
+    print '(A)', '#'
+    print '(A)', '# ok'
+  end subroutine print_summary
+  ! ..
+  ! Prints benchmarks results.
+  !
+  ! @param {integer} iterations - number of iterations
+  ! @param {double} elapsed - elapsed time in seconds
+  ! ..
+  subroutine print_results( iterations, elapsed )
+    ! ..
+    ! Scalar arguments:
+    double precision, intent(in) :: elapsed
+    integer, intent(in) :: iterations
+    ! ..
+    ! Local variables:
+    double precision :: rate
+    character(len=999) :: str, tmp
+    ! ..
+    ! Intrinsic functions:
+    intrinsic dble, adjustl, trim
+    ! ..
+    rate = dble( iterations ) / elapsed
+    ! ..
+    print '(A)', '  ---'
+    ! ..
+    write (str, '(I15)') iterations
+    tmp = adjustl( str )
+    print '(A,A)', '  iterations: ', trim( tmp )
+    ! ..
+    write (str, '(f0.9)') elapsed
+    tmp = adjustl( str )
+    print '(A,A)', '  elapsed: ', trim( tmp )
+    ! ..
+    write( str, '(f0.9)') rate
+    tmp = adjustl( str )
+    print '(A,A)', '  rate: ', trim( tmp )
+    ! ..
+    print '(A)', '  ...'
+  end subroutine print_results
+  ! ..
+  ! Runs a benchmark.
+  !
+  ! @param {integer} iterations - number of iterations
+  ! @param {integer} len - array length
+  ! @return {double} elapsed time in seconds
+  ! ..
+  double precision function benchmark( iterations, len )
+    ! ..
+    ! External functions:
+    interface
+      double precision function dznrm2( N, zx, strideX )
+        complex(kind=kind(0.0d0)) :: zx(*)
+        integer :: strideX, N
+      end function dznrm2
+    end interface
+    ! ..
+    ! Scalar arguments:
+    integer, intent(in) :: iterations, len
+    ! ..
+    ! Local scalars:
+    double precision :: elapsed, r1, r2, y
+    real :: t1, t2
+    integer :: i
+    ! ..
+    ! Local arrays:
+    complex(kind=kind(0.0d0)), allocatable :: x(:)
+    ! ..
+    ! Intrinsic functions:
+    intrinsic random_number, cpu_time, cmplx
+    ! ..
+    ! Allocate arrays:
+    allocate( x(len) )
+    ! ..
+    call random_number( r1 )
+    call random_number( r2 )
+    do i = 1, len
+      call random_number( r1 )
+      call random_number( r2 )
+      x( i ) = cmplx( (r1*10000.0d0)-5000.0d0, (r2*1000.0d0)-5000.0d0, kind=kind(0.0d0) )
+    end do
+    ! ..
+    y = 0.0d0
+    ! ..
+    call cpu_time( t1 )
+    ! ..
+    do i = 1, iterations
+      y = dznrm2( len, x, 1 );
+      if ( y /= y ) then
+        print '(A)', 'should not return NaN'
+        exit
+      end if
+    end do
+    ! ..
+    call cpu_time( t2 )
+    ! ..
+    elapsed = t2 - t1
+    ! ..
+    if ( y /= y ) then
+      print '(A)', 'should not return NaN'
+    end if
+    ! ..
+    ! Deallocate arrays:
+    deallocate( x )
+    ! ..
+    benchmark = elapsed
+    return
+  end function benchmark
+  ! ..
+  ! Main execution sequence.
+  ! ..
+  subroutine main()
+    ! ..
+    ! Local variables:
+    integer :: count, iter, len, i, j
+    double precision :: elapsed
+    character(len=999) :: str, tmp
+    ! ..
+    ! Intrinsic functions:
+    intrinsic adjustl, trim
+    ! ..
+    call print_version()
+    count = 0
+    do i = min, max
+      len = 10**i
+      iter = iterations / 10**(i-1)
+      do j = 1, repeats
+        count = count + 1
+        ! ..
+        write (str, '(I15)') len
+        tmp = adjustl( str )
+        print '(A,A,A,A)', '# fortran::native::', name, ':len=', trim( tmp )
+        ! ..
+        elapsed = benchmark( iter, len )
+        ! ..
+        call print_results( iter, elapsed )
+        ! ..
+        write (str, '(I15)') count
+        tmp = adjustl( str )
+        print '(A,A,A)', 'ok ', trim( tmp ), ' benchmark finished'
+      end do
+    end do
+    call print_summary( count, count )
+  end subroutine main
+end program bench
\ No newline at end of file
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/binding.gyp b/lib/node_modules/@stdlib/blas/base/dznrm2/binding.gyp
new file mode 100644
index 000000000000..02a2799da097
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/binding.gyp
@@ -0,0 +1,265 @@
+# @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.
+
+# A `.gyp` file for building a Node.js native add-on.
+#
+# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md
+# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md
+{
+  # List of files to include in this file:
+  'includes': [
+    './include.gypi',
+  ],
+
+  # Define variables to be used throughout the configuration for all targets:
+  'variables': {
+    # Target name should match the add-on export name:
+    'addon_target_name%': 'addon',
+
+    # Fortran compiler (to override -Dfortran_compiler=<compiler>):
+    'fortran_compiler%': 'gfortran',
+
+    # Fortran compiler flags:
+    'fflags': [
+      # Specify the Fortran standard to which a program is expected to conform:
+      '-std=f95',
+
+      # Indicate that the layout is free-form source code:
+      '-ffree-form',
+
+      # Aggressive optimization:
+      '-O3',
+
+      # Enable commonly used warning options:
+      '-Wall',
+
+      # Warn if source code contains problematic language features:
+      '-Wextra',
+
+      # Warn if a procedure is called without an explicit interface:
+      '-Wimplicit-interface',
+
+      # Do not transform names of entities specified in Fortran source files by appending underscores (i.e., don't mangle names, thus allowing easier usage in C wrappers):
+      '-fno-underscoring',
+
+      # Warn if source code contains Fortran 95 extensions and C-language constructs:
+      '-pedantic',
+
+      # Compile but do not link (output is an object file):
+      '-c',
+    ],
+
+    # Set variables based on the host OS:
+    'conditions': [
+      [
+        'OS=="win"',
+        {
+          # Define the object file suffix:
+          'obj': 'obj',
+        },
+        {
+          # Define the object file suffix:
+          'obj': 'o',
+        }
+      ], # end condition (OS=="win")
+    ], # end conditions
+  }, # end variables
+
+  # Define compile targets:
+  'targets': [
+
+    # Target to generate an add-on:
+    {
+      # The target name should match the add-on export name:
+      'target_name': '<(addon_target_name)',
+
+      # Define dependencies:
+      'dependencies': [],
+
+      # Define directories which contain relevant include headers:
+      'include_dirs': [
+        # Local include directory:
+        '<@(include_dirs)',
+      ],
+
+      # List of source files:
+      'sources': [
+        '<@(src_files)',
+      ],
+
+      # Settings which should be applied when a target's object files are used as linker input:
+      'link_settings': {
+        # Define libraries:
+        'libraries': [
+          '<@(libraries)',
+        ],
+
+        # Define library directories:
+        'library_dirs': [
+          '<@(library_dirs)',
+        ],
+      },
+
+      # C/C++ compiler flags:
+      'cflags': [
+        # Enable commonly used warning options:
+        '-Wall',
+
+        # Aggressive optimization:
+        '-O3',
+      ],
+
+      # C specific compiler flags:
+      'cflags_c': [
+        # Specify the C standard to which a program is expected to conform:
+        '-std=c99',
+      ],
+
+      # C++ specific compiler flags:
+      'cflags_cpp': [
+        # Specify the C++ standard to which a program is expected to conform:
+        '-std=c++11',
+      ],
+
+      # Linker flags:
+      'ldflags': [],
+
+      # Apply conditions based on the host OS:
+      'conditions': [
+        [
+          'OS=="mac"',
+          {
+            # Linker flags:
+            'ldflags': [
+              '-undefined dynamic_lookup',
+              '-Wl,-no-pie',
+              '-Wl,-search_paths_first',
+            ],
+          },
+        ], # end condition (OS=="mac")
+        [
+          'OS!="win"',
+          {
+            # C/C++ flags:
+            'cflags': [
+              # Generate platform-independent code:
+              '-fPIC',
+            ],
+          },
+        ], # end condition (OS!="win")
+      ], # end conditions
+
+      # Define custom build actions for particular inputs:
+      'rules': [
+        {
+          # Define a rule for processing Fortran files:
+          'extension': 'f',
+
+          # Define the pathnames to be used as inputs when performing processing:
+          'inputs': [
+            # Full path of the current input:
+            '<(RULE_INPUT_PATH)'
+          ],
+
+          # Define the outputs produced during processing:
+          'outputs': [
+            # Store an output object file in a directory for placing intermediate results (only accessible within a single target):
+            '<(INTERMEDIATE_DIR)/<(RULE_INPUT_ROOT).<(obj)'
+          ],
+
+          # Define the rule for compiling Fortran based on the host OS:
+          'conditions': [
+            [
+              'OS=="win"',
+
+              # Rule to compile Fortran on Windows:
+              {
+                'rule_name': 'compile_fortran_windows',
+                'message': 'Compiling Fortran file <(RULE_INPUT_PATH) on Windows...',
+
+                'process_outputs_as_sources': 0,
+
+                # Define the command-line invocation:
+                'action': [
+                  '<(fortran_compiler)',
+                  '<@(fflags)',
+                  '<@(_inputs)',
+                  '-o',
+                  '<@(_outputs)',
+                ],
+              },
+
+              # Rule to compile Fortran on non-Windows:
+              {
+                'rule_name': 'compile_fortran_linux',
+                'message': 'Compiling Fortran file <(RULE_INPUT_PATH) on Linux...',
+
+                'process_outputs_as_sources': 1,
+
+                # Define the command-line invocation:
+                'action': [
+                  '<(fortran_compiler)',
+                  '<@(fflags)',
+                  '-fPIC', # generate platform-independent code
+                  '<@(_inputs)',
+                  '-o',
+                  '<@(_outputs)',
+                ],
+              }
+            ], # end condition (OS=="win")
+          ], # end conditions
+        }, # end rule (extension=="f")
+      ], # end rules
+    }, # end target <(addon_target_name)
+
+    # Target to copy a generated add-on to a standard location:
+    {
+      'target_name': 'copy_addon',
+
+      # Declare that the output of this target is not linked:
+      'type': 'none',
+
+      # Define dependencies:
+      'dependencies': [
+        # Require that the add-on be generated before building this target:
+        '<(addon_target_name)',
+      ],
+
+      # Define a list of actions:
+      'actions': [
+        {
+          'action_name': 'copy_addon',
+          'message': 'Copying addon...',
+
+          # Explicitly list the inputs in the command-line invocation below:
+          'inputs': [],
+
+          # Declare the expected outputs:
+          'outputs': [
+            '<(addon_output_dir)/<(addon_target_name).node',
+          ],
+
+          # Define the command-line invocation:
+          'action': [
+            'cp',
+            '<(PRODUCT_DIR)/<(addon_target_name).node',
+            '<(addon_output_dir)/<(addon_target_name).node',
+          ],
+        },
+      ], # end actions
+    }, # end target copy_addon
+  ], # end targets
+}
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/examples/c/Makefile b/lib/node_modules/@stdlib/blas/base/dznrm2/examples/c/Makefile
new file mode 100644
index 000000000000..6aed70daf167
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/examples/c/Makefile
@@ -0,0 +1,146 @@
+#/
+# @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.
+#/
+
+# VARIABLES #
+
+ifndef VERBOSE
+	QUIET := @
+else
+	QUIET :=
+endif
+
+# Determine the OS ([1][1], [2][2]).
+#
+# [1]: https://en.wikipedia.org/wiki/Uname#Examples
+# [2]: http://stackoverflow.com/a/27776822/2225624
+OS ?= $(shell uname)
+ifneq (, $(findstring MINGW,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring MSYS,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring CYGWIN,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring Windows_NT,$(OS)))
+	OS := WINNT
+endif
+endif
+endif
+endif
+
+# Define the program used for compiling C source files:
+ifdef C_COMPILER
+	CC := $(C_COMPILER)
+else
+	CC := gcc
+endif
+
+# Define the command-line options when compiling C files:
+CFLAGS ?= \
+	-std=c99 \
+	-O3 \
+	-Wall \
+	-pedantic
+
+# Determine whether to generate position independent code ([1][1], [2][2]).
+#
+# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options
+# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option
+ifeq ($(OS), WINNT)
+	fPIC ?=
+else
+	fPIC ?= -fPIC
+endif
+
+# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`):
+INCLUDE ?=
+
+# List of source files:
+SOURCE_FILES ?=
+
+# List of libraries (e.g., `-lopenblas -lpthread`):
+LIBRARIES ?=
+
+# List of library paths (e.g., `-L /foo/bar -L /beep/boop`):
+LIBPATH ?=
+
+# List of C targets:
+c_targets := example.out
+
+
+# RULES #
+
+#/
+# Compiles source files.
+#
+# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`)
+# @param {string} [CFLAGS] - C compiler options
+# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`)
+# @param {string} [SOURCE_FILES] - list of source files
+# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`)
+# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`)
+#
+# @example
+# make
+#
+# @example
+# make all
+#/
+all: $(c_targets)
+
+.PHONY: all
+
+#/
+# Compiles C source files.
+#
+# @private
+# @param {string} CC - C compiler (e.g., `gcc`)
+# @param {string} CFLAGS - C compiler options
+# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`)
+# @param {string} SOURCE_FILES - list of source files
+# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`)
+# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`)
+#/
+$(c_targets): %.out: %.c
+	$(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES)
+
+#/
+# Runs compiled examples.
+#
+# @example
+# make run
+#/
+run: $(c_targets)
+	$(QUIET) ./$<
+
+.PHONY: run
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean:
+	$(QUIET) -rm -f *.o *.out
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/examples/c/example.c b/lib/node_modules/@stdlib/blas/base/dznrm2/examples/c/example.c
new file mode 100644
index 000000000000..45aac519f2c6
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/examples/c/example.c
@@ -0,0 +1,37 @@
+/**
+* @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.
+*/
+
+#include "stdlib/blas/base/dznrm2.h"
+#include <stdio.h>
+
+int main( void ) {
+	// Create a strided array of interleaved real and imaginary components:
+	const double zx[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 };
+
+	// Specify the number of elements:
+	const int N = 4;
+
+	// Specify stride length:
+	const int strideX = 1;
+
+	// Compute the L2-norm:
+	double norm = c_dznrm2( N, (void *)zx, strideX );
+
+	// Print the result:
+	printf( "L2-norm: %lf\n", norm );
+}
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/include.gypi b/lib/node_modules/@stdlib/blas/base/dznrm2/include.gypi
new file mode 100644
index 000000000000..497aeca15320
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/include.gypi
@@ -0,0 +1,70 @@
+# @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.
+
+# A GYP include file for building a Node.js native add-on.
+#
+# Note that nesting variables is required due to how GYP processes a configuration. Any variables defined within a nested 'variables' section is defined in the outer scope. Thus, conditions in the outer variable scope are free to use these variables without running into "variable undefined" errors.
+#
+# Main documentation:
+#
+# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md
+# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md
+#
+# Variable nesting hacks:
+#
+# [3]: https://chromium.googlesource.com/external/skia/gyp/+/master/common_variables.gypi
+# [4]: https://src.chromium.org/viewvc/chrome/trunk/src/build/common.gypi?revision=127004
+{
+  # Define variables to be used throughout the configuration for all targets:
+  'variables': {
+    'variables': {
+      # Host BLAS library (to override -Dblas=<blas>):
+      'blas%': '',
+
+      # Path to BLAS library (to override -Dblas_dir=<path>):
+      'blas_dir%': '',
+    }, # end variables
+
+    # Source directory:
+    'src_dir': './src',
+
+    # Include directories:
+    'include_dirs': [
+      '<@(blas_dir)',
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{\'os\':\'<(OS)\',\'blas\':\'<(blas)\'},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).include; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+
+    # Add-on destination directory:
+    'addon_output_dir': './src',
+
+    # Source files:
+    'src_files': [
+      '<(src_dir)/addon.c',
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{\'os\':\'<(OS)\',\'blas\':\'<(blas)\'},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).src; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+
+    # Library dependencies:
+    'libraries': [
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{\'os\':\'<(OS)\',\'blas\':\'<(blas)\'},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).libraries; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+
+    # Library directories:
+    'library_dirs': [
+      '<@(blas_dir)',
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{\'os\':\'<(OS)\',\'blas\':\'<(blas)\'},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).libpath; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+  }, # end variables
+}
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/include/stdlib/blas/base/dznrm2.h b/lib/node_modules/@stdlib/blas/base/dznrm2/include/stdlib/blas/base/dznrm2.h
new file mode 100644
index 000000000000..e2b5c0087b43
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/include/stdlib/blas/base/dznrm2.h
@@ -0,0 +1,43 @@
+/**
+* @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.
+*/
+
+/**
+* Header file containing function declarations for the C interface to the BLAS Level 1 routine `dznrm2`.
+*/
+#ifndef DZNRM2_H
+#define DZNRM2_H
+
+#include "stdlib/blas/base/shared.h"
+
+/*
+* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Computes the L2-norm of a complex double-precision floating-point vector.
+*/
+double API_SUFFIX(c_dznrm2)( const CBLAS_INT N, const void *ZX, const CBLAS_INT strideX );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !DZNRM2_H
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/include/stdlib/blas/base/dznrm2_cblas.h b/lib/node_modules/@stdlib/blas/base/dznrm2/include/stdlib/blas/base/dznrm2_cblas.h
new file mode 100644
index 000000000000..992b9f14ba43
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/include/stdlib/blas/base/dznrm2_cblas.h
@@ -0,0 +1,43 @@
+/**
+* @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.
+*/
+
+/**
+* Header file containing function declarations for the C interface to the CBLAS Level 1 routine `cblas_dznrm2`.
+*/
+#ifndef DZNRM2_CBLAS_H
+#define DZNRM2_CBLAS_H
+
+#include "stdlib/blas/base/shared.h"
+
+/*
+* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Computes the L2-norm of a complex double-precision floating-point vector.
+*/
+double API_SUFFIX(cblas_dznrm2)( const CBLAS_INT N, const void *ZX, const CBLAS_INT strideX );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !DZNRM2_CBLAS_H
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/include/stdlib/blas/base/dznrm2_fortran.h b/lib/node_modules/@stdlib/blas/base/dznrm2/include/stdlib/blas/base/dznrm2_fortran.h
new file mode 100644
index 000000000000..82a79fcf930f
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/include/stdlib/blas/base/dznrm2_fortran.h
@@ -0,0 +1,41 @@
+/**
+* @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.
+*/
+
+/**
+* Header file containing function declarations for the Fortran interface to the BLAS Level 1 routine `dznrm2`.
+*/
+#ifndef DZNRM2_FORTRAN_H
+#define DZNRM2_FORTRAN_H
+
+/*
+* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C/Fortran compiler (a Fortran compiler must be configured to not attach underscores).
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Computes the L2-norm of a complex double-precision floating-point vector.
+*/
+void dznrm2sub( const int *, const void *, const int *, double * );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !DZNRM2_FORTRAN_H
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/lib/dznrm2.native.js b/lib/node_modules/@stdlib/blas/base/dznrm2/lib/dznrm2.native.js
new file mode 100644
index 000000000000..1f29d0b549f1
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/lib/dznrm2.native.js
@@ -0,0 +1,54 @@
+/**
+* @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' );
+var addon = require( './../src/addon.node' );
+
+
+// MAIN //
+
+/**
+* Computes the L2-norm of a complex double-precision floating-point vector.
+*
+* @param {PositiveInteger} N - number of indexed elements
+* @param {Complex128Array} zx - input array
+* @param {integer} strideX - `zx` stride length
+* @returns {number} L2-norm
+*
+* @example
+* var Complex128Array = require( '@stdlib/array/complex128' );
+* var dznrm2 = require( '@stdlib/blas/base/dznrm2' );
+*
+* var zx = new Complex128Array( [ 0.3, 0.1, 0.5, 0.0, 0.0, 0.5, 0.0, 0.2, 2.0, 3.0 ] );
+*
+* var norm = dznrm2( 4, zx, 1 );
+* // returns ~0.8
+*/
+function dznrm2( N, zx, strideX ) {
+	var viewZX = reinterpret( zx, 0 );
+	return addon( N, viewZX, strideX );
+}
+
+
+// EXPORTS //
+
+module.exports = dznrm2;
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/lib/native.js b/lib/node_modules/@stdlib/blas/base/dznrm2/lib/native.js
new file mode 100644
index 000000000000..aa31cfabd90c
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/lib/native.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 dznrm2 = require( './dznrm2.native.js' );
+var ndarray = require( './ndarray.native.js' );
+
+
+// MAIN //
+
+setReadOnly( dznrm2, 'ndarray', ndarray );
+
+
+// EXPORTS //
+
+module.exports = dznrm2;
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/lib/ndarray.native.js b/lib/node_modules/@stdlib/blas/base/dznrm2/lib/ndarray.native.js
new file mode 100644
index 000000000000..6b71ead5effb
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/lib/ndarray.native.js
@@ -0,0 +1,58 @@
+/**
+* @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' );
+var minViewBufferIndex = require( '@stdlib/strided/base/min-view-buffer-index' );
+var addon = require( './../src/addon.node' );
+
+
+// MAIN //
+
+/**
+* Computes the L2-norm of a complex double-precision floating-point vector.
+*
+* @param {PositiveInteger} N - number of indexed elements
+* @param {Complex128Array} zx - input array
+* @param {integer} strideX - `zx` stride length
+* @param {NonNegativeInteger} offsetX - starting `zx` index
+* @returns {number} L2-norm
+*
+* @example
+* var Complex128Array = require( '@stdlib/array/complex128' );
+* var dznrm2 = require( '@stdlib/blas/base/dznrm2' );
+*
+* var zx = new Complex128Array( [ 0.3, 0.1, 0.5, 0.0, 0.0, 0.5, 0.0, 0.2, 2.0, 3.0 ] );
+*
+* var norm = dznrm2( 4, zx, 1 );
+* // returns ~0.8
+*/
+function dznrm2( N, zx, strideX, offsetX ) {
+	var viewZX;
+	offsetX = minViewBufferIndex( N, strideX, offsetX );
+	viewZX = reinterpret( zx, offsetX );
+	return addon( N, viewZX, strideX );
+}
+
+
+// EXPORTS //
+
+module.exports = dznrm2;
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/manifest.json b/lib/node_modules/@stdlib/blas/base/dznrm2/manifest.json
new file mode 100644
index 000000000000..7abbcb4e360c
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/manifest.json
@@ -0,0 +1,451 @@
+{
+  "options": {
+    "task": "build",
+    "os": "linux",
+    "blas": "",
+    "wasm": false
+  },
+  "fields": [
+    {
+      "field": "src",
+      "resolve": true,
+      "relative": true
+    },
+    {
+      "field": "include",
+      "resolve": true,
+      "relative": true
+    },
+    {
+      "field": "libraries",
+      "resolve": false,
+      "relative": false
+    },
+    {
+      "field": "libpath",
+      "resolve": true,
+      "relative": false
+    }
+  ],
+  "confs": [
+    {
+      "task": "build",
+      "os": "linux",
+      "blas": "",
+      "wasm": false,
+      "src": [
+        "./src/dznrm2.f",
+        "./src/dznrm2sub.f",
+        "./src/dznrm2_f.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared",
+        "@stdlib/napi/export",
+        "@stdlib/napi/argv",
+        "@stdlib/napi/argv-int64",
+        "@stdlib/napi/argv-strided-complex128array",
+        "@stdlib/napi/create-double"
+      ]
+    },
+    {
+      "task": "benchmark",
+      "os": "linux",
+      "blas": "",
+      "wasm": false,
+      "src": [
+        "./src/dznrm2.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared",
+        "@stdlib/math/base/special/abs",
+        "@stdlib/math/base/special/abs2",
+        "@stdlib/math/base/special/sqrt",
+        "@stdlib/constants/float64/max"
+      ]
+    },
+    {
+      "task": "examples",
+      "os": "linux",
+      "blas": "",
+      "wasm": false,
+      "src": [
+        "./src/dznrm2.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared",
+        "@stdlib/math/base/special/abs",
+        "@stdlib/math/base/special/abs2",
+        "@stdlib/math/base/special/sqrt",
+        "@stdlib/constants/float64/max"
+      ]
+    },
+
+    {
+      "task": "build",
+      "os": "linux",
+      "blas": "openblas",
+      "wasm": false,
+      "src": [
+        "./src/dznrm2_cblas.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [
+        "-lopenblas",
+        "-lpthread"
+      ],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared",
+        "@stdlib/napi/export",
+        "@stdlib/napi/argv",
+        "@stdlib/napi/argv-int64",
+        "@stdlib/napi/argv-strided-complex128array",
+        "@stdlib/napi/create-double"
+      ]
+    },
+    {
+      "task": "benchmark",
+      "os": "linux",
+      "blas": "openblas",
+      "wasm": false,
+      "src": [
+        "./src/dznrm2_cblas.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [
+        "-lopenblas",
+        "-lpthread"
+      ],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared"
+      ]
+    },
+    {
+      "task": "examples",
+      "os": "linux",
+      "blas": "openblas",
+      "wasm": false,
+      "src": [
+        "./src/dznrm2_cblas.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [
+        "-lopenblas",
+        "-lpthread"
+      ],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared"
+      ]
+    },
+
+    {
+      "task": "build",
+      "os": "mac",
+      "blas": "",
+      "wasm": false,
+      "src": [
+        "./src/dznrm2.f",
+        "./src/dznrm2sub.f",
+        "./src/dznrm2_f.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared",
+        "@stdlib/napi/export",
+        "@stdlib/napi/argv",
+        "@stdlib/napi/argv-int64",
+        "@stdlib/napi/argv-strided-complex128array",
+        "@stdlib/napi/create-double"
+      ]
+    },
+    {
+      "task": "benchmark",
+      "os": "mac",
+      "blas": "",
+      "wasm": false,
+      "src": [
+        "./src/dznrm2.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared",
+        "@stdlib/math/base/special/abs",
+        "@stdlib/math/base/special/abs2",
+        "@stdlib/math/base/special/sqrt",
+        "@stdlib/constants/float64/max"
+      ]
+    },
+    {
+      "task": "examples",
+      "os": "mac",
+      "blas": "",
+      "wasm": false,
+      "src": [
+        "./src/dznrm2.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared",
+        "@stdlib/math/base/special/abs",
+        "@stdlib/math/base/special/abs2",
+        "@stdlib/math/base/special/sqrt",
+        "@stdlib/constants/float64/max"
+      ]
+    },
+
+    {
+      "task": "build",
+      "os": "mac",
+      "blas": "apple_accelerate_framework",
+      "wasm": false,
+      "src": [
+        "./src/dznrm2_cblas.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [
+        "-lblas"
+      ],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared",
+        "@stdlib/napi/export",
+        "@stdlib/napi/argv",
+        "@stdlib/napi/argv-int64",
+        "@stdlib/napi/argv-strided-complex128array",
+        "@stdlib/napi/create-double"
+      ]
+    },
+    {
+      "task": "benchmark",
+      "os": "mac",
+      "blas": "apple_accelerate_framework",
+      "wasm": false,
+      "src": [
+        "./src/dznrm2_cblas.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [
+        "-lblas"
+      ],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared"
+      ]
+    },
+    {
+      "task": "examples",
+      "os": "mac",
+      "blas": "apple_accelerate_framework",
+      "wasm": false,
+      "src": [
+        "./src/dznrm2_cblas.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [
+        "-lblas"
+      ],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared"
+      ]
+    },
+
+    {
+      "task": "build",
+      "os": "mac",
+      "blas": "openblas",
+      "wasm": false,
+      "src": [
+        "./src/dznrm2_cblas.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [
+        "-lopenblas",
+        "-lpthread"
+      ],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared",
+        "@stdlib/napi/export",
+        "@stdlib/napi/argv",
+        "@stdlib/napi/argv-int64",
+        "@stdlib/napi/argv-strided-complex128array",
+        "@stdlib/napi/create-double"
+      ]
+    },
+    {
+      "task": "benchmark",
+      "os": "mac",
+      "blas": "openblas",
+      "wasm": false,
+      "src": [
+        "./src/dznrm2_cblas.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [
+        "-lopenblas",
+        "-lpthread"
+      ],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared"
+      ]
+    },
+    {
+      "task": "examples",
+      "os": "mac",
+      "blas": "openblas",
+      "wasm": false,
+      "src": [
+        "./src/dznrm2_cblas.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [
+        "-lopenblas",
+        "-lpthread"
+      ],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared"
+      ]
+    },
+
+    {
+      "task": "build",
+      "os": "win",
+      "blas": "",
+      "wasm": false,
+      "src": [
+        "./src/dznrm2.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared",
+        "@stdlib/napi/export",
+        "@stdlib/napi/argv",
+        "@stdlib/napi/argv-int64",
+        "@stdlib/napi/argv-strided-complex128array",
+        "@stdlib/napi/create-double",
+        "@stdlib/math/base/special/abs",
+        "@stdlib/math/base/special/abs2",
+        "@stdlib/math/base/special/sqrt",
+        "@stdlib/constants/float64/max"
+      ]
+    },
+    {
+      "task": "benchmark",
+      "os": "win",
+      "blas": "",
+      "wasm": false,
+      "src": [
+        "./src/dznrm2.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared",
+        "@stdlib/math/base/special/abs",
+        "@stdlib/math/base/special/abs2",
+        "@stdlib/math/base/special/sqrt",
+        "@stdlib/constants/float64/max"
+      ]
+    },
+    {
+      "task": "examples",
+      "os": "win",
+      "blas": "",
+      "wasm": false,
+      "src": [
+        "./src/dznrm2.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared",
+        "@stdlib/math/base/special/abs",
+        "@stdlib/math/base/special/abs2",
+        "@stdlib/math/base/special/sqrt",
+        "@stdlib/constants/float64/max"
+      ]
+    },
+
+    {
+      "task": "build",
+      "os": "",
+      "blas": "",
+      "wasm": true,
+      "src": [
+        "./src/dznrm2.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared",
+        "@stdlib/math/base/special/abs",
+        "@stdlib/math/base/special/abs2",
+        "@stdlib/math/base/special/sqrt",
+        "@stdlib/constants/float64/max"
+      ]
+    }
+  ]
+}
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/package.json b/lib/node_modules/@stdlib/blas/base/dznrm2/package.json
index 0e70208f73f0..1c9c493949ef 100644
--- a/lib/node_modules/@stdlib/blas/base/dznrm2/package.json
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@stdlib/blas/base/dznrm2",
   "version": "0.0.0",
-  "description": "Find the euclidean norm of a complex double-precision floating-point vector.",
+  "description": "Compute the L2-norm of a complex double-precision floating-point vector.",
   "license": "Apache-2.0",
   "author": {
     "name": "The Stdlib Authors",
@@ -14,11 +14,14 @@
     }
   ],
   "main": "./lib",
+  "gypfile": true,
   "directories": {
     "benchmark": "./benchmark",
     "doc": "./docs",
     "example": "./examples",
+    "include": "./include",
     "lib": "./lib",
+    "src": "./src",
     "test": "./test"
   },
   "types": "./docs/types",
@@ -65,11 +68,8 @@
     "vector",
     "array",
     "ndarray",
-    "complex",
-    "complex128",
     "float64",
-    "float",
-    "single",
+    "double",
     "float64array"
   ]
 }
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/src/Makefile b/lib/node_modules/@stdlib/blas/base/dznrm2/src/Makefile
new file mode 100644
index 000000000000..bcf18aa46655
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/src/Makefile
@@ -0,0 +1,70 @@
+#/
+# @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.
+#/
+
+# VARIABLES #
+
+ifndef VERBOSE
+	QUIET := @
+else
+	QUIET :=
+endif
+
+# Determine the OS ([1][1], [2][2]).
+#
+# [1]: https://en.wikipedia.org/wiki/Uname#Examples
+# [2]: http://stackoverflow.com/a/27776822/2225624
+OS ?= $(shell uname)
+ifneq (, $(findstring MINGW,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring MSYS,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring CYGWIN,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring Windows_NT,$(OS)))
+	OS := WINNT
+endif
+endif
+endif
+endif
+
+
+# RULES #
+
+#/
+# Removes generated files for building an add-on.
+#
+# @example
+# make clean-addon
+#/
+clean-addon:
+	$(QUIET) -rm -f *.o *.node
+
+.PHONY: clean-addon
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean: clean-addon
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/src/addon.c b/lib/node_modules/@stdlib/blas/base/dznrm2/src/addon.c
new file mode 100644
index 000000000000..59d90cff6642
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/src/addon.c
@@ -0,0 +1,45 @@
+/**
+* @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.
+*/
+
+#include "stdlib/blas/base/dznrm2.h"
+#include "stdlib/blas/base/shared.h"
+#include "stdlib/napi/export.h"
+#include "stdlib/napi/argv.h"
+#include "stdlib/napi/argv_int64.h"
+#include "stdlib/napi/argv_strided_complex128array.h"
+#include "stdlib/napi/create_double.h"
+#include <node_api.h>
+
+/**
+* Receives JavaScript callback invocation data.
+*
+* @private
+* @param env    environment under which the function is invoked
+* @param info   callback data
+* @return       Node-API value
+*/
+static napi_value addon( napi_env env, napi_callback_info info ) {
+	STDLIB_NAPI_ARGV( env, info, argv, argc, 3 );
+	STDLIB_NAPI_ARGV_INT64( env, N, argv, 0 );
+	STDLIB_NAPI_ARGV_INT64( env, strideX, argv, 2 );
+	STDLIB_NAPI_ARGV_STRIDED_COMPLEX128ARRAY( env, ZX, N, strideX, argv, 1 );
+	STDLIB_NAPI_CREATE_DOUBLE( env, API_SUFFIX(c_dznrm2)( N, ZX, strideX ), norm );
+	return norm;
+}
+
+STDLIB_NAPI_MODULE_EXPORT_FCN( addon )
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2.c b/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2.c
new file mode 100644
index 000000000000..e75fb386f759
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2.c
@@ -0,0 +1,127 @@
+/**
+* @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.
+*/
+
+#include "stdlib/blas/base/dznrm2.h"
+#include "stdlib/blas/base/shared.h"
+#include "stdlib/math/base/special/abs.h"
+#include "stdlib/math/base/special/abs2.h"
+#include "stdlib/math/base/special/sqrt.h"
+#include "stdlib/constants/float64/max.h"
+#include <stdbool.h>
+
+// Blue's scaling constants...
+static const double tsml = 1.4916681462400413E-154;
+static const double tbig = 1.9979190722022350E+146;
+static const double ssml = 4.4989137945431964E+161;
+static const double sbig = 1.1113793747425387E-162;
+
+/**
+* Computes the L2-norm of a complex double-precision floating-point vector.
+*
+* @param N         number of indexed elements
+* @param ZX        input array
+* @param strideX   ZX stride length
+*/
+double API_SUFFIX(c_dznrm2)( const CBLAS_INT N, const void *ZX, const CBLAS_INT strideX ) {
+	double *x = (double *)ZX;
+	CBLAS_INT sx;
+	CBLAS_INT ix;
+	bool notbig;
+	CBLAS_INT i;
+	double sumsq;
+	double abig;
+	double amed;
+	double asml;
+	double ymax;
+	double ymin;
+	double scl;
+	double ax;
+
+	if ( N <= 0 ) {
+		return 0.0;
+	}
+	sx = strideX * 2;
+	if ( sx < 0 ) {
+		ix = ( 1 - N ) * sx;
+	} else {
+		ix = 0;
+	}
+	// Compute the sum of squares using 3 accumulators--`abig` (sum of squares scaled down to avoid overflow), `asml` (sum of squares scaled up to avoid underflow), `amed` (sum of squares that do not require scaling)--and thresholds and multipliers--`tbig` (values bigger than this are scaled down by `sbig`) and `tsml` (values smaller than this are scaled up by `ssml`)...
+	notbig = true;
+	sumsq = 0.0;
+	abig = 0.0;
+	amed = 0.0;
+	asml = 0.0;
+	for ( i = 0; i < N; i++ ) {
+		ax = stdlib_base_abs( x[ ix ] );
+		if ( ax > tbig ) {
+			abig += stdlib_base_abs2( ax * sbig );
+			notbig = false;
+		} else if ( ax < tsml ) {
+			if ( notbig ) {
+				asml += stdlib_base_abs2( ax * ssml );
+			}
+		} else {
+			amed += stdlib_base_abs2( ax );
+		}
+		ax = stdlib_base_abs( x[ ix + 1 ] );
+		if ( ax > tbig ) {
+			abig += stdlib_base_abs2( ax * sbig );
+			notbig = false;
+		} else if ( ax < tsml ) {
+			if ( notbig ) {
+				asml += stdlib_base_abs2( ax * ssml );
+			}
+		} else {
+			amed += stdlib_base_abs2( ax );
+		}
+		ix += sx;
+	}
+	// Combine `abig` and `amed` or `amed` and `asml` if more than one accumulator was used...
+	if ( abig > 0.0 ) {
+		// Combine `abig` and `amed` if `abig` > 0...
+		if ( amed > 0.0 || ( amed > STDLIB_CONSTANT_FLOAT64_MAX ) || ( amed != amed ) ) {
+			abig += ( amed * sbig ) * sbig;
+		}
+		scl = 1.0 / sbig;
+		sumsq = abig;
+	} else if ( asml > 0.0 ) {
+		// Combine `amed` and `asml` if `asml` > 0...
+		if ( amed > 0.0 || amed > STDLIB_CONSTANT_FLOAT64_MAX || ( amed != amed ) ) {
+			amed = stdlib_base_sqrt( amed );
+			asml = stdlib_base_sqrt( asml ) / ssml;
+			if ( asml > amed ) {
+				ymin = amed;
+				ymax = asml;
+			} else {
+				ymin = asml;
+				ymax = amed;
+			}
+			scl = 1.0;
+			sumsq = stdlib_base_abs2( ymax ) * ( 1.0 + stdlib_base_abs2( ymin / ymax ) );
+		} else {
+			scl = 1.0 / ssml;
+			sumsq = asml;
+		}
+	} else {
+		// All values are mid-range...
+		scl = 1.0;
+		sumsq = amed;
+	}
+	return stdlib_base_sqrt( sumsq ) * scl;
+}
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2.f b/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2.f
new file mode 100644
index 000000000000..32e1da4b0943
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2.f
@@ -0,0 +1,165 @@
+!>
+! @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.
+!<
+
+!> Computes the L2-norm of a complex double-precision floating-point vector.
+!
+! ## Notes
+!
+! * Modified version of reference BLAS level1 routine (version 3.8.0). Updated to "free form" Fortran 95.
+!
+! ## Authors
+!
+! * Edward Anderson, Lockheed Martin
+! * Weslley Pereira, University of Colorado Denver, USA
+!
+! ## History
+!
+! * Original version written on August 2016.
+!
+! ## License
+!
+! From <http://netlib.org/blas/faq.html>:
+!
+! > The reference BLAS is a freely-available software package. It is available from netlib via anonymous ftp and the World Wide Web. Thus, it can be included in commercial software packages (and has been). We only ask that proper credit be given to the authors.
+! >
+! > Like all software, it is copyrighted. It is not trademarked, but we do ask the following:
+! >
+! > * If you modify the source for these routines we ask that you change the name of the routine and comment the changes made to the original.
+! >
+! > * We will gladly answer any questions regarding the software. If a modification is done, however, it is the responsibility of the person who modified the routine to provide support.
+!
+! @param {integer} N - number of indexed elements
+! @param {Array<complex<double>>} zx - array
+! @param {integer} strideX - `zx` stride length
+! @returns {double} L2-norm
+!<
+double precision function dznrm2( N, zx, strideX )
+  implicit none
+  ! ..
+  ! Define a kind parameter for single precision:
+  integer, parameter :: wp = kind( 1.0d0 )
+  ! ..
+  ! Define constants:
+  real( wp ), parameter :: zero = 0.0_wp
+  real( wp ), parameter :: one  = 1.0_wp
+  real( wp ), parameter :: maxN = huge( 0.0_wp )
+  ! ..
+  ! Blue's scaling constants:
+  real(wp), parameter :: tsml = 1.4916681462400413e-154_wp
+  real(wp), parameter :: tbig = 1.9979190722022350e146_wp
+  real(wp), parameter :: ssml = 4.4989137945431964e161_wp
+  real(wp), parameter :: sbig = 1.1113793747425387e-162_wp
+  !..
+  ! Scalar arguments:
+  integer :: N, strideX
+  ! ..
+  ! Array arguments:
+  complex( wp ) :: zx( * )
+  ! ..
+  ! Local scalars:
+  integer :: i, ix
+  logical :: notbig
+  real( wp ) :: abig, amed, asml, ax, scl, sumsq, ymax, ymin
+  ! ..
+  ! Intrinsic functions:
+  intrinsic abs, sqrt
+  ! ..
+  dznrm2 = zero
+  ! ..
+  if ( N <= 0 ) return
+  ! ..
+  scl = one
+  sumsq = zero
+  ! ..
+  ! Compute the sum of squares in 3 accumulators:
+  !     abig -- sums of squares scaled down to avoid overflow
+  !     asml -- sums of squares scaled up to avoid underflow
+  !     amed -- sums of squares that do not require scaling
+  ! Thresholds and multipliers:
+  !     tbig -- values bigger than this are scaled down by sbig
+  !     tsml -- values smaller than this are scaled up by ssml
+  ! ..
+  notbig = .true.
+  asml = zero
+  amed = zero
+  abig = zero
+  ix = 1
+  if ( strideX < 0 ) then
+    ix = 1 - ( N - 1 ) * strideX
+  end if
+  ! ..
+  do i = 1, N
+    ax = abs( real( zx( ix ) ) )
+    if ( ax > tbig ) then
+      abig = abig + ( ax * sbig )**2
+      notbig = .false.
+    else if ( ax < tsml ) then
+      if ( notbig ) then
+        asml = asml + ( ax * ssml )**2
+      end if
+    else
+      amed = amed + ax**2
+    end if
+    ax = abs( aimag( zx( ix ) ) )
+    if ( ax > tbig ) then
+      abig = abig + ( ax * sbig )**2
+      notbig = .false.
+    else if ( ax < tsml ) then
+      if ( notbig ) then
+        asml = asml + ( ax * ssml )**2
+      end if
+    else
+      amed = amed + ( ax**2 )
+    end if
+    ix = ix + strideX
+  end do
+  ! ..
+  ! Combine abig and amed or amed and asml if more than one accumulator was used:
+  if ( abig > zero ) then
+    ! Combine abig and amed if abig > 0...
+    if ( ( amed > zero ) .or. ( amed > maxN ) .or. ( amed /= amed ) ) then
+      abig = abig + ( amed * sbig ) * sbig
+    end if
+    scl = one / sbig
+    sumsq = abig
+  else if ( asml > zero ) then
+    ! Combine amed and asml if asml > 0...
+    if ( ( amed > zero ) .or. ( amed > maxN ) .or. ( amed /= amed ) ) then
+      amed = sqrt( amed )
+      asml = sqrt( asml ) / ssml
+      if ( asml > amed ) then
+        ymin = amed
+        ymax = asml
+      else
+        ymin = asml
+        ymax = amed
+      end if
+      scl = one
+      sumsq = ymax**2 * ( one + ( ymin / ymax )**2 )
+    else
+      scl = one / ssml
+      sumsq = asml
+    end if
+  else
+    ! All values are mid-range...
+    scl = one
+    sumsq = amed
+  end if
+  dznrm2 = scl * sqrt( sumsq )
+  return
+end function dznrm2
\ No newline at end of file
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2_cblas.c b/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2_cblas.c
new file mode 100644
index 000000000000..f809ea2cff89
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2_cblas.c
@@ -0,0 +1,32 @@
+/**
+* @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.
+*/
+
+#include "stdlib/blas/base/dznrm2.h"
+#include "stdlib/blas/base/dznrm2_cblas.h"
+#include "stdlib/blas/base/shared.h"
+
+/**
+* Computes the L2-norm of a complex double-precision floating-point vector.
+*
+* @param N         number of indexed elements
+* @param ZX        input array
+* @param strideX   ZX stride length
+*/
+double API_SUFFIX(c_dznrm2)( const CBLAS_INT N, const void *ZX, const CBLAS_INT strideX ) {
+	return API_SUFFIX(cblas_dznrm2)( N, ZX, strideX );
+}
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2_f.c b/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2_f.c
new file mode 100644
index 000000000000..a2b41fc95663
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2_f.c
@@ -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.
+*/
+
+#include "stdlib/blas/base/dznrm2.h"
+#include "stdlib/blas/base/dznrm2_fortran.h"
+#include "stdlib/blas/base/shared.h"
+
+/**
+* Computes the L2-norm of a complex double-precision floating-point vector.
+*
+* @param N        number of indexed elements
+* @param ZX       input array
+* @param strideX  ZX stride length
+* @return         L2-norm
+*/
+double API_SUFFIX(c_dznrm2)( const CBLAS_INT N, const void *ZX, const CBLAS_INT strideX ) {
+	double nrm2;
+	dznrm2sub( &N, ZX, &strideX, &nrm2 );
+	return nrm2;
+}
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2sub.f b/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2sub.f
new file mode 100644
index 000000000000..13629c91ffbb
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2sub.f
@@ -0,0 +1,47 @@
+!>
+! @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.
+!<
+
+!> Wraps `dznrm2` as a subroutine.
+!
+! @param {integer} N - number of indexed elements
+! @param {Array<complex<double>>} zx - input array
+! @param {integer} strideX - `zx` stride length
+! @param {double} nrm2 - L2-norm
+!<
+subroutine dznrm2sub( N, zx, strideX, nrm2 )
+  implicit none
+  ! ..
+  ! External functions:
+  interface
+    double precision function dznrm2( N, zx, strideX )
+      complex(kind=kind(0.0d0)) :: zx(*)
+      integer :: strideX, N
+    end function dznrm2
+  end interface
+  ! ..
+  ! Scalar arguments:
+  integer :: strideX, N
+  double precision :: nrm2
+  ! ..
+  ! Array arguments:
+  complex(kind=kind(0.0d0)) :: zx(*)
+  ! ..
+  ! Compute the L2-norm:
+  nrm2 = dznrm2( N, zx, strideX )
+  return
+end subroutine dznrm2sub
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.dznrm2.native.js b/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.dznrm2.native.js
new file mode 100644
index 000000000000..80b2186c2514
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.dznrm2.native.js
@@ -0,0 +1,224 @@
+/**
+* @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 resolve = require( 'path' ).resolve;
+var tape = require( 'tape' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var EPS = require( '@stdlib/constants/float64/eps' );
+var abs = require( '@stdlib/math/base/special/abs' );
+var tryRequire = require( '@stdlib/utils/try-require' );
+
+
+// VARIABLES //
+
+var dznrm2 = tryRequire( resolve( __dirname, './../lib/dznrm2.native.js' ) );
+var opts = {
+	'skip': ( dznrm2 instanceof Error )
+};
+
+
+// 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
+*/
+function isApprox( t, actual, expected, rtol ) {
+	var delta;
+	var tol;
+	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 ] );
+			tol = rtol * EPS * abs( expected[ i ] );
+			t.ok( delta <= tol, 'within tolerance. actual: '+actual[ i ]+'. expected: '+expected[ i ]+'. delta: '+delta+'. tol: '+tol+'.' );
+		}
+	}
+}
+
+
+// TESTS //
+
+tape( 'main export is a function', opts, function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof dznrm2, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 3', opts, function test( t ) {
+	t.strictEqual( dznrm2.length, 3, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function computes the L2-norm', opts, function test( t ) {
+	var expected;
+	var actual;
+	var zx;
+
+	zx = new Complex128Array([
+		0.3, // 1
+		0.1, // 1
+		0.5, // 2
+		0.0, // 2
+		0.0, // 3
+		0.5, // 3
+		0.0, // 4
+		0.2, // 4
+		2.0,
+		3.0
+	]);
+	expected = 0.8;
+
+	actual = dznrm2( 4, zx, 1 );
+	isApprox( t, actual, expected, 2.0 );
+
+	zx = new Complex128Array([
+		0.1,  // 1
+		0.1,  // 1
+		-0.6, // 2
+		0.1,  // 2
+		0.1,  // 3
+		-0.3, // 3
+		7.0,
+		8.0
+	]);
+	expected = 0.7;
+
+	actual = dznrm2( 3, zx, 1 );
+	isApprox( t, actual, expected, 2.0 );
+	t.end();
+});
+
+tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `0.0`', opts, function test( t ) {
+	var expected;
+	var actual;
+	var zx;
+
+	zx = new Complex128Array([
+		1.0,
+		2.0,
+		3.0,
+		4.0
+	]);
+	expected = 0.0;
+
+	actual = dznrm2( 0, zx, 1 );
+	t.strictEqual( actual, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports specifying a stride', opts, function test( t ) {
+	var expected;
+	var actual;
+	var zx;
+
+	zx = new Complex128Array([
+		0.3, // 1
+		0.1, // 1
+		5.0,
+		8.0,
+		0.5, // 2
+		0.0, // 2
+		6.0,
+		9.0,
+		0.0, // 3
+		0.5, // 3
+		8.0,
+		3.0,
+		0.0, // 4
+		0.2, // 4
+		9.0,
+		4.0
+	]);
+	expected = 0.8;
+
+	actual = dznrm2( 4, zx, 2 );
+	isApprox( t, actual, expected, 2.0 );
+	t.end();
+});
+
+tape( 'the function supports specifying a negative stride', opts, function test( t ) {
+	var expected;
+	var actual;
+	var zx;
+
+	zx = new Complex128Array([
+		0.3, // 1
+		0.1, // 1
+		5.0,
+		8.0,
+		0.5, // 2
+		0.0, // 2
+		6.0,
+		9.0,
+		0.0, // 3
+		0.5, // 3
+		8.0,
+		3.0,
+		0.0, // 4
+		0.2, // 4
+		9.0,
+		4.0
+	]);
+	expected = 0.8;
+
+	actual = dznrm2( 4, zx, -2 );
+	isApprox( t, actual, expected, 2.0 );
+	t.end();
+});
+
+tape( 'the function supports view offsets', opts, function test( t ) {
+	var expected;
+	var actual;
+	var zx0;
+	var zx1;
+
+	zx0 = new Complex128Array([
+		1.0,
+		2.0,
+		3.0, // 1
+		4.0, // 1
+		5.0, // 2
+		6.0, // 2
+		7.0, // 3
+		8.0, // 3
+		9.0,
+		10.0
+	]);
+	expected = 14.1;
+
+	zx1 = new Complex128Array( zx0.buffer, zx0.BYTES_PER_ELEMENT*1 );
+
+	actual = dznrm2( 3, zx1, 1 );
+	isApprox( t, actual, expected, 2.0 );
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.ndarray.native.js b/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.ndarray.native.js
new file mode 100644
index 000000000000..541603eddeda
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/test/test.ndarray.native.js
@@ -0,0 +1,221 @@
+/**
+* @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 resolve = require( 'path' ).resolve;
+var tape = require( 'tape' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var EPS = require( '@stdlib/constants/float64/eps' );
+var abs = require( '@stdlib/math/base/special/abs' );
+var tryRequire = require( '@stdlib/utils/try-require' );
+
+
+// VARIABLES //
+
+var dznrm2 = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) );
+var opts = {
+	'skip': ( dznrm2 instanceof Error )
+};
+
+
+// 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
+*/
+function isApprox( t, actual, expected, rtol ) {
+	var delta;
+	var tol;
+	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 ] );
+			tol = rtol * EPS * abs( expected[ i ] );
+			t.ok( delta <= tol, 'within tolerance. actual: '+actual[ i ]+'. expected: '+expected[ i ]+'. delta: '+delta+'. tol: '+tol+'.' );
+		}
+	}
+}
+
+
+// TESTS //
+
+tape( 'main export is a function', opts, function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof dznrm2, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 4', opts, function test( t ) {
+	t.strictEqual( dznrm2.length, 4, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function computes the L2-norm', opts, function test( t ) {
+	var expected;
+	var actual;
+	var zx;
+
+	zx = new Complex128Array([
+		0.3, // 1
+		0.1, // 1
+		0.5, // 2
+		0.0, // 2
+		0.0, // 3
+		0.5, // 3
+		0.0, // 4
+		0.2, // 4
+		2.0,
+		3.0
+	]);
+	expected = 0.8;
+
+	actual = dznrm2( 4, zx, 1, 0 );
+	isApprox( t, actual, expected, 2.0 );
+
+	zx = new Complex128Array([
+		0.1,  // 1
+		0.1,  // 1
+		-0.6, // 2
+		0.1,  // 2
+		0.1,  // 3
+		-0.3, // 3
+		7.0,
+		8.0
+	]);
+	expected = 0.7;
+
+	actual = dznrm2( 3, zx, 1, 0 );
+	isApprox( t, actual, expected, 2.0 );
+	t.end();
+});
+
+tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `0.0`', opts, function test( t ) {
+	var expected;
+	var actual;
+	var zx;
+
+	zx = new Complex128Array([
+		1.0,
+		2.0,
+		3.0,
+		4.0
+	]);
+	expected = 0.0;
+
+	actual = dznrm2( 0, zx, 1, 0 );
+	t.strictEqual( actual, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports specifying a stride', opts, function test( t ) {
+	var expected;
+	var actual;
+	var zx;
+
+	zx = new Complex128Array([
+		0.3, // 1
+		0.1, // 1
+		5.0,
+		8.0,
+		0.5, // 2
+		0.0, // 2
+		6.0,
+		9.0,
+		0.0, // 3
+		0.5, // 3
+		8.0,
+		3.0,
+		0.0, // 4
+		0.2, // 4
+		9.0,
+		4.0
+	]);
+	expected = 0.8;
+
+	actual = dznrm2( 4, zx, 2, 0 );
+	isApprox( t, actual, expected, 2.0 );
+	t.end();
+});
+
+tape( 'the function supports specifying a negative stride', opts, function test( t ) {
+	var expected;
+	var actual;
+	var zx;
+
+	zx = new Complex128Array([
+		0.3, // 1
+		0.1, // 1
+		5.0,
+		8.0,
+		0.5, // 2
+		0.0, // 2
+		6.0,
+		9.0,
+		0.0, // 3
+		0.5, // 3
+		8.0,
+		3.0,
+		0.0, // 4
+		0.2, // 4
+		9.0,
+		4.0
+	]);
+	expected = 0.8;
+
+	actual = dznrm2( 4, zx, -2, 6 );
+	isApprox( t, actual, expected, 2.0 );
+	t.end();
+});
+
+tape( 'the function supports specifying an offset', opts, function test( t ) {
+	var expected;
+	var actual;
+	var zx;
+
+	zx = new Complex128Array([
+		1.0,
+		2.0,
+		3.0, // 1
+		4.0, // 1
+		5.0, // 2
+		6.0, // 2
+		7.0, // 3
+		8.0, // 3
+		9.0,
+		10.0
+	]);
+	expected = 14.1;
+
+	actual = dznrm2( 3, zx, 1, 1 );
+	isApprox( t, actual, expected, 2.0 );
+	t.end();
+});

From a78f7d1b859b6b1d7b0bc0ee4daf76789e3e0910 Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Sun, 7 Jul 2024 11:12:07 -0500
Subject: [PATCH 05/16] style: add missing spaces

---
 .../eslint/rules/first-unit-test/lib/main.js  |  2 +-
 .../jsdoc-fenced-code-marker/lib/main.js      |  2 +-
 .../@stdlib/_tools/scripts/transform.js       |  6 +--
 .../benchmark/benchmark.assign.length.js      |  2 +-
 .../base/cuany/benchmark/benchmark.length.js  |  2 +-
 .../benchmark/benchmark.assign.length.js      |  2 +-
 .../cuevery/benchmark/benchmark.length.js     |  2 +-
 .../base/cunone/benchmark/benchmark.length.js |  2 +-
 .../@stdlib/array/base/take-map/lib/assign.js |  2 +-
 .../bool/benchmark/benchmark.find_index.js    |  2 +-
 .../benchmark/benchmark.find_last_index.js    |  2 +-
 .../@stdlib/array/bool/test/test.every.js     |  2 +-
 .../@stdlib/array/bool/test/test.find.js      |  4 +-
 .../@stdlib/array/bool/test/test.find_last.js |  4 +-
 .../@stdlib/array/bool/test/test.map.js       |  2 +-
 .../@stdlib/array/bool/test/test.some.js      |  4 +-
 .../benchmark/benchmark.fill.length.js        |  2 +-
 .../benchmark/benchmark.keys.length.js        |  2 +-
 .../complex128/benchmark/benchmark.map.js     |  2 +-
 .../benchmark/benchmark.values.length.js      |  2 +-
 .../array/complex128/test/test.every.js       |  2 +-
 .../array/complex128/test/test.find.js        |  6 +--
 .../array/complex128/test/test.find_last.js   |  6 +--
 .../array/complex128/test/test.for_each.js    |  2 +-
 .../@stdlib/array/complex128/test/test.map.js |  2 +-
 .../array/linspace/test/test.assign.js        |  2 +-
 .../@stdlib/array/pool/benchmark/benchmark.js |  2 +-
 .../@stdlib/blas/base/sdot/lib/sdot.js        |  2 +-
 .../math/base/special/acotd/lib/main.js       |  4 +-
 .../math/base/special/acscdf/test/test.js     |  2 +-
 .../base/special/acscdf/test/test.native.js   |  2 +-
 .../math/base/special/beta/lib/main.js        |  2 +-
 .../math/base/special/boxcox/test/test.js     |  2 +-
 .../base/special/boxcox/test/test.native.js   |  2 +-
 .../math/base/special/boxcox1p/test/test.js   |  2 +-
 .../base/special/boxcox1p/test/test.native.js |  2 +-
 .../base/special/boxcox1pinv/test/test.js     |  2 +-
 .../special/boxcox1pinv/test/test.native.js   |  2 +-
 .../math/base/special/boxcoxinv/test/test.js  |  2 +-
 .../special/boxcoxinv/test/test.native.js     |  2 +-
 .../math/base/special/cexp/lib/main.js        |  2 +-
 .../math/base/special/cinv/lib/main.js        |  2 +-
 .../math/base/special/cosm1/test/test.js      |  6 +--
 .../math/base/special/csc/lib/index.js        |  2 +-
 .../@stdlib/math/base/special/csc/lib/main.js |  4 +-
 .../math/base/special/csc/test/test.js        |  4 +-
 .../math/base/special/exp/lib/expmulti.js     |  2 +-
 .../math/base/special/gammainc/test/test.js   |  2 +-
 .../base/special/gammaincinv/lib/compute.js   |  2 +-
 .../base/special/kernel-betainc/lib/assign.js |  2 +-
 .../kernel-betaincinv/lib/halley_iterate.js   |  2 +-
 .../random/base/mt19937/test/test.factory.js  |  2 +-
 .../@stdlib/random/base/mt19937/test/test.js  |  2 +-
 .../random/streams/chisquare/lib/factory.js   |  2 +-
 .../@stdlib/stats/kde2d/examples/index.js     | 42 +++++++++----------
 .../@stdlib/stats/kde2d/lib/triweight.js      | 12 +++---
 .../@stdlib/stats/kde2d/test/test.js          |  6 +--
 .../@stdlib/stats/pcorrtest/lib/main.js       |  6 +--
 .../node/debug-sink/test/test.factory.js      |  4 +-
 .../streams/node/debug/test/test.factory.js   |  4 +-
 .../format-interpolate/lib/format_double.js   |  2 +-
 .../@stdlib/string/replace/lib/main.js        |  2 +-
 .../utils/any-in-by/benchmark/benchmark.js    |  2 +-
 .../@stdlib/utils/group-in/lib/return_keys.js |  2 +-
 .../utils/group-own/lib/return_keys.js        |  2 +-
 .../@stdlib/utils/move-property/test/test.js  |  2 +-
 .../@stdlib/utils/none-in-by/test/test.js     | 22 +++++-----
 .../@stdlib/utils/pick/benchmark/benchmark.js |  4 +-
 68 files changed, 124 insertions(+), 124 deletions(-)

diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/first-unit-test/lib/main.js b/lib/node_modules/@stdlib/_tools/eslint/rules/first-unit-test/lib/main.js
index 29b89162fed0..bc034defe25f 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/first-unit-test/lib/main.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/first-unit-test/lib/main.js
@@ -21,7 +21,7 @@
 // MODULES //
 
 var startsWith = require( '@stdlib/string/starts-with' );
-var endsWith = require('@stdlib/string/ends-with');
+var endsWith = require( '@stdlib/string/ends-with' );
 var contains = require( '@stdlib/assert/contains' );
 
 
diff --git a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-fenced-code-marker/lib/main.js b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-fenced-code-marker/lib/main.js
index a36786876197..15dc1a9e50ea 100644
--- a/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-fenced-code-marker/lib/main.js
+++ b/lib/node_modules/@stdlib/_tools/eslint/rules/jsdoc-fenced-code-marker/lib/main.js
@@ -24,7 +24,7 @@ var parseJSDoc = require( 'doctrine' ).parse;
 var remark = require( 'remark' );
 var remarkLint = require( 'remark-lint' );
 var remarkPlugin = require( 'remark-lint-fenced-code-marker' );
-var repeat = require('@stdlib/string/repeat');
+var repeat = require( '@stdlib/string/repeat' );
 var isObject = require( '@stdlib/assert/is-object' );
 var findJSDoc = require( '@stdlib/_tools/eslint/utils/find-jsdoc' );
 
diff --git a/lib/node_modules/@stdlib/_tools/scripts/transform.js b/lib/node_modules/@stdlib/_tools/scripts/transform.js
index 085352edb330..7692af0f366f 100644
--- a/lib/node_modules/@stdlib/_tools/scripts/transform.js
+++ b/lib/node_modules/@stdlib/_tools/scripts/transform.js
@@ -22,11 +22,11 @@
 
 var logger = require( 'debug' );
 var readFileSync = require( '@stdlib/fs/read-file' ).sync;
-var startsWith = require('@stdlib/string/starts-with');
-var contains = require('@stdlib/assert/contains');
+var startsWith = require( '@stdlib/string/starts-with' );
+var contains = require( '@stdlib/assert/contains' );
 var replace = require( '@stdlib/string/replace' );
 var pkg2id = require( '@stdlib/error/tools/pkg2id' );
-var msg2id = require( '@stdlib/error/tools/msg2id');
+var msg2id = require( '@stdlib/error/tools/msg2id' );
 var ENV = require( '@stdlib/process/env' );
 
 
diff --git a/lib/node_modules/@stdlib/array/base/cuany/benchmark/benchmark.assign.length.js b/lib/node_modules/@stdlib/array/base/cuany/benchmark/benchmark.assign.length.js
index 7e73c55e3b08..417d7ebd8d5c 100644
--- a/lib/node_modules/@stdlib/array/base/cuany/benchmark/benchmark.assign.length.js
+++ b/lib/node_modules/@stdlib/array/base/cuany/benchmark/benchmark.assign.length.js
@@ -23,7 +23,7 @@
 var bench = require( '@stdlib/bench' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var isArray = require( '@stdlib/assert/is-array' );
-var filled = require('@stdlib/array/base/filled');
+var filled = require( '@stdlib/array/base/filled' );
 var pkg = require( './../package.json' ).name;
 var cuany = require( './../lib' );
 
diff --git a/lib/node_modules/@stdlib/array/base/cuany/benchmark/benchmark.length.js b/lib/node_modules/@stdlib/array/base/cuany/benchmark/benchmark.length.js
index 55e3f7c124ea..9c3e8e35761e 100644
--- a/lib/node_modules/@stdlib/array/base/cuany/benchmark/benchmark.length.js
+++ b/lib/node_modules/@stdlib/array/base/cuany/benchmark/benchmark.length.js
@@ -23,7 +23,7 @@
 var bench = require( '@stdlib/bench' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var isArray = require( '@stdlib/assert/is-array' );
-var filled = require('@stdlib/array/base/filled');
+var filled = require( '@stdlib/array/base/filled' );
 var pkg = require( './../package.json' ).name;
 var cuany = require( './../lib' );
 
diff --git a/lib/node_modules/@stdlib/array/base/cuevery/benchmark/benchmark.assign.length.js b/lib/node_modules/@stdlib/array/base/cuevery/benchmark/benchmark.assign.length.js
index 15bfbabd288f..20233a5d5066 100644
--- a/lib/node_modules/@stdlib/array/base/cuevery/benchmark/benchmark.assign.length.js
+++ b/lib/node_modules/@stdlib/array/base/cuevery/benchmark/benchmark.assign.length.js
@@ -23,7 +23,7 @@
 var bench = require( '@stdlib/bench' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var isArray = require( '@stdlib/assert/is-array' );
-var filled = require('@stdlib/array/base/filled');
+var filled = require( '@stdlib/array/base/filled' );
 var pkg = require( './../package.json' ).name;
 var cuevery = require( './../lib' );
 
diff --git a/lib/node_modules/@stdlib/array/base/cuevery/benchmark/benchmark.length.js b/lib/node_modules/@stdlib/array/base/cuevery/benchmark/benchmark.length.js
index 9e8a60559af8..e9a54d3ab32e 100644
--- a/lib/node_modules/@stdlib/array/base/cuevery/benchmark/benchmark.length.js
+++ b/lib/node_modules/@stdlib/array/base/cuevery/benchmark/benchmark.length.js
@@ -23,7 +23,7 @@
 var bench = require( '@stdlib/bench' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var isArray = require( '@stdlib/assert/is-array' );
-var filled = require('@stdlib/array/base/filled');
+var filled = require( '@stdlib/array/base/filled' );
 var pkg = require( './../package.json' ).name;
 var cuevery = require( './../lib' );
 
diff --git a/lib/node_modules/@stdlib/array/base/cunone/benchmark/benchmark.length.js b/lib/node_modules/@stdlib/array/base/cunone/benchmark/benchmark.length.js
index f7292ff7166a..76d8a6779943 100644
--- a/lib/node_modules/@stdlib/array/base/cunone/benchmark/benchmark.length.js
+++ b/lib/node_modules/@stdlib/array/base/cunone/benchmark/benchmark.length.js
@@ -23,7 +23,7 @@
 var bench = require( '@stdlib/bench' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var isArray = require( '@stdlib/assert/is-array' );
-var filled = require('@stdlib/array/base/filled');
+var filled = require( '@stdlib/array/base/filled' );
 var pkg = require( './../package.json' ).name;
 var cunone = require( './../lib' );
 
diff --git a/lib/node_modules/@stdlib/array/base/take-map/lib/assign.js b/lib/node_modules/@stdlib/array/base/take-map/lib/assign.js
index 5c868c946569..bf2d129271ec 100644
--- a/lib/node_modules/@stdlib/array/base/take-map/lib/assign.js
+++ b/lib/node_modules/@stdlib/array/base/take-map/lib/assign.js
@@ -237,7 +237,7 @@ function complexMap( x, indices, mode, out, stride, offset, clbk ) {
 * function clbk( val ){
 	return val;
 }
-* var arr = assignMap( x, indices, 'throw', out, 1, 0, clbk);
+* var arr = assignMap( x, indices, 'throw', out, 1, 0, clbk );
 * // arr is [ 4, 2, 3, 1 ]
 *
 * var bool = ( arr === out );
diff --git a/lib/node_modules/@stdlib/array/bool/benchmark/benchmark.find_index.js b/lib/node_modules/@stdlib/array/bool/benchmark/benchmark.find_index.js
index 4eefbf9396e0..c1be2df5937d 100644
--- a/lib/node_modules/@stdlib/array/bool/benchmark/benchmark.find_index.js
+++ b/lib/node_modules/@stdlib/array/bool/benchmark/benchmark.find_index.js
@@ -23,7 +23,7 @@
 var bench = require( '@stdlib/bench' );
 var isInteger = require( '@stdlib/assert/is-integer' ).isPrimitive;
 var pkg = require( './../package.json' ).name;
-var BooleanArray = require('./../lib');
+var BooleanArray = require( './../lib' );
 
 
 // MAIN //
diff --git a/lib/node_modules/@stdlib/array/bool/benchmark/benchmark.find_last_index.js b/lib/node_modules/@stdlib/array/bool/benchmark/benchmark.find_last_index.js
index 458d098efb4c..2c2429f72de3 100644
--- a/lib/node_modules/@stdlib/array/bool/benchmark/benchmark.find_last_index.js
+++ b/lib/node_modules/@stdlib/array/bool/benchmark/benchmark.find_last_index.js
@@ -23,7 +23,7 @@
 var bench = require( '@stdlib/bench' );
 var isInteger = require( '@stdlib/assert/is-integer' ).isPrimitive;
 var pkg = require( './../package.json' ).name;
-var BooleanArray = require('./../lib');
+var BooleanArray = require( './../lib' );
 
 
 // MAIN //
diff --git a/lib/node_modules/@stdlib/array/bool/test/test.every.js b/lib/node_modules/@stdlib/array/bool/test/test.every.js
index e9162d943a43..0eae1a727e61 100644
--- a/lib/node_modules/@stdlib/array/bool/test/test.every.js
+++ b/lib/node_modules/@stdlib/array/bool/test/test.every.js
@@ -162,7 +162,7 @@ tape( 'the method supports providing an execution context', function test( t ) {
 	bool = arr.every( predicate, ctx );
 
 	t.strictEqual( bool, true, 'returns expected value' );
-	t.strictEqual( ctx.count, 4, 'returns expected value');
+	t.strictEqual( ctx.count, 4, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/array/bool/test/test.find.js b/lib/node_modules/@stdlib/array/bool/test/test.find.js
index 2cd9df385843..c675e996bc3e 100644
--- a/lib/node_modules/@stdlib/array/bool/test/test.find.js
+++ b/lib/node_modules/@stdlib/array/bool/test/test.find.js
@@ -161,8 +161,8 @@ tape( 'the method supports providing an execution context', function test( t ) {
 	arr = new BooleanArray( [ true, true, false, true, false ] );
 	v = arr.find( predicate, ctx );
 
-	t.strictEqual( v, false, 'returns expected value');
-	t.strictEqual( ctx.count, 3, 'returns expected value');
+	t.strictEqual( v, false, 'returns expected value' );
+	t.strictEqual( ctx.count, 3, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/array/bool/test/test.find_last.js b/lib/node_modules/@stdlib/array/bool/test/test.find_last.js
index 431bc3683d4a..bdd461accdca 100644
--- a/lib/node_modules/@stdlib/array/bool/test/test.find_last.js
+++ b/lib/node_modules/@stdlib/array/bool/test/test.find_last.js
@@ -161,8 +161,8 @@ tape( 'the method supports providing an execution context', function test( t ) {
 	arr = new BooleanArray( [ true, true, false, true, false ] );
 	v = arr.findLast( predicate, ctx );
 
-	t.strictEqual( v, true, 'returns expected value');
-	t.strictEqual( ctx.count, 2, 'returns expected value');
+	t.strictEqual( v, true, 'returns expected value' );
+	t.strictEqual( ctx.count, 2, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/array/bool/test/test.map.js b/lib/node_modules/@stdlib/array/bool/test/test.map.js
index b4805e7d24fc..cb70f0f4e885 100644
--- a/lib/node_modules/@stdlib/array/bool/test/test.map.js
+++ b/lib/node_modules/@stdlib/array/bool/test/test.map.js
@@ -27,7 +27,7 @@ var identity = require( '@stdlib/utils/identity-function' );
 var reinterpretBool = require( '@stdlib/strided/base/reinterpret-boolean' );
 var instanceOf = require( '@stdlib/assert/instance-of' );
 var Uint8Array = require( '@stdlib/array/uint8' );
-var BooleanArray = require('./../lib');
+var BooleanArray = require( './../lib' );
 
 
 // TESTS //
diff --git a/lib/node_modules/@stdlib/array/bool/test/test.some.js b/lib/node_modules/@stdlib/array/bool/test/test.some.js
index 81b09922f4f6..3d405035d13e 100644
--- a/lib/node_modules/@stdlib/array/bool/test/test.some.js
+++ b/lib/node_modules/@stdlib/array/bool/test/test.some.js
@@ -162,7 +162,7 @@ tape( 'the method supports providing an execution context', function test( t ) {
 	bool = arr.some( predicate, ctx );
 
 	t.strictEqual( bool, true, 'returns expected value' );
-	t.strictEqual( ctx.count, 2, 'returns expected value');
+	t.strictEqual( ctx.count, 2, 'returns expected value' );
 
 	t.end();
 
@@ -184,7 +184,7 @@ tape( 'the method stops executing upon encountering the first element which pass
 	bool = arr.some( predicate, ctx );
 
 	t.strictEqual( bool, true, 'returns expected value' );
-	t.strictEqual( ctx.count, 2, 'returns expected value');
+	t.strictEqual( ctx.count, 2, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/array/complex128/benchmark/benchmark.fill.length.js b/lib/node_modules/@stdlib/array/complex128/benchmark/benchmark.fill.length.js
index d711e00808f8..5ee76c29a404 100644
--- a/lib/node_modules/@stdlib/array/complex128/benchmark/benchmark.fill.length.js
+++ b/lib/node_modules/@stdlib/array/complex128/benchmark/benchmark.fill.length.js
@@ -23,7 +23,7 @@
 var bench = require( '@stdlib/bench' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var Complex128 = require( '@stdlib/complex/float64/ctor' );
-var isComplex128Array = require('@stdlib/assert/is-complex128array');
+var isComplex128Array = require( '@stdlib/assert/is-complex128array' );
 var pkg = require( './../package.json' ).name;
 var Complex128Array = require( './../lib' );
 
diff --git a/lib/node_modules/@stdlib/array/complex128/benchmark/benchmark.keys.length.js b/lib/node_modules/@stdlib/array/complex128/benchmark/benchmark.keys.length.js
index 602bf4b3ed6d..9cffd0956f5f 100644
--- a/lib/node_modules/@stdlib/array/complex128/benchmark/benchmark.keys.length.js
+++ b/lib/node_modules/@stdlib/array/complex128/benchmark/benchmark.keys.length.js
@@ -23,7 +23,7 @@
 var bench = require( '@stdlib/bench' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var Complex128 = require( '@stdlib/complex/float64/ctor' );
-var isIteratorLike = require('@stdlib/assert/is-iterator-like');
+var isIteratorLike = require( '@stdlib/assert/is-iterator-like' );
 var pkg = require( './../package.json' ).name;
 var Complex128Array = require( './../lib' );
 
diff --git a/lib/node_modules/@stdlib/array/complex128/benchmark/benchmark.map.js b/lib/node_modules/@stdlib/array/complex128/benchmark/benchmark.map.js
index 034137d30c70..e17343950295 100644
--- a/lib/node_modules/@stdlib/array/complex128/benchmark/benchmark.map.js
+++ b/lib/node_modules/@stdlib/array/complex128/benchmark/benchmark.map.js
@@ -24,7 +24,7 @@ var bench = require( '@stdlib/bench' );
 var isComplex128Array = require( '@stdlib/assert/is-complex128array' );
 var realf = require( '@stdlib/complex/realf' );
 var imagf = require( '@stdlib/complex/imagf' );
-var Complex128 = require('@stdlib/complex/float64/ctor');
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
 var pkg = require( './../package.json' ).name;
 var Complex128Array = require( './../lib' );
 
diff --git a/lib/node_modules/@stdlib/array/complex128/benchmark/benchmark.values.length.js b/lib/node_modules/@stdlib/array/complex128/benchmark/benchmark.values.length.js
index 0a43ff04bab2..4de53fab3302 100644
--- a/lib/node_modules/@stdlib/array/complex128/benchmark/benchmark.values.length.js
+++ b/lib/node_modules/@stdlib/array/complex128/benchmark/benchmark.values.length.js
@@ -23,7 +23,7 @@
 var bench = require( '@stdlib/bench' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var Complex128 = require( '@stdlib/complex/float64/ctor' );
-var isIteratorLike = require('@stdlib/assert/is-iterator-like');
+var isIteratorLike = require( '@stdlib/assert/is-iterator-like' );
 var pkg = require( './../package.json' ).name;
 var Complex128Array = require( './../lib' );
 
diff --git a/lib/node_modules/@stdlib/array/complex128/test/test.every.js b/lib/node_modules/@stdlib/array/complex128/test/test.every.js
index 887f105aa7d3..afb80cff2d90 100644
--- a/lib/node_modules/@stdlib/array/complex128/test/test.every.js
+++ b/lib/node_modules/@stdlib/array/complex128/test/test.every.js
@@ -164,7 +164,7 @@ tape( 'the method supports providing an execution context', function test( t ) {
 	bool = arr.every( predicate, ctx );
 
 	t.strictEqual( bool, true, 'returns expected value' );
-	t.strictEqual( ctx.count, 3, 'returns expected value');
+	t.strictEqual( ctx.count, 3, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/array/complex128/test/test.find.js b/lib/node_modules/@stdlib/array/complex128/test/test.find.js
index db78de2bac54..ed9b2c018035 100644
--- a/lib/node_modules/@stdlib/array/complex128/test/test.find.js
+++ b/lib/node_modules/@stdlib/array/complex128/test/test.find.js
@@ -164,9 +164,9 @@ tape( 'the method supports providing an execution context', function test( t ) {
 	arr = new Complex128Array( [ 1.0, -1.0, 2.0, -2.0, 3.0, 3.0 ] );
 	z = arr.find( predicate, ctx );
 
-	t.strictEqual( real( z ), 3.0, 'returns expected value');
-	t.strictEqual( imag( z ), 3.0, 'returns expected value');
-	t.strictEqual( ctx.count, 3, 'returns expected value');
+	t.strictEqual( real( z ), 3.0, 'returns expected value' );
+	t.strictEqual( imag( z ), 3.0, 'returns expected value' );
+	t.strictEqual( ctx.count, 3, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/array/complex128/test/test.find_last.js b/lib/node_modules/@stdlib/array/complex128/test/test.find_last.js
index d838f160db22..c4e3e949f178 100644
--- a/lib/node_modules/@stdlib/array/complex128/test/test.find_last.js
+++ b/lib/node_modules/@stdlib/array/complex128/test/test.find_last.js
@@ -164,9 +164,9 @@ tape( 'the method supports providing an execution context', function test( t ) {
 	arr = new Complex128Array( [ 1.0, -1.0, 2.0, -2.0, 3.0, 3.0 ] );
 	z = arr.findLast( predicate, ctx );
 
-	t.strictEqual( real( z ), 3.0, 'returns expected value');
-	t.strictEqual( imag( z ), 3.0, 'returns expected value');
-	t.strictEqual( ctx.count, 1, 'returns expected value');
+	t.strictEqual( real( z ), 3.0, 'returns expected value' );
+	t.strictEqual( imag( z ), 3.0, 'returns expected value' );
+	t.strictEqual( ctx.count, 1, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/array/complex128/test/test.for_each.js b/lib/node_modules/@stdlib/array/complex128/test/test.for_each.js
index 30e1f9d8e3d2..a9d978b956ab 100644
--- a/lib/node_modules/@stdlib/array/complex128/test/test.for_each.js
+++ b/lib/node_modules/@stdlib/array/complex128/test/test.for_each.js
@@ -24,7 +24,7 @@ var tape = require( 'tape' );
 var hasOwnProp = require( '@stdlib/assert/has-own-property' );
 var isFunction = require( '@stdlib/assert/is-function' );
 var reinterpret128 = require( '@stdlib/strided/base/reinterpret-complex128' );
-var isComplex128 = require('@stdlib/assert/is-complex128');
+var isComplex128 = require( '@stdlib/assert/is-complex128' );
 var Complex128Array = require( './../lib' );
 
 
diff --git a/lib/node_modules/@stdlib/array/complex128/test/test.map.js b/lib/node_modules/@stdlib/array/complex128/test/test.map.js
index f71c5301f6e2..38507811a3e5 100644
--- a/lib/node_modules/@stdlib/array/complex128/test/test.map.js
+++ b/lib/node_modules/@stdlib/array/complex128/test/test.map.js
@@ -28,7 +28,7 @@ var reinterpret128 = require( '@stdlib/strided/base/reinterpret-complex128' );
 var instanceOf = require( '@stdlib/assert/instance-of' );
 var real = require( '@stdlib/complex/real' );
 var imag = require( '@stdlib/complex/imag' );
-var Complex128 = require('@stdlib/complex/float64/ctor');
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
 var Float64Array = require( '@stdlib/array/float64' );
 var Complex128Array = require( './../lib' );
 
diff --git a/lib/node_modules/@stdlib/array/linspace/test/test.assign.js b/lib/node_modules/@stdlib/array/linspace/test/test.assign.js
index f4fc68232957..45b514d3cb04 100644
--- a/lib/node_modules/@stdlib/array/linspace/test/test.assign.js
+++ b/lib/node_modules/@stdlib/array/linspace/test/test.assign.js
@@ -1526,7 +1526,7 @@ tape( 'the function returns a linearly spaced array (real; dtype=float64)', func
 	t.strictEqual( actual, out, 'returns expected value' );
 	t.deepEqual( actual, expected, 'returns expected value' );
 
-	out = new Float64Array( 6);
+	out = new Float64Array( 6 );
 	actual = linspace( x1, x2, out, opts );
 	expected = new Float64Array( [ x1, -3.0, -1.0, 1.0, 3.0, x2 ] );
 	t.strictEqual( isFloat64Array( actual ), true, 'returns expected value' );
diff --git a/lib/node_modules/@stdlib/array/pool/benchmark/benchmark.js b/lib/node_modules/@stdlib/array/pool/benchmark/benchmark.js
index ed630f8555bf..cda52a9c4697 100644
--- a/lib/node_modules/@stdlib/array/pool/benchmark/benchmark.js
+++ b/lib/node_modules/@stdlib/array/pool/benchmark/benchmark.js
@@ -23,7 +23,7 @@
 var bench = require( '@stdlib/bench' );
 var isTypedArray = require( '@stdlib/assert/is-typed-array' );
 var isComplexTypedArray = require( '@stdlib/assert/is-complex-typed-array' );
-var isBooleanArray = require('@stdlib/assert/is-booleanarray');
+var isBooleanArray = require( '@stdlib/assert/is-booleanarray' );
 var pkg = require( './../package.json' ).name;
 var typedarray = require( './../lib' );
 
diff --git a/lib/node_modules/@stdlib/blas/base/sdot/lib/sdot.js b/lib/node_modules/@stdlib/blas/base/sdot/lib/sdot.js
index c2195bcff323..36ac4ecbc2bb 100644
--- a/lib/node_modules/@stdlib/blas/base/sdot/lib/sdot.js
+++ b/lib/node_modules/@stdlib/blas/base/sdot/lib/sdot.js
@@ -21,7 +21,7 @@
 // MODULES //
 
 var stride2offset = require( '@stdlib/strided/base/stride2offset' );
-var ndarray = require('./ndarray.js');
+var ndarray = require( './ndarray.js' );
 
 
 // MAIN //
diff --git a/lib/node_modules/@stdlib/math/base/special/acotd/lib/main.js b/lib/node_modules/@stdlib/math/base/special/acotd/lib/main.js
index 15054d14f0c4..7179721da52c 100644
--- a/lib/node_modules/@stdlib/math/base/special/acotd/lib/main.js
+++ b/lib/node_modules/@stdlib/math/base/special/acotd/lib/main.js
@@ -53,8 +53,8 @@ var acot = require( '@stdlib/math/base/special/acot' );
 * // returns NaN
 */
 function acotd( x ) {
-	var rad = acot(x);
-	return rad2deg(rad);
+	var rad = acot( x );
+	return rad2deg( rad );
 }
 
 
diff --git a/lib/node_modules/@stdlib/math/base/special/acscdf/test/test.js b/lib/node_modules/@stdlib/math/base/special/acscdf/test/test.js
index 9429d8450555..393ea050ccb3 100644
--- a/lib/node_modules/@stdlib/math/base/special/acscdf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/acscdf/test/test.js
@@ -25,7 +25,7 @@ var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var uniform = require( '@stdlib/random/base/uniform' );
 var abs = require( '@stdlib/math/base/special/abs' );
 var EPS = require( '@stdlib/constants/float32/eps' );
-var float64ToFloat32 = require('@stdlib/number/float64/base/to-float32');
+var float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' );
 var acscdf = require( './../lib' );
 
 
diff --git a/lib/node_modules/@stdlib/math/base/special/acscdf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/acscdf/test/test.native.js
index dd16800b80f0..bc07452bb70f 100644
--- a/lib/node_modules/@stdlib/math/base/special/acscdf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/acscdf/test/test.native.js
@@ -26,7 +26,7 @@ var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var uniform = require( '@stdlib/random/base/uniform' );
 var abs = require( '@stdlib/math/base/special/abs' );
 var EPS = require( '@stdlib/constants/float32/eps' );
-var float64ToFloat32 = require('@stdlib/number/float64/base/to-float32');
+var float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' );
 var tryRequire = require( '@stdlib/utils/try-require' );
 
 
diff --git a/lib/node_modules/@stdlib/math/base/special/beta/lib/main.js b/lib/node_modules/@stdlib/math/base/special/beta/lib/main.js
index 30d5e53b0692..eb5d2b16052a 100644
--- a/lib/node_modules/@stdlib/math/base/special/beta/lib/main.js
+++ b/lib/node_modules/@stdlib/math/base/special/beta/lib/main.js
@@ -143,7 +143,7 @@ function beta( a, b ) {
 	} else {
 		res *= pow( (agh*bgh)/(cgh*cgh), b );
 	}
-	res *= sqrt( E/bgh);
+	res *= sqrt( E/bgh );
 	return res;
 }
 
diff --git a/lib/node_modules/@stdlib/math/base/special/boxcox/test/test.js b/lib/node_modules/@stdlib/math/base/special/boxcox/test/test.js
index 74fd80be48cb..296413da88db 100644
--- a/lib/node_modules/@stdlib/math/base/special/boxcox/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/boxcox/test/test.js
@@ -48,7 +48,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 	var b;
 
-	b = boxcox( NaN, 1.0);
+	b = boxcox( NaN, 1.0 );
 	t.equal( isnan( b ), true, 'returns NaN' );
 
 	b = boxcox( 1.0, NaN );
diff --git a/lib/node_modules/@stdlib/math/base/special/boxcox/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/boxcox/test/test.native.js
index 4b074c7db737..21331670e081 100644
--- a/lib/node_modules/@stdlib/math/base/special/boxcox/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/boxcox/test/test.native.js
@@ -57,7 +57,7 @@ tape( 'main export is a function', opts, function test( t ) {
 tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 	var b;
 
-	b = boxcox( NaN, 1.0);
+	b = boxcox( NaN, 1.0 );
 	t.equal( isnan( b ), true, 'returns NaN' );
 
 	b = boxcox( 1.0, NaN );
diff --git a/lib/node_modules/@stdlib/math/base/special/boxcox1p/test/test.js b/lib/node_modules/@stdlib/math/base/special/boxcox1p/test/test.js
index c9c57e8e252a..0b9307ea9311 100644
--- a/lib/node_modules/@stdlib/math/base/special/boxcox1p/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/boxcox1p/test/test.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 	var b;
 
-	b = boxcox1p( NaN, 1.0);
+	b = boxcox1p( NaN, 1.0 );
 	t.equal( isnan( b ), true, 'returns NaN' );
 
 	b = boxcox1p( 1.0, NaN );
diff --git a/lib/node_modules/@stdlib/math/base/special/boxcox1p/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/boxcox1p/test/test.native.js
index 84dbe90a4564..31f934263a96 100644
--- a/lib/node_modules/@stdlib/math/base/special/boxcox1p/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/boxcox1p/test/test.native.js
@@ -59,7 +59,7 @@ tape( 'main export is a function', opts, function test( t ) {
 tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 	var b;
 
-	b = boxcox1p( NaN, 1.0);
+	b = boxcox1p( NaN, 1.0 );
 	t.equal( isnan( b ), true, 'returns NaN' );
 
 	b = boxcox1p( 1.0, NaN );
diff --git a/lib/node_modules/@stdlib/math/base/special/boxcox1pinv/test/test.js b/lib/node_modules/@stdlib/math/base/special/boxcox1pinv/test/test.js
index 7f98d40230a1..ffa20f3e9cf6 100644
--- a/lib/node_modules/@stdlib/math/base/special/boxcox1pinv/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/boxcox1pinv/test/test.js
@@ -50,7 +50,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 	var b;
 
-	b = boxcox1pinv( NaN, 1.0);
+	b = boxcox1pinv( NaN, 1.0 );
 	t.equal( isnan( b ), true, 'returns NaN' );
 
 	b = boxcox1pinv( 1.0, NaN );
diff --git a/lib/node_modules/@stdlib/math/base/special/boxcox1pinv/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/boxcox1pinv/test/test.native.js
index 38f5ab7ad7d7..3cfafba1e689 100644
--- a/lib/node_modules/@stdlib/math/base/special/boxcox1pinv/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/boxcox1pinv/test/test.native.js
@@ -59,7 +59,7 @@ tape( 'main export is a function', opts, function test( t ) {
 tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 	var b;
 
-	b = boxcox1pinv( NaN, 1.0);
+	b = boxcox1pinv( NaN, 1.0 );
 	t.equal( isnan( b ), true, 'returns NaN' );
 
 	b = boxcox1pinv( 1.0, NaN );
diff --git a/lib/node_modules/@stdlib/math/base/special/boxcoxinv/test/test.js b/lib/node_modules/@stdlib/math/base/special/boxcoxinv/test/test.js
index 9ef77883859c..f5d2a603fa82 100644
--- a/lib/node_modules/@stdlib/math/base/special/boxcoxinv/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/boxcoxinv/test/test.js
@@ -49,7 +49,7 @@ tape( 'main export is a function', function test( t ) {
 tape( 'the function returns `NaN` if provided `NaN`', function test( t ) {
 	var b;
 
-	b = boxcoxinv( NaN, 1.0);
+	b = boxcoxinv( NaN, 1.0 );
 	t.equal( isnan( b ), true, 'returns NaN' );
 
 	b = boxcoxinv( 1.0, NaN );
diff --git a/lib/node_modules/@stdlib/math/base/special/boxcoxinv/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/boxcoxinv/test/test.native.js
index 1127e1d0531c..ada83bafe164 100644
--- a/lib/node_modules/@stdlib/math/base/special/boxcoxinv/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/boxcoxinv/test/test.native.js
@@ -58,7 +58,7 @@ tape( 'main export is a function', opts, function test( t ) {
 tape( 'the function returns `NaN` if provided `NaN`', opts, function test( t ) {
 	var b;
 
-	b = boxcoxinv( NaN, 1.0);
+	b = boxcoxinv( NaN, 1.0 );
 	t.equal( isnan( b ), true, 'returns NaN' );
 
 	b = boxcoxinv( 1.0, NaN );
diff --git a/lib/node_modules/@stdlib/math/base/special/cexp/lib/main.js b/lib/node_modules/@stdlib/math/base/special/cexp/lib/main.js
index 09a4afa0d597..717dcba3b069 100644
--- a/lib/node_modules/@stdlib/math/base/special/cexp/lib/main.js
+++ b/lib/node_modules/@stdlib/math/base/special/cexp/lib/main.js
@@ -20,7 +20,7 @@
 
 // MODULES //
 
-var Complex128 = require('@stdlib/complex/float64/ctor');
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
 var copysign = require( '@stdlib/math/base/special/copysign' );
 var sincos = require( '@stdlib/math/base/special/sincos' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
diff --git a/lib/node_modules/@stdlib/math/base/special/cinv/lib/main.js b/lib/node_modules/@stdlib/math/base/special/cinv/lib/main.js
index 64f297bcc00f..3d0ac80da10c 100644
--- a/lib/node_modules/@stdlib/math/base/special/cinv/lib/main.js
+++ b/lib/node_modules/@stdlib/math/base/special/cinv/lib/main.js
@@ -97,7 +97,7 @@ function cinv( z ) {
 	}
 	re *= s;
 	im *= s;
-	return new Complex128( re, im);
+	return new Complex128( re, im );
 }
 
 
diff --git a/lib/node_modules/@stdlib/math/base/special/cosm1/test/test.js b/lib/node_modules/@stdlib/math/base/special/cosm1/test/test.js
index bcfe9bfd00f9..740dbfc662f2 100644
--- a/lib/node_modules/@stdlib/math/base/special/cosm1/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/cosm1/test/test.js
@@ -69,7 +69,7 @@ tape( 'the function computes the cosine minues one more accurately inside the in
 		} else {
 			delta = abs( y - expected[i] );
 			tol = 2.0 * EPS * abs( expected[i] );
-			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y+'. E: '+expected[i]+'. tol: '+tol+'. Δ: '+delta+'.');
+			t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y+'. E: '+expected[i]+'. tol: '+tol+'. Δ: '+delta+'.' );
 		}
 	}
 
@@ -91,7 +91,7 @@ tape( 'the function computes `cos(x) - 1.0` outside the interval [-π/4,π/4]',
 		expected = cos( x[i] ) - 1;
 		delta = abs( y - expected );
 		tol = EPS * abs( expected );
-		t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y+'. E: '+expected+'. tol: '+tol+'. Δ: '+delta+'.');
+		t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y+'. E: '+expected+'. tol: '+tol+'. Δ: '+delta+'.' );
 	}
 
 	x = linspace( -4.0*PI, NPIO4, 100 );
@@ -101,7 +101,7 @@ tape( 'the function computes `cos(x) - 1.0` outside the interval [-π/4,π/4]',
 		expected = cos( x[i] ) - 1.0;
 		delta = abs( y - expected );
 		tol = EPS * abs( expected );
-		t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y+'. E: '+expected+'. tol: '+tol+'. Δ: '+delta+'.');
+		t.ok( delta <= tol, 'within tolerance. x: '+x[i]+'. Value: '+y+'. E: '+expected+'. tol: '+tol+'. Δ: '+delta+'.' );
 	}
 
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/base/special/csc/lib/index.js b/lib/node_modules/@stdlib/math/base/special/csc/lib/index.js
index 515070b6d076..26e8d1037dc2 100644
--- a/lib/node_modules/@stdlib/math/base/special/csc/lib/index.js
+++ b/lib/node_modules/@stdlib/math/base/special/csc/lib/index.js
@@ -44,7 +44,7 @@
 
 // MODULES //
 
-var main = require('./main.js');
+var main = require( './main.js' );
 
 
 // EXPORTS //
diff --git a/lib/node_modules/@stdlib/math/base/special/csc/lib/main.js b/lib/node_modules/@stdlib/math/base/special/csc/lib/main.js
index 30f4f6a2d1f7..3d2cbe4fb3a8 100644
--- a/lib/node_modules/@stdlib/math/base/special/csc/lib/main.js
+++ b/lib/node_modules/@stdlib/math/base/special/csc/lib/main.js
@@ -20,7 +20,7 @@
 
 // MODULES //
 
-var sin = require('@stdlib/math/base/special/sin');
+var sin = require( '@stdlib/math/base/special/sin' );
 
 
 // MAIN //
@@ -52,7 +52,7 @@ var sin = require('@stdlib/math/base/special/sin');
 * // returns NaN
 */
 function csc( x ) {
-	return 1.0 / sin(x);
+	return 1.0 / sin( x );
 }
 
 
diff --git a/lib/node_modules/@stdlib/math/base/special/csc/test/test.js b/lib/node_modules/@stdlib/math/base/special/csc/test/test.js
index b6367b91e087..97ab0b739eeb 100644
--- a/lib/node_modules/@stdlib/math/base/special/csc/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/csc/test/test.js
@@ -50,8 +50,8 @@ var tinyPositive = require( './fixtures/julia/tiny_positive.json' );
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {
-	t.ok(true, __filename);
-	t.true(typeof csc, 'function', 'main export is a function');
+	t.ok( true, __filename );
+	t.true( typeof csc, 'function', 'main export is a function' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/math/base/special/exp/lib/expmulti.js b/lib/node_modules/@stdlib/math/base/special/exp/lib/expmulti.js
index c440e5123cad..d333c7e89b5b 100644
--- a/lib/node_modules/@stdlib/math/base/special/exp/lib/expmulti.js
+++ b/lib/node_modules/@stdlib/math/base/special/exp/lib/expmulti.js
@@ -88,7 +88,7 @@ function expmulti( hi, lo, k ) {
 	r = hi - lo;
 	t = r * r;
 	c = r - ( t*polyvalP( t ) );
-	y = 1.0 - ( lo - ( (r*c)/(2.0-c) ) - hi);
+	y = 1.0 - ( lo - ( (r*c)/(2.0-c) ) - hi );
 
 	return ldexp( y, k );
 }
diff --git a/lib/node_modules/@stdlib/math/base/special/gammainc/test/test.js b/lib/node_modules/@stdlib/math/base/special/gammainc/test/test.js
index 2ccc331c013e..09f8f6978307 100644
--- a/lib/node_modules/@stdlib/math/base/special/gammainc/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/gammainc/test/test.js
@@ -30,7 +30,7 @@ var gammainc = require( './../lib' );
 
 // FIXTURES //
 
-var fixtures = require( './fixtures/cpp/output.json');
+var fixtures = require( './fixtures/cpp/output.json' );
 var expected1 = fixtures.lower_regularized;
 var expected2 = fixtures.upper_regularized;
 var expected3 = fixtures.lower_unregularized;
diff --git a/lib/node_modules/@stdlib/math/base/special/gammaincinv/lib/compute.js b/lib/node_modules/@stdlib/math/base/special/gammaincinv/lib/compute.js
index 5e7a62aa66b4..c01fc8de1523 100644
--- a/lib/node_modules/@stdlib/math/base/special/gammaincinv/lib/compute.js
+++ b/lib/node_modules/@stdlib/math/base/special/gammaincinv/lib/compute.js
@@ -156,7 +156,7 @@ function compute( a, p, q ) {
 	}
 	if ( q < 1.0e-30 && a < HALF ) {
 		m = 0;
-		x0 = -ln( q*gamma(a) ) + ( ( a-1.0 ) * ln( -ln( q*gamma(a) ) ));
+		x0 = -ln( q*gamma(a) ) + ( ( a-1.0 ) * ln( -ln( q*gamma(a) ) ) );
 		k = 1;
 		lgama = gammaln( a );
 	}
diff --git a/lib/node_modules/@stdlib/math/base/special/kernel-betainc/lib/assign.js b/lib/node_modules/@stdlib/math/base/special/kernel-betainc/lib/assign.js
index 37bed3858413..8e65e08a8a55 100644
--- a/lib/node_modules/@stdlib/math/base/special/kernel-betainc/lib/assign.js
+++ b/lib/node_modules/@stdlib/math/base/special/kernel-betainc/lib/assign.js
@@ -55,7 +55,7 @@ var PI = require( '@stdlib/constants/float64/pi' );
 var betaSmallBLargeASeries = require( './beta_small_b_large_a_series.js' );
 var risingFactorialRatio = require( './rising_factorial_ratio.js' );
 var ibetaPowerTerms = require( './ibeta_power_terms.js' );
-var ibetaFraction2 = require( './ibeta_fraction2.js');
+var ibetaFraction2 = require( './ibeta_fraction2.js' );
 var binomialCCDF = require( './binomial_ccdf.js' );
 var ibetaAStep = require( './ibeta_a_step.js' );
 var ibetaSeries = require( './ibeta_series.js' );
diff --git a/lib/node_modules/@stdlib/math/base/special/kernel-betaincinv/lib/halley_iterate.js b/lib/node_modules/@stdlib/math/base/special/kernel-betaincinv/lib/halley_iterate.js
index 2d0993756ca7..116de3b0e761 100644
--- a/lib/node_modules/@stdlib/math/base/special/kernel-betaincinv/lib/halley_iterate.js
+++ b/lib/node_modules/@stdlib/math/base/special/kernel-betaincinv/lib/halley_iterate.js
@@ -86,7 +86,7 @@ function halleyIterate( fun, guess, minimum, maximum, digits, maxIter ) {
 		f0Last = f0;
 		delta2 = delta1;
 		delta1 = delta;
-		res = fun( result);
+		res = fun( result );
 		f0 = res[ 0 ];
 		f1 = res[ 1 ];
 		f2 = res[ 2 ];
diff --git a/lib/node_modules/@stdlib/random/base/mt19937/test/test.factory.js b/lib/node_modules/@stdlib/random/base/mt19937/test/test.factory.js
index 855546f1f991..0c13b6b7847e 100644
--- a/lib/node_modules/@stdlib/random/base/mt19937/test/test.factory.js
+++ b/lib/node_modules/@stdlib/random/base/mt19937/test/test.factory.js
@@ -25,7 +25,7 @@
 var tape = require( 'tape' );
 var ENV = require( '@stdlib/process/env' );
 var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
-var FLOAT64_MAX_SAFE_INTEGER = require('@stdlib/constants/float64/max-safe-integer');
+var FLOAT64_MAX_SAFE_INTEGER = require( '@stdlib/constants/float64/max-safe-integer' );
 var isNonNegativeInteger = require( '@stdlib/math/base/assert/is-nonnegative-integer' );
 var isUint32Array = require( '@stdlib/assert/is-uint32array' );
 var Uint32Array = require( '@stdlib/array/uint32' );
diff --git a/lib/node_modules/@stdlib/random/base/mt19937/test/test.js b/lib/node_modules/@stdlib/random/base/mt19937/test/test.js
index 6845277a35bb..0de4aa709e0d 100644
--- a/lib/node_modules/@stdlib/random/base/mt19937/test/test.js
+++ b/lib/node_modules/@stdlib/random/base/mt19937/test/test.js
@@ -22,7 +22,7 @@
 
 var tape = require( 'tape' );
 var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
-var FLOAT64_MAX_SAFE_INTEGER = require('@stdlib/constants/float64/max-safe-integer');
+var FLOAT64_MAX_SAFE_INTEGER = require( '@stdlib/constants/float64/max-safe-integer' );
 var isUint32Array = require( '@stdlib/assert/is-uint32array' );
 var isNonNegativeInteger = require( '@stdlib/math/base/assert/is-nonnegative-integer' );
 var mt19937 = require( './../lib' );
diff --git a/lib/node_modules/@stdlib/random/streams/chisquare/lib/factory.js b/lib/node_modules/@stdlib/random/streams/chisquare/lib/factory.js
index e09b2a76e09b..79455513b32c 100644
--- a/lib/node_modules/@stdlib/random/streams/chisquare/lib/factory.js
+++ b/lib/node_modules/@stdlib/random/streams/chisquare/lib/factory.js
@@ -75,7 +75,7 @@ function factory( k, options ) {
 			throw new TypeError( format( 'invalid argument. Options argument must be an object. Value: `%s`.', options ) );
 		}
 		fcn = createStream2;
-		opts = assign( {}, options);
+		opts = assign( {}, options );
 	} else if ( nargs === 1 ) {
 		if ( isPositive( k ) ) {
 			fcn = createStream2;
diff --git a/lib/node_modules/@stdlib/stats/kde2d/examples/index.js b/lib/node_modules/@stdlib/stats/kde2d/examples/index.js
index 886d670abf88..c8f764a437d6 100644
--- a/lib/node_modules/@stdlib/stats/kde2d/examples/index.js
+++ b/lib/node_modules/@stdlib/stats/kde2d/examples/index.js
@@ -20,7 +20,7 @@
 
 var normal = require( '@stdlib/random/base/normal' );
 var ndarray = require( '@stdlib/ndarray/ctor' );
-var kde2d = require( '../lib');
+var kde2d = require( './../lib' );
 
 var strides;
 var buffer;
@@ -38,46 +38,46 @@ var n;
 
 n = 100;
 
-x = new Array(n);
-y = new Array(n);
+x = new Array( n );
+y = new Array( n );
 
-randX = normal.factory(3, 1.2);
-randY = normal.factory(10, 4.5);
+randX = normal.factory( 3, 1.2 );
+randY = normal.factory( 10, 4.5 );
 
 for (i = 0; i < n; i++) {
-	x[i] = randX();
-	y[i] = randY();
+	x[ i ] = randX();
+	y[ i ] = randY();
 }
 
-out = kde2d(x, y);
-console.log(out);
+out = kde2d( x, y );
+console.log( out );
 
 // Choose a different number of grid point:
-out = kde2d(x, y, {
+out = kde2d( x, y, {
 	'n': 15
 });
-console.log(out);
+console.log( out );
 
 // Set the x-axis limits:
-out = kde2d(x, y, {
-	'xLim': [-5, 12]
+out = kde2d( x, y, {
+	'xLim': [ -5, 12 ]
 });
-console.log(out);
+console.log( out );
 
 // Set the y-axis limits:
-out = kde2d(x, y, {
-	'yLim': [-3, 13]
+out = kde2d( x, y, {
+	'yLim': [ -3, 13 ]
 } );
-console.log(out);
+console.log( out );
 
 // Choose custom bandwidths:
-out = kde2d(x, y, {
-	'h': [0.05, 0.1]
+out = kde2d( x, y, {
+	'h': [ 0.05, 0.1 ]
 });
-console.log(out);
+console.log( out );
 
 // Use it with an `ndarray`:
-buffer = x.concat(y);
+buffer = x.concat( y );
 shape = [ n, 2 ];
 order = 'column-major';
 strides = [ 1, n ];
diff --git a/lib/node_modules/@stdlib/stats/kde2d/lib/triweight.js b/lib/node_modules/@stdlib/stats/kde2d/lib/triweight.js
index ff35eb98bb10..03f0a019fe8c 100644
--- a/lib/node_modules/@stdlib/stats/kde2d/lib/triweight.js
+++ b/lib/node_modules/@stdlib/stats/kde2d/lib/triweight.js
@@ -36,21 +36,21 @@ var pow = require( '@stdlib/math/base/special/pow' );
 *
 * @example
 * var u = 5;
-* out = triweight(u);
+* out = triweight( u );
 * // returns 0.0
 */
-function triweight(u) {
+function triweight( u ) {
 	var absU;
 
-	if (isnan(u)) {
+	if ( isnan( u ) ) {
 		return NaN;
 	}
 
-	absU = abs(u);
-	if (absU > 1) {
+	absU = abs( u );
+	if ( absU > 1 ) {
 		return 0;
 	}
-	return (35 / 32) * pow(1.0 - pow(u, 2.0), 3.0);
+	return ( 35 / 32 ) * pow( 1.0 - pow( u, 2.0 ), 3.0 );
 }
 
 
diff --git a/lib/node_modules/@stdlib/stats/kde2d/test/test.js b/lib/node_modules/@stdlib/stats/kde2d/test/test.js
index 28e2721ea400..2c569af6b862 100644
--- a/lib/node_modules/@stdlib/stats/kde2d/test/test.js
+++ b/lib/node_modules/@stdlib/stats/kde2d/test/test.js
@@ -208,10 +208,10 @@ tape( 'the function computes the same values with `ndarray` and numeric array in
 	order = 'col-major';
 	offset = 0;
 
-	nd = ndarray( 'generic', buffer, shape, strides, offset, order);
+	nd = ndarray( 'generic', buffer, shape, strides, offset, order );
 
-	actualND = kde2d(nd);
-	actualNumeric = kde2d(dataXSmall, dataYSmall);
+	actualND = kde2d( nd );
+	actualNumeric = kde2d( dataXSmall, dataYSmall );
 
 	// Check x
 	for (i = 0; i < n; i++) {
diff --git a/lib/node_modules/@stdlib/stats/pcorrtest/lib/main.js b/lib/node_modules/@stdlib/stats/pcorrtest/lib/main.js
index 48d9287c46d8..ddff4159ccec 100644
--- a/lib/node_modules/@stdlib/stats/pcorrtest/lib/main.js
+++ b/lib/node_modules/@stdlib/stats/pcorrtest/lib/main.js
@@ -134,11 +134,11 @@ function pcorrTest( x, y, options ) {
 			pval = 1.0 - tCDF( stat, df );
 			break;
 		case 'less':
-			pval = tCDF( stat, df);
+			pval = tCDF( stat, df );
 			break;
 		case 'two-sided':
 		default:
-			pval = 2.0 * min( tCDF( stat, df), 1.0 - tCDF( stat, df ));
+			pval = 2.0 * min( tCDF( stat, df), 1.0 - tCDF( stat, df ) );
 			break;
 		}
 	} else {
@@ -154,7 +154,7 @@ function pcorrTest( x, y, options ) {
 			break;
 		case 'two-sided':
 		default:
-			pval = 2.0 * min( normCDF( -stat ), 1.0 - normCDF( -stat ));
+			pval = 2.0 * min( normCDF( -stat ), 1.0 - normCDF( -stat ) );
 			break;
 		}
 	}
diff --git a/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.factory.js
index 88844dcff6f9..8673c83981e8 100644
--- a/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/debug-sink/test/test.factory.js
@@ -112,7 +112,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 'beep' ) instanceof DebugSinkStream, true, 'returns stream instances');
+		t.equal( createStream( 'beep' ) instanceof DebugSinkStream, true, 'returns stream instances' );
 	}
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns a factory function which creates stream instances (c
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 'beep', noop ) instanceof DebugSinkStream, true, 'returns stream instances');
+		t.equal( createStream( 'beep', noop ) instanceof DebugSinkStream, true, 'returns stream instances' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/streams/node/debug/test/test.factory.js b/lib/node_modules/@stdlib/streams/node/debug/test/test.factory.js
index 52ee81cd0c00..718939d59a97 100644
--- a/lib/node_modules/@stdlib/streams/node/debug/test/test.factory.js
+++ b/lib/node_modules/@stdlib/streams/node/debug/test/test.factory.js
@@ -112,7 +112,7 @@ tape( 'the function returns a factory function which creates stream instances',
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 'beep' ) instanceof DebugStream, true, 'returns stream instances');
+		t.equal( createStream( 'beep' ) instanceof DebugStream, true, 'returns stream instances' );
 	}
 	t.end();
 });
@@ -124,7 +124,7 @@ tape( 'the function returns a factory function which creates stream instances (c
 	createStream = factory();
 
 	for ( i = 0; i < 10; i++ ) {
-		t.equal( createStream( 'beep', noop ) instanceof DebugStream, true, 'returns stream instances');
+		t.equal( createStream( 'beep', noop ) instanceof DebugStream, true, 'returns stream instances' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/string/base/format-interpolate/lib/format_double.js b/lib/node_modules/@stdlib/string/base/format-interpolate/lib/format_double.js
index b84528770da9..38ed7eaa0a7b 100644
--- a/lib/node_modules/@stdlib/string/base/format-interpolate/lib/format_double.js
+++ b/lib/node_modules/@stdlib/string/base/format-interpolate/lib/format_double.js
@@ -83,7 +83,7 @@ function formatDouble( token ) {
 		}
 		if ( !token.alternate ) {
 			out = replace.call( out, RE_ZERO_BEFORE_EXP, '$1e' );
-			out = replace.call( out, RE_PERIOD_ZERO_EXP, 'e');
+			out = replace.call( out, RE_PERIOD_ZERO_EXP, 'e' );
 			out = replace.call( out, RE_TRAILING_PERIOD_ZERO, '' );
 		}
 		break;
diff --git a/lib/node_modules/@stdlib/string/replace/lib/main.js b/lib/node_modules/@stdlib/string/replace/lib/main.js
index acdd27920ebd..d1a447f993e4 100644
--- a/lib/node_modules/@stdlib/string/replace/lib/main.js
+++ b/lib/node_modules/@stdlib/string/replace/lib/main.js
@@ -60,7 +60,7 @@ var base = require( '@stdlib/string/base/replace' );
 *     return capitalize( p1 );
 * }
 *
-* var out = replace( str, /([^\s]*)/gi, replacer);
+* var out = replace( str, /([^\s]*)/gi, replacer );
 * // returns 'Oranges And Lemons Say The Bells Of St. Clement\'s'
 */
 function replace( str, search, newval ) {
diff --git a/lib/node_modules/@stdlib/utils/any-in-by/benchmark/benchmark.js b/lib/node_modules/@stdlib/utils/any-in-by/benchmark/benchmark.js
index b6a24896daf0..de375f7857d5 100644
--- a/lib/node_modules/@stdlib/utils/any-in-by/benchmark/benchmark.js
+++ b/lib/node_modules/@stdlib/utils/any-in-by/benchmark/benchmark.js
@@ -85,7 +85,7 @@ bench( pkg+'::built-in', function benchmark( b ) {
 			'f': NaN
 		};
 		keys = Object.keys( obj );
-		bool = keys.some(testPredicate);
+		bool = keys.some( testPredicate );
 		if ( typeof bool !== 'boolean' ) {
 			b.fail( 'should return a boolean' );
 		}
diff --git a/lib/node_modules/@stdlib/utils/group-in/lib/return_keys.js b/lib/node_modules/@stdlib/utils/group-in/lib/return_keys.js
index 56a84a857ef6..b3ac8a82f306 100644
--- a/lib/node_modules/@stdlib/utils/group-in/lib/return_keys.js
+++ b/lib/node_modules/@stdlib/utils/group-in/lib/return_keys.js
@@ -66,7 +66,7 @@ function groupIn( obj, opts, indicator ) {
 	for ( key in obj ) { // eslint-disable-line guard-for-in
 		g = indicator.call( thisArg, obj[ key ], key );
 		if ( hasOwnProp( out, g ) ) {
-			out[ g ].push( key);
+			out[ g ].push( key );
 		} else {
 			out[ g ] = [ key ];
 		}
diff --git a/lib/node_modules/@stdlib/utils/group-own/lib/return_keys.js b/lib/node_modules/@stdlib/utils/group-own/lib/return_keys.js
index be5cd1c745af..ebad60a5f244 100644
--- a/lib/node_modules/@stdlib/utils/group-own/lib/return_keys.js
+++ b/lib/node_modules/@stdlib/utils/group-own/lib/return_keys.js
@@ -60,7 +60,7 @@ function groupOwn( obj, opts, indicator ) {
 		if ( hasOwnProp( obj, key ) ) {
 			g = indicator.call( thisArg, obj[ key ], key );
 			if ( hasOwnProp( out, g ) ) {
-				out[ g ].push( key);
+				out[ g ].push( key );
 			} else {
 				out[ g ] = [ key ];
 			}
diff --git a/lib/node_modules/@stdlib/utils/move-property/test/test.js b/lib/node_modules/@stdlib/utils/move-property/test/test.js
index 655e59dd29bb..aff4228ecdbb 100644
--- a/lib/node_modules/@stdlib/utils/move-property/test/test.js
+++ b/lib/node_modules/@stdlib/utils/move-property/test/test.js
@@ -135,7 +135,7 @@ tape( 'the function preserves property\'s descriptors', function test( t ) {
 
 	bool = moveProperty( obj1, 'a', obj2 );
 
-	t.ok( bool, 'successfully moved property');
+	t.ok( bool, 'successfully moved property' );
 	t.deepEqual( obj1, {}, 'deep equal' );
 	t.equal( obj2.a, 'b' );
 	t.deepEqual( Object.getOwnPropertyDescriptor( obj2, 'a' ), desc, 'descriptors are equal' );
diff --git a/lib/node_modules/@stdlib/utils/none-in-by/test/test.js b/lib/node_modules/@stdlib/utils/none-in-by/test/test.js
index e059e15e8034..c59178db2354 100644
--- a/lib/node_modules/@stdlib/utils/none-in-by/test/test.js
+++ b/lib/node_modules/@stdlib/utils/none-in-by/test/test.js
@@ -87,12 +87,12 @@ tape( 'if provided an empty object, the function returns `true`', function test(
 	var obj = {};
 
 	function foo() {
-		t.fail('should not be invoked');
+		t.fail( 'should not be invoked' );
 	}
 
-	bool = noneInBy(obj, foo);
+	bool = noneInBy( obj, foo );
 
-	t.strictEqual(bool, true, 'returns true');
+	t.strictEqual( bool, true, 'returns true' );
 	t.end();
 });
 
@@ -105,13 +105,13 @@ tape('the function returns `true` if every property fails a test ', function tes
 		'c': -3
 	};
 
-	function isPositive(value) {
-		return (value > 0);
+	function isPositive( value ) {
+		return ( value > 0 );
 	}
 
-	bool = noneInBy(obj, isPositive);
+	bool = noneInBy( obj, isPositive );
 
-	t.strictEqual(bool, true, 'returns true');
+	t.strictEqual( bool, true, 'returns true' );
 	t.end();
 });
 
@@ -123,13 +123,13 @@ tape( 'the function returns `false` if one or more properties pass a test ', fun
 		'2': -3
 	};
 
-	function isPositive(value) {
-		return (value > 0);
+	function isPositive( value ) {
+		return ( value > 0 );
 	}
 
-	bool = noneInBy(obj, isPositive);
+	bool = noneInBy( obj, isPositive );
 
-	t.strictEqual(bool, false, 'returns false');
+	t.strictEqual( bool, false, 'returns false' );
 	t.end();
 });
 
diff --git a/lib/node_modules/@stdlib/utils/pick/benchmark/benchmark.js b/lib/node_modules/@stdlib/utils/pick/benchmark/benchmark.js
index 0d9cf5273b76..8e95ca339a7f 100644
--- a/lib/node_modules/@stdlib/utils/pick/benchmark/benchmark.js
+++ b/lib/node_modules/@stdlib/utils/pick/benchmark/benchmark.js
@@ -100,8 +100,8 @@ bench( pkg+'::array,multiple', function benchmark( b ) {
 	b.tic();
 	for ( i = 0; i < b.iterations; i++ ) {
 		k1 = fromCodePoint( 97+(i%26) );
-		k2 = fromCodePoint( 97+((i+5)%26));
-		k3 = fromCodePoint( 97+((i+12)%26));
+		k2 = fromCodePoint( 97+((i+5)%26) );
+		k3 = fromCodePoint( 97+((i+12)%26) );
 		o = pick( obj, [ k1, k2, k3 ] );
 		if ( isnan( o[ k1 ] ) ) {
 			b.fail( 'should not be NaN' );

From 659f752db18317bf5fc237fdbcad0d74b61e1ed9 Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Sun, 7 Jul 2024 11:50:27 -0500
Subject: [PATCH 06/16] style: add missing spaces

---
 .../benchmark/benchmark.fill.length.js         |  2 +-
 .../benchmark/benchmark.keys.length.js         |  2 +-
 .../array/complex64/benchmark/benchmark.map.js |  2 +-
 .../complex64/benchmark/benchmark.reduce.js    |  2 +-
 .../benchmark/benchmark.reduce.length.js       |  2 +-
 .../benchmark/benchmark.values.length.js       |  2 +-
 .../@stdlib/array/complex64/test/test.every.js |  2 +-
 .../@stdlib/array/complex64/test/test.find.js  |  6 +++---
 .../array/complex64/test/test.find_last.js     |  6 +++---
 .../array/complex64/test/test.for_each.js      |  2 +-
 .../@stdlib/array/complex64/test/test.map.js   |  2 +-
 .../array/complex64/test/test.reduce.js        |  2 +-
 .../@stdlib/array/complex64/test/test.some.js  |  4 ++--
 .../is-nonpositive-finite/examples/index.js    |  6 +++---
 .../assert/is-nonpositive-finite/lib/main.js   |  2 +-
 .../is-nonpositive-finite/test/test.main.js    |  2 +-
 .../assert/is-well-formed-string/lib/object.js |  4 ++--
 .../is-well-formed-string/lib/primitive.js     |  2 +-
 .../napi/equal-typedarray-types/lib/native.js  |  2 +-
 .../@stdlib/blas/base/sdsdot/lib/sdsdot.js     |  4 ++--
 .../@stdlib/blas/base/srot/lib/srot.js         |  2 +-
 .../blas/base/srotg/test/test.assign.js        |  8 ++++----
 .../@stdlib/blas/base/srotm/lib/srotm.js       |  2 +-
 .../@stdlib/blas/base/sswap/lib/sswap.js       |  4 ++--
 .../ext/base/dnansumkbn2/examples/index.js     |  8 ++++----
 .../@stdlib/complex/base/parse/lib/main.js     |  8 ++++----
 .../@stdlib/complex/float32/parse/test/test.js |  2 +-
 .../@stdlib/complex/float64/parse/test/test.js |  2 +-
 .../@stdlib/fs/append-file/test/test.cli.js    |  2 +-
 .../iter/do-while-each/examples/index.js       |  6 +++---
 .../math/base/special/acosd/lib/main.js        |  4 ++--
 .../special/asec/benchmark/benchmark.native.js | 18 +++++++++---------
 .../math/base/special/asecd/test/test.js       |  4 ++--
 .../base/special/asecd/test/test.native.js     |  4 ++--
 .../math/base/special/asecf/test/test.js       |  2 +-
 .../base/special/asecf/test/test.native.js     |  2 +-
 .../math/base/special/asindf/test/test.js      |  2 +-
 .../base/special/asindf/test/test.native.js    |  2 +-
 .../math/base/special/bessely1/test/test.js    |  2 +-
 .../math/base/special/expm1rel/test/test.js    | 12 ++++++------
 .../base/special/expm1rel/test/test.native.js  | 12 ++++++------
 .../base/special/fast/pow-int/test/test.js     |  2 +-
 .../special/fast/pow-int/test/test.native.js   |  2 +-
 .../lib/gamma_delta_ratio_lanczos.js           |  2 +-
 .../math/base/special/gammainc/lib/main.js     |  4 ++--
 .../special/kernel-betaincinv/lib/temme2.js    |  2 +-
 .../math/base/special/log1mexp/test/test.js    |  6 +++---
 .../base/special/log1mexp/test/test.native.js  |  6 +++---
 .../math/base/special/nanmax/lib/main.js       |  6 +++---
 .../math/base/special/nanmin/lib/main.js       |  6 +++---
 .../math/base/special/rad2degf/test/test.js    |  2 +-
 .../base/special/rad2degf/test/test.native.js  |  2 +-
 .../tools/hermitepoly/test/test.factory.js     |  6 +++---
 .../math/base/tools/hermitepoly/test/test.js   |  6 +++---
 .../tools/normhermitepoly/test/test.factory.js |  6 +++---
 .../base/tools/normhermitepoly/test/test.js    |  6 +++---
 .../base/tools/normhermitepolyf/lib/factory.js |  2 +-
 .../normhermitepolyf/test/test.factory.js      |  6 +++---
 .../base/tools/normhermitepolyf/test/test.js   |  6 +++---
 .../sequences/tribonacci/examples/index.js     |  2 +-
 .../@stdlib/net/http-server/lib/main.js        |  2 +-
 .../stats/base/dists/cosine/cdf/lib/main.js    |  2 +-
 .../stats/base/dists/cosine/mgf/lib/main.js    |  2 +-
 .../base/dists/cosine/quantile/lib/bisect.js   |  2 +-
 .../base/dists/weibull/skewness/lib/main.js    |  2 +-
 .../@stdlib/string/base/replace/lib/main.js    |  2 +-
 66 files changed, 129 insertions(+), 129 deletions(-)

diff --git a/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.fill.length.js b/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.fill.length.js
index ef367e0793c1..bf4df7eaf57d 100644
--- a/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.fill.length.js
+++ b/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.fill.length.js
@@ -23,7 +23,7 @@
 var bench = require( '@stdlib/bench' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var Complex64 = require( '@stdlib/complex/float32/ctor' );
-var isComplex64Array = require('@stdlib/assert/is-complex64array');
+var isComplex64Array = require( '@stdlib/assert/is-complex64array' );
 var pkg = require( './../package.json' ).name;
 var Complex64Array = require( './../lib' );
 
diff --git a/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.keys.length.js b/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.keys.length.js
index 3a1eec4e6ded..51d4d3178f13 100644
--- a/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.keys.length.js
+++ b/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.keys.length.js
@@ -23,7 +23,7 @@
 var bench = require( '@stdlib/bench' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var Complex64 = require( '@stdlib/complex/float32/ctor' );
-var isIteratorLike = require('@stdlib/assert/is-iterator-like');
+var isIteratorLike = require( '@stdlib/assert/is-iterator-like' );
 var pkg = require( './../package.json' ).name;
 var Complex64Array = require( './../lib' );
 
diff --git a/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.map.js b/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.map.js
index 2a18b870ad27..6661130e4a7e 100644
--- a/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.map.js
+++ b/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.map.js
@@ -24,7 +24,7 @@ var bench = require( '@stdlib/bench' );
 var isComplex64Array = require( '@stdlib/assert/is-complex64array' );
 var realf = require( '@stdlib/complex/realf' );
 var imagf = require( '@stdlib/complex/imagf' );
-var Complex64 = require('@stdlib/complex/float32/ctor');
+var Complex64 = require( '@stdlib/complex/float32/ctor' );
 var pkg = require( './../package.json' ).name;
 var Complex64Array = require( './../lib' );
 
diff --git a/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.reduce.js b/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.reduce.js
index f266762c6468..206bbc3fc9d8 100644
--- a/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.reduce.js
+++ b/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.reduce.js
@@ -22,7 +22,7 @@
 
 var bench = require( '@stdlib/bench' );
 var caddf = require( '@stdlib/math/base/ops/caddf' );
-var isComplexLike = require('@stdlib/assert/is-complex-like');
+var isComplexLike = require( '@stdlib/assert/is-complex-like' );
 var pkg = require( './../package.json' ).name;
 var Complex64Array = require( './../lib' );
 
diff --git a/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.reduce.length.js b/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.reduce.length.js
index a2a61b487d4a..9250c9c588b3 100644
--- a/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.reduce.length.js
+++ b/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.reduce.length.js
@@ -23,7 +23,7 @@
 var bench = require( '@stdlib/bench' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var caddf = require( '@stdlib/math/base/ops/caddf' );
-var isComplexLike = require('@stdlib/assert/is-complex-like');
+var isComplexLike = require( '@stdlib/assert/is-complex-like' );
 var Complex64 = require( '@stdlib/complex/float32/ctor' );
 var pkg = require( './../package.json' ).name;
 var Complex64Array = require( './../lib' );
diff --git a/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.values.length.js b/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.values.length.js
index 384b6bfdff28..30620c7ef9e0 100644
--- a/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.values.length.js
+++ b/lib/node_modules/@stdlib/array/complex64/benchmark/benchmark.values.length.js
@@ -23,7 +23,7 @@
 var bench = require( '@stdlib/bench' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var Complex64 = require( '@stdlib/complex/float32/ctor' );
-var isIteratorLike = require('@stdlib/assert/is-iterator-like');
+var isIteratorLike = require( '@stdlib/assert/is-iterator-like' );
 var pkg = require( './../package.json' ).name;
 var Complex64Array = require( './../lib' );
 
diff --git a/lib/node_modules/@stdlib/array/complex64/test/test.every.js b/lib/node_modules/@stdlib/array/complex64/test/test.every.js
index 5c0a497d695e..146306cb5d64 100644
--- a/lib/node_modules/@stdlib/array/complex64/test/test.every.js
+++ b/lib/node_modules/@stdlib/array/complex64/test/test.every.js
@@ -164,7 +164,7 @@ tape( 'the method supports providing an execution context', function test( t ) {
 	bool = arr.every( predicate, ctx );
 
 	t.strictEqual( bool, true, 'returns expected value' );
-	t.strictEqual( ctx.count, 3, 'returns expected value');
+	t.strictEqual( ctx.count, 3, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/array/complex64/test/test.find.js b/lib/node_modules/@stdlib/array/complex64/test/test.find.js
index de556b2fe0a8..463b096751d8 100644
--- a/lib/node_modules/@stdlib/array/complex64/test/test.find.js
+++ b/lib/node_modules/@stdlib/array/complex64/test/test.find.js
@@ -164,9 +164,9 @@ tape( 'the method supports providing an execution context', function test( t ) {
 	arr = new Complex64Array( [ 1.0, -1.0, 2.0, -2.0, 3.0, 3.0 ] );
 	z = arr.find( predicate, ctx );
 
-	t.strictEqual( realf( z ), 3, 'returns expected value');
-	t.strictEqual( imagf( z ), 3, 'returns expected value');
-	t.strictEqual( ctx.count, 3, 'returns expected value');
+	t.strictEqual( realf( z ), 3, 'returns expected value' );
+	t.strictEqual( imagf( z ), 3, 'returns expected value' );
+	t.strictEqual( ctx.count, 3, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/array/complex64/test/test.find_last.js b/lib/node_modules/@stdlib/array/complex64/test/test.find_last.js
index ba277a7e95b2..4d5a147dcea9 100644
--- a/lib/node_modules/@stdlib/array/complex64/test/test.find_last.js
+++ b/lib/node_modules/@stdlib/array/complex64/test/test.find_last.js
@@ -164,9 +164,9 @@ tape( 'the method supports providing an execution context', function test( t ) {
 	arr = new Complex64Array( [ 1.0, -1.0, 2.0, -2.0, 3.0, 3.0 ] );
 	z = arr.findLast( predicate, ctx );
 
-	t.strictEqual( realf( z ), 3, 'returns expected value');
-	t.strictEqual( imagf( z ), 3, 'returns expected value');
-	t.strictEqual( ctx.count, 1, 'returns expected value');
+	t.strictEqual( realf( z ), 3, 'returns expected value' );
+	t.strictEqual( imagf( z ), 3, 'returns expected value' );
+	t.strictEqual( ctx.count, 1, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/array/complex64/test/test.for_each.js b/lib/node_modules/@stdlib/array/complex64/test/test.for_each.js
index 68316f2b30da..ab30241b6245 100644
--- a/lib/node_modules/@stdlib/array/complex64/test/test.for_each.js
+++ b/lib/node_modules/@stdlib/array/complex64/test/test.for_each.js
@@ -24,7 +24,7 @@ var tape = require( 'tape' );
 var hasOwnProp = require( '@stdlib/assert/has-own-property' );
 var isFunction = require( '@stdlib/assert/is-function' );
 var reinterpret64 = require( '@stdlib/strided/base/reinterpret-complex64' );
-var isComplex64 = require('@stdlib/assert/is-complex64');
+var isComplex64 = require( '@stdlib/assert/is-complex64' );
 var Complex64Array = require( './../lib' );
 
 
diff --git a/lib/node_modules/@stdlib/array/complex64/test/test.map.js b/lib/node_modules/@stdlib/array/complex64/test/test.map.js
index 90822e49d420..c5ca13a5d924 100644
--- a/lib/node_modules/@stdlib/array/complex64/test/test.map.js
+++ b/lib/node_modules/@stdlib/array/complex64/test/test.map.js
@@ -28,7 +28,7 @@ var reinterpret64 = require( '@stdlib/strided/base/reinterpret-complex64' );
 var instanceOf = require( '@stdlib/assert/instance-of' );
 var realf = require( '@stdlib/complex/realf' );
 var imagf = require( '@stdlib/complex/imagf' );
-var Complex64 = require('@stdlib/complex/float32/ctor');
+var Complex64 = require( '@stdlib/complex/float32/ctor' );
 var Float32Array = require( '@stdlib/array/float32' );
 var Complex64Array = require( './../lib' );
 
diff --git a/lib/node_modules/@stdlib/array/complex64/test/test.reduce.js b/lib/node_modules/@stdlib/array/complex64/test/test.reduce.js
index 8bf0be2de605..151282e8199c 100644
--- a/lib/node_modules/@stdlib/array/complex64/test/test.reduce.js
+++ b/lib/node_modules/@stdlib/array/complex64/test/test.reduce.js
@@ -27,7 +27,7 @@ var caddf = require( '@stdlib/math/base/ops/caddf' );
 var instanceOf = require( '@stdlib/assert/instance-of' );
 var realf = require( '@stdlib/complex/realf' );
 var imagf = require( '@stdlib/complex/imagf' );
-var Complex64 = require('@stdlib/complex/float32/ctor');
+var Complex64 = require( '@stdlib/complex/float32/ctor' );
 var Complex64Array = require( './../lib' );
 
 
diff --git a/lib/node_modules/@stdlib/array/complex64/test/test.some.js b/lib/node_modules/@stdlib/array/complex64/test/test.some.js
index 3a6327b4ef05..7c9cfad06f4e 100644
--- a/lib/node_modules/@stdlib/array/complex64/test/test.some.js
+++ b/lib/node_modules/@stdlib/array/complex64/test/test.some.js
@@ -164,7 +164,7 @@ tape( 'the method supports providing an execution context', function test( t ) {
 	bool = arr.some( predicate, ctx );
 
 	t.strictEqual( bool, true, 'returns expected value' );
-	t.strictEqual( ctx.count, 3, 'returns expected value');
+	t.strictEqual( ctx.count, 3, 'returns expected value' );
 
 	t.end();
 
@@ -186,7 +186,7 @@ tape( 'the method stops executing upon encountering the first element which pass
 	bool = arr.some( predicate, ctx );
 
 	t.strictEqual( bool, true, 'returns expected value' );
-	t.strictEqual( ctx.count, 1, 'returns expected value');
+	t.strictEqual( ctx.count, 1, 'returns expected value' );
 
 	t.end();
 
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-finite/examples/index.js b/lib/node_modules/@stdlib/assert/is-nonpositive-finite/examples/index.js
index bdf0c8ce2b19..d8e718f00567 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-finite/examples/index.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-finite/examples/index.js
@@ -20,13 +20,13 @@
 
 'use strict';
 
-var NINF = require('@stdlib/constants/float64/ninf');
+var NINF = require( '@stdlib/constants/float64/ninf' );
 var isNonPositiveFinite = require( './../lib' );
 
-console.log( isNonPositiveFinite( -2 ));
+console.log( isNonPositiveFinite( -2 ) );
 // => true
 
-console.log( isNonPositiveFinite( -2.99 ));
+console.log( isNonPositiveFinite( -2.99 ) );
 // => true
 
 console.log( isNonPositiveFinite( NINF ) );
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-finite/lib/main.js b/lib/node_modules/@stdlib/assert/is-nonpositive-finite/lib/main.js
index 6a756700627c..df8ab7901894 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-finite/lib/main.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-finite/lib/main.js
@@ -21,7 +21,7 @@
 
 // MODULES //
 
-var NINF = require('@stdlib/constants/float64/ninf');
+var NINF = require( '@stdlib/constants/float64/ninf' );
 var isPrimitive = require( './primitive.js' );
 var isObject = require( './object.js' );
 
diff --git a/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.main.js b/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.main.js
index 08544f3fd113..523410e2de33 100644
--- a/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.main.js
+++ b/lib/node_modules/@stdlib/assert/is-nonpositive-finite/test/test.main.js
@@ -21,7 +21,7 @@
 // MODULES //
 
 var tape = require( 'tape' );
-var NINF = require('@stdlib/constants/float64/ninf');
+var NINF = require( '@stdlib/constants/float64/ninf' );
 var Number = require( '@stdlib/number/ctor' );
 var isNonPositiveFinite = require( './../lib/main.js' );
 
diff --git a/lib/node_modules/@stdlib/assert/is-well-formed-string/lib/object.js b/lib/node_modules/@stdlib/assert/is-well-formed-string/lib/object.js
index 34b1999cf095..3c4f5e78df90 100644
--- a/lib/node_modules/@stdlib/assert/is-well-formed-string/lib/object.js
+++ b/lib/node_modules/@stdlib/assert/is-well-formed-string/lib/object.js
@@ -20,8 +20,8 @@
 
 // MODULES //
 
-var isString = require('@stdlib/assert/is-string');
-var isWellFormed = require('./iswellformed.js');
+var isString = require( '@stdlib/assert/is-string' );
+var isWellFormed = require( './iswellformed.js' );
 
 
 // MAIN //
diff --git a/lib/node_modules/@stdlib/assert/is-well-formed-string/lib/primitive.js b/lib/node_modules/@stdlib/assert/is-well-formed-string/lib/primitive.js
index da4e82c9aa16..819c61bda55c 100644
--- a/lib/node_modules/@stdlib/assert/is-well-formed-string/lib/primitive.js
+++ b/lib/node_modules/@stdlib/assert/is-well-formed-string/lib/primitive.js
@@ -20,7 +20,7 @@
 
 // MODULES //
 
-var isWellFormed = require('./iswellformed.js');
+var isWellFormed = require( './iswellformed.js' );
 
 
 // MAIN //
diff --git a/lib/node_modules/@stdlib/assert/napi/equal-typedarray-types/lib/native.js b/lib/node_modules/@stdlib/assert/napi/equal-typedarray-types/lib/native.js
index 61b2eb776c79..e206abe2a463 100644
--- a/lib/node_modules/@stdlib/assert/napi/equal-typedarray-types/lib/native.js
+++ b/lib/node_modules/@stdlib/assert/napi/equal-typedarray-types/lib/native.js
@@ -36,7 +36,7 @@ var addon = require( './../src/addon.node' );
 * var typedarray = require( '@stdlib/array/typed' );
 *
 * var x = typedarray( 10, 'float64' );
-* var y = typedarray( x.length, 'float64');
+* var y = typedarray( x.length, 'float64' );
 *
 * wrapper( x, y );
 */
diff --git a/lib/node_modules/@stdlib/blas/base/sdsdot/lib/sdsdot.js b/lib/node_modules/@stdlib/blas/base/sdsdot/lib/sdsdot.js
index 97ad4722dcd2..21180af85a9f 100644
--- a/lib/node_modules/@stdlib/blas/base/sdsdot/lib/sdsdot.js
+++ b/lib/node_modules/@stdlib/blas/base/sdsdot/lib/sdsdot.js
@@ -21,8 +21,8 @@
 // MODULES //
 
 var float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' );
-var stride2offset = require('@stdlib/strided/base/stride2offset');
-var ndarray = require('./ndarray.js');
+var stride2offset = require( '@stdlib/strided/base/stride2offset' );
+var ndarray = require( './ndarray.js' );
 
 
 // MAIN //
diff --git a/lib/node_modules/@stdlib/blas/base/srot/lib/srot.js b/lib/node_modules/@stdlib/blas/base/srot/lib/srot.js
index a338c0dda778..75c57aedb804 100644
--- a/lib/node_modules/@stdlib/blas/base/srot/lib/srot.js
+++ b/lib/node_modules/@stdlib/blas/base/srot/lib/srot.js
@@ -21,7 +21,7 @@
 // MODULES //
 
 var stride2offset = require( '@stdlib/strided/base/stride2offset' );
-var ndarray = require('./ndarray.js');
+var ndarray = require( './ndarray.js' );
 
 
 // MAIN //
diff --git a/lib/node_modules/@stdlib/blas/base/srotg/test/test.assign.js b/lib/node_modules/@stdlib/blas/base/srotg/test/test.assign.js
index 635d12a3e2dc..ed47ce929949 100644
--- a/lib/node_modules/@stdlib/blas/base/srotg/test/test.assign.js
+++ b/lib/node_modules/@stdlib/blas/base/srotg/test/test.assign.js
@@ -107,7 +107,7 @@ tape( 'the function supports providing a positive stride', function test(t) {
 
 	actual = srotg( 0.3, 0.4, out, 2, 0 );
 	t.strictEqual( actual, out, 'returns expected value' );
-	t.deepEqual( actual, expected, 'returns expected value');
+	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
 
@@ -121,7 +121,7 @@ tape( 'the function supports providing a negative stride', function test(t) {
 
 	actual = srotg( 0.3, 0.4, out, -2, 6 );
 	t.strictEqual( actual, out, 'returns expected value' );
-	t.deepEqual( actual, expected, 'returns expected value');
+	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
 
@@ -135,7 +135,7 @@ tape( 'the function supports providing an offset', function test(t) {
 
 	actual = srotg( 0.3, 0.4, out, 1, 1 );
 	t.strictEqual( actual, out, 'returns expected value' );
-	t.deepEqual( actual, expected, 'returns expected value');
+	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
 
@@ -149,6 +149,6 @@ tape( 'the function supports providing both a stride and offset', function test(
 
 	actual = srotg( 0.3, 0.4, out, 2, 2 );
 	t.strictEqual( actual, out, 'returns expected value' );
-	t.deepEqual( actual, expected, 'returns expected value');
+	t.deepEqual( actual, expected, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/base/srotm/lib/srotm.js b/lib/node_modules/@stdlib/blas/base/srotm/lib/srotm.js
index aa95b01cd67c..c4e028821d33 100644
--- a/lib/node_modules/@stdlib/blas/base/srotm/lib/srotm.js
+++ b/lib/node_modules/@stdlib/blas/base/srotm/lib/srotm.js
@@ -21,7 +21,7 @@
 // MODULES //
 
 var stride2offset = require( '@stdlib/strided/base/stride2offset' );
-var ndarray = require('./ndarray.js');
+var ndarray = require( './ndarray.js' );
 
 
 // MAIN //
diff --git a/lib/node_modules/@stdlib/blas/base/sswap/lib/sswap.js b/lib/node_modules/@stdlib/blas/base/sswap/lib/sswap.js
index f5ff4e322269..afac7b3d1535 100644
--- a/lib/node_modules/@stdlib/blas/base/sswap/lib/sswap.js
+++ b/lib/node_modules/@stdlib/blas/base/sswap/lib/sswap.js
@@ -20,8 +20,8 @@
 
 // MODULES //
 
-var stride2offset = require('@stdlib/strided/base/stride2offset');
-var ndarray = require('./ndarray.js');
+var stride2offset = require( '@stdlib/strided/base/stride2offset' );
+var ndarray = require( './ndarray.js' );
 
 
 // MAIN //
diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/examples/index.js b/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/examples/index.js
index fcfe1f21cddd..52f20ff63955 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/examples/index.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/examples/index.js
@@ -18,10 +18,10 @@
 
 'use strict';
 
-var discreteUniform = require('@stdlib/random/base/discrete-uniform');
-var bernoulli = require('@stdlib/random/base/bernoulli');
-var filledarrayBy = require('@stdlib/array/filled-by');
-var dnansumkbn2 = require('./../lib');
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var dnansumkbn2 = require( './../lib' );
 
 function clbk() {
 	if ( bernoulli( 0.7 ) > 0 ) {
diff --git a/lib/node_modules/@stdlib/complex/base/parse/lib/main.js b/lib/node_modules/@stdlib/complex/base/parse/lib/main.js
index c364db5353a4..4cfa330cbc21 100644
--- a/lib/node_modules/@stdlib/complex/base/parse/lib/main.js
+++ b/lib/node_modules/@stdlib/complex/base/parse/lib/main.js
@@ -65,13 +65,13 @@ function parse( str ) {
 	str = replace( str, ' ', '' );
 	for ( i = 0; i < str.length; i++ ) {
 		if ( (str[i] === '+' || str[i] === '-') && i !== 0 && str[i - 1] !== 'e' ) {
-			parts.push(currentToken);
+			parts.push( currentToken );
 			currentToken = '';
 		} else if ( i === str.length - 1 ) {
-			currentToken += str[i];
-			parts.push(currentToken);
+			currentToken += str[ i ];
+			parts.push( currentToken );
 		}
-		currentToken += str[i];
+		currentToken += str[ i ];
 	}
 
 	for ( i = 0; i < parts.length; i++ ) { // Check for invalid parts...
diff --git a/lib/node_modules/@stdlib/complex/float32/parse/test/test.js b/lib/node_modules/@stdlib/complex/float32/parse/test/test.js
index f672ee2dcf6e..a9ea3614eb6e 100644
--- a/lib/node_modules/@stdlib/complex/float32/parse/test/test.js
+++ b/lib/node_modules/@stdlib/complex/float32/parse/test/test.js
@@ -59,7 +59,7 @@ tape( 'the function will parse a string representation of a complex number', fun
 	w = parseComplex64( '5 + 12i' );
 
 	t.ok( isComplex64( w ), 'is an instance' );
-	t.ok( isSameComplex64( w, z ), 'has expected property value');
+	t.ok( isSameComplex64( w, z ), 'has expected property value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/complex/float64/parse/test/test.js b/lib/node_modules/@stdlib/complex/float64/parse/test/test.js
index c82c486c15e1..c67552dac3e1 100644
--- a/lib/node_modules/@stdlib/complex/float64/parse/test/test.js
+++ b/lib/node_modules/@stdlib/complex/float64/parse/test/test.js
@@ -59,7 +59,7 @@ tape( 'the function will parse a string representation of a complex number', fun
 	w = parseComplex128( '5 + 12i' );
 
 	t.ok( isComplex128( w ), 'is an instance' );
-	t.ok( isSameComplex128( w, z ), 'has expected property value');
+	t.ok( isSameComplex128( w, z ), 'has expected property value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/fs/append-file/test/test.cli.js b/lib/node_modules/@stdlib/fs/append-file/test/test.cli.js
index ccf695f9d521..f6fe27839c94 100644
--- a/lib/node_modules/@stdlib/fs/append-file/test/test.cli.js
+++ b/lib/node_modules/@stdlib/fs/append-file/test/test.cli.js
@@ -188,7 +188,7 @@ tape( 'the command-line interface appends data received from `stdin` to a file',
 			t.strictEqual( stderr.toString(), '', 'does not print to `stderr`' );
 		}
 		actual = readFileSync( FILE, 'utf8' );
-		t.strictEqual(actual, expected, 'file contains expected contents');
+		t.strictEqual( actual, expected, 'file contains expected contents' );
 
 		restore();
 		t.end();
diff --git a/lib/node_modules/@stdlib/iter/do-while-each/examples/index.js b/lib/node_modules/@stdlib/iter/do-while-each/examples/index.js
index 04793191cece..a2eb563c4a78 100644
--- a/lib/node_modules/@stdlib/iter/do-while-each/examples/index.js
+++ b/lib/node_modules/@stdlib/iter/do-while-each/examples/index.js
@@ -43,10 +43,10 @@ var it = iterDoWhileEach( rand, predicate, assert );
 
 // Iterate over the iterator:
 var r;
-while (true) {
+while ( true ) {
 	r = it.next();
-	if (r.done) {
+	if ( r.done ) {
 		break;
 	}
-	console.log(r.value);
+	console.log( r.value );
 }
diff --git a/lib/node_modules/@stdlib/math/base/special/acosd/lib/main.js b/lib/node_modules/@stdlib/math/base/special/acosd/lib/main.js
index 8e3bb72c7ac2..5db916348d9f 100644
--- a/lib/node_modules/@stdlib/math/base/special/acosd/lib/main.js
+++ b/lib/node_modules/@stdlib/math/base/special/acosd/lib/main.js
@@ -20,8 +20,8 @@
 
 // MODULES //
 
-var rad2deg = require('@stdlib/math/base/special/rad2deg');
-var acos = require('@stdlib/math/base/special/acos');
+var rad2deg = require( '@stdlib/math/base/special/rad2deg' );
+var acos = require( '@stdlib/math/base/special/acos' );
 
 
 // MAIN //
diff --git a/lib/node_modules/@stdlib/math/base/special/asec/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/math/base/special/asec/benchmark/benchmark.native.js
index c77f5156d14b..4752c0beef1e 100644
--- a/lib/node_modules/@stdlib/math/base/special/asec/benchmark/benchmark.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/asec/benchmark/benchmark.native.js
@@ -20,25 +20,25 @@
 
 // MODULES //
 
-var resolve = require('path').resolve;
-var bench = require('@stdlib/bench');
-var randu = require('@stdlib/random/base/randu');
-var isnan = require('@stdlib/math/base/assert/is-nan');
-var tryRequire = require('@stdlib/utils/try-require');
-var pkg = require('./../package.json').name;
+var resolve = require( 'path' ).resolve;
+var bench = require( '@stdlib/bench' );
+var randu = require( '@stdlib/random/base/randu' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var tryRequire = require( '@stdlib/utils/try-require' );
+var pkg = require( './../package.json' ).name;
 
 
 // VARIABLES //
 
-var asec = tryRequire(resolve(__dirname, './../lib/native.js'));
+var asec = tryRequire( resolve( __dirname, './../lib/native.js' ) );
 var opts = {
-	'skip': (asec instanceof Error)
+	'skip': ( asec instanceof Error )
 };
 
 
 // MAIN //
 
-bench(pkg + '::native', opts, function benchmark(b) {
+bench( pkg + '::native', opts, function benchmark( b ) {
 	var y;
 	var i;
 	var x;
diff --git a/lib/node_modules/@stdlib/math/base/special/asecd/test/test.js b/lib/node_modules/@stdlib/math/base/special/asecd/test/test.js
index 67e207f3c8dc..a0911a598ceb 100644
--- a/lib/node_modules/@stdlib/math/base/special/asecd/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/asecd/test/test.js
@@ -22,9 +22,9 @@
 
 var tape = require( 'tape' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
-var abs = require('@stdlib/math/base/special/abs');
+var abs = require( '@stdlib/math/base/special/abs' );
 var EPS = require( '@stdlib/constants/float64/eps' );
-var randu = require('@stdlib/random/base/randu');
+var randu = require( '@stdlib/random/base/randu' );
 var asecd = require( './../lib' );
 
 
diff --git a/lib/node_modules/@stdlib/math/base/special/asecd/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/asecd/test/test.native.js
index c3700a0052a5..1e2d5122846a 100644
--- a/lib/node_modules/@stdlib/math/base/special/asecd/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/asecd/test/test.native.js
@@ -23,9 +23,9 @@
 var resolve = require( 'path' ).resolve;
 var tape = require( 'tape' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
-var abs = require('@stdlib/math/base/special/abs');
+var abs = require( '@stdlib/math/base/special/abs' );
 var EPS = require( '@stdlib/constants/float64/eps' );
-var randu = require('@stdlib/random/base/randu');
+var randu = require( '@stdlib/random/base/randu' );
 var tryRequire = require( '@stdlib/utils/try-require' );
 
 
diff --git a/lib/node_modules/@stdlib/math/base/special/asecf/test/test.js b/lib/node_modules/@stdlib/math/base/special/asecf/test/test.js
index 511d2bac357d..33b911ad9f0b 100644
--- a/lib/node_modules/@stdlib/math/base/special/asecf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/asecf/test/test.js
@@ -24,7 +24,7 @@ var tape = require( 'tape' );
 var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var EPS = require( '@stdlib/constants/float32/eps' );
 var abs = require( '@stdlib/math/base/special/abs' );
-var float64ToFloat32 = require('@stdlib/number/float64/base/to-float32');
+var float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' );
 var asecf = require( './../lib' );
 
 
diff --git a/lib/node_modules/@stdlib/math/base/special/asecf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/asecf/test/test.native.js
index 76b314be2f6b..fdf47a656bc4 100644
--- a/lib/node_modules/@stdlib/math/base/special/asecf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/asecf/test/test.native.js
@@ -25,7 +25,7 @@ var tape = require( 'tape' );
 var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var EPS = require( '@stdlib/constants/float32/eps' );
 var abs = require( '@stdlib/math/base/special/abs' );
-var float64ToFloat32 = require('@stdlib/number/float64/base/to-float32');
+var float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' );
 var tryRequire = require( '@stdlib/utils/try-require' );
 
 
diff --git a/lib/node_modules/@stdlib/math/base/special/asindf/test/test.js b/lib/node_modules/@stdlib/math/base/special/asindf/test/test.js
index f668dc9d0102..d4ed4003e024 100644
--- a/lib/node_modules/@stdlib/math/base/special/asindf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/asindf/test/test.js
@@ -25,7 +25,7 @@ var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var uniform = require( '@stdlib/random/base/uniform' );
 var abs = require( '@stdlib/math/base/special/abs' );
 var EPS = require( '@stdlib/constants/float32/eps' );
-var float64ToFloat32 = require('@stdlib/number/float64/base/to-float32');
+var float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' );
 var asindf = require( './../lib' );
 
 
diff --git a/lib/node_modules/@stdlib/math/base/special/asindf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/asindf/test/test.native.js
index 12b9c6d5daad..b92903c9ddaf 100644
--- a/lib/node_modules/@stdlib/math/base/special/asindf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/asindf/test/test.native.js
@@ -26,7 +26,7 @@ var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var uniform = require( '@stdlib/random/base/uniform' );
 var abs = require( '@stdlib/math/base/special/abs' );
 var EPS = require( '@stdlib/constants/float32/eps' );
-var float64ToFloat32 = require('@stdlib/number/float64/base/to-float32');
+var float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' );
 var tryRequire = require( '@stdlib/utils/try-require' );
 
 
diff --git a/lib/node_modules/@stdlib/math/base/special/bessely1/test/test.js b/lib/node_modules/@stdlib/math/base/special/bessely1/test/test.js
index 5f948a586a2e..8ccb327be333 100644
--- a/lib/node_modules/@stdlib/math/base/special/bessely1/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/bessely1/test/test.js
@@ -197,7 +197,7 @@ tape( 'The Bessel function of the second kind of one order (Y_1) (subnormal valu
 	x = subnormal.x;
 	for ( i = 0; i < x.length; i++ ) {
 		y = y1( x[i] );
-		t.equal( y, NINF, 'returns -Infinity');
+		t.equal( y, NINF, 'returns -Infinity' );
 	}
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/expm1rel/test/test.js b/lib/node_modules/@stdlib/math/base/special/expm1rel/test/test.js
index 382e6c4120b3..5005126114b1 100644
--- a/lib/node_modules/@stdlib/math/base/special/expm1rel/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/expm1rel/test/test.js
@@ -148,23 +148,23 @@ tape( 'the function accurately computes `(exp(x)-1)/x` for very small `x`', func
 
 tape( 'the function returns `1.0` near `0.0`', function test( t ) {
 	t.equal( expm1rel( 0 ), 1.0, 'equals 1.0' );
-	t.equal( expm1rel( EPS ), 1.0, 'equals 1.0');
-	t.equal( expm1rel( -EPS ), 1.0, 'equals 1.0');
+	t.equal( expm1rel( EPS ), 1.0, 'equals 1.0' );
+	t.equal( expm1rel( -EPS ), 1.0, 'equals 1.0' );
 	t.end();
 });
 
-tape( 'the function returns `NaN` when evaulated at `NaN`', function test( t ) {
+tape( 'the function returns `NaN` when evaluated at `NaN`', function test( t ) {
 	var y = expm1rel( NaN );
-	t.equal( isnan( y ), true, 'equals NaN');
+	t.equal( isnan( y ), true, 'equals NaN' );
 	t.end();
 });
 
 tape('the function returns `+infinity` at `+infinity`', function test( t ) {
-	t.equal( expm1rel( PINF ), PINF, 'equals +infinity');
+	t.equal( expm1rel( PINF ), PINF, 'equals +infinity' );
 	t.end();
 });
 
 tape('the function returns `0` at `-infinity`', function test( t ) {
-	t.equal( expm1rel( NINF ), 0.0, 'equals 0');
+	t.equal( expm1rel( NINF ), 0.0, 'equals 0' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/expm1rel/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/expm1rel/test/test.native.js
index b4fc66f96195..8f8efec03d46 100644
--- a/lib/node_modules/@stdlib/math/base/special/expm1rel/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/expm1rel/test/test.native.js
@@ -157,23 +157,23 @@ tape( 'the function accurately computes `(exp(x)-1)/x` for very small `x`', opts
 
 tape( 'the function returns `1.0` near `0.0`', opts, function test( t ) {
 	t.equal( expm1rel( 0 ), 1.0, 'equals 1.0' );
-	t.equal( expm1rel( EPS ), 1.0, 'equals 1.0');
-	t.equal( expm1rel( -EPS ), 1.0, 'equals 1.0');
+	t.equal( expm1rel( EPS ), 1.0, 'equals 1.0' );
+	t.equal( expm1rel( -EPS ), 1.0, 'equals 1.0' );
 	t.end();
 });
 
-tape( 'the function returns `NaN` when evaulated at `NaN`', opts, function test( t ) {
+tape( 'the function returns `NaN` when evaluated at `NaN`', opts, function test( t ) {
 	var y = expm1rel( NaN );
-	t.equal( isnan( y ), true, 'equals NaN');
+	t.equal( isnan( y ), true, 'equals NaN' );
 	t.end();
 });
 
 tape('the function returns `+infinity` at `+infinity`', opts, function test( t ) {
-	t.equal( expm1rel( PINF ), PINF, 'equals +infinity');
+	t.equal( expm1rel( PINF ), PINF, 'equals +infinity' );
 	t.end();
 });
 
 tape('the function returns `0` at `-infinity`', opts, function test( t ) {
-	t.equal( expm1rel( NINF ), 0.0, 'equals 0');
+	t.equal( expm1rel( NINF ), 0.0, 'equals 0' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/special/fast/pow-int/test/test.js b/lib/node_modules/@stdlib/math/base/special/fast/pow-int/test/test.js
index 51dbc0a0513f..aadf9f745cc9 100644
--- a/lib/node_modules/@stdlib/math/base/special/fast/pow-int/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/fast/pow-int/test/test.js
@@ -212,7 +212,7 @@ tape( '`+-0` raised to a positive even integer is `0`', function test( t ) {
 		v = pow( +0.0, y );
 		t.strictEqual( isPositiveZero( v ), true, 'pow(0,'+y+') returns +0' );
 
-		v = pow( -0.0, y);
+		v = pow( -0.0, y );
 		t.strictEqual( isPositiveZero( v ), true, 'pow(-0,'+y+') returns +0' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/base/special/fast/pow-int/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/fast/pow-int/test/test.native.js
index 96602893adf3..1031640f7fbb 100644
--- a/lib/node_modules/@stdlib/math/base/special/fast/pow-int/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/fast/pow-int/test/test.native.js
@@ -221,7 +221,7 @@ tape( '`+-0` raised to a positive even integer is `0`', opts, function test( t )
 		v = pow( +0.0, y );
 		t.strictEqual( isPositiveZero( v ), true, 'pow(0,'+y+') returns +0' );
 
-		v = pow( -0.0, y);
+		v = pow( -0.0, y );
 		t.strictEqual( isPositiveZero( v ), true, 'pow(-0,'+y+') returns +0' );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/base/special/gamma-delta-ratio/lib/gamma_delta_ratio_lanczos.js b/lib/node_modules/@stdlib/math/base/special/gamma-delta-ratio/lib/gamma_delta_ratio_lanczos.js
index 052a8894b06a..9800f78778ba 100644
--- a/lib/node_modules/@stdlib/math/base/special/gamma-delta-ratio/lib/gamma_delta_ratio_lanczos.js
+++ b/lib/node_modules/@stdlib/math/base/special/gamma-delta-ratio/lib/gamma_delta_ratio_lanczos.js
@@ -97,7 +97,7 @@ function gammaDeltaRatioLanczos( z, delta ) {
 		}
 	} else {
 		if ( abs(delta) < 10.0 ) {
-			result = exp( ( 0.5-z ) * log1p( delta/zgh ));
+			result = exp( ( 0.5-z ) * log1p( delta/zgh ) );
 		} else {
 			result = pow( zgh / (zgh+delta), z-0.5 );
 		}
diff --git a/lib/node_modules/@stdlib/math/base/special/gammainc/lib/main.js b/lib/node_modules/@stdlib/math/base/special/gammainc/lib/main.js
index 46a5a582600a..1916cd504e3f 100644
--- a/lib/node_modules/@stdlib/math/base/special/gammainc/lib/main.js
+++ b/lib/node_modules/@stdlib/math/base/special/gammainc/lib/main.js
@@ -125,7 +125,7 @@ function gammainc( x, a, regularized, upper ) {
 					// This is method 2 below, done in logs, we're really outside the range of this method, but since the result is almost certainly infinite, we should probably be OK:
 					result = ( a * ln( x ) ) - x;
 					initValue = 0.0;
-					result += ln( lowerGammaSeries( a, x, initValue ) / a);
+					result += ln( lowerGammaSeries( a, x, initValue ) / a );
 				}
 			}
 			else {
@@ -223,7 +223,7 @@ function gammainc( x, a, regularized, upper ) {
 			initValue = 0.0;
 			optimisedInvert = false;
 			if ( invert ) {
-				initValue = ( normalized ) ? 1.0 : gamma(a);
+				initValue = ( normalized ) ? 1.0 : gamma( a );
 				if (
 					normalized ||
 					result >= 1.0 ||
diff --git a/lib/node_modules/@stdlib/math/base/special/kernel-betaincinv/lib/temme2.js b/lib/node_modules/@stdlib/math/base/special/kernel-betaincinv/lib/temme2.js
index a6c44b910578..cac92a7c38d7 100644
--- a/lib/node_modules/@stdlib/math/base/special/kernel-betaincinv/lib/temme2.js
+++ b/lib/node_modules/@stdlib/math/base/special/kernel-betaincinv/lib/temme2.js
@@ -42,7 +42,7 @@ var ln = require( '@stdlib/math/base/special/ln' );
 var sqrt = require( '@stdlib/math/base/special/sqrt' );
 var sin = require( '@stdlib/math/base/special/sin' );
 var cos = require( '@stdlib/math/base/special/cos' );
-var temmeRootFinder = require( './root_finder.js');
+var temmeRootFinder = require( './root_finder.js' );
 var newtonRaphsonIterate = require( './newton_raphson.js' );
 var polyval1 = require( './polyval_co1.js' );
 var polyval2 = require( './polyval_co2.js' );
diff --git a/lib/node_modules/@stdlib/math/base/special/log1mexp/test/test.js b/lib/node_modules/@stdlib/math/base/special/log1mexp/test/test.js
index 634eec1e6460..2bee66e8432d 100644
--- a/lib/node_modules/@stdlib/math/base/special/log1mexp/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/log1mexp/test/test.js
@@ -58,10 +58,10 @@ tape( 'if provided `+-0`, the function returns -infinity', function test( t ) {
 	var v;
 
 	v = log1mexp( 0.0 );
-	t.strictEqual(v, NINF, 'returns -infinity');
+	t.strictEqual( v, NINF, 'returns -infinity' );
 
 	v = log1mexp( -0.0 );
-	t.strictEqual(v, NINF, 'returns -infinity');
+	t.strictEqual( v, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -75,7 +75,7 @@ tape( 'the function computes the natural logarithm of `1-exp(-|x|)` (`0 < |x| <=
 	for ( i = 0; i < 1e3; i++ ) {
 		v = randu() * LN2;
 		x = log1mexp( v );
-		y = ln( -expm1( -v ));
+		y = ln( -expm1( -v ) );
 		t.strictEqual( x, y, 'returns '+y+' when provided '+v );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/base/special/log1mexp/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/log1mexp/test/test.native.js
index 09b3c5022565..7b11196ccda0 100644
--- a/lib/node_modules/@stdlib/math/base/special/log1mexp/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/log1mexp/test/test.native.js
@@ -67,10 +67,10 @@ tape( 'if provided `+-0`, the function returns -infinity', opts, function test(
 	var v;
 
 	v = log1mexp( 0.0 );
-	t.strictEqual(v, NINF, 'returns -infinity');
+	t.strictEqual( v, NINF, 'returns -infinity' );
 
 	v = log1mexp( -0.0 );
-	t.strictEqual(v, NINF, 'returns -infinity');
+	t.strictEqual( v, NINF, 'returns -infinity' );
 
 	t.end();
 });
@@ -84,7 +84,7 @@ tape( 'the function computes the natural logarithm of `1-exp(-|x|)` (`0 < |x| <=
 	for ( i = 0; i < 1e3; i++ ) {
 		v = randu() * LN2;
 		x = log1mexp( v );
-		y = ln( -expm1( -v ));
+		y = ln( -expm1( -v ) );
 		t.strictEqual( x, y, 'returns '+y+' when provided '+v );
 	}
 	t.end();
diff --git a/lib/node_modules/@stdlib/math/base/special/nanmax/lib/main.js b/lib/node_modules/@stdlib/math/base/special/nanmax/lib/main.js
index a8738c2f5b37..89c49c6d3957 100644
--- a/lib/node_modules/@stdlib/math/base/special/nanmax/lib/main.js
+++ b/lib/node_modules/@stdlib/math/base/special/nanmax/lib/main.js
@@ -20,8 +20,8 @@
 
 // MODULES //
 
-var max = require( '@stdlib/math/base/special/max');
-var isnan = require( '@stdlib/math/base/assert/is-nan');
+var max = require( '@stdlib/math/base/special/max' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
 
 
 // MAIN //
@@ -42,7 +42,7 @@ var isnan = require( '@stdlib/math/base/assert/is-nan');
 * // returns 4.14
 *
 * @example
-* var v = nanmax( NaN, NaN);
+* var v = nanmax( NaN, NaN );
 * // returns NaN
 */
 function nanmax( x, y ) {
diff --git a/lib/node_modules/@stdlib/math/base/special/nanmin/lib/main.js b/lib/node_modules/@stdlib/math/base/special/nanmin/lib/main.js
index 1aa0cd48fc8d..42ec9c625ca1 100644
--- a/lib/node_modules/@stdlib/math/base/special/nanmin/lib/main.js
+++ b/lib/node_modules/@stdlib/math/base/special/nanmin/lib/main.js
@@ -20,8 +20,8 @@
 
 // MODULES //
 
-var min = require( '@stdlib/math/base/special/min');
-var isnan = require( '@stdlib/math/base/assert/is-nan');
+var min = require( '@stdlib/math/base/special/min' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
 
 
 // MAIN //
@@ -42,7 +42,7 @@ var isnan = require( '@stdlib/math/base/assert/is-nan');
 * // returns 4.14
 *
 * @example
-* var v = nanmin( NaN, NaN);
+* var v = nanmin( NaN, NaN );
 * // returns NaN
 */
 function nanmin( x, y ) {
diff --git a/lib/node_modules/@stdlib/math/base/special/rad2degf/test/test.js b/lib/node_modules/@stdlib/math/base/special/rad2degf/test/test.js
index ba1feb96a250..e70a3cd7f56a 100644
--- a/lib/node_modules/@stdlib/math/base/special/rad2degf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/special/rad2degf/test/test.js
@@ -27,7 +27,7 @@ var PI = require( '@stdlib/constants/float32/pi' );
 var EPS = require( '@stdlib/constants/float32/eps' );
 var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var abs = require( '@stdlib/math/base/special/abs' );
-var float64ToFloat32 = require('@stdlib/number/float64/base/to-float32');
+var float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' );
 var rad2degf = require( './../lib' );
 
 
diff --git a/lib/node_modules/@stdlib/math/base/special/rad2degf/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/rad2degf/test/test.native.js
index 281105204938..bfe43abc804f 100644
--- a/lib/node_modules/@stdlib/math/base/special/rad2degf/test/test.native.js
+++ b/lib/node_modules/@stdlib/math/base/special/rad2degf/test/test.native.js
@@ -28,7 +28,7 @@ var PI = require( '@stdlib/constants/float32/pi' );
 var EPS = require( '@stdlib/constants/float32/eps' );
 var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var abs = require( '@stdlib/math/base/special/abs' );
-var float64ToFloat32 = require('@stdlib/number/float64/base/to-float32');
+var float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' );
 var tryRequire = require( '@stdlib/utils/try-require' );
 
 
diff --git a/lib/node_modules/@stdlib/math/base/tools/hermitepoly/test/test.factory.js b/lib/node_modules/@stdlib/math/base/tools/hermitepoly/test/test.factory.js
index 3699b8dd3798..3960928c9160 100644
--- a/lib/node_modules/@stdlib/math/base/tools/hermitepoly/test/test.factory.js
+++ b/lib/node_modules/@stdlib/math/base/tools/hermitepoly/test/test.factory.js
@@ -501,7 +501,7 @@ tape( 'the function returns a function which returns `NaN` when `x` is `NaN`', f
 	hermitepoly = factory( 1 );
 
 	y = hermitepoly( NaN );
-	t.equal( isnan( y ), true, 'equals NaN');
+	t.equal( isnan( y ), true, 'equals NaN' );
 
 	t.end();
 });
@@ -513,7 +513,7 @@ tape( 'the function returns a function which returns `NaN` when `n` is a negativ
 	hermitepoly = factory( -1 );
 
 	y = hermitepoly( 0.0 );
-	t.equal( isnan( y ), true, 'equals NaN');
+	t.equal( isnan( y ), true, 'equals NaN' );
 
 	t.end();
 });
@@ -525,7 +525,7 @@ tape( 'the function returns a function which returns `NaN` when `n` is not an in
 	hermitepoly = factory( 1.01 );
 
 	y = hermitepoly( 0.0 );
-	t.equal( isnan( y ), true, 'equals NaN');
+	t.equal( isnan( y ), true, 'equals NaN' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/tools/hermitepoly/test/test.js b/lib/node_modules/@stdlib/math/base/tools/hermitepoly/test/test.js
index a64b577cd9cb..1d8c66570a13 100644
--- a/lib/node_modules/@stdlib/math/base/tools/hermitepoly/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/tools/hermitepoly/test/test.js
@@ -445,7 +445,7 @@ tape( 'the function returns `NaN` when `x` is `NaN`', function test( t ) {
 	var y;
 
 	y = hermitepoly( 0, NaN );
-	t.equal( isnan( y ), true, 'equals NaN');
+	t.equal( isnan( y ), true, 'equals NaN' );
 
 	t.end();
 });
@@ -454,7 +454,7 @@ tape( 'the function returns `NaN` when `n` is a negative integer`', function tes
 	var y;
 
 	y = hermitepoly( -1, 0.0 );
-	t.equal( isnan( y ), true, 'equals NaN');
+	t.equal( isnan( y ), true, 'equals NaN' );
 
 	t.end();
 });
@@ -463,7 +463,7 @@ tape( 'the function returns `NaN` when `n` is not an integer`', function test( t
 	var y;
 
 	y = hermitepoly( 1.01, 0.0 );
-	t.equal( isnan( y ), true, 'equals NaN');
+	t.equal( isnan( y ), true, 'equals NaN' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/tools/normhermitepoly/test/test.factory.js b/lib/node_modules/@stdlib/math/base/tools/normhermitepoly/test/test.factory.js
index 7f4ab0bb3392..4455a6db8cc2 100644
--- a/lib/node_modules/@stdlib/math/base/tools/normhermitepoly/test/test.factory.js
+++ b/lib/node_modules/@stdlib/math/base/tools/normhermitepoly/test/test.factory.js
@@ -501,7 +501,7 @@ tape( 'the function returns a function which returns `NaN` when `x` is `NaN`', f
 	f = factory( 1 );
 
 	y = f( NaN );
-	t.strictEqual( isnan( y ), true, 'returns expected value');
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -513,7 +513,7 @@ tape( 'the function returns a function which returns `NaN` when `n` is a negativ
 	f = factory( -1 );
 
 	y = f( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns expected value');
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -525,7 +525,7 @@ tape( 'the function returns a function which returns `NaN` when `n` is not an in
 	f = factory( 1.01 );
 
 	y = f( 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns expected value');
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/tools/normhermitepoly/test/test.js b/lib/node_modules/@stdlib/math/base/tools/normhermitepoly/test/test.js
index 00f064e25c2b..3bc7be68b8e9 100644
--- a/lib/node_modules/@stdlib/math/base/tools/normhermitepoly/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/tools/normhermitepoly/test/test.js
@@ -445,7 +445,7 @@ tape( 'the function returns `NaN` when `x` is `NaN`', function test( t ) {
 	var y;
 
 	y = normhermitepoly( 0, NaN );
-	t.strictEqual( isnan( y ), true, 'returns expected value');
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -454,7 +454,7 @@ tape( 'the function returns `NaN` when `n` is a negative integer`', function tes
 	var y;
 
 	y = normhermitepoly( -1, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns expected value');
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -463,7 +463,7 @@ tape( 'the function returns `NaN` when `n` is not an integer`', function test( t
 	var y;
 
 	y = normhermitepoly( 1.01, 0.0 );
-	t.strictEqual( isnan( y ), true, 'returns expected value');
+	t.strictEqual( isnan( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/tools/normhermitepolyf/lib/factory.js b/lib/node_modules/@stdlib/math/base/tools/normhermitepolyf/lib/factory.js
index b82fcf9810bd..e7c097deaa3b 100644
--- a/lib/node_modules/@stdlib/math/base/tools/normhermitepolyf/lib/factory.js
+++ b/lib/node_modules/@stdlib/math/base/tools/normhermitepolyf/lib/factory.js
@@ -73,7 +73,7 @@ function factory( n ) {
 			y3 = y2;
 			y2 = y1;
 		}
-		return float64ToFloat32( float64ToFloat32( x*y2 ) - y3);
+		return float64ToFloat32( float64ToFloat32( x*y2 ) - y3 );
 	}
 }
 
diff --git a/lib/node_modules/@stdlib/math/base/tools/normhermitepolyf/test/test.factory.js b/lib/node_modules/@stdlib/math/base/tools/normhermitepolyf/test/test.factory.js
index 93e93df036c6..683893ef890e 100644
--- a/lib/node_modules/@stdlib/math/base/tools/normhermitepolyf/test/test.factory.js
+++ b/lib/node_modules/@stdlib/math/base/tools/normhermitepolyf/test/test.factory.js
@@ -534,7 +534,7 @@ tape( 'the function returns a function which returns `NaN` when `x` is `NaN`', f
 	f = factory( 1 );
 
 	y = f( NaN );
-	t.strictEqual( isnanf( y ), true, 'returns expected value');
+	t.strictEqual( isnanf( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -546,7 +546,7 @@ tape( 'the function returns a function which returns `NaN` when `n` is a negativ
 	f = factory( -1 );
 
 	y = f( 0.0 );
-	t.strictEqual( isnanf( y ), true, 'returns expected value');
+	t.strictEqual( isnanf( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -558,7 +558,7 @@ tape( 'the function returns a function which returns `NaN` when `n` is not an in
 	f = factory( 1.01 );
 
 	y = f( 0.0 );
-	t.strictEqual( isnanf( y ), true, 'returns expected value');
+	t.strictEqual( isnanf( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/base/tools/normhermitepolyf/test/test.js b/lib/node_modules/@stdlib/math/base/tools/normhermitepolyf/test/test.js
index e965b87c22cf..b8def1bb2ea8 100644
--- a/lib/node_modules/@stdlib/math/base/tools/normhermitepolyf/test/test.js
+++ b/lib/node_modules/@stdlib/math/base/tools/normhermitepolyf/test/test.js
@@ -478,7 +478,7 @@ tape( 'the function returns `NaN` when `x` is `NaN`', function test( t ) {
 	var y;
 
 	y = normhermitepolyf( 0, NaN );
-	t.strictEqual( isnanf( y ), true, 'returns expected value');
+	t.strictEqual( isnanf( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -487,7 +487,7 @@ tape( 'the function returns `NaN` when `n` is a negative integer`', function tes
 	var y;
 
 	y = normhermitepolyf( -1, 0.0 );
-	t.strictEqual( isnanf( y ), true, 'returns expected value');
+	t.strictEqual( isnanf( y ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -496,7 +496,7 @@ tape( 'the function returns `NaN` when `n` is not an integer`', function test( t
 	var y;
 
 	y = normhermitepolyf( 1.01, 0.0 );
-	t.strictEqual( isnanf( y ), true, 'returns expected value');
+	t.strictEqual( isnanf( y ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/math/iter/sequences/tribonacci/examples/index.js b/lib/node_modules/@stdlib/math/iter/sequences/tribonacci/examples/index.js
index 75a61f73e78e..c4550c9a8984 100644
--- a/lib/node_modules/@stdlib/math/iter/sequences/tribonacci/examples/index.js
+++ b/lib/node_modules/@stdlib/math/iter/sequences/tribonacci/examples/index.js
@@ -18,7 +18,7 @@
 
 'use strict';
 
-var iterTribonacciSeq = require('./../lib');
+var iterTribonacciSeq = require( './../lib' );
 
 // Create an iterator:
 var it = iterTribonacciSeq();
diff --git a/lib/node_modules/@stdlib/net/http-server/lib/main.js b/lib/node_modules/@stdlib/net/http-server/lib/main.js
index 07afcb15912e..061667010acf 100644
--- a/lib/node_modules/@stdlib/net/http-server/lib/main.js
+++ b/lib/node_modules/@stdlib/net/http-server/lib/main.js
@@ -30,7 +30,7 @@ var DEFAULTS = require( './defaults.json' );
 
 // VARIABLES //
 
-var debug = logger( '@stdlib/net/http-server');
+var debug = logger( '@stdlib/net/http-server' );
 
 
 // MAIN //
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/lib/main.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/lib/main.js
index 9f0832223b72..cd306c0df4a1 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/lib/main.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/cdf/lib/main.js
@@ -44,7 +44,7 @@ var PI = require( '@stdlib/constants/float64/pi' );
 * // returns 1.0
 *
 * @example
-* var y = cdf( -0.9, 0.0, 1.0);
+* var y = cdf( -0.9, 0.0, 1.0 );
 * // returns ~0.0
 *
 * @example
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/lib/main.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/lib/main.js
index 4980634e8da5..917462d0c594 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/lib/main.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/mgf/lib/main.js
@@ -45,7 +45,7 @@ var PI_SQUARED = require( '@stdlib/constants/float64/pi-squared' );
 * // returns ~1.098
 *
 * @example
-* var y = mgf( -0.9, 0.0, 3.0);
+* var y = mgf( -0.9, 0.0, 3.0 );
 * // returns ~1.578
 *
 * @example
diff --git a/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/lib/bisect.js b/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/lib/bisect.js
index 87220ebfb55d..ec5481be254a 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/lib/bisect.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/cosine/quantile/lib/bisect.js
@@ -55,7 +55,7 @@ function bisect( p, mu, s ) {
 		if ( b - a < TOLERANCE ) {
 			return m;
 		}
-		c = cosineCDF( m, mu, s);
+		c = cosineCDF( m, mu, s );
 		if ( p > c ) {
 			a = m;
 		} else {
diff --git a/lib/node_modules/@stdlib/stats/base/dists/weibull/skewness/lib/main.js b/lib/node_modules/@stdlib/stats/base/dists/weibull/skewness/lib/main.js
index 13574c7d6858..ef04da2898ce 100644
--- a/lib/node_modules/@stdlib/stats/base/dists/weibull/skewness/lib/main.js
+++ b/lib/node_modules/@stdlib/stats/base/dists/weibull/skewness/lib/main.js
@@ -79,7 +79,7 @@ function skewness( k, lambda ) {
 		return NaN;
 	}
 	mu = mean( k, lambda );
-	sigma2 = variance( k, lambda);
+	sigma2 = variance( k, lambda );
 	sigma = sqrt( sigma2 );
 	out = gamma( 1.0 + ( 3.0/k ) ) * pow( lambda, 3.0 );
 	out -= ( 3.0*mu*sigma2 ) + pow( mu, 3.0 );
diff --git a/lib/node_modules/@stdlib/string/base/replace/lib/main.js b/lib/node_modules/@stdlib/string/base/replace/lib/main.js
index 510e7d206fdd..7b65550fefc6 100644
--- a/lib/node_modules/@stdlib/string/base/replace/lib/main.js
+++ b/lib/node_modules/@stdlib/string/base/replace/lib/main.js
@@ -42,7 +42,7 @@
 *     return capitalize( p1 );
 * }
 *
-* var out = replace( str, /([^\s]*)/gi, replacer);
+* var out = replace( str, /([^\s]*)/gi, replacer );
 * // returns 'Oranges And Lemons Say The Bells Of St. Clement\'s'
 */
 function replace( str, search, newval ) {

From 62e703a5eb7df95a40b3592366da89c5ff42a1b1 Mon Sep 17 00:00:00 2001
From: GUNJ JOSHI <gunjjoshi8372@gmail.com>
Date: Mon, 8 Jul 2024 20:00:49 +0530
Subject: [PATCH 07/16] docs: add missing `@private` in
 `math/base/special/round/lib/native.js`

PR-URL: #2536

Signed-off-by: GUNJ JOSHI <gunjjoshi8372@gmail.com>
Reviewed-by: Philipp Burckhardt <pburckhardt@outlook.com>
---
 lib/node_modules/@stdlib/math/base/special/round/lib/native.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/node_modules/@stdlib/math/base/special/round/lib/native.js b/lib/node_modules/@stdlib/math/base/special/round/lib/native.js
index 10f48f5fc41e..f99fa002947a 100644
--- a/lib/node_modules/@stdlib/math/base/special/round/lib/native.js
+++ b/lib/node_modules/@stdlib/math/base/special/round/lib/native.js
@@ -28,6 +28,7 @@ var addon = require( './../src/addon.node' );
 /**
 * Rounds a numeric value to the nearest integer.
 *
+* @private
 * @param {number} x - input value
 * @returns {number} function value
 *

From efc3551764c30c6cae9a48058cae2868d4055190 Mon Sep 17 00:00:00 2001
From: GUNJ JOSHI <gunjjoshi8372@gmail.com>
Date: Tue, 9 Jul 2024 05:05:21 +0530
Subject: [PATCH 08/16] feat: add C implementation for
 `math/base/special/round2`

PR-URL:  #2537
Ref: #649

Reviewed-by: Philipp Burckhardt <pburckhardt@outlook.com>
---
 .../math/base/special/round2/README.md        |  85 +++++++++
 .../round2/benchmark/benchmark.native.js      |  60 ++++++
 .../round2/benchmark/c/native/Makefile        | 146 ++++++++++++++
 .../round2/benchmark/c/native/benchmark.c     | 136 +++++++++++++
 .../math/base/special/round2/binding.gyp      | 170 +++++++++++++++++
 .../base/special/round2/examples/c/Makefile   | 146 ++++++++++++++
 .../base/special/round2/examples/c/example.c  |  31 +++
 .../math/base/special/round2/include.gypi     |  53 ++++++
 .../include/stdlib/math/base/special/round2.h |  38 ++++
 .../math/base/special/round2/lib/main.js      |   5 +-
 .../math/base/special/round2/lib/native.js    |  54 ++++++
 .../math/base/special/round2/manifest.json    |  96 ++++++++++
 .../math/base/special/round2/src/Makefile     |  70 +++++++
 .../math/base/special/round2/src/addon.c      |  23 +++
 .../math/base/special/round2/src/main.c       |  97 ++++++++++
 .../base/special/round2/test/test.native.js   | 180 ++++++++++++++++++
 16 files changed, 1389 insertions(+), 1 deletion(-)
 create mode 100644 lib/node_modules/@stdlib/math/base/special/round2/benchmark/benchmark.native.js
 create mode 100644 lib/node_modules/@stdlib/math/base/special/round2/benchmark/c/native/Makefile
 create mode 100644 lib/node_modules/@stdlib/math/base/special/round2/benchmark/c/native/benchmark.c
 create mode 100644 lib/node_modules/@stdlib/math/base/special/round2/binding.gyp
 create mode 100644 lib/node_modules/@stdlib/math/base/special/round2/examples/c/Makefile
 create mode 100644 lib/node_modules/@stdlib/math/base/special/round2/examples/c/example.c
 create mode 100644 lib/node_modules/@stdlib/math/base/special/round2/include.gypi
 create mode 100644 lib/node_modules/@stdlib/math/base/special/round2/include/stdlib/math/base/special/round2.h
 create mode 100644 lib/node_modules/@stdlib/math/base/special/round2/lib/native.js
 create mode 100644 lib/node_modules/@stdlib/math/base/special/round2/manifest.json
 create mode 100644 lib/node_modules/@stdlib/math/base/special/round2/src/Makefile
 create mode 100644 lib/node_modules/@stdlib/math/base/special/round2/src/addon.c
 create mode 100644 lib/node_modules/@stdlib/math/base/special/round2/src/main.c
 create mode 100644 lib/node_modules/@stdlib/math/base/special/round2/test/test.native.js

diff --git a/lib/node_modules/@stdlib/math/base/special/round2/README.md b/lib/node_modules/@stdlib/math/base/special/round2/README.md
index a4988a95d368..61d621eebec5 100644
--- a/lib/node_modules/@stdlib/math/base/special/round2/README.md
+++ b/lib/node_modules/@stdlib/math/base/special/round2/README.md
@@ -101,6 +101,91 @@ for ( i = 0; i < 100; i++ ) {
 
 <!-- /.examples -->
 
+<!-- C interface documentation. -->
+
+* * *
+
+<section class="c">
+
+## C APIs
+
+<!-- Section to include introductory text. Make sure to keep an empty line after the intro `section` element and another before the `/section` close. -->
+
+<section class="intro">
+
+</section>
+
+<!-- /.intro -->
+
+<!-- C usage documentation. -->
+
+<section class="usage">
+
+### Usage
+
+```c
+#include "stdlib/math/base/special/round2.h"
+```
+
+#### stdlib_base_round2( x )
+
+Rounds a `numeric` value to the nearest power of two on a linear scale.
+
+```c
+double out = stdlib_base_round2( -4.2 );
+// returns -4.0
+```
+
+The function accepts the following arguments:
+
+-   **x**: `[in] double` input value.
+
+```c
+double stdlib_base_round2( const double x );
+```
+
+</section>
+
+<!-- /.usage -->
+
+<!-- C API usage notes. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="notes">
+
+</section>
+
+<!-- /.notes -->
+
+<!-- C API usage examples. -->
+
+<section class="examples">
+
+### Examples
+
+```c
+#include "stdlib/math/base/special/round2.h"
+#include <stdio.h>
+
+int main( void ) {
+    const double x[] = { -5.0, -3.89, -2.78, -1.67, -0.56, 0.56, 1.67, 2.78, 3.89, 5.0 };
+    
+    double v;
+    int i;
+    for ( i = 0; i < 10; i++ ) {
+        v = stdlib_base_round2( x[ i ] );
+        printf( "round2(%lf) = %lf\n", x[ i ], v );
+    }
+}
+```
+
+</section>
+
+<!-- /.examples -->
+
+</section>
+
+<!-- /.c -->
+
 <!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
 
 <section class="related">
diff --git a/lib/node_modules/@stdlib/math/base/special/round2/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/math/base/special/round2/benchmark/benchmark.native.js
new file mode 100644
index 000000000000..deb24dfdd018
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/round2/benchmark/benchmark.native.js
@@ -0,0 +1,60 @@
+/**
+* @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 resolve = require( 'path' ).resolve;
+var bench = require( '@stdlib/bench' );
+var randu = require( '@stdlib/random/base/randu' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var tryRequire = require( '@stdlib/utils/try-require' );
+var pkg = require( './../package.json' ).name;
+
+
+// VARIABLES //
+
+var round2 = tryRequire( resolve( __dirname, './../lib/native.js' ) );
+var opts = {
+	'skip': ( round2 instanceof Error )
+};
+
+
+// MAIN //
+
+bench( pkg+'::native', opts, function benchmark( b ) {
+	var x;
+	var y;
+	var i;
+
+	b.tic();
+	for ( i = 0; i < b.iterations; i++ ) {
+		x = ( randu() * 1.0e7 ) - 5.0e6;
+		y = round2( x );
+		if ( isnan( y ) ) {
+			b.fail( 'should not return NaN' );
+		}
+	}
+	b.toc();
+	if ( isnan( y ) ) {
+		b.fail( 'should not return NaN' );
+	}
+	b.pass( 'benchmark finished' );
+	b.end();
+});
diff --git a/lib/node_modules/@stdlib/math/base/special/round2/benchmark/c/native/Makefile b/lib/node_modules/@stdlib/math/base/special/round2/benchmark/c/native/Makefile
new file mode 100644
index 000000000000..f69e9da2b4d3
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/round2/benchmark/c/native/Makefile
@@ -0,0 +1,146 @@
+#/
+# @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.
+#/
+
+# VARIABLES #
+
+ifndef VERBOSE
+	QUIET := @
+else
+	QUIET :=
+endif
+
+# Determine the OS ([1][1], [2][2]).
+#
+# [1]: https://en.wikipedia.org/wiki/Uname#Examples
+# [2]: http://stackoverflow.com/a/27776822/2225624
+OS ?= $(shell uname)
+ifneq (, $(findstring MINGW,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring MSYS,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring CYGWIN,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring Windows_NT,$(OS)))
+	OS := WINNT
+endif
+endif
+endif
+endif
+
+# Define the program used for compiling C source files:
+ifdef C_COMPILER
+	CC := $(C_COMPILER)
+else
+	CC := gcc
+endif
+
+# Define the command-line options when compiling C files:
+CFLAGS ?= \
+	-std=c99 \
+	-O3 \
+	-Wall \
+	-pedantic
+
+# Determine whether to generate position independent code ([1][1], [2][2]).
+#
+# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options
+# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option
+ifeq ($(OS), WINNT)
+	fPIC ?=
+else
+	fPIC ?= -fPIC
+endif
+
+# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`):
+INCLUDE ?=
+
+# List of source files:
+SOURCE_FILES ?=
+
+# List of libraries (e.g., `-lopenblas -lpthread`):
+LIBRARIES ?=
+
+# List of library paths (e.g., `-L /foo/bar -L /beep/boop`):
+LIBPATH ?=
+
+# List of C targets:
+c_targets := benchmark.out
+
+
+# RULES #
+
+#/
+# Compiles source files.
+#
+# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`)
+# @param {string} [CFLAGS] - C compiler options
+# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`)
+# @param {string} [SOURCE_FILES] - list of source files
+# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`)
+# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`)
+#
+# @example
+# make
+#
+# @example
+# make all
+#/
+all: $(c_targets)
+
+.PHONY: all
+
+#/
+# Compiles C source files.
+#
+# @private
+# @param {string} CC - C compiler (e.g., `gcc`)
+# @param {string} CFLAGS - C compiler options
+# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`)
+# @param {string} SOURCE_FILES - list of source files
+# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`)
+# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`)
+#/
+$(c_targets): %.out: %.c
+	$(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES)
+
+#/
+# Runs compiled benchmarks.
+#
+# @example
+# make run
+#/
+run: $(c_targets)
+	$(QUIET) ./$<
+
+.PHONY: run
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean:
+	$(QUIET) -rm -f *.o *.out
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/math/base/special/round2/benchmark/c/native/benchmark.c b/lib/node_modules/@stdlib/math/base/special/round2/benchmark/c/native/benchmark.c
new file mode 100644
index 000000000000..e36f0322dfdf
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/round2/benchmark/c/native/benchmark.c
@@ -0,0 +1,136 @@
+/**
+* @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.
+*/
+
+/**
+* Benchmark `round2`.
+*/
+#include "stdlib/math/base/special/round2.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+#include <time.h>
+#include <sys/time.h>
+
+#define NAME "round2"
+#define ITERATIONS 1000000
+#define REPEATS 3
+
+/**
+* Prints the TAP version.
+*/
+void print_version() {
+	printf( "TAP version 13\n" );
+}
+
+/**
+* Prints the TAP summary.
+*
+* @param total     total number of tests
+* @param passing   total number of passing tests
+*/
+void print_summary( int total, int passing ) {
+	printf( "#\n" );
+	printf( "1..%d\n", total ); // TAP plan
+	printf( "# total %d\n", total );
+	printf( "# pass  %d\n", passing );
+	printf( "#\n" );
+	printf( "# ok\n" );
+}
+
+/**
+* Prints benchmarks results.
+*
+* @param elapsed   elapsed time in seconds
+*/
+void print_results( double elapsed ) {
+	double rate = (double)ITERATIONS / elapsed;
+	printf( "  ---\n" );
+	printf( "  iterations: %d\n", ITERATIONS );
+	printf( "  elapsed: %0.9f\n", elapsed );
+	printf( "  rate: %0.9f\n", rate );
+	printf( "  ...\n" );
+}
+
+/**
+* Returns a clock time.
+*
+* @return clock time
+*/
+double tic() {
+	struct timeval now;
+	gettimeofday( &now, NULL );
+	return (double)now.tv_sec + (double)now.tv_usec/1.0e6;
+}
+
+/**
+* Generates a random number on the interval [0,1].
+*
+* @return random number
+*/
+double rand_double() {
+	int r = rand();
+	return (double)r / ( (double)RAND_MAX + 1.0 );
+}
+
+/**
+* Runs a benchmark.
+*
+* @return elapsed time in seconds
+*/
+double benchmark() {
+	double elapsed;
+	double x;
+	double y;
+	double t;
+	int i;
+
+	t = tic();
+	for ( i = 0; i < ITERATIONS; i++ ) {
+		x = ( 1.0e7 * rand_double() ) - 5.0e6;
+		y = stdlib_base_round2( x );
+		if ( y != y ) {
+			printf( "should not return NaN\n" );
+			break;
+		}
+	}
+	elapsed = tic() - t;
+	if ( y != y ) {
+		printf( "should not return NaN\n" );
+	}
+	return elapsed;
+}
+
+/**
+* Main execution sequence.
+*/
+int main( void ) {
+	double elapsed;
+	int i;
+
+	// Use the current time to seed the random number generator:
+	srand( time( NULL ) );
+
+	print_version();
+	for ( i = 0; i < REPEATS; i++ ) {
+		printf( "# c::native::%s\n", NAME );
+		elapsed = benchmark();
+		print_results( elapsed );
+		printf( "ok %d benchmark finished\n", i+1 );
+	}
+	print_summary( REPEATS, REPEATS );
+}
diff --git a/lib/node_modules/@stdlib/math/base/special/round2/binding.gyp b/lib/node_modules/@stdlib/math/base/special/round2/binding.gyp
new file mode 100644
index 000000000000..ec3992233442
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/round2/binding.gyp
@@ -0,0 +1,170 @@
+# @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.
+
+# A `.gyp` file for building a Node.js native add-on.
+#
+# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md
+# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md
+{
+  # List of files to include in this file:
+  'includes': [
+    './include.gypi',
+  ],
+
+  # Define variables to be used throughout the configuration for all targets:
+  'variables': {
+    # Target name should match the add-on export name:
+    'addon_target_name%': 'addon',
+
+    # Set variables based on the host OS:
+    'conditions': [
+      [
+        'OS=="win"',
+        {
+          # Define the object file suffix:
+          'obj': 'obj',
+        },
+        {
+          # Define the object file suffix:
+          'obj': 'o',
+        }
+      ], # end condition (OS=="win")
+    ], # end conditions
+  }, # end variables
+
+  # Define compile targets:
+  'targets': [
+
+    # Target to generate an add-on:
+    {
+      # The target name should match the add-on export name:
+      'target_name': '<(addon_target_name)',
+
+      # Define dependencies:
+      'dependencies': [],
+
+      # Define directories which contain relevant include headers:
+      'include_dirs': [
+        # Local include directory:
+        '<@(include_dirs)',
+      ],
+
+      # List of source files:
+      'sources': [
+        '<@(src_files)',
+      ],
+
+      # Settings which should be applied when a target's object files are used as linker input:
+      'link_settings': {
+        # Define libraries:
+        'libraries': [
+          '<@(libraries)',
+        ],
+
+        # Define library directories:
+        'library_dirs': [
+          '<@(library_dirs)',
+        ],
+      },
+
+      # C/C++ compiler flags:
+      'cflags': [
+        # Enable commonly used warning options:
+        '-Wall',
+
+        # Aggressive optimization:
+        '-O3',
+      ],
+
+      # C specific compiler flags:
+      'cflags_c': [
+        # Specify the C standard to which a program is expected to conform:
+        '-std=c99',
+      ],
+
+      # C++ specific compiler flags:
+      'cflags_cpp': [
+        # Specify the C++ standard to which a program is expected to conform:
+        '-std=c++11',
+      ],
+
+      # Linker flags:
+      'ldflags': [],
+
+      # Apply conditions based on the host OS:
+      'conditions': [
+        [
+          'OS=="mac"',
+          {
+            # Linker flags:
+            'ldflags': [
+              '-undefined dynamic_lookup',
+              '-Wl,-no-pie',
+              '-Wl,-search_paths_first',
+            ],
+          },
+        ], # end condition (OS=="mac")
+        [
+          'OS!="win"',
+          {
+            # C/C++ flags:
+            'cflags': [
+              # Generate platform-independent code:
+              '-fPIC',
+            ],
+          },
+        ], # end condition (OS!="win")
+      ], # end conditions
+    }, # end target <(addon_target_name)
+
+    # Target to copy a generated add-on to a standard location:
+    {
+      'target_name': 'copy_addon',
+
+      # Declare that the output of this target is not linked:
+      'type': 'none',
+
+      # Define dependencies:
+      'dependencies': [
+        # Require that the add-on be generated before building this target:
+        '<(addon_target_name)',
+      ],
+
+      # Define a list of actions:
+      'actions': [
+        {
+          'action_name': 'copy_addon',
+          'message': 'Copying addon...',
+
+          # Explicitly list the inputs in the command-line invocation below:
+          'inputs': [],
+
+          # Declare the expected outputs:
+          'outputs': [
+            '<(addon_output_dir)/<(addon_target_name).node',
+          ],
+
+          # Define the command-line invocation:
+          'action': [
+            'cp',
+            '<(PRODUCT_DIR)/<(addon_target_name).node',
+            '<(addon_output_dir)/<(addon_target_name).node',
+          ],
+        },
+      ], # end actions
+    }, # end target copy_addon
+  ], # end targets
+}
diff --git a/lib/node_modules/@stdlib/math/base/special/round2/examples/c/Makefile b/lib/node_modules/@stdlib/math/base/special/round2/examples/c/Makefile
new file mode 100644
index 000000000000..6aed70daf167
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/round2/examples/c/Makefile
@@ -0,0 +1,146 @@
+#/
+# @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.
+#/
+
+# VARIABLES #
+
+ifndef VERBOSE
+	QUIET := @
+else
+	QUIET :=
+endif
+
+# Determine the OS ([1][1], [2][2]).
+#
+# [1]: https://en.wikipedia.org/wiki/Uname#Examples
+# [2]: http://stackoverflow.com/a/27776822/2225624
+OS ?= $(shell uname)
+ifneq (, $(findstring MINGW,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring MSYS,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring CYGWIN,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring Windows_NT,$(OS)))
+	OS := WINNT
+endif
+endif
+endif
+endif
+
+# Define the program used for compiling C source files:
+ifdef C_COMPILER
+	CC := $(C_COMPILER)
+else
+	CC := gcc
+endif
+
+# Define the command-line options when compiling C files:
+CFLAGS ?= \
+	-std=c99 \
+	-O3 \
+	-Wall \
+	-pedantic
+
+# Determine whether to generate position independent code ([1][1], [2][2]).
+#
+# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options
+# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option
+ifeq ($(OS), WINNT)
+	fPIC ?=
+else
+	fPIC ?= -fPIC
+endif
+
+# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`):
+INCLUDE ?=
+
+# List of source files:
+SOURCE_FILES ?=
+
+# List of libraries (e.g., `-lopenblas -lpthread`):
+LIBRARIES ?=
+
+# List of library paths (e.g., `-L /foo/bar -L /beep/boop`):
+LIBPATH ?=
+
+# List of C targets:
+c_targets := example.out
+
+
+# RULES #
+
+#/
+# Compiles source files.
+#
+# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`)
+# @param {string} [CFLAGS] - C compiler options
+# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`)
+# @param {string} [SOURCE_FILES] - list of source files
+# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`)
+# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`)
+#
+# @example
+# make
+#
+# @example
+# make all
+#/
+all: $(c_targets)
+
+.PHONY: all
+
+#/
+# Compiles C source files.
+#
+# @private
+# @param {string} CC - C compiler (e.g., `gcc`)
+# @param {string} CFLAGS - C compiler options
+# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`)
+# @param {string} SOURCE_FILES - list of source files
+# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`)
+# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`)
+#/
+$(c_targets): %.out: %.c
+	$(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES)
+
+#/
+# Runs compiled examples.
+#
+# @example
+# make run
+#/
+run: $(c_targets)
+	$(QUIET) ./$<
+
+.PHONY: run
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean:
+	$(QUIET) -rm -f *.o *.out
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/math/base/special/round2/examples/c/example.c b/lib/node_modules/@stdlib/math/base/special/round2/examples/c/example.c
new file mode 100644
index 000000000000..3f5e09bec2c0
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/round2/examples/c/example.c
@@ -0,0 +1,31 @@
+/**
+* @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.
+*/
+
+#include "stdlib/math/base/special/round2.h"
+#include <stdio.h>
+
+int main( void ) {
+    const double x[] = { -5.0, -3.89, -2.78, -1.67, -0.56, 0.56, 1.67, 2.78, 3.89, 5.0 };
+
+    double v;
+    int i;
+    for ( i = 0; i < 10; i++ ) {
+        v = stdlib_base_round2( x[ i ] );
+        printf( "round2(%lf) = %lf\n", x[ i ], v );
+    }
+}
diff --git a/lib/node_modules/@stdlib/math/base/special/round2/include.gypi b/lib/node_modules/@stdlib/math/base/special/round2/include.gypi
new file mode 100644
index 000000000000..575cb043c0bf
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/round2/include.gypi
@@ -0,0 +1,53 @@
+# @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.
+
+# A GYP include file for building a Node.js native add-on.
+#
+# Main documentation:
+#
+# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md
+# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md
+{
+  # Define variables to be used throughout the configuration for all targets:
+  'variables': {
+    # Source directory:
+    'src_dir': './src',
+
+    # Include directories:
+    'include_dirs': [
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).include; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+
+    # Add-on destination directory:
+    'addon_output_dir': './src',
+
+    # Source files:
+    'src_files': [
+      '<(src_dir)/addon.c',
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).src; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+
+    # Library dependencies:
+    'libraries': [
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).libraries; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+
+    # Library directories:
+    'library_dirs': [
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).libpath; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+  }, # end variables
+}
diff --git a/lib/node_modules/@stdlib/math/base/special/round2/include/stdlib/math/base/special/round2.h b/lib/node_modules/@stdlib/math/base/special/round2/include/stdlib/math/base/special/round2.h
new file mode 100644
index 000000000000..0846e3368559
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/round2/include/stdlib/math/base/special/round2.h
@@ -0,0 +1,38 @@
+/**
+* @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.
+*/
+
+#ifndef STDLIB_MATH_BASE_SPECIAL_ROUND2_H
+#define STDLIB_MATH_BASE_SPECIAL_ROUND2_H
+
+/*
+* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Rounds a numeric value to the nearest power of two on a linear scale.
+*/
+double stdlib_base_round2( const double x );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !STDLIB_MATH_BASE_SPECIAL_ROUND2_H
diff --git a/lib/node_modules/@stdlib/math/base/special/round2/lib/main.js b/lib/node_modules/@stdlib/math/base/special/round2/lib/main.js
index 3393ab7e55ee..cfc5d6b8c659 100644
--- a/lib/node_modules/@stdlib/math/base/special/round2/lib/main.js
+++ b/lib/node_modules/@stdlib/math/base/special/round2/lib/main.js
@@ -79,6 +79,7 @@ function round2( x ) {
 	} else {
 		sign = 1.0;
 	}
+
 	// Solve the equation `2^p = x` for `p`:
 	p = log2( x );
 
@@ -86,6 +87,7 @@ function round2( x ) {
 	if ( p === MIN_EXP_SUBNORMAL ) {
 		return x;
 	}
+
 	// Find the previous and next integer powers:
 	p1 = floor( p );
 	p2 = ceil( p );
@@ -97,13 +99,14 @@ function round2( x ) {
 		}
 		return sign * HUGE;
 	}
+
 	// Compute previous and next powers of two:
 	y1 = pow( 2.0, p1 );
 	y2 = pow( 2.0, p2 );
 
 	// Find the closest power of two:
 	half = ( y2 - y1 ) / 2.0;
-	if ( y1+half > x ) {
+	if ( y1 + half > x ) {
 		return sign * y1;
 	}
 	return sign * y2;
diff --git a/lib/node_modules/@stdlib/math/base/special/round2/lib/native.js b/lib/node_modules/@stdlib/math/base/special/round2/lib/native.js
new file mode 100644
index 000000000000..88b8b9bc0314
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/round2/lib/native.js
@@ -0,0 +1,54 @@
+/**
+* @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 addon = require( './../src/addon.node' );
+
+
+// MAIN //
+
+/**
+* Rounds a numeric value to the nearest power of two on a linear scale.
+*
+* @private
+* @param {number} x - input value
+* @returns {number} rounded value
+*
+* @example
+* var v = round2( 3.141592653589793 );
+* // returns 4.0
+*
+* @example
+* var v = round2( 13.0 );
+* // returns 16.0
+*
+* @example
+* var v = round2( -0.314 );
+* // returns -0.25
+*/
+function round2( x ) {
+	return addon( x );
+}
+
+
+// EXPORTS //
+
+module.exports = round2;
diff --git a/lib/node_modules/@stdlib/math/base/special/round2/manifest.json b/lib/node_modules/@stdlib/math/base/special/round2/manifest.json
new file mode 100644
index 000000000000..f50a980becef
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/round2/manifest.json
@@ -0,0 +1,96 @@
+{
+  "options": {
+    "task": "build"
+  },
+  "fields": [
+    {
+      "field": "src",
+      "resolve": true,
+      "relative": true
+    },
+    {
+      "field": "include",
+      "resolve": true,
+      "relative": true
+    },
+    {
+      "field": "libraries",
+      "resolve": false,
+      "relative": false
+    },
+    {
+      "field": "libpath",
+      "resolve": true,
+      "relative": false
+    }
+  ],
+  "confs": [
+    {
+      "task": "build",
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/math/base/napi/unary",
+        "@stdlib/math/base/assert/is-nan",
+        "@stdlib/math/base/assert/is-infinite",
+        "@stdlib/math/base/special/floor",
+        "@stdlib/math/base/special/pow",
+        "@stdlib/math/base/special/ceil",
+        "@stdlib/math/base/special/log2",
+        "@stdlib/constants/float64/max-base2-exponent",
+        "@stdlib/constants/float64/min-base2-exponent-subnormal",
+        "@stdlib/constants/float64/pinf"
+      ]
+    },
+    {
+      "task": "benchmark",
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/math/base/assert/is-nan",
+        "@stdlib/math/base/assert/is-infinite",
+        "@stdlib/math/base/special/floor",
+        "@stdlib/math/base/special/pow",
+        "@stdlib/math/base/special/ceil",
+        "@stdlib/math/base/special/log2",
+        "@stdlib/constants/float64/max-base2-exponent",
+        "@stdlib/constants/float64/min-base2-exponent-subnormal",
+        "@stdlib/constants/float64/pinf"
+      ]
+    },
+    {
+      "task": "examples",
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/math/base/assert/is-nan",
+        "@stdlib/math/base/assert/is-infinite",
+        "@stdlib/math/base/special/floor",
+        "@stdlib/math/base/special/pow",
+        "@stdlib/math/base/special/ceil",
+        "@stdlib/math/base/special/log2",
+        "@stdlib/constants/float64/max-base2-exponent",
+        "@stdlib/constants/float64/min-base2-exponent-subnormal",
+        "@stdlib/constants/float64/pinf"
+      ]
+    }
+  ]
+}
diff --git a/lib/node_modules/@stdlib/math/base/special/round2/src/Makefile b/lib/node_modules/@stdlib/math/base/special/round2/src/Makefile
new file mode 100644
index 000000000000..bcf18aa46655
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/round2/src/Makefile
@@ -0,0 +1,70 @@
+#/
+# @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.
+#/
+
+# VARIABLES #
+
+ifndef VERBOSE
+	QUIET := @
+else
+	QUIET :=
+endif
+
+# Determine the OS ([1][1], [2][2]).
+#
+# [1]: https://en.wikipedia.org/wiki/Uname#Examples
+# [2]: http://stackoverflow.com/a/27776822/2225624
+OS ?= $(shell uname)
+ifneq (, $(findstring MINGW,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring MSYS,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring CYGWIN,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring Windows_NT,$(OS)))
+	OS := WINNT
+endif
+endif
+endif
+endif
+
+
+# RULES #
+
+#/
+# Removes generated files for building an add-on.
+#
+# @example
+# make clean-addon
+#/
+clean-addon:
+	$(QUIET) -rm -f *.o *.node
+
+.PHONY: clean-addon
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean: clean-addon
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/math/base/special/round2/src/addon.c b/lib/node_modules/@stdlib/math/base/special/round2/src/addon.c
new file mode 100644
index 000000000000..eaa3d9002df7
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/round2/src/addon.c
@@ -0,0 +1,23 @@
+/**
+* @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.
+*/
+
+#include "stdlib/math/base/special/round2.h"
+#include "stdlib/math/base/napi/unary.h"
+
+// cppcheck-suppress shadowFunction
+STDLIB_MATH_BASE_NAPI_MODULE_D_D( stdlib_base_round2 )
diff --git a/lib/node_modules/@stdlib/math/base/special/round2/src/main.c b/lib/node_modules/@stdlib/math/base/special/round2/src/main.c
new file mode 100644
index 000000000000..75a8a38dc0a5
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/round2/src/main.c
@@ -0,0 +1,97 @@
+/**
+* @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.
+*/
+
+#include "stdlib/math/base/special/round2.h"
+#include "stdlib/math/base/assert/is_nan.h"
+#include "stdlib/math/base/assert/is_infinite.h"
+#include "stdlib/math/base/special/floor.h"
+#include "stdlib/math/base/special/pow.h"
+#include "stdlib/math/base/special/ceil.h"
+#include "stdlib/math/base/special/log2.h"
+#include "stdlib/constants/float64/max_base2_exponent.h"
+#include "stdlib/constants/float64/min_base2_exponent_subnormal.h"
+#include "stdlib/constants/float64/pinf.h"
+
+/**
+* Rounds a numeric value to the nearest power of two on a linear scale.
+*
+* @param x    input value
+* @return     rounded value
+*
+* @example
+* double out = stdlib_base_round2( 3.141592653589793 );
+* // returns 4.0
+*/
+double stdlib_base_round2( const double x ) {
+	double HALF_HUGE_VALUE;
+	double HUGE_VALUE;
+	double sign;
+	double half;
+	double p1;
+	double p2;
+	double y1;
+	double y2;
+	double xc;
+	double p;
+
+	if ( stdlib_base_is_nan( x ) || stdlib_base_is_infinite( x ) || x == 0.0 ) {
+		return x;
+	}
+	xc = x;
+	if ( xc < 0 ) {
+		xc = -xc;
+		sign = -1.0;
+	} else {
+		sign = 1.0;
+	}
+
+	// Solve the equation `2^p = x` for `p`:
+	p = stdlib_base_log2( xc );
+
+	// If provided the smallest subnormal, no rounding possible:
+	if ( p == STDLIB_CONSTANT_FLOAT64_MIN_BASE2_EXPONENT_SUBNORMAL ) {
+		return xc;
+	}
+
+	// Find the previous and next integer powers:
+	p1 = stdlib_base_floor( p );
+	p2 = stdlib_base_ceil( p );
+
+	// 2^1023:
+	HUGE_VALUE = stdlib_base_pow( 2.0, STDLIB_CONSTANT_FLOAT64_MAX_BASE2_EXPONENT );
+	HALF_HUGE_VALUE = HUGE_VALUE / 2.0;
+
+	// Handle overflow:
+	if ( p1 == STDLIB_CONSTANT_FLOAT64_MAX_BASE2_EXPONENT ) {
+		if ( xc - HUGE_VALUE >= HALF_HUGE_VALUE ) {
+			return sign * STDLIB_CONSTANT_FLOAT64_PINF; // sign-preserving
+		}
+		return sign * HUGE_VALUE;
+	}
+
+	// Compute previous and next powers of two:
+	y1 = stdlib_base_pow( 2.0, p1 );
+	y2 = stdlib_base_pow( 2.0, p2 );
+
+	// Find the closest power of two:
+	half = ( y2 - y1 ) / 2.0;
+	if ( y1 + half > xc ) {
+		return sign * y1;
+	}
+	return sign * y2;
+}
diff --git a/lib/node_modules/@stdlib/math/base/special/round2/test/test.native.js b/lib/node_modules/@stdlib/math/base/special/round2/test/test.native.js
new file mode 100644
index 000000000000..8ea63ca3bbfd
--- /dev/null
+++ b/lib/node_modules/@stdlib/math/base/special/round2/test/test.native.js
@@ -0,0 +1,180 @@
+/**
+* @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 resolve = require( 'path' ).resolve;
+var tape = require( 'tape' );
+var NINF = require( '@stdlib/constants/float64/ninf' );
+var PINF = require( '@stdlib/constants/float64/pinf' );
+var SMALLEST_SUBNORMAL = require( '@stdlib/constants/float64/smallest-subnormal' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var isNegativeZero = require( '@stdlib/math/base/assert/is-negative-zero' );
+var isPositiveZero = require( '@stdlib/math/base/assert/is-positive-zero' );
+var exp2 = require( '@stdlib/math/base/special/exp2' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var tryRequire = require( '@stdlib/utils/try-require' );
+
+
+// VARIABLES //
+
+var round2 = tryRequire( resolve( __dirname, './../lib/native.js' ) );
+var opts = {
+	'skip': ( round2 instanceof Error )
+};
+
+
+// TESTS //
+
+tape( 'main export is a function', opts, function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof round2, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function returns `+0` if provided `+0`', opts, function test( t ) {
+	var v;
+
+	v = round2( 0.0 );
+	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+
+	v = round2( +0.0 );
+	t.strictEqual( isPositiveZero( v ), true, 'returns +0' );
+
+	t.end();
+});
+
+tape( 'the function returns `-0` if provided `-0`', opts, function test( t ) {
+	var v = round2( -0.0 );
+	t.strictEqual( isNegativeZero( v ), true, 'returns -0' );
+	t.end();
+});
+
+tape( 'the function returns `NaN` if provided a `NaN`', opts, function test( t ) {
+	var v = round2( NaN );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns `+infinity` if provided `+infinity`', opts, function test( t ) {
+	var v = round2( PINF );
+	t.strictEqual( v, PINF, 'returns +infinity' );
+	t.end();
+});
+
+tape( 'the function returns `-infinity` if provided `-infinity`', opts, function test( t ) {
+	var v = round2( NINF );
+	t.strictEqual( v, NINF, 'returns -infinity' );
+	t.end();
+});
+
+tape( 'the function returns the minimum double-precision floating-point value if provided the minimum double-precision floating-point value', opts, function test( t ) {
+	var v = round2( SMALLEST_SUBNORMAL );
+	t.strictEqual( v, SMALLEST_SUBNORMAL, 'returns smallest subnormal' );
+	t.end();
+});
+
+tape( 'the function overflows if provided a sufficiently large value', opts, function test( t ) {
+	var x;
+	var v;
+
+	x = exp2( 1023 );
+	v = round2( x + (x/2.0) );
+	t.strictEqual( v, PINF, 'returns +infinity' );
+
+	x = -exp2( 1023 );
+	v = round2( x + (x/2.0) );
+	t.strictEqual( v, NINF, 'returns -infinity' );
+
+	t.end();
+});
+
+tape( 'the function supports rounding large values', opts, function test( t ) {
+	var x;
+	var v;
+
+	x = exp2( 1023 );
+	v = round2( x + (x/3.0) );
+	t.strictEqual( v, x, 'returns expected value' );
+
+	x = -exp2( 1023 );
+	v = round2( x + (x/3.0) );
+	t.strictEqual( v, x, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports rounding subnormal values', opts, function test( t ) {
+	var expected;
+	var x;
+	var v;
+
+	expected = pow( 2.0, -1044 );
+
+	x = pow( 2.0, -1045 );
+	v = round2( x + (x/2.0) );
+	t.strictEqual( v, expected, 'returns expected value' );
+
+	expected = pow( 2.0, -1045 );
+
+	x = pow( 2.0, -1045 );
+	v = round2( x + (x/3.0) );
+	t.strictEqual( v, expected, 'returns expected value' );
+
+	expected = -pow( 2.0, -1044 );
+
+	x = -pow( 2.0, -1045 );
+	v = round2( x + (x/2.0) );
+	t.strictEqual( v, expected, 'returns expected value' );
+
+	expected = -pow( 2.0, -1045 );
+
+	x = -pow( 2.0, -1045 );
+	v = round2( x + (x/3.0) );
+	t.strictEqual( v, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function rounds a numeric value to the nearest power of two on a linear scale', opts, function test( t ) {
+	t.strictEqual( round2( -4.2 ), -4.0, 'returns expected value' );
+	t.strictEqual( round2( -4.5 ), -4.0, 'returns expected value' );
+	t.strictEqual( round2( -4.8 ), -4.0, 'returns expected value' );
+	t.strictEqual( round2( 4.2 ), 4.0, 'returns expected value' );
+	t.strictEqual( round2( 9.99999 ), 8.0, 'returns expected value' );
+	t.strictEqual( round2( 9.5 ), 8.0, 'returns expected value' );
+	t.strictEqual( round2( 9.4 ), 8.0, 'returns expected value' );
+	t.strictEqual( round2( 12.0 ), 16.0, 'returns expected value' );
+	t.strictEqual( round2( -12.0 ), -16.0, 'returns expected value' );
+	t.strictEqual( round2( 13.0 ), 16.0, 'returns expected value' );
+	t.strictEqual( round2( -13.0 ), -16.0, 'returns expected value' );
+	t.strictEqual( round2( 23.0 ), 16.0, 'returns expected value' );
+	t.strictEqual( round2( -23.0 ), -16.0, 'returns expected value' );
+	t.strictEqual( round2( 0.0 ), 0.0, 'returns expected value' );
+	t.strictEqual( round2( 27.0 ), 32.0, 'returns expected value' );
+	t.strictEqual( round2( -27.0 ), -32.0, 'returns expected value' );
+	t.strictEqual( round2( 48.1 ), 64.0, 'returns expected value' );
+	t.strictEqual( round2( -48.1 ), -64.0, 'returns expected value' );
+	t.strictEqual( round2( 0.3 ), 0.25, 'returns expected value' );
+	t.strictEqual( round2( -0.3 ), -0.25, 'returns expected value' );
+	t.strictEqual( round2( 0.45 ), 0.5, 'returns expected value' );
+	t.strictEqual( round2( -0.45 ), -0.5, 'returns expected value' );
+	t.end();
+});

From ca18359c4b18000828a214bc52a32db7ac6c1121 Mon Sep 17 00:00:00 2001
From: GUNJ JOSHI <gunjjoshi8372@gmail.com>
Date: Tue, 9 Jul 2024 12:56:10 +0530
Subject: [PATCH 09/16] refactor: update to use stdlib `pow`

PR-URL: https://github.com/stdlib-js/stdlib/pull/2539
Reviewed-by: Athan Reines <kgryte@gmail.com>
---
 .../math/base/special/roundn/manifest.json     | 18 ++++++++++++------
 .../special/roundn/src/{roundn.c => main.c}    |  9 +++++----
 2 files changed, 17 insertions(+), 10 deletions(-)
 rename lib/node_modules/@stdlib/math/base/special/roundn/src/{roundn.c => main.c} (95%)

diff --git a/lib/node_modules/@stdlib/math/base/special/roundn/manifest.json b/lib/node_modules/@stdlib/math/base/special/roundn/manifest.json
index eb9529f7f29b..68abf0bebf73 100644
--- a/lib/node_modules/@stdlib/math/base/special/roundn/manifest.json
+++ b/lib/node_modules/@stdlib/math/base/special/roundn/manifest.json
@@ -28,7 +28,7 @@
     {
       "task": "build",
       "src": [
-        "./src/roundn.c"
+        "./src/main.c"
       ],
       "include": [
         "./include"
@@ -41,17 +41,19 @@
         "@stdlib/math/base/napi/binary",
         "@stdlib/math/base/special/abs",
         "@stdlib/math/base/special/round",
+        "@stdlib/math/base/special/pow",
         "@stdlib/constants/float64/max-safe-integer",
         "@stdlib/constants/float64/max-base10-exponent",
         "@stdlib/constants/float64/min-base10-exponent",
         "@stdlib/constants/float64/min-base10-exponent-subnormal",
-        "@stdlib/math/base/assert/is-infinite"
+        "@stdlib/math/base/assert/is-infinite",
+        "@stdlib/math/base/assert/is-nan"
       ]
     },
     {
       "task": "benchmark",
       "src": [
-        "./src/roundn.c"
+        "./src/main.c"
       ],
       "include": [
         "./include"
@@ -63,17 +65,19 @@
       "dependencies": [
         "@stdlib/math/base/special/abs",
         "@stdlib/math/base/special/round",
+        "@stdlib/math/base/special/pow",
         "@stdlib/constants/float64/max-safe-integer",
         "@stdlib/constants/float64/max-base10-exponent",
         "@stdlib/constants/float64/min-base10-exponent",
         "@stdlib/constants/float64/min-base10-exponent-subnormal",
-        "@stdlib/math/base/assert/is-infinite"
+        "@stdlib/math/base/assert/is-infinite",
+        "@stdlib/math/base/assert/is-nan"
       ]
     },
     {
       "task": "examples",
       "src": [
-        "./src/roundn.c"
+        "./src/main.c"
       ],
       "include": [
         "./include"
@@ -85,11 +89,13 @@
       "dependencies": [
         "@stdlib/math/base/special/abs",
         "@stdlib/math/base/special/round",
+        "@stdlib/math/base/special/pow",
         "@stdlib/constants/float64/max-safe-integer",
         "@stdlib/constants/float64/max-base10-exponent",
         "@stdlib/constants/float64/min-base10-exponent",
         "@stdlib/constants/float64/min-base10-exponent-subnormal",
-        "@stdlib/math/base/assert/is-infinite"
+        "@stdlib/math/base/assert/is-infinite",
+        "@stdlib/math/base/assert/is-nan"
       ]
     }
   ]
diff --git a/lib/node_modules/@stdlib/math/base/special/roundn/src/roundn.c b/lib/node_modules/@stdlib/math/base/special/roundn/src/main.c
similarity index 95%
rename from lib/node_modules/@stdlib/math/base/special/roundn/src/roundn.c
rename to lib/node_modules/@stdlib/math/base/special/roundn/src/main.c
index f391f3458450..7b1bab64c5da 100644
--- a/lib/node_modules/@stdlib/math/base/special/roundn/src/roundn.c
+++ b/lib/node_modules/@stdlib/math/base/special/roundn/src/main.c
@@ -18,14 +18,15 @@
 
 #include "stdlib/math/base/special/roundn.h"
 #include "stdlib/math/base/assert/is_infinite.h"
+#include "stdlib/math/base/assert/is_nan.h"
 #include "stdlib/math/base/special/abs.h"
 #include "stdlib/math/base/special/round.h"
+#include "stdlib/math/base/special/pow.h"
 #include "stdlib/constants/float64/max_safe_integer.h"
 #include "stdlib/constants/float64/max_base10_exponent.h"
 #include "stdlib/constants/float64/min_base10_exponent.h"
 #include "stdlib/constants/float64/min_base10_exponent_subnormal.h"
 #include <stdint.h>
-#include <math.h>
 
 static const double MAX_INT = STDLIB_CONSTANT_FLOAT64_MAX_SAFE_INTEGER + 1.0;
 static const double HUGE_VALUE = 1.0e+308;
@@ -115,7 +116,7 @@ double stdlib_base_roundn( const double x, const int32_t n ) {
 	double s;
 	double y;
 
-	if ( isnan( x ) ){
+	if ( stdlib_base_is_nan( x ) ){
 		return 0.0 / 0.0; // NaN
 	}
 
@@ -140,14 +141,14 @@ double stdlib_base_roundn( const double x, const int32_t n ) {
 	}
 	// If we overflow, return `x`, as the number of digits to the right of the decimal is too small (i.e., `x` is too large / lacks sufficient fractional precision) for there to be any effect when rounding...
 	if ( n < STDLIB_CONSTANT_FLOAT64_MIN_BASE10_EXPONENT ){
-		s = pow( 10.0, -( n + STDLIB_CONSTANT_FLOAT64_MAX_BASE10_EXPONENT ) );  // TODO: replace use of `pow` once have stdlib equivalent
+		s = stdlib_base_pow( 10.0, -( n + STDLIB_CONSTANT_FLOAT64_MAX_BASE10_EXPONENT ) );
 		y = ( x * HUGE_VALUE ) * s; // order of operation matters!
 		if ( stdlib_base_is_infinite( y ) ){
 			return x;
 		}
 		return ( stdlib_base_round( y ) / HUGE_VALUE ) / s;
 	}
-	s = pow( 10.0, -n );  // TODO: replace use of `pow` once have stdlib equivalent
+	s = stdlib_base_pow( 10.0, -n );
 	y = x * s;
 	if ( stdlib_base_is_infinite( y ) ){
 		return x;

From abf99695e39313d7a9348c82b3b5d794b6cdf84a Mon Sep 17 00:00:00 2001
From: Athan Reines <kgryte@gmail.com>
Date: Tue, 9 Jul 2024 00:38:58 -0700
Subject: [PATCH 10/16] fix: update variable name

---
 .../@stdlib/blas/base/dznrm2/docs/types/index.d.ts            | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/base/dznrm2/docs/types/index.d.ts
index 76c7073965e2..6762509746bc 100644
--- a/lib/node_modules/@stdlib/blas/base/dznrm2/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/docs/types/index.d.ts
@@ -42,7 +42,7 @@ interface Routine {
 	* var norm = dznrm2( 4, zx, 1 );
 	* // returns ~0.8
 	*/
-	( N: number, x: Complex128Array, strideX: number ): number;
+	( N: number, zx: Complex128Array, strideX: number ): number;
 
 	/**
 	* Computes the L2-norm of a complex double-precision floating-point vector using alternative indexing semantics.
@@ -61,7 +61,7 @@ interface Routine {
 	* var norm = dznrm2.ndarray( 4, zx, 1, 0 );
 	* // returns ~0.8
 	*/
-	ndarray( N: number, x: Complex128Array, strideX: number, offsetX: number ): number;
+	ndarray( N: number, zx: Complex128Array, strideX: number, offsetX: number ): number;
 }
 
 /**

From c38be491330a6b2c81f8ab210672f0de4a882a7b Mon Sep 17 00:00:00 2001
From: Athan Reines <kgryte@gmail.com>
Date: Tue, 9 Jul 2024 00:39:22 -0700
Subject: [PATCH 11/16] docs: fix text wrapping

---
 lib/node_modules/@stdlib/blas/base/dznrm2/docs/repl.txt | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/docs/repl.txt b/lib/node_modules/@stdlib/blas/base/dznrm2/docs/repl.txt
index 6885dc313541..953cdd9b4105 100644
--- a/lib/node_modules/@stdlib/blas/base/dznrm2/docs/repl.txt
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/docs/repl.txt
@@ -1,7 +1,6 @@
 
 {{alias}}( N, zx, strideX )
-    Computes the L2-norm of a complex double-precision floating-point
-    vector.
+    Computes the L2-norm of a complex double-precision floating-point vector.
 
     The `N` and stride parameters determine which elements in the strided array
     are accessed at runtime.

From c0eb70eca65415c2e6074cb4079d68555d77486d Mon Sep 17 00:00:00 2001
From: Athan Reines <kgryte@gmail.com>
Date: Tue, 9 Jul 2024 00:41:15 -0700
Subject: [PATCH 12/16] docs: update variable names

---
 .../@stdlib/blas/base/dznrm2/docs/repl.txt     | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/docs/repl.txt b/lib/node_modules/@stdlib/blas/base/dznrm2/docs/repl.txt
index 953cdd9b4105..a62ab64253a5 100644
--- a/lib/node_modules/@stdlib/blas/base/dznrm2/docs/repl.txt
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/docs/repl.txt
@@ -23,14 +23,14 @@
 
     Returns
     -------
-    norm: number
+    out: number
         L2-norm.
 
     Examples
     --------
     // Standard Usage:
     > var zx = new {{alias:@stdlib/array/complex128}}( [ 0.3, 0.1, 0.5, 0.0, 0.0, 0.5 ] );
-    > var norm = {{alias}}( 3, zx, 1 )
+    > var out = {{alias}}( 3, zx, 1 )
     ~0.77
 
     // Using `N` and stride parameters:
@@ -41,17 +41,17 @@
     // Using view offsets:
     > var zx0 = new {{alias:@stdlib/array/complex128}}( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );
     > var zx1 = new {{alias:@stdlib/array/complex128}}( zx0.buffer, zx0.BYTES_PER_ELEMENT*1 );
-    > norm = {{alias}}( 2, zx1, 1 )
+    > out = {{alias}}( 2, zx1, 1 )
     ~9.3
 
 
 {{alias}}.ndarray( N, zx, strideX, offsetX )
-    Computes the L2-norm of a complex double-precision floating-point
-    vector using alternative indexing semantics.
+    Computes the L2-norm of a complex double-precision floating-point vector
+    using alternative indexing semantics.
 
     While typed array views mandate a view offset based on the underlying
-    buffer, the `offsetX` parameter supports indexing semantics based on a
-    starting index.
+    buffer, the offset parameter supports indexing semantics based on a starting
+    index.
 
     Parameters
     ----------
@@ -69,7 +69,7 @@
 
     Returns
     -------
-    norm: number
+    out: number
         L2-norm.
 
     Examples
@@ -81,7 +81,7 @@
 
     // Using an index offset:
     > zx = new {{alias:@stdlib/array/complex128}}( [ 1.0, -2.0, 3.0, -4.0, 5.0, -6.0 ] );
-    > norm = {{alias}}.ndarray( 2, zx, 1, 1 )
+    > out = {{alias}}.ndarray( 2, zx, 1, 1 )
     ~9.3
 
     See Also

From d99cfa53d1f63db69d5aa6766352ec40f51e62dd Mon Sep 17 00:00:00 2001
From: Athan Reines <kgryte@gmail.com>
Date: Tue, 9 Jul 2024 00:45:55 -0700
Subject: [PATCH 13/16] refactor: use utility to resolve offset

---
 .../@stdlib/blas/base/dznrm2/lib/dznrm2.js           | 12 ++----------
 1 file changed, 2 insertions(+), 10 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/lib/dznrm2.js b/lib/node_modules/@stdlib/blas/base/dznrm2/lib/dznrm2.js
index 832556fd9e6a..bc7bc6c633cd 100644
--- a/lib/node_modules/@stdlib/blas/base/dznrm2/lib/dznrm2.js
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/lib/dznrm2.js
@@ -20,6 +20,7 @@
 
 // MODULES //
 
+var stride2offset = require( '@stdlib/strided/base/stride2offset' );
 var ndarray = require( './ndarray.js' );
 
 
@@ -42,16 +43,7 @@ var ndarray = require( './ndarray.js' );
 * // returns ~0.8
 */
 function dznrm2( N, zx, strideX ) {
-	var ox;
-	if ( N <= 0 ) {
-		return 0.0;
-	}
-	if ( strideX < 0 ) {
-		ox = ( 1 - N ) * strideX;
-	} else {
-		ox = 0;
-	}
-	return ndarray( N, zx, strideX, ox );
+	return ndarray( N, zx, strideX, stride2offset( N, strideX ) );
 }
 
 

From 589a7043f79f76a6883dfd7b6ec13c02ae7838f5 Mon Sep 17 00:00:00 2001
From: Athan Reines <kgryte@gmail.com>
Date: Tue, 9 Jul 2024 00:49:32 -0700
Subject: [PATCH 14/16] docs: fix description and remove unnecessary
 parentheses

---
 .../@stdlib/blas/base/dznrm2/lib/ndarray.js          | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/lib/ndarray.js b/lib/node_modules/@stdlib/blas/base/dznrm2/lib/ndarray.js
index 2873ef15e6a5..a615def8c1fa 100644
--- a/lib/node_modules/@stdlib/blas/base/dznrm2/lib/ndarray.js
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/lib/ndarray.js
@@ -39,7 +39,7 @@ var sbig = 1.1113793747425387E-162;
 // MAIN //
 
 /**
-* Computes the L2-norm of a complex single-precision floating-point vector.
+* Computes the L2-norm of a complex double-precision floating-point vector.
 *
 * @param {PositiveInteger} N - number of indexed elements
 * @param {Complex128Array} zx - input array
@@ -98,7 +98,7 @@ function dznrm2( N, zx, strideX, offsetX ) {
 				asml += abs2( ax * ssml );
 			}
 		} else {
-			amed += ( ax * ax );
+			amed += ax * ax;
 		}
 		ax = abs( viewX[ ix + 1 ] );
 		if ( ax > tbig ) {
@@ -109,7 +109,7 @@ function dznrm2( N, zx, strideX, offsetX ) {
 				asml += abs2( ax * ssml );
 			}
 		} else {
-			amed += ( ax * ax );
+			amed += ax * ax;
 		}
 		ix += sx;
 	}
@@ -117,9 +117,9 @@ function dznrm2( N, zx, strideX, offsetX ) {
 	if ( abig > 0.0 ) {
 		// Combine `abig` and `amed` if `abig` > 0...
 		if ( amed > 0.0 || ( amed > FLOAT64_MAX ) || ( amed !== amed ) ) {
-			abig += ( ( amed * sbig ) * sbig );
+			abig += ( amed * sbig ) * sbig;
 		}
-		scl = ( 1.0 / sbig );
+		scl = 1.0 / sbig;
 		sumsq = abig;
 	} else if ( asml > 0.0 ) {
 		// Combine `amed` and `asml` if `asml` > 0...
@@ -136,7 +136,7 @@ function dznrm2( N, zx, strideX, offsetX ) {
 			scl = 1.0;
 			sumsq = ( ymax * ymax ) * ( 1.0 + abs2( ymin / ymax ) );
 		} else {
-			scl = ( 1.0 / ssml );
+			scl = 1.0 / ssml;
 			sumsq = asml;
 		}
 	} else {

From 50fd6f2dd68223e9d221b16381393a0bb1bea96f Mon Sep 17 00:00:00 2001
From: Athan Reines <kgryte@gmail.com>
Date: Tue, 9 Jul 2024 00:55:44 -0700
Subject: [PATCH 15/16] fix: use `d*` intrinsics

---
 .../@stdlib/blas/base/dznrm2/src/dznrm2.f     | 20 +++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2.f b/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2.f
index 32e1da4b0943..7e4c5bce8f3d 100644
--- a/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2.f
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2.f
@@ -60,10 +60,10 @@ double precision function dznrm2( N, zx, strideX )
   real( wp ), parameter :: maxN = huge( 0.0_wp )
   ! ..
   ! Blue's scaling constants:
-  real(wp), parameter :: tsml = 1.4916681462400413e-154_wp
-  real(wp), parameter :: tbig = 1.9979190722022350e146_wp
-  real(wp), parameter :: ssml = 4.4989137945431964e161_wp
-  real(wp), parameter :: sbig = 1.1113793747425387e-162_wp
+  real( wp ), parameter :: tsml = 1.4916681462400413e-154_wp
+  real( wp ), parameter :: tbig = 1.9979190722022350e146_wp
+  real( wp ), parameter :: ssml = 4.4989137945431964e161_wp
+  real( wp ), parameter :: sbig = 1.1113793747425387e-162_wp
   !..
   ! Scalar arguments:
   integer :: N, strideX
@@ -77,7 +77,7 @@ double precision function dznrm2( N, zx, strideX )
   real( wp ) :: abig, amed, asml, ax, scl, sumsq, ymax, ymin
   ! ..
   ! Intrinsic functions:
-  intrinsic abs, sqrt
+  intrinsic dabs, dsqrt
   ! ..
   dznrm2 = zero
   ! ..
@@ -104,7 +104,7 @@ double precision function dznrm2( N, zx, strideX )
   end if
   ! ..
   do i = 1, N
-    ax = abs( real( zx( ix ) ) )
+    ax = dabs( real( zx( ix ) ) )
     if ( ax > tbig ) then
       abig = abig + ( ax * sbig )**2
       notbig = .false.
@@ -115,7 +115,7 @@ double precision function dznrm2( N, zx, strideX )
     else
       amed = amed + ax**2
     end if
-    ax = abs( aimag( zx( ix ) ) )
+    ax = dabs( aimag( zx( ix ) ) )
     if ( ax > tbig ) then
       abig = abig + ( ax * sbig )**2
       notbig = .false.
@@ -140,8 +140,8 @@ double precision function dznrm2( N, zx, strideX )
   else if ( asml > zero ) then
     ! Combine amed and asml if asml > 0...
     if ( ( amed > zero ) .or. ( amed > maxN ) .or. ( amed /= amed ) ) then
-      amed = sqrt( amed )
-      asml = sqrt( asml ) / ssml
+      amed = dsqrt( amed )
+      asml = dsqrt( asml ) / ssml
       if ( asml > amed ) then
         ymin = amed
         ymax = asml
@@ -160,6 +160,6 @@ double precision function dznrm2( N, zx, strideX )
     scl = one
     sumsq = amed
   end if
-  dznrm2 = scl * sqrt( sumsq )
+  dznrm2 = scl * dsqrt( sumsq )
   return
 end function dznrm2
\ No newline at end of file

From a461b1b601acbae45af0a0f5ab4982e4a4976d11 Mon Sep 17 00:00:00 2001
From: Athan Reines <kgryte@gmail.com>
Date: Tue, 9 Jul 2024 00:58:47 -0700
Subject: [PATCH 16/16] revert: use generics

---
 .../@stdlib/blas/base/dznrm2/src/dznrm2.f            | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2.f b/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2.f
index 7e4c5bce8f3d..05d821fb43c9 100644
--- a/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2.f
+++ b/lib/node_modules/@stdlib/blas/base/dznrm2/src/dznrm2.f
@@ -77,7 +77,7 @@ double precision function dznrm2( N, zx, strideX )
   real( wp ) :: abig, amed, asml, ax, scl, sumsq, ymax, ymin
   ! ..
   ! Intrinsic functions:
-  intrinsic dabs, dsqrt
+  intrinsic abs, sqrt
   ! ..
   dznrm2 = zero
   ! ..
@@ -104,7 +104,7 @@ double precision function dznrm2( N, zx, strideX )
   end if
   ! ..
   do i = 1, N
-    ax = dabs( real( zx( ix ) ) )
+    ax = abs( real( zx( ix ) ) )
     if ( ax > tbig ) then
       abig = abig + ( ax * sbig )**2
       notbig = .false.
@@ -115,7 +115,7 @@ double precision function dznrm2( N, zx, strideX )
     else
       amed = amed + ax**2
     end if
-    ax = dabs( aimag( zx( ix ) ) )
+    ax = abs( aimag( zx( ix ) ) )
     if ( ax > tbig ) then
       abig = abig + ( ax * sbig )**2
       notbig = .false.
@@ -140,8 +140,8 @@ double precision function dznrm2( N, zx, strideX )
   else if ( asml > zero ) then
     ! Combine amed and asml if asml > 0...
     if ( ( amed > zero ) .or. ( amed > maxN ) .or. ( amed /= amed ) ) then
-      amed = dsqrt( amed )
-      asml = dsqrt( asml ) / ssml
+      amed = sqrt( amed )
+      asml = sqrt( asml ) / ssml
       if ( asml > amed ) then
         ymin = amed
         ymax = asml
@@ -160,6 +160,6 @@ double precision function dznrm2( N, zx, strideX )
     scl = one
     sumsq = amed
   end if
-  dznrm2 = scl * dsqrt( sumsq )
+  dznrm2 = scl * sqrt( sumsq )
   return
 end function dznrm2
\ No newline at end of file