From 61867fb97527dcd59c55ef3275ed1dbd91e0925a Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 15 Sep 2026 14:16:58 +0000 Subject: [PATCH 1/3] test: migrate `lapack/base/spttrf` to ULP-based assertions Migrate the `lapack/base/spttrf` tests from computed relative-tolerance comparisons to ULP-difference assertions using `@stdlib/number/float32/base/assert/is-almost-same-value`. Ref: https://github.com/stdlib-js/stdlib/issues/11352 Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_016pbi1frD9BsfTzxAMAHerB --- .../lapack/base/spttrf/test/test.ndarray.js | 51 ++++++++++--------- .../lapack/base/spttrf/test/test.spttrf.js | 27 ++++------ 2 files changed, 36 insertions(+), 42 deletions(-) diff --git a/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.ndarray.js index ae50fce2d530..bec697ed6932 100644 --- a/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.ndarray.js @@ -24,8 +24,7 @@ var tape = require( 'tape' ); var Float32Array = require( '@stdlib/array/float32' ); -var EPS = require( '@stdlib/constants/float32/eps' ); -var abs = require( '@stdlib/math/base/special/abs' ); +var isAlmostSameValuef = require( '@stdlib/number/float32/base/assert/is-almost-same-value' ); var spttrf = require( './../lib/ndarray.js' ); @@ -38,22 +37,14 @@ var spttrf = 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( isAlmostSameValuef( actual[ i ], expected[ i ], ulp ), true, 'returns expected value' ); } } @@ -104,10 +95,12 @@ tape( 'the function computes the `L * D * L^T` factorization of a real symmetric var expectedD; var expectedE; var info; + var ULP; var D; var E; var N; + ULP = 26; N = 3; D = new Float32Array( [ 4.0, 5.0, 6.0 ] ); @@ -118,8 +111,8 @@ tape( 'the function computes the `L * D * L^T` factorization of a real symmetric info = spttrf( N, D, 1, 0, E, 1, 0 ); t.strictEqual( info, 0, 'returns expected value' ); - isApprox( t, D, expectedD, 2.0 ); - isApprox( t, E, expectedE, 2.0 ); + isApprox( t, D, expectedD, ULP ); + isApprox( t, E, expectedE, ULP ); N = 7; @@ -131,8 +124,8 @@ tape( 'the function computes the `L * D * L^T` factorization of a real symmetric info = spttrf( N, D, 1, 0, E, 1, 0 ); t.strictEqual( info, 0, 'returns expected value' ); - isApprox( t, D, expectedD, 15.0 ); - isApprox( t, E, expectedE, 2.0 ); + isApprox( t, D, expectedD, ULP ); + isApprox( t, E, expectedE, ULP ); t.end(); }); @@ -141,10 +134,12 @@ tape( 'the function supports providing index offsets', function test( t ) { var expectedD; var expectedE; var info; + var ULP; var D; var E; var N; + ULP = 0; N = 3; D = new Float32Array( [ 0.0, 0.0, 4.0, 5.0, 6.0 ] ); @@ -155,8 +150,8 @@ tape( 'the function supports providing index offsets', function test( t ) { info = spttrf( N, D, 1, 2, E, 1, 3 ); t.strictEqual( info, 0, 'returns expected value' ); - isApprox( t, D, expectedD, 2.0 ); - isApprox( t, E, expectedE, 2.0 ); + isApprox( t, D, expectedD, ULP ); + isApprox( t, E, expectedE, ULP ); t.end(); }); @@ -165,10 +160,12 @@ tape( 'the function supports providing positive strides', function test( t ) { var expectedD; var expectedE; var info; + var ULP; var D; var E; var N; + ULP = 0; N = 3; D = new Float32Array( [ 0.0, 0.0, 4.0, 0.0, 0.0, 5.0, 0.0, 0.0, 6.0 ] ); @@ -179,8 +176,8 @@ tape( 'the function supports providing positive strides', function test( t ) { info = spttrf( N, D, 3, 2, E, 2, 3 ); t.strictEqual( info, 0, 'returns expected value' ); - isApprox( t, D, expectedD, 2.0 ); - isApprox( t, E, expectedE, 2.0 ); + isApprox( t, D, expectedD, ULP ); + isApprox( t, E, expectedE, ULP ); t.end(); }); @@ -189,10 +186,12 @@ tape( 'the function supports providing mixed sign strides', function test( t ) { var expectedD; var expectedE; var info; + var ULP; var D; var E; var N; + ULP = 0; N = 3; D = new Float32Array( [ 6.0, 0.0, 0.0, 5.0, 0.0, 0.0, 4.0 ] ); @@ -203,8 +202,8 @@ tape( 'the function supports providing mixed sign strides', function test( t ) { info = spttrf( N, D, -3, 6, E, 2, 3 ); t.strictEqual( info, 0, 'returns expected value' ); - isApprox( t, D, expectedD, 2.0 ); - isApprox( t, E, expectedE, 2.0 ); + isApprox( t, D, expectedD, ULP ); + isApprox( t, E, expectedE, ULP ); t.end(); }); @@ -213,10 +212,12 @@ tape( 'the function supports providing negative strides', function test( t ) { var expectedD; var expectedE; var info; + var ULP; var D; var E; var N; + ULP = 0; N = 3; D = new Float32Array( [ 6.0, 0.0, 0.0, 5.0, 0.0, 0.0, 4.0 ] ); @@ -227,8 +228,8 @@ tape( 'the function supports providing negative strides', function test( t ) { info = spttrf( N, D, -3, 6, E, -2, 5 ); t.strictEqual( info, 0, 'returns expected value' ); - isApprox( t, D, expectedD, 2.0 ); - isApprox( t, E, expectedE, 2.0 ); + isApprox( t, D, expectedD, ULP ); + isApprox( t, E, expectedE, ULP ); t.end(); }); diff --git a/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.spttrf.js b/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.spttrf.js index 2ff65bab938b..d16d0e30f193 100644 --- a/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.spttrf.js +++ b/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.spttrf.js @@ -24,8 +24,7 @@ var tape = require( 'tape' ); var Float32Array = require( '@stdlib/array/float32' ); -var EPS = require( '@stdlib/constants/float32/eps' ); -var abs = require( '@stdlib/math/base/special/abs' ); +var isAlmostSameValuef = require( '@stdlib/number/float32/base/assert/is-almost-same-value' ); var spttrf = require( './../lib/spttrf.js' ); @@ -38,22 +37,14 @@ var spttrf = require( './../lib/spttrf.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( isAlmostSameValuef( actual[ i ], expected[ i ], ulp ), true, 'returns expected value' ); } } @@ -104,10 +95,12 @@ tape( 'the function computes the `L * D * L^T` factorization of a real symmetric var expectedD; var expectedE; var info; + var ULP; var D; var E; var N; + ULP = 26; N = 3; D = new Float32Array( [ 4.0, 5.0, 6.0 ] ); @@ -118,8 +111,8 @@ tape( 'the function computes the `L * D * L^T` factorization of a real symmetric info = spttrf( N, D, E ); t.strictEqual( info, 0, 'returns expected value' ); - isApprox( t, D, expectedD, 2.0 ); - isApprox( t, E, expectedE, 2.0 ); + isApprox( t, D, expectedD, ULP ); + isApprox( t, E, expectedE, ULP ); N = 7; @@ -131,8 +124,8 @@ tape( 'the function computes the `L * D * L^T` factorization of a real symmetric info = spttrf( N, D, E ); t.strictEqual( info, 0, 'returns expected value' ); - isApprox( t, D, expectedD, 15.0 ); - isApprox( t, E, expectedE, 2.0 ); + isApprox( t, D, expectedD, ULP ); + isApprox( t, E, expectedE, ULP ); t.end(); }); From 8ee70f142ab19cf48a1d6682fb6c789aaf4fe9a0 Mon Sep 17 00:00:00 2001 From: Philipp Burckhardt Date: Mon, 21 Sep 2026 23:44:32 -0500 Subject: [PATCH 2/3] style: inline ULP values and remove isApprox helper Co-Authored-By: Claude Opus 5 (1M context) --- .../lapack/base/spttrf/test/test.ndarray.js | 68 +++++++------------ .../lapack/base/spttrf/test/test.spttrf.js | 44 +++++------- 2 files changed, 42 insertions(+), 70 deletions(-) diff --git a/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.ndarray.js index bec697ed6932..033ca7691580 100644 --- a/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.ndarray.js @@ -28,27 +28,6 @@ var isAlmostSameValuef = require( '@stdlib/number/float32/base/assert/is-almost- var spttrf = 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( isAlmostSameValuef( actual[ i ], expected[ i ], ulp ), true, 'returns expected value' ); - } -} - - // TESTS // tape( 'main export is a function', function test( t ) { @@ -95,12 +74,11 @@ tape( 'the function computes the `L * D * L^T` factorization of a real symmetric var expectedD; var expectedE; var info; - var ULP; var D; var E; var N; + var i; - ULP = 26; N = 3; D = new Float32Array( [ 4.0, 5.0, 6.0 ] ); @@ -111,8 +89,14 @@ tape( 'the function computes the `L * D * L^T` factorization of a real symmetric info = spttrf( N, D, 1, 0, E, 1, 0 ); t.strictEqual( info, 0, 'returns expected value' ); - isApprox( t, D, expectedD, ULP ); - isApprox( t, E, expectedE, ULP ); + t.strictEqual( D.length, expectedD.length, 'returns expected value' ); + for ( i = 0; i < expectedD.length; i++ ) { + t.strictEqual( isAlmostSameValuef( D[ i ], expectedD[ i ], 0 ), true, 'returns expected value' ); + } + t.strictEqual( E.length, expectedE.length, 'returns expected value' ); + for ( i = 0; i < expectedE.length; i++ ) { + t.strictEqual( isAlmostSameValuef( E[ i ], expectedE[ i ], 0 ), true, 'returns expected value' ); + } N = 7; @@ -124,8 +108,14 @@ tape( 'the function computes the `L * D * L^T` factorization of a real symmetric info = spttrf( N, D, 1, 0, E, 1, 0 ); t.strictEqual( info, 0, 'returns expected value' ); - isApprox( t, D, expectedD, ULP ); - isApprox( t, E, expectedE, ULP ); + t.strictEqual( D.length, expectedD.length, 'returns expected value' ); + for ( i = 0; i < expectedD.length; i++ ) { + t.strictEqual( isAlmostSameValuef( D[ i ], expectedD[ i ], 26 ), true, 'returns expected value' ); + } + t.strictEqual( E.length, expectedE.length, 'returns expected value' ); + for ( i = 0; i < expectedE.length; i++ ) { + t.strictEqual( isAlmostSameValuef( E[ i ], expectedE[ i ], 2 ), true, 'returns expected value' ); + } t.end(); }); @@ -134,12 +124,10 @@ tape( 'the function supports providing index offsets', function test( t ) { var expectedD; var expectedE; var info; - var ULP; var D; var E; var N; - ULP = 0; N = 3; D = new Float32Array( [ 0.0, 0.0, 4.0, 5.0, 6.0 ] ); @@ -150,8 +138,8 @@ tape( 'the function supports providing index offsets', function test( t ) { info = spttrf( N, D, 1, 2, E, 1, 3 ); t.strictEqual( info, 0, 'returns expected value' ); - isApprox( t, D, expectedD, ULP ); - isApprox( t, E, expectedE, ULP ); + t.deepEqual( D, expectedD, 'returns expected value' ); + t.deepEqual( E, expectedE, 'returns expected value' ); t.end(); }); @@ -160,12 +148,10 @@ tape( 'the function supports providing positive strides', function test( t ) { var expectedD; var expectedE; var info; - var ULP; var D; var E; var N; - ULP = 0; N = 3; D = new Float32Array( [ 0.0, 0.0, 4.0, 0.0, 0.0, 5.0, 0.0, 0.0, 6.0 ] ); @@ -176,8 +162,8 @@ tape( 'the function supports providing positive strides', function test( t ) { info = spttrf( N, D, 3, 2, E, 2, 3 ); t.strictEqual( info, 0, 'returns expected value' ); - isApprox( t, D, expectedD, ULP ); - isApprox( t, E, expectedE, ULP ); + t.deepEqual( D, expectedD, 'returns expected value' ); + t.deepEqual( E, expectedE, 'returns expected value' ); t.end(); }); @@ -186,12 +172,10 @@ tape( 'the function supports providing mixed sign strides', function test( t ) { var expectedD; var expectedE; var info; - var ULP; var D; var E; var N; - ULP = 0; N = 3; D = new Float32Array( [ 6.0, 0.0, 0.0, 5.0, 0.0, 0.0, 4.0 ] ); @@ -202,8 +186,8 @@ tape( 'the function supports providing mixed sign strides', function test( t ) { info = spttrf( N, D, -3, 6, E, 2, 3 ); t.strictEqual( info, 0, 'returns expected value' ); - isApprox( t, D, expectedD, ULP ); - isApprox( t, E, expectedE, ULP ); + t.deepEqual( D, expectedD, 'returns expected value' ); + t.deepEqual( E, expectedE, 'returns expected value' ); t.end(); }); @@ -212,12 +196,10 @@ tape( 'the function supports providing negative strides', function test( t ) { var expectedD; var expectedE; var info; - var ULP; var D; var E; var N; - ULP = 0; N = 3; D = new Float32Array( [ 6.0, 0.0, 0.0, 5.0, 0.0, 0.0, 4.0 ] ); @@ -228,8 +210,8 @@ tape( 'the function supports providing negative strides', function test( t ) { info = spttrf( N, D, -3, 6, E, -2, 5 ); t.strictEqual( info, 0, 'returns expected value' ); - isApprox( t, D, expectedD, ULP ); - isApprox( t, E, expectedE, ULP ); + t.deepEqual( D, expectedD, 'returns expected value' ); + t.deepEqual( E, expectedE, 'returns expected value' ); t.end(); }); diff --git a/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.spttrf.js b/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.spttrf.js index d16d0e30f193..18454397c7b2 100644 --- a/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.spttrf.js +++ b/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.spttrf.js @@ -28,27 +28,6 @@ var isAlmostSameValuef = require( '@stdlib/number/float32/base/assert/is-almost- var spttrf = require( './../lib/spttrf.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( isAlmostSameValuef( actual[ i ], expected[ i ], ulp ), true, 'returns expected value' ); - } -} - - // TESTS // tape( 'main export is a function', function test( t ) { @@ -95,12 +74,11 @@ tape( 'the function computes the `L * D * L^T` factorization of a real symmetric var expectedD; var expectedE; var info; - var ULP; var D; var E; var N; + var i; - ULP = 26; N = 3; D = new Float32Array( [ 4.0, 5.0, 6.0 ] ); @@ -111,8 +89,14 @@ tape( 'the function computes the `L * D * L^T` factorization of a real symmetric info = spttrf( N, D, E ); t.strictEqual( info, 0, 'returns expected value' ); - isApprox( t, D, expectedD, ULP ); - isApprox( t, E, expectedE, ULP ); + t.strictEqual( D.length, expectedD.length, 'returns expected value' ); + for ( i = 0; i < expectedD.length; i++ ) { + t.strictEqual( isAlmostSameValuef( D[ i ], expectedD[ i ], 0 ), true, 'returns expected value' ); + } + t.strictEqual( E.length, expectedE.length, 'returns expected value' ); + for ( i = 0; i < expectedE.length; i++ ) { + t.strictEqual( isAlmostSameValuef( E[ i ], expectedE[ i ], 0 ), true, 'returns expected value' ); + } N = 7; @@ -124,8 +108,14 @@ tape( 'the function computes the `L * D * L^T` factorization of a real symmetric info = spttrf( N, D, E ); t.strictEqual( info, 0, 'returns expected value' ); - isApprox( t, D, expectedD, ULP ); - isApprox( t, E, expectedE, ULP ); + t.strictEqual( D.length, expectedD.length, 'returns expected value' ); + for ( i = 0; i < expectedD.length; i++ ) { + t.strictEqual( isAlmostSameValuef( D[ i ], expectedD[ i ], 26 ), true, 'returns expected value' ); + } + t.strictEqual( E.length, expectedE.length, 'returns expected value' ); + for ( i = 0; i < expectedE.length; i++ ) { + t.strictEqual( isAlmostSameValuef( E[ i ], expectedE[ i ], 2 ), true, 'returns expected value' ); + } t.end(); }); From 42025bfcc046a86d4579c9eea8033fb6fcacd187 Mon Sep 17 00:00:00 2001 From: Philipp Burckhardt Date: Tue, 22 Sep 2026 00:02:15 -0500 Subject: [PATCH 3/3] style: restore isApprox helper and inline ULP values per call site Co-Authored-By: Claude Opus 5 (1M context) --- .../lapack/base/spttrf/test/test.ndarray.js | 42 +++++++++++-------- .../lapack/base/spttrf/test/test.spttrf.js | 42 +++++++++++-------- 2 files changed, 50 insertions(+), 34 deletions(-) diff --git a/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.ndarray.js index 033ca7691580..afc3b6bd41e6 100644 --- a/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.ndarray.js @@ -28,6 +28,27 @@ var isAlmostSameValuef = require( '@stdlib/number/float32/base/assert/is-almost- var spttrf = 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( isAlmostSameValuef( actual[ i ], expected[ i ], ulp ), true, 'returns expected value' ); + } +} + + // TESTS // tape( 'main export is a function', function test( t ) { @@ -77,7 +98,6 @@ tape( 'the function computes the `L * D * L^T` factorization of a real symmetric var D; var E; var N; - var i; N = 3; @@ -89,14 +109,8 @@ tape( 'the function computes the `L * D * L^T` factorization of a real symmetric info = spttrf( N, D, 1, 0, E, 1, 0 ); t.strictEqual( info, 0, 'returns expected value' ); - t.strictEqual( D.length, expectedD.length, 'returns expected value' ); - for ( i = 0; i < expectedD.length; i++ ) { - t.strictEqual( isAlmostSameValuef( D[ i ], expectedD[ i ], 0 ), true, 'returns expected value' ); - } - t.strictEqual( E.length, expectedE.length, 'returns expected value' ); - for ( i = 0; i < expectedE.length; i++ ) { - t.strictEqual( isAlmostSameValuef( E[ i ], expectedE[ i ], 0 ), true, 'returns expected value' ); - } + isApprox( t, D, expectedD, 0 ); + isApprox( t, E, expectedE, 0 ); N = 7; @@ -108,14 +122,8 @@ tape( 'the function computes the `L * D * L^T` factorization of a real symmetric info = spttrf( N, D, 1, 0, E, 1, 0 ); t.strictEqual( info, 0, 'returns expected value' ); - t.strictEqual( D.length, expectedD.length, 'returns expected value' ); - for ( i = 0; i < expectedD.length; i++ ) { - t.strictEqual( isAlmostSameValuef( D[ i ], expectedD[ i ], 26 ), true, 'returns expected value' ); - } - t.strictEqual( E.length, expectedE.length, 'returns expected value' ); - for ( i = 0; i < expectedE.length; i++ ) { - t.strictEqual( isAlmostSameValuef( E[ i ], expectedE[ i ], 2 ), true, 'returns expected value' ); - } + isApprox( t, D, expectedD, 26 ); + isApprox( t, E, expectedE, 2 ); t.end(); }); diff --git a/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.spttrf.js b/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.spttrf.js index 18454397c7b2..c52e981bbe46 100644 --- a/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.spttrf.js +++ b/lib/node_modules/@stdlib/lapack/base/spttrf/test/test.spttrf.js @@ -28,6 +28,27 @@ var isAlmostSameValuef = require( '@stdlib/number/float32/base/assert/is-almost- var spttrf = require( './../lib/spttrf.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( isAlmostSameValuef( actual[ i ], expected[ i ], ulp ), true, 'returns expected value' ); + } +} + + // TESTS // tape( 'main export is a function', function test( t ) { @@ -77,7 +98,6 @@ tape( 'the function computes the `L * D * L^T` factorization of a real symmetric var D; var E; var N; - var i; N = 3; @@ -89,14 +109,8 @@ tape( 'the function computes the `L * D * L^T` factorization of a real symmetric info = spttrf( N, D, E ); t.strictEqual( info, 0, 'returns expected value' ); - t.strictEqual( D.length, expectedD.length, 'returns expected value' ); - for ( i = 0; i < expectedD.length; i++ ) { - t.strictEqual( isAlmostSameValuef( D[ i ], expectedD[ i ], 0 ), true, 'returns expected value' ); - } - t.strictEqual( E.length, expectedE.length, 'returns expected value' ); - for ( i = 0; i < expectedE.length; i++ ) { - t.strictEqual( isAlmostSameValuef( E[ i ], expectedE[ i ], 0 ), true, 'returns expected value' ); - } + isApprox( t, D, expectedD, 0 ); + isApprox( t, E, expectedE, 0 ); N = 7; @@ -108,14 +122,8 @@ tape( 'the function computes the `L * D * L^T` factorization of a real symmetric info = spttrf( N, D, E ); t.strictEqual( info, 0, 'returns expected value' ); - t.strictEqual( D.length, expectedD.length, 'returns expected value' ); - for ( i = 0; i < expectedD.length; i++ ) { - t.strictEqual( isAlmostSameValuef( D[ i ], expectedD[ i ], 26 ), true, 'returns expected value' ); - } - t.strictEqual( E.length, expectedE.length, 'returns expected value' ); - for ( i = 0; i < expectedE.length; i++ ) { - t.strictEqual( isAlmostSameValuef( E[ i ], expectedE[ i ], 2 ), true, 'returns expected value' ); - } + isApprox( t, D, expectedD, 26 ); + isApprox( t, E, expectedE, 2 ); t.end(); });