From 3417fdc326c82c87fd9551c02416e4334cdcdd97 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sun, 13 Sep 2026 18:25:19 +0000
Subject: [PATCH 1/6] test: migrate `blas/base/zdrot` to ULP-based assertions

Ref: https://github.com/stdlib-js/stdlib/issues/11352

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QCuBBb9N9TCMg49xnkeVSM
---
 .../blas/base/zdrot/test/test.ndarray.js      | 66 +++++++++++--------
 .../base/zdrot/test/test.ndarray.native.js    | 66 +++++++++++--------
 .../blas/base/zdrot/test/test.zdrot.js        | 59 ++++++++++-------
 .../blas/base/zdrot/test/test.zdrot.native.js | 59 ++++++++++-------
 4 files changed, 146 insertions(+), 104 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js
index c940adafd196..0e76b7dfcd20 100644
--- a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js
@@ -23,8 +23,7 @@
 var tape = require( 'tape' );
 var Float64Array = require( '@stdlib/array/float64' );
 var Complex128Array = require( '@stdlib/array/complex128' );
-var EPS = require( '@stdlib/constants/float64/eps' );
-var abs = require( '@stdlib/math/base/special/abs' );
+var isAlmostSameValue = require( '@stdlib/assert/is-almost-same-value' );
 var zdrot = require( './../lib/ndarray.js' );
 
 
@@ -37,22 +36,14 @@ var zdrot = require( './../lib/ndarray.js' );
 * @param {Object} t - test object
 * @param {Collection} actual - actual values
 * @param {Collection} expected - expected values
-* @param {number} rtol - relative tolerance
+* @param {NonNegativeInteger} ulp - maximum allowed ULP difference
 */
-function isApprox( t, actual, expected, rtol ) {
-	var delta;
-	var tol;
+function isApprox( t, actual, expected, ulp ) {
 	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+'.' );
-		}
+		t.strictEqual( isAlmostSameValue( actual[ i ], expected[ i ], ulp ), true, 'returns expected value' );
 	}
 }
 
@@ -74,11 +65,14 @@ tape( 'the function applies a plane rotation', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 1
 		2.0, // 1
@@ -125,8 +119,8 @@ tape( 'the function applies a plane rotation', function test( t ) {
 	]);
 
 	out = zdrot( x.length, x, 1, 0, y, 1, 0, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -135,11 +129,14 @@ tape( 'the function supports an `x` stride', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 1
 		2.0, // 1
@@ -186,8 +183,8 @@ tape( 'the function supports an `x` stride', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, 0, y, 1, 0, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -196,11 +193,14 @@ tape( 'the function supports an `x` offset', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0,
 		2.0,
@@ -247,8 +247,8 @@ tape( 'the function supports an `x` offset', function test( t ) {
 	]);
 
 	out = zdrot( 3, x, 1, 1, y, 1, 0, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -257,11 +257,14 @@ tape( 'the function supports a `y` stride', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 1
 		2.0, // 1
@@ -308,8 +311,8 @@ tape( 'the function supports a `y` stride', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 1, 0, y, 2, 0, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -318,11 +321,14 @@ tape( 'the function supports a `y` offset', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 1
 		2.0, // 1
@@ -369,8 +375,8 @@ tape( 'the function supports a `y` offset', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, 0, y, -1, 1, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -421,11 +427,14 @@ tape( 'the function supports negative strides', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 2
 		2.0, // 2
@@ -472,8 +481,8 @@ tape( 'the function supports negative strides', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, -1, 1, y, -2, 2, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -482,11 +491,14 @@ tape( 'the function supports complex access patterns', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 1
 		2.0, // 1
@@ -533,8 +545,8 @@ tape( 'the function supports complex access patterns', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, 1, y, 1, 2, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.native.js b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.native.js
index 30c5fe0f7b97..653c55836c33 100644
--- a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.native.js
+++ b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.native.js
@@ -24,8 +24,7 @@ var resolve = require( 'path' ).resolve;
 var tape = require( 'tape' );
 var Float64Array = require( '@stdlib/array/float64' );
 var Complex128Array = require( '@stdlib/array/complex128' );
-var EPS = require( '@stdlib/constants/float64/eps' );
-var abs = require( '@stdlib/math/base/special/abs' );
+var isAlmostSameValue = require( '@stdlib/assert/is-almost-same-value' );
 var tryRequire = require( '@stdlib/utils/try-require' );
 
 
@@ -46,22 +45,14 @@ var opts = {
 * @param {Object} t - test object
 * @param {Collection} actual - actual values
 * @param {Collection} expected - expected values
-* @param {number} rtol - relative tolerance
+* @param {NonNegativeInteger} ulp - maximum allowed ULP difference
 */
-function isApprox( t, actual, expected, rtol ) {
-	var delta;
-	var tol;
+function isApprox( t, actual, expected, ulp ) {
 	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+'.' );
-		}
+		t.strictEqual( isAlmostSameValue( actual[ i ], expected[ i ], ulp ), true, 'returns expected value' );
 	}
 }
 
@@ -83,11 +74,14 @@ tape( 'the function applies a plane rotation', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 1
 		2.0, // 1
@@ -134,8 +128,8 @@ tape( 'the function applies a plane rotation', opts, function test( t ) {
 	]);
 
 	out = zdrot( x.length, x, 1, 0, y, 1, 0, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -144,11 +138,14 @@ tape( 'the function supports an `x` stride', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 1
 		2.0, // 1
@@ -195,8 +192,8 @@ tape( 'the function supports an `x` stride', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, 0, y, 1, 0, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -205,11 +202,14 @@ tape( 'the function supports an `x` offset', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0,
 		2.0,
@@ -256,8 +256,8 @@ tape( 'the function supports an `x` offset', opts, function test( t ) {
 	]);
 
 	out = zdrot( 3, x, 1, 1, y, 1, 0, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -266,11 +266,14 @@ tape( 'the function supports a `y` stride', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 1
 		2.0, // 1
@@ -317,8 +320,8 @@ tape( 'the function supports a `y` stride', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 1, 0, y, 2, 0, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -327,11 +330,14 @@ tape( 'the function supports a `y` offset', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 1
 		2.0, // 1
@@ -378,8 +384,8 @@ tape( 'the function supports a `y` offset', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, 0, y, -1, 1, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -430,11 +436,14 @@ tape( 'the function supports negative strides', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 2
 		2.0, // 2
@@ -481,8 +490,8 @@ tape( 'the function supports negative strides', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x, -1, 1, y, -2, 2, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -491,11 +500,14 @@ tape( 'the function supports complex access patterns', opts, function test( t )
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 1
 		2.0, // 1
@@ -542,8 +554,8 @@ tape( 'the function supports complex access patterns', opts, function test( t )
 	]);
 
 	out = zdrot( 2, x, 2, 1, y, 1, 2, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js
index 08dd719cc6b0..698a5587564e 100644
--- a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js
+++ b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js
@@ -23,8 +23,7 @@
 var tape = require( 'tape' );
 var Float64Array = require( '@stdlib/array/float64' );
 var Complex128Array = require( '@stdlib/array/complex128' );
-var EPS = require( '@stdlib/constants/float64/eps' );
-var abs = require( '@stdlib/math/base/special/abs' );
+var isAlmostSameValue = require( '@stdlib/assert/is-almost-same-value' );
 var zdrot = require( './../lib/zdrot.js' );
 
 
@@ -37,22 +36,14 @@ var zdrot = require( './../lib/zdrot.js' );
 * @param {Object} t - test object
 * @param {Collection} actual - actual values
 * @param {Collection} expected - expected values
-* @param {number} rtol - relative tolerance
+* @param {NonNegativeInteger} ulp - maximum allowed ULP difference
 */
-function isApprox( t, actual, expected, rtol ) {
-	var delta;
-	var tol;
+function isApprox( t, actual, expected, ulp ) {
 	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+'.' );
-		}
+		t.strictEqual( isAlmostSameValue( actual[ i ], expected[ i ], ulp ), true, 'returns expected value' );
 	}
 }
 
@@ -74,11 +65,14 @@ tape( 'the function applies a plane rotation', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 1
 		2.0, // 1
@@ -125,8 +119,8 @@ tape( 'the function applies a plane rotation', function test( t ) {
 	]);
 
 	out = zdrot( x.length, x, 1, y, 1, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -135,11 +129,14 @@ tape( 'the function supports an `x` stride', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 1
 		2.0, // 1
@@ -186,8 +183,8 @@ tape( 'the function supports an `x` stride', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, y, 1, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -196,11 +193,14 @@ tape( 'the function supports a `y` stride', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 1
 		2.0, // 1
@@ -247,8 +247,8 @@ tape( 'the function supports a `y` stride', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 1, y, 2, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -299,11 +299,14 @@ tape( 'the function supports negative strides', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 2
 		2.0, // 2
@@ -350,8 +353,8 @@ tape( 'the function supports negative strides', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, -1, y, -2, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -360,11 +363,14 @@ tape( 'the function supports complex access patterns', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 1
 		2.0, // 1
@@ -411,8 +417,8 @@ tape( 'the function supports complex access patterns', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, y, -1, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -421,6 +427,7 @@ tape( 'the function supports view offsets', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var x0;
 	var y0;
 	var x1;
@@ -428,6 +435,8 @@ tape( 'the function supports view offsets', function test( t ) {
 	var xe;
 	var ye;
 
+	ULP = 1;
+
 	// Initial arrays...
 	x0 = new Complex128Array([
 		1.0,
@@ -479,8 +488,8 @@ tape( 'the function supports view offsets', function test( t ) {
 	]);
 
 	out = zdrot( 2, x1, -2, y1, 1, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y1, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.native.js b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.native.js
index 4acdcfcde091..edc16b2f9384 100644
--- a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.native.js
+++ b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.native.js
@@ -24,8 +24,7 @@ var resolve = require( 'path' ).resolve;
 var tape = require( 'tape' );
 var Float64Array = require( '@stdlib/array/float64' );
 var Complex128Array = require( '@stdlib/array/complex128' );
-var EPS = require( '@stdlib/constants/float64/eps' );
-var abs = require( '@stdlib/math/base/special/abs' );
+var isAlmostSameValue = require( '@stdlib/assert/is-almost-same-value' );
 var tryRequire = require( '@stdlib/utils/try-require' );
 
 
@@ -46,22 +45,14 @@ var opts = {
 * @param {Object} t - test object
 * @param {Collection} actual - actual values
 * @param {Collection} expected - expected values
-* @param {number} rtol - relative tolerance
+* @param {NonNegativeInteger} ulp - maximum allowed ULP difference
 */
-function isApprox( t, actual, expected, rtol ) {
-	var delta;
-	var tol;
+function isApprox( t, actual, expected, ulp ) {
 	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+'.' );
-		}
+		t.strictEqual( isAlmostSameValue( actual[ i ], expected[ i ], ulp ), true, 'returns expected value' );
 	}
 }
 
@@ -83,11 +74,14 @@ tape( 'the function applies a plane rotation', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 1
 		2.0, // 1
@@ -134,8 +128,8 @@ tape( 'the function applies a plane rotation', opts, function test( t ) {
 	]);
 
 	out = zdrot( x.length, x, 1, y, 1, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -144,11 +138,14 @@ tape( 'the function supports an `x` stride', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 1
 		2.0, // 1
@@ -195,8 +192,8 @@ tape( 'the function supports an `x` stride', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, y, 1, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -205,11 +202,14 @@ tape( 'the function supports a `y` stride', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 1
 		2.0, // 1
@@ -256,8 +256,8 @@ tape( 'the function supports a `y` stride', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 1, y, 2, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -308,11 +308,14 @@ tape( 'the function supports negative strides', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 2
 		2.0, // 2
@@ -359,8 +362,8 @@ tape( 'the function supports negative strides', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x, -1, y, -2, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -369,11 +372,14 @@ tape( 'the function supports complex access patterns', opts, function test( t )
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
 
+	ULP = 1;
+
 	x = new Complex128Array([
 		1.0, // 1
 		2.0, // 1
@@ -420,8 +426,8 @@ tape( 'the function supports complex access patterns', opts, function test( t )
 	]);
 
 	out = zdrot( 2, x, 2, y, -1, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -430,6 +436,7 @@ tape( 'the function supports view offsets', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
+	var ULP;
 	var x0;
 	var y0;
 	var x1;
@@ -437,6 +444,8 @@ tape( 'the function supports view offsets', opts, function test( t ) {
 	var xe;
 	var ye;
 
+	ULP = 1;
+
 	// Initial arrays...
 	x0 = new Complex128Array([
 		1.0,
@@ -488,8 +497,8 @@ tape( 'the function supports view offsets', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x1, -2, y1, 1, 0.8, 0.6 );
-	isApprox( t, viewX, xe, 2.0 );
-	isApprox( t, viewY, ye, 2.0 );
+	isApprox( t, viewX, xe, ULP );
+	isApprox( t, viewY, ye, ULP );
 	t.strictEqual( out, y1, 'returns expected value' );
 	t.end();
 });

From 84f397ce25b2cee05c881dc38b5ed7b8817716ba Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Mon, 21 Sep 2026 23:19:52 -0500
Subject: [PATCH 2/6] refactor: inline ULP values and remove isApprox helper

Address review feedback by removing the isApprox helper function
and inlining isAlmostSameValue assertions directly at each call site.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../blas/base/zdrot/test/test.ndarray.js      | 120 ++++++++---------
 .../base/zdrot/test/test.ndarray.native.js    | 121 +++++++++---------
 .../blas/base/zdrot/test/test.zdrot.js        | 106 +++++++--------
 .../blas/base/zdrot/test/test.zdrot.native.js | 107 ++++++++--------
 4 files changed, 234 insertions(+), 220 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js
index 0e76b7dfcd20..506fc717024d 100644
--- a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js
@@ -26,28 +26,6 @@ var Complex128Array = require( '@stdlib/array/complex128' );
 var isAlmostSameValue = require( '@stdlib/assert/is-almost-same-value' );
 var zdrot = 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 {NonNegativeInteger} ulp - maximum allowed ULP difference
-*/
-function isApprox( t, actual, expected, ulp ) {
-	var i;
-
-	t.strictEqual( actual.length, expected.length, 'returns expected value' );
-	for ( i = 0; i < expected.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( actual[ i ], expected[ i ], ulp ), true, 'returns expected value' );
-	}
-}
-
-
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {
@@ -65,13 +43,11 @@ tape( 'the function applies a plane rotation', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -119,8 +95,14 @@ tape( 'the function applies a plane rotation', function test( t ) {
 	]);
 
 	out = zdrot( x.length, x, 1, 0, y, 1, 0, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -129,13 +111,11 @@ tape( 'the function supports an `x` stride', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -183,8 +163,14 @@ tape( 'the function supports an `x` stride', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, 0, y, 1, 0, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -193,13 +179,11 @@ tape( 'the function supports an `x` offset', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0,
@@ -247,8 +231,14 @@ tape( 'the function supports an `x` offset', function test( t ) {
 	]);
 
 	out = zdrot( 3, x, 1, 1, y, 1, 0, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -257,13 +247,11 @@ tape( 'the function supports a `y` stride', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -311,8 +299,14 @@ tape( 'the function supports a `y` stride', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 1, 0, y, 2, 0, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -321,13 +315,11 @@ tape( 'the function supports a `y` offset', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -375,8 +367,14 @@ tape( 'the function supports a `y` offset', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, 0, y, -1, 1, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -427,13 +425,11 @@ tape( 'the function supports negative strides', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 2
@@ -481,8 +477,14 @@ tape( 'the function supports negative strides', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, -1, 1, y, -2, 2, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -491,13 +493,11 @@ tape( 'the function supports complex access patterns', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -545,8 +545,14 @@ tape( 'the function supports complex access patterns', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, 1, y, 1, 2, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.native.js b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.native.js
index 653c55836c33..d4546159eaa4 100644
--- a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.native.js
+++ b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.native.js
@@ -27,7 +27,6 @@ var Complex128Array = require( '@stdlib/array/complex128' );
 var isAlmostSameValue = require( '@stdlib/assert/is-almost-same-value' );
 var tryRequire = require( '@stdlib/utils/try-require' );
 
-
 // VARIABLES //
 
 var zdrot = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) );
@@ -35,28 +34,6 @@ var opts = {
 	'skip': ( zdrot 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 {NonNegativeInteger} ulp - maximum allowed ULP difference
-*/
-function isApprox( t, actual, expected, ulp ) {
-	var i;
-
-	t.strictEqual( actual.length, expected.length, 'returns expected value' );
-	for ( i = 0; i < expected.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( actual[ i ], expected[ i ], ulp ), true, 'returns expected value' );
-	}
-}
-
-
 // TESTS //
 
 tape( 'main export is a function', opts, function test( t ) {
@@ -74,13 +51,11 @@ tape( 'the function applies a plane rotation', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -128,8 +103,14 @@ tape( 'the function applies a plane rotation', opts, function test( t ) {
 	]);
 
 	out = zdrot( x.length, x, 1, 0, y, 1, 0, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -138,13 +119,11 @@ tape( 'the function supports an `x` stride', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -192,8 +171,14 @@ tape( 'the function supports an `x` stride', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, 0, y, 1, 0, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -202,13 +187,11 @@ tape( 'the function supports an `x` offset', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0,
@@ -256,8 +239,14 @@ tape( 'the function supports an `x` offset', opts, function test( t ) {
 	]);
 
 	out = zdrot( 3, x, 1, 1, y, 1, 0, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -266,13 +255,11 @@ tape( 'the function supports a `y` stride', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -320,8 +307,14 @@ tape( 'the function supports a `y` stride', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 1, 0, y, 2, 0, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -330,13 +323,11 @@ tape( 'the function supports a `y` offset', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -384,8 +375,14 @@ tape( 'the function supports a `y` offset', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, 0, y, -1, 1, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -436,13 +433,11 @@ tape( 'the function supports negative strides', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 2
@@ -490,8 +485,14 @@ tape( 'the function supports negative strides', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x, -1, 1, y, -2, 2, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -500,13 +501,11 @@ tape( 'the function supports complex access patterns', opts, function test( t )
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -554,8 +553,14 @@ tape( 'the function supports complex access patterns', opts, function test( t )
 	]);
 
 	out = zdrot( 2, x, 2, 1, y, 1, 2, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js
index 698a5587564e..06b319308439 100644
--- a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js
+++ b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js
@@ -26,28 +26,6 @@ var Complex128Array = require( '@stdlib/array/complex128' );
 var isAlmostSameValue = require( '@stdlib/assert/is-almost-same-value' );
 var zdrot = require( './../lib/zdrot.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 {NonNegativeInteger} ulp - maximum allowed ULP difference
-*/
-function isApprox( t, actual, expected, ulp ) {
-	var i;
-
-	t.strictEqual( actual.length, expected.length, 'returns expected value' );
-	for ( i = 0; i < expected.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( actual[ i ], expected[ i ], ulp ), true, 'returns expected value' );
-	}
-}
-
-
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {
@@ -65,13 +43,11 @@ tape( 'the function applies a plane rotation', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -119,8 +95,14 @@ tape( 'the function applies a plane rotation', function test( t ) {
 	]);
 
 	out = zdrot( x.length, x, 1, y, 1, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -129,13 +111,11 @@ tape( 'the function supports an `x` stride', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -183,8 +163,14 @@ tape( 'the function supports an `x` stride', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, y, 1, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -193,13 +179,11 @@ tape( 'the function supports a `y` stride', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -247,8 +231,14 @@ tape( 'the function supports a `y` stride', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 1, y, 2, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -299,13 +289,11 @@ tape( 'the function supports negative strides', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 2
@@ -353,8 +341,14 @@ tape( 'the function supports negative strides', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, -1, y, -2, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -363,13 +357,11 @@ tape( 'the function supports complex access patterns', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -417,8 +409,14 @@ tape( 'the function supports complex access patterns', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, y, -1, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -427,15 +425,13 @@ tape( 'the function supports view offsets', function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var x0;
 	var y0;
 	var x1;
 	var y1;
 	var xe;
 	var ye;
-
-	ULP = 1;
+	var i;
 
 	// Initial arrays...
 	x0 = new Complex128Array([
@@ -488,8 +484,14 @@ tape( 'the function supports view offsets', function test( t ) {
 	]);
 
 	out = zdrot( 2, x1, -2, y1, 1, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y1, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.native.js b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.native.js
index edc16b2f9384..a1fa65827337 100644
--- a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.native.js
+++ b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.native.js
@@ -27,7 +27,6 @@ var Complex128Array = require( '@stdlib/array/complex128' );
 var isAlmostSameValue = require( '@stdlib/assert/is-almost-same-value' );
 var tryRequire = require( '@stdlib/utils/try-require' );
 
-
 // VARIABLES //
 
 var zdrot = tryRequire( resolve( __dirname, './../lib/zdrot.native.js' ) );
@@ -35,28 +34,6 @@ var opts = {
 	'skip': ( zdrot 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 {NonNegativeInteger} ulp - maximum allowed ULP difference
-*/
-function isApprox( t, actual, expected, ulp ) {
-	var i;
-
-	t.strictEqual( actual.length, expected.length, 'returns expected value' );
-	for ( i = 0; i < expected.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( actual[ i ], expected[ i ], ulp ), true, 'returns expected value' );
-	}
-}
-
-
 // TESTS //
 
 tape( 'main export is a function', opts, function test( t ) {
@@ -74,13 +51,11 @@ tape( 'the function applies a plane rotation', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -128,8 +103,14 @@ tape( 'the function applies a plane rotation', opts, function test( t ) {
 	]);
 
 	out = zdrot( x.length, x, 1, y, 1, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -138,13 +119,11 @@ tape( 'the function supports an `x` stride', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -192,8 +171,14 @@ tape( 'the function supports an `x` stride', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, y, 1, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -202,13 +187,11 @@ tape( 'the function supports a `y` stride', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -256,8 +239,14 @@ tape( 'the function supports a `y` stride', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 1, y, 2, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -308,13 +297,11 @@ tape( 'the function supports negative strides', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 2
@@ -362,8 +349,14 @@ tape( 'the function supports negative strides', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x, -1, y, -2, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -372,13 +365,11 @@ tape( 'the function supports complex access patterns', opts, function test( t )
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var xe;
 	var ye;
 	var x;
 	var y;
-
-	ULP = 1;
+	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -426,8 +417,14 @@ tape( 'the function supports complex access patterns', opts, function test( t )
 	]);
 
 	out = zdrot( 2, x, 2, y, -1, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -436,15 +433,13 @@ tape( 'the function supports view offsets', opts, function test( t ) {
 	var viewX;
 	var viewY;
 	var out;
-	var ULP;
 	var x0;
 	var y0;
 	var x1;
 	var y1;
 	var xe;
 	var ye;
-
-	ULP = 1;
+	var i;
 
 	// Initial arrays...
 	x0 = new Complex128Array([
@@ -497,8 +492,14 @@ tape( 'the function supports view offsets', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x1, -2, y1, 1, 0.8, 0.6 );
-	isApprox( t, viewX, xe, ULP );
-	isApprox( t, viewY, ye, ULP );
+	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
+	for ( i = 0; i < xe.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
+	}
+	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
+	for ( i = 0; i < ye.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
+	}
 	t.strictEqual( out, y1, 'returns expected value' );
 	t.end();
 });

From f5523e6f119a5190a3bbc21fbcc696ad0f268da6 Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Mon, 21 Sep 2026 23:34:59 -0500
Subject: [PATCH 3/6] style: add missing blank line before section headers

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js | 1 +
 lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js   | 1 +
 2 files changed, 2 insertions(+)

diff --git a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js
index 506fc717024d..cba091e024fc 100644
--- a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js
@@ -26,6 +26,7 @@ var Complex128Array = require( '@stdlib/array/complex128' );
 var isAlmostSameValue = require( '@stdlib/assert/is-almost-same-value' );
 var zdrot = require( './../lib/ndarray.js' );
 
+
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {
diff --git a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js
index 06b319308439..c2dcf034f2f7 100644
--- a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js
+++ b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js
@@ -26,6 +26,7 @@ var Complex128Array = require( '@stdlib/array/complex128' );
 var isAlmostSameValue = require( '@stdlib/assert/is-almost-same-value' );
 var zdrot = require( './../lib/zdrot.js' );
 
+
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {

From 87f590f466b6d4b4c99bde31ec7e28438a5bf7ef Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Mon, 21 Sep 2026 23:47:50 -0500
Subject: [PATCH 4/6] style: add missing blank lines before section headers

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../@stdlib/blas/base/zdrot/test/test.ndarray.native.js         | 2 ++
 .../@stdlib/blas/base/zdrot/test/test.zdrot.native.js           | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.native.js b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.native.js
index d4546159eaa4..938e77a61fc7 100644
--- a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.native.js
+++ b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.native.js
@@ -27,6 +27,7 @@ var Complex128Array = require( '@stdlib/array/complex128' );
 var isAlmostSameValue = require( '@stdlib/assert/is-almost-same-value' );
 var tryRequire = require( '@stdlib/utils/try-require' );
 
+
 // VARIABLES //
 
 var zdrot = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) );
@@ -34,6 +35,7 @@ var opts = {
 	'skip': ( zdrot instanceof Error )
 };
 
+
 // TESTS //
 
 tape( 'main export is a function', opts, function test( t ) {
diff --git a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.native.js b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.native.js
index a1fa65827337..7ca87c8a4894 100644
--- a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.native.js
+++ b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.native.js
@@ -27,6 +27,7 @@ var Complex128Array = require( '@stdlib/array/complex128' );
 var isAlmostSameValue = require( '@stdlib/assert/is-almost-same-value' );
 var tryRequire = require( '@stdlib/utils/try-require' );
 
+
 // VARIABLES //
 
 var zdrot = tryRequire( resolve( __dirname, './../lib/zdrot.native.js' ) );
@@ -34,6 +35,7 @@ var opts = {
 	'skip': ( zdrot instanceof Error )
 };
 
+
 // TESTS //
 
 tape( 'main export is a function', opts, function test( t ) {

From 5bb106a514e9d5e046a58c51ac9aaeb929906a4f Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Tue, 22 Sep 2026 00:03:39 -0500
Subject: [PATCH 5/6] style: restore isApprox helper and inline ULP values per
 call site

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../blas/base/zdrot/test/test.ndarray.js      | 99 +++++++------------
 .../base/zdrot/test/test.ndarray.native.js    | 99 +++++++------------
 .../blas/base/zdrot/test/test.zdrot.js        | 88 +++++++----------
 .../blas/base/zdrot/test/test.zdrot.native.js | 88 +++++++----------
 4 files changed, 140 insertions(+), 234 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js
index cba091e024fc..9b3ebc765340 100644
--- a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js
@@ -27,6 +27,28 @@ var isAlmostSameValue = require( '@stdlib/assert/is-almost-same-value' );
 var zdrot = 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 {NonNegativeInteger} ulp - maximum allowed ULP difference
+*/
+function isApprox( t, actual, expected, ulp ) {
+	var i;
+
+	t.strictEqual( actual.length, expected.length, 'returns expected value' );
+	for ( i = 0; i < expected.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( actual[ i ], expected[ i ], ulp ), true, 'returns expected value' );
+	}
+}
+
+
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {
@@ -48,7 +70,6 @@ tape( 'the function applies a plane rotation', function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -96,14 +117,8 @@ tape( 'the function applies a plane rotation', function test( t ) {
 	]);
 
 	out = zdrot( x.length, x, 1, 0, y, 1, 0, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -116,7 +131,6 @@ tape( 'the function supports an `x` stride', function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -164,14 +178,8 @@ tape( 'the function supports an `x` stride', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, 0, y, 1, 0, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -184,7 +192,6 @@ tape( 'the function supports an `x` offset', function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0,
@@ -232,14 +239,8 @@ tape( 'the function supports an `x` offset', function test( t ) {
 	]);
 
 	out = zdrot( 3, x, 1, 1, y, 1, 0, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -252,7 +253,6 @@ tape( 'the function supports a `y` stride', function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -300,14 +300,8 @@ tape( 'the function supports a `y` stride', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 1, 0, y, 2, 0, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -320,7 +314,6 @@ tape( 'the function supports a `y` offset', function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -368,14 +361,8 @@ tape( 'the function supports a `y` offset', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, 0, y, -1, 1, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -430,7 +417,6 @@ tape( 'the function supports negative strides', function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 2
@@ -478,14 +464,8 @@ tape( 'the function supports negative strides', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, -1, 1, y, -2, 2, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -498,7 +478,6 @@ tape( 'the function supports complex access patterns', function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -546,14 +525,8 @@ tape( 'the function supports complex access patterns', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, 1, y, 1, 2, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.native.js b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.native.js
index 938e77a61fc7..cef76758566a 100644
--- a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.native.js
+++ b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.native.js
@@ -36,6 +36,28 @@ var opts = {
 };
 
 
+
+// FUNCTIONS //
+
+/**
+* Tests for element-wise approximate equality.
+*
+* @private
+* @param {Object} t - test object
+* @param {Collection} actual - actual values
+* @param {Collection} expected - expected values
+* @param {NonNegativeInteger} ulp - maximum allowed ULP difference
+*/
+function isApprox( t, actual, expected, ulp ) {
+	var i;
+
+	t.strictEqual( actual.length, expected.length, 'returns expected value' );
+	for ( i = 0; i < expected.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( actual[ i ], expected[ i ], ulp ), true, 'returns expected value' );
+	}
+}
+
+
 // TESTS //
 
 tape( 'main export is a function', opts, function test( t ) {
@@ -57,7 +79,6 @@ tape( 'the function applies a plane rotation', opts, function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -105,14 +126,8 @@ tape( 'the function applies a plane rotation', opts, function test( t ) {
 	]);
 
 	out = zdrot( x.length, x, 1, 0, y, 1, 0, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -125,7 +140,6 @@ tape( 'the function supports an `x` stride', opts, function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -173,14 +187,8 @@ tape( 'the function supports an `x` stride', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, 0, y, 1, 0, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -193,7 +201,6 @@ tape( 'the function supports an `x` offset', opts, function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0,
@@ -241,14 +248,8 @@ tape( 'the function supports an `x` offset', opts, function test( t ) {
 	]);
 
 	out = zdrot( 3, x, 1, 1, y, 1, 0, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -261,7 +262,6 @@ tape( 'the function supports a `y` stride', opts, function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -309,14 +309,8 @@ tape( 'the function supports a `y` stride', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 1, 0, y, 2, 0, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -329,7 +323,6 @@ tape( 'the function supports a `y` offset', opts, function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -377,14 +370,8 @@ tape( 'the function supports a `y` offset', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, 0, y, -1, 1, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -439,7 +426,6 @@ tape( 'the function supports negative strides', opts, function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 2
@@ -487,14 +473,8 @@ tape( 'the function supports negative strides', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x, -1, 1, y, -2, 2, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -507,7 +487,6 @@ tape( 'the function supports complex access patterns', opts, function test( t )
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -555,14 +534,8 @@ tape( 'the function supports complex access patterns', opts, function test( t )
 	]);
 
 	out = zdrot( 2, x, 2, 1, y, 1, 2, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js
index c2dcf034f2f7..2b95ea4e1d82 100644
--- a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js
+++ b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js
@@ -27,6 +27,28 @@ var isAlmostSameValue = require( '@stdlib/assert/is-almost-same-value' );
 var zdrot = require( './../lib/zdrot.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 {NonNegativeInteger} ulp - maximum allowed ULP difference
+*/
+function isApprox( t, actual, expected, ulp ) {
+	var i;
+
+	t.strictEqual( actual.length, expected.length, 'returns expected value' );
+	for ( i = 0; i < expected.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( actual[ i ], expected[ i ], ulp ), true, 'returns expected value' );
+	}
+}
+
+
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {
@@ -48,7 +70,6 @@ tape( 'the function applies a plane rotation', function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -96,14 +117,8 @@ tape( 'the function applies a plane rotation', function test( t ) {
 	]);
 
 	out = zdrot( x.length, x, 1, y, 1, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -116,7 +131,6 @@ tape( 'the function supports an `x` stride', function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -164,14 +178,8 @@ tape( 'the function supports an `x` stride', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, y, 1, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -184,7 +192,6 @@ tape( 'the function supports a `y` stride', function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -232,14 +239,8 @@ tape( 'the function supports a `y` stride', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 1, y, 2, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -294,7 +295,6 @@ tape( 'the function supports negative strides', function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 2
@@ -342,14 +342,8 @@ tape( 'the function supports negative strides', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, -1, y, -2, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -362,7 +356,6 @@ tape( 'the function supports complex access patterns', function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -410,14 +403,8 @@ tape( 'the function supports complex access patterns', function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, y, -1, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -432,7 +419,6 @@ tape( 'the function supports view offsets', function test( t ) {
 	var y1;
 	var xe;
 	var ye;
-	var i;
 
 	// Initial arrays...
 	x0 = new Complex128Array([
@@ -485,14 +471,8 @@ tape( 'the function supports view offsets', function test( t ) {
 	]);
 
 	out = zdrot( 2, x1, -2, y1, 1, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y1, 'returns expected value' );
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.native.js b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.native.js
index 7ca87c8a4894..5b0ce77cc59b 100644
--- a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.native.js
+++ b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.native.js
@@ -36,6 +36,28 @@ var opts = {
 };
 
 
+
+// FUNCTIONS //
+
+/**
+* Tests for element-wise approximate equality.
+*
+* @private
+* @param {Object} t - test object
+* @param {Collection} actual - actual values
+* @param {Collection} expected - expected values
+* @param {NonNegativeInteger} ulp - maximum allowed ULP difference
+*/
+function isApprox( t, actual, expected, ulp ) {
+	var i;
+
+	t.strictEqual( actual.length, expected.length, 'returns expected value' );
+	for ( i = 0; i < expected.length; i++ ) {
+		t.strictEqual( isAlmostSameValue( actual[ i ], expected[ i ], ulp ), true, 'returns expected value' );
+	}
+}
+
+
 // TESTS //
 
 tape( 'main export is a function', opts, function test( t ) {
@@ -57,7 +79,6 @@ tape( 'the function applies a plane rotation', opts, function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -105,14 +126,8 @@ tape( 'the function applies a plane rotation', opts, function test( t ) {
 	]);
 
 	out = zdrot( x.length, x, 1, y, 1, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -125,7 +140,6 @@ tape( 'the function supports an `x` stride', opts, function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -173,14 +187,8 @@ tape( 'the function supports an `x` stride', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 2, y, 1, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -193,7 +201,6 @@ tape( 'the function supports a `y` stride', opts, function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -241,14 +248,8 @@ tape( 'the function supports a `y` stride', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x, 1, y, 2, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -303,7 +304,6 @@ tape( 'the function supports negative strides', opts, function test( t ) {
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 2
@@ -351,14 +351,8 @@ tape( 'the function supports negative strides', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x, -1, y, -2, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -371,7 +365,6 @@ tape( 'the function supports complex access patterns', opts, function test( t )
 	var ye;
 	var x;
 	var y;
-	var i;
 
 	x = new Complex128Array([
 		1.0, // 1
@@ -419,14 +412,8 @@ tape( 'the function supports complex access patterns', opts, function test( t )
 	]);
 
 	out = zdrot( 2, x, 2, y, -1, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y, 'returns expected value' );
 	t.end();
 });
@@ -441,7 +428,6 @@ tape( 'the function supports view offsets', opts, function test( t ) {
 	var y1;
 	var xe;
 	var ye;
-	var i;
 
 	// Initial arrays...
 	x0 = new Complex128Array([
@@ -494,14 +480,8 @@ tape( 'the function supports view offsets', opts, function test( t ) {
 	]);
 
 	out = zdrot( 2, x1, -2, y1, 1, 0.8, 0.6 );
-	t.strictEqual( viewX.length, xe.length, 'returns expected value' );
-	for ( i = 0; i < xe.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewX[ i ], xe[ i ], 1 ), true, 'returns expected value' );
-	}
-	t.strictEqual( viewY.length, ye.length, 'returns expected value' );
-	for ( i = 0; i < ye.length; i++ ) {
-		t.strictEqual( isAlmostSameValue( viewY[ i ], ye[ i ], 1 ), true, 'returns expected value' );
-	}
+	isApprox( t, viewX, xe, 1 );
+	isApprox( t, viewY, ye, 1 );
 	t.strictEqual( out, y1, 'returns expected value' );
 	t.end();
 });

From ee934f431b3678ca7af37a33eacf77c6623a81ed Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Tue, 22 Sep 2026 00:09:38 -0500
Subject: [PATCH 6/6] style: fix blank lines before section headers

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js    | 1 -
 .../@stdlib/blas/base/zdrot/test/test.ndarray.native.js          | 1 -
 lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js      | 1 -
 .../@stdlib/blas/base/zdrot/test/test.zdrot.native.js            | 1 -
 4 files changed, 4 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js
index 9b3ebc765340..88410c0fff54 100644
--- a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.js
@@ -27,7 +27,6 @@ var isAlmostSameValue = require( '@stdlib/assert/is-almost-same-value' );
 var zdrot = require( './../lib/ndarray.js' );
 
 
-
 // FUNCTIONS //
 
 /**
diff --git a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.native.js b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.native.js
index cef76758566a..af2a09d69eb5 100644
--- a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.native.js
+++ b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.ndarray.native.js
@@ -36,7 +36,6 @@ var opts = {
 };
 
 
-
 // FUNCTIONS //
 
 /**
diff --git a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js
index 2b95ea4e1d82..fdbd57b99b9f 100644
--- a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js
+++ b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.js
@@ -27,7 +27,6 @@ var isAlmostSameValue = require( '@stdlib/assert/is-almost-same-value' );
 var zdrot = require( './../lib/zdrot.js' );
 
 
-
 // FUNCTIONS //
 
 /**
diff --git a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.native.js b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.native.js
index 5b0ce77cc59b..f6bbd253a12e 100644
--- a/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.native.js
+++ b/lib/node_modules/@stdlib/blas/base/zdrot/test/test.zdrot.native.js
@@ -36,7 +36,6 @@ var opts = {
 };
 
 
-
 // FUNCTIONS //
 
 /**