diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/README.md b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/README.md
new file mode 100644
index 000000000000..4a58b6ab84ca
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/README.md
@@ -0,0 +1,338 @@
+
+
+# dlagbrpvgrw
+
+> LAPACK routine to computes the reciprocal pivot growth factor norm(A)/norm(U) for a general banded matrix `A`.
+
+
+
+The `dlagbrpvgrw` routine computes the reciprocal pivot growth factor for a general banded matrix `A`. The factorization has the form:
+
+
+
+```math
+\text{RPGFactor} = \frac{\text||A||}{\text||U||}
+```
+
+
+
+
+
+
+
+
+
+
+
+## Usage
+
+
+
+```javascript
+var dlagbrpvgrw = require( '@stdlib/lapack/base/dla-gbrpvgrw' );
+```
+
+#### dlagbrpvgrw( order, N, KL, KU, NCOLS, AB, LDAB, AFB, LDAFB )
+
+Computes the reciprocal pivot growth factor norm(A)/norm(U) for a general banded matrix `A`.
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var dlagbrpvgrw = require( '@stdlib/lapack/base/dla-gbrpvgrw' );
+
+/*
+ A = [
+ [ 1.0, 2.0, 0.0, 0.0 ],
+ [ 3.0, 4.0, 5.0, 0.0 ],
+ [ 0.0, 6.0, 7.0, 8.0 ],
+ [ 0.0, 0.0, 9.0,10.0 ]
+]
+*/
+
+var AB = new Float64Array( [ 0.0, 2.0, 5.0, 8.0, 1.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 0.0 ] );
+var AFB = new Float64Array( [ 0.0, 0.0, 5.0, 8.0, 0.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 1.8272, 0.3333, 0.1111, -0.2716, 0.0 ] );
+
+var out = dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, AFB, 4 );
+// returns 1.0
+```
+
+The function has the following parameters:
+
+- **order**: storage layout.
+- **N**: number of columns in matrix `A`.
+- **KL**: number of subdiagonals within the band of matrix `A`.
+- **KU**: number of superdiagonals within the band of matrix `A`.
+- **NCOLS**: number of columns in matrix `A`.
+- **AB**: the matrix `A` in band storage, stored in linear memory as a [`Float64Array`][mdn-float64array].
+- **LDAB**: stride of the first dimension of `AB` (a.k.a., leading dimension of the matrix `AB`).
+- **AFB**: the details of the LU factorization of the band matrix `A` stored in linear memory as a [`Float64Array`][mdn-float64array].
+- **LDAFB**: stride of the first dimension of `AFB` (a.k.a., leading dimension of the matrix `AFB`).
+
+The function returns the reciprocal pivot growth factor.
+
+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' );
+var dlagbrpvgrw = require( '@stdlib/lapack/base/dla-gbrpvgrw' );
+
+// Initial arrays...
+var AB0 = new Float64Array( [ 0.0, 0.0, 2.0, 5.0, 8.0, 1.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 0.0 ] );
+var AFB0 = new Float64Array( [ 0.0, 0.0, 0.0, 5.0, 8.0, 0.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 1.8272, 0.3333, 0.1111, -0.2716, 0.0 ] );
+
+/*
+ A = [
+ [ 1.0, 2.0, 0.0, 0.0 ],
+ [ 3.0, 4.0, 5.0, 0.0 ],
+ [ 0.0, 6.0, 7.0, 8.0 ],
+ [ 0.0, 0.0, 9.0,10.0 ]
+]
+*/
+
+// Create offset views...
+var AB = new Float64Array( AB0.buffer, AB0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+var AFB = new Float64Array( AFB0.buffer, AFB0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+
+var out = dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, AFB, 4 );
+// returns 1.0
+```
+
+
+
+#### dlagbrpvgrw.ndarray( N, KL, KU, NCOLS, AB, strideAB1, strideAB2, offsetAB, AFB, strideAFB1, strideAFB2, offsetAFB )
+
+Computes the reciprocal pivot growth factor norm(A)/norm(U) for a general banded matrix `A` using alternative indexing semantics.
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var dlagbrpvgrw = require( '@stdlib/lapack/base/dla-gbrpvgrw' );
+
+/*
+ A = [
+ [ 1.0, 2.0, 0.0, 0.0 ],
+ [ 3.0, 4.0, 5.0, 0.0 ],
+ [ 0.0, 6.0, 7.0, 8.0 ],
+ [ 0.0, 0.0, 9.0,10.0 ]
+]
+*/
+
+var AB = new Float64Array( [ 0.0, 2.0, 5.0, 8.0, 1.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 0.0 ] );
+var AFB = new Float64Array( [ 0.0, 0.0, 5.0, 8.0, 0.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 1.8272, 0.3333, 0.1111, -0.2716, 0.0 ] );
+
+var out = dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 );
+// returns 1.0
+```
+
+The function has the following parameters:
+
+- **N**: number of columns in matrix `A`.
+- **KL**: number of subdiagonals within the band of matrix `A`.
+- **KU**: number of superdiagonals within the band of matrix `A`.
+- **NCOLS**: number of columns in matrix `A`.
+- **AB**: the matrix `A` in band storage, stored in linear memory as a [`Float64Array`][mdn-float64array].
+- **strideAB1**: stride of the first dimension of `AB`.
+- **strideAB2**: stride of the second dimension of `AB`.
+- **offsetAB**: index offset for `AB`.
+- **AFB**: the details of the LU factorization of the band matrix `A` stored in linear memory as a [`Float64Array`][mdn-float64array].
+- **strideAB1**: stride of the first dimension of `AFB`.
+- **strideAB2**: stride of the second dimension of `AFB`.
+- **offsetAB**: index offset for `AFB`.
+
+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 dlagbrpvgrw = require( '@stdlib/lapack/base/dla-gbrpvgrw' );
+
+/*
+ A = [
+ [ 1.0, 2.0, 0.0, 0.0 ],
+ [ 3.0, 4.0, 5.0, 0.0 ],
+ [ 0.0, 6.0, 7.0, 8.0 ],
+ [ 0.0, 0.0, 9.0,10.0 ]
+]
+*/
+
+var AB = new Float64Array( [ 0.0, 0.0, 2.0, 5.0, 8.0, 1.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 0.0 ] );
+var AFB = new Float64Array( [ 0.0, 0.0, 0.0, 5.0, 8.0, 0.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 1.8272, 0.3333, 0.1111, -0.2716, 0.0 ] );
+
+var out = dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 1, AFB, 4, 1, 1 );
+// returns 1.0
+```
+
+
+
+
+
+
+
+## Notes
+
+- The norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix `A` could be poor. This also means that the solution `X`, estimated condition numbers, and error bounds could be unreliable.
+
+- Matrix `AB` is the matrix A in band storage, in rows 0 to `KL+KU`. The j-th column of A is stored in the j-th column of the matrix `AB` as `AB( KU+i-j, j ) = A( i, j )` for `max( 0, j - KU ) <= i <= min( N - 1, j + KL )`.
+
+- Matrix `AFB` stores the details of the LU factorization of the band matrix `A`, as computed by `DGBTRF`. `U` is stored as an upper triangular band matrix with KL+KU superdiagonals in rows 0 to `KL+KU+1`, and the multipliers used during the factorization are stored in rows `KL+KU+1` to `2*KL+KU`.
+
+- The leading dimension of `AB`, `LDAB` >= `KL+KU+1`.
+
+- The leading dimension of `AFB`, `LDAFB` >= `2*KL+KU+1`.
+
+- `dlagbrpvgrw()` corresponds to the [LAPACK][LAPACK] function [`dlagbrpvgrw`][lapack-dlagbrpvgrw].
+
+
+
+
+
+
+
+## Examples
+
+
+
+
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var dlagbrpvgrw = require( '@stdlib/lapack/base/dla-gbrpvgrw' );
+
+var N = 4;
+var KL = 1;
+var KU = 1;
+var NCOLS = 4;
+var LDAB = 3;
+var LDAFB = 4;
+
+var AB = new Float64Array( [ 0.0, 2.0, 5.0, 8.0, 1.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 0.0 ] );
+var AFB = new Float64Array( [ 0.0, 0.0, 5.0, 8.0, 0.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 1.8272, 0.3333, 0.1111, -0.2716, 0.0 ] );
+
+console.log( 'The matrix `AB` i.e, the matrix `A` in band storage, in rows 1 to KL+KU+1:' );
+console.log( ndarray2array( AB, [ LDAB, N ], [ N, 1 ], 0, 'row-major' ) );
+
+console.log( 'The matrix `AFB` containing the details of the LU factorization of the band matrix `A`, as computed by `DGBTRF`:' );
+console.log( ndarray2array( AFB, [ LDAFB, N ], [ N, 1 ], 0, 'row-major' ) );
+
+console.log( 'The reciprocal pivot growth factor norm(A)/norm(U) for `AB`:' );
+console.log( dlagbrpvgrw( 'row-major', N, KL, KU, NCOLS, AB, LDAB, AFB, LDAFB ) );
+```
+
+
+
+
+
+
+
+* * *
+
+
+
+## C APIs
+
+
+
+
+
+
+
+
+
+
+
+### Usage
+
+```c
+TODO
+```
+
+#### TODO
+
+TODO.
+
+```c
+TODO
+```
+
+TODO
+
+```c
+TODO
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Examples
+
+```c
+TODO
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[lapack]: https://www.netlib.org/lapack/explore-html/
+
+[lapack-dlagbrpvgrw]: https://netlib.org/lapack/explore-html//d1/ddf/group__la__gbrpvgrw_ga8475794e57172d20803e770faa7d4543.html
+
+[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/dla-gbrpvgrw/benchmark/benchmark.js b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/benchmark/benchmark.js
new file mode 100644
index 000000000000..61733c053dfd
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/benchmark/benchmark.js
@@ -0,0 +1,123 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/* eslint-disable camelcase */
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var dla_gbrpvgrw = require( './../lib/dlagbrpvgrw.js' );
+
+
+// VARIABLES //
+
+var LAYOUTS = [
+ 'row-major',
+ 'column-major'
+];
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {string} order - storage layout
+* @param {PositiveInteger} N - matrix order (N-by-N)
+* @returns {Function} benchmark function
+*/
+function createBenchmark( order, N ) {
+ var opts;
+ var AFB;
+ var AB;
+
+ opts = {
+ 'dtype': 'float64'
+ };
+
+ AFB = uniform( 4*N*N, -1.0, 1.0, opts );
+ AB = uniform( 4*N*N, -1.0, 1.0, opts );
+
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var i;
+ var z;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ z = dla_gbrpvgrw( order, N, N, N, N, AB, 4*N, AFB, 4*N );
+ if ( isnan( z ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ }
+ b.toc();
+ if ( isnan( z ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var min;
+ var max;
+ var ord;
+ var N;
+ var f;
+ var i;
+ var k;
+
+ min = 1; // 10^min
+ max = 6; // 10^max
+
+ for ( k = 0; k < LAYOUTS.length; k++ ) {
+ ord = LAYOUTS[ k ];
+ for ( i = min; i <= max; i++ ) {
+ N = floor( pow( pow( 10, i ), 1.0/2.0 ) );
+ f = createBenchmark( ord, N );
+ bench( format( '%s:order=%s,size=%d', pkg, ord, N*N ), f );
+ }
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/benchmark/benchmark.ndarray.js
new file mode 100644
index 000000000000..c32e2aee2e8f
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/benchmark/benchmark.ndarray.js
@@ -0,0 +1,133 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/* eslint-disable camelcase */
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var isColumnMajor = require( '@stdlib/ndarray/base/assert/is-column-major-string' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var dla_gbrpvgrw = require( './../lib/ndarray.js' );
+
+
+// VARIABLES //
+
+var LAYOUTS = [
+ 'row-major',
+ 'column-major'
+];
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {string} order - storage layout
+* @param {PositiveInteger} N - matrix order (N-by-N)
+* @returns {Function} benchmark function
+*/
+function createBenchmark( order, N ) {
+ var sa1;
+ var sa2;
+ var AFB;
+ var AB;
+
+ if ( isColumnMajor( order ) ) {
+ sa1 = 1;
+ sa2 = 4*N;
+ } else {
+ sa1 = N;
+ sa2 = 1;
+ }
+
+ AFB = uniform( 4*N*N, -1.0, 1.0, {
+ 'dtype': 'float64'
+ });
+ AB = uniform( 4*N*N, -1.0, 1.0, {
+ 'dtype': 'float64'
+ });
+
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var i;
+ var z;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ z = dla_gbrpvgrw( N, N, N, N, AB, sa1, sa2, 0, AFB, sa1, sa2, 0 );
+ if ( isnan( z ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ }
+ b.toc();
+ if ( isnan( z ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var min;
+ var max;
+ var ord;
+ var N;
+ var f;
+ var i;
+ var k;
+
+ min = 1; // 10^min
+ max = 6; // 10^max
+
+ for ( k = 0; k < LAYOUTS.length; k++ ) {
+ ord = LAYOUTS[ k ];
+ for ( i = min; i <= max; i++ ) {
+ N = floor( pow( pow( 10, i ), 1.0/2.0 ) );
+ f = createBenchmark( ord, N );
+ bench( format( '%s:ndarray:order=%s,size=%d', pkg, ord, N*N ), f );
+ }
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/docs/repl.txt
new file mode 100644
index 000000000000..89ffd1bb6a49
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/docs/repl.txt
@@ -0,0 +1,121 @@
+
+{{alias}}( order, N, KL, KU, NCOLS, AB, LDAB, AFB, LDAFB )
+ Computes the reciprocal pivot growth factor norm(A)/norm(U) for a
+ general banded matrix `A`.
+
+ Indexing is relative to the first index. To introduce an offset, use typed
+ array views.
+
+ Parameters
+ ----------
+ order: string
+ Row-major (C-style) or column-major (Fortran-style) order. Must be
+ either 'row-major' or 'column-major'.
+
+ N: integer
+ Number of rows in matrix `A`.
+
+ KL: integer
+ Number of subdiagonals within the band of matrix `A`.
+
+ KU: integer
+ Number of superdiagonals within the band of matrix `A`.
+
+ NCOLS: integer
+ Number of columns in matrix `A`.
+
+ AB: Float64Array
+ The matrix `A` in band storage.
+
+ LDAB: integer
+ Stride of the first dimension of `AB` (a.k.a., leading dimension
+ of the matrix `AB`) `LDAB` >= KL+KU+1.
+
+ AFB: Float64Array
+ The details of the LU factorization of the band matrix `A`.
+
+ LDAFB: integer
+ Stride of the first dimension of `AFB` (a.k.a., leading dimension
+ of the matrix `AFB`) `LDAFB` >= 2*KL+KU+1.
+
+ Returns
+ -------
+ rpgFactor: number
+ The reciprocal pivot growth factor for `A`.
+
+ Examples
+ --------
+ > var AB = new {{alias:@stdlib/array/float64}}([ 0,10,1,3,2,0 ]);
+ > var AFB = new {{alias:@stdlib/array/float64}}([ 0,0,0,10,1,-17,2,0 ]);
+ > {{alias}}( 'row-major', 2, 1, 1, 2, AB, 3, AFB, 4 )
+ 1.0
+
+ // Using typed array views:
+ > var AB0 = new {{alias:@stdlib/array/float64}}([ 0,0,10,1,3,2,0 ]);
+ > var AFB0 = new {{alias:@stdlib/array/float64}}([ 0,0,0,0,10,1,-17,2,0 ]);
+ > AB = new Float64Array( AB0.buffer, AB0.BYTES_PER_ELEMENT*1 );
+ > AFB = new Float64Array( AFB0.buffer, AFB0.BYTES_PER_ELEMENT*1 );
+ > {{alias}}( 'row-major', 2, 1, 1, 2, AB, 3, AFB, 4 )
+ 1.0
+
+
+{{alias}}.ndarray( N,KL,KU,NCOLS,AB,sab1,sab2,oab,AFB,safb1,safb2,oafb )
+ Computes the reciprocal pivot growth factor norm(A)/norm(U) for a
+ general banded matrix `A`.
+
+ While typed array views mandate a view offset based on the underlying
+ buffer, the offset parameters support indexing semantics based on starting
+ indices.
+
+ Parameters
+ ----------
+ N: integer
+ Number of rows in matrix `A`.
+
+ KL: integer
+ Number of subdiagonals within the band of matrix `A`.
+
+ KU: integer
+ Number of superdiagonals within the band of matrix `A`.
+
+ NCOLS: integer
+ Number of columns in matrix `A`.
+
+ AB: Float64Array
+ The matrix `A` in band storage.
+
+ sab1: integer
+ Stride of the first dimension of `AB`.
+
+ sab2: integer
+ Stride of the second dimension of `AB`.
+
+ oab: integer
+ Index offset for `AB`.
+
+ AFB: Float64Array
+ The details of the LU factorization of the band matrix `A`.
+
+ safb1: integer
+ Stride of the first dimension of `AFB`.
+
+ safb2: integer
+ Stride of the second dimension of `AFB`.
+
+ oafb: integer
+ Index offset for `AFB`.
+
+ Returns
+ -------
+ rpgFactor: number
+ The reciprocal pivot growth factor for `A`.
+
+ Examples
+ --------
+ > var AB = new {{alias:@stdlib/array/float64}}([ 0,10,1,3,2,0 ]);
+ > var AFB = new {{alias:@stdlib/array/float64}}([ 0,0,0,10,1,-17,2,0 ]);
+ > {{alias}}.ndarray( 2, 1, 1, 2, AB, 2, 1, 0, AFB, 2, 1, 0 )
+ 1.0
+
+ See Also
+ --------
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/docs/types/index.d.ts
new file mode 100644
index 000000000000..467b63d84036
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/docs/types/index.d.ts
@@ -0,0 +1,144 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+// TypeScript Version: 4.1
+
+///
+
+import { Layout } from '@stdlib/types/blas';
+
+/**
+* Interface describing `dla-gbrpvgrw`.
+*/
+interface Routine {
+ /**
+ * Computes the reciprocal pivot growth factor norm(A)/norm(U) for a general banded matrix `A`.
+ *
+ * ## Notes
+ *
+ * - The norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix `A` could be poor. This also means that the solution `X`, estimated condition numbers, and error bounds could be unreliable.
+ * - Matrix `AB` is the matrix A in band storage, in rows 0 to `KL+KU`. The j-th column of A is stored in the j-th column of the matrix `AB` as `AB( KU+i-j, j ) = A( i, j )` for `max( 0, j - KU ) <= i <= min( N - 1, j + KL )`.
+ * - Matrix `AFB` stores the details of the LU factorization of the band matrix `A`, as computed by `DGBTRF`. `U` is stored as an upper triangular band matrix with KL+KU superdiagonals in rows 0 to `KL+KU+1`, and the multipliers used during the factorization are stored in rows `KL+KU+1` to `2*KL+KU`.
+ * - The leading dimension of `AB`, `LDAB` >= `KL+KU+1`.
+ * - The leading dimension of `AFB`, `LDAFB` >= `2*KL+KU+1`.
+ *
+ * @param order - order of matrix `A`
+ * @param N - number of rows in matrix `A`
+ * @param KL - number of subdiagonals within the band of matrix `A`
+ * @param KU - number of superdiagonals within the band of matrix `A`
+ * @param NCOLS - number of columns in matrix `A`
+ * @param AB - the matrix A in band storage
+ * @param LDAB - the leading dimension of the matrix `AB`
+ * @param AFB - details of the LU factorization of the band matrix `A`
+ * @param LDAFB - the leading dimension of the matrix `AFB`
+ * @returns the reciprocal pivot growth factor
+ *
+ * @example
+ * var Float64Array = require( '@stdlib/array/float64' );
+ *
+ * var AB = new Float64Array( [ 0.0, 2.0, 5.0, 8.0, 1.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 0.0 ] );
+ * var AFB = new Float64Array( [ 0.0, 0.0, 5.0, 8.0, 0.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 1.8272, 0.3333, 0.1111, -0.2716, 0.0 ] );
+ *
+ * var out = dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, AFB, 4 );
+ * // returns 1.0
+ */
+ ( order: Layout, N: number, KL: number, KU: number, NCOLS: number, AB: Float64Array, LDAB: number, AFB: Float64Array, LDAFB: number ): number;
+
+ /**
+ * Computes the reciprocal pivot growth factor norm(A)/norm(U) for a general banded matrix `A` using alternating indexing semantics.
+ *
+ * ## Notes
+ *
+ * - The norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix `A` could be poor. This also means that the solution `X`, estimated condition numbers, and error bounds could be unreliable.
+ * - Matrix `AB` is the matrix A in band storage, in rows 0 to `KL+KU`. The j-th column of A is stored in the j-th column of the matrix `AB` as `AB( KU+i-j, j ) = A( i, j )` for `max( 0, j - KU ) <= i <= min( N - 1, j + KL )`.
+ * - Matrix `AFB` stores the details of the LU factorization of the band matrix `A`, as computed by `DGBTRF`. `U` is stored as an upper triangular band matrix with KL+KU superdiagonals in rows 0 to `KL+KU+1`, and the multipliers used during the factorization are stored in rows `KL+KU+1` to `2*KL+KU`.
+ * - The leading dimension of `AB`, `LDAB` >= `KL+KU+1`.
+ * - The leading dimension of `AFB`, `LDAFB` >= `2*KL+KU+1`.
+ *
+ * @param N - number of rows in matrix `A`
+ * @param KL - number of subdiagonals within the band of matrix `A`
+ * @param KU - number of superdiagonals within the band of matrix `A`
+ * @param NCOLS - number of columns in matrix `A`
+ * @param AB - the matrix A in band storage
+ * @param strideAB1 - stride of the first dimension of `AB`
+ * @param strideAB2 - stride of the second dimension of `AB`
+ * @param offsetAB - index offset for `AB`
+ * @param AFB - details of the LU factorization of the band matrix `A`
+ * @param strideAFB1 - stride of the first dimension of `AFB`
+ * @param strideAFB2 - stride of the second dimension of `AFB`
+ * @param offsetAFB - index offset for `AFB`
+ * @returns the reciprocal pivot growth factor
+ *
+ * @example
+ * var Float64Array = require( '@stdlib/array/float64' );
+ *
+ * var AB = new Float64Array( [ 0.0, 2.0, 5.0, 8.0, 1.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 0.0 ] );
+ * var AFB = new Float64Array( [ 0.0, 0.0, 5.0, 8.0, 0.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 1.8272, 0.3333, 0.1111, -0.2716, 0.0 ] );
+ *
+ * var out = dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 );
+ * // returns 1.0
+ */
+ ndarray( N: number, KL: number, KU: number, NCOLS: number, AB: Float64Array, strideAB1: number, strideAB2: number, offsetAB: number, AFB: Float64Array, strideAFB1: number, strideAFB2: number, offsetAFB: number ): number; // eslint-disable-line max-len
+}
+
+/**
+* Computes the reciprocal pivot growth factor norm(A)/norm(U) for a general banded matrix `A`.
+*
+* ## Notes
+*
+* - The norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix `A` could be poor. This also means that the solution `X`, estimated condition numbers, and error bounds could be unreliable.
+* - Matrix `AB` is the matrix A in band storage, in rows 0 to `KL+KU`. The j-th column of A is stored in the j-th column of the matrix `AB` as `AB( KU+i-j, j ) = A( i, j )` for `max( 0, j - KU ) <= i <= min( N - 1, j + KL )`.
+* - Matrix `AFB` stores the details of the LU factorization of the band matrix `A`, as computed by `DGBTRF`. `U` is stored as an upper triangular band matrix with KL+KU superdiagonals in rows 0 to `KL+KU+1`, and the multipliers used during the factorization are stored in rows `KL+KU+1` to `2*KL+KU`.
+* - The leading dimension of `AB`, `LDAB` >= `KL+KU+1`.
+* - The leading dimension of `AFB`, `LDAFB` >= `2*KL+KU+1`.
+*
+* @param order - order of matrix `A`
+* @param N - number of rows in matrix `A`
+* @param KL - number of subdiagonals within the band of matrix `A`
+* @param KU - number of superdiagonals within the band of matrix `A`
+* @param NCOLS - number of columns in matrix `A`
+* @param AB - the matrix A in band storage
+* @param LDAB - the leading dimension of the matrix `AB`
+* @param AFB - details of the LU factorization of the band matrix `A`
+* @param LDAFB - the leading dimension of the matrix `AFB`
+* @returns the reciprocal pivot growth factor
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var AB = new Float64Array( [ 0.0, 2.0, 5.0, 8.0, 1.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 0.0 ] );
+* var AFB = new Float64Array( [ 0.0, 0.0, 5.0, 8.0, 0.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 1.8272, 0.3333, 0.1111, -0.2716, 0.0 ] );
+*
+* var out = dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, AFB, 4 );
+* // returns 1.0
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var AB = new Float64Array( [ 0.0, 2.0, 5.0, 8.0, 1.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 0.0 ] );
+* var AFB = new Float64Array( [ 0.0, 0.0, 5.0, 8.0, 0.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 1.8272, 0.3333, 0.1111, -0.2716, 0.0 ] );
+*
+* var out = dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 );
+* // returns 1.0
+*/
+declare var dlagbrpvgrw: Routine;
+
+
+// EXPORTS //
+
+export = dlagbrpvgrw;
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/docs/types/test.ts b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/docs/types/test.ts
new file mode 100644
index 000000000000..04a595774c25
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/docs/types/test.ts
@@ -0,0 +1,373 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+import dlagbrpvgrw = require( './index' );
+
+
+// TESTS //
+
+// The function returns a number...
+{
+ const AB = new Float64Array( 12 );
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, AFB, 4 ); // $ExpectType number
+}
+
+// The compiler throws an error if the function is provided a first argument which is not a string...
+{
+ const AB = new Float64Array( 12 );
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw( 5, 4, 1, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( true, 4, 1, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( false, 4, 1, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( null, 4, 1, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( void 0, 4, 1, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( [], 4, 1, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( {}, 4, 1, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( ( x: number ): number => x, 4, 1, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not a number...
+{
+ const AB = new Float64Array( 12 );
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw( 'row-major', '4', 1, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', true, 1, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', false, 1, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', null, 1, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', void 0, 1, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', [], 1, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', {}, 1, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', ( x: number ): number => x, 1, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a third argument which is not a number...
+{
+ const AB = new Float64Array( 12 );
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw( 'row-major', 4, '4', 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, true, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, false, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, null, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, void 0, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, [], 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, {}, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, ( x: number ): number => x, 1, 4, AB, 3, AFB, 4 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fourth argument which is not a number...
+{
+ const AB = new Float64Array( 12 );
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw( 'row-major', 4, 1, '4', 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, true, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, false, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, null, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, void 0, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, [], 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, {}, 4, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, ( x: number ): number => x, 4, AB, 3, AFB, 4 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fifth argument which is not a number...
+{
+ const AB = new Float64Array( 12 );
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw( 'row-major', 4, 1, 1, '4', AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, true, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, false, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, null, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, void 0, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, [], AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, {}, AB, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, ( x: number ): number => x, AB, 3, AFB, 4 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a sixth argument which is not a Float64Array...
+{
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, '4', 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, 4, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, true, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, false, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, null, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, void 0, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, [], 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, {}, 3, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, ( x: number ): number => x, 3, AFB, 4 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a seventh argument which is not a number...
+{
+ const AB = new Float64Array( 12 );
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, '4', AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, true, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, false, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, null, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, void 0, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, [], AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, {}, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, ( x: number ): number => x, AFB, 4 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a eighth argument which is not a Float64Array...
+{
+ const AB = new Float64Array( 12 );
+
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, '4', 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, 4, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, true, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, false, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, null, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, void 0, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, [], 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, {}, 4 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, ( x: number ): number => x, 4 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a ninth argument which is not a number...
+{
+ const AB = new Float64Array( 12 );
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, AFB, '4' ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, AFB, true ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, AFB, false ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, AFB, null ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, AFB, void 0 ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, AFB, [] ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, AFB, {} ); // $ExpectError
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, AFB, ( x: number ): number => x ); // $ExpectError
+}
+
+// Attached to main export is an `ndarray` method which returns a number...
+{
+ const AB = new Float64Array( 12 );
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectType number
+}
+
+// The compiler throws an error if the function is provided a first argument which is not a number...
+{
+ const AB = new Float64Array( 12 );
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw.ndarray( '3', 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( true, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( false, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( null, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( void 0, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( [], 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( {}, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( ( x: number ): number => x, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not a number...
+{
+ const AB = new Float64Array( 12 );
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw.ndarray( 4, '3', 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, true, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, false, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, null, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, void 0, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, [], 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, {}, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, ( x: number ): number => x, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a third argument which is not a number...
+{
+ const AB = new Float64Array( 12 );
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw.ndarray( 4, 1, '3', 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, true, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, false, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, null, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, void 0, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, [], 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, {}, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, ( x: number ): number => x, 4, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fourth argument which is not a number...
+{
+ const AB = new Float64Array( 12 );
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw.ndarray( 4, 1, 1, '3', AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, true, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, false, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, null, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, void 0, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, [], AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, {}, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, ( x: number ): number => x, AB, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fifth argument which is not a Float64Array...
+{
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, 3, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, '3', 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, true, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, false, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, null, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, void 0, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, [], 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, {}, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, ( x: number ): number => x, 4, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a sixth argument which is not a number...
+{
+ const AB = new Float64Array( 12 );
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, '3', 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, true, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, false, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, null, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, void 0, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, [], 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, {}, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, ( x: number ): number => x, 1, 0, AFB, 4, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a seventh argument which is not a number...
+{
+ const AB = new Float64Array( 12 );
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, '3', 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, true, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, false, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, null, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, void 0, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, [], 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, {}, 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, ( x: number ): number => x, 0, AFB, 4, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a eight argument which is not a number...
+{
+ const AB = new Float64Array( 12 );
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, '3', AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, true, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, false, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, null, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, void 0, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, [], AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, {}, AFB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, ( x: number ): number => x, AFB, 4, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a ninth argument which is not a Float64Array...
+{
+ const AB = new Float64Array( 12 );
+
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, 3, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, '3', 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, true, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, false, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, null, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, void 0, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, [], 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, {}, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, ( x: number ): number => x, 4, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a tenth argument which is not a number...
+{
+ const AB = new Float64Array( 12 );
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, '3', 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, true, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, false, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, null, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, void 0, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, [], 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, {}, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, ( x: number ): number => x, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a eleventh argument which is not a number...
+{
+ const AB = new Float64Array( 12 );
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, '3', 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, true, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, false, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, null, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, void 0, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, [], 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, {}, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, ( x: number ): number => x, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a twelveth argument which is not a number...
+{
+ const AB = new Float64Array( 12 );
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, '3' ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, true ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, false ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, null ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, void 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, [] ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, {} ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided an unsupported number of arguments...
+{
+ const AB = new Float64Array( 12 );
+ const AFB = new Float64Array( 16 );
+
+ dlagbrpvgrw.ndarray(); // $ExpectError
+ dlagbrpvgrw.ndarray( 4 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1 ); // $ExpectError
+ dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0, 10 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/examples/index.js b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/examples/index.js
new file mode 100644
index 000000000000..63c5f62fa4d0
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/examples/index.js
@@ -0,0 +1,72 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+var Float64Array = require( '@stdlib/array/float64' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var dlagbrpvgrw = require( './../lib' );
+
+var N = 4;
+var KL = 1;
+var KU = 1;
+var NCOLS = 4;
+var LDAB = 3;
+var LDAFB = 4;
+
+var AB = new Float64Array([
+ 0.0,
+ 2.0,
+ 5.0,
+ 8.0,
+ 1.0,
+ 4.0,
+ 7.0,
+ 10.0,
+ 3.0,
+ 6.0,
+ 9.0,
+ 0.0
+]);
+var AFB = new Float64Array([
+ 0.0,
+ 0.0,
+ 5.0,
+ 8.0,
+ 0.0,
+ 4.0,
+ 7.0,
+ 10.0,
+ 3.0,
+ 6.0,
+ 9.0,
+ 1.8272,
+ 0.3333,
+ 0.1111,
+ -0.2716,
+ 0.0
+]);
+
+console.log( 'The matrix `AB` i.e, the matrix `A` in band storage, in rows 1 to KL+KU+1:' );
+console.log( ndarray2array( AB, [ LDAB, N ], [ N, 1 ], 0, 'row-major' ) );
+
+console.log( 'The matrix `AFB` containing the details of the LU factorization of the band matrix `A`, as computed by `DGBTRF`:' );
+console.log( ndarray2array( AFB, [ LDAFB, N ], [ N, 1 ], 0, 'row-major' ) );
+
+console.log( 'The reciprocal pivot growth factor norm(A)/norm(U) for `AB`:' );
+console.log( dlagbrpvgrw( 'row-major', N, KL, KU, NCOLS, AB, LDAB, AFB, LDAFB ) );
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/lib/base.js
new file mode 100644
index 000000000000..80db60085039
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/lib/base.js
@@ -0,0 +1,116 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var abs = require( '@stdlib/math/base/special/abs' );
+var max = require( '@stdlib/math/base/special/max' );
+var min = require( '@stdlib/math/base/special/min' );
+
+
+// MAIN //
+
+/**
+* Computes the reciprocal pivot growth factor norm(A)/norm(U) for a general banded matrix `A`.
+*
+* ## Notes
+*
+* - The norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix `A` could be poor. This also means that the solution `X`, estimated condition numbers, and error bounds could be unreliable.
+* - Matrix `AB` is the matrix A in band storage, in rows 0 to `KL+KU`. The j-th column of A is stored in the j-th column of the matrix `AB` as `AB( KU+i-j, j ) = A( i, j )` for `max( 0, j - KU ) <= i <= min( N - 1, j + KL )`.
+* - Matrix `AFB` stores the details of the LU factorization of the band matrix `A`, as computed by `DGBTRF`. `U` is stored as an upper triangular band matrix with KL+KU superdiagonals in rows 0 to `KL+KU+1`, and the multipliers used during the factorization are stored in rows `KL+KU+1` to `2*KL+KU`.
+* - The leading dimension of `AB`, `LDAB` >= `KL+KU+1`.
+* - The leading dimension of `AFB`, `LDAFB` >= `2*KL+KU+1`.
+*
+* @private
+* @param {NonNegativeInteger} N - number of rows in matrix `A`
+* @param {NonNegativeInteger} KL - number of subdiagonals within the band of matrix `A`
+* @param {NonNegativeInteger} KU - number of superdiagonals within the band of matrix `A`
+* @param {NonNegativeInteger} NCOLS - number of columns in matrix `A`
+* @param {Float64Array} AB - the matrix A in band storage
+* @param {integer} strideAB1 - stride of the first dimension of `AB`
+* @param {integer} strideAB2 - stride of the second dimension of `AB`
+* @param {NonNegativeInteger} offsetAB - index offset for `AB`
+* @param {Float64Array} AFB - details of the LU factorization of the band matrix `A`
+* @param {integer} strideAFB1 - stride of the first dimension of `AFB`
+* @param {integer} strideAFB2 - stride of the second dimension of `AFB`
+* @param {NonNegativeInteger} offsetAFB - index offset for `AFB`
+* @returns {number} the reciprocal pivot growth factor
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var AB = new Float64Array( [ 0.0, 2.0, 5.0, 8.0, 1.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 0.0 ] );
+* var AFB = new Float64Array( [ 0.0, 0.0, 5.0, 8.0, 0.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 1.8272, 0.3333, 0.1111, -0.2716, 0.0 ] );
+*
+* var out = dlagbrpvgrw( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 );
+* // returns 1.0
+*/
+function dlagbrpvgrw( N, KL, KU, NCOLS, AB, strideAB1, strideAB2, offsetAB, AFB, strideAFB1, strideAFB2, offsetAFB ) { // eslint-disable-line max-params, max-len
+ var rowEndAB;
+ var rowStart;
+ var rpvgrw;
+ var amax;
+ var iafb;
+ var umax;
+ var iab;
+ var kd;
+ var i;
+ var j;
+
+ rpvgrw = 1.0;
+
+ kd = KU + 1;
+ iab = offsetAB;
+ iafb = offsetAFB;
+ for ( j = 0; j < NCOLS; j++ ) {
+ amax = 0.0;
+ umax = 0.0;
+
+ rowStart = max( j - KU, 0 ); // Starting index for row
+ rowEndAB = min( j + KL + 1, N ); // Ending index for row in AB
+ iab += ( kd + rowStart - j - 1 )*strideAB1;
+ iafb += ( kd + rowStart - j - 1 )*strideAFB1;
+
+ for ( i = rowStart; i < rowEndAB; i++ ) {
+ amax = max( abs( AB[ iab ] ), amax );
+ iab += strideAB1;
+ }
+
+ for ( i = rowStart; i <= j; i++ ) {
+ umax = max( abs( AFB[ iafb ] ), umax );
+ iafb += strideAFB1;
+ }
+
+ if ( umax !== 0.0 ) {
+ rpvgrw = min( amax / umax, rpvgrw );
+ }
+
+ // Shift the index for both matrices to the beginning of the next column
+ iab += strideAB2 - ( ( kd + rowEndAB - j - 1 )*strideAB1 );
+ iafb += strideAFB2 - ( kd*strideAFB1 );
+ }
+
+ return rpvgrw;
+}
+
+
+// EXPORTS //
+
+module.exports = dlagbrpvgrw;
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/lib/dlagbrpvgrw.js b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/lib/dlagbrpvgrw.js
new file mode 100644
index 000000000000..9e94e0ef0bcc
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/lib/dlagbrpvgrw.js
@@ -0,0 +1,97 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var isLayout = require( '@stdlib/blas/base/assert/is-layout' );
+var isColumnMajor = require( '@stdlib/ndarray/base/assert/is-column-major-string' );
+var format = require( '@stdlib/string/format' );
+var base = require( './base.js' );
+
+
+// MAIN //
+
+/**
+* Computes the reciprocal pivot growth factor norm(A)/norm(U) for a general banded matrix `A`.
+*
+* ## Notes
+*
+* - The norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix `A` could be poor. This also means that the solution `X`, estimated condition numbers, and error bounds could be unreliable.
+* - Matrix `AB` is the matrix A in band storage, in rows 0 to `KL+KU`. The j-th column of A is stored in the j-th column of the matrix `AB` as `AB( KU+i-j, j ) = A( i, j )` for `max( 0, j - KU ) <= i <= min( N - 1, j + KL )`.
+* - Matrix `AFB` stores the details of the LU factorization of the band matrix `A`, as computed by `DGBTRF`. `U` is stored as an upper triangular band matrix with KL+KU superdiagonals in rows 0 to `KL+KU+1`, and the multipliers used during the factorization are stored in rows `KL+KU+1` to `2*KL+KU`.
+* - The leading dimension of `AB`, `LDAB` >= `KL+KU+1`.
+* - The leading dimension of `AFB`, `LDAFB` >= `2*KL+KU+1`.
+*
+* @param {string} order - order of matrix `A`
+* @param {NonNegativeInteger} N - number of rows in matrix `A`
+* @param {NonNegativeInteger} KL - number of subdiagonals within the band of matrix `A`
+* @param {NonNegativeInteger} KU - number of superdiagonals within the band of matrix `A`
+* @param {NonNegativeInteger} NCOLS - number of columns in matrix `A`
+* @param {Float64Array} AB - the matrix `A` in band storage
+* @param {PositiveInteger} LDAB - the leading dimension of the matrix `AB`
+* @param {Float64Array} AFB - details of the LU factorization of the band matrix `A`
+* @param {PositiveInteger} LDAFB - the leading dimension of the matrix `AFB`
+* @throws {TypeError} first argument must be a valid order
+* @throws {RangeError} seventh argument must be >= KL+KU+1
+* @throws {RangeError} ninth argument must be >= 2*KL+KU+1
+* @returns {number} the reciprocal pivot growth factor
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var AB = new Float64Array( [ 0.0, 2.0, 5.0, 8.0, 1.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 0.0 ] );
+* var AFB = new Float64Array( [ 0.0, 0.0, 5.0, 8.0, 0.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 1.8272, 0.3333, 0.1111, -0.2716, 0.0 ] );
+*
+* var out = dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, AFB, 4 );
+* // returns 1.0
+*/
+function dlagbrpvgrw( order, N, KL, KU, NCOLS, AB, LDAB, AFB, LDAFB ) {
+ var safb1;
+ var safb2;
+ var sab1;
+ var sab2;
+
+ if ( !isLayout( order ) ) {
+ throw new TypeError( format( 'invalid argument. First argument must be a valid order. Value: `%s`.', order ) );
+ }
+ if ( LDAB < KL + KU + 1 ) {
+ throw new RangeError( format( 'invalid argument. Seventh argument must be greater than or equal to KL + KU + 1 = %d. Value: `%d`.', KL + KU + 1, LDAB ) );
+ }
+ if ( LDAFB < ( 2*KL ) + KU + 1 ) {
+ throw new RangeError( format( 'invalid argument. Ninth argument must be greater than or equal to ( 2*KL ) + KU + 1 = %d. Value: `%d`.', ( 2*KL ) + KU + 1, LDAFB ) );
+ }
+ if ( isColumnMajor( order ) ) {
+ sab1 = 1;
+ sab2 = LDAB;
+ safb1 = 1;
+ safb2 = LDAFB;
+ } else { // order === 'row-major'
+ sab1 = N;
+ sab2 = 1;
+ safb1 = N;
+ safb2 = 1;
+ }
+ return base( N, KL, KU, NCOLS, AB, sab1, sab2, 0, AFB, safb1, safb2, 0 );
+}
+
+
+// EXPORTS //
+
+module.exports = dlagbrpvgrw;
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/lib/index.js
new file mode 100644
index 000000000000..91ad8dbcd201
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/lib/index.js
@@ -0,0 +1,68 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+/**
+* LAPACK routine to compute the reciprocal pivot growth factor norm(A)/norm(U) for a general banded matrix `A`.
+*
+* @module @stdlib/lapack/base/dla-gbrpvgrw
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var dlagbrpvgrw = require( '@stdlib/lapack/base/dla-gbrpvgrw' );
+*
+* var AB = new Float64Array( [ 0.0, 2.0, 5.0, 8.0, 1.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 0.0 ] );
+* var AFB = new Float64Array( [ 0.0, 0.0, 5.0, 8.0, 0.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 1.8272, 0.3333, 0.1111, -0.2716, 0.0 ] );
+*
+* var out = dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, AFB, 4 );
+* // returns 1.0
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var dlagbrpvgrw = require( '@stdlib/lapack/base/dla-gbrpvgrw' );
+*
+* var AB = new Float64Array( [ 0.0, 2.0, 5.0, 8.0, 1.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 0.0 ] );
+* var AFB = new Float64Array( [ 0.0, 0.0, 5.0, 8.0, 0.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 1.8272, 0.3333, 0.1111, -0.2716, 0.0 ] );
+*
+* var out = dlagbrpvgrw.ndarray( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 );
+* // returns 1.0
+*/
+
+// MODULES //
+
+var join = require( 'path' ).join;
+var tryRequire = require( '@stdlib/utils/try-require' );
+var isError = require( '@stdlib/assert/is-error' );
+var main = require( './main.js' );
+
+
+// MAIN //
+
+var dlagbrpvgrw;
+var tmp = tryRequire( join( __dirname, './native.js' ) );
+if ( isError( tmp ) ) {
+ dlagbrpvgrw = main;
+} else {
+ dlagbrpvgrw = tmp;
+}
+
+
+// EXPORTS //
+
+module.exports = dlagbrpvgrw;
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/lib/main.js b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/lib/main.js
new file mode 100644
index 000000000000..e1b273b4fe3e
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/lib/main.js
@@ -0,0 +1,35 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var dlagbrpvgrw = require( './dlagbrpvgrw.js' );
+var ndarray = require( './ndarray.js' );
+
+
+// MAIN //
+
+setReadOnly( dlagbrpvgrw, 'ndarray', ndarray );
+
+
+// EXPORTS //
+
+module.exports = dlagbrpvgrw;
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/lib/ndarray.js
new file mode 100644
index 000000000000..5e187c6c45c5
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/lib/ndarray.js
@@ -0,0 +1,69 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var base = require( './base.js' );
+
+
+// MAIN //
+
+/**
+* Computes the reciprocal pivot growth factor norm(A)/norm(U) for a general banded matrix `A` using alternating indexing semantics.
+*
+* ## Notes
+*
+* - The norm is used. If this is much less than 1, the stability of the LU factorization of the (equilibrated) matrix `A` could be poor. This also means that the solution `X`, estimated condition numbers, and error bounds could be unreliable.
+* - Matrix `AB` is the matrix A in band storage, in rows 0 to `KL+KU`. The j-th column of A is stored in the j-th column of the matrix `AB` as `AB( KU+i-j, j ) = A( i, j )` for `max( 0, j - KU ) <= i <= min( N - 1, j + KL )`.
+* - Matrix `AFB` stores the details of the LU factorization of the band matrix `A`, as computed by `DGBTRF`. `U` is stored as an upper triangular band matrix with KL+KU superdiagonals in rows 0 to `KL+KU+1`, and the multipliers used during the factorization are stored in rows `KL+KU+1` to `2*KL+KU`.
+* - The leading dimension of `AB`, `LDAB` >= `KL+KU+1`.
+* - The leading dimension of `AFB`, `LDAFB` >= `2*KL+KU+1`.
+*
+* @param {NonNegativeInteger} N - number of rows in matrix `A`
+* @param {NonNegativeInteger} KL - number of subdiagonals within the band of matrix `A`
+* @param {NonNegativeInteger} KU - number of superdiagonals within the band of matrix `A`
+* @param {NonNegativeInteger} NCOLS - number of columns in matrix `A`
+* @param {Float64Array} AB - the matrix A in band storage
+* @param {integer} strideAB1 - stride of the first dimension of `AB`
+* @param {integer} strideAB2 - stride of the second dimension of `AB`
+* @param {NonNegativeInteger} offsetAB - index offset for `AB`
+* @param {Float64Array} AFB - details of the LU factorization of the band matrix `A`
+* @param {integer} strideAFB1 - stride of the first dimension of `AFB`
+* @param {integer} strideAFB2 - stride of the second dimension of `AFB`
+* @param {NonNegativeInteger} offsetAFB - index offset for `AFB`
+* @returns {number} the reciprocal pivot growth factor
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var AB = new Float64Array( [ 0.0, 2.0, 5.0, 8.0, 1.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 0.0 ] );
+* var AFB = new Float64Array( [ 0.0, 0.0, 5.0, 8.0, 0.0, 4.0, 7.0, 10.0, 3.0, 6.0, 9.0, 1.8272, 0.3333, 0.1111, -0.2716, 0.0 ] );
+*
+* var out = dlagbrpvgrw( 4, 1, 1, 4, AB, 4, 1, 0, AFB, 4, 1, 0 );
+* // returns 1.0
+*/
+function dlagbrpvgrw( N, KL, KU, NCOLS, AB, strideAB1, strideAB2, offsetAB, AFB, strideAFB1, strideAFB2, offsetAFB ) { // eslint-disable-line max-len, max-params
+ return base( N, KL, KU, NCOLS, AB, strideAB1, strideAB2, offsetAB, AFB, strideAFB1, strideAFB2, offsetAFB ); // eslint-disable-line max-len
+}
+
+
+// EXPORTS //
+
+module.exports = dlagbrpvgrw;
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/package.json b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/package.json
new file mode 100644
index 000000000000..0d6c50a43f64
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/package.json
@@ -0,0 +1,73 @@
+{
+ "name": "@stdlib/lapack/base/dla-gbrpvgrw",
+ "version": "0.0.0",
+ "description": "LAPACK routine to computes the reciprocal pivot growth factor norm(A)/norm(U) for a general banded matrix.",
+ "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",
+ "dla_gbrpvgrw",
+ "orthogonal",
+ "qr",
+ "decomposition",
+ "householder",
+ "reflectors",
+ "matrix",
+ "linear",
+ "algebra",
+ "subroutines",
+ "array",
+ "ndarray",
+ "float64",
+ "double",
+ "float64array"
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/column_major.json b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/column_major.json
new file mode 100644
index 000000000000..de46a814cdb6
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/column_major.json
@@ -0,0 +1,59 @@
+{
+ "order": "column-major",
+ "N": 4,
+ "KL": 1,
+ "KU": 1,
+ "NCOLS": 4,
+ "LDAB": 3,
+ "LDAFB": 4,
+ "rpgFactor": 1,
+ "AB_mat": [
+ [ 0, 2, 5, 8 ],
+ [ 1, 4, 7, 10 ],
+ [ 3, 6, 9, 0 ]
+ ],
+ "AB": [
+ 0.0,
+ 1.0,
+ 3.0,
+ 2.0,
+ 4.0,
+ 6.0,
+ 5.0,
+ 7.0,
+ 9.0,
+ 8.0,
+ 10.0,
+ 0.0
+ ],
+ "strideAB1": 1,
+ "strideAB2": 3,
+ "offsetAB": 0,
+ "AFB_mat": [
+ [ 0.0, 0.0, 5.0, 8.0 ],
+ [ 0.0, 4.0, 7.0, 10.0 ],
+ [ 3.0, 6.0, 9.0, 1.8272 ],
+ [ 0.3333, 0.1111, -0.2716, 0.0 ]
+ ],
+ "AFB": [
+ 0.0,
+ 0.0,
+ 3.0,
+ 0.3333,
+ 0.0,
+ 4.0,
+ 6.0,
+ 0.1111,
+ 5.0,
+ 7.0,
+ 9.0,
+ -0.2716,
+ 8.0,
+ 10.0,
+ 1.8272,
+ 0.0
+ ],
+ "strideAFB1": 1,
+ "strideAFB2": 4,
+ "offsetAFB": 0
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/large_strides/column_major.json b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/large_strides/column_major.json
new file mode 100644
index 000000000000..434d8d8e676c
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/large_strides/column_major.json
@@ -0,0 +1,87 @@
+{
+ "order": "column-major",
+ "N": 4,
+ "KL": 1,
+ "KU": 1,
+ "NCOLS": 4,
+ "LDAB": 3,
+ "LDAFB": 4,
+ "rpgFactor": 1,
+ "AB_mat": [
+ [ 0, 2, 5, 8 ],
+ [ 1, 4, 7, 10 ],
+ [ 3, 6, 9, 0 ]
+ ],
+ "AB": [
+ 0,
+ 9999,
+ 1,
+ 9999,
+ 3,
+ 9999,
+ 2,
+ 9999,
+ 4,
+ 9999,
+ 6,
+ 9999,
+ 5,
+ 9999,
+ 7,
+ 9999,
+ 9,
+ 9999,
+ 8,
+ 9999,
+ 10,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideAB1": 2,
+ "strideAB2": 6,
+ "offsetAB": 0,
+ "AFB_mat": [
+ [ 0.0, 0.0, 5.0, 8.0 ],
+ [ 0.0, 4.0, 7.0, 10.0 ],
+ [ 3.0, 6.0, 9.0, 1.8272 ],
+ [ 0.3333, 0.1111, -0.2716, 0.0 ]
+ ],
+ "AFB": [
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 3,
+ 9999,
+ 0.3333,
+ 9999,
+ 0,
+ 9999,
+ 4,
+ 9999,
+ 6,
+ 9999,
+ 0.1111,
+ 9999,
+ 5,
+ 9999,
+ 7,
+ 9999,
+ 9,
+ 9999,
+ -0.2716,
+ 9999,
+ 8,
+ 9999,
+ 10,
+ 9999,
+ 1.8272,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideAFB1": 2,
+ "strideAFB2": 8,
+ "offsetAFB": 0
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/large_strides/row_major.json b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/large_strides/row_major.json
new file mode 100644
index 000000000000..e2361efc22c0
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/large_strides/row_major.json
@@ -0,0 +1,87 @@
+{
+ "order": "row-major",
+ "N": 4,
+ "KL": 1,
+ "KU": 1,
+ "NCOLS": 4,
+ "LDAB": 3,
+ "LDAFB": 4,
+ "rpgFactor": 1,
+ "AB_mat": [
+ [ 0, 2, 5, 8 ],
+ [ 1, 4, 7, 10 ],
+ [ 3, 6, 9, 0 ]
+ ],
+ "AB": [
+ 0,
+ 9999,
+ 2,
+ 9999,
+ 5,
+ 9999,
+ 8,
+ 9999,
+ 1,
+ 9999,
+ 4,
+ 9999,
+ 7,
+ 9999,
+ 10,
+ 9999,
+ 3,
+ 9999,
+ 6,
+ 9999,
+ 9,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideAB1": 8,
+ "strideAB2": 2,
+ "offsetAB": 0,
+ "AFB_mat": [
+ [ 0, 0, 5, 8 ],
+ [ 0, 4, 7, 10 ],
+ [ 3, 6, 9, 1.8272 ],
+ [ 0.3333, 0.1111, -0.2716, 0 ]
+ ],
+ "AFB": [
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 5,
+ 9999,
+ 8,
+ 9999,
+ 0,
+ 9999,
+ 4,
+ 9999,
+ 7,
+ 9999,
+ 10,
+ 9999,
+ 3,
+ 9999,
+ 6,
+ 9999,
+ 9,
+ 9999,
+ 1.8272,
+ 9999,
+ 0.3333,
+ 9999,
+ 0.1111,
+ 9999,
+ -0.2716,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideAFB1": 8,
+ "strideAFB2": 2,
+ "offsetAFB": 0
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/mixed_strides/column_major.json b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/mixed_strides/column_major.json
new file mode 100644
index 000000000000..75aa027fb168
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/mixed_strides/column_major.json
@@ -0,0 +1,59 @@
+{
+ "order": "column-major",
+ "N": 4,
+ "KL": 1,
+ "KU": 1,
+ "NCOLS": 4,
+ "LDAB": 3,
+ "LDAFB": 4,
+ "rpgFactor": 1,
+ "AB_mat": [
+ [ 0, 2, 5, 8 ],
+ [ 1, 4, 7, 10 ],
+ [ 3, 6, 9, 0 ]
+ ],
+ "AB": [
+ 8,
+ 10,
+ 0,
+ 5,
+ 7,
+ 9,
+ 2,
+ 4,
+ 6,
+ 0,
+ 1,
+ 3
+ ],
+ "strideAB1": 1,
+ "strideAB2": -3,
+ "offsetAB": 9,
+ "AFB_mat": [
+ [ 0.0, 0.0, 5.0, 8.0 ],
+ [ 0.0, 4.0, 7.0, 10.0 ],
+ [ 3.0, 6.0, 9.0, 1.8272 ],
+ [ 0.3333, 0.1111, -0.2716, 0.0 ]
+ ],
+ "AFB": [
+ 8,
+ 10,
+ 1.8272,
+ 0,
+ 5,
+ 7,
+ 9,
+ -0.2716,
+ 0,
+ 4,
+ 6,
+ 0.1111,
+ 0,
+ 0,
+ 3,
+ 0.3333
+ ],
+ "strideAFB1": 1,
+ "strideAFB2": -4,
+ "offsetAFB": 12
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/mixed_strides/row_major.json b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/mixed_strides/row_major.json
new file mode 100644
index 000000000000..a614102c86bc
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/mixed_strides/row_major.json
@@ -0,0 +1,59 @@
+{
+ "order": "row-major",
+ "N": 4,
+ "KL": 1,
+ "KU": 1,
+ "NCOLS": 4,
+ "LDAB": 3,
+ "LDAFB": 4,
+ "rpgFactor": 1,
+ "AB_mat": [
+ [ 0, 2, 5, 8 ],
+ [ 1, 4, 7, 10 ],
+ [ 3, 6, 9, 0 ]
+ ],
+ "AB": [
+ 3,
+ 6,
+ 9,
+ 0,
+ 1,
+ 4,
+ 7,
+ 10,
+ 0,
+ 2,
+ 5,
+ 8
+ ],
+ "strideAB1": -4,
+ "strideAB2": 1,
+ "offsetAB": 8,
+ "AFB_mat": [
+ [ 0, 0, 5, 8 ],
+ [ 0, 4, 7, 10 ],
+ [ 3, 6, 9, 1.8272 ],
+ [ 0.3333, 0.1111, -0.2716, 0 ]
+ ],
+ "AFB": [
+ 0.3333,
+ 0.1111,
+ -0.2716,
+ 0,
+ 3,
+ 6,
+ 9,
+ 1.8272,
+ 0,
+ 4,
+ 7,
+ 10,
+ 0,
+ 0,
+ 5,
+ 8
+ ],
+ "strideAFB1": -4,
+ "strideAFB2": 1,
+ "offsetAFB": 12
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/negative_strides/column_major.json b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/negative_strides/column_major.json
new file mode 100644
index 000000000000..8c0f66396e7d
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/negative_strides/column_major.json
@@ -0,0 +1,59 @@
+{
+ "order": "column-major",
+ "N": 4,
+ "KL": 1,
+ "KU": 1,
+ "NCOLS": 4,
+ "LDAB": 3,
+ "LDAFB": 4,
+ "rpgFactor": 1,
+ "AB_mat": [
+ [ 0, 2, 5, 8 ],
+ [ 1, 4, 7, 10 ],
+ [ 3, 6, 9, 0 ]
+ ],
+ "AB": [
+ 0,
+ 10,
+ 8,
+ 9,
+ 7,
+ 5,
+ 6,
+ 4,
+ 2,
+ 3,
+ 1,
+ 0
+ ],
+ "strideAB1": -1,
+ "strideAB2": -3,
+ "offsetAB": 11,
+ "AFB_mat": [
+ [ 0.0, 0.0, 5.0, 8.0 ],
+ [ 0.0, 4.0, 7.0, 10.0 ],
+ [ 3.0, 6.0, 9.0, 1.8272 ],
+ [ 0.3333, 0.1111, -0.2716, 0.0 ]
+ ],
+ "AFB": [
+ 0,
+ 1.8272,
+ 10,
+ 8,
+ -0.2716,
+ 9,
+ 7,
+ 5,
+ 0.1111,
+ 6,
+ 4,
+ 0,
+ 0.3333,
+ 3,
+ 0,
+ 0
+ ],
+ "strideAFB1": -1,
+ "strideAFB2": -4,
+ "offsetAFB": 15
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/negative_strides/row_major.json b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/negative_strides/row_major.json
new file mode 100644
index 000000000000..cd37105e1a6f
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/negative_strides/row_major.json
@@ -0,0 +1,59 @@
+{
+ "order": "row-major",
+ "N": 4,
+ "KL": 1,
+ "KU": 1,
+ "NCOLS": 4,
+ "LDAB": 3,
+ "LDAFB": 4,
+ "rpgFactor": 1,
+ "AB_mat": [
+ [ 0, 2, 5, 8 ],
+ [ 1, 4, 7, 10 ],
+ [ 3, 6, 9, 0 ]
+ ],
+ "AB": [
+ 0,
+ 9,
+ 6,
+ 3,
+ 10,
+ 7,
+ 4,
+ 1,
+ 8,
+ 5,
+ 2,
+ 0
+ ],
+ "strideAB1": -4,
+ "strideAB2": -1,
+ "offsetAB": 11,
+ "AFB_mat": [
+ [ 0, 0, 5, 8 ],
+ [ 0, 4, 7, 10 ],
+ [ 3, 6, 9, 1.8272 ],
+ [ 0.3333, 0.1111, -0.2716, 0 ]
+ ],
+ "AFB": [
+ 0,
+ -0.2716,
+ 0.1111,
+ 0.3333,
+ 1.8272,
+ 9,
+ 6,
+ 3,
+ 10,
+ 7,
+ 4,
+ 0,
+ 8,
+ 5,
+ 0,
+ 0
+ ],
+ "strideAFB1": -4,
+ "strideAFB2": -1,
+ "offsetAFB": 15
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/offsets/column_major.json b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/offsets/column_major.json
new file mode 100644
index 000000000000..82e5b3fa9620
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/offsets/column_major.json
@@ -0,0 +1,61 @@
+{
+ "order": "column-major",
+ "N": 4,
+ "KL": 1,
+ "KU": 1,
+ "NCOLS": 4,
+ "LDAB": 3,
+ "LDAFB": 4,
+ "rpgFactor": 1,
+ "AB_mat": [
+ [ 0, 2, 5, 8 ],
+ [ 1, 4, 7, 10 ],
+ [ 3, 6, 9, 0 ]
+ ],
+ "AB": [
+ 9999,
+ 0,
+ 1,
+ 3,
+ 2,
+ 4,
+ 6,
+ 5,
+ 7,
+ 9,
+ 8,
+ 10,
+ 0
+ ],
+ "strideAB1": 1,
+ "strideAB2": 3,
+ "offsetAB": 1,
+ "AFB_mat": [
+ [ 0.0, 0.0, 5.0, 8.0 ],
+ [ 0.0, 4.0, 7.0, 10.0 ],
+ [ 3.0, 6.0, 9.0, 1.8272 ],
+ [ 0.3333, 0.1111, -0.2716, 0.0 ]
+ ],
+ "AFB": [
+ 9999,
+ 0,
+ 0,
+ 3,
+ 0.3333,
+ 0,
+ 4,
+ 6,
+ 0.1111,
+ 5,
+ 7,
+ 9,
+ -0.2716,
+ 8,
+ 10,
+ 1.8272,
+ 0
+ ],
+ "strideAFB1": 1,
+ "strideAFB2": 4,
+ "offsetAFB": 1
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/offsets/row_major.json b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/offsets/row_major.json
new file mode 100644
index 000000000000..0219a9c1a58e
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/offsets/row_major.json
@@ -0,0 +1,61 @@
+{
+ "order": "row-major",
+ "N": 4,
+ "KL": 1,
+ "KU": 1,
+ "NCOLS": 4,
+ "LDAB": 3,
+ "LDAFB": 4,
+ "rpgFactor": 1,
+ "AB_mat": [
+ [ 0, 2, 5, 8 ],
+ [ 1, 4, 7, 10 ],
+ [ 3, 6, 9, 0 ]
+ ],
+ "AB": [
+ 9999,
+ 0,
+ 2,
+ 5,
+ 8,
+ 1,
+ 4,
+ 7,
+ 10,
+ 3,
+ 6,
+ 9,
+ 0
+ ],
+ "strideAB1": 4,
+ "strideAB2": 1,
+ "offsetAB": 1,
+ "AFB_mat": [
+ [ 0, 0, 5, 8 ],
+ [ 0, 4, 7, 10 ],
+ [ 3, 6, 9, 1.8272 ],
+ [ 0.3333, 0.1111, -0.2716, 0 ]
+ ],
+ "AFB": [
+ 9999,
+ 0,
+ 0,
+ 5,
+ 8,
+ 0,
+ 4,
+ 7,
+ 10,
+ 3,
+ 6,
+ 9,
+ 1.8272,
+ 0.3333,
+ 0.1111,
+ -0.2716,
+ 0
+ ],
+ "strideAFB1": 4,
+ "strideAFB2": 1,
+ "offsetAFB": 1
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/row_major.json b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/row_major.json
new file mode 100644
index 000000000000..584c2405bfe1
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/fixtures/row_major.json
@@ -0,0 +1,59 @@
+{
+ "order": "row-major",
+ "N": 4,
+ "KL": 1,
+ "KU": 1,
+ "NCOLS": 4,
+ "LDAB": 3,
+ "LDAFB": 4,
+ "rpgFactor": 1,
+ "AB_mat": [
+ [ 0, 2, 5, 8 ],
+ [ 1, 4, 7, 10 ],
+ [ 3, 6, 9, 0 ]
+ ],
+ "AB": [
+ 0.0,
+ 2.0,
+ 5.0,
+ 8.0,
+ 1.0,
+ 4.0,
+ 7.0,
+ 10.0,
+ 3.0,
+ 6.0,
+ 9.0,
+ 0.0
+ ],
+ "strideAB1": 4,
+ "strideAB2": 1,
+ "offsetAB": 0,
+ "AFB_mat": [
+ [ 0, 0, 5, 8 ],
+ [ 0, 4, 7, 10 ],
+ [ 3, 6, 9, 1.8272 ],
+ [ 0.3333, 0.1111, -0.2716, 0 ]
+ ],
+ "AFB": [
+ 0.0,
+ 0.0,
+ 5.0,
+ 8.0,
+ 0.0,
+ 4.0,
+ 7.0,
+ 10.0,
+ 3.0,
+ 6.0,
+ 9.0,
+ 1.8272,
+ 0.3333,
+ 0.1111,
+ -0.2716,
+ 0.0
+ ],
+ "strideAFB1": 4,
+ "strideAFB2": 1,
+ "offsetAFB": 0
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/test.dlagbrpvgrw.js b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/test.dlagbrpvgrw.js
new file mode 100644
index 000000000000..c915a2285e76
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/test.dlagbrpvgrw.js
@@ -0,0 +1,204 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var Float64Array = require( '@stdlib/array/float64' );
+var EPS = require( '@stdlib/constants/float64/eps' );
+var abs = require( '@stdlib/math/base/special/abs' );
+var dlagbrpvgrw = require( './../lib/dlagbrpvgrw.js' );
+
+
+// FIXTURES //
+
+// Note: the outputs are tested against the outputs of the Fortran implementation.
+
+var COL_MAJOR = require( './fixtures/column_major.json' );
+var ROW_MAJOR = require( './fixtures/row_major.json' );
+
+
+// FUNCTIONS //
+
+/**
+* Tests for element-wise approximate equality.
+*
+* @private
+* @param {Object} t - test object
+* @param {Collection} actual - actual values
+* @param {Collection} expected - expected values
+* @param {number} rtol - relative tolerance
+*/
+function isApprox( t, actual, expected, rtol ) {
+ var delta;
+ var tol;
+ var i;
+
+ t.strictEqual( actual.length, expected.length, 'returns expected value' );
+ for ( i = 0; i < expected.length; i++ ) {
+ if ( actual[ i ] === expected[ i ] ) {
+ t.strictEqual( actual[ i ], expected[ i ], 'returns expected value' );
+ } else {
+ delta = abs( actual[ i ] - expected[ i ] );
+ tol = rtol * EPS * abs( expected[ i ] );
+ t.ok( delta <= tol, 'within tolerance. actual: '+actual[ i ]+'. expected: '+expected[ i ]+'. delta: '+delta+'. tol: '+tol+'.' );
+ }
+ }
+}
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof dlagbrpvgrw, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function has an arity of 9', function test( t ) {
+ t.strictEqual( dlagbrpvgrw.length, 9, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function throws an error if provided a first argument which is not a valid order', function test( t ) {
+ var values;
+ var AFB;
+ var AB;
+ var i;
+
+ values = [
+ 'foo',
+ 'bar',
+ 'beep',
+ 'boop',
+ -5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [],
+ {},
+ function noop() {}
+ ];
+
+ AFB = new Float64Array( 16 );
+ AB = new Float64Array( 16 );
+
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ dlagbrpvgrw( value, 4, 1, 1, 4, AB, 3, AFB, 4 );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a seventh argument which is not a valid `LDAB` value', function test( t ) {
+ var values;
+ var AFB;
+ var AB;
+ var i;
+
+ values = [
+ 0,
+ 1,
+ 2
+ ];
+
+ AFB = new Float64Array( 16 );
+ AB = new Float64Array( 16 );
+
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, value, AFB, 4 );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a ninth argument which is not a valid `LDAFB` value', function test( t ) {
+ var values;
+ var AFB;
+ var AB;
+ var i;
+
+ values = [
+ 0,
+ 1,
+ 2,
+ 3
+ ];
+
+ AFB = new Float64Array( 16 );
+ AB = new Float64Array( 16 );
+
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ dlagbrpvgrw( 'row-major', 4, 1, 1, 4, AB, 3, AFB, value );
+ };
+ }
+});
+
+tape( 'the function computes the reciprocal pivot growth factor for a general banded matrix `AB` (column-major)', function test( t ) {
+ var rpgFactor;
+ var data;
+ var AFB;
+ var AB;
+
+ data = COL_MAJOR;
+
+ AFB = new Float64Array( data.AFB );
+ AB = new Float64Array( data.AB );
+
+ rpgFactor = dlagbrpvgrw( data.order, data.N, data.KL, data.KU, data.NCOLS, AB, data.LDAB, AFB, data.LDAFB ); // eslint-disable-line max-len
+ isApprox( t, rpgFactor, data.rpgFactor, 1.0 );
+
+ t.end();
+});
+
+tape( 'the function computes the reciprocal pivot growth factor for a general banded matrix `AB` (row-major)', function test( t ) {
+ var rpgFactor;
+ var data;
+ var AFB;
+ var AB;
+
+ data = ROW_MAJOR;
+
+ AFB = new Float64Array( data.AFB );
+ AB = new Float64Array( data.AB );
+
+ rpgFactor = dlagbrpvgrw( data.order, data.N, data.KL, data.KU, data.NCOLS, AB, data.LDAB, AFB, data.LDAFB ); // eslint-disable-line max-len
+ isApprox( t, rpgFactor, data.rpgFactor, 1.0 );
+
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/test.js b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/test.js
new file mode 100644
index 000000000000..c1ed83d47be0
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/test.js
@@ -0,0 +1,82 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var proxyquire = require( 'proxyquire' );
+var IS_BROWSER = require( '@stdlib/assert/is-browser' );
+var dlagbrpvgrw = 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 dlagbrpvgrw, '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 dlagbrpvgrw.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 dlagbrpvgrw = proxyquire( './../lib', {
+ '@stdlib/utils/try-require': tryRequire
+ });
+
+ t.strictEqual( dlagbrpvgrw, 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 dlagbrpvgrw;
+ var main;
+
+ main = require( './../lib/dlagbrpvgrw.js' );
+
+ dlagbrpvgrw = proxyquire( './../lib', {
+ '@stdlib/utils/try-require': tryRequire
+ });
+
+ t.strictEqual( dlagbrpvgrw, main, 'returns expected value' );
+ t.end();
+
+ function tryRequire() {
+ return new Error( 'Cannot find module' );
+ }
+});
diff --git a/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/test.ndarray.js
new file mode 100644
index 000000000000..afdd07e98b37
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dla-gbrpvgrw/test/test.ndarray.js
@@ -0,0 +1,258 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var Float64Array = require( '@stdlib/array/float64' );
+var EPS = require( '@stdlib/constants/float64/eps' );
+var abs = require( '@stdlib/math/base/special/abs' );
+var dlagbrpvgrw = require( './../lib/ndarray.js' );
+
+
+// FIXTURES //
+
+// Note: the outputs are tested against the outputs of the Fortran implementation.
+
+var COL_MAJOR = require( './fixtures/column_major.json' );
+var ROW_MAJOR = require( './fixtures/row_major.json' );
+var LARGE_STRIDES_COL_MAJOR = require( './fixtures/large_strides/column_major.json' );
+var LARGE_STRIDES_ROW_MAJOR = require( './fixtures/large_strides/row_major.json' );
+var NEGATIVE_STRIDES_COL_MAJOR = require( './fixtures/negative_strides/column_major.json' );
+var NEGATIVE_STRIDES_ROW_MAJOR = require( './fixtures/negative_strides/row_major.json' );
+var MIXED_STRIDES_COL_MAJOR = require( './fixtures/mixed_strides/column_major.json' );
+var MIXED_STRIDES_ROW_MAJOR = require( './fixtures/mixed_strides/row_major.json' );
+var OFFSETS_COL_MAJOR = require( './fixtures/offsets/column_major.json' );
+var OFFSETS_ROW_MAJOR = require( './fixtures/offsets/row_major.json' );
+
+
+// FUNCTIONS //
+
+/**
+* Tests for element-wise approximate equality.
+*
+* @private
+* @param {Object} t - test object
+* @param {Collection} actual - actual values
+* @param {Collection} expected - expected values
+* @param {number} rtol - relative tolerance
+*/
+function isApprox( t, actual, expected, rtol ) {
+ var delta;
+ var tol;
+ var i;
+
+ t.strictEqual( actual.length, expected.length, 'returns expected value' );
+ for ( i = 0; i < expected.length; i++ ) {
+ if ( actual[ i ] === expected[ i ] ) {
+ t.strictEqual( actual[ i ], expected[ i ], 'returns expected value' );
+ } else {
+ delta = abs( actual[ i ] - expected[ i ] );
+ tol = rtol * EPS * abs( expected[ i ] );
+ t.ok( delta <= tol, 'within tolerance. actual: '+actual[ i ]+'. expected: '+expected[ i ]+'. delta: '+delta+'. tol: '+tol+'.' );
+ }
+ }
+}
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof dlagbrpvgrw, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function has an arity of 12', function test( t ) {
+ t.strictEqual( dlagbrpvgrw.length, 12, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes the reciprocal pivot growth factor for a general banded matrix `AB` (column-major)', function test( t ) {
+ var rpgFactor;
+ var data;
+ var AFB;
+ var AB;
+
+ data = COL_MAJOR;
+
+ AFB = new Float64Array( data.AFB );
+ AB = new Float64Array( data.AB );
+
+ rpgFactor = dlagbrpvgrw( data.N, data.KL, data.KU, data.NCOLS, AB, data.strideAB1, data.strideAB2, data.offsetAB, AFB, data.strideAFB1, data.strideAFB2, data.offsetAFB );
+ isApprox( t, rpgFactor, data.rpgFactor, 1.0 );
+
+ t.end();
+});
+
+tape( 'the function computes the reciprocal pivot growth factor for a general banded matrix `AB` (rpw-major)', function test( t ) {
+ var rpgFactor;
+ var data;
+ var AFB;
+ var AB;
+
+ data = ROW_MAJOR;
+
+ AFB = new Float64Array( data.AFB );
+ AB = new Float64Array( data.AB );
+
+ rpgFactor = dlagbrpvgrw( data.N, data.KL, data.KU, data.NCOLS, AB, data.strideAB1, data.strideAB2, data.offsetAB, AFB, data.strideAFB1, data.strideAFB2, data.offsetAFB );
+ isApprox( t, rpgFactor, data.rpgFactor, 1.0 );
+
+ t.end();
+});
+
+tape( 'the function computes the reciprocal pivot growth factor for a general banded matrix `AB` (column-major, large strides)', function test( t ) {
+ var rpgFactor;
+ var data;
+ var AFB;
+ var AB;
+
+ data = LARGE_STRIDES_COL_MAJOR;
+
+ AFB = new Float64Array( data.AFB );
+ AB = new Float64Array( data.AB );
+
+ rpgFactor = dlagbrpvgrw( data.N, data.KL, data.KU, data.NCOLS, AB, data.strideAB1, data.strideAB2, data.offsetAB, AFB, data.strideAFB1, data.strideAFB2, data.offsetAFB );
+ isApprox( t, rpgFactor, data.rpgFactor, 1.0 );
+
+ t.end();
+});
+
+tape( 'the function computes the reciprocal pivot growth factor for a general banded matrix `AB` (row-major, large strides)', function test( t ) {
+ var rpgFactor;
+ var data;
+ var AFB;
+ var AB;
+
+ data = LARGE_STRIDES_ROW_MAJOR;
+
+ AFB = new Float64Array( data.AFB );
+ AB = new Float64Array( data.AB );
+
+ rpgFactor = dlagbrpvgrw( data.N, data.KL, data.KU, data.NCOLS, AB, data.strideAB1, data.strideAB2, data.offsetAB, AFB, data.strideAFB1, data.strideAFB2, data.offsetAFB );
+ isApprox( t, rpgFactor, data.rpgFactor, 1.0 );
+
+ t.end();
+});
+
+tape( 'the function computes the reciprocal pivot growth factor for a general banded matrix `AB` (column-major, negative strides)', function test( t ) {
+ var rpgFactor;
+ var data;
+ var AFB;
+ var AB;
+
+ data = NEGATIVE_STRIDES_COL_MAJOR;
+
+ AFB = new Float64Array( data.AFB );
+ AB = new Float64Array( data.AB );
+
+ rpgFactor = dlagbrpvgrw( data.N, data.KL, data.KU, data.NCOLS, AB, data.strideAB1, data.strideAB2, data.offsetAB, AFB, data.strideAFB1, data.strideAFB2, data.offsetAFB );
+ isApprox( t, rpgFactor, data.rpgFactor, 1.0 );
+
+ t.end();
+});
+
+tape( 'the function computes the reciprocal pivot growth factor for a general banded matrix `AB` (row-major, negative strides)', function test( t ) {
+ var rpgFactor;
+ var data;
+ var AFB;
+ var AB;
+
+ data = NEGATIVE_STRIDES_ROW_MAJOR;
+
+ AFB = new Float64Array( data.AFB );
+ AB = new Float64Array( data.AB );
+
+ rpgFactor = dlagbrpvgrw( data.N, data.KL, data.KU, data.NCOLS, AB, data.strideAB1, data.strideAB2, data.offsetAB, AFB, data.strideAFB1, data.strideAFB2, data.offsetAFB );
+ isApprox( t, rpgFactor, data.rpgFactor, 1.0 );
+
+ t.end();
+});
+
+tape( 'the function computes the reciprocal pivot growth factor for a general banded matrix `AB` (column-major, offsets)', function test( t ) {
+ var rpgFactor;
+ var data;
+ var AFB;
+ var AB;
+
+ data = OFFSETS_COL_MAJOR;
+
+ AFB = new Float64Array( data.AFB );
+ AB = new Float64Array( data.AB );
+
+ rpgFactor = dlagbrpvgrw( data.N, data.KL, data.KU, data.NCOLS, AB, data.strideAB1, data.strideAB2, data.offsetAB, AFB, data.strideAFB1, data.strideAFB2, data.offsetAFB );
+ isApprox( t, rpgFactor, data.rpgFactor, 1.0 );
+
+ t.end();
+});
+
+tape( 'the function computes the reciprocal pivot growth factor for a general banded matrix `AB` (row-major, offsets)', function test( t ) {
+ var rpgFactor;
+ var data;
+ var AFB;
+ var AB;
+
+ data = OFFSETS_ROW_MAJOR;
+
+ AFB = new Float64Array( data.AFB );
+ AB = new Float64Array( data.AB );
+
+ rpgFactor = dlagbrpvgrw( data.N, data.KL, data.KU, data.NCOLS, AB, data.strideAB1, data.strideAB2, data.offsetAB, AFB, data.strideAFB1, data.strideAFB2, data.offsetAFB );
+ isApprox( t, rpgFactor, data.rpgFactor, 1.0 );
+
+ t.end();
+});
+
+tape( 'the function computes the reciprocal pivot growth factor for a general banded matrix `AB` (column-major, mixed strides)', function test( t ) {
+ var rpgFactor;
+ var data;
+ var AFB;
+ var AB;
+
+ data = MIXED_STRIDES_COL_MAJOR;
+
+ AFB = new Float64Array( data.AFB );
+ AB = new Float64Array( data.AB );
+
+ rpgFactor = dlagbrpvgrw( data.N, data.KL, data.KU, data.NCOLS, AB, data.strideAB1, data.strideAB2, data.offsetAB, AFB, data.strideAFB1, data.strideAFB2, data.offsetAFB );
+ isApprox( t, rpgFactor, data.rpgFactor, 1.0 );
+
+ t.end();
+});
+
+tape( 'the function computes the reciprocal pivot growth factor for a general banded matrix `AB` (row-major, mixed strides)', function test( t ) {
+ var rpgFactor;
+ var data;
+ var AFB;
+ var AB;
+
+ data = MIXED_STRIDES_ROW_MAJOR;
+
+ AFB = new Float64Array( data.AFB );
+ AB = new Float64Array( data.AB );
+
+ rpgFactor = dlagbrpvgrw( data.N, data.KL, data.KU, data.NCOLS, AB, data.strideAB1, data.strideAB2, data.offsetAB, AFB, data.strideAFB1, data.strideAFB2, data.offsetAFB );
+ isApprox( t, rpgFactor, data.rpgFactor, 1.0 );
+
+ t.end();
+});