diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/README.md b/lib/node_modules/@stdlib/lapack/base/dlasq3/README.md
new file mode 100644
index 000000000000..83699ce014b6
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/README.md
@@ -0,0 +1,280 @@
+
+
+# dlasq3
+
+> Check for deflation, compute a shift (`TAU`) and call DQDS.
+
+
+
+The `dlasq3` routine checks for deflation of the QD array, computes a shift `TAU` and then calls DQDS. In case of failure it changes shifts and tries again until the output is positive. It is used as a helper by `sbdsqr` and `sstegr` when computing singular values and eigenvalues.
+
+The QD array `Z` stores interleaved values in the following format:
+
+```text
+Z[4*i] = d(i) (diagonal from q-array)
+Z[4*i+1] = e(i) (off-diagonal)
+Z[4*i+2] = d(i+1) (diagonal from d-array, ping)
+Z[4*i+3] = e(i+1) (off-diagonal)
+```
+
+
+
+
+
+
+
+## Usage
+
+```javascript
+var dlasq3 = require( '@stdlib/lapack/base/dlasq3' );
+```
+
+#### dlasq3( I0, N0, Z, PP, IEEE, out )
+
+Checks for deflation, computes a shift (`TAU`) and calls DQDS.
+
+
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+
+var Z = new Float64Array( [ 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ] );
+var out = new Float64Array( 15 );
+
+dlasq3( 0, 3, Z, 0, true, out );
+// Z => [ ~100.0, ~181.0, ~81.0, ~28.641, ~64.0, ~84.359, ~49.0, ~20.911, ~36.0, ~40.089, ~25.0, ~9.978, ~16.0, ~6.022, ~9.0, ~28.641 ]
+// out => ~6.022, ~181.0, ~0.0, ~0.0, ~0.0, ~1.0, ~5.0, ~-1.0, ~15.089, ~35.359, ~6.022, ~15.089, ~35.359, ~0.0, ~0.0 ]
+```
+
+The function has the following parameters:
+
+- **I0**: first index.
+- **N0**: last index.
+- **Z**: the QD array as a [`Float64Array`][@stdlib/array/float64]. Should have `4*N0 + 4` indexed elements. `Z` is mutated in-place during the computation.
+- **PP**: ping-pong flag. `0` for ping, `1` for pong, `2` indicates that flipping was applied to the `Z` array and that the initial tests for deflation should not be performed.
+- **IEEE**: flag for IEEE or non IEEE arithmetic. Passed to `DLASQ5`.
+- **out**: output array as a [`Float64Array`][@stdlib/array/float64] of length `15` containing the 15 scalar values `DMIN`, `SIGMA`, `DESIG`, `QMAX`, `NFAIL`, `ITER`, `NDIV`, `TTYPE`, `DMIN1`, `DMIN2`, `DN`, `DN1`, `DN2`, `G`, and `TAU`. On input, `out` should be initialized with the current values of these scalars.
+
+Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
+
+
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+
+// Initial arrays...
+var Z0 = new Float64Array( [ 0.0, 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ] );
+var out0 = new Float64Array( 16 );
+
+// Create offset views...
+var Z = new Float64Array( Z0.buffer, Z0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+var out = new Float64Array( out0.buffer, out0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+
+dlasq3( 0, 3, Z, 0, true, out );
+// Z0 => [ 0.0, ~100.0, ~181.0, ~81.0, ~28.641, ~64.0, ~84.359, ~49.0, ~20.911, ~36.0, ~40.089, ~25.0, ~9.978, ~16.0, ~6.022, ~9.0, ~28.641 ]
+// out0 => [ 0.0, ~6.022, ~181.0, ~0.0, ~0.0, ~0.0, ~1.0, ~5.0, ~-1.0, ~15.089, ~35.359, ~6.022, ~15.089, ~35.359, ~0.0, ~0.0 ]
+```
+
+#### dlasq3.ndarray( I0,N0,Z,strideZ,offsetZ,PP,IEEE,out,strideOut,offsetOut )
+
+Checks for deflation, computes a shift (`TAU`) and calls DQDS using alternative indexing semantics.
+
+
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+
+var Z = new Float64Array( [ 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ] );
+var out = new Float64Array( 15 );
+
+dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, 1, 0 );
+// Z => [ ~100.0, ~181.0, ~81.0, ~28.641, ~64.0, ~84.359, ~49.0, ~20.911, ~36.0, ~40.089, ~25.0, ~9.978, ~16.0, ~6.022, ~9.0, ~28.641 ]
+// out => [ ~6.022, ~181.0, ~0.0, ~0.0, ~0.0, ~1.0, ~5.0, ~-1.0, ~15.089, ~35.359, ~6.022, ~15.089, ~35.359, ~0.0, ~0.0 ]
+```
+
+The function has the following additional parameters:
+
+- **strideZ**: stride length for `Z`.
+- **offsetZ**: starting index for `Z`.
+- **strideOut**: stride length for `out`.
+- **offsetOut**: starting index for `out`.
+
+While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameters support indexing semantics based on starting indices. For example,
+
+
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+
+var Z = new Float64Array( [ 0.0, 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ] );
+var out = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+dlasq3.ndarray( 0, 3, Z, 1, 1, 0, true, out, 1, 1 );
+// Z => [ 0.0, ~100.0, ~181.0, ~81.0, ~28.641, ~64.0, ~84.359, ~49.0, ~20.911, ~36.0, ~40.089, ~25.0, ~9.978, ~16.0, ~6.022, ~9.0, ~28.641 ]
+// out => [ 0.0, ~6.022, ~181.0, ~0.0, ~0.0, ~0.0, ~1.0, ~5.0, ~-1.0, ~15.089, ~35.359, ~6.022, ~15.089, ~35.359, ~0.0, ~0.0 ]
+```
+
+
+
+
+
+
+
+## Notes
+
+- Both functions mutate the input arrays `Z` and `out`.
+- The `out` array provides space to store the 15 scalar values `DMIN`, `SIGMA`, `DESIG`, `QMAX`, `NFAIL`, `ITER`, `NDIV`, `TTYPE`, `DMIN1`, `DMIN2`, `DN`, `DN1`, `DN2`, `G`, and `TAU`. These scalar values are maintained across successive calls to `dlasq3`.
+- `dlasq3()` corresponds to the [LAPACK][LAPACK] routine [`dlasq3`][lapack-dlasq3].
+
+
+
+
+
+
+
+## Examples
+
+
+
+
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var dlasq3 = require( '@stdlib/lapack/base/dlasq3' );
+
+var I0 = 0;
+var N0 = 3;
+var PP = 0;
+var IEEE = true;
+
+var out = new Float64Array( 15 );
+var Z = new Float64Array( [ 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ] );
+
+/*
+ Z is a flattened QD array of size 4*N0+4 = 16 where:
+ - Z[4*i] = d(i) (diagonal elements)
+ - Z[4*i+1] = e(i) (off-diagonal elements)
+*/
+
+// Perform the DQDS iteration:
+dlasq3( I0, N0, Z, PP, IEEE, out );
+
+console.log( Z );
+console.log( out );
+```
+
+
+
+
+
+
+
+* * *
+
+
+
+## C APIs
+
+
+
+
+
+
+
+
+
+
+
+### Usage
+
+```c
+TODO
+```
+
+#### TODO
+
+TODO.
+
+```c
+TODO
+```
+
+TODO
+
+```c
+TODO
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Examples
+
+```c
+TODO
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[lapack]: https://www.netlib.org/lapack/explore-html/
+
+[lapack-dlasq3]: https://www.netlib.org/lapack/explore-html/d9/d22/group__lasq3_gab56750e63973f380503fa3f10f68ff95.html#gab56750e63973f380503fa3f10f68ff95
+
+[@stdlib/array/float64]: https://stdlib.io/docs/api/latest/@stdlib/array/float64
+
+[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
+
+
+
+
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/benchmark/benchmark.js b/lib/node_modules/@stdlib/lapack/base/dlasq3/benchmark/benchmark.js
new file mode 100644
index 000000000000..22369050703e
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/benchmark/benchmark.js
@@ -0,0 +1,104 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var Float64Array = require( '@stdlib/array/float64' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var dlasq3 = require( './../lib/dlasq3.js' );
+
+
+// VARIABLES //
+
+var options = {
+ 'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+ var out = new Float64Array( 15 );
+ var Z = uniform( ( 4 * ( len + 1 ) ) + 1, 0.0, 100.0, options );
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ dlasq3( 0, len, Z, 0, true, out );
+ if ( isnan( Z[ i%Z.length ] ) ) {
+ b.fail( 'unexpected NaN value' );
+ }
+ }
+ b.toc();
+ if ( isnan( Z[ i%Z.length ] ) ) {
+ b.fail( 'unexpected NaN value' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var len;
+ var min;
+ var max;
+ var f;
+ var i;
+
+ min = 1; // 10^min
+ max = 6; // 10^max
+
+ for ( i = min; i <= max; i++ ) {
+ len = pow( 10, i );
+ f = createBenchmark( len );
+ bench( format( '%s:len=%d', pkg, len ), f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlasq3/benchmark/benchmark.ndarray.js
new file mode 100644
index 000000000000..78c3450db716
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/benchmark/benchmark.ndarray.js
@@ -0,0 +1,104 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var Float64Array = require( '@stdlib/array/float64' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var dlasq3 = require( './../lib/ndarray.js' );
+
+
+// VARIABLES //
+
+var options = {
+ 'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+ var out = new Float64Array( 15 );
+ var Z = uniform( ( 4 * ( len + 1 ) ) + 1, 0.0, 100.0, options );
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ dlasq3( 0, len, Z, 1, 0, 0, true, out, 1, 0 );
+ if ( isnan( Z[ i%Z.length ] ) ) {
+ b.fail( 'unexpected NaN value' );
+ }
+ }
+ b.toc();
+ if ( isnan( Z[ i%Z.length ] ) ) {
+ b.fail( 'unexpected NaN value' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var len;
+ var min;
+ var max;
+ var f;
+ var i;
+
+ min = 1; // 10^min
+ max = 6; // 10^max
+
+ for ( i = min; i <= max; i++ ) {
+ len = pow( 10, i );
+ f = createBenchmark( len );
+ bench( format( '%s:ndarray:len=%d', pkg, len ), f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/dlasq3/docs/repl.txt
new file mode 100644
index 000000000000..0d69e8d23374
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/docs/repl.txt
@@ -0,0 +1,143 @@
+
+{{alias}}( I0, N0, Z, PP, IEEE, out )
+ Checks for deflation, computes a shift (`TAU`) and calls DQDS. In case of
+ failure it changes shifts, and tries again until output is positive.
+
+ Indexing is relative to the first index. To introduce an offset, use typed
+ array views.
+
+ The function mutates the `Z` array and the `out` array.
+
+ Parameters
+ ----------
+ I0: integer
+ First index.
+
+ N0: integer
+ Last index.
+
+ Z: Float64Array
+ The QD array. Should have `4*N0 + 4` indexed elements. `Z` is mutated
+ in-place during the computation.
+
+ PP: integer
+ Ping-pong flag. `0` for ping, `1` for pong, `2` indicates that flipping
+ was applied to the Z array and that the initial tests for deflation
+ should not be performed.
+
+ IEEE: boolean
+ Flag for IEEE or non IEEE arithmetic.
+
+ out: Float64Array
+ Output array of length `15` containing `DMIN`, `SIGMA`, `DESIG`, `QMAX`,
+ `NFAIL`, `ITER`, `NDIV`, `TTYPE`, `DMIN1`, `DMIN2`, `DN`, `DN1`, `DN2`,
+ `G`, and `TAU` respectively. On input, `out` should be initialized with
+ the current values of these scalars.
+
+ Returns
+ -------
+ out: Float64Array
+ Output array.
+
+ Examples
+ --------
+ > var out = new {{alias:@stdlib/array/float64}}( 15 );
+ > var Z = new {{alias:@stdlib/array/float64}}( 16 );
+ > Z[ 0 ] = 100;
+ > Z[ 1 ] = 4;
+ > Z[ 2 ] = 81;
+ > Z[ 3 ] = 3;
+ > Z[ 4 ] = 64;
+ > Z[ 5 ] = 2.5;
+ > Z[ 6 ] = 49;
+ > Z[ 7 ] = 2;
+ > Z[ 8 ] = 36;
+ > Z[ 9 ] = 1.5;
+ > Z[ 10 ] = 25;
+ > Z[ 11 ] = 1;
+ > Z[ 12 ] = 16;
+ > Z[ 13 ] = 0.5;
+ > Z[ 14 ] = 9;
+ > Z[ 15 ] = 0;
+ > {{alias}}( 0, 3, Z, 0, true, out )
+ [~6.02,0,0,0,0,1,5,-1,~15.09,~35.36,~6.022,~15.09,~35.359,0,0]
+
+
+{{alias}}.ndarray( I0,N0,Z,strideZ,offsetZ,PP,IEEE,out,strideOut,offsetOut )
+ Checks for deflation, computes a shift (`TAU`) and calls DQDS with
+ alternative indexing semantics.
+
+ While typed array views mandate a view offset based on the underlying
+ buffer, the offset parameters support indexing semantics based on starting
+ indices.
+
+ The function mutates the `Z` array and the `out` array.
+
+ Parameters
+ ----------
+ I0: integer
+ First index.
+
+ N0: integer
+ Last index.
+
+ Z: Float64Array
+ The QD array. Should have `4*N0 + 4` indexed elements. `Z` is mutated
+ in-place during the computation.
+
+ strideZ: integer
+ Stride length for `Z`.
+
+ offsetZ: integer
+ Starting index for `Z`.
+
+ PP: integer
+ Ping-pong flag. `0` for ping, `1` for pong, `2` indicates that flipping
+ was applied to the Z array and that the initial tests for deflation
+ should not be performed.
+
+ IEEE: boolean
+ Flag for IEEE or non IEEE arithmetic.
+
+ out: Float64Array
+ Output array of length `15` containing `DMIN`, `SIGMA`, `DESIG`, `QMAX`,
+ `NFAIL`, `ITER`, `NDIV`, `TTYPE`, `DMIN1`, `DMIN2`, `DN`, `DN1`, `DN2`,
+ `G`, and `TAU` respectively. On input, `out` should be initialized with
+ the current values of these scalars.
+
+ strideOut: integer
+ Stride length for `out`.
+
+ offsetOut: integer
+ Starting index for `out`.
+
+ Returns
+ -------
+ out: Float64Array
+ Output array.
+
+ Examples
+ --------
+ > var out = new {{alias:@stdlib/array/float64}}( 15 );
+ > var Z = new {{alias:@stdlib/array/float64}}( 16 );
+ > Z[ 0 ] = 100;
+ > Z[ 1 ] = 4;
+ > Z[ 2 ] = 81;
+ > Z[ 3 ] = 3;
+ > Z[ 4 ] = 64;
+ > Z[ 5 ] = 2.5;
+ > Z[ 6 ] = 49;
+ > Z[ 7 ] = 2;
+ > Z[ 8 ] = 36;
+ > Z[ 9 ] = 1.5;
+ > Z[ 10 ] = 25;
+ > Z[ 11 ] = 1;
+ > Z[ 12 ] = 16;
+ > Z[ 13 ] = 0.5;
+ > Z[ 14 ] = 9;
+ > Z[ 15 ] = 0;
+ > {{alias}}.ndarray( 0, 3, Z, 1, 0, 0, true, out, 1, 0 )
+ [~6.02,0,0,0,0,1,5,-1,~15.09,~35.36,~6.022,~15.09,~35.359,0,0]
+
+ See Also
+ --------
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/dlasq3/docs/types/index.d.ts
new file mode 100644
index 000000000000..b581bd40173d
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/docs/types/index.d.ts
@@ -0,0 +1,112 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+// TypeScript Version: 4.1
+
+/**
+* Interface describing `dlasq3`.
+*/
+interface Routine {
+ /**
+ * Checks for deflation, computes a shift (`TAU`) and calls DQDS. In case of failure it changes shifts, and tries again until output is positive.
+ *
+ * @param I0 - first index
+ * @param N0 - last index
+ * @param Z - the QD array
+ * @param PP - ping-pong flag (0 or 1)
+ * @param IEEE - IEEE arithmetic flag
+ * @param out - output array containing `DMIN`, `SIGMA`, `DESIG`, `QMAX`, `NFAIL`, `ITER`, `NDIV`, `TTYPE`, `DMIN1`, `DMIN2`, `DN`, `DN1`, `DN2`, `G`, and `TAU`
+ * @returns output array
+ *
+ * @example
+ * var Float64Array = require( '@stdlib/array/float64' );
+ *
+ * var out = new Float64Array( 15 );
+ * var Z = new Float64Array( [ 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ] );
+ *
+ * dlasq3( 0, 3, Z, 0, true, out );
+ * // Z => [ ~100.0, ~181.0, ~81.0, ~28.641, ~64.0, ~84.359, ~49.0, ~20.911, ~36.0, ~40.089, ~25.0, ~9.978, ~16.0, ~6.022, ~9.0, ~28.641 ]
+ * // out => [ ~6.022, ~181.0, ~0.0, ~0.0, ~0.0, ~1.0, ~5.0, ~-1.0, ~15.089, ~35.359, ~6.022, ~15.089, ~35.359, ~0.0, ~0.0 ]
+ */
+ ( I0: number, N0: number, Z: Float64Array, PP: number, IEEE: boolean, out: Float64Array ): Float64Array;
+
+ /**
+ * Checks for deflation, computes a shift (`TAU`) and calls DQDS using alternative indexing semantics.
+ *
+ * @param I0 - first index
+ * @param N0 - last index
+ * @param Z - the QD array
+ * @param strideZ - stride length for `Z`
+ * @param offsetZ - starting index of `Z`
+ * @param PP - ping-pong flag (0 or 1)
+ * @param IEEE - IEEE arithmetic flag
+ * @param out - output array containing `DMIN`, `SIGMA`, `DESIG`, `QMAX`, `NFAIL`, `ITER`, `NDIV`, `TTYPE`, `DMIN1`, `DMIN2`, `DN`, `DN1`, `DN2`, `G`, and `TAU`
+ * @param strideOut - stride length for `out`
+ * @param offsetOut - starting index of `out`
+ * @returns output array
+ *
+ * @example
+ * var Float64Array = require( '@stdlib/array/float64' );
+ *
+ * var out = new Float64Array( 15 );
+ * var Z = new Float64Array( [ 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ] );
+ *
+ * dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, 1, 0 );
+ * // Z => [ ~100.0, ~181.0, ~81.0, ~28.641, ~64.0, ~84.359, ~49.0, ~20.911, ~36.0, ~40.089, ~25.0, ~9.978, ~16.0, ~6.022, ~9.0, ~28.641 ]
+ * // out => [ ~6.022, ~181.0, ~0.0, ~0.0, ~0.0, ~1.0, ~5.0, ~-1.0, ~15.089, ~35.359, ~6.022, ~15.089, ~35.359, ~0.0, ~0.0 ]
+ */
+ ndarray( I0: number, N0: number, Z: Float64Array, strideZ: number, offsetZ: number, PP: number, IEEE: boolean, out: Float64Array, strideOut: number, offsetOut: number ): Float64Array;
+}
+
+/**
+* LAPACK routine to check for deflation, compute a shift (`TAU`) and call DQDS.
+*
+* @param I0 - first index
+* @param N0 - last index
+* @param Z - the QD array
+* @param PP - ping-pong flag (0 or 1)
+* @param IEEE - IEEE arithmetic flag
+* @param out - output array containing `DMIN`, `SIGMA`, `DESIG`, `QMAX`, `NFAIL`, `ITER`, `NDIV`, `TTYPE`, `DMIN1`, `DMIN2`, `DN`, `DN1`, `DN2`, `G`, and `TAU`
+* @returns output array
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var out = new Float64Array( 15 );
+* var Z = new Float64Array( [ 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ] );
+*
+* dlasq3( 0, 3, Z, 0, true, out );
+* // Z => [ ~100.0, ~181.0, ~81.0, ~28.641, ~64.0, ~84.359, ~49.0, ~20.911, ~36.0, ~40.089, ~25.0, ~9.978, ~16.0, ~6.022, ~9.0, ~28.641 ]
+* // out => [ ~6.022, ~181.0, ~0.0, ~0.0, ~0.0, ~1.0, ~5.0, ~-1.0, ~15.089, ~35.359, ~6.022, ~15.089, ~35.359, ~0.0, ~0.0 ]
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var out = new Float64Array( 15 );
+* var Z = new Float64Array( [ 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ] );
+*
+* dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, 1, 0 );
+* // Z => [ ~100.0, ~181.0, ~81.0, ~28.641, ~64.0, ~84.359, ~49.0, ~20.911, ~36.0, ~40.089, ~25.0, ~9.978, ~16.0, ~6.022, ~9.0, ~28.641 ]
+* // out => [ ~6.022, ~181.0, ~0.0, ~0.0, ~0.0, ~1.0, ~5.0, ~-1.0, ~15.089, ~35.359, ~6.022, ~15.089, ~35.359, ~0.0, ~0.0 ]
+*/
+declare var dlasq3: Routine;
+
+
+// EXPORTS //
+
+export = dlasq3;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/docs/types/test.ts b/lib/node_modules/@stdlib/lapack/base/dlasq3/docs/types/test.ts
new file mode 100644
index 000000000000..1e169ad4fe29
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/docs/types/test.ts
@@ -0,0 +1,309 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+// TypeScript Version: 4.1
+
+import dlasq3 = require( './index' );
+
+// TESTS //
+
+// The function returns a Float64Array...
+{
+ const Z = new Float64Array( 16 );
+ const out = new Float64Array( 15 );
+
+ dlasq3( 0, 3, Z, 0, true, out ); // $ExpectType Float64Array
+}
+
+// The compiler throws an error if the function is provided a first argument which is not a number...
+{
+ const Z = new Float64Array( 16 );
+ const out = new Float64Array( 15 );
+
+ dlasq3( '5', 3, Z, 0, true, out ); // $ExpectError
+ dlasq3( true, 3, Z, 0, true, out ); // $ExpectError
+ dlasq3( false, 3, Z, 0, true, out ); // $ExpectError
+ dlasq3( null, 3, Z, 0, true, out ); // $ExpectError
+ dlasq3( undefined, 3, Z, 0, true, out ); // $ExpectError
+ dlasq3( [], 3, Z, 0, true, out ); // $ExpectError
+ dlasq3( {}, 3, Z, 0, true, out ); // $ExpectError
+ dlasq3( ( x: number ): number => x, 3, Z, 0, true, out ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not a number...
+{
+ const Z = new Float64Array( 16 );
+ const out = new Float64Array( 15 );
+
+ dlasq3( 0, '5', Z, 0, true, out ); // $ExpectError
+ dlasq3( 0, true, Z, 0, true, out ); // $ExpectError
+ dlasq3( 0, false, Z, 0, true, out ); // $ExpectError
+ dlasq3( 0, null, Z, 0, true, out ); // $ExpectError
+ dlasq3( 0, undefined, Z, 0, true, out ); // $ExpectError
+ dlasq3( 0, [], Z, 0, true, out ); // $ExpectError
+ dlasq3( 0, {}, Z, 0, true, out ); // $ExpectError
+ dlasq3( 0, ( x: number ): number => x, Z, 0, true, out ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a third argument which is not a Float64Array...
+{
+ const out = new Float64Array( 15 );
+
+ dlasq3( 0, 3, '5', 0, true, out ); // $ExpectError
+ dlasq3( 0, 3, 5, 0, true, out ); // $ExpectError
+ dlasq3( 0, 3, true, 0, true, out ); // $ExpectError
+ dlasq3( 0, 3, false, 0, true, out ); // $ExpectError
+ dlasq3( 0, 3, null, 0, true, out ); // $ExpectError
+ dlasq3( 0, 3, undefined, 0, true, out ); // $ExpectError
+ dlasq3( 0, 3, [], 0, true, out ); // $ExpectError
+ dlasq3( 0, 3, {}, 0, true, out ); // $ExpectError
+ dlasq3( 0, 3, ( x: number ): number => x, 0, true, out ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fourth argument which is not a number...
+{
+ const Z = new Float64Array( 16 );
+ const out = new Float64Array( 15 );
+
+ dlasq3( 0, 3, Z, '5', true, out ); // $ExpectError
+ dlasq3( 0, 3, Z, true, true, out ); // $ExpectError
+ dlasq3( 0, 3, Z, false, true, out ); // $ExpectError
+ dlasq3( 0, 3, Z, null, true, out ); // $ExpectError
+ dlasq3( 0, 3, Z, undefined, true, out ); // $ExpectError
+ dlasq3( 0, 3, Z, [], true, out ); // $ExpectError
+ dlasq3( 0, 3, Z, {}, true, out ); // $ExpectError
+ dlasq3( 0, 3, Z, ( x: number ): number => x, true, out ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fifth argument which is not a boolean...
+{
+ const Z = new Float64Array( 16 );
+ const out = new Float64Array( 15 );
+
+ dlasq3( 0, 3, Z, 0, '5', out ); // $ExpectError
+ dlasq3( 0, 3, Z, 0, 5, out ); // $ExpectError
+ dlasq3( 0, 3, Z, 0, null, out ); // $ExpectError
+ dlasq3( 0, 3, Z, 0, undefined, out ); // $ExpectError
+ dlasq3( 0, 3, Z, 0, [], out ); // $ExpectError
+ dlasq3( 0, 3, Z, 0, {}, out ); // $ExpectError
+ dlasq3( 0, 3, Z, 0, ( x: number ): number => x, out ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a sixth argument which is not a Float64Array...
+{
+ const Z = new Float64Array( 16 );
+
+ dlasq3( 0, 3, Z, 0, true, '5' ); // $ExpectError
+ dlasq3( 0, 3, Z, 0, true, 5 ); // $ExpectError
+ dlasq3( 0, 3, Z, 0, true, true ); // $ExpectError
+ dlasq3( 0, 3, Z, 0, true, false ); // $ExpectError
+ dlasq3( 0, 3, Z, 0, true, null ); // $ExpectError
+ dlasq3( 0, 3, Z, 0, true, undefined ); // $ExpectError
+ dlasq3( 0, 3, Z, 0, true, [] ); // $ExpectError
+ dlasq3( 0, 3, Z, 0, true, {} ); // $ExpectError
+ dlasq3( 0, 3, Z, 0, true, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ const Z = new Float64Array( 16 );
+ const out = new Float64Array( 15 );
+
+ dlasq3(); // $ExpectError
+ dlasq3( 0 ); // $ExpectError
+ dlasq3( 0, 3 ); // $ExpectError
+ dlasq3( 0, 3, Z ); // $ExpectError
+ dlasq3( 0, 3, Z, 0 ); // $ExpectError
+ dlasq3( 0, 3, Z, 0, true ); // $ExpectError
+ dlasq3( 0, 3, Z, 0, true, out, 10 ); // $ExpectError
+}
+
+// Attached to main export is an `ndarray` method which returns a Float64Array...
+{
+ const Z = new Float64Array( 16 );
+ const out = new Float64Array( 15 );
+
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, 1, 0 ); // $ExpectType Float64Array
+}
+
+// The compiler throws an error if the function is provided a first argument which is not a number...
+{
+ const Z = new Float64Array( 16 );
+ const out = new Float64Array( 15 );
+
+ dlasq3.ndarray( '5', 3, Z, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( true, 3, Z, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( false, 3, Z, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( null, 3, Z, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( undefined, 3, Z, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( [], 3, Z, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( {}, 3, Z, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( ( x: number ): number => x, 3, Z, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not a number...
+{
+ const Z = new Float64Array( 16 );
+ const out = new Float64Array( 15 );
+
+ dlasq3.ndarray( 0, '5', Z, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, true, Z, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, false, Z, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, null, Z, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, undefined, Z, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, [], Z, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, {}, Z, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, ( x: number ): number => x, Z, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a third argument which is not a Float64Array...
+{
+ const out = new Float64Array( 15 );
+
+ dlasq3.ndarray( 0, 3, '5', 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, 5, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, true, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, false, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, null, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, undefined, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, [], 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, {}, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, ( x: number ): number => x, 1, 0, 0, true, out, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fourth argument which is not a number...
+{
+ const Z = new Float64Array( 16 );
+ const out = new Float64Array( 15 );
+
+ dlasq3.ndarray( 0, 3, Z, '5', 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, true, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, false, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, null, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, undefined, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, [], 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, {}, 0, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, ( x: number ): number => x, 0, 0, true, out, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fifth argument which is not a number...
+{
+ const Z = new Float64Array( 16 );
+ const out = new Float64Array( 15 );
+
+ dlasq3.ndarray( 0, 3, Z, 1, '5', 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, true, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, false, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, null, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, undefined, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, [], 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, {}, 0, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, ( x: number ): number => x, 0, true, out, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a sixth argument which is not a number...
+{
+ const Z = new Float64Array( 16 );
+ const out = new Float64Array( 15 );
+
+ dlasq3.ndarray( 0, 3, Z, 1, 0, '5', true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, true, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, false, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, null, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, undefined, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, [], true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, {}, true, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, ( x: number ): number => x, true, out, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a seventh argument which is not a boolean...
+{
+ const Z = new Float64Array( 16 );
+ const out = new Float64Array( 15 );
+
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, '5', out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, 5, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, null, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, undefined, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, [], out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, {}, out, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, ( x: number ): number => x, out, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an eighth argument which is not a Float64Array...
+{
+ const Z = new Float64Array( 16 );
+
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, '5', 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, 5, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, true, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, false, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, null, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, undefined, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, [], 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, {}, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, ( x: number ): number => x, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a ninth argument which is not a number...
+{
+ const Z = new Float64Array( 16 );
+ const out = new Float64Array( 15 );
+
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, '5', 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, true, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, false, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, null, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, undefined, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, [], 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, {}, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, ( x: number ): number => x, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a tenth argument which is not a number...
+{
+ const Z = new Float64Array( 16 );
+ const out = new Float64Array( 15 );
+
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, 1, '5' ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, 1, true ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, 1, false ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, 1, null ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, 1, undefined ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, 1, [] ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, 1, {} ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, 1, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ const Z = new Float64Array( 16 );
+ const out = new Float64Array( 15 );
+
+ dlasq3.ndarray(); // $ExpectError
+ dlasq3.ndarray( 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, 1 ); // $ExpectError
+ dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, 1, 0, 10 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/examples/index.js b/lib/node_modules/@stdlib/lapack/base/dlasq3/examples/index.js
new file mode 100644
index 000000000000..9a3da24dd116
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/examples/index.js
@@ -0,0 +1,42 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+var Float64Array = require( '@stdlib/array/float64' );
+var dlasq3 = require( './../lib' );
+
+var I0 = 0;
+var N0 = 3;
+var PP = 0;
+var IEEE = true;
+
+var out = new Float64Array( 15 );
+var Z = new Float64Array([ 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ]);
+
+/*
+ Z is a flattened QD array of size 4*N0+4 = 16 where:
+ - Z[4*i] = d(i) (diagonal elements)
+ - Z[4*i+1] = e(i) (off-diagonal elements)
+*/
+
+// Perform the dqds iteration:
+dlasq3( I0, N0, Z, PP, IEEE, out );
+
+console.log( Z );
+console.log( out );
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/base.js
new file mode 100644
index 000000000000..6298fd895f5b
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/base.js
@@ -0,0 +1,368 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+/* eslint-disable max-len, max-statements, max-lines-per-function */
+
+// MODULES //
+
+var Float64Array = require( '@stdlib/array/float64' );
+var dlamch = require( '@stdlib/lapack/base/dlamch' );
+var isnan = require( '@stdlib/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var max = require( '@stdlib/math/base/special/max' );
+var min = require( '@stdlib/math/base/special/min' );
+var sqrt = require( '@stdlib/math/base/special/sqrt' );
+var abs = require( '@stdlib/math/base/special/abs' );
+var dlasq4 = require( './dlasq4.js' );
+var dlasq5 = require( './dlasq5.js' );
+var dlasq6 = require( './dlasq6.js' );
+
+
+// VARIABLES //
+
+var CBIAS = 1.50;
+var EPS = dlamch( 'P' );
+var TOL = EPS * 100;
+var TOL2 = pow( TOL, 2 );
+
+
+// MAIN //
+
+/**
+* Checks for deflation, computes a shift (`TAU`) and calls DQDS. In case of failure it changes shifts, and tries again until output is positive.
+*
+* @private
+* @param {integer} I0 - first index
+* @param {integer} N0 - last index
+* @param {Float64Array} Z - qd array
+* @param {integer} strideZ - stride length for `Z`
+* @param {NonNegativeInteger} offsetZ - starting index of `Z`
+* @param {integer} PP - ping-pong flag (0 or 1)
+* @param {boolean} IEEE - IEEE arithmetic flag
+* @param {Float64Array} out - output array containing `DMIN`, `SIGMA`, `DESIG`, `QMAX`, `NFAIL`, `ITER`, `NDIV`, `TTYPE`, `DMIN1`, `DMIN2`, `DN`, `DN1`, `DN2`, `G` and `TAU`
+* @param {integer} strideOut - stride length for `out`
+* @param {NonNegativeInteger} offsetOut - starting index of `out`
+* @returns {Float64Array} output array
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var out = new Float64Array( 15 );
+* var Z = new Float64Array( [ 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ] );
+*
+* dlasq3( 0, 3, Z, 1, 0, 0, true, out, 1, 0 );
+* // Z => [ 100.0, 181.0, 81.0, ~28.641, 64.0, ~84.359, 49.0, ~20.911, ~36.0, ~40.089, 25.0, ~9.978, 16.0, ~6.022, 9.0, ~28.641 ]
+* // out => [ ~6.022, 0.0, 0.0, 0.0, 0.0, 1.0, 5.0, -1.0, ~15.089, ~35.359, ~6.022, 15.089, 35.359, 0.0, 0.0 ]
+*/
+function dlasq3( I0, N0, Z, strideZ, offsetZ, PP, IEEE, out, strideOut, offsetOut ) {
+ var goto80;
+ var desig;
+ var dmin1;
+ var dmin2;
+ var nfail;
+ var sigma;
+ var ttype;
+ var dmin;
+ var idx1;
+ var idx2;
+ var idx3;
+ var idx4;
+ var ipn4;
+ var iter;
+ var n0in;
+ var ndiv;
+ var out1;
+ var temp;
+ var qmax;
+ var dn1;
+ var dn2;
+ var idx;
+ var tau;
+ var dn;
+ var j4;
+ var nn;
+ var g;
+ var s;
+ var t;
+
+ // Read input values from output array
+ idx = offsetOut;
+ dmin = out[ idx ];
+ idx += strideOut;
+ sigma = out[ idx ];
+ idx += strideOut;
+ desig = out[ idx ];
+ idx += strideOut;
+ qmax = out[ idx ];
+ idx += strideOut;
+ nfail = out[ idx ];
+ idx += strideOut;
+ iter = out[ idx ];
+ idx += strideOut;
+ ndiv = out[ idx ];
+ idx += strideOut;
+ ttype = out[ idx ];
+ idx += strideOut;
+ dmin1 = out[ idx ];
+ idx += strideOut;
+ dmin2 = out[ idx ];
+ idx += strideOut;
+ dn = out[ idx ];
+ idx += strideOut;
+ dn1 = out[ idx ];
+ idx += strideOut;
+ dn2 = out[ idx ];
+ idx += strideOut;
+ g = out[ idx ];
+ idx += strideOut;
+ tau = out[ idx ];
+
+ n0in = N0;
+ idx3 = offsetZ + ( strideZ * ( 4 * N0 ) );
+ idx4 = offsetZ + ( strideZ * ( 4 * I0 ) );
+
+ // Check for deflation
+ while ( true ) {
+ idx3 = offsetZ + ( strideZ * ( 4 * N0 ) );
+ if ( N0 < I0 ) {
+ return out;
+ }
+ if ( N0 === I0 ) {
+ // Deflate 1 eigenvalue
+ Z[ idx3 ] = Z[ idx3 + ( strideZ * PP ) ] + sigma;
+ N0 -= 1;
+ continue;
+ }
+ nn = offsetZ + ( strideZ * ( ( 4 * N0 ) + PP + 3 ) );
+ if ( N0 !== ( I0 + 1 ) ) {
+ if ( Z[ nn - ( 5 * strideZ ) ] > TOL2 * ( sigma + Z[ nn - ( 3 * strideZ ) ] ) && Z[ nn - ( strideZ * ( ( 2 * PP ) + 4 ) ) ] > TOL2 * Z[ nn - ( 7 * strideZ ) ] ) {
+ // Check whether E(N0-1) is negligible, 1 eigenvalue
+ if ( Z[ nn - ( 9 * strideZ ) ] > TOL2 * sigma &&
+ Z[ nn - ( strideZ * ( ( 2 * PP ) + 8 ) ) ] > TOL2 * Z[ nn - ( 11 * strideZ ) ] ) {
+ break; // No deflation possible
+ }
+ } else {
+ Z[ idx3 ] = Z[ idx3 + ( strideZ * PP ) ] + sigma;
+ N0 -= 1;
+ continue;
+ }
+ }
+
+ // Check whether E(N0-2) is negligible, 2 eigenvalues
+ if ( Z[ nn - ( 3 * strideZ ) ] > Z[ nn - ( 7 * strideZ ) ] ) {
+ s = Z[ nn - ( 3 * strideZ ) ];
+ Z[ nn - ( 3 * strideZ ) ] = Z[ nn - ( 7 * strideZ ) ];
+ Z[ nn - ( 7 * strideZ ) ] = s;
+ }
+ t = 0.5 * ( ( Z[ nn - ( 7 * strideZ ) ] - Z[ nn - ( 3 * strideZ ) ] ) + Z[ nn - ( 5 * strideZ ) ] );
+ if ( Z[ nn - ( 5 * strideZ ) ] > Z[ nn - ( 3 * strideZ ) ] * TOL2 && t !== 0.0 ) {
+ s = Z[ nn - ( 3 * strideZ ) ] * ( Z[ nn - ( 5 * strideZ ) ] / t );
+ if ( s <= t ) {
+ s = Z[ nn - ( 3 * strideZ ) ] * ( Z[ nn - ( 5 * strideZ ) ] / ( t * ( 1.0 + sqrt( 1.0 + ( s / t ) ) ) ) );
+ } else {
+ s = Z[ nn - ( 3 * strideZ ) ] * ( Z[ nn - ( 5 * strideZ ) ] / ( t + ( sqrt( t ) * sqrt( t + s ) ) ) );
+ }
+ t = Z[ nn - ( 7 * strideZ ) ] + ( s + Z[ nn - ( 5 * strideZ ) ] );
+ Z[ nn - ( 3 * strideZ ) ] = Z[ nn - ( 3 * strideZ ) ] * ( Z[ nn - ( 7 * strideZ ) ] / t );
+ Z[ nn - ( 7 * strideZ ) ] = t;
+ }
+ Z[ idx3 - ( strideZ * 4 ) ] = Z[ nn - ( 7 * strideZ ) ] + sigma;
+ Z[ idx3 ] = Z[ nn - ( 3 * strideZ ) ] + sigma;
+ N0 -= 2;
+ }
+
+ // 50: No deflation, need shift
+ if ( PP === 2 ) {
+ PP = 0;
+ }
+
+ // Reverse the qd-array, if warranted
+ if ( dmin <= 0.0 || N0 < n0in ) {
+ if ( CBIAS * Z[ idx4 + ( strideZ * PP ) ] < Z[ idx3 + ( strideZ * PP ) ] ) {
+ ipn4 = ( 4 * ( I0 + N0 ) ) + 7;
+ for ( j4 = ( 4 * I0 ) + 3; j4 <= ( 2 * ( I0 + N0 ) ) + 1; j4 += 4 ) {
+ idx1 = offsetZ + ( strideZ * ( j4 - 3 ) );
+ idx2 = offsetZ + ( strideZ * ( ipn4 - j4 - 4 ) );
+
+ temp = Z[ idx1 ];
+ Z[ idx1 ] = Z[ idx2 ];
+ Z[ idx2 ] = temp;
+
+ idx1 += strideZ;
+ idx2 += strideZ;
+
+ temp = Z[ idx1 ];
+ Z[ idx1 ] = Z[ idx2 ];
+ Z[ idx2 ] = temp;
+
+ idx1 += strideZ;
+ idx2 -= 3*strideZ;
+
+ temp = Z[ idx1 ];
+ Z[ idx1 ] = Z[ idx2 ];
+ Z[ idx2 ] = temp;
+
+ idx1 += strideZ;
+ idx2 += strideZ;
+
+ temp = Z[ idx1 ];
+ Z[ idx1 ] = Z[ idx2 ];
+ Z[ idx2 ] = temp;
+ }
+ if ( ( N0 - I0 ) <= 4 ) {
+ Z[ idx3 + ( strideZ * ( PP + 2 ) ) ] = Z[ idx4 + ( strideZ * ( PP + 2 ) ) ];
+ Z[ idx3 + ( strideZ * ( 3 - PP ) ) ] = Z[ idx4 + ( strideZ * ( 3 - PP ) ) ];
+ }
+ dmin2 = min( dmin2, Z[ idx3 + ( strideZ * ( PP + 2 ) ) ] );
+ Z[ idx3 + ( strideZ * ( PP + 2 ) ) ] = min( Z[ idx3 + ( strideZ * ( PP + 2 ) ) ], min( Z[ idx4 + ( strideZ * ( PP + 2 ) ) ], Z[ idx4 + ( strideZ * ( PP + 6 ) ) ] ) );
+ Z[ idx3 + ( strideZ * ( 3 - PP ) ) ] = min( Z[ idx3 + ( strideZ * ( 3 - PP ) ) ], min( Z[ idx4 + ( strideZ * ( 3 - PP ) ) ], Z[ idx4 + ( strideZ * ( 7 - PP ) ) ] ) );
+ qmax = max( qmax, Z[ idx4 + ( strideZ * ( PP ) ) ], Z[ idx4 + ( strideZ * ( PP + 4 ) ) ] );
+ dmin = -0.0;
+ }
+ }
+
+ // Choose a shift
+ out1 = new Float64Array( 3 );
+ out1[ 1 ] = ttype;
+ out1[ 2 ] = g;
+ dlasq4( I0, N0, Z, strideZ, offsetZ, PP, n0in, dmin, dmin1, dmin2, dn, dn1, dn2, out1, 1, 0 );
+ tau = out1[ 0 ];
+ ttype = out1[ 1 ];
+ g = out1[ 2 ];
+
+ // Call DQDS until DMIN > 0
+ out1 = new Float64Array( 6 );
+ while ( true ) {
+ dlasq5( I0, N0, Z, strideZ, offsetZ, PP, tau, sigma, IEEE, EPS, out1, 1, 0 );
+ dmin = out1[ 0 ];
+ dmin1 = out1[ 1 ];
+ dmin2 = out1[ 2 ];
+ dn = out1[ 3 ];
+ dn1 = out1[ 4 ];
+ dn2 = out1[ 5 ];
+
+ ndiv += ( N0 - I0 + 2 );
+ iter += 1;
+
+ // Check status
+ if ( dmin >= 0.0 && dmin1 >= 0.0 ) {
+ // Success
+ goto80 = false;
+ break;
+ } else if ( dmin < 0.0 && dmin1 > 0.0 && Z[ idx3 - ( strideZ * ( PP + 1 ) ) ] < TOL * ( sigma + dn1 ) && abs( dn ) < TOL * sigma ) {
+ // Convergence hidden by negative DN
+ Z[ idx3 + ( strideZ * ( 1 - PP ) ) ] = 0.0;
+ dmin = 0.0;
+ goto80 = false;
+ break;
+ } else if ( dmin < 0.0 ) {
+ // TAU too big. Select new TAU and try again.
+ nfail += 1;
+ if ( ttype < -22 ) {
+ // Failed twice. Play it safe.
+ tau = 0.0;
+ } else if ( dmin1 > 0.0 ) {
+ // Late failure. Gives excellent shift.
+ tau = ( tau + dmin ) * ( 1.0 - ( 2.0 * EPS ) );
+ ttype -= 11;
+ } else {
+ // Early failure. Divide by 4.
+ tau *= 0.25;
+ ttype -= 12;
+ }
+ continue;
+ } else if ( isnan( dmin ) ) {
+ // NaN
+ if ( tau === 0.0 ) {
+ goto80 = true;
+ break;
+ }
+ tau = 0.0;
+ continue;
+ }
+ // Possible underflow. Play it safe.
+ goto80 = true;
+ break;
+ }
+
+ // Risk of underflow
+ if ( goto80 ) {
+ out1 = new Float64Array( 6 );
+ dlasq6( I0, N0, Z, strideZ, offsetZ, PP, out1, 1, 0 );
+ dmin = out1[ 0 ];
+ dmin1 = out1[ 1 ];
+ dmin2 = out1[ 2 ];
+ dn = out1[ 3 ];
+ dn1 = out1[ 4 ];
+ dn2 = out1[ 5 ];
+ ndiv += ( N0 - I0 + 2 );
+ iter += 1;
+ tau = 0.0;
+ }
+
+ if ( tau < sigma ) {
+ desig += tau;
+ t = sigma + desig;
+ desig -= ( t - sigma );
+ } else {
+ t = sigma + tau;
+ desig = sigma - ( t - tau ) + desig;
+ }
+ sigma = t;
+
+ // Store output values
+ idx = offsetOut;
+ out[ idx ] = dmin;
+ idx += strideOut;
+ out[ idx ] = sigma;
+ idx += strideOut;
+ out[ idx ] = desig;
+ idx += strideOut;
+ out[ idx ] = qmax;
+ idx += strideOut;
+ out[ idx ] = nfail;
+ idx += strideOut;
+ out[ idx ] = iter;
+ idx += strideOut;
+ out[ idx ] = ndiv;
+ idx += strideOut;
+ out[ idx ] = ttype;
+ idx += strideOut;
+ out[ idx ] = dmin1;
+ idx += strideOut;
+ out[ idx ] = dmin2;
+ idx += strideOut;
+ out[ idx ] = dn;
+ idx += strideOut;
+ out[ idx ] = dn1;
+ idx += strideOut;
+ out[ idx ] = dn2;
+ idx += strideOut;
+ out[ idx ] = g;
+ idx += strideOut;
+ out[ idx ] = tau;
+
+ return out;
+}
+
+
+// EXPORTS //
+
+module.exports = dlasq3;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/dlasq3.js b/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/dlasq3.js
new file mode 100644
index 000000000000..b4d2f9130eb5
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/dlasq3.js
@@ -0,0 +1,56 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var base = require( './base.js' );
+
+
+// MAIN //
+
+/**
+* Checks for deflation, computes a shift (`TAU`) and calls DQDS. In case of failure it changes shifts, and tries again until output is positive.
+*
+* @param {integer} I0 - first index
+* @param {integer} N0 - last index
+* @param {Float64Array} Z - qd array
+* @param {integer} PP - ping-pong flag (0 or 1)
+* @param {boolean} IEEE - IEEE arithmetic flag
+* @param {Float64Array} out - output array containing `DMIN`, `SIGMA`, `DESIG`, `QMAX`, `NFAIL`, `ITER`, `NDIV`, `TTYPE`, `DMIN1`, `DMIN2`, `DN`, `DN1`, `DN2`, `G` and `TAU`
+* @returns {Float64Array} output array
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var out = new Float64Array( 15 );
+* var Z = new Float64Array( [ 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ] );
+*
+* dlasq3( 0, 3, Z, 0, true, out );
+* // Z => [ 100.0, 181.0, 81.0, ~28.641, 64.0, ~84.359, 49.0, ~20.911, ~36.0, ~40.089, 25.0, ~9.978, 16.0, ~6.022, 9.0, ~28.641 ]
+* // out => [ ~6.022, 0.0, 0.0, 0.0, 0.0, 1.0, 5.0, -1.0, ~15.089, ~35.359, ~6.022, 15.089, 35.359, 0.0, 0.0 ]
+*/
+function dlasq3( I0, N0, Z, PP, IEEE, out ) {
+ return base( I0, N0, Z, 1, 0, PP, IEEE, out, 1, 0 );
+}
+
+
+// EXPORTS //
+
+module.exports = dlasq3;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/dlasq4.js b/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/dlasq4.js
new file mode 100644
index 000000000000..53117a0a6373
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/dlasq4.js
@@ -0,0 +1,401 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var max = require( '@stdlib/math/base/special/max' );
+var min = require( '@stdlib/math/base/special/min' );
+var sqrt = require( '@stdlib/math/base/special/sqrt' );
+
+
+// MAIN //
+
+/**
+* Computes an approximation to the smallest eigenvalue using values of d from the previous transform.
+*
+* ## Notes
+*
+* - `Z` is a 1-D array of length >= `4*N0` storing interleaved q/e values.
+* - `PP` is `0` for ping, `1` for pong.
+* - `TAU` is approximation to the smallest eigenvalue and is used as a shift to accelerate convergence of the dqds iteration.
+* - `TTYPE` is an integer flag describing how TAU was computed.
+* - `G` is a state variable that is preserved across successive calls and is used to regulate the magnitude of fallback shifts.
+*
+* @private
+* @param {integer} I0 - first index
+* @param {integer} N0 - last index
+* @param {Float64Array} Z - qd array
+* @param {integer} strideZ - stride length for `Z`
+* @param {NonNegativeInteger} offsetZ - starting index for `Z`
+* @param {integer} PP - ping-pong flag (0 or 1)
+* @param {integer} N0IN - value of `N0` at the start of `EIGTEST`
+* @param {number} DMIN - minimum value of `d`
+* @param {number} DMIN1 - minimum value of `d`, excluding `D(N0)`
+* @param {number} DMIN2 - minimum value of `d`, excluding `D(N0)` and `D(N0-1)`
+* @param {number} DN - `d(N)`
+* @param {number} DN1 - `d(N-1)`
+* @param {number} DN2 - `d(N-2)`
+* @param {Float64Array} out - output array containing `tau`, `ttype`, and `G`
+* @param {integer} strideOut - stride length for `out`
+* @param {NonNegativeInteger} offsetOut - starting index for `out`
+* @returns {Float64Array} output array
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var out = new Float64Array( [ 0, 0, 0.25 ] );
+* var Z = new Float64Array( [ 5, 0, 7, 0, 9, 0, 3, 0, 10, 0, 4.5, 0, 18, 0, 0, 0 ] );
+*
+* dlasq4( 0, 3, Z, 1, 0, 0, 3, 0.2, 0.15, 0.1, 0.8, 0.7, 0.6, out, 1, 0 );
+* // out => [ ~0.05, -6, 0.25 ]
+*/
+function dlasq4( I0, N0, Z, strideZ, offsetZ, PP, N0IN, DMIN, DMIN1, DMIN2, DN, DN1, DN2, out, strideOut, offsetOut ) { // eslint-disable-line max-len, max-params
+ var CNST1;
+ var CNST2;
+ var CNST3;
+ var ttype;
+ var idx2;
+ var gap1;
+ var gap2;
+ var gam;
+ var idx;
+ var tau;
+ var a2;
+ var b1;
+ var b2;
+ var i4;
+ var nn;
+ var np;
+ var G;
+ var s;
+
+ idx2 = offsetOut;
+ tau = out[ idx2 ];
+ idx2 += strideOut;
+ ttype = out[ idx2 ];
+ idx2 += strideOut;
+ G = out[ idx2 ];
+
+ CNST1 = 0.563;
+ CNST2 = 1.010;
+ CNST3 = 1.050;
+
+ // A negative DMIN forces the shift to take that absolute value TTYPE records the type of shift.
+ if ( DMIN <= 0 ) {
+ tau = -DMIN;
+ ttype = -1;
+
+ idx2 = offsetOut;
+ out[ idx2 ] = tau;
+ idx2 += strideOut;
+ out[ idx2 ] = ttype;
+ idx2 += strideOut;
+ out[ idx2 ] = G;
+ return out;
+ }
+
+ nn = offsetZ + ( strideZ*( ( 4*N0 ) + PP + 3 ) );
+
+ if ( N0IN === N0 ) {
+ // No eigenvalues deflated.
+ if ( DMIN === DN || DMIN === DN1 ) {
+ b1 = sqrt( Z[ nn - ( 3*strideZ ) ] )*sqrt( Z[ nn - ( 5*strideZ ) ] );
+ b2 = sqrt( Z[ nn - ( 7*strideZ ) ] )*sqrt( Z[ nn - ( 9*strideZ ) ] );
+ a2 = Z[ nn - ( 7*strideZ ) ] + Z[ nn - ( 5*strideZ ) ];
+
+ // Cases 2 and 3.
+ if ( DMIN === DN && DMIN1 === DN1 ) {
+ gap2 = DMIN2 - a2 - ( DMIN2*0.25 );
+
+ if ( gap2 > 0 && gap2 > b2 ) {
+ gap1 = a2 - DN - ( ( b2 / gap2 )*b2 );
+ } else {
+ gap1 = a2 - DN - ( b1 + b2 );
+ }
+ if ( gap1 > 0 && gap1 > b1 ) {
+ s = max( DN - ( ( b1 / gap1 )*b1 ), 0.5*DMIN );
+ ttype = -2;
+ } else {
+ s = 0;
+ if ( DN > b1 ) {
+ s = DN - b1;
+ }
+ if ( a2 > ( b1 + b2 ) ) {
+ s = min( s, a2 - ( b1 + b2 ) );
+ }
+ s = max( s, 0.333*DMIN );
+ ttype = -3;
+ }
+ } else {
+ // Case 4.
+ ttype = -4;
+ s = 0.25*DMIN;
+
+ if ( DMIN === DN ) {
+ gam = DN;
+ a2 = 0;
+ if ( Z[ nn - ( 5*strideZ ) ] > Z[ nn - ( 7*strideZ ) ] ) {
+ idx2 = offsetOut + strideOut;
+ out[ idx2 ] = ttype;
+ idx2 += strideOut;
+ out[ idx2 ] = G;
+ return out;
+ }
+ b2 = Z[ nn - ( 5*strideZ ) ] / Z[ nn - ( 7*strideZ ) ];
+ np = nn - ( 9*strideZ );
+ } else {
+ np = nn - ( 2*PP*strideZ );
+ gam = DN1;
+ if ( Z[ np - ( 4*strideZ ) ] > Z[ np - ( 2*strideZ ) ] ) {
+ idx2 = offsetOut + strideOut;
+ out[ idx2 ] = ttype;
+ idx2 += strideOut;
+ out[ idx2 ] = G;
+ return out;
+ }
+ a2 = Z[ np - ( 4*strideZ ) ] / Z[ np - ( 2*strideZ ) ];
+ if ( Z[ nn - ( 9*strideZ ) ] > Z[ nn - ( 11*strideZ ) ] ) {
+ idx2 = offsetOut + strideOut;
+ out[ idx2 ] = ttype;
+ idx2 += strideOut;
+ out[ idx2 ] = G;
+ return out;
+ }
+ b2 = Z[ nn - ( 9*strideZ ) ] / Z[ nn - ( 11*strideZ ) ];
+ np = nn - ( 13*strideZ );
+ }
+
+ // Approximate contribution to norm squared from I < NN-1.
+ a2 += b2;
+ i4 = np;
+ for ( idx = ( np - offsetZ ) / strideZ; idx >= ( 4*I0 ) + PP + 2; idx -= 4 ) {
+ if ( b2 === 0 ) {
+ break;
+ }
+ b1 = b2;
+ if ( Z[ i4 ] > Z[ i4 - ( 2*strideZ ) ] ) {
+ idx2 = offsetOut + strideOut;
+ out[ idx2 ] = ttype;
+ idx2 += strideOut;
+ out[ idx2 ] = G;
+ return out;
+ }
+ b2 *= Z[ i4 ] / Z[ i4 - ( 2*strideZ ) ];
+ a2 += b2;
+ if ( ( 100*max( b2, b1 ) ) < a2 || CNST1 < a2 ) {
+ break;
+ }
+ i4 -= 4*strideZ;
+ }
+ a2 *= CNST3;
+
+ // Rayleigh quotient residual bound.
+ if ( a2 < CNST1 ) {
+ s = gam*( 1 - sqrt( a2 ) ) / ( 1 + a2 );
+ }
+ }
+ } else if ( DMIN === DN2 ) {
+ // Case 5.
+ ttype = -5;
+ s = 0.25*DMIN;
+
+ // Compute contribution to norm squared from I > NN-2.
+ np = nn - ( 2*PP*strideZ );
+ b1 = Z[ np - ( 2*strideZ ) ];
+ b2 = Z[ np - ( 6*strideZ ) ];
+ gam = DN2;
+ if ( Z[ np - ( 8*strideZ ) ] > b2 || Z[ np - ( 4*strideZ ) ] > b1 ) {
+ idx2 = offsetOut + strideOut;
+ out[ idx2 ] = ttype;
+ idx2 += strideOut;
+ out[ idx2 ] = G;
+ return out;
+ }
+ a2 = ( Z[ np - ( 8*strideZ ) ] / b2 )*( 1 + ( Z[ np - ( 4*strideZ ) ] / b1 ) );
+
+ // Approximate contribution to norm squared from I < NN-2.
+ if ( ( N0 - I0 ) > 2 ) {
+ b2 = Z[ nn - ( 13*strideZ ) ] / Z[ nn - ( 15*strideZ ) ];
+ a2 += b2;
+
+ i4 = nn - ( strideZ*17 );
+ for ( idx = ( ( nn - offsetZ ) / strideZ ) - 17; idx >= ( 4*I0 ) + PP + 2; idx -= 4 ) {
+ if ( b2 === 0 ) {
+ break;
+ }
+ b1 = b2;
+ if ( Z[ i4 ] > Z[ i4 - ( 2*strideZ ) ] ) {
+ idx2 = offsetOut + strideOut;
+ out[ idx2 ] = ttype;
+ idx2 += strideOut;
+ out[ idx2 ] = G;
+ return out;
+ }
+ b2 *= ( Z[ i4 ] / Z[ i4 - ( 2*strideZ ) ] );
+ a2 += b2;
+ if ( ( 100*max( b2, b1 ) ) < a2 || CNST1 < a2 ) {
+ break;
+ }
+ i4 -= 4*strideZ;
+ }
+ a2 *= CNST3;
+ }
+
+ if ( a2 < CNST1 ) {
+ s = gam * ( 1 - sqrt( a2 ) ) / ( 1 + a2 );
+ }
+ } else {
+ // Case 6, no information to guide us.
+ if ( ttype === -6 ) { // Case when `ttype` is previously set by another routine.
+ G += 0.333*( 1 - G );
+ } else if ( ttype === -18 ) { // Case when `ttype` is previously set by another routine.
+ G += 0.25*0.333;
+ } else {
+ G = 0.25;
+ }
+ s = G*DMIN;
+ ttype = -6;
+ }
+ } else if ( N0IN === ( N0 + 1 ) ) {
+ // 1 eigenvalue just deflated. Use DMIN1, DN1 for DMIN and DN.
+ if ( DMIN1 === DN1 && DMIN2 === DN2 ) {
+ // Cases 7 and 8.
+ ttype = -7;
+ s = 0.3330*DMIN1;
+
+ if ( Z[ nn - ( 5*strideZ ) ] > Z[ nn - ( 7*strideZ ) ] ) {
+ idx2 = offsetOut + strideOut;
+ out[ idx2 ] = ttype;
+ idx2 += strideOut;
+ out[ idx2 ] = G;
+ return out;
+ }
+
+ b1 = Z[ nn - ( 5*strideZ ) ] / Z[ nn - ( 7*strideZ ) ];
+ b2 = b1;
+
+ if ( b2 !== 0 ) {
+ i4 = offsetZ + ( strideZ*( ( 4*N0 ) - 6 + PP ) );
+ for ( idx = 2; idx >= 0; idx-- ) {
+ a2 = b1;
+ if ( Z[ i4 ] > Z[ i4 - ( 2*strideZ ) ] ) {
+ idx2 = offsetOut + strideOut;
+ out[ idx2 ] = ttype;
+ idx2 += strideOut;
+ out[ idx2 ] = G;
+ return out;
+ }
+ b1 *= Z[ i4 ] / Z[ i4 - ( 2*strideZ ) ];
+ b2 += b1;
+
+ if ( ( 100*max( b1, a2 ) ) < b2 ) {
+ break;
+ }
+ i4 -= 4*strideZ;
+ }
+ }
+
+ b2 = sqrt( CNST3*b2 );
+ a2 = DMIN1 / ( 1 + ( b2*b2 ) );
+ gap2 = ( 0.5*DMIN2 ) - a2;
+
+ if ( gap2 > 0 && gap2 > ( b2*a2 ) ) {
+ s = max( s, a2*( 1 - ( CNST2*a2*( b2 / gap2 )*b2 ) ) );
+ } else {
+ s = max( s, a2*( 1 - ( CNST2*b2 ) ) );
+ ttype = -8;
+ }
+ } else {
+ // Case 9.
+ s = 0.25*DMIN1;
+ if ( DMIN1 === DN1 ) {
+ s = 0.5*DMIN1;
+ }
+ ttype = -9;
+ }
+ } else if ( N0IN === ( N0 + 2 ) ) {
+ // 2 eigenvalues deflated. Use DMIN2, DN2 for DMIN and DN.
+
+ // Cases 10 and 11.
+ if ( DMIN2 === DN2 && ( 2*Z[ nn - ( 5*strideZ ) ] ) < Z[ nn - ( 7*strideZ ) ] ) {
+ ttype = -10;
+ s = 0.3330*DMIN2;
+ if ( Z[ nn - ( 5*strideZ ) ] > Z[ nn - ( 7*strideZ ) ] ) {
+ idx2 = offsetOut + strideOut;
+ out[ idx2 ] = ttype;
+ idx2 += strideOut;
+ out[ idx2 ] = G;
+ return out;
+ }
+ b1 = Z[ nn - ( 5*strideZ ) ] / Z[ nn - ( 7*strideZ ) ];
+ b2 = b1;
+ if ( b2 !== 0 ) {
+ i4 = offsetZ + ( strideZ*( ( 4*N0 ) - 6 + PP ) );
+ for ( idx = 1; idx >= 0; idx-- ) {
+ if ( Z[ i4 ] > Z[ i4 - ( 2*strideZ ) ] ) {
+ idx2 = offsetOut + strideOut;
+ out[ idx2 ] = ttype;
+ idx2 += strideOut;
+ out[ idx2 ] = G;
+ return out;
+ }
+ b1 *= ( Z[ i4 ] / Z[ i4 - ( 2*strideZ ) ] );
+ b2 += b1;
+ if ( ( 100*b1 ) < b2 ) {
+ break;
+ }
+ i4 -= 4*strideZ;
+ }
+ }
+
+ b2 = sqrt( CNST3*b2 );
+ a2 = DMIN2 / ( 1 + ( b2*b2 ) );
+ gap2 = Z[ nn - ( 7*strideZ ) ] + Z[ nn - ( 9*strideZ ) ] - ( sqrt( Z[ nn - ( 11*strideZ ) ] )*sqrt( Z[ nn - ( 9*strideZ ) ] ) ) - a2;
+ if ( gap2 > 0 && gap2 > ( b2*a2 ) ) {
+ s = max( s, a2*( 1 - ( CNST2*a2*( b2 / gap2 )*b2 ) ) );
+ } else {
+ s = max( s, a2*( 1 - ( CNST2*b2 ) ) );
+ }
+ } else {
+ // Case 11.
+ s = 0.25*DMIN2;
+ ttype = -11;
+ }
+ } else if ( N0IN > ( N0 + 2 ) ) {
+ // Case 12, more than 2 eigenvalues deflated. No information.
+ s = 0;
+ ttype = -12;
+ }
+
+ tau = s;
+
+ idx2 = offsetOut;
+ out[ idx2 ] = tau;
+ idx2 += strideOut;
+ out[ idx2 ] = ttype;
+ idx2 += strideOut;
+ out[ idx2 ] = G;
+ return out;
+}
+
+
+// EXPORTS //
+
+module.exports = dlasq4;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/dlasq5.js b/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/dlasq5.js
new file mode 100644
index 000000000000..8c938fe35377
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/dlasq5.js
@@ -0,0 +1,331 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var min = require( '@stdlib/math/base/special/min' );
+
+
+// MAIN //
+
+/**
+* Computes one dqds transform in ping-pong form.
+*
+* ## Notes
+*
+* - `Z` is a 1-D array of length >= `4*N0` storing interleaved q/e values.
+* - `PP` is `0` for ping, `1` for pong.
+*
+* @private
+* @param {integer} I0 - the first index
+* @param {integer} N0 - the last index
+* @param {Float64Array} Z - the QD array
+* @param {integer} strideZ - stride length for `Z`
+* @param {NonNegativeInteger} offsetZ - starting index for `Z`
+* @param {integer} PP - ping-pong flag (0 or 1)
+* @param {number} TAU - the shift
+* @param {number} SIGMA - the accumulated shift
+* @param {boolean} IEEE - IEEE arithmetic flag
+* @param {number} EPS - epsilon used by the routine
+* @param {Float64Array} out - output array containing `DMIN`, `DMIN1`, `DMIN2`, `DN`, `DNM1`, and `DNM2` respectively
+* @param {integer} strideOut - stride length for `out`
+* @param {NonNegativeInteger} offsetOut - starting index of `out`
+* @returns {Float64Array} output array
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var out = new Float64Array( 6 );
+* var Z = new Float64Array( [ 5, 0, 7, 0, 9, 0, 3, 0, 11, 0, 4, 0, 20, 0, 0, 0 ] );
+*
+* dlasq5( 0, 3, Z, 1, 0, 0, 0.1, 0.0, true, 2.220446049250313e-16, out, 1, 0 );
+* // out => [ ~3.606, ~3.606, ~3.606, ~11.823, ~5.904, ~3.606 ]
+*/
+function dlasq5( I0, N0, Z, strideZ, offsetZ, PP, TAU, SIGMA, IEEE, EPS, out, strideOut, offsetOut ) { // eslint-disable-line max-len, max-params
+ var dthresh;
+ var dmin1;
+ var dmin2;
+ var dnm1;
+ var dnm2;
+ var emin;
+ var dmin;
+ var temp;
+ var j4p2;
+ var idx;
+ var j4;
+ var dn;
+ var d;
+
+ // Quick return...
+ if ( ( N0 - I0 - 1 ) <= 0 ) {
+ return out;
+ }
+
+ dthresh = EPS * ( SIGMA + TAU );
+ if ( TAU < ( dthresh * 0.5 ) ) {
+ TAU = 0;
+ }
+
+ if ( TAU > 0 || TAU < 0 ) {
+ j4 = offsetZ + ( strideZ*( ( 4*I0 ) + PP ) );
+ emin = Z[ j4 + ( 4*strideZ ) ];
+ d = Z[ j4 ] - TAU;
+ dmin = d;
+ dmin1 = -Z[ j4 ];
+
+ if ( IEEE ) {
+ if ( PP === 0 ) {
+ j4 = offsetZ + ( strideZ * ( ( 4*I0 ) + 3 ) );
+ for ( idx = ( 4*I0 ) + 3; idx <= ( 4*N0 ) - 9; idx += 4 ) {
+ Z[ j4 - ( 2*strideZ ) ] = d + Z[ j4 - strideZ ];
+ temp = Z[ j4 + strideZ ] / Z[ j4 - ( 2*strideZ ) ];
+ d = ( d*temp ) - TAU;
+ dmin = min( dmin, d );
+ Z[ j4 ] = Z[ j4 - strideZ ]*temp;
+ emin = min( Z[ j4 ], emin );
+ j4 += 4*strideZ;
+ }
+ } else {
+ j4 = offsetZ + ( strideZ * ( ( 4*I0 ) + 3 ) );
+ for ( idx = ( 4*I0 ) + 3; idx <= ( 4*N0 ) - 9; idx += 4 ) {
+ Z[ j4 - ( 3*strideZ ) ] = d + Z[ j4 ];
+ temp = Z[ j4 + ( 2*strideZ ) ] / Z[ j4 - ( 3*strideZ ) ];
+ d = ( d*temp ) - TAU;
+ dmin = min( dmin, d );
+ Z[ j4 - strideZ ] = Z[ j4 ] * temp;
+ emin = min( Z[ j4 - strideZ ], emin );
+ j4 += 4*strideZ;
+ }
+ }
+
+ // Unroll last two steps.
+ dnm2 = d;
+ dmin2 = dmin;
+
+ j4 = offsetZ + ( strideZ * ( ( 4*N0 ) - 5 - PP ) );
+ j4p2 = j4 + ( strideZ * ( ( 2*PP ) - 1 ) );
+ Z[ j4 - ( 2*strideZ ) ] = dnm2 + Z[ j4p2 ];
+ Z[ j4 ] = Z[ j4p2 + ( 2*strideZ ) ] * ( Z[ j4p2 ] / Z[ j4 - ( 2*strideZ ) ] );
+ dnm1 = ( Z[ j4p2 + ( 2*strideZ ) ]*( dnm2 / Z[ j4 - ( 2*strideZ ) ] ) ) - TAU;
+ dmin = min( dmin, dnm1 );
+
+ dmin1 = dmin;
+ j4 += 4*strideZ;
+ j4p2 = j4 + ( strideZ * ( ( 2*PP ) - 1 ) );
+ Z[ j4 - ( 2*strideZ ) ] = dnm1 + Z[ j4p2 ];
+ Z[ j4 ] = Z[ j4p2 + ( 2*strideZ ) ] * ( Z[ j4p2 ] / Z[ j4 - ( 2*strideZ ) ] );
+ dn = ( Z[ j4p2 + ( 2*strideZ ) ]*( dnm1 / Z[ j4 - ( 2*strideZ ) ] ) ) - TAU;
+ dmin = min( dmin, dn );
+ } else {
+ if ( PP === 0 ) {
+ j4 = offsetZ + ( strideZ * ( ( 4*I0 ) + 3 ) );
+ for ( idx = ( 4*I0 ) + 3; idx <= ( 4*N0 ) - 9; idx += 4 ) {
+ Z[ j4 - ( 2*strideZ ) ] = d + Z[ j4 - strideZ ];
+ if ( d < 0 ) {
+ return out;
+ }
+ Z[ j4 ] = Z[ j4 + strideZ ] * ( Z[ j4 - strideZ ] / Z[ j4 - ( 2*strideZ ) ] );
+ d = ( Z[ j4 + strideZ ]*( d / Z[ j4 - ( 2*strideZ ) ] ) ) - TAU;
+ dmin = min( dmin, d );
+ emin = min( emin, Z[ j4 ] );
+ j4 += 4*strideZ;
+ }
+ } else {
+ j4 = offsetZ + ( strideZ * ( ( 4*I0 ) + 3 ) );
+ for ( idx = ( 4*I0 ) + 3; idx <= ( 4*N0 ) - 9; idx += 4 ) {
+ Z[ j4 - ( 3*strideZ ) ] = d + Z[ j4 ];
+ if ( d < 0 ) {
+ return out;
+ }
+ Z[ j4 - strideZ ] = Z[ j4 + ( 2*strideZ ) ] * ( Z[ j4 ] / Z[ j4 - ( 3*strideZ ) ] );
+ d = ( Z[ j4 + ( 2*strideZ ) ]*( d / Z[ j4 - ( 3*strideZ ) ] ) ) - TAU;
+ dmin = min( dmin, d );
+ emin = min( emin, Z[ j4 - strideZ ] );
+ j4 += 4*strideZ;
+ }
+ }
+
+ // Unroll last two steps.
+ dnm2 = d;
+ dmin2 = dmin;
+
+ j4 = offsetZ + ( strideZ * ( ( 4*N0 ) - 5 - PP ) );
+ j4p2 = j4 + ( strideZ * ( ( 2*PP ) - 1 ) );
+ Z[ j4 - ( 2*strideZ ) ] = dnm2 + Z[ j4p2 ];
+ if ( dnm2 < 0 ) {
+ return out;
+ }
+ Z[ j4 ] = Z[ j4p2 + ( 2*strideZ ) ] * ( Z[ j4p2 ] / Z[ j4 - ( 2*strideZ ) ] );
+ dnm1 = ( Z[ j4p2 + ( 2*strideZ ) ]*( dnm2 / Z[ j4 - ( 2*strideZ ) ] ) ) - TAU;
+ dmin = min( dmin, dnm1 );
+
+ dmin1 = dmin;
+ j4 += 4*strideZ;
+ j4p2 = j4 + ( strideZ * ( ( 2*PP ) - 1 ) );
+ Z[ j4 - ( 2*strideZ ) ] = dnm1 + Z[ j4p2 ];
+ if ( dnm1 < 0 ) {
+ return out;
+ }
+ Z[ j4 ] = Z[ j4p2 + ( 2*strideZ ) ] * ( Z[ j4p2 ] / Z[ j4 - ( 2*strideZ ) ] );
+ dn = ( Z[ j4p2 + ( 2*strideZ ) ]*( dnm1 / Z[ j4 - ( 2*strideZ ) ] ) ) - TAU;
+ dmin = min( dmin, dn );
+ }
+ } else {
+ // This is the version that sets d's to zero if they are small enough
+ j4 = offsetZ + ( strideZ * ( ( 4*I0 ) + PP ) );
+ emin = Z[ j4 + ( 4*strideZ ) ];
+ d = Z[ j4 ];
+ dmin = d;
+ dmin1 = -Z[ j4 ];
+
+ if ( IEEE ) {
+ if ( PP === 0 ) {
+ j4 = offsetZ + ( strideZ * ( ( 4*I0 ) + 3 ) );
+ for ( idx = ( 4*I0 ) + 3; idx <= ( 4*N0 ) - 9; idx += 4 ) {
+ Z[ j4 - ( 2*strideZ ) ] = d + Z[ j4 - strideZ ];
+ temp = Z[ j4 + strideZ ] / Z[ j4 - ( 2*strideZ ) ];
+ d = ( d*temp ) - TAU;
+ if ( d < dthresh ) {
+ d = 0;
+ }
+ dmin = min( dmin, d );
+ Z[ j4 ] = Z[ j4 - strideZ ] * temp;
+ emin = min( Z[ j4 ], emin );
+ j4 += 4*strideZ;
+ }
+ } else {
+ j4 = offsetZ + ( strideZ * ( ( 4*I0 ) + 3 ) );
+ for ( idx = ( 4*I0 ) + 3; idx <= ( 4*N0 ) - 9; idx += 4 ) {
+ Z[ j4 - ( 3*strideZ ) ] = d + Z[ j4 ];
+ temp = Z[ j4 + ( 2*strideZ ) ] / Z[ j4 - ( 3*strideZ ) ];
+ d = ( d*temp ) - TAU;
+ if ( d < dthresh ) {
+ d = 0;
+ }
+ dmin = min( dmin, d );
+ Z[ j4 - strideZ ] = Z[ j4 ] * temp;
+ emin = min( Z[ j4 - strideZ ], emin );
+ j4 += 4*strideZ;
+ }
+ }
+
+ // Unroll last two steps.
+ dnm2 = d;
+ dmin2 = dmin;
+
+ j4 = offsetZ + ( strideZ * ( ( 4*N0 ) - 5 - PP ) );
+ j4p2 = j4 + ( strideZ * ( ( 2*PP ) - 1 ) );
+ Z[ j4 - ( 2*strideZ ) ] = dnm2 + Z[ j4p2 ];
+ Z[ j4 ] = Z[ j4p2 + ( 2*strideZ ) ] * ( Z[ j4p2 ] / Z[ j4 - ( 2*strideZ ) ] );
+ dnm1 = ( Z[ j4p2 + ( 2*strideZ ) ]*( dnm2 / Z[ j4 - ( 2*strideZ ) ] ) ) - TAU;
+ dmin = min( dmin, dnm1 );
+
+ dmin1 = dmin;
+ j4 += 4*strideZ;
+ j4p2 = j4 + ( strideZ * ( ( 2*PP ) - 1 ) );
+ Z[ j4 - ( 2*strideZ ) ] = dnm1 + Z[ j4p2 ];
+ Z[ j4 ] = Z[ j4p2 + ( 2*strideZ ) ] * ( Z[ j4p2 ] / Z[ j4 - ( 2*strideZ ) ] );
+ dn = ( Z[ j4p2 + ( 2*strideZ ) ]*( dnm1 / Z[ j4 - ( 2*strideZ ) ] ) ) - TAU;
+ dmin = min( dmin, dn );
+ } else {
+ if ( PP === 0 ) {
+ j4 = offsetZ + ( strideZ * ( ( 4*I0 ) + 3 ) );
+ for ( idx = ( 4*I0 ) + 3; idx <= ( 4*N0 ) - 9; idx += 4 ) {
+ Z[ j4 - ( 2*strideZ ) ] = d + Z[ j4 - strideZ ];
+ if ( d < 0 ) {
+ return out;
+ }
+ Z[ j4 ] = Z[ j4 + strideZ ] * ( Z[ j4 - strideZ ] / Z[ j4 - ( 2*strideZ ) ] );
+ d = ( Z[ j4 + strideZ ]*( d / Z[ j4 - ( 2*strideZ ) ] ) ) - TAU;
+ if ( d < dthresh ) {
+ d = 0;
+ }
+ dmin = min( dmin, d );
+ emin = min( emin, Z[ j4 ] );
+ j4 += 4*strideZ;
+ }
+ } else {
+ j4 = offsetZ + ( strideZ * ( ( 4*I0 ) + 3 ) );
+ for ( idx = ( 4*I0 ) + 3; idx <= ( 4*N0 ) - 9; idx += 4 ) {
+ Z[ j4 - ( 3*strideZ ) ] = d + Z[ j4 ];
+ if ( d < 0 ) {
+ return out;
+ }
+ Z[ j4 - strideZ ] = Z[ j4 + ( 2*strideZ ) ] * ( Z[ j4 ] / Z[ j4 - ( 3*strideZ ) ] );
+ d = ( Z[ j4 + ( 2*strideZ ) ]*( d / Z[ j4 - ( 3*strideZ ) ] ) ) - TAU;
+ if ( d < dthresh ) {
+ d = 0;
+ }
+ dmin = min( dmin, d );
+ emin = min( emin, Z[ j4 - strideZ ] );
+ j4 += 4*strideZ;
+ }
+ }
+
+ // Unroll last two steps.
+ dnm2 = d;
+ dmin2 = dmin;
+
+ j4 = offsetZ + ( strideZ * ( ( 4*N0 ) - 5 - PP ) );
+ j4p2 = j4 + ( strideZ * ( ( 2*PP ) - 1 ) );
+ Z[ j4 - ( 2*strideZ ) ] = dnm2 + Z[ j4p2 ];
+ if ( dnm2 < 0 ) {
+ return out;
+ }
+ Z[ j4 ] = Z[ j4p2 + ( 2*strideZ ) ] * ( Z[ j4p2 ] / Z[ j4 - ( 2*strideZ ) ] );
+ dnm1 = ( Z[ j4p2 + ( 2*strideZ ) ]*( dnm2 / Z[ j4 - ( 2*strideZ ) ] ) ) - TAU;
+
+ dmin = min( dmin, dnm1 );
+ dmin1 = dmin;
+ j4 += 4*strideZ;
+ j4p2 = j4 + ( strideZ * ( ( 2*PP ) - 1 ) );
+ Z[ j4 - ( 2*strideZ ) ] = dnm1 + Z[ j4p2 ];
+ if ( dnm1 < 0 ) {
+ return out;
+ }
+ Z[ j4 ] = Z[ j4p2 + ( 2*strideZ ) ] * ( Z[ j4p2 ] / Z[ j4 - ( 2*strideZ ) ] );
+ dn = ( Z[ j4p2 + ( 2*strideZ ) ]*( dnm1 / Z[ j4 - ( 2*strideZ ) ] ) ) - TAU;
+ dmin = min( dmin, dn );
+ }
+ }
+
+ Z[ j4 + ( 2*strideZ ) ] = dn;
+ Z[ offsetZ + ( strideZ * ( ( 4*N0 ) + 3 - PP ) ) ] = emin;
+
+ idx = offsetOut;
+ out[ idx ] = dmin;
+ idx += strideOut;
+ out[ idx ] = dmin1;
+ idx += strideOut;
+ out[ idx ] = dmin2;
+ idx += strideOut;
+ out[ idx ] = dn;
+ idx += strideOut;
+ out[ idx ] = dnm1;
+ idx += strideOut;
+ out[ idx ] = dnm2;
+
+ return out;
+}
+
+
+// EXPORTS //
+
+module.exports = dlasq5;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/dlasq6.js b/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/dlasq6.js
new file mode 100644
index 000000000000..8c925518502d
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/dlasq6.js
@@ -0,0 +1,220 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var dlamch = require( '@stdlib/lapack/base/dlamch' );
+var min = require( '@stdlib/math/base/special/min' );
+
+
+// VARIABLES //
+
+var SFMIN = dlamch( 'S' );
+
+
+// MAIN //
+
+/**
+* Computes one dqd transform in ping-pong form.
+*
+* ## Notes
+*
+* - Z is a 1-D array of length >= 4*N0 storing interleaved q/e values.
+* - PP is 0 for ping, 1 for pong.
+*
+* @private
+* @param {integer} I0 - the first index
+* @param {integer} N0 - the last index
+* @param {Float64Array} Z - the QD array
+* @param {integer} strideZ - stride length for `z`
+* @param {NonNegativeInteger} offsetZ - starting index for `z`
+* @param {boolean} PP - ping-pong flag (0 or 1)
+* @param {Float64Array} out - output array containing `DMIN`, `DMIN1`, `DMIN2`, `DN`, `DNM1`, and `DNM2` respectively
+* @param {integer} strideOut - stride length for `out`
+* @param {NonNegativeInteger} offsetOut - starting index of `out`
+* @returns {Float64Array} output array
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var out = new Float64Array( 6 );
+* var Z = new Float64Array( [ 5, 0, 7, 0, 9, 0, 3, 0, 11, 0, 4, 0, 20, 0, 0, 0 ] );
+*
+* dlasq6( 0, 3, Z, 1, 0, 0, out, 1, 0 );
+* // out => [ 3.75, 3.75, 3.75, ~12.088, ~6.111, 3.75 ]
+*/
+function dlasq6( I0, N0, Z, strideZ, offsetZ, PP, out, strideOut, offsetOut ) {
+ var dmin1;
+ var dmin2;
+ var dnm1;
+ var dnm2;
+ var emin;
+ var dmin;
+ var temp;
+ var j4p2;
+ var idx;
+ var iz1;
+ var iz2;
+ var iz3;
+ var iz4;
+ var j4;
+ var dn;
+ var d;
+
+ // Quick return...
+ if ( ( N0 - I0 - 1 ) <= 0 ) {
+ return out;
+ }
+
+ idx = offsetZ;
+
+ j4 = offsetZ + ( strideZ*( ( 4*I0 ) + PP ) );
+ emin = Z[ j4 + ( 4*strideZ ) ];
+ d = Z[ j4 ];
+ dmin = d;
+
+ j4 = offsetZ + ( strideZ*( ( 4*I0 ) + 3 ) );
+
+ if ( PP === 0 ) {
+ for ( idx = ( 4*I0 ) + 3; idx <= ( 4*N0 ) - 9; idx += 4 ) {
+ iz1 = j4 + strideZ;
+ iz2 = j4 - strideZ;
+ iz3 = j4 - ( 2*strideZ );
+
+ Z[ iz3 ] = d + Z[ iz2 ];
+ if ( Z[ iz3 ] === 0 ) {
+ Z[ j4 ] = 0;
+ d = Z[ iz1 ];
+ dmin = d;
+ emin = 0;
+ } else if ( ( SFMIN*Z[ iz1 ] < Z[ iz3 ] ) &&
+ ( SFMIN*Z[ iz3 ] < Z[ iz1 ] ) ) {
+ temp = Z[ iz1 ] / Z[ iz3 ];
+ Z[ j4 ] = Z[ iz2 ]*temp;
+ d *= temp;
+ } else {
+ Z[ j4 ] = Z[ iz1 ]*( Z[ iz2 ] / Z[ iz3 ] );
+ d = Z[ iz1 ]*( d / Z[ iz3 ] );
+ }
+ dmin = min( dmin, d );
+ emin = min( emin, Z[ j4 ] );
+ j4 += 4*strideZ;
+ }
+ } else {
+ for ( idx = ( 4*I0 ) + 3; idx <= ( 4*N0 ) - 9; idx += 4 ) {
+ iz1 = j4 + ( 2*strideZ );
+ iz2 = j4 - strideZ;
+ iz3 = j4 - ( 2*strideZ );
+ iz4 = j4 - ( 3*strideZ );
+
+ Z[ iz4 ] = d + Z[ j4 ];
+ if ( Z[ iz4 ] === 0 ) {
+ Z[ iz2 ] = 0;
+ d = Z[ iz1 ];
+ dmin = d;
+ emin = 0;
+ } else if ( ( SFMIN*Z[ iz1 ] < Z[ iz4 ] ) &&
+ ( SFMIN*Z[ iz4 ] < Z[ iz1 ] ) ) {
+ temp = Z[ iz1 ] / Z[ iz4 ];
+ Z[ j4 - strideZ ] = Z[ j4 ]*temp;
+ d *= temp;
+ } else {
+ Z[ iz2 ] = Z[ iz1 ]*( Z[ j4 ] / Z[ iz4 ] );
+ d = Z[ iz1 ]*( d / Z[ iz4 ] );
+ }
+ dmin = min( dmin, d );
+ emin = min( emin, Z[ iz2 ] );
+ j4 += 4*strideZ;
+ }
+ }
+
+ // Unroll last two steps.
+ dnm2 = d;
+ dmin2 = dmin;
+ j4 = offsetZ + ( strideZ*( ( 4*N0 ) - 5 - PP ) );
+ j4p2 = j4 + ( strideZ*( ( 2*PP ) - 1 ) );
+
+ iz1 = j4 - ( 2*strideZ );
+ iz2 = j4p2 + ( 2*strideZ );
+
+ Z[ j4 - ( 2*strideZ ) ] = dnm2 + Z[ j4p2 ];
+ if ( Z[ iz1 ] === 0 ) {
+ Z[ j4 ] = 0;
+ dnm1 = Z[ iz2 ];
+ dmin = dnm1;
+ emin = 0;
+ } else if ( ( SFMIN*Z[ iz2 ] < Z[ iz1 ] ) &&
+ ( SFMIN*Z[ iz1 ] < Z[ iz2 ] ) ) {
+ temp = Z[ iz2 ] / Z[ iz1 ];
+ Z[ j4 ] = Z[ j4p2 ]*temp;
+ dnm1 = dnm2*temp;
+ } else {
+ Z[ j4 ] = Z[ iz2 ]*( Z[ j4p2 ] / Z[ iz1 ] );
+ dnm1 = Z[ iz2 ]*( dnm2 / Z[ iz1 ] );
+ }
+ dmin = min( dmin, dnm1 );
+
+ dmin1 = dmin;
+ j4 += 4*strideZ;
+ j4p2 = j4 + ( strideZ*( ( 2*PP ) - 1 ) );
+
+ iz1 = j4 - ( 2*strideZ );
+ iz2 = j4p2 + ( 2*strideZ );
+
+ Z[ iz1 ] = dnm1 + Z[ j4p2 ];
+ if ( Z[ iz1 ] === 0 ) {
+ Z[ j4 ] = 0;
+ dn = Z[ iz2 ];
+ dmin = dn;
+ emin = 0;
+ } else if ( ( SFMIN*Z[ iz2 ] < Z[ iz1 ] ) &&
+ ( SFMIN*Z[ iz1 ] < Z[ iz2 ] ) ) {
+ temp = Z[ iz2 ] / Z[ iz1 ];
+ Z[ j4 ] = Z[ j4p2 ]*temp;
+ dn = dnm1*temp;
+ } else {
+ Z[ j4 ] = Z[ iz2 ]*( Z[ j4p2 ] / Z[ iz1 ] );
+ dn = Z[ iz2 ]*( dnm1 / Z[ iz1 ] );
+ }
+ dmin = min( dmin, dn );
+
+ Z[ j4 + ( 2*strideZ ) ] = dn;
+ Z[ offsetZ + ( strideZ*( ( 4*( N0 ) ) + 3 - PP ) ) ] = emin;
+
+ idx = offsetOut;
+ out[ idx ] = dmin;
+ idx += strideOut;
+ out[ idx ] = dmin1;
+ idx += strideOut;
+ out[ idx ] = dmin2;
+ idx += strideOut;
+ out[ idx ] = dn;
+ idx += strideOut;
+ out[ idx ] = dnm1;
+ idx += strideOut;
+ out[ idx ] = dnm2;
+
+ return out;
+}
+
+
+// EXPORTS //
+
+module.exports = dlasq6;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/index.js
new file mode 100644
index 000000000000..4da303b22621
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/index.js
@@ -0,0 +1,73 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+/**
+* Check for deflation, computes a shift (`TAU`) and calls DQDS. In case of failure it changes shifts, and tries again until output is positive.
+*
+* @module @stdlib/lapack/base/dlasq3
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var dlasq3 = require( '@stdlib/lapack/base/dlasq3' );
+*
+* var out = new Float64Array( 15 );
+* var Z = new Float64Array( [ 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ] );
+*
+* dlasq3( 0, 3, Z, 0, true, out );
+* // Z => [ 100.0, 181.0, 81.0, ~28.641, 64.0, ~84.359, 49.0, ~20.911, ~36.0, ~40.089, 25.0, ~9.978, 16.0, ~6.022, 9.0, ~28.641 ]
+* // out => [ ~6.022, 0.0, 0.0, 0.0, 0.0, 1.0, 5.0, -1.0, ~15.089, ~35.359, ~6.022, 15.089, 35.359, 0.0, 0.0 ]
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var dlasq3 = require( '@stdlib/lapack/base/dlasq3' );
+*
+* var out = new Float64Array( 15 );
+* var Z = new Float64Array( [ 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ] );
+*
+* dlasq3.ndarray( 0, 3, Z, 1, 0, 0, true, out, 1, 0 );
+* // Z => [ 100.0, 181.0, 81.0, ~28.641, 64.0, ~84.359, 49.0, ~20.911, ~36.0, ~40.089, 25.0, ~9.978, 16.0, ~6.022, 9.0, ~28.641 ]
+* // out => [ ~6.022, 0.0, 0.0, 0.0, 0.0, 1.0, 5.0, -1.0, ~15.089, ~35.359, ~6.022, 15.089, 35.359, 0.0, 0.0 ]
+*/
+
+
+// MODULES //
+
+var join = require( 'path' ).join;
+var tryRequire = require( '@stdlib/utils/try-require' );
+var isError = require( '@stdlib/assert/is-error' );
+var main = require( './main.js' );
+
+
+// MAIN //
+
+var dlasq3;
+var tmp = tryRequire( join( __dirname, './native.js' ) );
+if ( isError( tmp ) ) {
+ dlasq3 = main;
+} else {
+ dlasq3 = tmp;
+}
+
+
+// EXPORTS //
+
+module.exports = dlasq3;
+
+// exports: { "ndarray": "dlasq3.ndarray" }
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/main.js b/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/main.js
new file mode 100644
index 000000000000..58d444508e7a
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/main.js
@@ -0,0 +1,35 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var dlasq3 = require( './dlasq3.js' );
+var ndarray = require( './ndarray.js' );
+
+
+// MAIN //
+
+setReadOnly( dlasq3, 'ndarray', ndarray );
+
+
+// EXPORTS //
+
+module.exports = dlasq3;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/ndarray.js
new file mode 100644
index 000000000000..3858f7bc6f98
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/lib/ndarray.js
@@ -0,0 +1,60 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var base = require( './base.js' );
+
+
+// MAIN //
+
+/**
+* Checks for deflation, computes a shift (`TAU`) and calls DQDS. In case of failure it changes shifts, and tries again until output is positive using alternative indexing semantics.
+*
+* @param {integer} I0 - first index
+* @param {integer} N0 - last index
+* @param {Float64Array} Z - qd array
+* @param {integer} strideZ - stride length for `Z`
+* @param {NonNegativeInteger} offsetZ - starting index of `Z`
+* @param {integer} PP - ping-pong flag (0 or 1)
+* @param {boolean} IEEE - IEEE arithmetic flag
+* @param {Float64Array} out - output array containing `DMIN`, `SIGMA`, `DESIG`, `QMAX`, `NFAIL`, `ITER`, `NDIV`, `TTYPE`, `DMIN1`, `DMIN2`, `DN`, `DN1`, `DN2`, `G` and `TAU`
+* @param {integer} strideOut - stride length for `out`
+* @param {NonNegativeInteger} offsetOut - starting index of `out`
+* @returns {Float64Array} output array
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var out = new Float64Array( 15 );
+* var Z = new Float64Array( [ 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ] );
+*
+* dlasq3( 0, 3, Z, 1, 0, 0, true, out, 1, 0 );
+* // Z => [ 100.0, 181.0, 81.0, ~28.641, 64.0, ~84.359, 49.0, ~20.911, ~36.0, ~40.089, 25.0, ~9.978, 16.0, ~6.022, 9.0, ~28.641 ]
+* // out => [ ~6.022, 0.0, 0.0, 0.0, 0.0, 1.0, 5.0, -1.0, ~15.089, ~35.359, ~6.022, 15.089, 35.359, 0.0, 0.0 ]
+*/
+function dlasq3( I0, N0, Z, strideZ, offsetZ, PP, IEEE, out, strideOut, offsetOut ) { // eslint-disable-line max-len
+ return base( I0, N0, Z, strideZ, offsetZ, PP, IEEE, out, strideOut, offsetOut ); // eslint-disable-line max-len
+}
+
+
+// EXPORTS //
+
+module.exports = dlasq3;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/package.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/package.json
new file mode 100644
index 000000000000..ddfeb697f4c5
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/package.json
@@ -0,0 +1,72 @@
+{
+ "name": "@stdlib/lapack/base/dlasq3",
+ "version": "0.0.0",
+ "description": "LAPACK routine to check for deflation, compute a shift (`TAU`) and call DQDS.",
+ "license": "Apache-2.0",
+ "author": {
+ "name": "The Stdlib Authors",
+ "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+ },
+ "contributors": [
+ {
+ "name": "The Stdlib Authors",
+ "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+ }
+ ],
+ "main": "./lib",
+ "directories": {
+ "benchmark": "./benchmark",
+ "doc": "./docs",
+ "example": "./examples",
+ "lib": "./lib",
+ "test": "./test"
+ },
+ "types": "./docs/types",
+ "scripts": {},
+ "homepage": "https://github.com/stdlib-js/stdlib",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/stdlib-js/stdlib.git"
+ },
+ "bugs": {
+ "url": "https://github.com/stdlib-js/stdlib/issues"
+ },
+ "dependencies": {},
+ "devDependencies": {},
+ "engines": {
+ "node": ">=0.10.0",
+ "npm": ">2.7.0"
+ },
+ "os": [
+ "aix",
+ "darwin",
+ "freebsd",
+ "linux",
+ "macos",
+ "openbsd",
+ "sunos",
+ "win32",
+ "windows"
+ ],
+ "keywords": [
+ "stdlib",
+ "stdmath",
+ "mathematics",
+ "math",
+ "lapack",
+ "svd",
+ "decomposition",
+ "dlasq3",
+ "exchange",
+ "permute",
+ "permutedims",
+ "linear",
+ "algebra",
+ "subroutines",
+ "array",
+ "ndarray",
+ "float64",
+ "double",
+ "float64array"
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/alternate.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/alternate.json
new file mode 100644
index 000000000000..0c969477e53e
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/alternate.json
@@ -0,0 +1,52 @@
+{
+ "I0": 0,
+ "N0": 3,
+
+ "Z": [ 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ],
+ "strideZ": 1,
+ "offsetZ": 0,
+
+ "PP": 1,
+ "IEEE": false,
+
+ "output": [ 0.20, 0.15, 0.10, 100.0, 0, 0, 0, -6, 0.15, 0.10, 0.80, 0.70, 0.60, 0.25, 0.0 ],
+ "strideOutput": 1,
+ "offsetOutput": 0,
+
+ "Z_out": [
+ 6.90005000000000024E+000,
+ 4.00000000000000000E+000,
+ 1.08694864529967172E+000,
+ 3.00000000000000000E+000,
+ 3.31310135470032829E+000,
+ 2.50000000000000000E+000,
+ 9.05495992672808447E-001,
+ 2.00000000000000000E+000,
+ 1.49455400732719168E+000,
+ 1.50000000000000000E+000,
+ 3.34547963839849860E-001,
+ 1.00000000000000000E+000,
+ 6.55020361601501011E-002,
+ 5.00000000000000000E-001,
+ 1.08694864529967172E+000,
+ 0.00000000000000000E+000
+ ],
+
+ "output_out": [
+ 6.55020361601501011E-002,
+ 3.49949999999999983E-001,
+ 2.77555756156289135E-017,
+ 1.00000000000000000E+002,
+ 0,
+ 1,
+ 5,
+ -6,
+ 4.94554007327191569E-001,
+ 1.31310135470032807E+000,
+ 6.55020361601501011E-002,
+ 4.94554007327191569E-001,
+ 1.31310135470032807E+000,
+ 4.99750000000000028E-001,
+ 9.99500000000000111E-002
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/big_tau.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/big_tau.json
new file mode 100644
index 000000000000..7e369de141c7
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/big_tau.json
@@ -0,0 +1,52 @@
+{
+ "I0": 0,
+ "N0": 3,
+
+ "Z": [ 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ],
+ "strideZ": 1,
+ "offsetZ": 0,
+
+ "PP": 0,
+ "IEEE": true,
+
+ "output": [ 1000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
+ "strideOutput": 1,
+ "offsetOutput": 0,
+
+ "Z_out": [
+ 1.00000000000000000E+002,
+ 1.81000000000000000E+002,
+ 8.10000000000000000E+001,
+ 2.86408839779005504E+001,
+ 6.40000000000000000E+001,
+ 8.43591160220994425E+001,
+ 4.90000000000000000E+001,
+ 2.09106031829196439E+001,
+ 3.60000000000000000E+001,
+ 4.00893968170803561E+001,
+ 2.50000000000000000E+001,
+ 9.97770063304063726E+000,
+ 1.60000000000000000E+001,
+ 6.02229936695936185E+000,
+ 9.00000000000000000E+000,
+ 2.86408839779005504E+001
+ ],
+
+ "output_out": [
+ 6.02229936695936185E+000,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 3,
+ 4,
+ 20,
+ -30,
+ 1.50893968170803561E+001,
+ 3.53591160220994425E+001,
+ 6.02229936695936185E+000,
+ 1.50893968170803561E+001,
+ 3.53591160220994425E+001,
+ 2.50000000000000000E-001,
+ 0.00000000000000000E+000
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/deflate1.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/deflate1.json
new file mode 100644
index 000000000000..49d566d77f07
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/deflate1.json
@@ -0,0 +1,52 @@
+{
+ "I0": 0,
+ "N0": 0,
+
+ "Z": [ 5.0, 0.0, 7.0, 0.0, 9.0, 0.0, 3.0, 0.0, 11.0, 0.0, 4.0, 0.0, 20.0, 0.0, 0.0, 0.0 ],
+ "strideZ": 1,
+ "offsetZ": 0,
+
+ "PP": 0,
+ "IEEE": true,
+
+ "output": [ 0.0, 1.0, 0.0, 20.0, 0, 0, 0, 0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.25, 0.0 ],
+ "strideOutput": 1,
+ "offsetOutput": 0,
+
+ "Z_out": [
+ 6.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 7.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 9.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 3.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 1.10000000000000000E+001,
+ 0.00000000000000000E+000,
+ 4.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 2.00000000000000000E+001,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000
+ ],
+
+ "output_out": [
+ 0.00000000000000000E+000,
+ 1.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 2.00000000000000000E+001,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 2.50000000000000000E-001,
+ 0.00000000000000000E+000
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/deflate2.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/deflate2.json
new file mode 100644
index 000000000000..73fd16b25ebd
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/deflate2.json
@@ -0,0 +1,52 @@
+{
+ "I0": 0,
+ "N0": 1,
+
+ "Z": [ 25.0, 1.5, 16.0, 2.0, 12.0, 1.0, 8.0, 1.2, 6.0, 0.8, 4.0, 0.5, 2.0, 0.2, 1.0, 0.0 ],
+ "strideZ": 1,
+ "offsetZ": 0,
+
+ "PP": 1,
+ "IEEE": true,
+
+ "output": [ -0.05, 0.15, 0.10, 25.0, 0, 2, 4, -6, 0.12, 0.08, 0.60, 0.40, 0.20, 0.25, 0.05 ],
+ "strideOutput": 1,
+ "offsetOutput": 0,
+
+ "Z_out": [
+ 4.28745860881768781E+000,
+ 4.13745860881768746E+000,
+ 1.60000000000000000E+001,
+ 2.00000000000000000E+000,
+ 5.12541391182312567E-001,
+ 3.62541391182312600E-001,
+ 8.00000000000000000E+000,
+ 1.19999999999999996E+000,
+ 6.00000000000000000E+000,
+ 8.00000000000000044E-001,
+ 4.00000000000000000E+000,
+ 5.00000000000000000E-001,
+ 2.00000000000000000E+000,
+ 2.00000000000000011E-001,
+ 1.00000000000000000E+000,
+ 0.00000000000000000E+000
+ ],
+
+ "output_out": [
+ -5.00000000000000028E-002,
+ 1.49999999999999994E-001,
+ 1.00000000000000006E-001,
+ 2.50000000000000000E+001,
+ 0,
+ 2,
+ 4,
+ -6,
+ 1.19999999999999996E-001,
+ 8.00000000000000017E-002,
+ 5.99999999999999978E-001,
+ 4.00000000000000022E-001,
+ 2.00000000000000011E-001,
+ 2.50000000000000000E-001,
+ 5.00000000000000028E-002
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/deflate_else.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/deflate_else.json
new file mode 100644
index 000000000000..7bc7f63bf61c
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/deflate_else.json
@@ -0,0 +1,52 @@
+{
+ "I0": 0,
+ "N0": 3,
+
+ "Z": [ 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 0, 1, 16, 0.5, 9, 0 ],
+ "strideZ": 1,
+ "offsetZ": 0,
+
+ "PP": 0,
+ "IEEE": true,
+
+ "output": [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
+ "strideOutput": 1,
+ "offsetOutput": 0,
+
+ "Z_out": [
+ 1.00000000000000000E+002,
+ 1.81000000000000000E+002,
+ 8.10000000000000000E+001,
+ 2.86408839779005540E+001,
+ 6.40000000000000000E+001,
+ 8.43591160220994425E+001,
+ 4.90000000000000000E+001,
+ 2.09106031829196439E+001,
+ 3.60000000000000000E+001,
+ 1.50893968170803614E+001,
+ 0.00000000000000000E+000,
+ 6.40000000000000000E+001,
+ 1.60000000000000000E+001,
+ 5.00000000000000000E-001,
+ 9.00000000000000000E+000,
+ 0.00000000000000000E+000
+ ],
+
+ "output_out": [
+ 1.50893968170803614E+001,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 0,
+ 1,
+ 4,
+ -1,
+ 3.53591160220994496E+001,
+ 1.00000000000000000E+002,
+ 1.50893968170803614E+001,
+ 3.53591160220994496E+001,
+ 1.00000000000000000E+002,
+ 0.00000000000000000E+000,
+ -0.00000000000000000E+000
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/alternate.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/alternate.json
new file mode 100644
index 000000000000..f98c47737e53
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/alternate.json
@@ -0,0 +1,142 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 100,
+ 9999,
+ 4,
+ 9999,
+ 81,
+ 9999,
+ 3,
+ 9999,
+ 64,
+ 9999,
+ 2.5,
+ 9999,
+ 49,
+ 9999,
+ 2,
+ 9999,
+ 36,
+ 9999,
+ 1.5,
+ 9999,
+ 25,
+ 9999,
+ 1,
+ 9999,
+ 16,
+ 9999,
+ 0.5,
+ 9999,
+ 9,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideZ": 2,
+ "offsetZ": 0,
+ "PP": 1,
+ "IEEE": false,
+ "output": [
+ 0.2,
+ 9999,
+ 0.15,
+ 9999,
+ 0.1,
+ 9999,
+ 100,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ -6,
+ 9999,
+ 0.15,
+ 9999,
+ 0.1,
+ 9999,
+ 0.8,
+ 9999,
+ 0.7,
+ 9999,
+ 0.6,
+ 9999,
+ 0.25,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideOutput": 2,
+ "offsetOutput": 0,
+ "Z_out": [
+ 6.90005,
+ 9999,
+ 4,
+ 9999,
+ 1.0869486452996717,
+ 9999,
+ 3,
+ 9999,
+ 3.3131013547003283,
+ 9999,
+ 2.5,
+ 9999,
+ 0.9054959926728084,
+ 9999,
+ 2,
+ 9999,
+ 1.4945540073271917,
+ 9999,
+ 1.5,
+ 9999,
+ 0.33454796383984986,
+ 9999,
+ 1,
+ 9999,
+ 0.0655020361601501,
+ 9999,
+ 0.5,
+ 9999,
+ 1.0869486452996717,
+ 9999,
+ 0,
+ 9999
+ ],
+ "output_out": [
+ 0.0655020361601501,
+ 9999,
+ 0.34995,
+ 9999,
+ 2.7755575615628914e-17,
+ 9999,
+ 100,
+ 9999,
+ 0,
+ 9999,
+ 1,
+ 9999,
+ 5,
+ 9999,
+ -6,
+ 9999,
+ 0.49455400732719157,
+ 9999,
+ 1.313101354700328,
+ 9999,
+ 0.0655020361601501,
+ 9999,
+ 0.49455400732719157,
+ 9999,
+ 1.313101354700328,
+ 9999,
+ 0.49975,
+ 9999,
+ 0.09995000000000001,
+ 9999
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/big_tau.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/big_tau.json
new file mode 100644
index 000000000000..3adec4f00e98
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/big_tau.json
@@ -0,0 +1,142 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 100,
+ 9999,
+ 4,
+ 9999,
+ 81,
+ 9999,
+ 3,
+ 9999,
+ 64,
+ 9999,
+ 2.5,
+ 9999,
+ 49,
+ 9999,
+ 2,
+ 9999,
+ 36,
+ 9999,
+ 1.5,
+ 9999,
+ 25,
+ 9999,
+ 1,
+ 9999,
+ 16,
+ 9999,
+ 0.5,
+ 9999,
+ 9,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideZ": 2,
+ "offsetZ": 0,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ 1000,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideOutput": 2,
+ "offsetOutput": 0,
+ "Z_out": [
+ 100,
+ 9999,
+ 181,
+ 9999,
+ 81,
+ 9999,
+ 28.64088397790055,
+ 9999,
+ 64,
+ 9999,
+ 84.35911602209944,
+ 9999,
+ 49,
+ 9999,
+ 20.910603182919644,
+ 9999,
+ 36,
+ 9999,
+ 40.089396817080356,
+ 9999,
+ 25,
+ 9999,
+ 9.977700633040637,
+ 9999,
+ 16,
+ 9999,
+ 6.022299366959362,
+ 9999,
+ 9,
+ 9999,
+ 28.64088397790055,
+ 9999
+ ],
+ "output_out": [
+ 6.022299366959362,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 3,
+ 9999,
+ 4,
+ 9999,
+ 20,
+ 9999,
+ -30,
+ 9999,
+ 15.089396817080356,
+ 9999,
+ 35.35911602209944,
+ 9999,
+ 6.022299366959362,
+ 9999,
+ 15.089396817080356,
+ 9999,
+ 35.35911602209944,
+ 9999,
+ 0.25,
+ 9999,
+ 0,
+ 9999
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/deflate1.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/deflate1.json
new file mode 100644
index 000000000000..5299f1c6b1de
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/deflate1.json
@@ -0,0 +1,142 @@
+{
+ "I0": 0,
+ "N0": 0,
+ "Z": [
+ 5,
+ 9999,
+ 0,
+ 9999,
+ 7,
+ 9999,
+ 0,
+ 9999,
+ 9,
+ 9999,
+ 0,
+ 9999,
+ 3,
+ 9999,
+ 0,
+ 9999,
+ 11,
+ 9999,
+ 0,
+ 9999,
+ 4,
+ 9999,
+ 0,
+ 9999,
+ 20,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideZ": 2,
+ "offsetZ": 0,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ 0,
+ 9999,
+ 1,
+ 9999,
+ 0,
+ 9999,
+ 20,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0.25,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideOutput": 2,
+ "offsetOutput": 0,
+ "Z_out": [
+ 6,
+ 9999,
+ 0,
+ 9999,
+ 7,
+ 9999,
+ 0,
+ 9999,
+ 9,
+ 9999,
+ 0,
+ 9999,
+ 3,
+ 9999,
+ 0,
+ 9999,
+ 11,
+ 9999,
+ 0,
+ 9999,
+ 4,
+ 9999,
+ 0,
+ 9999,
+ 20,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999
+ ],
+ "output_out": [
+ 0,
+ 9999,
+ 1,
+ 9999,
+ 0,
+ 9999,
+ 20,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0.25,
+ 9999,
+ 0,
+ 9999
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/deflate2.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/deflate2.json
new file mode 100644
index 000000000000..3cb152cb768e
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/deflate2.json
@@ -0,0 +1,142 @@
+{
+ "I0": 0,
+ "N0": 1,
+ "Z": [
+ 25,
+ 9999,
+ 1.5,
+ 9999,
+ 16,
+ 9999,
+ 2,
+ 9999,
+ 12,
+ 9999,
+ 1,
+ 9999,
+ 8,
+ 9999,
+ 1.2,
+ 9999,
+ 6,
+ 9999,
+ 0.8,
+ 9999,
+ 4,
+ 9999,
+ 0.5,
+ 9999,
+ 2,
+ 9999,
+ 0.2,
+ 9999,
+ 1,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideZ": 2,
+ "offsetZ": 0,
+ "PP": 1,
+ "IEEE": true,
+ "output": [
+ -0.05,
+ 9999,
+ 0.15,
+ 9999,
+ 0.1,
+ 9999,
+ 25,
+ 9999,
+ 0,
+ 9999,
+ 2,
+ 9999,
+ 4,
+ 9999,
+ -6,
+ 9999,
+ 0.12,
+ 9999,
+ 0.08,
+ 9999,
+ 0.6,
+ 9999,
+ 0.4,
+ 9999,
+ 0.2,
+ 9999,
+ 0.25,
+ 9999,
+ 0.05,
+ 9999
+ ],
+ "strideOutput": 2,
+ "offsetOutput": 0,
+ "Z_out": [
+ 4.287458608817688,
+ 9999,
+ 4.1374586088176875,
+ 9999,
+ 16,
+ 9999,
+ 2,
+ 9999,
+ 0.5125413911823126,
+ 9999,
+ 0.3625413911823126,
+ 9999,
+ 8,
+ 9999,
+ 1.2,
+ 9999,
+ 6,
+ 9999,
+ 0.8,
+ 9999,
+ 4,
+ 9999,
+ 0.5,
+ 9999,
+ 2,
+ 9999,
+ 0.2,
+ 9999,
+ 1,
+ 9999,
+ 0,
+ 9999
+ ],
+ "output_out": [
+ -0.05,
+ 9999,
+ 0.15,
+ 9999,
+ 0.1,
+ 9999,
+ 25,
+ 9999,
+ 0,
+ 9999,
+ 2,
+ 9999,
+ 4,
+ 9999,
+ -6,
+ 9999,
+ 0.12,
+ 9999,
+ 0.08,
+ 9999,
+ 0.6,
+ 9999,
+ 0.4,
+ 9999,
+ 0.2,
+ 9999,
+ 0.25,
+ 9999,
+ 0.05,
+ 9999
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/deflate_else.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/deflate_else.json
new file mode 100644
index 000000000000..37e89164f621
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/deflate_else.json
@@ -0,0 +1,142 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 100,
+ 9999,
+ 4,
+ 9999,
+ 81,
+ 9999,
+ 3,
+ 9999,
+ 64,
+ 9999,
+ 2.5,
+ 9999,
+ 49,
+ 9999,
+ 2,
+ 9999,
+ 36,
+ 9999,
+ 1.5,
+ 9999,
+ 0,
+ 9999,
+ 1,
+ 9999,
+ 16,
+ 9999,
+ 0.5,
+ 9999,
+ 9,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideZ": 2,
+ "offsetZ": 0,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideOutput": 2,
+ "offsetOutput": 0,
+ "Z_out": [
+ 100,
+ 9999,
+ 181,
+ 9999,
+ 81,
+ 9999,
+ 28.640883977900554,
+ 9999,
+ 64,
+ 9999,
+ 84.35911602209944,
+ 9999,
+ 49,
+ 9999,
+ 20.910603182919644,
+ 9999,
+ 36,
+ 9999,
+ 15.089396817080361,
+ 9999,
+ 0,
+ 9999,
+ 64,
+ 9999,
+ 16,
+ 9999,
+ 0.5,
+ 9999,
+ 9,
+ 9999,
+ 0,
+ 9999
+ ],
+ "output_out": [
+ 15.089396817080361,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 1,
+ 9999,
+ 4,
+ 9999,
+ -1,
+ 9999,
+ 35.35911602209945,
+ 9999,
+ 100,
+ 9999,
+ 15.089396817080361,
+ 9999,
+ 35.35911602209945,
+ 9999,
+ 100,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/late_failure.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/late_failure.json
new file mode 100644
index 000000000000..46c2812316ae
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/late_failure.json
@@ -0,0 +1,142 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 100,
+ 9999,
+ 4,
+ 9999,
+ 81,
+ 9999,
+ 3,
+ 9999,
+ 64,
+ 9999,
+ 2.5,
+ 9999,
+ 49,
+ 9999,
+ 2,
+ 9999,
+ 36,
+ 9999,
+ 1.5,
+ 9999,
+ 25,
+ 9999,
+ 1,
+ 9999,
+ 16,
+ 9999,
+ 0.5,
+ 9999,
+ 9,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideZ": 2,
+ "offsetZ": 0,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ 20,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideOutput": 2,
+ "offsetOutput": 0,
+ "Z_out": [
+ 100,
+ 9999,
+ 176.92546583850933,
+ 9999,
+ 81,
+ 9999,
+ 29.30047393364929,
+ 9999,
+ 64,
+ 9999,
+ 79.62499190486002,
+ 9999,
+ 49,
+ 9999,
+ 22.153848406135054,
+ 9999,
+ 36,
+ 9999,
+ 34.77161743237427,
+ 9999,
+ 25,
+ 9999,
+ 11.503635135119662,
+ 9999,
+ 16,
+ 9999,
+ 0.4218307033896549,
+ 9999,
+ 9,
+ 9999,
+ 29.30047393364929,
+ 9999
+ ],
+ "output_out": [
+ 0.4218307033896549,
+ 9999,
+ 4.074534161490681,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 1,
+ 9999,
+ 2,
+ 9999,
+ 10,
+ 9999,
+ -17,
+ 9999,
+ 9.771617432374267,
+ 9999,
+ 30.624991904860032,
+ 9999,
+ 0.4218307033896549,
+ 9999,
+ 9.771617432374267,
+ 9999,
+ 30.624991904860032,
+ 9999,
+ 0.25,
+ 9999,
+ 4.074534161490681,
+ 9999
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/nan_dmin.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/nan_dmin.json
new file mode 100644
index 000000000000..b4a70bf3e2bc
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/nan_dmin.json
@@ -0,0 +1,142 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 100,
+ 9999,
+ 4,
+ 9999,
+ 81,
+ 9999,
+ 3,
+ 9999,
+ 64,
+ 9999,
+ 2.5,
+ 9999,
+ 49,
+ 9999,
+ 2,
+ 9999,
+ 36,
+ 9999,
+ 1.5,
+ 9999,
+ 25,
+ 9999,
+ 1,
+ 9999,
+ 16,
+ 9999,
+ 0.5,
+ 9999,
+ 9,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideZ": 2,
+ "offsetZ": 0,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ "NaN",
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideOutput": 2,
+ "offsetOutput": 0,
+ "Z_out": [
+ 100,
+ 9999,
+ 181,
+ 9999,
+ 81,
+ 9999,
+ 28.64088397790055,
+ 9999,
+ 64,
+ 9999,
+ 84.35911602209944,
+ 9999,
+ 49,
+ 9999,
+ 20.910603182919644,
+ 9999,
+ 36,
+ 9999,
+ 40.089396817080356,
+ 9999,
+ 25,
+ 9999,
+ 9.977700633040637,
+ 9999,
+ 16,
+ 9999,
+ 6.022299366959362,
+ 9999,
+ 9,
+ 9999,
+ 28.64088397790055,
+ 9999
+ ],
+ "output_out": [
+ 6.022299366959362,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 2,
+ 9999,
+ 10,
+ 9999,
+ -6,
+ 9999,
+ 15.089396817080356,
+ 9999,
+ 35.35911602209944,
+ 9999,
+ 6.022299366959362,
+ 9999,
+ 15.089396817080356,
+ 9999,
+ 35.35911602209944,
+ 9999,
+ 0.25,
+ 9999,
+ 0,
+ 9999
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/pp2.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/pp2.json
new file mode 100644
index 000000000000..e06bc5d4c0a2
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/pp2.json
@@ -0,0 +1,142 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 100,
+ 9999,
+ 4,
+ 9999,
+ 81,
+ 9999,
+ 3,
+ 9999,
+ 64,
+ 9999,
+ 2.5,
+ 9999,
+ 49,
+ 9999,
+ 2,
+ 9999,
+ 36,
+ 9999,
+ 1.5,
+ 9999,
+ 25,
+ 9999,
+ 1,
+ 9999,
+ 16,
+ 9999,
+ 0.5,
+ 9999,
+ 9,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideZ": 2,
+ "offsetZ": 0,
+ "PP": 2,
+ "IEEE": true,
+ "output": [
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideOutput": 2,
+ "offsetOutput": 0,
+ "Z_out": [
+ 100,
+ 9999,
+ 181,
+ 9999,
+ 81,
+ 9999,
+ 28.64088397790055,
+ 9999,
+ 64,
+ 9999,
+ 84.35911602209944,
+ 9999,
+ 49,
+ 9999,
+ 20.910603182919644,
+ 9999,
+ 36,
+ 9999,
+ 40.089396817080356,
+ 9999,
+ 25,
+ 9999,
+ 9.977700633040637,
+ 9999,
+ 16,
+ 9999,
+ 6.022299366959362,
+ 9999,
+ 9,
+ 9999,
+ 28.64088397790055,
+ 9999
+ ],
+ "output_out": [
+ 6.022299366959362,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 1,
+ 9999,
+ 5,
+ 9999,
+ -1,
+ 9999,
+ 15.089396817080356,
+ 9999,
+ 35.35911602209944,
+ 9999,
+ 6.022299366959362,
+ 9999,
+ 15.089396817080356,
+ 9999,
+ 35.35911602209944,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/reverse.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/reverse.json
new file mode 100644
index 000000000000..4ecab5d948b3
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/reverse.json
@@ -0,0 +1,142 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 16,
+ 9999,
+ 0.5,
+ 9999,
+ 9,
+ 9999,
+ 0,
+ 9999,
+ 100,
+ 9999,
+ 4,
+ 9999,
+ 81,
+ 9999,
+ 3,
+ 9999,
+ 64,
+ 9999,
+ 2.5,
+ 9999,
+ 49,
+ 9999,
+ 2,
+ 9999,
+ 100,
+ 9999,
+ 1.5,
+ 9999,
+ 25,
+ 9999,
+ 1,
+ 9999
+ ],
+ "strideZ": 2,
+ "offsetZ": 0,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ -0.05,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideOutput": 2,
+ "offsetOutput": 0,
+ "Z_out": [
+ 100,
+ 9999,
+ 149,
+ 9999,
+ 49,
+ 9999,
+ 21.04697986577181,
+ 9999,
+ 64,
+ 9999,
+ 123.95302013422818,
+ 9999,
+ 81,
+ 9999,
+ 65.34733878390817,
+ 9999,
+ 100,
+ 9999,
+ 43.652661216091836,
+ 9999,
+ 9,
+ 9999,
+ 3.2987679556846072,
+ 9999,
+ 16,
+ 9999,
+ 12.701232044315393,
+ 9999,
+ 49,
+ 9999,
+ 21.04697986577181,
+ 9999
+ ],
+ "output_out": [
+ 12.701232044315393,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 100,
+ 9999,
+ 0,
+ 9999,
+ 1,
+ 9999,
+ 5,
+ 9999,
+ -1,
+ 9999,
+ 34.652661216091836,
+ 9999,
+ 42.95302013422819,
+ 9999,
+ 12.701232044315393,
+ 9999,
+ 34.652661216091836,
+ 9999,
+ 42.95302013422819,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/standard.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/standard.json
new file mode 100644
index 000000000000..03c057bd504f
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/standard.json
@@ -0,0 +1,142 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 100,
+ 9999,
+ 4,
+ 9999,
+ 81,
+ 9999,
+ 3,
+ 9999,
+ 64,
+ 9999,
+ 2.5,
+ 9999,
+ 49,
+ 9999,
+ 2,
+ 9999,
+ 36,
+ 9999,
+ 1.5,
+ 9999,
+ 25,
+ 9999,
+ 1,
+ 9999,
+ 16,
+ 9999,
+ 0.5,
+ 9999,
+ 9,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideZ": 2,
+ "offsetZ": 0,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideOutput": 2,
+ "offsetOutput": 0,
+ "Z_out": [
+ 100,
+ 9999,
+ 181,
+ 9999,
+ 81,
+ 9999,
+ 28.64088397790055,
+ 9999,
+ 64,
+ 9999,
+ 84.35911602209944,
+ 9999,
+ 49,
+ 9999,
+ 20.910603182919644,
+ 9999,
+ 36,
+ 9999,
+ 40.089396817080356,
+ 9999,
+ 25,
+ 9999,
+ 9.977700633040637,
+ 9999,
+ 16,
+ 9999,
+ 6.022299366959362,
+ 9999,
+ 9,
+ 9999,
+ 28.64088397790055,
+ 9999
+ ],
+ "output_out": [
+ 6.022299366959362,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 1,
+ 9999,
+ 5,
+ 9999,
+ -1,
+ 9999,
+ 15.089396817080356,
+ 9999,
+ 35.35911602209944,
+ 9999,
+ 6.022299366959362,
+ 9999,
+ 15.089396817080356,
+ 9999,
+ 35.35911602209944,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/swap.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/swap.json
new file mode 100644
index 000000000000..e58ffb60c272
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/large_strides/swap.json
@@ -0,0 +1,142 @@
+{
+ "I0": 0,
+ "N0": 1,
+ "Z": [
+ 10,
+ 9999,
+ 1.5,
+ 9999,
+ 16,
+ 9999,
+ 2,
+ 9999,
+ 30,
+ 9999,
+ 1,
+ 9999,
+ 8,
+ 9999,
+ 1.2,
+ 9999,
+ 6,
+ 9999,
+ 0.8,
+ 9999,
+ 4,
+ 9999,
+ 0.5,
+ 9999,
+ 2,
+ 9999,
+ 0.2,
+ 9999,
+ 1,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideZ": 2,
+ "offsetZ": 0,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ -0.05,
+ 9999,
+ 0.15,
+ 9999,
+ 0.1,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0.25,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideOutput": 2,
+ "offsetOutput": 0,
+ "Z_out": [
+ 50.15,
+ 9999,
+ 1.5,
+ 9999,
+ 16,
+ 9999,
+ 2,
+ 9999,
+ 6.15,
+ 9999,
+ 1,
+ 9999,
+ 8,
+ 9999,
+ 1.2,
+ 9999,
+ 6,
+ 9999,
+ 0.8,
+ 9999,
+ 4,
+ 9999,
+ 0.5,
+ 9999,
+ 2,
+ 9999,
+ 0.2,
+ 9999,
+ 1,
+ 9999,
+ 0,
+ 9999
+ ],
+ "output_out": [
+ -0.05,
+ 9999,
+ 0.15,
+ 9999,
+ 0.1,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0.25,
+ 9999,
+ 0,
+ 9999
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/late_failure.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/late_failure.json
new file mode 100644
index 000000000000..bff5e20e5f04
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/late_failure.json
@@ -0,0 +1,52 @@
+{
+ "I0": 0,
+ "N0": 3,
+
+ "Z": [ 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ],
+ "strideZ": 1,
+ "offsetZ": 0,
+
+ "PP": 0,
+ "IEEE": true,
+
+ "output": [ 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
+ "strideOutput": 1,
+ "offsetOutput": 0,
+
+ "Z_out": [
+ 1.00000000000000000E+002,
+ 1.76925465838509325E+002,
+ 8.10000000000000000E+001,
+ 2.93004739336492896E+001,
+ 6.40000000000000000E+001,
+ 7.96249919048600248E+001,
+ 4.90000000000000000E+001,
+ 2.21538484061350545E+001,
+ 3.60000000000000000E+001,
+ 3.47716174323742706E+001,
+ 2.50000000000000000E+001,
+ 1.15036351351196622E+001,
+ 1.60000000000000000E+001,
+ 4.21830703389654893E-001,
+ 9.00000000000000000E+000,
+ 2.93004739336492896E+001
+ ],
+
+ "output_out": [
+ 4.21830703389654893E-001,
+ 4.07453416149068115E+000,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 1,
+ 2,
+ 10,
+ -17,
+ 9.77161743237426705E+000,
+ 3.06249919048600319E+001,
+ 4.21830703389654893E-001,
+ 9.77161743237426705E+000,
+ 3.06249919048600319E+001,
+ 2.50000000000000000E-001,
+ 4.07453416149068115E+000
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/nan_dmin.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/nan_dmin.json
new file mode 100644
index 000000000000..cd8c372f5317
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/nan_dmin.json
@@ -0,0 +1,52 @@
+{
+ "I0": 0,
+ "N0": 3,
+
+ "Z": [ 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ],
+ "strideZ": 1,
+ "offsetZ": 0,
+
+ "PP": 0,
+ "IEEE": true,
+
+ "output": [ "NaN", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
+ "strideOutput": 1,
+ "offsetOutput": 0,
+
+ "Z_out": [
+ 1.00000000000000000E+002,
+ 1.81000000000000000E+002,
+ 8.10000000000000000E+001,
+ 2.86408839779005504E+001,
+ 6.40000000000000000E+001,
+ 8.43591160220994425E+001,
+ 4.90000000000000000E+001,
+ 2.09106031829196439E+001,
+ 3.60000000000000000E+001,
+ 4.00893968170803561E+001,
+ 2.50000000000000000E+001,
+ 9.97770063304063726E+000,
+ 1.60000000000000000E+001,
+ 6.02229936695936185E+000,
+ 9.00000000000000000E+000,
+ 2.86408839779005504E+001
+ ],
+
+ "output_out": [
+ 6.02229936695936185E+000,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 0,
+ 2,
+ 10,
+ -6,
+ 1.50893968170803561E+001,
+ 3.53591160220994425E+001,
+ 6.02229936695936185E+000,
+ 1.50893968170803561E+001,
+ 3.53591160220994425E+001,
+ 2.50000000000000000E-001,
+ 0.00000000000000000E+000
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/nan_z.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/nan_z.json
new file mode 100644
index 000000000000..39217180dfd3
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/nan_z.json
@@ -0,0 +1,52 @@
+{
+ "I0": 0,
+ "N0": 3,
+
+ "Z": [ "NaN", 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ],
+ "strideZ": 1,
+ "offsetZ": 0,
+
+ "PP": 0,
+ "IEEE": true,
+
+ "output": [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
+ "strideOutput": 1,
+ "offsetOutput": 0,
+
+ "Z_out": [
+ "NaN",
+ "NaN",
+ 8.10000000000000000E+001,
+ "NaN",
+ 6.40000000000000000E+001,
+ "NaN",
+ 4.90000000000000000E+001,
+ "NaN",
+ 3.60000000000000000E+001,
+ "NaN",
+ 2.50000000000000000E+001,
+ "NaN",
+ 1.60000000000000000E+001,
+ "NaN",
+ 9.00000000000000000E+000,
+ "NaN"
+ ],
+
+ "output_out": [
+ "NaN",
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 0,
+ 2,
+ 10,
+ -1,
+ "NaN",
+ "NaN",
+ "NaN",
+ "NaN",
+ "NaN",
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/alternate.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/alternate.json
new file mode 100644
index 000000000000..506de269f79c
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/alternate.json
@@ -0,0 +1,80 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 0,
+ 9,
+ 0.5,
+ 16,
+ 1,
+ 25,
+ 1.5,
+ 36,
+ 2,
+ 49,
+ 2.5,
+ 64,
+ 3,
+ 81,
+ 4,
+ 100
+ ],
+ "strideZ": -1,
+ "offsetZ": 15,
+ "PP": 1,
+ "IEEE": false,
+ "output": [
+ 0,
+ 0.25,
+ 0.6,
+ 0.7,
+ 0.8,
+ 0.1,
+ 0.15,
+ -6,
+ 0,
+ 0,
+ 0,
+ 100,
+ 0.1,
+ 0.15,
+ 0.2
+ ],
+ "strideOutput": -1,
+ "offsetOutput": 14,
+ "Z_out": [
+ 0,
+ 1.0869486452996717,
+ 0.5,
+ 0.0655020361601501,
+ 1,
+ 0.33454796383984986,
+ 1.5,
+ 1.4945540073271917,
+ 2,
+ 0.9054959926728084,
+ 2.5,
+ 3.3131013547003283,
+ 3,
+ 1.0869486452996717,
+ 4,
+ 6.90005
+ ],
+ "output_out": [
+ 0.09995000000000001,
+ 0.49975,
+ 1.313101354700328,
+ 0.49455400732719157,
+ 0.0655020361601501,
+ 1.313101354700328,
+ 0.49455400732719157,
+ -6,
+ 5,
+ 1,
+ 0,
+ 100,
+ 2.7755575615628914e-17,
+ 0.34995,
+ 0.0655020361601501
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/big_tau.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/big_tau.json
new file mode 100644
index 000000000000..7dc6a29b99ff
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/big_tau.json
@@ -0,0 +1,80 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 0,
+ 9,
+ 0.5,
+ 16,
+ 1,
+ 25,
+ 1.5,
+ 36,
+ 2,
+ 49,
+ 2.5,
+ 64,
+ 3,
+ 81,
+ 4,
+ 100
+ ],
+ "strideZ": -1,
+ "offsetZ": 15,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1000
+ ],
+ "strideOutput": -1,
+ "offsetOutput": 14,
+ "Z_out": [
+ 28.64088397790055,
+ 9,
+ 6.022299366959362,
+ 16,
+ 9.977700633040637,
+ 25,
+ 40.089396817080356,
+ 36,
+ 20.910603182919644,
+ 49,
+ 84.35911602209944,
+ 64,
+ 28.64088397790055,
+ 81,
+ 181,
+ 100
+ ],
+ "output_out": [
+ 0,
+ 0.25,
+ 35.35911602209944,
+ 15.089396817080356,
+ 6.022299366959362,
+ 35.35911602209944,
+ 15.089396817080356,
+ -30,
+ 20,
+ 4,
+ 3,
+ 0,
+ 0,
+ 0,
+ 6.022299366959362
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/deflate1.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/deflate1.json
new file mode 100644
index 000000000000..9acb33db2341
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/deflate1.json
@@ -0,0 +1,80 @@
+{
+ "I0": 0,
+ "N0": 0,
+ "Z": [
+ 0,
+ 0,
+ 0,
+ 20,
+ 0,
+ 4,
+ 0,
+ 11,
+ 0,
+ 3,
+ 0,
+ 9,
+ 0,
+ 7,
+ 0,
+ 5
+ ],
+ "strideZ": -1,
+ "offsetZ": 15,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ 0,
+ 0.25,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 20,
+ 0,
+ 1,
+ 0
+ ],
+ "strideOutput": -1,
+ "offsetOutput": 14,
+ "Z_out": [
+ 0,
+ 0,
+ 0,
+ 20,
+ 0,
+ 4,
+ 0,
+ 11,
+ 0,
+ 3,
+ 0,
+ 9,
+ 0,
+ 7,
+ 0,
+ 6
+ ],
+ "output_out": [
+ 0,
+ 0.25,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 20,
+ 0,
+ 1,
+ 0
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/deflate2.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/deflate2.json
new file mode 100644
index 000000000000..5886832b1672
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/deflate2.json
@@ -0,0 +1,80 @@
+{
+ "I0": 0,
+ "N0": 1,
+ "Z": [
+ 0,
+ 1,
+ 0.2,
+ 2,
+ 0.5,
+ 4,
+ 0.8,
+ 6,
+ 1.2,
+ 8,
+ 1,
+ 12,
+ 2,
+ 16,
+ 1.5,
+ 25
+ ],
+ "strideZ": -1,
+ "offsetZ": 15,
+ "PP": 1,
+ "IEEE": true,
+ "output": [
+ 0.05,
+ 0.25,
+ 0.2,
+ 0.4,
+ 0.6,
+ 0.08,
+ 0.12,
+ -6,
+ 4,
+ 2,
+ 0,
+ 25,
+ 0.1,
+ 0.15,
+ -0.05
+ ],
+ "strideOutput": -1,
+ "offsetOutput": 14,
+ "Z_out": [
+ 0,
+ 1,
+ 0.2,
+ 2,
+ 0.5,
+ 4,
+ 0.8,
+ 6,
+ 1.2,
+ 8,
+ 0.3625413911823126,
+ 0.5125413911823126,
+ 2,
+ 16,
+ 4.1374586088176875,
+ 4.287458608817688
+ ],
+ "output_out": [
+ 0.05,
+ 0.25,
+ 0.2,
+ 0.4,
+ 0.6,
+ 0.08,
+ 0.12,
+ -6,
+ 4,
+ 2,
+ 0,
+ 25,
+ 0.1,
+ 0.15,
+ -0.05
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/deflate_else.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/deflate_else.json
new file mode 100644
index 000000000000..e43df608f2e1
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/deflate_else.json
@@ -0,0 +1,80 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 0,
+ 9,
+ 0.5,
+ 16,
+ 1,
+ 0,
+ 1.5,
+ 36,
+ 2,
+ 49,
+ 2.5,
+ 64,
+ 3,
+ 81,
+ 4,
+ 100
+ ],
+ "strideZ": -1,
+ "offsetZ": 15,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideOutput": -1,
+ "offsetOutput": 14,
+ "Z_out": [
+ 0,
+ 9,
+ 0.5,
+ 16,
+ 64,
+ 0,
+ 15.089396817080361,
+ 36,
+ 20.910603182919644,
+ 49,
+ 84.35911602209944,
+ 64,
+ 28.640883977900554,
+ 81,
+ 181,
+ 100
+ ],
+ "output_out": [
+ 0,
+ 0,
+ 100,
+ 35.35911602209945,
+ 15.089396817080361,
+ 100,
+ 35.35911602209945,
+ -1,
+ 4,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 15.089396817080361
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/late_failure.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/late_failure.json
new file mode 100644
index 000000000000..8f36751853b6
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/late_failure.json
@@ -0,0 +1,80 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 0,
+ 9,
+ 0.5,
+ 16,
+ 1,
+ 25,
+ 1.5,
+ 36,
+ 2,
+ 49,
+ 2.5,
+ 64,
+ 3,
+ 81,
+ 4,
+ 100
+ ],
+ "strideZ": -1,
+ "offsetZ": 15,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 20
+ ],
+ "strideOutput": -1,
+ "offsetOutput": 14,
+ "Z_out": [
+ 29.30047393364929,
+ 9,
+ 0.4218307033896549,
+ 16,
+ 11.503635135119662,
+ 25,
+ 34.77161743237427,
+ 36,
+ 22.153848406135054,
+ 49,
+ 79.62499190486002,
+ 64,
+ 29.30047393364929,
+ 81,
+ 176.92546583850933,
+ 100
+ ],
+ "output_out": [
+ 4.074534161490681,
+ 0.25,
+ 30.624991904860032,
+ 9.771617432374267,
+ 0.4218307033896549,
+ 30.624991904860032,
+ 9.771617432374267,
+ -17,
+ 10,
+ 2,
+ 1,
+ 0,
+ 0,
+ 4.074534161490681,
+ 0.4218307033896549
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/nan_dmin.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/nan_dmin.json
new file mode 100644
index 000000000000..61f230467e37
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/nan_dmin.json
@@ -0,0 +1,80 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 0,
+ 9,
+ 0.5,
+ 16,
+ 1,
+ 25,
+ 1.5,
+ 36,
+ 2,
+ 49,
+ 2.5,
+ 64,
+ 3,
+ 81,
+ 4,
+ 100
+ ],
+ "strideZ": -1,
+ "offsetZ": 15,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ "NaN"
+ ],
+ "strideOutput": -1,
+ "offsetOutput": 14,
+ "Z_out": [
+ 28.64088397790055,
+ 9,
+ 6.022299366959362,
+ 16,
+ 9.977700633040637,
+ 25,
+ 40.089396817080356,
+ 36,
+ 20.910603182919644,
+ 49,
+ 84.35911602209944,
+ 64,
+ 28.64088397790055,
+ 81,
+ 181,
+ 100
+ ],
+ "output_out": [
+ 0,
+ 0.25,
+ 35.35911602209944,
+ 15.089396817080356,
+ 6.022299366959362,
+ 35.35911602209944,
+ 15.089396817080356,
+ -6,
+ 10,
+ 2,
+ 0,
+ 0,
+ 0,
+ 0,
+ 6.022299366959362
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/pp2.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/pp2.json
new file mode 100644
index 000000000000..3329f20fa2a1
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/pp2.json
@@ -0,0 +1,80 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 0,
+ 9,
+ 0.5,
+ 16,
+ 1,
+ 25,
+ 1.5,
+ 36,
+ 2,
+ 49,
+ 2.5,
+ 64,
+ 3,
+ 81,
+ 4,
+ 100
+ ],
+ "strideZ": -1,
+ "offsetZ": 15,
+ "PP": 2,
+ "IEEE": true,
+ "output": [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideOutput": -1,
+ "offsetOutput": 14,
+ "Z_out": [
+ 28.64088397790055,
+ 9,
+ 6.022299366959362,
+ 16,
+ 9.977700633040637,
+ 25,
+ 40.089396817080356,
+ 36,
+ 20.910603182919644,
+ 49,
+ 84.35911602209944,
+ 64,
+ 28.64088397790055,
+ 81,
+ 181,
+ 100
+ ],
+ "output_out": [
+ 0,
+ 0,
+ 35.35911602209944,
+ 15.089396817080356,
+ 6.022299366959362,
+ 35.35911602209944,
+ 15.089396817080356,
+ -1,
+ 5,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 6.022299366959362
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/reverse.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/reverse.json
new file mode 100644
index 000000000000..50f016c80098
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/reverse.json
@@ -0,0 +1,80 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 1,
+ 25,
+ 1.5,
+ 100,
+ 2,
+ 49,
+ 2.5,
+ 64,
+ 3,
+ 81,
+ 4,
+ 100,
+ 0,
+ 9,
+ 0.5,
+ 16
+ ],
+ "strideZ": -1,
+ "offsetZ": 15,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ -0.05
+ ],
+ "strideOutput": -1,
+ "offsetOutput": 14,
+ "Z_out": [
+ 21.04697986577181,
+ 49,
+ 12.701232044315393,
+ 16,
+ 3.2987679556846072,
+ 9,
+ 43.652661216091836,
+ 100,
+ 65.34733878390817,
+ 81,
+ 123.95302013422818,
+ 64,
+ 21.04697986577181,
+ 49,
+ 149,
+ 100
+ ],
+ "output_out": [
+ 0,
+ 0,
+ 42.95302013422819,
+ 34.652661216091836,
+ 12.701232044315393,
+ 42.95302013422819,
+ 34.652661216091836,
+ -1,
+ 5,
+ 1,
+ 0,
+ 100,
+ 0,
+ 0,
+ 12.701232044315393
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/standard.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/standard.json
new file mode 100644
index 000000000000..6938d92d6444
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/standard.json
@@ -0,0 +1,80 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 0,
+ 9,
+ 0.5,
+ 16,
+ 1,
+ 25,
+ 1.5,
+ 36,
+ 2,
+ 49,
+ 2.5,
+ 64,
+ 3,
+ 81,
+ 4,
+ 100
+ ],
+ "strideZ": -1,
+ "offsetZ": 15,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideOutput": -1,
+ "offsetOutput": 14,
+ "Z_out": [
+ 28.64088397790055,
+ 9,
+ 6.022299366959362,
+ 16,
+ 9.977700633040637,
+ 25,
+ 40.089396817080356,
+ 36,
+ 20.910603182919644,
+ 49,
+ 84.35911602209944,
+ 64,
+ 28.64088397790055,
+ 81,
+ 181,
+ 100
+ ],
+ "output_out": [
+ 0,
+ 0,
+ 35.35911602209944,
+ 15.089396817080356,
+ 6.022299366959362,
+ 35.35911602209944,
+ 15.089396817080356,
+ -1,
+ 5,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 6.022299366959362
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/swap.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/swap.json
new file mode 100644
index 000000000000..055db0b64423
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/negative_strides/swap.json
@@ -0,0 +1,80 @@
+{
+ "I0": 0,
+ "N0": 1,
+ "Z": [
+ 0,
+ 1,
+ 0.2,
+ 2,
+ 0.5,
+ 4,
+ 0.8,
+ 6,
+ 1.2,
+ 8,
+ 1,
+ 30,
+ 2,
+ 16,
+ 1.5,
+ 10
+ ],
+ "strideZ": -1,
+ "offsetZ": 15,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ 0,
+ 0.25,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0.1,
+ 0.15,
+ -0.05
+ ],
+ "strideOutput": -1,
+ "offsetOutput": 14,
+ "Z_out": [
+ 0,
+ 1,
+ 0.2,
+ 2,
+ 0.5,
+ 4,
+ 0.8,
+ 6,
+ 1.2,
+ 8,
+ 1,
+ 6.15,
+ 2,
+ 16,
+ 1.5,
+ 50.15
+ ],
+ "output_out": [
+ 0,
+ 0.25,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0.1,
+ 0.15,
+ -0.05
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/alternate.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/alternate.json
new file mode 100644
index 000000000000..8f5d17115d34
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/alternate.json
@@ -0,0 +1,84 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 9999,
+ 100,
+ 4,
+ 81,
+ 3,
+ 64,
+ 2.5,
+ 49,
+ 2,
+ 36,
+ 1.5,
+ 25,
+ 1,
+ 16,
+ 0.5,
+ 9,
+ 0
+ ],
+ "strideZ": 1,
+ "offsetZ": 1,
+ "PP": 1,
+ "IEEE": false,
+ "output": [
+ 9999,
+ 0.2,
+ 0.15,
+ 0.1,
+ 100,
+ 0,
+ 0,
+ 0,
+ -6,
+ 0.15,
+ 0.1,
+ 0.8,
+ 0.7,
+ 0.6,
+ 0.25,
+ 0
+ ],
+ "strideOutput": 1,
+ "offsetOutput": 1,
+ "Z_out": [
+ 9999,
+ 6.90005,
+ 4,
+ 1.0869486452996717,
+ 3,
+ 3.3131013547003283,
+ 2.5,
+ 0.9054959926728084,
+ 2,
+ 1.4945540073271917,
+ 1.5,
+ 0.33454796383984986,
+ 1,
+ 0.0655020361601501,
+ 0.5,
+ 1.0869486452996717,
+ 0
+ ],
+ "output_out": [
+ 9999,
+ 0.0655020361601501,
+ 0.34995,
+ 2.7755575615628914e-17,
+ 100,
+ 0,
+ 1,
+ 5,
+ -6,
+ 0.49455400732719157,
+ 1.313101354700328,
+ 0.0655020361601501,
+ 0.49455400732719157,
+ 1.313101354700328,
+ 0.49975,
+ 0.09995000000000001
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/big_tau.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/big_tau.json
new file mode 100644
index 000000000000..8ec7942dd2eb
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/big_tau.json
@@ -0,0 +1,84 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 9999,
+ 100,
+ 4,
+ 81,
+ 3,
+ 64,
+ 2.5,
+ 49,
+ 2,
+ 36,
+ 1.5,
+ 25,
+ 1,
+ 16,
+ 0.5,
+ 9,
+ 0
+ ],
+ "strideZ": 1,
+ "offsetZ": 1,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ 9999,
+ 1000,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideOutput": 1,
+ "offsetOutput": 1,
+ "Z_out": [
+ 9999,
+ 100,
+ 181,
+ 81,
+ 28.64088397790055,
+ 64,
+ 84.35911602209944,
+ 49,
+ 20.910603182919644,
+ 36,
+ 40.089396817080356,
+ 25,
+ 9.977700633040637,
+ 16,
+ 6.022299366959362,
+ 9,
+ 28.64088397790055
+ ],
+ "output_out": [
+ 9999,
+ 6.022299366959362,
+ 0,
+ 0,
+ 0,
+ 3,
+ 4,
+ 20,
+ -30,
+ 15.089396817080356,
+ 35.35911602209944,
+ 6.022299366959362,
+ 15.089396817080356,
+ 35.35911602209944,
+ 0.25,
+ 0
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/deflate1.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/deflate1.json
new file mode 100644
index 000000000000..2b9eec9b4e03
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/deflate1.json
@@ -0,0 +1,84 @@
+{
+ "I0": 0,
+ "N0": 0,
+ "Z": [
+ 9999,
+ 5,
+ 0,
+ 7,
+ 0,
+ 9,
+ 0,
+ 3,
+ 0,
+ 11,
+ 0,
+ 4,
+ 0,
+ 20,
+ 0,
+ 0,
+ 0
+ ],
+ "strideZ": 1,
+ "offsetZ": 1,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ 9999,
+ 0,
+ 1,
+ 0,
+ 20,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0.25,
+ 0
+ ],
+ "strideOutput": 1,
+ "offsetOutput": 1,
+ "Z_out": [
+ 9999,
+ 6,
+ 0,
+ 7,
+ 0,
+ 9,
+ 0,
+ 3,
+ 0,
+ 11,
+ 0,
+ 4,
+ 0,
+ 20,
+ 0,
+ 0,
+ 0
+ ],
+ "output_out": [
+ 9999,
+ 0,
+ 1,
+ 0,
+ 20,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0.25,
+ 0
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/deflate2.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/deflate2.json
new file mode 100644
index 000000000000..88423daaa0ed
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/deflate2.json
@@ -0,0 +1,84 @@
+{
+ "I0": 0,
+ "N0": 1,
+ "Z": [
+ 9999,
+ 25,
+ 1.5,
+ 16,
+ 2,
+ 12,
+ 1,
+ 8,
+ 1.2,
+ 6,
+ 0.8,
+ 4,
+ 0.5,
+ 2,
+ 0.2,
+ 1,
+ 0
+ ],
+ "strideZ": 1,
+ "offsetZ": 1,
+ "PP": 1,
+ "IEEE": true,
+ "output": [
+ 9999,
+ -0.05,
+ 0.15,
+ 0.1,
+ 25,
+ 0,
+ 2,
+ 4,
+ -6,
+ 0.12,
+ 0.08,
+ 0.6,
+ 0.4,
+ 0.2,
+ 0.25,
+ 0.05
+ ],
+ "strideOutput": 1,
+ "offsetOutput": 1,
+ "Z_out": [
+ 9999,
+ 4.287458608817688,
+ 4.1374586088176875,
+ 16,
+ 2,
+ 0.5125413911823126,
+ 0.3625413911823126,
+ 8,
+ 1.2,
+ 6,
+ 0.8,
+ 4,
+ 0.5,
+ 2,
+ 0.2,
+ 1,
+ 0
+ ],
+ "output_out": [
+ 9999,
+ -0.05,
+ 0.15,
+ 0.1,
+ 25,
+ 0,
+ 2,
+ 4,
+ -6,
+ 0.12,
+ 0.08,
+ 0.6,
+ 0.4,
+ 0.2,
+ 0.25,
+ 0.05
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/deflate_else.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/deflate_else.json
new file mode 100644
index 000000000000..090ac002dde6
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/deflate_else.json
@@ -0,0 +1,84 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 9999,
+ 100,
+ 4,
+ 81,
+ 3,
+ 64,
+ 2.5,
+ 49,
+ 2,
+ 36,
+ 1.5,
+ 0,
+ 1,
+ 16,
+ 0.5,
+ 9,
+ 0
+ ],
+ "strideZ": 1,
+ "offsetZ": 1,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ 9999,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideOutput": 1,
+ "offsetOutput": 1,
+ "Z_out": [
+ 9999,
+ 100,
+ 181,
+ 81,
+ 28.640883977900554,
+ 64,
+ 84.35911602209944,
+ 49,
+ 20.910603182919644,
+ 36,
+ 15.089396817080361,
+ 0,
+ 64,
+ 16,
+ 0.5,
+ 9,
+ 0
+ ],
+ "output_out": [
+ 9999,
+ 15.089396817080361,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 4,
+ -1,
+ 35.35911602209945,
+ 100,
+ 15.089396817080361,
+ 35.35911602209945,
+ 100,
+ 0,
+ 0
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/late_failure.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/late_failure.json
new file mode 100644
index 000000000000..3ab2e319f71d
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/late_failure.json
@@ -0,0 +1,84 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 9999,
+ 100,
+ 4,
+ 81,
+ 3,
+ 64,
+ 2.5,
+ 49,
+ 2,
+ 36,
+ 1.5,
+ 25,
+ 1,
+ 16,
+ 0.5,
+ 9,
+ 0
+ ],
+ "strideZ": 1,
+ "offsetZ": 1,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ 9999,
+ 20,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideOutput": 1,
+ "offsetOutput": 1,
+ "Z_out": [
+ 9999,
+ 100,
+ 176.92546583850933,
+ 81,
+ 29.30047393364929,
+ 64,
+ 79.62499190486002,
+ 49,
+ 22.153848406135054,
+ 36,
+ 34.77161743237427,
+ 25,
+ 11.503635135119662,
+ 16,
+ 0.4218307033896549,
+ 9,
+ 29.30047393364929
+ ],
+ "output_out": [
+ 9999,
+ 0.4218307033896549,
+ 4.074534161490681,
+ 0,
+ 0,
+ 1,
+ 2,
+ 10,
+ -17,
+ 9.771617432374267,
+ 30.624991904860032,
+ 0.4218307033896549,
+ 9.771617432374267,
+ 30.624991904860032,
+ 0.25,
+ 4.074534161490681
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/nan_dmin.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/nan_dmin.json
new file mode 100644
index 000000000000..a34ec11ccb44
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/nan_dmin.json
@@ -0,0 +1,84 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 9999,
+ 100,
+ 4,
+ 81,
+ 3,
+ 64,
+ 2.5,
+ 49,
+ 2,
+ 36,
+ 1.5,
+ 25,
+ 1,
+ 16,
+ 0.5,
+ 9,
+ 0
+ ],
+ "strideZ": 1,
+ "offsetZ": 1,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ 9999,
+ "NaN",
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideOutput": 1,
+ "offsetOutput": 1,
+ "Z_out": [
+ 9999,
+ 100,
+ 181,
+ 81,
+ 28.64088397790055,
+ 64,
+ 84.35911602209944,
+ 49,
+ 20.910603182919644,
+ 36,
+ 40.089396817080356,
+ 25,
+ 9.977700633040637,
+ 16,
+ 6.022299366959362,
+ 9,
+ 28.64088397790055
+ ],
+ "output_out": [
+ 9999,
+ 6.022299366959362,
+ 0,
+ 0,
+ 0,
+ 0,
+ 2,
+ 10,
+ -6,
+ 15.089396817080356,
+ 35.35911602209944,
+ 6.022299366959362,
+ 15.089396817080356,
+ 35.35911602209944,
+ 0.25,
+ 0
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/pp2.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/pp2.json
new file mode 100644
index 000000000000..35287c968be1
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/pp2.json
@@ -0,0 +1,84 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 9999,
+ 100,
+ 4,
+ 81,
+ 3,
+ 64,
+ 2.5,
+ 49,
+ 2,
+ 36,
+ 1.5,
+ 25,
+ 1,
+ 16,
+ 0.5,
+ 9,
+ 0
+ ],
+ "strideZ": 1,
+ "offsetZ": 1,
+ "PP": 2,
+ "IEEE": true,
+ "output": [
+ 9999,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideOutput": 1,
+ "offsetOutput": 1,
+ "Z_out": [
+ 9999,
+ 100,
+ 181,
+ 81,
+ 28.64088397790055,
+ 64,
+ 84.35911602209944,
+ 49,
+ 20.910603182919644,
+ 36,
+ 40.089396817080356,
+ 25,
+ 9.977700633040637,
+ 16,
+ 6.022299366959362,
+ 9,
+ 28.64088397790055
+ ],
+ "output_out": [
+ 9999,
+ 6.022299366959362,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 5,
+ -1,
+ 15.089396817080356,
+ 35.35911602209944,
+ 6.022299366959362,
+ 15.089396817080356,
+ 35.35911602209944,
+ 0,
+ 0
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/reverse.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/reverse.json
new file mode 100644
index 000000000000..ddd77fda2f4a
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/reverse.json
@@ -0,0 +1,84 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 9999,
+ 16,
+ 0.5,
+ 9,
+ 0,
+ 100,
+ 4,
+ 81,
+ 3,
+ 64,
+ 2.5,
+ 49,
+ 2,
+ 100,
+ 1.5,
+ 25,
+ 1
+ ],
+ "strideZ": 1,
+ "offsetZ": 1,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ 9999,
+ -0.05,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideOutput": 1,
+ "offsetOutput": 1,
+ "Z_out": [
+ 9999,
+ 100,
+ 149,
+ 49,
+ 21.04697986577181,
+ 64,
+ 123.95302013422818,
+ 81,
+ 65.34733878390817,
+ 100,
+ 43.652661216091836,
+ 9,
+ 3.2987679556846072,
+ 16,
+ 12.701232044315393,
+ 49,
+ 21.04697986577181
+ ],
+ "output_out": [
+ 9999,
+ 12.701232044315393,
+ 0,
+ 0,
+ 100,
+ 0,
+ 1,
+ 5,
+ -1,
+ 34.652661216091836,
+ 42.95302013422819,
+ 12.701232044315393,
+ 34.652661216091836,
+ 42.95302013422819,
+ 0,
+ 0
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/standard.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/standard.json
new file mode 100644
index 000000000000..ec68c9e8efd5
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/standard.json
@@ -0,0 +1,84 @@
+{
+ "I0": 0,
+ "N0": 3,
+ "Z": [
+ 9999,
+ 100,
+ 4,
+ 81,
+ 3,
+ 64,
+ 2.5,
+ 49,
+ 2,
+ 36,
+ 1.5,
+ 25,
+ 1,
+ 16,
+ 0.5,
+ 9,
+ 0
+ ],
+ "strideZ": 1,
+ "offsetZ": 1,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ 9999,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideOutput": 1,
+ "offsetOutput": 1,
+ "Z_out": [
+ 9999,
+ 100,
+ 181,
+ 81,
+ 28.64088397790055,
+ 64,
+ 84.35911602209944,
+ 49,
+ 20.910603182919644,
+ 36,
+ 40.089396817080356,
+ 25,
+ 9.977700633040637,
+ 16,
+ 6.022299366959362,
+ 9,
+ 28.64088397790055
+ ],
+ "output_out": [
+ 9999,
+ 6.022299366959362,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 5,
+ -1,
+ 15.089396817080356,
+ 35.35911602209944,
+ 6.022299366959362,
+ 15.089396817080356,
+ 35.35911602209944,
+ 0,
+ 0
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/swap.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/swap.json
new file mode 100644
index 000000000000..2ee2326d5373
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/offsets/swap.json
@@ -0,0 +1,84 @@
+{
+ "I0": 0,
+ "N0": 1,
+ "Z": [
+ 9999,
+ 10,
+ 1.5,
+ 16,
+ 2,
+ 30,
+ 1,
+ 8,
+ 1.2,
+ 6,
+ 0.8,
+ 4,
+ 0.5,
+ 2,
+ 0.2,
+ 1,
+ 0
+ ],
+ "strideZ": 1,
+ "offsetZ": 1,
+ "PP": 0,
+ "IEEE": true,
+ "output": [
+ 9999,
+ -0.05,
+ 0.15,
+ 0.1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0.25,
+ 0
+ ],
+ "strideOutput": 1,
+ "offsetOutput": 1,
+ "Z_out": [
+ 9999,
+ 50.15,
+ 1.5,
+ 16,
+ 2,
+ 6.15,
+ 1,
+ 8,
+ 1.2,
+ 6,
+ 0.8,
+ 4,
+ 0.5,
+ 2,
+ 0.2,
+ 1,
+ 0
+ ],
+ "output_out": [
+ 9999,
+ -0.05,
+ 0.15,
+ 0.1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0.25,
+ 0
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/pp2.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/pp2.json
new file mode 100644
index 000000000000..64730887cdd4
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/pp2.json
@@ -0,0 +1,52 @@
+{
+ "I0": 0,
+ "N0": 3,
+
+ "Z": [ 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ],
+ "strideZ": 1,
+ "offsetZ": 0,
+
+ "PP": 2,
+ "IEEE": true,
+
+ "output": [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
+ "strideOutput": 1,
+ "offsetOutput": 0,
+
+ "Z_out": [
+ 1.00000000000000000E+002,
+ 1.81000000000000000E+002,
+ 8.10000000000000000E+001,
+ 2.86408839779005504E+001,
+ 6.40000000000000000E+001,
+ 8.43591160220994425E+001,
+ 4.90000000000000000E+001,
+ 2.09106031829196439E+001,
+ 3.60000000000000000E+001,
+ 4.00893968170803561E+001,
+ 2.50000000000000000E+001,
+ 9.97770063304063726E+000,
+ 1.60000000000000000E+001,
+ 6.02229936695936185E+000,
+ 9.00000000000000000E+000,
+ 2.86408839779005504E+001
+ ],
+
+ "output_out": [
+ 6.02229936695936185E+000,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 0,
+ 1,
+ 5,
+ -1,
+ 1.50893968170803561E+001,
+ 3.53591160220994425E+001,
+ 6.02229936695936185E+000,
+ 1.50893968170803561E+001,
+ 3.53591160220994425E+001,
+ 0.00000000000000000E+000,
+ -0.00000000000000000E+000
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/reverse.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/reverse.json
new file mode 100644
index 000000000000..63e40b6c70d1
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/reverse.json
@@ -0,0 +1,52 @@
+{
+ "I0": 0,
+ "N0": 3,
+
+ "Z": [ 16, 0.5, 9, 0, 100, 4, 81, 3, 64, 2.5, 49, 2, 100, 1.5, 25, 1 ],
+ "strideZ": 1,
+ "offsetZ": 0,
+
+ "PP": 0,
+ "IEEE": true,
+
+ "output": [ -0.05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
+ "strideOutput": 1,
+ "offsetOutput": 0,
+
+ "Z_out": [
+ 1.00000000000000000E+002,
+ 1.49000000000000000E+002,
+ 4.90000000000000000E+001,
+ 2.10469798657718101E+001,
+ 6.40000000000000000E+001,
+ 1.23953020134228183E+002,
+ 8.10000000000000000E+001,
+ 6.53473387839081710E+001,
+ 1.00000000000000000E+002,
+ 4.36526612160918361E+001,
+ 9.00000000000000000E+000,
+ 3.29876795568460723E+000,
+ 1.60000000000000000E+001,
+ 1.27012320443153932E+001,
+ 4.90000000000000000E+001,
+ 2.10469798657718101E+001
+ ],
+
+ "output_out": [
+ 1.27012320443153932E+001,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 1.00000000000000000E+002,
+ 0,
+ 1,
+ 5,
+ -1,
+ 3.46526612160918361E+001,
+ 4.29530201342281899E+001,
+ 1.27012320443153932E+001,
+ 3.46526612160918361E+001,
+ 4.29530201342281899E+001,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/standard.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/standard.json
new file mode 100644
index 000000000000..02a8e41b5a2a
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/standard.json
@@ -0,0 +1,52 @@
+{
+ "I0": 0,
+ "N0": 3,
+
+ "Z": [ 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0 ],
+ "strideZ": 1,
+ "offsetZ": 0,
+
+ "PP": 0,
+ "IEEE": true,
+
+ "output": [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
+ "strideOutput": 1,
+ "offsetOutput": 0,
+
+ "Z_out": [
+ 1.00000000000000000E+002,
+ 1.81000000000000000E+002,
+ 8.10000000000000000E+001,
+ 2.86408839779005504E+001,
+ 6.40000000000000000E+001,
+ 8.43591160220994425E+001,
+ 4.90000000000000000E+001,
+ 2.09106031829196439E+001,
+ 3.60000000000000000E+001,
+ 4.00893968170803561E+001,
+ 2.50000000000000000E+001,
+ 9.97770063304063726E+000,
+ 1.60000000000000000E+001,
+ 6.02229936695936185E+000,
+ 9.00000000000000000E+000,
+ 2.86408839779005504E+001
+ ],
+
+ "output_out": [
+ 6.02229936695936185E+000,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 0,
+ 1,
+ 5,
+ -1,
+ 1.50893968170803561E+001,
+ 3.53591160220994425E+001,
+ 6.02229936695936185E+000,
+ 1.50893968170803561E+001,
+ 3.53591160220994425E+001,
+ 0.00000000000000000E+000,
+ -0.00000000000000000E+000
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/swap.json b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/swap.json
new file mode 100644
index 000000000000..1ddbfa50b8ad
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/fixtures/swap.json
@@ -0,0 +1,52 @@
+{
+ "I0": 0,
+ "N0": 1,
+
+ "Z": [ 10, 1.5, 16, 2, 30, 1, 8, 1.2, 6, 0.8, 4, 0.5, 2, 0.2, 1, 0 ],
+ "strideZ": 1,
+ "offsetZ": 0,
+
+ "PP": 0,
+ "IEEE": true,
+
+ "output": [ -0.05, 0.15, 0.10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.25, 0 ],
+ "strideOutput": 1,
+ "offsetOutput": 0,
+
+ "Z_out": [
+ 5.01499999999999986E+001,
+ 1.50000000000000000E+000,
+ 1.60000000000000000E+001,
+ 2.00000000000000000E+000,
+ 6.15000000000000036E+000,
+ 1.00000000000000000E+000,
+ 8.00000000000000000E+000,
+ 1.19999999999999996E+000,
+ 6.00000000000000000E+000,
+ 8.00000000000000044E-001,
+ 4.00000000000000000E+000,
+ 5.00000000000000000E-001,
+ 2.00000000000000000E+000,
+ 2.00000000000000011E-001,
+ 1.00000000000000000E+000,
+ 0.00000000000000000E+000
+ ],
+
+ "output_out": [
+ -5.00000000000000028E-002,
+ 1.49999999999999994E-001,
+ 1.00000000000000006E-001,
+ 0.00000000000000000E+000,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 0.00000000000000000E+000,
+ 2.50000000000000000E-001,
+ 0.00000000000000000E+000
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/test.dlasq3.js b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/test.dlasq3.js
new file mode 100644
index 000000000000..96b72bf20fb3
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/test.dlasq3.js
@@ -0,0 +1,416 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var Float64Array = require( '@stdlib/array/float64' );
+var isAlmostEqual = require( '@stdlib/assert/is-almost-equal-float64array' );
+var isnan = require( '@stdlib/assert/is-nan' );
+var dlasq3 = require( './../lib/dlasq3.js' );
+
+
+// FIXTURES //
+
+// All tests have been verified with the LAPACK fortran code.
+var STD = require( './fixtures/standard.json' );
+var ALT = require( './fixtures/alternate.json' );
+var DEF1 = require( './fixtures/deflate1.json' );
+var DEF2 = require( './fixtures/deflate2.json' );
+var DEF_ELSE = require( './fixtures/deflate_else.json' );
+var REVERSE = require( './fixtures/reverse.json' );
+var SWAP = require( './fixtures/swap.json' );
+var BIG_TAU = require( './fixtures/big_tau.json' );
+var LATE_FAILURE = require( './fixtures/late_failure.json' );
+var PP2 = require( './fixtures/pp2.json' );
+var NAN_DMIN = require( './fixtures/nan_dmin.json' );
+var NAN_Z = require( './fixtures/nan_z.json' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof dlasq3, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function has an arity of 6', function test( t ) {
+ t.strictEqual( dlasq3.length, 6, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function quick returns when `N0` < `I0`', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = STD;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output );
+ expectedZ = new Float64Array( data.Z );
+
+ dlasq3( data.I0, -1, Z, data.PP, data.IEEE, out );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = STD;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.PP, data.IEEE, out );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = ALT;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.PP, data.IEEE, out );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = DEF1;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.PP, data.IEEE, out );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = DEF2;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.PP, data.IEEE, out );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = DEF_ELSE;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.PP, data.IEEE, out );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = REVERSE;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.PP, data.IEEE, out );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = SWAP;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.PP, data.IEEE, out );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = BIG_TAU;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.PP, data.IEEE, out );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = PP2;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.PP, data.IEEE, out );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = LATE_FAILURE;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.PP, data.IEEE, out );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = NAN_DMIN;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.PP, data.IEEE, out );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = NAN_Z;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.PP, data.IEEE, out );
+ t.strictEqual( isnan( Z[ 0 ] ), true, 'returns expected Z(0) value' );
+ t.strictEqual( isnan( Z[ 1 ] ), true, 'returns expected Z(1) value' );
+ t.strictEqual( Z[ 2 ], expectedZ[ 2 ], 'returns expected Z(2) value' );
+ t.strictEqual( isnan( Z[ 3 ] ), true, 'returns expected Z(3) value' );
+ t.strictEqual( Z[ 4 ], expectedZ[ 4 ], 'returns expected Z(4) value' );
+ t.strictEqual( isnan( Z[ 5 ] ), true, 'returns expected Z(5) value' );
+ t.strictEqual( Z[ 6 ], expectedZ[ 6 ], 'returns expected Z(6) value' );
+ t.strictEqual( isnan( Z[ 7 ] ), true, 'returns expected Z(7) value' );
+ t.strictEqual( Z[ 8 ], expectedZ[ 8 ], 'returns expected Z(8) value' );
+ t.strictEqual( isnan( Z[ 9 ] ), true, 'returns expected Z(9) value' );
+ t.strictEqual( Z[ 10 ], expectedZ[ 10 ], 'returns expected Z(10) value' );
+ t.strictEqual( isnan( Z[ 11 ] ), true, 'returns expected Z(11) value' );
+ t.strictEqual( Z[ 12 ], expectedZ[ 12 ], 'returns expected Z(12) value' );
+ t.strictEqual( isnan( Z[ 13 ] ), true, 'returns expected Z(13) value' );
+ t.strictEqual( Z[ 14 ], expectedZ[ 14 ], 'returns expected Z(14) value' );
+ t.strictEqual( isnan( Z[ 15 ] ), true, 'returns expected Z(15) value' );
+
+ t.strictEqual( isnan( out[ 0 ] ), true, 'returns expected DMIN value' );
+ t.strictEqual( out[ 1 ], expectedOut[ 1 ], 'returns expected SIGMA value' );
+ t.strictEqual( out[ 2 ], expectedOut[ 2 ], 'returns expected DESIG value' );
+ t.strictEqual( out[ 3 ], expectedOut[ 3 ], 'returns expected QMAX value' );
+ t.strictEqual( out[ 4 ], expectedOut[ 4 ], 'returns expected NFAIL value' );
+ t.strictEqual( out[ 5 ], expectedOut[ 5 ], 'returns expected ITER value' );
+ t.strictEqual( out[ 6 ], expectedOut[ 6 ], 'returns expected NDIV value' );
+ t.strictEqual( out[ 7 ], expectedOut[ 7 ], 'returns expected TTYPE value' );
+ t.strictEqual( isnan( out[ 8 ] ), true, 'returns expected DMIN1 value' );
+ t.strictEqual( isnan( out[ 9 ] ), true, 'returns expected DMIN2 value' );
+ t.strictEqual( isnan( out[ 10 ] ), true, 'returns expected DN value' );
+ t.strictEqual( isnan( out[ 11 ] ), true, 'returns expected DN1 value' );
+ t.strictEqual( isnan( out[ 12 ] ), true, 'returns expected DN2 value' );
+ t.strictEqual( out[ 13 ], expectedOut[ 13 ], 'returns expected G value' );
+ t.strictEqual( out[ 14 ], expectedOut[ 14 ], 'returns expected TAU value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS and handles convergence hidden by negative DN', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var out;
+ var Z;
+
+ Z = new Float64Array([
+ 100, 4, 81, 3, 64, 2.5, 49, 2, 36, 1.5, 25, 1, 16, 0.5, 9, 0
+ ]);
+ out = new Float64Array( 15 );
+ out[ 0 ] = 20;
+ out[ 1 ] = 600000000000000;
+
+ expectedOut = new Float64Array([
+ 0.0,
+ 600000000000005.0,
+ 0.0,
+ 0.0,
+ 0.0,
+ 1.0,
+ 5.0,
+ -6.0,
+ 8.541666666666668,
+ 29.545454545454547,
+ -0.9254658385093171,
+ 8.541666666666668,
+ 29.545454545454547,
+ 0.25,
+ 5.0
+ ]);
+ expectedZ = new Float64Array([
+ 100.0,
+ 176.0,
+ 81.0,
+ 29.454545454545457,
+ 64.0,
+ 78.54545454545455,
+ 49.0,
+ 22.458333333333332,
+ 36.0,
+ 33.54166666666667,
+ 25.0,
+ 11.925465838509314,
+ 16.0,
+ 0.0,
+ 9.0,
+ 29.454545454545457
+ ]);
+
+ dlasq3( 0, 3, Z, 0, true, out );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected output' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected Z' );
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/test.js b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/test.js
new file mode 100644
index 000000000000..62d3da092024
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/test.js
@@ -0,0 +1,82 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var proxyquire = require( 'proxyquire' );
+var IS_BROWSER = require( '@stdlib/assert/is-browser' );
+var dlasq3 = require( './../lib' );
+
+
+// VARIABLES //
+
+var opts = {
+ 'skip': IS_BROWSER
+};
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof dlasq3, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'attached to the main export is a method providing an ndarray interface', function test( t ) {
+ t.strictEqual( typeof dlasq3.ndarray, 'function', 'method is a function' );
+ t.end();
+});
+
+tape( 'if a native implementation is available, the main export is the native implementation', opts, function test( t ) {
+ var dlasq3 = proxyquire( './../lib', {
+ '@stdlib/utils/try-require': tryRequire
+ });
+
+ t.strictEqual( dlasq3, mock, 'returns expected value' );
+ t.end();
+
+ function tryRequire() {
+ return mock;
+ }
+
+ function mock() {
+ // Mock...
+ }
+});
+
+tape( 'if a native implementation is not available, the main export is a JavaScript implementation', opts, function test( t ) {
+ var dlasq3;
+ var main;
+
+ main = require( './../lib/dlasq3.js' );
+
+ dlasq3 = proxyquire( './../lib', {
+ '@stdlib/utils/try-require': tryRequire
+ });
+
+ t.strictEqual( dlasq3, main, 'returns expected value' );
+ t.end();
+
+ function tryRequire() {
+ return new Error( 'Cannot find module' );
+ }
+});
diff --git a/lib/node_modules/@stdlib/lapack/base/dlasq3/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/test.ndarray.js
new file mode 100644
index 000000000000..20bd03650ec9
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlasq3/test/test.ndarray.js
@@ -0,0 +1,1087 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var Float64Array = require( '@stdlib/array/float64' );
+var isAlmostEqual = require( '@stdlib/assert/is-almost-equal-float64array' );
+var isnan = require( '@stdlib/assert/is-nan' );
+var dlasq3 = require( './../lib/ndarray.js' );
+
+
+// FIXTURES //
+
+// All tests have been verified with the LAPACK fortran code.
+var STD = require( './fixtures/standard.json' );
+var ALT = require( './fixtures/alternate.json' );
+var DEF1 = require( './fixtures/deflate1.json' );
+var DEF2 = require( './fixtures/deflate2.json' );
+var DEF_ELSE = require( './fixtures/deflate_else.json' );
+var REVERSE = require( './fixtures/reverse.json' );
+var SWAP = require( './fixtures/swap.json' );
+var BIG_TAU = require( './fixtures/big_tau.json' );
+var LATE_FAILURE = require( './fixtures/late_failure.json' );
+var PP2 = require( './fixtures/pp2.json' );
+var NAN_DMIN = require( './fixtures/nan_dmin.json' );
+var NAN_Z = require( './fixtures/nan_z.json' );
+var LAR_STR_STD = require( './fixtures/large_strides/standard.json' );
+var LAR_STR_ALT = require( './fixtures/large_strides/alternate.json' );
+var LAR_STR_DEF1 = require( './fixtures/large_strides/deflate1.json' );
+var LAR_STR_DEF2 = require( './fixtures/large_strides/deflate2.json' );
+var LAR_STR_DEF_ELSE = require( './fixtures/large_strides/deflate_else.json' );
+var LAR_STR_REVERSE = require( './fixtures/large_strides/reverse.json' );
+var LAR_STR_SWAP = require( './fixtures/large_strides/swap.json' );
+var LAR_STR_BIG_TAU = require( './fixtures/large_strides/big_tau.json' );
+var LAR_STR_LATE_FAILURE = require( './fixtures/large_strides/late_failure.json' );
+var LAR_STR_PP2 = require( './fixtures/large_strides/pp2.json' );
+var LAR_STR_NAN_DMIN = require( './fixtures/large_strides/nan_dmin.json' );
+var NEG_STR_STD = require( './fixtures/negative_strides/standard.json' );
+var NEG_STR_ALT = require( './fixtures/negative_strides/alternate.json' );
+var NEG_STR_DEF1 = require( './fixtures/negative_strides/deflate1.json' );
+var NEG_STR_DEF2 = require( './fixtures/negative_strides/deflate2.json' );
+var NEG_STR_DEF_ELSE = require( './fixtures/negative_strides/deflate_else.json' );
+var NEG_STR_REVERSE = require( './fixtures/negative_strides/reverse.json' );
+var NEG_STR_SWAP = require( './fixtures/negative_strides/swap.json' );
+var NEG_STR_BIG_TAU = require( './fixtures/negative_strides/big_tau.json' );
+var NEG_STR_LATE_FAILURE = require( './fixtures/negative_strides/late_failure.json' );
+var NEG_STR_PP2 = require( './fixtures/negative_strides/pp2.json' );
+var NEG_STR_NAN_DMIN = require( './fixtures/negative_strides/nan_dmin.json' );
+var OFF_STD = require( './fixtures/offsets/standard.json' );
+var OFF_ALT = require( './fixtures/offsets/alternate.json' );
+var OFF_DEF1 = require( './fixtures/offsets/deflate1.json' );
+var OFF_DEF2 = require( './fixtures/offsets/deflate2.json' );
+var OFF_DEF_ELSE = require( './fixtures/offsets/deflate_else.json' );
+var OFF_REVERSE = require( './fixtures/offsets/reverse.json' );
+var OFF_SWAP = require( './fixtures/offsets/swap.json' );
+var OFF_BIG_TAU = require( './fixtures/offsets/big_tau.json' );
+var OFF_LATE_FAILURE = require( './fixtures/offsets/late_failure.json' );
+var OFF_PP2 = require( './fixtures/offsets/pp2.json' );
+var OFF_NAN_DMIN = require( './fixtures/offsets/nan_dmin.json' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof dlasq3, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function has an arity of 10', function test( t ) {
+ t.strictEqual( dlasq3.length, 10, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function quick returns when `N0` < `I0`', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = STD;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output );
+ expectedZ = new Float64Array( data.Z );
+
+ dlasq3( data.I0, -1, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = STD;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = ALT;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = DEF1;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = DEF2;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = DEF_ELSE;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = REVERSE;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = SWAP;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = BIG_TAU;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = PP2;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = LATE_FAILURE;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = NAN_DMIN;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (negative stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = NAN_Z;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isnan( Z[ 0 ] ), true, 'returns expected Z(0) value' );
+ t.strictEqual( isnan( Z[ 1 ] ), true, 'returns expected Z(1) value' );
+ t.strictEqual( Z[ 2 ], expectedZ[ 2 ], 'returns expected Z(2) value' );
+ t.strictEqual( isnan( Z[ 3 ] ), true, 'returns expected Z(3) value' );
+ t.strictEqual( Z[ 4 ], expectedZ[ 4 ], 'returns expected Z(4) value' );
+ t.strictEqual( isnan( Z[ 5 ] ), true, 'returns expected Z(5) value' );
+ t.strictEqual( Z[ 6 ], expectedZ[ 6 ], 'returns expected Z(6) value' );
+ t.strictEqual( isnan( Z[ 7 ] ), true, 'returns expected Z(7) value' );
+ t.strictEqual( Z[ 8 ], expectedZ[ 8 ], 'returns expected Z(8) value' );
+ t.strictEqual( isnan( Z[ 9 ] ), true, 'returns expected Z(9) value' );
+ t.strictEqual( Z[ 10 ], expectedZ[ 10 ], 'returns expected Z(10) value' );
+ t.strictEqual( isnan( Z[ 11 ] ), true, 'returns expected Z(11) value' );
+ t.strictEqual( Z[ 12 ], expectedZ[ 12 ], 'returns expected Z(12) value' );
+ t.strictEqual( isnan( Z[ 13 ] ), true, 'returns expected Z(13) value' );
+ t.strictEqual( Z[ 14 ], expectedZ[ 14 ], 'returns expected Z(14) value' );
+ t.strictEqual( isnan( Z[ 15 ] ), true, 'returns expected Z(15) value' );
+
+ t.strictEqual( isnan( out[ 0 ] ), true, 'returns expected DMIN value' );
+ t.strictEqual( out[ 1 ], expectedOut[ 1 ], 'returns expected SIGMA value' );
+ t.strictEqual( out[ 2 ], expectedOut[ 2 ], 'returns expected DESIG value' );
+ t.strictEqual( out[ 3 ], expectedOut[ 3 ], 'returns expected QMAX value' );
+ t.strictEqual( out[ 4 ], expectedOut[ 4 ], 'returns expected NFAIL value' );
+ t.strictEqual( out[ 5 ], expectedOut[ 5 ], 'returns expected ITER value' );
+ t.strictEqual( out[ 6 ], expectedOut[ 6 ], 'returns expected NDIV value' );
+ t.strictEqual( out[ 7 ], expectedOut[ 7 ], 'returns expected TTYPE value' );
+ t.strictEqual( isnan( out[ 8 ] ), true, 'returns expected DMIN1 value' );
+ t.strictEqual( isnan( out[ 9 ] ), true, 'returns expected DMIN2 value' );
+ t.strictEqual( isnan( out[ 10 ] ), true, 'returns expected DN value' );
+ t.strictEqual( isnan( out[ 11 ] ), true, 'returns expected DN1 value' );
+ t.strictEqual( isnan( out[ 12 ] ), true, 'returns expected DN2 value' );
+ t.strictEqual( out[ 13 ], expectedOut[ 13 ], 'returns expected G value' );
+ t.strictEqual( out[ 14 ], expectedOut[ 14 ], 'returns expected TAU value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (large stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = LAR_STR_STD;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (large stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = LAR_STR_ALT;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (large stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = LAR_STR_DEF1;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (large stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = LAR_STR_DEF2;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (large stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = LAR_STR_DEF_ELSE;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (large stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = LAR_STR_REVERSE;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (large stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = LAR_STR_SWAP;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (large stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = LAR_STR_BIG_TAU;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (large stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = LAR_STR_PP2;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (large stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = LAR_STR_LATE_FAILURE;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (large stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = LAR_STR_NAN_DMIN;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (negative stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = NEG_STR_STD;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (negative stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = NEG_STR_ALT;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (negative stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = NEG_STR_DEF1;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (negative stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = NEG_STR_DEF2;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (negative stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = NEG_STR_DEF_ELSE;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (negative stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = NEG_STR_REVERSE;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (negative stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = NEG_STR_SWAP;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (negative stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = NEG_STR_BIG_TAU;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (negative stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = NEG_STR_PP2;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (negative stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = NEG_STR_LATE_FAILURE;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (negative stride)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = NEG_STR_NAN_DMIN;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (offset)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = OFF_STD;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (offset)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = OFF_ALT;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (offset)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = OFF_DEF1;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (offset)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = OFF_DEF2;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (offset)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = OFF_DEF_ELSE;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (offset)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = OFF_REVERSE;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (offset)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = OFF_SWAP;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (offset)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = OFF_BIG_TAU;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (offset)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = OFF_PP2;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (offset)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = OFF_LATE_FAILURE;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function checks for deflation, computes a shift (`TAU`) and calls DQDS (offset)', function test( t ) {
+ var expectedOut;
+ var expectedZ;
+ var data;
+ var out;
+ var Z;
+
+ data = OFF_NAN_DMIN;
+
+ Z = new Float64Array( data.Z );
+ out = new Float64Array( data.output );
+
+ expectedOut = new Float64Array( data.output_out );
+ expectedZ = new Float64Array( data.Z_out );
+
+ dlasq3( data.I0, data.N0, Z, data.strideZ, data.offsetZ, data.PP, data.IEEE, out, data.strideOutput, data.offsetOutput );
+ t.strictEqual( isAlmostEqual( out, expectedOut, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( Z, expectedZ, 1 ), true, 'returns expected value' );
+ t.end();
+});