diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/README.md b/lib/node_modules/@stdlib/lapack/base/dlanv2/README.md
new file mode 100644
index 000000000000..8de6529a8732
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/README.md
@@ -0,0 +1,427 @@
+
+
+# dlanv2
+
+> Copy all or part of a matrix `A` to another matrix `B`.
+
+
+
+
+The `dlanv2` routine computes the real Schur factorization of a real 2-by-2 nonsymmetric matrix `A` using an orthogonal similarity transformation. The factorization has the form:
+
+
+
+```math
+A = Q T Q^T
+```
+
+
+
+where `Q` is an orthogonal matrix represented as a Givens rotation:
+
+
+
+```math
+Q = \begin{bmatrix} cs & sn \\
+-sn & cs \end{bmatrix}
+```
+
+
+
+and `T` is the resulting matrix in real Schur form, satisfying one of the two cases:
+
+1. `T` is upper triangular, with real eigenvalues:
+
+
+
+```math
+T = \begin{bmatrix} AA & BB \\
+0 & DD \end{bmatrix}
+```
+
+
+
+2. `T` is a 2x2 block with complex conjugate eigenvalues:
+
+
+
+```math
+T = \begin{bmatrix} AA & BB \\
+CC & AA \end{bmatrix}
+```
+
+
+
+with `BB*CC < 0`, yielding complex conjugate eigenvalues:
+
+
+
+```math
+\lambda = AA \pm i\sqrt{-BB \cdot CC}
+```
+
+
+
+
+
+
+
+
+
+## Usage
+
+```javascript
+var dlanv2 = require( '@stdlib/lapack/base/dlanv2' );
+```
+
+#### dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN )
+
+Computes the Schur factorization of a real 2-by-2 nonsymmetric matrix `A` in standard form.
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+
+var A = new Float64Array( [ 4.0 ] );
+var B = new Float64Array( [ -5.0 ] );
+var C = new Float64Array( [ 2.0 ] );
+var D = new Float64Array( [ -3.0 ] );
+var RT1R = new Float64Array( 1 );
+var RT1I = new Float64Array( 1 );
+var RT2R = new Float64Array( 1 );
+var RT2I = new Float64Array( 1 );
+var CS = new Float64Array( 1 );
+var SN = new Float64Array( 1 );
+
+dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
+// A => [ 2.0 ]
+// B => [ -7.0 ]
+// C => [ 0.0 ]
+// D => [ -1.0 ]
+// RT1R => [ 2.0 ]
+// RT1I => [ 0.0 ]
+// RT2R => [ -1.0 ]
+// RT2I => [ 0.0 ]
+// CS => [ ~0.93 ]
+// SN => [ ~0.34 ]
+```
+
+The function has the following parameters:`
+
+- **A**: single-element [`Float64Array`][mdn-float64array] containing the element `A(1,1)`.
+- **B**: single-element [`Float64Array`][mdn-float64array] containing the element `A(1,2)`.
+- **C**: single-element [`Float64Array`][mdn-float64array] containing the element `A(2,1)`.
+- **D**: single-element [`Float64Array`][mdn-float64array] containing the element `A(2,2)`.
+- **RT1R**: single-element output [`Float64Array`][mdn-float64array] to store the real value of the first eigenvector.
+- **RT1I**: single-element output [`Float64Array`][mdn-float64array] to store the imaginary value of the first eigenvector.
+- **RT2R**: single-element output [`Float64Array`][mdn-float64array] to store the real value of the second eigenvector.
+- **RT2I**: single-element output [`Float64Array`][mdn-float64array] to store the imaginary value of the second eigenvector.
+- **CS**: output [`Float64Array`][mdn-float64array] to store the cosine of the rotation.
+- **SN**: output [`Float64Array`][mdn-float64array] to store the sine of the rotation.
+
+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 A0 = new Float64Array( [ 0.0, 4.0 ] );
+var B0 = new Float64Array( [ 0.0, -5.0 ] );
+var C0 = new Float64Array( [ 0.0, 2.0 ] );
+var D0 = new Float64Array( [ 0.0, -3.0 ] );
+var RT1R0 = new Float64Array( 2 );
+var RT1I0 = new Float64Array( 2 );
+var RT2R0 = new Float64Array( 2 );
+var RT2I0 = new Float64Array( 2 );
+var CS0 = new Float64Array( 2 );
+var SN0 = new Float64Array( 2 );
+
+// Create offset views...
+var A1 = new Float64Array( A0.buffer, A0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+var B1 = new Float64Array( B0.buffer, B0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+var C1 = new Float64Array( C0.buffer, C0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+var D1 = new Float64Array( D0.buffer, D0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+var RT1R1 = new Float64Array( RT1R0.buffer, RT1R0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+var RT1I1 = new Float64Array( RT1I0.buffer, RT1I0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+var RT2R1 = new Float64Array( RT2R0.buffer, RT2R0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+var RT2I1 = new Float64Array( RT2I0.buffer, RT2I0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+var CS1 = new Float64Array( CS0.buffer, CS0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+var SN1 = new Float64Array( SN0.buffer, SN0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+
+dlanv2( A1, B1, C1, D1, RT1R1, RT1I1, RT2R1, RT2I1, CS1, SN1 );
+// A0 => [ 0.0, 2.0 ]
+// B0 => [ 0.0, -7.0 ]
+// C0 => [ 0.0, 0.0 ]
+// D0 => [ 0.0, -1.0 ]
+// RT1R0 => [ 0.0, 2.0 ]
+// RT1I0 => [ 0.0, 0.0 ]
+// RT2R0 => [ 0.0, -1.0 ]
+// RT2I0 => [ 0.0, 0.0 ]
+// CS0 => [ 0.0, ~0.93 ]
+// SN0 => [ 0.0, ~0.34 ]
+```
+
+
+
+#### dlanv2.ndarray( A, oa, B, ob, C, oc, D, od, RT1R, or1, RT1I, oi1, RT2R, or2, RT2I, oi2, CS, ocs, SN, osn )
+
+Computes the Schur factorization of a real 2-by-2 nonsymmetric matrix `A` in standard form using alternative indexing semantics.
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+
+var A = new Float64Array( [ 4.0 ] );
+var B = new Float64Array( [ -5.0 ] );
+var C = new Float64Array( [ 2.0 ] );
+var D = new Float64Array( [ -3.0 ] );
+var RT1R = new Float64Array( 1 );
+var RT1I = new Float64Array( 1 );
+var RT2R = new Float64Array( 1 );
+var RT2I = new Float64Array( 1 );
+var CS = new Float64Array( 1 );
+var SN = new Float64Array( 1 );
+
+dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 );
+// A => [ 2.0 ]
+// B => [ -7.0 ]
+// C => [ 0.0 ]
+// D => [ -1.0 ]
+// RT1R => [ 2.0 ]
+// RT1I => [ 0.0 ]
+// RT2R => [ -1.0 ]
+// RT2I => [ 0.0 ]
+// CS => [ ~0.93 ]
+// SN => [ ~0.34 ]
+```
+
+The function has the following parameters:
+
+- **A**: single-element [`Float64Array`][mdn-float64array] containing the element `A(1,1)`.
+- **oa**: starting index for `A`.
+- **B**: single-element [`Float64Array`][mdn-float64array] containing the element `A(1,2)`.
+- **ob**: starting index for `B`.
+- **C**: single-element [`Float64Array`][mdn-float64array] containing the element `A(2,1)`.
+- **oc**: starting index for `C`.
+- **D**: single-element [`Float64Array`][mdn-float64array] containing the element `A(2,2)`.
+- **od**: starting index for `D`.
+- **RT1R**: single-element output [`Float64Array`][mdn-float64array] to store the real value of the first eigenvector.
+- **or1**: starting index for `RT1R`.
+- **RT1I**: single-element output [`Float64Array`][mdn-float64array] to store the imaginary value of the first eigenvector.
+- **oi1**: starting index for `RT1I`.
+- **RT2R**: single-element output [`Float64Array`][mdn-float64array] to store the real value of the second eigenvector.
+- **or2**: starting index for `RT2R`.
+- **RT2I**: single-element output [`Float64Array`][mdn-float64array] to store the imaginary value of the second eigenvector.
+- **oi2**: starting index for `RT2I`.
+- **CS**: output [`Float64Array`][mdn-float64array] to store the cosine of the rotation.
+- **ocs**: starting index for `CS`.
+- **SN**: output [`Float64Array`][mdn-float64array] to store the sine of the rotation.
+- **osn**: starting index for `SN`.
+
+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 A = new Float64Array( [ 0.0, 4.0 ] );
+var B = new Float64Array( [ 0.0, -5.0 ] );
+var C = new Float64Array( [ 0.0, 2.0 ] );
+var D = new Float64Array( [ 0.0, -3.0 ] );
+var RT1R = new Float64Array( 2 );
+var RT1I = new Float64Array( 2 );
+var RT2R = new Float64Array( 2 );
+var RT2I = new Float64Array( 2 );
+var CS = new Float64Array( 2 );
+var SN = new Float64Array( 2 );
+
+dlanv2.ndarray( A, 1, B, 1, C, 1, D, 1, RT1R, 1, RT1I, 1, RT2R, 1, RT2I, 1, CS, 1, SN, 1 );
+// A => [ 0.0, 2.0 ]
+// B => [ 0.0, -7.0 ]
+// C => [ 0.0, 0.0 ]
+// D => [ 0.0, -1.0 ]
+// RT1R => [ 0.0, 2.0 ]
+// RT1I => [ 0.0, 0.0 ]
+// RT2R => [ 0.0, -1.0 ]
+// RT2I => [ 0.0, 0.0 ]
+// CS => [ 0.0, ~0.93 ]
+// SN => [ 0.0, ~0.34 ]
+```
+
+
+
+
+
+
+
+## Notes
+
+- `dlanv2()` corresponds to the [LAPACK][lapack] routine [`dlanv2`][lapack-dlanv2].
+
+
+
+
+
+
+
+## Examples
+
+
+
+```javascript
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var Float64Array = require( '@stdlib/array/float64' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var dlanv2 = require( '@stdlib/lapack/base/dlanv2' );
+
+var opts = {
+ 'dtype': 'float64'
+};
+var A = discreteUniform( 1, -50, 50, opts );
+var B = discreteUniform( 1, -50, 50, opts );
+var C = discreteUniform( 1, -50, 50, opts );
+var D = discreteUniform( 1, -50, 50, opts );
+var RT1R = new Float64Array( 1 );
+var RT1I = new Float64Array( 1 );
+var RT2R = new Float64Array( 1 );
+var RT2I = new Float64Array( 1 );
+var CS = new Float64Array( 1 );
+var SN = new Float64Array( 1 );
+
+console.log( 'input matrix: ' );
+console.log( [ [ A[ 0 ], B[ 0 ] ], [ C[ 0 ], D[ 0 ] ] ] );
+
+dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
+
+console.log( 'the schur factorization of the matrix: ' );
+console.log([
+ [ CS[ 0 ], -SN[ 0 ] ],
+ [ SN[ 0 ], CS[ 0 ] ]
+], '*', [
+ [ A[ 0 ], B[ 0 ] ],
+ [ C[ 0 ], D[ 0 ] ]
+], '*', [
+ [ CS[ 0 ], SN[ 0 ] ],
+ [ -SN[ 0 ], CS[ 0 ] ]
+]);
+
+var eigenvalue1 = new Complex128( RT1R[ 0 ], RT1I[ 0 ] );
+var eigenvalue2 = new Complex128( RT2R[ 0 ], RT2I[ 0 ] );
+
+console.log( 'and the two eigenvectors are: ', eigenvalue1, 'and', eigenvalue2 );
+```
+
+
+
+
+
+
+
+* * *
+
+
+
+## C APIs
+
+
+
+
+
+
+
+
+
+
+
+### Usage
+
+```c
+TODO
+```
+
+#### TODO
+
+TODO.
+
+```c
+TODO
+```
+
+TODO
+
+```c
+TODO
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Examples
+
+```c
+TODO
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[lapack]: https://www.netlib.org/lapack/explore-html/
+
+[lapack-dlanv2]: https://netlib.org/lapack/explore-html/d1/d61/group__lanv2_ga2835625c9ec341faca0a2712c85dd636.html#ga2835625c9ec341faca0a2712c85dd636
+
+[mdn-float64array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array
+
+[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/dlanv2/benchmark/benchmark.js b/lib/node_modules/@stdlib/lapack/base/dlanv2/benchmark/benchmark.js
new file mode 100644
index 000000000000..511c7afa7457
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/benchmark/benchmark.js
@@ -0,0 +1,77 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* 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 discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var Float64Array = require( '@stdlib/array/float64' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pkg = require( './../package.json' ).name;
+var dlanv2 = require( './../lib/dlanv2.js' );
+
+
+// VARIABLES //
+
+var opts = {
+ 'dtype': 'float64'
+};
+
+
+// MAIN //
+
+bench( pkg, function benchmark( b ) {
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+ var i;
+
+ A = discreteUniform( 1, -50, 50, opts );
+ B = discreteUniform( 1, -50, 50, opts );
+ C = discreteUniform( 1, -50, 50, opts );
+ D = discreteUniform( 1, -50, 50, opts );
+ RT1R = new Float64Array( 1 );
+ RT1I = new Float64Array( 1 );
+ RT2R = new Float64Array( 1 );
+ RT2I = new Float64Array( 1 );
+ CS = new Float64Array( 1 );
+ SN = new Float64Array( 1 );
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
+ if ( isnan( A[ 0 ] ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ }
+ b.toc();
+ if ( isnan( B[ 0 ] ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlanv2/benchmark/benchmark.ndarray.js
new file mode 100644
index 000000000000..e2efc8a80d18
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/benchmark/benchmark.ndarray.js
@@ -0,0 +1,77 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* 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 discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var Float64Array = require( '@stdlib/array/float64' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pkg = require( './../package.json' ).name;
+var dlanv2 = require( './../lib/ndarray.js' );
+
+
+// VARIABLES //
+
+var opts = {
+ 'dtype': 'float64'
+};
+
+
+// MAIN //
+
+bench( pkg, function benchmark( b ) {
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+ var i;
+
+ A = discreteUniform( 1, -50, 50, opts );
+ B = discreteUniform( 1, -50, 50, opts );
+ C = discreteUniform( 1, -50, 50, opts );
+ D = discreteUniform( 1, -50, 50, opts );
+ RT1R = new Float64Array( 1 );
+ RT1I = new Float64Array( 1 );
+ RT2R = new Float64Array( 1 );
+ RT2I = new Float64Array( 1 );
+ CS = new Float64Array( 1 );
+ SN = new Float64Array( 1 );
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ dlanv2( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // eslint-disable-line max-len
+ if ( isnan( A[ 0 ] ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ }
+ b.toc();
+ if ( isnan( B[ 0 ] ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/dlanv2/docs/repl.txt
new file mode 100644
index 000000000000..12b92d6e6359
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/docs/repl.txt
@@ -0,0 +1,216 @@
+{{alias}}( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN )
+ Computes the real Schur factorization of a 2-by-2 real nonsymmetric
+ matrix using an orthogonal similarity transformation.
+
+ Given matrix:
+
+ [ A B ]
+ [ C D ]
+
+ The routine computes an orthogonal rotation (cosine CS, sine SN) such
+ that:
+
+ Q^T * [ A B ] * Q = [ AA BB ]
+ [ C D ] [ CC DD ]
+
+ where Q is a 2x2 rotation matrix:
+
+ Q = [ CS SN ]
+ [ -SN CS ]
+
+ and the result is either real upper triangular (real eigenvalues) or
+ 2x2 block diagonal (complex conjugate eigenvalues).
+
+ Indexing is relative to the first index. To introduce an offset, use
+ typed array views.
+
+ Parameters
+ ----------
+ A: Float64Array
+ Input element A(1,1).
+
+ B: Float64Array
+ Input element A(1,2).
+
+ C: Float64Array
+ Input element A(2,1).
+
+ D: Float64Array
+ Input element A(2,2).
+
+ RT1R: Float64Array
+ Output: real part of the first eigenvalue.
+
+ RT1I: Float64Array
+ Output: imaginary part of the first eigenvalue.
+
+ RT2R: Float64Array
+ Output: real part of the second eigenvalue.
+
+ RT2I: Float64Array
+ Output: imaginary part of the second eigenvalue.
+
+ CS: Float64Array
+ Output: cosine of the rotation.
+
+ SN: Float64Array
+ Output: sine of the rotation.
+
+ Returns
+ -------
+ undefined
+
+ Examples
+ --------
+ > var Float64Array = require( '@stdlib/array/float64' );
+ > var dlanv2 = require( '@stdlib/lapack/base/dlanv2' );
+
+ > var A = new Float64Array( [ 4.0 ] );
+ > var B = new Float64Array( [ -5.0 ] );
+ > var C = new Float64Array( [ 2.0 ] );
+ > var D = new Float64Array( [ -3.0 ] );
+ > var RT1R = new Float64Array( 1 );
+ > var RT1I = new Float64Array( 1 );
+ > var RT2R = new Float64Array( 1 );
+ > var RT2I = new Float64Array( 1 );
+ > var CS = new Float64Array( 1 );
+ > var SN = new Float64Array( 1 );
+
+ > dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
+
+ > A
+ [ 2.0 ]
+ > B
+ [ -7.0 ]
+ > C
+ [ 0.0 ]
+ > D
+ [ -1.0 ]
+ > RT1R
+ [ 2.0 ]
+ > RT1I
+ [ 0.0 ]
+ > RT2R
+ [ -1.0 ]
+ > RT2I
+ [ 0.0 ]
+ > CS
+ [ ~0.93 ]
+ > SN
+ [ ~0.34 ]
+
+{{alias}}.ndarray( A,oa,B,ob,C,oc,D,od,R1,or1,I1,oi1,R2,or2,I2,oi2,CS,ocs,SN,osn )
+
+ Computes the Schur factorization of a 2-by-2 real nonsymmetric matrix
+ using alternative indexing semantics.
+
+ Given matrix:
+
+ [ A B ]
+ [ C D ]
+
+ The routine computes an orthogonal rotation (cosine CS, sine SN) such
+ that:
+
+ Q^T * [ A B ] * Q = [ AA BB ]
+ [ C D ] [ CC DD ]
+
+ where Q is a 2x2 rotation matrix:
+
+ Q = [ CS SN ]
+ [ -SN CS ]
+
+ and the result is either real upper triangular (real eigenvalues) or
+ 2x2 block diagonal (complex conjugate eigenvalues).
+
+ While typed array views mandate a view offset based on the underlying
+ buffer, the offset parameters support indexing semantics based on starting
+ indices.
+
+ Parameters
+ ----------
+ A: Float64Array
+ Input element A(1,1).
+
+ oa: integer
+ Starting index for `A`.
+
+ B: Float64Array
+ Input element A(1,2).
+
+ ob: integer
+ Starting index for `B`.
+
+ C: Float64Array
+ Input element A(2,1).
+
+ oc: integer
+ Starting index for `C`.
+
+ D: Float64Array
+ Input element A(2,2).
+
+ od: integer
+ Starting index for `D`.
+
+ R1: Float64Array
+ Output: real part of the first eigenvalue.
+
+ or1: integer
+ Starting index for `R1`.
+
+ I1: Float64Array
+ Output: imaginary part of the first eigenvalue.
+
+ oi1: integer
+ Starting index for `I1`.
+
+ R2: Float64Array
+ Output: real part of the second eigenvalue.
+
+ or2: integer
+ Starting index for `R2`.
+
+ I2: Float64Array
+ Output: imaginary part of the second eigenvalue.
+
+ oi2: integer
+ Starting index for `I2`.
+
+ CS: Float64Array
+ Output: cosine of the rotation.
+
+ ocs: integer
+ Starting index for `CS`.
+
+ SN: Float64Array
+ Output: sine of the rotation.
+
+ osn: integer
+ Starting index for `SN`.
+
+ Examples
+ --------
+ > var Float64Array = require( '@stdlib/array/float64' );
+ > var A = new Float64Array( [ 0.0, 4.0 ] );
+ > var B = new Float64Array( [ 0.0, -5.0 ] );
+ > var C = new Float64Array( [ 0.0, 2.0 ] );
+ > var D = new Float64Array( [ 0.0, -3.0 ] );
+ > var RT1R = new Float64Array( 2 );
+ > var RT1I = new Float64Array( 2 );
+ > var RT2R = new Float64Array( 2 );
+ > var RT2I = new Float64Array( 2 );
+ > var CS = new Float64Array( 2 );
+ > var SN = new Float64Array( 2 );
+
+ > dlanv2.ndarray( A, 1, B, 1, C, 1, D, 1,
+ RT1R, 1, RT1I, 1, RT2R, 1, RT2I, 1, CS, 1, SN, 1 );
+
+ > A
+ [ 0.0, 2.0 ]
+ > C
+ [ 0.0, 0.0 ]
+ > RT1R
+ [ 0.0, 2.0 ]
+ > RT2R
+ [ 0.0, -1.0 ]
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/dlanv2/docs/types/index.d.ts
new file mode 100644
index 000000000000..831db528f512
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/docs/types/index.d.ts
@@ -0,0 +1,287 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* 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 `dlanv2`.
+*/
+interface Routine {
+ /**
+ * Computes the Schur factorization of a real 2-by-2 nonsymmetric matrix `A` in standard form.
+ *
+ * Given a real 2×2 matrix:
+ *
+ * ```tex
+ * \begin{bmatrix}
+ * A & B \\
+ * C & D
+ * \end{bmatrix}
+ * ```
+ *
+ * this routine computes an orthogonal matrix:
+ *
+ * ```tex
+ * \begin{bmatrix}
+ * \text{CS} & \text{SN} \\
+ * -\text{SN} & \text{CS}
+ * \end{bmatrix}
+ * ```
+ *
+ * such that the matrix is reduced to Schur (quasi-triangular) form:
+ *
+ * ```tex
+ * \begin{bmatrix}
+ * \text{AA} & \text{BB} \\
+ * \text{CC} & \text{DD}
+ * \end{bmatrix}
+ * ```
+ *
+ * where either:
+ *
+ * - `CC` = 0, `AA` and `DD` are the real eigenvalues of the matrix.
+ * - `AA` = `DD` and `BB * CC` < 0, `AA + sqrt( BB * CC )` and `AA - sqrt( BB * CC )` are the complex conjugate eigenvalues.
+ *
+ * @param A - array containing the element A(1,1)
+ * @param B - array containing the element A(1,2)
+ * @param C - array containing the element A(2,1)
+ * @param D - array containing the element A(2,2)
+ * @param RT1R - output array for the real part of the first eigenvalue
+ * @param RT1I - output array for the imaginary part of the first eigenvalue
+ * @param RT2R - output array for the real part of the second eigenvalue
+ * @param RT2I - output array for the imaginary part of the second eigenvalue
+ * @param CS - output array for cosine of the rotation
+ * @param SN - output array for sine of the rotation
+ *
+ * @example
+ * var Float64Array = require( '@stdlib/array/float64' );
+ *
+ * var A = new Float64Array( [ 4.0 ] );
+ * var B = new Float64Array( [ -5.0 ] );
+ * var C = new Float64Array( [ 2.0 ] );
+ * var D = new Float64Array( [ -3.0 ] );
+ * var RT1R = new Float64Array( 1 );
+ * var RT1I = new Float64Array( 1 );
+ * var RT2R = new Float64Array( 1 );
+ * var RT2I = new Float64Array( 1 );
+ * var CS = new Float64Array( 1 );
+ * var SN = new Float64Array( 1 );
+ *
+ * dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
+ * // A => [ 2.0 ]
+ * // B => [ -7.0 ]
+ * // C => [ 0.0 ]
+ * // D => [ -1.0 ]
+ * // RT1R => [ 2.0 ]
+ * // RT1I => [ 0.0 ]
+ * // RT2R => [ -1.0 ]
+ * // RT2I => [ 0.0 ]
+ * // CS => [ ~0.93 ]
+ * // SN => [ ~0.34 ]`
+ */
+ ( A: Float64Array, B: Float64Array, C: Float64Array, D: Float64Array, RT1R: Float64Array, RT1I: Float64Array, RT2R: Float64Array, RT2I: Float64Array, CS: Float64Array, SN: Float64Array ): void;
+
+ /**
+ * Computes the Schur factorization of a real 2-by-2 nonsymmetric matrix `A` in standard form using alternative indexing semantics.
+ *
+ * Given a real 2×2 matrix:
+ *
+ * ```tex
+ * \begin{bmatrix}
+ * A & B \\
+ * C & D
+ * \end{bmatrix}
+ * ```
+ *
+ * this routine computes an orthogonal matrix:
+ *
+ * ```tex
+ * \begin{bmatrix}
+ * \text{CS} & \text{SN} \\
+ * -\text{SN} & \text{CS}
+ * \end{bmatrix}
+ * ```
+ *
+ * such that the matrix is reduced to Schur (quasi-triangular) form:
+ *
+ * ```tex
+ * \begin{bmatrix}
+ * \text{AA} & \text{BB} \\
+ * \text{CC} & \text{DD}
+ * \end{bmatrix}
+ * ```
+ *
+ * where either:
+ *
+ * - `CC` = 0, `AA` and `DD` are the real eigenvalues of the matrix.
+ * - `AA` = `DD` and `BB * CC` < 0, `AA + sqrt( BB * CC )` and `AA - sqrt( BB * CC )` are the complex conjugate eigenvalues.
+ *
+ * @param A - array containing the element A(1,1)
+ * @param offsetA - index in `A` of the element A(1,1)
+ * @param B - array containing the element A(1,2)
+ * @param offsetB - index in `B` of the element A(1,2)
+ * @param C - array containing the element A(2,1)
+ * @param offsetC - index in `C` of the element A(2,1)
+ * @param D - array containing the element A(2,2)
+ * @param offsetD - index in `D` of the element A(2,2)
+ * @param RT1R - output array for the real part of the first eigenvalue
+ * @param offsetRT1R - index in `RT1R` at which to store the value
+ * @param RT1I - output array for the imaginary part of the first eigenvalue
+ * @param offsetRT1I - index in `RT1I` at which to store the value
+ * @param RT2R - output array for the real part of the second eigenvalue
+ * @param offsetRT2R - index in `RT2R` at which to store the value
+ * @param RT2I - output array for the imaginary part of the second eigenvalue
+ * @param offsetRT2I - index in `RT2I` at which to store the value
+ * @param CS - output array for cosine of the rotation
+ * @param offsetCS - index in `CS` at which to store the value
+ * @param SN - output array for sine of the rotation
+ * @param offsetSN - index in `SN` at which to store the value
+ *
+ * @example
+ * var Float64Array = require( '@stdlib/array/float64' );
+ *
+ * var A = new Float64Array( [ 4.0 ] );
+ * var B = new Float64Array( [ -5.0 ] );
+ * var C = new Float64Array( [ 2.0 ] );
+ * var D = new Float64Array( [ -3.0 ] );
+ * var RT1R = new Float64Array( 1 );
+ * var RT1I = new Float64Array( 1 );
+ * var RT2R = new Float64Array( 1 );
+ * var RT2I = new Float64Array( 1 );
+ * var CS = new Float64Array( 1 );
+ * var SN = new Float64Array( 1 );
+ *
+ * dlanv2( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 );
+ * // A => [ 2.0 ]
+ * // B => [ -7.0 ]
+ * // C => [ 0.0 ]
+ * // D => [ -1.0 ]
+ * // RT1R => [ 2.0 ]
+ * // RT1I => [ 0.0 ]
+ * // RT2R => [ -1.0 ]
+ * // RT2I => [ 0.0 ]
+ * // CS => [ ~0.93 ]
+ * // SN => [ ~0.34 ]
+ */
+ ndarray( A: Float64Array, offsetA: number, B: Float64Array, offsetB: number, C: Float64Array, offsetC: number, D: Float64Array, offsetD: number, RT1R: Float64Array, offsetRT1R: number, RT1I: Float64Array, offsetRT1I: number, RT2R: Float64Array, offsetRT2R: number, RT2I: Float64Array, offsetRT2I: number, CS: Float64Array, offsetCS: number, SN: Float64Array, offsetSN: number ): void;
+}
+
+/**
+* Computes the Schur factorization of a real 2-by-2 nonsymmetric matrix `A` in standard form using alternative indexing semantics.
+*
+* Given a real 2×2 matrix:
+*
+* ```tex
+* \begin{bmatrix}
+* A & B \\
+* C & D
+* \end{bmatrix}
+* ```
+*
+* this routine computes an orthogonal matrix:
+*
+* ```tex
+* \begin{bmatrix}
+* \text{CS} & \text{SN} \\
+* -\text{SN} & \text{CS}
+* \end{bmatrix}
+* ```
+*
+* such that the matrix is reduced to Schur (quasi-triangular) form:
+*
+* ```tex
+* \begin{bmatrix}
+* \text{AA} & \text{BB} \\
+* \text{CC} & \text{DD}
+* \end{bmatrix}
+* ```
+*
+* where either:
+*
+* - `CC` = 0, `AA` and `DD` are the real eigenvalues of the matrix.
+* - `AA` = `DD` and `BB * CC` < 0, `AA + sqrt( BB * CC )` and `AA - sqrt( BB * CC )` are the complex conjugate eigenvalues.
+*
+* @param A - array containing the element A(1,1)
+* @param B - array containing the element A(1,2)
+* @param C - array containing the element A(2,1)
+* @param D - array containing the element A(2,2)
+* @param RT1R - output array for the real part of the first eigenvalue
+* @param RT1I - output array for the imaginary part of the first eigenvalue
+* @param RT2R - output array for the real part of the second eigenvalue
+* @param RT2I - output array for the imaginary part of the second eigenvalue
+* @param CS - output array for cosine of the rotation
+* @param SN - output array for sine of the rotation
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var A = new Float64Array( [ 4.0 ] );
+* var B = new Float64Array( [ -5.0 ] );
+* var C = new Float64Array( [ 2.0 ] );
+* var D = new Float64Array( [ -3.0 ] );
+* var RT1R = new Float64Array( 1 );
+* var RT1I = new Float64Array( 1 );
+* var RT2R = new Float64Array( 1 );
+* var RT2I = new Float64Array( 1 );
+* var CS = new Float64Array( 1 );
+* var SN = new Float64Array( 1 );
+*
+* dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
+* // A => [ 2.0 ]
+* // B => [ -7.0 ]
+* // C => [ 0.0 ]
+* // D => [ -1.0 ]
+* // RT1R => [ 2.0 ]
+* // RT1I => [ 0.0 ]
+* // RT2R => [ -1.0 ]
+* // RT2I => [ 0.0 ]
+* // CS => [ ~0.93 ]
+* // SN => [ ~0.34 ]
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var A = new Float64Array( [ 4.0 ] );
+* var B = new Float64Array( [ -5.0 ] );
+* var C = new Float64Array( [ 2.0 ] );
+* var D = new Float64Array( [ -3.0 ] );
+* var RT1R = new Float64Array( 1 );
+* var RT1I = new Float64Array( 1 );
+* var RT2R = new Float64Array( 1 );
+* var RT2I = new Float64Array( 1 );
+* var CS = new Float64Array( 1 );
+* var SN = new Float64Array( 1 );
+*
+* dlanv2( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 );
+* // A => [ 2.0 ]
+* // B => [ -7.0 ]
+* // C => [ 0.0 ]
+* // D => [ -1.0 ]
+* // RT1R => [ 2.0 ]
+* // RT1I => [ 0.0 ]
+* // RT2R => [ -1.0 ]
+* // RT2I => [ 0.0 ]
+* // CS => [ ~0.93 ]
+* // SN => [ ~0.34 ]
+*/
+declare var dlanv2: Routine;
+
+
+// EXPORTS //
+
+export = dlanv2;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/docs/types/test.ts b/lib/node_modules/@stdlib/lapack/base/dlanv2/docs/types/test.ts
new file mode 100644
index 000000000000..a83f9603ced8
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/docs/types/test.ts
@@ -0,0 +1,805 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+import dlanv2 = require( './index' );
+
+
+// TESTS //
+
+// The function returns undefined...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectType void
+}
+
+// The compiler throws an error if the function is provided a first argument which is not a Float64Array...
+{
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2( '5', B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( 5, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( true, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( false, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( null, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( undefined, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( [], B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( {}, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( ( x: number ): number => x, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not a Float64Array...
+{
+ const A = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2( A, '5', C, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, 5, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, true, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, false, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, null, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, undefined, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, [], C, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, {}, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, ( x: number ): number => x, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a third argument which is not a Float64Array...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2( A, B, '5', D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, 5, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, true, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, false, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, null, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, undefined, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, [], D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, {}, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, ( x: number ): number => x, D, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fourth argument which is not a Float64Array...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2( A, B, C, '5', RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, 5, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, true, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, false, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, null, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, undefined, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, [], RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, {}, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, ( x: number ): number => x, RT1R, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fifth argument which is not a Float64Array...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2( A, B, C, D, '5', RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, 5, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, true, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, false, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, null, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, undefined, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, [], RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, {}, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, ( x: number ): number => x, RT1I, RT2R, RT2I, CS, SN ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a sixth argument which is not a Float64Array...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2( A, B, C, D, RT1R, '5', RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, 5, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, true, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, false, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, null, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, undefined, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, [], RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, {}, RT2R, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, ( x: number ): number => x, RT2R, RT2I, CS, SN ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a seventh argument which is not a Float64Array...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2( A, B, C, D, RT1R, RT1I, '5', RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, 5, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, true, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, false, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, null, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, undefined, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, [], RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, {}, RT2I, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, ( x: number ): number => x, RT2I, CS, SN ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an eighth argument which is not a Float64Array...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, '5', CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, 5, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, true, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, false, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, null, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, undefined, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, [], CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, {}, CS, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, ( x: number ): number => x, CS, SN ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a ninth argument which is not a Float64Array...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, '5', SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, 5, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, true, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, false, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, null, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, undefined, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, [], SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, {}, SN ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, ( x: number ): number => x, SN ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a tenth argument which is not a Float64Array...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, '5' ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, 5 ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, true ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, false ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, null ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, undefined ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, [] ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, {} ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2(); // $ExpectError
+ dlanv2( A ); // $ExpectError
+ dlanv2( A, B ); // $ExpectError
+ dlanv2( A, B, C ); // $ExpectError
+ dlanv2( A, B, C, D ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS ); // $ExpectError
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN, 0 ); // $ExpectError
+}
+
+// Attached to main export is an `ndarray` method which returns undefined...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectType void
+}
+
+// The compiler throws an error if the `ndarray` method is provided a first argument which is not a Float64Array...
+{
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2.ndarray( '5', 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( 5, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( true, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( false, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( null, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( undefined, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( [], 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( {}, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( ( x: number ): number => x, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a second argument which is not a number...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2.ndarray( A, '0', B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, true, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, false, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, null, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, undefined, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, [], B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, {}, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, ( x: number ): number => x, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a third argument which is not a Float64Array...
+{
+ const A = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2.ndarray( A, 0, '5', 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, 5, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, true, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, false, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, null, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, undefined, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, [], 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, {}, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, ( x: number ): number => x, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2.ndarray( A, 0, B, '0', C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, true, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, false, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, null, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, undefined, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, [], C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, {}, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, ( x: number ): number => x, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a Float64Array...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2.ndarray( A, 0, B, 0, '5', 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, 5, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, true, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, false, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, null, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, undefined, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, [], 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, {}, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, ( x: number ): number => x, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a sixth argument which is not a number...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2.ndarray( A, 0, B, 0, C, '0', D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, true, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, false, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, null, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, undefined, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, [], D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, {}, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, ( x: number ): number => x, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a seventh argument which is not a Float64Array...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2.ndarray( A, 0, B, 0, C, 0, '5', 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, 5, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, true, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, false, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, null, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, undefined, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, [], 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, {}, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, ( x: number ): number => x, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided an eighth argument which is not a number...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, '0', RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, true, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, false, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, null, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, undefined, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, [], RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, {}, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, ( x: number ): number => x, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a ninth argument which is not a Float64Array...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, '5', 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, 5, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, true, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, false, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, null, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, undefined, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, [], 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, {}, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, ( x: number ): number => x, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a tenth argument which is not a number...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, '0', RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, true, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, false, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, null, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, undefined, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, [], RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, {}, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, ( x: number ): number => x, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided an eleventh argument which is not a Float64Array...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, '5', 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, 5, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, true, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, false, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, null, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, undefined, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, [], 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, {}, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, ( x: number ): number => x, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a twelfth argument which is not a number...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, '0', RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, true, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, false, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, null, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, undefined, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, [], RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, {}, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, ( x: number ): number => x, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a thirteenth argument which is not a Float64Array...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, '5', 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, 5, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, true, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, false, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, null, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, undefined, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, [], 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, {}, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, ( x: number ): number => x, 0, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a fourteenth argument which is not a number...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, '0', RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, true, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, false, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, null, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, undefined, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, [], RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, {}, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, ( x: number ): number => x, RT2I, 0, CS, 0, SN, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a fifteenth argument which is not a Float64Array...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, '5', 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, 5, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, true, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, false, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, null, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, undefined, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, [], 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, {}, 0, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, ( x: number ): number => x, 0, CS, 0, SN, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a sixteenth argument which is not a number...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, '0', CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, true, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, false, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, null, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, undefined, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, [], CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, {}, CS, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, ( x: number ): number => x, CS, 0, SN, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a seventeenth argument which is not a Float64Array...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, '5', 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, 5, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, true, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, false, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, null, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, undefined, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, [], 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, {}, 0, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, ( x: number ): number => x, 0, SN, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided an eighteenth argument which is not a number...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, '0', SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, true, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, false, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, null, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, undefined, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, [], SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, {}, SN, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, ( x: number ): number => x, SN, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a nineteenth argument which is not a Float64Array...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, '5', 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, 5, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, true, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, false, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, null, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, undefined, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, [], 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, {}, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0,( x: number ): number => x, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a twentieth argument which is not a number...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, '0' ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, true ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, false ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, null ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, undefined ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, [] ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, {} ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided an unsupported number of arguments...
+{
+ const A = new Float64Array( 1 );
+ const B = new Float64Array( 1 );
+ const C = new Float64Array( 1 );
+ const D = new Float64Array( 1 );
+ const RT1R = new Float64Array( 1 );
+ const RT1I = new Float64Array( 1 );
+ const RT2R = new Float64Array( 1 );
+ const RT2I = new Float64Array( 1 );
+ const CS = new Float64Array( 1 );
+ const SN = new Float64Array( 1 );
+ dlanv2.ndarray(); // $ExpectError
+ dlanv2.ndarray( A ); // $ExpectError
+ dlanv2.ndarray( A, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0 ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN ); // $ExpectError
+ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0, {} ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/examples/index.js b/lib/node_modules/@stdlib/lapack/base/dlanv2/examples/index.js
new file mode 100644
index 000000000000..69a130efdfb6
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/examples/index.js
@@ -0,0 +1,60 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var Float64Array = require( '@stdlib/array/float64' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var dlanv2 = require( './../lib' );
+
+var opts = {
+ 'dtype': 'float64'
+};
+var A = discreteUniform( 1, -50, 50, opts );
+var B = discreteUniform( 1, -50, 50, opts );
+var C = discreteUniform( 1, -50, 50, opts );
+var D = discreteUniform( 1, -50, 50, opts );
+var RT1R = new Float64Array( 1 );
+var RT1I = new Float64Array( 1 );
+var RT2R = new Float64Array( 1 );
+var RT2I = new Float64Array( 1 );
+var CS = new Float64Array( 1 );
+var SN = new Float64Array( 1 );
+
+console.log( 'input matrix: ' );
+console.log( [ [ A[ 0 ], B[ 0 ] ], [ C[ 0 ], D[ 0 ] ] ] );
+
+dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
+
+console.log( 'the schur factorization of the matrix: ' );
+console.log([
+ [ CS[ 0 ], -SN[ 0 ] ],
+ [ SN[ 0 ], CS[ 0 ] ]
+], '*', [
+ [ A[ 0 ], B[ 0 ] ],
+ [ C[ 0 ], D[ 0 ] ]
+], '*', [
+ [ CS[ 0 ], SN[ 0 ] ],
+ [ -SN[ 0 ], CS[ 0 ] ]
+]);
+
+var eigenvalue1 = new Complex128( RT1R[ 0 ], RT1I[ 0 ] );
+var eigenvalue2 = new Complex128( RT2R[ 0 ], RT2I[ 0 ] );
+
+console.log( 'and the two eigenvectors are: ', eigenvalue1, 'and', eigenvalue2 );
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dlanv2/lib/base.js
new file mode 100644
index 000000000000..24d765f82963
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/lib/base.js
@@ -0,0 +1,264 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* 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.
+*/
+
+/* eslint-disable max-len, max-params, max-statements */
+
+'use strict';
+
+// MODULES //
+
+var dlamch = require( '@stdlib/lapack/base/dlamch' );
+var dlapy2 = require( '@stdlib/lapack/base/dlapy2' );
+var int = require( '@stdlib/math/base/special/floor' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var ln = require( '@stdlib/math/base/special/ln' );
+var sign = require( '@stdlib/math/base/special/copysign' );
+var max = require( '@stdlib/math/base/special/fast/max' );
+var min = require( '@stdlib/math/base/special/fast/min' );
+var abs = require( '@stdlib/math/base/special/fast/abs' );
+var sqrt = require( '@stdlib/math/base/special/sqrt' );
+
+
+// VARIABLES //
+
+var safmin = dlamch( 'safe minimum' );
+var eps = dlamch( 'precision' );
+var safmin2 = pow( dlamch( 'base' ), int( ln( safmin / eps ) / ln( dlamch('base') ) / 2.0 ) );
+var safmax2 = 1.0 / safmin2;
+var multpl = 4.0;
+
+
+// MAIN //
+
+/**
+* Computes the Schur factorization of a real 2-by-2 nonsymmetric matrix `A` in standard form.
+*
+* Given a real 2×2 matrix:
+*
+* ```tex
+* \begin{bmatrix}
+* A & B \\
+* C & D
+* \end{bmatrix}
+* ```
+*
+* this routine computes an orthogonal matrix:
+*
+* ```tex
+* \begin{bmatrix}
+* \text{CS} & \text{SN} \\
+* -\text{SN} & \text{CS}
+* \end{bmatrix}
+* ```
+*
+* such that the matrix is reduced to Schur (quasi-triangular) form:
+*
+* ```tex
+* \begin{bmatrix}
+* \text{AA} & \text{BB} \\
+* \text{CC} & \text{DD}
+* \end{bmatrix}
+* ```
+*
+* where either:
+*
+* - `CC` = 0, `AA` and `DD` are the real eigenvalues of the matrix.
+* - `AA` = `DD` and `BB * CC` < 0, `AA + sqrt( BB * CC )` and `AA - sqrt( BB * CC )` are the complex conjugate eigenvalues.
+*
+* @private
+* @param {Float64Array} A - array containing the element A(1,1)
+* @param {NonNegativeInteger} offsetA - index in `A` of the element A(1,1)
+* @param {Float64Array} B - array containing the element A(1,2)
+* @param {NonNegativeInteger} offsetB - index in `B` of the element A(1,2)
+* @param {Float64Array} C - array containing the element A(2,1)
+* @param {NonNegativeInteger} offsetC - index in `C` of the element A(2,1)
+* @param {Float64Array} D - array containing the element A(2,2)
+* @param {NonNegativeInteger} offsetD - index in `D` of the element A(2,2)
+* @param {Float64Array} RT1R - output array for the real part of the first eigenvalue
+* @param {NonNegativeInteger} offsetRT1R - index in `RT1R` at which to store the value
+* @param {Float64Array} RT1I - output array for the imaginary part of the first eigenvalue
+* @param {NonNegativeInteger} offsetRT1I - index in `RT1I` at which to store the value
+* @param {Float64Array} RT2R - output array for the real part of the second eigenvalue
+* @param {NonNegativeInteger} offsetRT2R - index in `RT2R` at which to store the value
+* @param {Float64Array} RT2I - output array for the imaginary part of the second eigenvalue
+* @param {NonNegativeInteger} offsetRT2I - index in `RT2I` at which to store the value
+* @param {Float64Array} CS - output array for cosine of the rotation
+* @param {NonNegativeInteger} offsetCS - index in `CS` at which to store the value
+* @param {Float64Array} SN - output array for sine of the rotation
+* @param {NonNegativeInteger} offsetSN - index in `SN` at which to store the value
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var A = new Float64Array( [ 4.0 ] );
+* var B = new Float64Array( [ -5.0 ] );
+* var C = new Float64Array( [ 2.0 ] );
+* var D = new Float64Array( [ -3.0 ] );
+* var RT1R = new Float64Array( 1 );
+* var RT1I = new Float64Array( 1 );
+* var RT2R = new Float64Array( 1 );
+* var RT2I = new Float64Array( 1 );
+* var CS = new Float64Array( 1 );
+* var SN = new Float64Array( 1 );
+*
+* dlanv2( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 );
+* // A => [ 2.0 ]
+* // B => [ -7.0 ]
+* // C => [ 0.0 ]
+* // D => [ -1.0 ]
+* // RT1R => [ 2.0 ]
+* // RT1I => [ 0.0 ]
+* // RT2R => [ -1.0 ]
+* // RT2I => [ 0.0 ]
+* // CS => [ ~0.93 ]
+* // SN => [ ~0.34 ]
+*/
+function dlanv2( A, offsetA, B, offsetB, C, offsetC, D, offsetD, RT1R, offsetRT1R, RT1I, offsetRT1I, RT2R, offsetRT2R, RT2I, offsetRT2I, CS, offsetCS, SN, offsetSN ) {
+ var bcmax;
+ var bcmis;
+ var sigma;
+ var scale;
+ var count;
+ var temp;
+ var tau;
+ var sab;
+ var sac;
+ var sn1;
+ var cs1;
+ var aa;
+ var bb;
+ var cc;
+ var dd;
+ var p;
+ var z;
+
+ if ( C[ offsetC ] === 0.0 ) {
+ CS[ offsetCS ] = 1.0;
+ SN[ offsetSN ] = 0.0;
+ } else if ( B[ offsetB ] === 0.0 ) {
+ CS[ offsetCS ] = 0.0;
+ SN[ offsetSN ] = 1.0;
+ temp = D[ offsetD ];
+ D[ offsetD ] = A[ offsetA ];
+ A[ offsetA ] = temp;
+ B[ offsetB ] = -C[ offsetC ];
+ C[ offsetC ] = 0.0;
+ } else if ( A[ offsetA ] === D[ offsetD ] && ( sign( 1.0, B[ offsetB ] ) !== sign( 1.0, C[ offsetC ] ) ) ) {
+ CS[ offsetCS ] = 1.0;
+ SN[ offsetSN ] = 0.0;
+ } else {
+ temp = A[ offsetA ] - D[ offsetD ];
+ p = 0.5 * temp;
+ bcmax = max( abs( B[ offsetB ] ), abs( C[ offsetC ] ) );
+ bcmis = min( abs( B[ offsetB ] ), abs( C[ offsetC ] ) ) * sign( 1.0, B[ offsetB ] ) * sign( 1.0, C[ offsetC ] );
+ scale = max( abs( p ), bcmax );
+ z = ( ( p / scale ) * p ) + ( ( bcmax / scale ) * bcmis );
+
+ if ( z > multpl * eps ) {
+ z = p + sign( sqrt( scale ) * sqrt( z ), p );
+ A[ offsetA ] = D[ offsetD ] + z;
+ D[ offsetD ] -= ( bcmax / z ) * bcmis;
+ tau = dlapy2( C[ offsetC ], z );
+ CS[ offsetCS ] = z / tau;
+ SN[ offsetSN ] = C[ offsetC ] / tau;
+ B[ offsetB ] -= C[ offsetC ];
+ C[ offsetC ] = 0.0;
+ } else {
+ count = 0;
+ sigma = B[ offsetB ] + C[ offsetC ];
+ while ( true ) {
+ scale = max( abs( temp ), abs( sigma ) );
+ if ( count <= 20 ) {
+ if ( scale >= safmax2 ) {
+ sigma *= safmin2;
+ temp *= safmin2;
+ count += 1;
+ continue;
+ }
+ if ( scale <= safmin2 ) {
+ sigma *= safmax2;
+ temp *= safmax2;
+ count += 1;
+ continue;
+ }
+ }
+ break;
+ }
+
+ p = 0.5 * temp;
+ tau = dlapy2( sigma, temp );
+
+ CS[ offsetCS ] = sqrt( 0.5 * ( 1.0 + ( abs( sigma ) / tau ) ) );
+ SN[ offsetSN ] = -( p / ( tau * CS[ offsetCS ] ) ) * sign( 1.0, sigma );
+
+ aa = ( A[ offsetA ] * CS[ offsetCS ] ) + ( B[ offsetB ] * SN[ offsetSN ] );
+ bb = -( A[ offsetA ] * SN[ offsetSN ] ) + ( B[ offsetB ] * CS[ offsetCS ] );
+ cc = ( C[ offsetC ] * CS[ offsetCS ] ) + ( D[ offsetD ] * SN[ offsetSN ] );
+ dd = -( C[ offsetC ] * SN[ offsetSN ] ) + ( D[ offsetD ] * CS[ offsetCS ] );
+
+ A[ offsetA ] = ( aa * CS[ offsetCS ] ) + ( cc * SN[ offsetSN ] );
+ B[ offsetB ] = ( bb * CS[ offsetCS ] ) + ( dd * SN[ offsetSN ] );
+ C[ offsetC ] = -( aa * SN[ offsetSN ] ) + ( cc * CS[ offsetCS ] );
+ D[ offsetD ] = -( bb * SN[ offsetSN ] ) + ( dd * CS[ offsetCS ] );
+
+ temp = 0.5 * ( A[ offsetA ] + D[ offsetD ] );
+ A[ offsetA ] = temp;
+ D[ offsetD ] = temp;
+
+ if ( C[ offsetC ] !== 0.0 ) {
+ if ( B[ offsetB ] === 0.0 ) {
+ B[ offsetB ] -= C[ offsetC ];
+ C[ offsetC ] = 0.0;
+ temp = CS[ offsetCS ];
+ CS[ offsetCS ] = -SN[ offsetSN ];
+ SN[ offsetSN ] = temp;
+ } else if ( sign( 1.0, B[ offsetB ] ) === sign( 1.0, C[ offsetC ] ) ) {
+ sab = sqrt( abs( B[ offsetB ] ) );
+ sac = sqrt( abs( C[ offsetC ] ) );
+ p = sign( sab*sac, C[ offsetC ] );
+ tau = 1.0 / sqrt( abs( B[ offsetB ]+C[ offsetC ] ) );
+ A[ offsetA ] = temp + p;
+ D[ offsetD ] = temp - p;
+ B[ offsetB ] -= C[ offsetC ];
+ C[ offsetC ] = 0.0;
+ cs1 = sab*tau;
+ sn1 = sac*tau;
+ temp = ( CS[ offsetCS ] * cs1 ) - ( SN[ offsetSN ] * sn1 );
+ SN[ offsetSN ] = ( CS[ offsetCS ] * sn1 ) + ( SN[ offsetSN ] * cs1 );
+ CS[ offsetCS ] = temp;
+ }
+ }
+ }
+ }
+ RT1R[ offsetRT1R ] = A[ offsetA ];
+ RT2R[ offsetRT2R ] = D[ offsetD ];
+
+ if ( C[ offsetC ] === 0.0 ) {
+ RT1I[ offsetRT1I ] = 0.0;
+ RT2I[ offsetRT2I ] = 0.0;
+ } else {
+ RT1I[ offsetRT1I ] = sqrt( abs( B[ offsetB ] * C[ offsetC ] ) );
+ RT2I[ offsetRT2I ] = -RT1I[ offsetRT1I ];
+ }
+}
+
+
+// EXPORTS //
+
+module.exports = dlanv2;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/lib/dlanv2.js b/lib/node_modules/@stdlib/lapack/base/dlanv2/lib/dlanv2.js
new file mode 100644
index 000000000000..07ae8059073e
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/lib/dlanv2.js
@@ -0,0 +1,108 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* 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 //
+
+/**
+* Computes the Schur factorization of a real 2-by-2 nonsymmetric matrix `A` in standard form.
+*
+* Given a real 2×2 matrix:
+*
+* ```tex
+* \begin{bmatrix}
+* A & B \\
+* C & D
+* \end{bmatrix}
+* ```
+*
+* this routine computes an orthogonal matrix:
+*
+* ```tex
+* \begin{bmatrix}
+* \text{CS} & \text{SN} \\
+* -\text{SN} & \text{CS}
+* \end{bmatrix}
+* ```
+*
+* such that the matrix is reduced to Schur (quasi-triangular) form:
+*
+* ```tex
+* \begin{bmatrix}
+* \text{AA} & \text{BB} \\
+* \text{CC} & \text{DD}
+* \end{bmatrix}
+* ```
+*
+* where either:
+*
+* - `CC` = 0, `AA` and `DD` are the real eigenvalues of the matrix.
+* - `AA` = `DD` and `BB * CC` < 0, `AA + sqrt( BB * CC )` and `AA - sqrt( BB * CC )` are the complex conjugate eigenvalues.
+*
+* @param {Float64Array} A - array containing the element A(1,1)
+* @param {Float64Array} B - array containing the element A(1,2)
+* @param {Float64Array} C - array containing the element A(2,1)
+* @param {Float64Array} D - array containing the element A(2,2)
+* @param {Float64Array} RT1R - output array for the real part of the first eigenvalue
+* @param {Float64Array} RT1I - output array for the imaginary part of the first eigenvalue
+* @param {Float64Array} RT2R - output array for the real part of the second eigenvalue
+* @param {Float64Array} RT2I - output array for the imaginary part of the second eigenvalue
+* @param {Float64Array} CS - output array for cosine of the rotation
+* @param {Float64Array} SN - output array for sine of the rotation
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var A = new Float64Array( [ 4.0 ] );
+* var B = new Float64Array( [ -5.0 ] );
+* var C = new Float64Array( [ 2.0 ] );
+* var D = new Float64Array( [ -3.0 ] );
+* var RT1R = new Float64Array( 1 );
+* var RT1I = new Float64Array( 1 );
+* var RT2R = new Float64Array( 1 );
+* var RT2I = new Float64Array( 1 );
+* var CS = new Float64Array( 1 );
+* var SN = new Float64Array( 1 );
+*
+* dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
+* // A => [ 2.0 ]
+* // B => [ -7.0 ]
+* // C => [ 0.0 ]
+* // D => [ -1.0 ]
+* // RT1R => [ 2.0 ]
+* // RT1I => [ 0.0 ]
+* // RT2R => [ -1.0 ]
+* // RT2I => [ 0.0 ]
+* // CS => [ ~0.93 ]
+* // SN => [ ~0.34 ]
+*/
+function dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN ) {
+ return base( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 ); // eslint-disable-line max-len
+}
+
+
+// EXPORTS //
+
+module.exports = dlanv2;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dlanv2/lib/index.js
new file mode 100644
index 000000000000..b6c356cbd4a6
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/lib/index.js
@@ -0,0 +1,107 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* 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';
+
+/**
+* LAPACK routine to compute the Schur factorization of a real 2-by-2 nonsymmetric matrix `A` in standard form.
+*
+* Given a real 2×2 matrix:
+*
+* ```tex
+* \begin{bmatrix}
+* A & B \\
+* C & D
+* \end{bmatrix}
+* ```
+*
+* this routine computes an orthogonal matrix:
+*
+* ```tex
+* \begin{bmatrix}
+* \text{CS} & \text{SN} \\
+* -\text{SN} & \text{CS}
+* \end{bmatrix}
+* ```
+*
+* such that the matrix is reduced to Schur (quasi-triangular) form:
+*
+* ```tex
+* \begin{bmatrix}
+* \text{AA} & \text{BB} \\
+* \text{CC} & \text{DD}
+* \end{bmatrix}
+* ```
+*
+* where either:
+*
+* - `CC` = 0, `AA` and `DD` are the real eigenvalues of the matrix.
+* - `AA` = `DD` and `BB * CC` < 0, `AA + sqrt( BB * CC )` and `AA - sqrt( BB * CC )` are the complex conjugate eigenvalues.
+*
+* @module @stdlib/lapack/base/dlanv2
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var dlanv2 = require( '@stdlib/lapack/base/dlanv2' );
+*
+* var A = new Float64Array( [ 4.0 ] );
+* var B = new Float64Array( [ -5.0 ] );
+* var C = new Float64Array( [ 2.0 ] );
+* var D = new Float64Array( [ -3.0 ] );
+* var RT1R = new Float64Array( 1 );
+* var RT1I = new Float64Array( 1 );
+* var RT2R = new Float64Array( 1 );
+* var RT2I = new Float64Array( 1 );
+* var CS = new Float64Array( 1 );
+* var SN = new Float64Array( 1 );
+*
+* dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
+* // A => [ 2.0 ]
+* // B => [ -7.0 ]
+* // C => [ 0.0 ]
+* // D => [ -1.0 ]
+* // RT1R => [ 2.0 ]
+* // RT1I => [ 0.0 ]
+* // RT2R => [ -1.0 ]
+* // RT2I => [ 0.0 ]
+* // CS => [ ~0.93 ]
+* // SN => [ ~0.34 ]
+*/
+
+// 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 dlanv2;
+var tmp = tryRequire( join( __dirname, './native.js' ) );
+if ( isError( tmp ) ) {
+ dlanv2 = main;
+} else {
+ dlanv2 = tmp;
+}
+
+
+// EXPORTS //
+
+module.exports = dlanv2;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/lib/main.js b/lib/node_modules/@stdlib/lapack/base/dlanv2/lib/main.js
new file mode 100644
index 000000000000..9af5823661b6
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/lib/main.js
@@ -0,0 +1,35 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* 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 dlanv2 = require( './dlanv2.js' );
+var ndarray = require( './ndarray.js' );
+
+
+// MAIN //
+
+setReadOnly( dlanv2, 'ndarray', ndarray );
+
+
+// EXPORTS //
+
+module.exports = dlanv2;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlanv2/lib/ndarray.js
new file mode 100644
index 000000000000..dd3b64117228
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/lib/ndarray.js
@@ -0,0 +1,118 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* 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 //
+
+/**
+* Computes the Schur factorization of a real 2-by-2 nonsymmetric matrix `A` in standard form using alternative indexing semantics.
+*
+* Given a real 2×2 matrix:
+*
+* ```tex
+* \begin{bmatrix}
+* A & B \\
+* C & D
+* \end{bmatrix}
+* ```
+*
+* this routine computes an orthogonal matrix:
+*
+* ```tex
+* \begin{bmatrix}
+* \text{CS} & \text{SN} \\
+* -\text{SN} & \text{CS}
+* \end{bmatrix}
+* ```
+*
+* such that the matrix is reduced to Schur (quasi-triangular) form:
+*
+* ```tex
+* \begin{bmatrix}
+* \text{AA} & \text{BB} \\
+* \text{CC} & \text{DD}
+* \end{bmatrix}
+* ```
+*
+* where either:
+*
+* - `CC` = 0, `AA` and `DD` are the real eigenvalues of the matrix.
+* - `AA` = `DD` and `BB * CC` < 0, `AA + sqrt( BB * CC )` and `AA - sqrt( BB * CC )` are the complex conjugate eigenvalues.
+*
+* @param {Float64Array} A - array containing the element A(1,1)
+* @param {NonNegativeInteger} offsetA - index in `A` of the element A(1,1)
+* @param {Float64Array} B - array containing the element A(1,2)
+* @param {NonNegativeInteger} offsetB - index in `B` of the element A(1,2)
+* @param {Float64Array} C - array containing the element A(2,1)
+* @param {NonNegativeInteger} offsetC - index in `C` of the element A(2,1)
+* @param {Float64Array} D - array containing the element A(2,2)
+* @param {NonNegativeInteger} offsetD - index in `D` of the element A(2,2)
+* @param {Float64Array} RT1R - output array for the real part of the first eigenvalue
+* @param {NonNegativeInteger} offsetRT1R - index in `RT1R` at which to store the value
+* @param {Float64Array} RT1I - output array for the imaginary part of the first eigenvalue
+* @param {NonNegativeInteger} offsetRT1I - index in `RT1I` at which to store the value
+* @param {Float64Array} RT2R - output array for the real part of the second eigenvalue
+* @param {NonNegativeInteger} offsetRT2R - index in `RT2R` at which to store the value
+* @param {Float64Array} RT2I - output array for the imaginary part of the second eigenvalue
+* @param {NonNegativeInteger} offsetRT2I - index in `RT2I` at which to store the value
+* @param {Float64Array} CS - output array for cosine of the rotation
+* @param {NonNegativeInteger} offsetCS - index in `CS` at which to store the value
+* @param {Float64Array} SN - output array for sine of the rotation
+* @param {NonNegativeInteger} offsetSN - index in `SN` at which to store the value
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var A = new Float64Array( [ 4.0 ] );
+* var B = new Float64Array( [ -5.0 ] );
+* var C = new Float64Array( [ 2.0 ] );
+* var D = new Float64Array( [ -3.0 ] );
+* var RT1R = new Float64Array( 1 );
+* var RT1I = new Float64Array( 1 );
+* var RT2R = new Float64Array( 1 );
+* var RT2I = new Float64Array( 1 );
+* var CS = new Float64Array( 1 );
+* var SN = new Float64Array( 1 );
+*
+* dlanv2( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS, 0, SN, 0 );
+* // A => [ 2.0 ]
+* // B => [ -7.0 ]
+* // C => [ 0.0 ]
+* // D => [ -1.0 ]
+* // RT1R => [ 2.0 ]
+* // RT1I => [ 0.0 ]
+* // RT2R => [ -1.0 ]
+* // RT2I => [ 0.0 ]
+* // CS => [ ~0.93 ]
+* // SN => [ ~0.34 ]
+*/
+function dlanv2( A, offsetA, B, offsetB, C, offsetC, D, offsetD, RT1R, offsetRT1R, RT1I, offsetRT1I, RT2R, offsetRT2R, RT2I, offsetRT2I, CS, offsetCS, SN, offsetSN ) { // eslint-disable-line max-len, max-params
+ return base( A, offsetA, B, offsetB, C, offsetC, D, offsetD, RT1R, offsetRT1R, RT1I, offsetRT1I, RT2R, offsetRT2R, RT2I, offsetRT2I, CS, offsetCS, SN, offsetSN ); // eslint-disable-line max-len
+}
+
+
+// EXPORTS //
+
+module.exports = dlanv2;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/package.json b/lib/node_modules/@stdlib/lapack/base/dlanv2/package.json
new file mode 100644
index 000000000000..49045b01b5b1
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/package.json
@@ -0,0 +1,69 @@
+{
+ "name": "@stdlib/lapack/base/dlanv2",
+ "version": "0.0.0",
+ "description": "LAPACK routine to compute the Schur factorization of a real 2-by-2 nonsymmetric matrix `A` in standard form.",
+ "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",
+ "dlanv2",
+ "copy",
+ "linear",
+ "algebra",
+ "subroutines",
+ "array",
+ "ndarray",
+ "matrix",
+ "float64",
+ "double",
+ "float64array"
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/a_eq_d_opp_sign.json b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/a_eq_d_opp_sign.json
new file mode 100644
index 000000000000..4fc494650e2c
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/a_eq_d_opp_sign.json
@@ -0,0 +1,33 @@
+{
+ "A": [ 3.0 ],
+ "offsetA": 0,
+ "B": [ 4.0 ],
+ "offsetB": 0,
+ "C": [ -2.0 ],
+ "offsetC": 0,
+ "D": [ 3.0 ],
+ "offsetD": 0,
+ "RT1R": [ 0.0 ],
+ "offsetRT1R": 0,
+ "RT1I": [ 0.0 ],
+ "offsetRT1I": 0,
+ "RT2R": [ 0.0 ],
+ "offsetRT2R": 0,
+ "RT2I": [ 0.0 ],
+ "offsetRT2I": 0,
+ "CS": [ 0.0 ],
+ "offsetCS": 0,
+ "SN": [ 0.0 ],
+ "offsetSN": 0,
+
+ "A_OUT": [ 3.0 ],
+ "B_OUT": [ 4.0 ],
+ "C_OUT": [ -2.0 ],
+ "D_OUT": [ 3.0 ],
+ "RT1R_OUT": [ 3.0 ],
+ "RT1I_OUT": [ 2.8284271247461903 ],
+ "RT2R_OUT": [ 3.0 ],
+ "RT2I_OUT": [ -2.8284271247461903 ],
+ "CS_OUT": [ 1.0 ],
+ "SN_OUT": [ 0.0 ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/b_eq_zero.json b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/b_eq_zero.json
new file mode 100644
index 000000000000..09184f84b093
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/b_eq_zero.json
@@ -0,0 +1,33 @@
+{
+ "A": [ 1.0 ],
+ "offsetA": 0,
+ "B": [ 0.0 ],
+ "offsetB": 0,
+ "C": [ 5.0 ],
+ "offsetC": 0,
+ "D": [ 6.0 ],
+ "offsetD": 0,
+ "RT1R": [ 0.0 ],
+ "offsetRT1R": 0,
+ "RT1I": [ 0.0 ],
+ "offsetRT1I": 0,
+ "RT2R": [ 0.0 ],
+ "offsetRT2R": 0,
+ "RT2I": [ 0.0 ],
+ "offsetRT2I": 0,
+ "CS": [ 0.0 ],
+ "offsetCS": 0,
+ "SN": [ 0.0 ],
+ "offsetSN": 0,
+
+ "A_OUT": [ 6.0 ],
+ "B_OUT": [ -5.0 ],
+ "C_OUT": [ 0.0 ],
+ "D_OUT": [ 1.0 ],
+ "RT1R_OUT": [ 6.0 ],
+ "RT1I_OUT": [ 0.0 ],
+ "RT2R_OUT": [ 1.0 ],
+ "RT2I_OUT": [ 0.0 ],
+ "CS_OUT": [ 0.0 ],
+ "SN_OUT": [ 1.0 ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/c_eq_zero.json b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/c_eq_zero.json
new file mode 100644
index 000000000000..f9f057f7f45d
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/c_eq_zero.json
@@ -0,0 +1,33 @@
+{
+ "A": [ 7.0 ],
+ "offsetA": 0,
+ "B": [ 3.0 ],
+ "offsetB": 0,
+ "C": [ 0.0 ],
+ "offsetC": 0,
+ "D": [ 2.0 ],
+ "offsetD": 0,
+ "RT1R": [ 0.0 ],
+ "offsetRT1R": 0,
+ "RT1I": [ 0.0 ],
+ "offsetRT1I": 0,
+ "RT2R": [ 0.0 ],
+ "offsetRT2R": 0,
+ "RT2I": [ 0.0 ],
+ "offsetRT2I": 0,
+ "CS": [ 0.0 ],
+ "offsetCS": 0,
+ "SN": [ 0.0 ],
+ "offsetSN": 0,
+
+ "A_OUT": [ 7.0 ],
+ "B_OUT": [ 3.0 ],
+ "C_OUT": [ 0.0 ],
+ "D_OUT": [ 2.0 ],
+ "RT1R_OUT": [ 7.0 ],
+ "RT1I_OUT": [ 0.0 ],
+ "RT2R_OUT": [ 2.0 ],
+ "RT2I_OUT": [ 0.0 ],
+ "CS_OUT": [ 1.0 ],
+ "SN_OUT": [ 0.0 ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/a_eq_d_opp_sign.json b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/a_eq_d_opp_sign.json
new file mode 100644
index 000000000000..8325847a2d74
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/a_eq_d_opp_sign.json
@@ -0,0 +1,92 @@
+{
+ "A": [
+ 9999,
+ 3
+ ],
+ "offsetA": 1,
+ "B": [
+ 9999,
+ 4
+ ],
+ "offsetB": 1,
+ "C": [
+ 9999,
+ -2
+ ],
+ "offsetC": 1,
+ "D": [
+ 9999,
+ 3
+ ],
+ "offsetD": 1,
+ "RT1R": [
+ 9999,
+ 0
+ ],
+ "offsetRT1R": 1,
+ "RT1I": [
+ 9999,
+ 0
+ ],
+ "offsetRT1I": 1,
+ "RT2R": [
+ 9999,
+ 0
+ ],
+ "offsetRT2R": 1,
+ "RT2I": [
+ 9999,
+ 0
+ ],
+ "offsetRT2I": 1,
+ "CS": [
+ 9999,
+ 0
+ ],
+ "offsetCS": 1,
+ "SN": [
+ 9999,
+ 0
+ ],
+ "offsetSN": 1,
+ "A_OUT": [
+ 9999,
+ 3
+ ],
+ "B_OUT": [
+ 9999,
+ 4
+ ],
+ "C_OUT": [
+ 9999,
+ -2
+ ],
+ "D_OUT": [
+ 9999,
+ 3
+ ],
+ "RT1R_OUT": [
+ 9999,
+ 3
+ ],
+ "RT1I_OUT": [
+ 9999,
+ 2.8284271247461903
+ ],
+ "RT2R_OUT": [
+ 9999,
+ 3
+ ],
+ "RT2I_OUT": [
+ 9999,
+ -2.8284271247461903
+ ],
+ "CS_OUT": [
+ 9999,
+ 1
+ ],
+ "SN_OUT": [
+ 9999,
+ 0
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/b_eq_zero.json b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/b_eq_zero.json
new file mode 100644
index 000000000000..f291ef66ed17
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/b_eq_zero.json
@@ -0,0 +1,92 @@
+{
+ "A": [
+ 9999,
+ 1
+ ],
+ "offsetA": 1,
+ "B": [
+ 9999,
+ 0
+ ],
+ "offsetB": 1,
+ "C": [
+ 9999,
+ 5
+ ],
+ "offsetC": 1,
+ "D": [
+ 9999,
+ 6
+ ],
+ "offsetD": 1,
+ "RT1R": [
+ 9999,
+ 0
+ ],
+ "offsetRT1R": 1,
+ "RT1I": [
+ 9999,
+ 0
+ ],
+ "offsetRT1I": 1,
+ "RT2R": [
+ 9999,
+ 0
+ ],
+ "offsetRT2R": 1,
+ "RT2I": [
+ 9999,
+ 0
+ ],
+ "offsetRT2I": 1,
+ "CS": [
+ 9999,
+ 0
+ ],
+ "offsetCS": 1,
+ "SN": [
+ 9999,
+ 0
+ ],
+ "offsetSN": 1,
+ "A_OUT": [
+ 9999,
+ 6
+ ],
+ "B_OUT": [
+ 9999,
+ -5
+ ],
+ "C_OUT": [
+ 9999,
+ 0
+ ],
+ "D_OUT": [
+ 9999,
+ 1
+ ],
+ "RT1R_OUT": [
+ 9999,
+ 6
+ ],
+ "RT1I_OUT": [
+ 9999,
+ 0
+ ],
+ "RT2R_OUT": [
+ 9999,
+ 1
+ ],
+ "RT2I_OUT": [
+ 9999,
+ 0
+ ],
+ "CS_OUT": [
+ 9999,
+ 0
+ ],
+ "SN_OUT": [
+ 9999,
+ 1
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/c_eq_zero.json b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/c_eq_zero.json
new file mode 100644
index 000000000000..1930229af1d1
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/c_eq_zero.json
@@ -0,0 +1,92 @@
+{
+ "A": [
+ 9999,
+ 7
+ ],
+ "offsetA": 1,
+ "B": [
+ 9999,
+ 3
+ ],
+ "offsetB": 1,
+ "C": [
+ 9999,
+ 0
+ ],
+ "offsetC": 1,
+ "D": [
+ 9999,
+ 2
+ ],
+ "offsetD": 1,
+ "RT1R": [
+ 9999,
+ 0
+ ],
+ "offsetRT1R": 1,
+ "RT1I": [
+ 9999,
+ 0
+ ],
+ "offsetRT1I": 1,
+ "RT2R": [
+ 9999,
+ 0
+ ],
+ "offsetRT2R": 1,
+ "RT2I": [
+ 9999,
+ 0
+ ],
+ "offsetRT2I": 1,
+ "CS": [
+ 9999,
+ 0
+ ],
+ "offsetCS": 1,
+ "SN": [
+ 9999,
+ 0
+ ],
+ "offsetSN": 1,
+ "A_OUT": [
+ 9999,
+ 7
+ ],
+ "B_OUT": [
+ 9999,
+ 3
+ ],
+ "C_OUT": [
+ 9999,
+ 0
+ ],
+ "D_OUT": [
+ 9999,
+ 2
+ ],
+ "RT1R_OUT": [
+ 9999,
+ 7
+ ],
+ "RT1I_OUT": [
+ 9999,
+ 0
+ ],
+ "RT2R_OUT": [
+ 9999,
+ 2
+ ],
+ "RT2I_OUT": [
+ 9999,
+ 0
+ ],
+ "CS_OUT": [
+ 9999,
+ 1
+ ],
+ "SN_OUT": [
+ 9999,
+ 0
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/scale_gt_safmax.json b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/scale_gt_safmax.json
new file mode 100644
index 000000000000..34ae19f2c1d5
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/scale_gt_safmax.json
@@ -0,0 +1,92 @@
+{
+ "A": [
+ 9999,
+ 1
+ ],
+ "offsetA": 1,
+ "B": [
+ 9999,
+ 1e+200
+ ],
+ "offsetB": 1,
+ "C": [
+ 9999,
+ 1e-200
+ ],
+ "offsetC": 1,
+ "D": [
+ 9999,
+ 1
+ ],
+ "offsetD": 1,
+ "RT1R": [
+ 9999,
+ 0
+ ],
+ "offsetRT1R": 1,
+ "RT1I": [
+ 9999,
+ 0
+ ],
+ "offsetRT1I": 1,
+ "RT2R": [
+ 9999,
+ 0
+ ],
+ "offsetRT2R": 1,
+ "RT2I": [
+ 9999,
+ 0
+ ],
+ "offsetRT2I": 1,
+ "CS": [
+ 9999,
+ 0
+ ],
+ "offsetCS": 1,
+ "SN": [
+ 9999,
+ 0
+ ],
+ "offsetSN": 1,
+ "A_OUT": [
+ 9999,
+ 2
+ ],
+ "B_OUT": [
+ 9999,
+ 1e+200
+ ],
+ "C_OUT": [
+ 9999,
+ 0
+ ],
+ "D_OUT": [
+ 9999,
+ 0
+ ],
+ "RT1R_OUT": [
+ 9999,
+ 2
+ ],
+ "RT1I_OUT": [
+ 9999,
+ 0
+ ],
+ "RT2R_OUT": [
+ 9999,
+ 0
+ ],
+ "RT2I_OUT": [
+ 9999,
+ 0
+ ],
+ "CS_OUT": [
+ 9999,
+ 1
+ ],
+ "SN_OUT": [
+ 9999,
+ 1e-200
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/scale_lt_safmin.json b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/scale_lt_safmin.json
new file mode 100644
index 000000000000..76932cef482a
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/scale_lt_safmin.json
@@ -0,0 +1,92 @@
+{
+ "A": [
+ 9999,
+ 1
+ ],
+ "offsetA": 1,
+ "B": [
+ 9999,
+ 1e-200
+ ],
+ "offsetB": 1,
+ "C": [
+ 9999,
+ 1e-200
+ ],
+ "offsetC": 1,
+ "D": [
+ 9999,
+ 1
+ ],
+ "offsetD": 1,
+ "RT1R": [
+ 9999,
+ 0
+ ],
+ "offsetRT1R": 1,
+ "RT1I": [
+ 9999,
+ 0
+ ],
+ "offsetRT1I": 1,
+ "RT2R": [
+ 9999,
+ 0
+ ],
+ "offsetRT2R": 1,
+ "RT2I": [
+ 9999,
+ 0
+ ],
+ "offsetRT2I": 1,
+ "CS": [
+ 9999,
+ 0
+ ],
+ "offsetCS": 1,
+ "SN": [
+ 9999,
+ 0
+ ],
+ "offsetSN": 1,
+ "A_OUT": [
+ 9999,
+ 1
+ ],
+ "B_OUT": [
+ 9999,
+ 0
+ ],
+ "C_OUT": [
+ 9999,
+ 0
+ ],
+ "D_OUT": [
+ 9999,
+ 1
+ ],
+ "RT1R_OUT": [
+ 9999,
+ 1
+ ],
+ "RT1I_OUT": [
+ 9999,
+ 0
+ ],
+ "RT2R_OUT": [
+ 9999,
+ 1
+ ],
+ "RT2I_OUT": [
+ 9999,
+ 0
+ ],
+ "CS_OUT": [
+ 9999,
+ 0.7071067811865476
+ ],
+ "SN_OUT": [
+ 9999,
+ 0.7071067811865476
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/z_gt_multpleps.json b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/z_gt_multpleps.json
new file mode 100644
index 000000000000..a958b96e5abf
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/z_gt_multpleps.json
@@ -0,0 +1,92 @@
+{
+ "A": [
+ 9999,
+ 4
+ ],
+ "offsetA": 1,
+ "B": [
+ 9999,
+ 2
+ ],
+ "offsetB": 1,
+ "C": [
+ 9999,
+ 3
+ ],
+ "offsetC": 1,
+ "D": [
+ 9999,
+ 1
+ ],
+ "offsetD": 1,
+ "RT1R": [
+ 9999,
+ 0
+ ],
+ "offsetRT1R": 1,
+ "RT1I": [
+ 9999,
+ 0
+ ],
+ "offsetRT1I": 1,
+ "RT2R": [
+ 9999,
+ 0
+ ],
+ "offsetRT2R": 1,
+ "RT2I": [
+ 9999,
+ 0
+ ],
+ "offsetRT2I": 1,
+ "CS": [
+ 9999,
+ 0
+ ],
+ "offsetCS": 1,
+ "SN": [
+ 9999,
+ 0
+ ],
+ "offsetSN": 1,
+ "A_OUT": [
+ 9999,
+ 5.372281323269014
+ ],
+ "B_OUT": [
+ 9999,
+ -1
+ ],
+ "C_OUT": [
+ 9999,
+ 0
+ ],
+ "D_OUT": [
+ 9999,
+ -0.3722813232690143
+ ],
+ "RT1R_OUT": [
+ 9999,
+ 5.372281323269014
+ ],
+ "RT1I_OUT": [
+ 9999,
+ 0
+ ],
+ "RT2R_OUT": [
+ 9999,
+ -0.3722813232690143
+ ],
+ "RT2I_OUT": [
+ 9999,
+ 0
+ ],
+ "CS_OUT": [
+ 9999,
+ 0.8245648401323938
+ ],
+ "SN_OUT": [
+ 9999,
+ 0.5657674649689923
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/z_lt_multpleps.json b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/z_lt_multpleps.json
new file mode 100644
index 000000000000..a5f09b054c99
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/z_lt_multpleps.json
@@ -0,0 +1,92 @@
+{
+ "A": [
+ 9999,
+ 10
+ ],
+ "offsetA": 1,
+ "B": [
+ 9999,
+ 1e-19
+ ],
+ "offsetB": 1,
+ "C": [
+ 9999,
+ 1e-19
+ ],
+ "offsetC": 1,
+ "D": [
+ 9999,
+ 10
+ ],
+ "offsetD": 1,
+ "RT1R": [
+ 9999,
+ 0
+ ],
+ "offsetRT1R": 1,
+ "RT1I": [
+ 9999,
+ 0
+ ],
+ "offsetRT1I": 1,
+ "RT2R": [
+ 9999,
+ 0
+ ],
+ "offsetRT2R": 1,
+ "RT2I": [
+ 9999,
+ 0
+ ],
+ "offsetRT2I": 1,
+ "CS": [
+ 9999,
+ 0
+ ],
+ "offsetCS": 1,
+ "SN": [
+ 9999,
+ 0
+ ],
+ "offsetSN": 1,
+ "A_OUT": [
+ 9999,
+ 10
+ ],
+ "B_OUT": [
+ 9999,
+ 0
+ ],
+ "C_OUT": [
+ 9999,
+ 0
+ ],
+ "D_OUT": [
+ 9999,
+ 10
+ ],
+ "RT1R_OUT": [
+ 9999,
+ 10
+ ],
+ "RT1I_OUT": [
+ 9999,
+ 0
+ ],
+ "RT2R_OUT": [
+ 9999,
+ 10
+ ],
+ "RT2I_OUT": [
+ 9999,
+ 0
+ ],
+ "CS_OUT": [
+ 9999,
+ 0.7071067811865476
+ ],
+ "SN_OUT": [
+ 9999,
+ 0.7071067811865476
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/z_lt_mutpleps_b_eq_zero.json b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/z_lt_mutpleps_b_eq_zero.json
new file mode 100644
index 000000000000..d7408cc1df8e
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/offsets/z_lt_mutpleps_b_eq_zero.json
@@ -0,0 +1,92 @@
+{
+ "A": [
+ 9999,
+ 2
+ ],
+ "offsetA": 1,
+ "B": [
+ 9999,
+ -1
+ ],
+ "offsetB": 1,
+ "C": [
+ 9999,
+ 1
+ ],
+ "offsetC": 1,
+ "D": [
+ 9999,
+ 0
+ ],
+ "offsetD": 1,
+ "RT1R": [
+ 9999,
+ 0
+ ],
+ "offsetRT1R": 1,
+ "RT1I": [
+ 9999,
+ 0
+ ],
+ "offsetRT1I": 1,
+ "RT2R": [
+ 9999,
+ 0
+ ],
+ "offsetRT2R": 1,
+ "RT2I": [
+ 9999,
+ 0
+ ],
+ "offsetRT2I": 1,
+ "CS": [
+ 9999,
+ 0
+ ],
+ "offsetCS": 1,
+ "SN": [
+ 9999,
+ 0
+ ],
+ "offsetSN": 1,
+ "A_OUT": [
+ 9999,
+ 1
+ ],
+ "B_OUT": [
+ 9999,
+ -2
+ ],
+ "C_OUT": [
+ 9999,
+ 0
+ ],
+ "D_OUT": [
+ 9999,
+ 1
+ ],
+ "RT1R_OUT": [
+ 9999,
+ 1
+ ],
+ "RT1I_OUT": [
+ 9999,
+ 0
+ ],
+ "RT2R_OUT": [
+ 9999,
+ 1
+ ],
+ "RT2I_OUT": [
+ 9999,
+ 0
+ ],
+ "CS_OUT": [
+ 9999,
+ 0.7071067811865475
+ ],
+ "SN_OUT": [
+ 9999,
+ 0.7071067811865476
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/scale_gt_safmax.json b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/scale_gt_safmax.json
new file mode 100644
index 000000000000..1a2ac7e27bb6
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/scale_gt_safmax.json
@@ -0,0 +1,33 @@
+{
+ "A": [ 1.0 ],
+ "offsetA": 0,
+ "B": [ 9.9999999999999997e+199 ],
+ "offsetB": 0,
+ "C": [ 9.9999999999999998e-201 ],
+ "offsetC": 0,
+ "D": [ 1.0 ],
+ "offsetD": 0,
+ "RT1R": [ 0.0 ],
+ "offsetRT1R": 0,
+ "RT1I": [ 0.0 ],
+ "offsetRT1I": 0,
+ "RT2R": [ 0.0 ],
+ "offsetRT2R": 0,
+ "RT2I": [ 0.0 ],
+ "offsetRT2I": 0,
+ "CS": [ 0.0 ],
+ "offsetCS": 0,
+ "SN": [ 0.0 ],
+ "offsetSN": 0,
+
+ "A_OUT": [ 2.0 ],
+ "B_OUT": [ 9.9999999999999997e+199 ],
+ "C_OUT": [ 0.0 ],
+ "D_OUT": [ 0.0 ],
+ "RT1R_OUT": [ 2.0 ],
+ "RT1I_OUT": [ 0.0 ],
+ "RT2R_OUT": [ 0.0 ],
+ "RT2I_OUT": [ 0.0 ],
+ "CS_OUT": [ 1.0 ],
+ "SN_OUT": [ 9.9999999999999998e-201 ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/scale_lt_safmin.json b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/scale_lt_safmin.json
new file mode 100644
index 000000000000..468642061223
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/scale_lt_safmin.json
@@ -0,0 +1,33 @@
+{
+ "A": [ 1.0 ],
+ "offsetA": 0,
+ "B": [ 9.9999999999999998e-201 ],
+ "offsetB": 0,
+ "C": [ 9.9999999999999998e-201 ],
+ "offsetC": 0,
+ "D": [ 1.0 ],
+ "offsetD": 0,
+ "RT1R": [ 0.0 ],
+ "offsetRT1R": 0,
+ "RT1I": [ 0.0 ],
+ "offsetRT1I": 0,
+ "RT2R": [ 0.0 ],
+ "offsetRT2R": 0,
+ "RT2I": [ 0.0 ],
+ "offsetRT2I": 0,
+ "CS": [ 0.0 ],
+ "offsetCS": 0,
+ "SN": [ 0.0 ],
+ "offsetSN": 0,
+
+ "A_OUT": [ 1.0 ],
+ "B_OUT": [ 0.0 ],
+ "C_OUT": [ 0.0 ],
+ "D_OUT": [ 1.0 ],
+ "RT1R_OUT": [ 1.0 ],
+ "RT1I_OUT": [ 0.0 ],
+ "RT2R_OUT": [ 1.0 ],
+ "RT2I_OUT": [ 0.0 ],
+ "CS_OUT": [ 0.70710678118654757 ],
+ "SN_OUT": [ 0.70710678118654757 ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/z_gt_multpleps.json b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/z_gt_multpleps.json
new file mode 100644
index 000000000000..ac3537b04f81
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/z_gt_multpleps.json
@@ -0,0 +1,33 @@
+{
+ "A": [ 4.0 ],
+ "offsetA": 0,
+ "B": [ 2.0 ],
+ "offsetB": 0,
+ "C": [ 3.0 ],
+ "offsetC": 0,
+ "D": [ 1.0 ],
+ "offsetD": 0,
+ "RT1R": [ 0.0 ],
+ "offsetRT1R": 0,
+ "RT1I": [ 0.0 ],
+ "offsetRT1I": 0,
+ "RT2R": [ 0.0 ],
+ "offsetRT2R": 0,
+ "RT2I": [ 0.0 ],
+ "offsetRT2I": 0,
+ "CS": [ 0.0 ],
+ "offsetCS": 0,
+ "SN": [ 0.0 ],
+ "offsetSN": 0,
+
+ "A_OUT": [ 5.37228132326901434 ],
+ "B_OUT": [ -1.0 ],
+ "C_OUT": [ 0.0 ],
+ "D_OUT": [ -0.37228132326901431 ],
+ "RT1R_OUT": [ 5.37228132326901434 ],
+ "RT1I_OUT": [ 0.0 ],
+ "RT2R_OUT": [ -0.37228132326901431 ],
+ "RT2I_OUT": [ 0.0 ],
+ "CS_OUT": [ 0.82456484013239384 ],
+ "SN_OUT": [ 0.56576746496899233 ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/z_lt_multpleps.json b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/z_lt_multpleps.json
new file mode 100644
index 000000000000..ed01862f5509
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/z_lt_multpleps.json
@@ -0,0 +1,33 @@
+{
+ "A": [ 10.0 ],
+ "offsetA": 0,
+ "B": [ 9.9999999999999995e-20 ],
+ "offsetB": 0,
+ "C": [ 9.9999999999999995e-20 ],
+ "offsetC": 0,
+ "D": [ 10.0 ],
+ "offsetD": 0,
+ "RT1R": [ 0.0 ],
+ "offsetRT1R": 0,
+ "RT1I": [ 0.0 ],
+ "offsetRT1I": 0,
+ "RT2R": [ 0.0 ],
+ "offsetRT2R": 0,
+ "RT2I": [ 0.0 ],
+ "offsetRT2I": 0,
+ "CS": [ 0.0 ],
+ "offsetCS": 0,
+ "SN": [ 0.0 ],
+ "offsetSN": 0,
+
+ "A_OUT": [ 10.0 ],
+ "B_OUT": [ 0.0 ],
+ "C_OUT": [ 0.0 ],
+ "D_OUT": [ 10.0 ],
+ "RT1R_OUT": [ 10.0 ],
+ "RT1I_OUT": [ 0.0 ],
+ "RT2R_OUT": [ 10.0 ],
+ "RT2I_OUT": [ 0.0 ],
+ "CS_OUT": [ 0.70710678118654757 ],
+ "SN_OUT": [ 0.70710678118654757 ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/z_lt_mutpleps_b_eq_zero.json b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/z_lt_mutpleps_b_eq_zero.json
new file mode 100644
index 000000000000..3eb21ab0fea3
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/fixtures/z_lt_mutpleps_b_eq_zero.json
@@ -0,0 +1,33 @@
+{
+ "A": [ 2.0 ],
+ "offsetA": 0,
+ "B": [ -1.0 ],
+ "offsetB": 0,
+ "C": [ 1.0 ],
+ "offsetC": 0,
+ "D": [ 0.0 ],
+ "offsetD": 0,
+ "RT1R": [ 0.0 ],
+ "offsetRT1R": 0,
+ "RT1I": [ 0.0 ],
+ "offsetRT1I": 0,
+ "RT2R": [ 0.0 ],
+ "offsetRT2R": 0,
+ "RT2I": [ 0.0 ],
+ "offsetRT2I": 0,
+ "CS": [ 0.0 ],
+ "offsetCS": 0,
+ "SN": [ 0.0 ],
+ "offsetSN": 0,
+
+ "A_OUT": [ 1.0 ],
+ "B_OUT": [ -2.0 ],
+ "C_OUT": [ 0.0 ],
+ "D_OUT": [ 1.0 ],
+ "RT1R_OUT": [ 1.0 ],
+ "RT1I_OUT": [ 0.0 ],
+ "RT2R_OUT": [ 1.0 ],
+ "RT2I_OUT": [ 0.0 ],
+ "CS_OUT": [ 0.70710678118654746 ],
+ "SN_OUT": [ 0.70710678118654757 ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/test/test.dlanv2.js b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/test.dlanv2.js
new file mode 100644
index 000000000000..349aed705e96
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/test.dlanv2.js
@@ -0,0 +1,555 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* 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 dlanv2 = require( './../lib/dlanv2.js' );
+
+
+// FIXTURES //
+
+var C_EQ_ZERO = require( './fixtures/c_eq_zero.json' );
+var B_EQ_ZERO = require( './fixtures/b_eq_zero.json' );
+var A_EQ_D_OPP_SIGN = require( './fixtures/a_eq_d_opp_sign.json' );
+var Z_GT_MULTPLEPS = require( './fixtures/z_gt_multpleps.json' );
+var Z_LT_MULTPLEPS = require( './fixtures/z_lt_multpleps.json' );
+var SCALE_GT_SAFMAX = require( './fixtures/scale_gt_safmax.json' );
+var SCALE_LT_SAFMIN = require( './fixtures/scale_lt_safmin.json' );
+var Z_LT_MULTPLEPS_B_EQ_ZERO = require( './fixtures/z_lt_mutpleps_b_eq_zero.json' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof dlanv2, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function has an arity of 10', function test( t ) {
+ t.strictEqual( dlanv2.length, 10, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function returns expected output for C = 0', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = C_EQ_ZERO;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output for B = 0', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = B_EQ_ZERO;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output for A = D and B and C have opposite signs', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = A_EQ_D_OPP_SIGN;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output for Z > MULTPL * EPS', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = Z_GT_MULTPLEPS;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output for Z < MULTPL * EPS', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = Z_LT_MULTPLEPS;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output for very large values', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = SCALE_GT_SAFMAX;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output for very small values', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = SCALE_LT_SAFMIN;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output when B = 0 post rotation', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = Z_LT_MULTPLEPS_B_EQ_ZERO;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/test/test.js b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/test.js
new file mode 100644
index 000000000000..b0abf3c88f1a
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/test.js
@@ -0,0 +1,82 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* 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 dlanv2 = 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 dlanv2, '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 dlanv2.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 dlanv2 = proxyquire( './../lib', {
+ '@stdlib/utils/try-require': tryRequire
+ });
+
+ t.strictEqual( dlanv2, 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 dlanv2;
+ var main;
+
+ main = require( './../lib/dlanv2.js' );
+
+ dlanv2 = proxyquire( './../lib', {
+ '@stdlib/utils/try-require': tryRequire
+ });
+
+ t.strictEqual( dlanv2, main, 'returns expected value' );
+ t.end();
+
+ function tryRequire() {
+ return new Error( 'Cannot find module' );
+ }
+});
diff --git a/lib/node_modules/@stdlib/lapack/base/dlanv2/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/test.ndarray.js
new file mode 100644
index 000000000000..47ac0fb88e54
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlanv2/test/test.ndarray.js
@@ -0,0 +1,1070 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* 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.
+*/
+
+/* eslint-disable max-len, id-length */
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var Float64Array = require( '@stdlib/array/float64' );
+var dlanv2 = require( './../lib/ndarray.js' );
+
+
+// FIXTURES //
+
+var C_EQ_ZERO = require( './fixtures/c_eq_zero.json' );
+var B_EQ_ZERO = require( './fixtures/b_eq_zero.json' );
+var A_EQ_D_OPP_SIGN = require( './fixtures/a_eq_d_opp_sign.json' );
+var Z_GT_MULTPLEPS = require( './fixtures/z_gt_multpleps.json' );
+var Z_LT_MULTPLEPS = require( './fixtures/z_lt_multpleps.json' );
+var SCALE_GT_SAFMAX = require( './fixtures/scale_gt_safmax.json' );
+var SCALE_LT_SAFMIN = require( './fixtures/scale_lt_safmin.json' );
+var Z_LT_MULTPLEPS_B_EQ_ZERO = require( './fixtures/z_lt_mutpleps_b_eq_zero.json' );
+
+var OFFSET_C_EQ_ZERO = require( './fixtures/offsets/c_eq_zero.json' );
+var OFFSET_B_EQ_ZERO = require( './fixtures/offsets/b_eq_zero.json' );
+var OFFSET_A_EQ_D_OPP_SIGN = require( './fixtures/offsets/a_eq_d_opp_sign.json' );
+var OFFSET_Z_GT_MULTPLEPS = require( './fixtures/offsets/z_gt_multpleps.json' );
+var OFFSET_Z_LT_MULTPLEPS = require( './fixtures/offsets/z_lt_multpleps.json' );
+var OFFSET_SCALE_GT_SAFMAX = require( './fixtures/offsets/scale_gt_safmax.json' );
+var OFFSET_SCALE_LT_SAFMIN = require( './fixtures/offsets/scale_lt_safmin.json' );
+var OFFSET_Z_LT_MULTPLEPS_B_EQ_ZERO = require( './fixtures/offsets/z_lt_mutpleps_b_eq_zero.json' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof dlanv2, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function has an arity of 20', function test( t ) {
+ t.strictEqual( dlanv2.length, 20, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function returns expected output for C = 0', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = C_EQ_ZERO;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, data.offsetA, B, data.offsetB, C, data.offsetC, D, data.offsetD, RT1R, data.offsetRT1R, RT1I, data.offsetRT1I, RT2R, data.offsetRT2R, RT2I, data.offsetRT2I, CS, data.offsetCS, SN, data.offsetSN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output for B = 0', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = B_EQ_ZERO;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, data.offsetA, B, data.offsetB, C, data.offsetC, D, data.offsetD, RT1R, data.offsetRT1R, RT1I, data.offsetRT1I, RT2R, data.offsetRT2R, RT2I, data.offsetRT2I, CS, data.offsetCS, SN, data.offsetSN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output for A = D and B and C have opposite signs', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = A_EQ_D_OPP_SIGN;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, data.offsetA, B, data.offsetB, C, data.offsetC, D, data.offsetD, RT1R, data.offsetRT1R, RT1I, data.offsetRT1I, RT2R, data.offsetRT2R, RT2I, data.offsetRT2I, CS, data.offsetCS, SN, data.offsetSN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output for Z > MULTPL * EPS', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = Z_GT_MULTPLEPS;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, data.offsetA, B, data.offsetB, C, data.offsetC, D, data.offsetD, RT1R, data.offsetRT1R, RT1I, data.offsetRT1I, RT2R, data.offsetRT2R, RT2I, data.offsetRT2I, CS, data.offsetCS, SN, data.offsetSN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output for Z < MULTPL * EPS', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = Z_LT_MULTPLEPS;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, data.offsetA, B, data.offsetB, C, data.offsetC, D, data.offsetD, RT1R, data.offsetRT1R, RT1I, data.offsetRT1I, RT2R, data.offsetRT2R, RT2I, data.offsetRT2I, CS, data.offsetCS, SN, data.offsetSN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output for very large values', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = SCALE_GT_SAFMAX;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, data.offsetA, B, data.offsetB, C, data.offsetC, D, data.offsetD, RT1R, data.offsetRT1R, RT1I, data.offsetRT1I, RT2R, data.offsetRT2R, RT2I, data.offsetRT2I, CS, data.offsetCS, SN, data.offsetSN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output for very small values', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = SCALE_LT_SAFMIN;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, data.offsetA, B, data.offsetB, C, data.offsetC, D, data.offsetD, RT1R, data.offsetRT1R, RT1I, data.offsetRT1I, RT2R, data.offsetRT2R, RT2I, data.offsetRT2I, CS, data.offsetCS, SN, data.offsetSN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output when B = 0 post rotation', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = Z_LT_MULTPLEPS_B_EQ_ZERO;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, data.offsetA, B, data.offsetB, C, data.offsetC, D, data.offsetD, RT1R, data.offsetRT1R, RT1I, data.offsetRT1I, RT2R, data.offsetRT2R, RT2I, data.offsetRT2I, CS, data.offsetCS, SN, data.offsetSN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output for C = 0 (offsets)', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = OFFSET_C_EQ_ZERO;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, data.offsetA, B, data.offsetB, C, data.offsetC, D, data.offsetD, RT1R, data.offsetRT1R, RT1I, data.offsetRT1I, RT2R, data.offsetRT2R, RT2I, data.offsetRT2I, CS, data.offsetCS, SN, data.offsetSN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output for B = 0 (offsets)', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = OFFSET_B_EQ_ZERO;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, data.offsetA, B, data.offsetB, C, data.offsetC, D, data.offsetD, RT1R, data.offsetRT1R, RT1I, data.offsetRT1I, RT2R, data.offsetRT2R, RT2I, data.offsetRT2I, CS, data.offsetCS, SN, data.offsetSN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output for A = D and B and C have opposite signs (offsets)', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = OFFSET_A_EQ_D_OPP_SIGN;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, data.offsetA, B, data.offsetB, C, data.offsetC, D, data.offsetD, RT1R, data.offsetRT1R, RT1I, data.offsetRT1I, RT2R, data.offsetRT2R, RT2I, data.offsetRT2I, CS, data.offsetCS, SN, data.offsetSN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output for Z > MULTPL * EPS (offsets)', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = OFFSET_Z_GT_MULTPLEPS;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, data.offsetA, B, data.offsetB, C, data.offsetC, D, data.offsetD, RT1R, data.offsetRT1R, RT1I, data.offsetRT1I, RT2R, data.offsetRT2R, RT2I, data.offsetRT2I, CS, data.offsetCS, SN, data.offsetSN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output for Z < MULTPL * EPS (offsets)', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = OFFSET_Z_LT_MULTPLEPS;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, data.offsetA, B, data.offsetB, C, data.offsetC, D, data.offsetD, RT1R, data.offsetRT1R, RT1I, data.offsetRT1I, RT2R, data.offsetRT2R, RT2I, data.offsetRT2I, CS, data.offsetCS, SN, data.offsetSN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output for very large values (offsets)', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = OFFSET_SCALE_GT_SAFMAX;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, data.offsetA, B, data.offsetB, C, data.offsetC, D, data.offsetD, RT1R, data.offsetRT1R, RT1I, data.offsetRT1I, RT2R, data.offsetRT2R, RT2I, data.offsetRT2I, CS, data.offsetCS, SN, data.offsetSN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output for very small values (offsets)', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = OFFSET_SCALE_LT_SAFMIN;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, data.offsetA, B, data.offsetB, C, data.offsetC, D, data.offsetD, RT1R, data.offsetRT1R, RT1I, data.offsetRT1I, RT2R, data.offsetRT2R, RT2I, data.offsetRT2I, CS, data.offsetCS, SN, data.offsetSN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns expected output when B = 0 post rotation (offsets)', function test( t ) {
+ var RT1R_OUT;
+ var RT1I_OUT;
+ var RT2R_OUT;
+ var RT2I_OUT;
+ var CS_OUT;
+ var SN_OUT;
+ var A_OUT;
+ var B_OUT;
+ var C_OUT;
+ var D_OUT;
+ var data;
+ var RT1R;
+ var RT1I;
+ var RT2R;
+ var RT2I;
+ var CS;
+ var SN;
+ var A;
+ var B;
+ var C;
+ var D;
+
+ data = OFFSET_Z_LT_MULTPLEPS_B_EQ_ZERO;
+
+ A = new Float64Array( data.A );
+ B = new Float64Array( data.B );
+ C = new Float64Array( data.C );
+ D = new Float64Array( data.D );
+ RT1R = new Float64Array( data.RT1R );
+ RT1I = new Float64Array( data.RT1I );
+ RT2R = new Float64Array( data.RT2R );
+ RT2I = new Float64Array( data.RT2I );
+ CS = new Float64Array( data.CS );
+ SN = new Float64Array( data.SN );
+
+ dlanv2( A, data.offsetA, B, data.offsetB, C, data.offsetC, D, data.offsetD, RT1R, data.offsetRT1R, RT1I, data.offsetRT1I, RT2R, data.offsetRT2R, RT2I, data.offsetRT2I, CS, data.offsetCS, SN, data.offsetSN );
+
+ A_OUT = new Float64Array( data.A_OUT );
+ B_OUT = new Float64Array( data.B_OUT );
+ C_OUT = new Float64Array( data.C_OUT );
+ D_OUT = new Float64Array( data.D_OUT );
+ RT1R_OUT = new Float64Array( data.RT1R_OUT );
+ RT1I_OUT = new Float64Array( data.RT1I_OUT );
+ RT2R_OUT = new Float64Array( data.RT2R_OUT );
+ RT2I_OUT = new Float64Array( data.RT2I_OUT );
+ CS_OUT = new Float64Array( data.CS_OUT );
+ SN_OUT = new Float64Array( data.SN_OUT );
+
+ t.deepEqual( A, A_OUT, 'returns expected value' );
+ t.deepEqual( B, B_OUT, 'returns expected value' );
+ t.deepEqual( C, C_OUT, 'returns expected value' );
+ t.deepEqual( D, D_OUT, 'returns expected value' );
+ t.deepEqual( RT1R, RT1R_OUT, 'returns expected value' );
+ t.deepEqual( RT1I, RT1I_OUT, 'returns expected value' );
+ t.deepEqual( RT2R, RT2R_OUT, 'returns expected value' );
+ t.deepEqual( RT2I, RT2I_OUT, 'returns expected value' );
+ t.deepEqual( CS, CS_OUT, 'returns expected value' );
+ t.deepEqual( SN, SN_OUT, 'returns expected value' );
+
+ t.end();
+});