diff --git a/lib/node_modules/@stdlib/lapack/base/dgebal/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/base.js
new file mode 100644
index 000000000000..df6482de6d99
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/base.js
@@ -0,0 +1,285 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/* eslint-disable max-len, max-params, max-statements */
+
+'use strict';
+
+// MODULES //
+
+var dswap = require( '@stdlib/blas/base/dswap' ).ndarray;
+var dlamch = require( '@stdlib/lapack/base/dlamch' );
+var dnrm2 = require( '@stdlib/blas/base/dnrm2' ).ndarray;
+var idamax = require( '@stdlib/blas/base/idamax' ).ndarray;
+var abs = require( '@stdlib/math/base/special/abs' );
+var isnan = require( '@stdlib/assert/is-nan' );
+var max = require( '@stdlib/math/base/special/maxn' );
+var min = require( '@stdlib/math/base/special/minn' );
+var dscal = require( '@stdlib/blas/base/dscal' ).ndarray;
+
+
+// MAIN //
+
+/**
+* Balances a general real matrix `A`.
+*
+* ## Notes
+*
+* The job parameter can be one of the following:
+*
+* -   'none': none, return immediately
+* -   'permutate': permute only
+* -   'scale': scale only
+* -   'both': both permute and scale
+*
+* The matrix `A` is overwritten by the balanced matrix. Scale factors are stored in the `scale` array.
+*
+* @private
+* @param {string} job - indicates the operations to be performed
+* @param {NonNegativeInteger} N - number of rows/columns in matrix `A`
+* @param {Float64Array} A - input matrix to be balanced
+* @param {integer} strideA1 - stride of the first dimension of `A`
+* @param {integer} strideA2 - stride of the second dimension of `A`
+* @param {NonNegativeInteger} offsetA - starting index for `A`
+* @param {Float64Array} out - stores the first and last row/column of the balanced submatrix
+* @param {integer} strideOut - stride of `out`
+* @param {NonNegativeInteger} offsetOut - starting index for `out`
+* @param {Float64Array} scale - array containing permutation and scaling information
+* @param {integer} strideScale - stride of `scale`
+* @param {NonNegativeInteger} offsetScale  - starting index for `scale`
+* @returns {integer} status code
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var A = new Float64Array( [ 1.0, 100.0, 0.0, 2.0, 200.0, 0.0, 0.0, 0.0, 3.0 ] );
+* var out = new Float64Array( 2 );
+* var scale = new Float64Array( 3 );
+*
+* dgebal( 'both', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 0 );
+* // A => <Float64Array>[ 1, 12.5, 0, 16, 200, 0, 0, 0, 3 ]
+* // out => <Float64Array>[ 0, 1 ]
+* // scale => <Float64Array>[ 8, 1, 2 ]
+*/
+function dgebal( job, N, A, strideA1, strideA2, offsetA, out, strideOut, offsetOut, scale, strideScale, offsetScale ) {
+	var canSwap;
+	var noconv;
+	var sfmin1;
+	var sfmin2;
+	var sfmax1;
+	var sfmax2;
+	var sclfac;
+	var factor;
+	var ica;
+	var ira;
+	var ca;
+	var ra;
+	var is;
+	var c;
+	var r;
+	var k;
+	var l;
+	var i;
+	var j;
+	var g;
+	var f;
+	var s;
+
+	sclfac = 2.0;
+	factor = 0.95;
+
+	// Quick return if possible
+	if ( N === 0 ) {
+		out[ offsetOut ] = 0.0; // ilo
+		out[ offsetOut + strideOut ] = -1.0; // ihi (invalid)
+		return 0;
+	}
+
+	if ( job === 'none' ) {
+		is = offsetScale;
+		for ( i = 0; i < N; i++ ) {
+			scale[ is ] = 1.0;
+			is += strideScale;
+		}
+
+		out[ offsetOut ] = 0.0; // ilo
+		out[ offsetOut + strideOut ] = N - 1; // ihi
+		return 0;
+	}
+
+	// Permutation to isolate eigenvalues if possible
+	k = 0;
+	l = N - 1;
+
+	if ( job !== 'scale' ) {
+		// Row and column exchange
+		noconv = true;
+		while ( noconv ) {
+			// Search for rows isolating an eigenvalue and push them down
+			noconv = false;
+			for ( i = l; i >= 0; i-- ) {
+				canSwap = true;
+				for ( j = 0; j <= l; j++ ) {
+					if ( i !== j && A[ offsetA + (i*strideA1) + (j*strideA2) ] !== 0.0 ) {
+						canSwap = false;
+						break;
+					}
+				}
+
+				if ( canSwap ) {
+					scale[ offsetScale + (l*strideScale) ] = i;
+					if ( i !== l ) {
+						dswap( l+1, A, strideA1, offsetA + (i*strideA2), A, strideA1, offsetA + (l*strideA2) );
+						dswap( N - k, A, strideA2, offsetA + (i*strideA1) + (k*strideA2), A, strideA2, offsetA + (l*strideA1) + (k*strideA2) );
+					}
+					noconv = true;
+
+					// Check if remaining submatrix is empty and return
+					if ( l === 0.0 ) {
+						out[ offsetOut ] = 0.0; // ilo
+						out[ offsetOut + strideOut ] = 0.0; // ihi
+						return 0;
+					}
+					l -= 1;
+				}
+			}
+		}
+
+		noconv = true;
+		while ( noconv ) {
+			// Search for columns isolating an eigenvalue and push them left
+			noconv = false;
+			for ( j = k; j <= l; j++ ) {
+				canSwap = true;
+				for ( i = k; i <= l; i++ ) {
+					if ( i !== j && A[ offsetA + (i*strideA1) + (j*strideA2) ] !== 0.0 ) {
+						canSwap = false;
+						break;
+					}
+				}
+
+				if ( canSwap ) {
+					scale[ offsetScale + (k*strideScale) ] = j;
+					if ( j !== k ) {
+						dswap( l+1, A, strideA1, offsetA + (j*strideA2), A, strideA1, offsetA + (k*strideA2) );
+						dswap( N-k, A, strideA2, offsetA + (j*strideA1), A, strideA2, offsetA + (k*strideA1) );
+					}
+					noconv = true;
+					k += 1;
+				}
+			}
+		}
+	}
+
+	// Initialize `scale` for non-permuted submatrix
+	is = offsetScale + (k*strideScale);
+	for ( i = k; i <= l; i++ ) {
+		scale[ is ] = 1.0;
+		is += strideScale;
+	}
+
+	if ( job === 'permutate' ) {
+		out[ offsetOut ] = k; // ilo
+		out[ offsetOut + strideOut ] = l; // ihi
+		return 0;
+	}
+
+	// Balance the submatrix in rows K to L, iterative loop for norm reduction (job = 'B')
+	sfmin1 = dlamch( 'S' ) / dlamch( 'P' );
+	sfmax1 = 1.0 / sfmin1;
+	sfmin2 = sfmin1 * sclfac;
+	sfmax2 = 1.0 / sfmin2;
+
+	noconv = true;
+	while ( noconv ) {
+		noconv = false;
+		for ( i = k; i <= l; i++ ) {
+			c = dnrm2( l-k+1, A, strideA1, offsetA + (k*strideA1) + (i*strideA2) );
+			r = dnrm2( l-k+1, A, strideA2, offsetA + (i*strideA1) + (k*strideA2) );
+			ica = idamax( l+1, A, strideA1, offsetA + (i*strideA2) );
+			ca = abs( A[ offsetA + (ica*strideA1) + (i*strideA2) ] );
+			ira = idamax( N-k+1, A, strideA2, offsetA + (i*strideA1) + (k*strideA2) );
+			ra = abs( A[ offsetA + (i*strideA1) + ((ira+k)*strideA2) ] );
+
+			if ( c === 0.0 || r === 0.0 ) {
+				continue;
+			}
+
+			if ( isnan( c ) || isnan( r ) || isnan( ca ) || isnan( ra ) ) {
+				return -3;
+			}
+
+			g = r / sclfac;
+			f = 1.0;
+			s = c + r;
+
+			while ( c < g && max( f, c, ca ) < sfmax2 && min( r, g, ra ) > sfmin2 ) {
+				f *= sclfac;
+				c *= sclfac;
+				ca *= sclfac;
+				r /= sclfac;
+				g /= sclfac;
+				ra /= sclfac;
+			}
+
+			g = c / sclfac;
+
+			while ( g >= r && max( r, ra ) < sfmax2 && min( f, c, g, ca ) > sfmin2 ) {
+				f /= sclfac;
+				c /= sclfac;
+				g /= sclfac;
+				ca /= sclfac;
+				r *= sclfac;
+				ra *= sclfac;
+			}
+
+			// Now balance
+			if ( ( c + r ) >= factor * s ) {
+				continue;
+			}
+
+			if ( f < 1.0 && scale[ offsetScale + (i*strideScale) ] < 1.0 ) {
+				if ( f * scale[ offsetScale + (i*strideScale) ] <= sfmin1 ) {
+					continue;
+				}
+			}
+
+			if ( f > 1.0 && scale[ offsetScale + (i*strideScale) ] > 1.0 ) {
+				if ( scale[ offsetScale + (i*strideScale) ] >= sfmax1 / f ) {
+					continue;
+				}
+			}
+
+			g = 1.0 / f;
+			scale[ offsetScale + (i*strideScale) ] *= f;
+			noconv = true;
+
+			dscal( N-k, g, A, strideA2, offsetA + (i*strideA1) + (k*strideA2) );
+			dscal( l+1, f, A, strideA1, offsetA + (i*strideA2) );
+		}
+	}
+
+	out[ offsetOut ] = k; // ilo
+	out[ offsetOut + strideOut ] = l; // ihi
+	return 0;
+}
+
+
+// EXPORTS //
+
+module.exports = dgebal;
diff --git a/lib/node_modules/@stdlib/lapack/base/dgebal/lib/dgebal.js b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/dgebal.js
new file mode 100644
index 000000000000..a5506edd5b38
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/dgebal.js
@@ -0,0 +1,96 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var 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 //
+
+/**
+* Balances a general real matrix `A`.
+*
+* ## Notes
+*
+* The job parameter can be one of the following:
+*
+* -   'none': none, return immediately
+* -   'permutate': permute only
+* -   'scale': scale only
+* -   'both': both permute and scale
+* -   The matrix `A` is overwritten by the balanced matrix.
+*
+* @private
+* @param {string} order - storage layout of `A`
+* @param {string} job - indicates the operations to be performed
+* @param {NonNegativeInteger} N - number of rows/columns in matrix `A`
+* @param {Float64Array} A - input matrix to be balanced
+* @param {NonNegativeInteger} LDA - leading dimension of `A`
+* @param {Float64Array} out - stores the first and last row/column of the balanced submatrix
+* @param {Float64Array} scale - array containing permutation and scaling information
+* @throws {TypeError} first argument must be a valid order
+* @throws {TypeError} second argument must be a valid job
+* @throws {RangeError} fifth argument must be greater than or equal to `N`
+* @returns {integer} status code
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var A = new Float64Array( [ 1.0, 100.0, 0.0, 2.0, 200.0, 0.0, 0.0, 0.0, 3.0 ] );
+* var out = new Float64Array( 2 );
+* var scale = new Float64Array( 3 );
+*
+* dgebal( 'row-major', 'both', 3, A, 3, out, scale );
+* // A => <Float64Array>[ 1, 12.5, 0, 16, 200, 0, 0, 0, 3 ]
+* // out => <Float64Array>[ 0, 1 ]
+* // scale => <Float64Array>[ 8, 1, 2 ]
+*/
+function dgebal( order, job, N, A, LDA, out, scale ) {
+	var sa1;
+	var sa2;
+
+	if ( !isLayout( order ) ) {
+		throw new TypeError( format( 'invalid argument. First argument must be a valid order. Value: `%s`.', order ) );
+	}
+	if ( job !== 'both' && job !== 'scale' && job !== 'permutate' && job !== 'none' ) {
+		throw new TypeError( format( 'invalid argument. Second argument must be one of the following: `both`, `scale`, `permutate`, or `none`. Value: `%s`.', job ) );
+	}
+	if ( isColumnMajor( order ) ) {
+		sa1 = 1;
+		sa2 = LDA;
+	} else { // order === 'row-major'
+		if ( LDA < N ) {
+			throw new RangeError( format( 'invalid argument. Eighth argument must be greater than or equal to %d. Value: `%d`.', N, LDA ) );
+		}
+		sa1 = LDA;
+		sa2 = 1;
+	}
+
+	return base( job, N, A, sa1, sa2, 0, out, 1, 0, scale, 1, 0 );
+}
+
+
+// EXPORTS //
+
+module.exports = dgebal;
diff --git a/lib/node_modules/@stdlib/lapack/base/dgebal/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/index.js
new file mode 100644
index 000000000000..75b2826b6ba8
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/index.js
@@ -0,0 +1,76 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+/**
+* LAPACK routine to balance a general real matrix `A`.
+*
+* @module @stdlib/lapack/base/dgebal
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var dgebal = require( '@stdlib/lapack/base/dgebal' );
+*
+* var A = new Float64Array( [ 1.0, 100.0, 0.0, 2.0, 200.0, 0.0, 0.0, 0.0, 3.0 ] );
+* var out = new Float64Array( 2 );
+* var scale = new Float64Array( 3 );
+*
+* dgebal( 'row-major', 'both', 3, A, 3, out, scale );
+* // A => <Float64Array>[ 1, 12.5, 0, 16, 200, 0, 0, 0, 3 ]
+* // out => <Float64Array>[ 0, 1 ]
+* // scale => <Float64Array>[ 8, 1, 2 ]
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var dgebal = require( '@stdlib/lapack/base/dgebal' );
+*
+* var A = new Float64Array( [ 1.0, 100.0, 0.0, 2.0, 200.0, 0.0, 0.0, 0.0, 3.0 ] );
+* var out = new Float64Array( 2 );
+* var scale = new Float64Array( 3 );
+*
+* dgebal.ndarray( 'both', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 0 );
+* // A => <Float64Array>[ 1, 12.5, 0, 16, 200, 0, 0, 0, 3 ]
+* // out => <Float64Array>[ 0, 1 ]
+* // scale => <Float64Array>[ 8, 1, 2 ]
+*/
+
+// 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 dgebal;
+var tmp = tryRequire( join( __dirname, './native.js' ) );
+if ( isError( tmp ) ) {
+	dgebal = main;
+} else {
+	dgebal = tmp;
+}
+
+
+// EXPORTS //
+
+module.exports = dgebal;
+
+// exports: { "ndarray": "dgebal.ndarray" }
diff --git a/lib/node_modules/@stdlib/lapack/base/dgebal/lib/main.js b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/main.js
new file mode 100644
index 000000000000..b9c15110c92a
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/main.js
@@ -0,0 +1,35 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var dgebal = require( './dgebal.js' );
+var ndarray = require( './ndarray.js' );
+
+
+// MAIN //
+
+setReadOnly( dgebal, 'ndarray', ndarray );
+
+
+// EXPORTS //
+
+module.exports = dgebal;
diff --git a/lib/node_modules/@stdlib/lapack/base/dgebal/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/ndarray.js
new file mode 100644
index 000000000000..e05576f03767
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/ndarray.js
@@ -0,0 +1,80 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var format = require( '@stdlib/string/format' );
+var base = require( './base.js' );
+
+
+// MAIN //
+
+/**
+* Balances a general real matrix `A` using alternative indexing semantics.
+*
+* ## Notes
+*
+* The job parameter can be one of the following:
+*
+* -   'none': none, return immediately
+* -   'permutate': permute only
+* -   'scale': scale only
+* -   'both': both permute and scale
+* -   The matrix `A` is overwritten by the balanced matrix.
+*
+* @private
+* @param {string} job - indicates the operations to be performed
+* @param {NonNegativeInteger} N - number of rows/columns in matrix `A`
+* @param {Float64Array} A - input matrix to be balanced
+* @param {integer} strideA1 - stride of the first dimension of `A`
+* @param {integer} strideA2 - stride of the second dimension of `A`
+* @param {NonNegativeInteger} offsetA - starting index for `A`
+* @param {Float64Array} out - stores the first and last row/column of the balanced submatrix
+* @param {integer} strideOut - stride of `out`
+* @param {NonNegativeInteger} offsetOut - starting index for `out`
+* @param {Float64Array} scale - array containing permutation and scaling information
+* @param {integer} strideScale - stride of `scale`
+* @param {NonNegativeInteger} offsetScale  - starting index for `scale`
+* @throws {TypeError} second argument must be a valid job
+* @returns {integer} status code
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var A = new Float64Array( [ 1.0, 100.0, 0.0, 2.0, 200.0, 0.0, 0.0, 0.0, 3.0 ] );
+* var out = new Float64Array( 2 );
+* var scale = new Float64Array( 3 );
+*
+* dgebal( 'both', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 0 );
+* // A => <Float64Array>[ 1, 12.5, 0, 16, 200, 0, 0, 0, 3 ]
+* // out => <Float64Array>[ 0, 1 ]
+* // scale => <Float64Array>[ 8, 1, 2 ]
+*/
+function dgebal( job, N, A, strideA1, strideA2, offsetA, out, strideOut, offsetOut, scale, strideScale, offsetScale ) { // eslint-disable-line max-len, max-params
+	if ( job !== 'both' && job !== 'scale' && job !== 'permutate' && job !== 'none' ) {
+		throw new TypeError( format( 'invalid argument. Second argument must be one of the following: `both`, `scale`, `permutate`, or `none`. Value: `%s`.', job ) );
+	}
+	return base( job, N, A, strideA1, strideA2, offsetA, out, strideOut, offsetOut, scale, strideScale, offsetScale ); // eslint-disable-line max-len
+}
+
+
+// EXPORTS //
+
+module.exports = dgebal;
diff --git a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js
new file mode 100644
index 000000000000..da614f6e9668
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js
@@ -0,0 +1,747 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/* eslint-disable array-element-newline */
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var Float64Array = require( '@stdlib/array/float64' );
+var dgebal = require( './../lib/dgebal.js' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof dgebal, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 7', function test( t ) {
+	t.strictEqual( dgebal.length, 7, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function throws an error if provided an invalid first argument', function test( t ) {
+	var values;
+	var scale;
+	var out;
+	var A;
+	var i;
+
+	values = [
+		'foo',
+		'bar',
+		'beep',
+		'boop'
+	];
+
+	A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 2 );
+
+	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() {
+			dgebal( value, 'both', 2, A, 2, out, scale );
+		};
+	}
+});
+
+tape( 'the function throws an error if provided an invalid second argument', function test( t ) {
+	var values;
+	var scale;
+	var out;
+	var A;
+	var i;
+
+	values = [
+		'foo',
+		'bar',
+		'beep',
+		'boop'
+	];
+
+	A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 2 );
+
+	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() {
+			dgebal( 'row-major', value, 2, A, 2, out, scale );
+		};
+	}
+});
+
+tape( 'the function throws an error if provided an invalid second argument', function test( t ) {
+	var values;
+	var scale;
+	var out;
+	var A;
+	var i;
+
+	values = [
+		0,
+		1
+	];
+
+	A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 2 );
+
+	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() {
+			dgebal( 'row-major', 'both', 2, A, value, out, scale );
+		};
+	}
+});
+
+tape( 'the function returns invalid indices and leaves the input array unchanged for N = 0', function test( t ) {
+	var expectedOut;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 2 );
+
+	info = dgebal( 'row-major', 'both', 0, A, 2, out, scale );
+
+	expectedOut = new Float64Array( [ 0.0, -1.0 ] );
+
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = none (row-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 2.0, 3.0,
+		4.0, 5.0, 6.0,
+		7.0, 8.0, 9.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 2.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1.0, 1.0 ] );
+	expectedA = new Float64Array([
+		1.0, 2.0, 3.0,
+		4.0, 5.0, 6.0,
+		7.0, 8.0, 9.0
+	]);
+
+	info = dgebal( 'row-major', 'none', 3, A, 3, out, scale );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = none (column-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 4.0, 7.0,
+		2.0, 5.0, 8.0,
+		3.0, 6.0, 9.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 2.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1.0, 1.0 ] );
+	expectedA = new Float64Array([
+		1.0, 4.0, 7.0,
+		2.0, 5.0, 8.0,
+		3.0, 6.0, 9.0
+	]);
+
+	info = dgebal( 'column-major', 'none', 3, A, 3, out, scale );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = permutate (row-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 0.0, 2.0,
+		0.0, 5.0, 0.0,
+		3.0, 0.0, 4.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 1.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1.0, 1.0 ] );
+	expectedA = new Float64Array([
+		1.0, 2.0, 0.0,
+		3.0, 4.0, 0.0,
+		0.0, 0.0, 5.0
+	]);
+
+	info = dgebal( 'row-major', 'permutate', 3, A, 3, out, scale );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = permutate (column-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 0.0, 3.0,
+		0.0, 5.0, 0.0,
+		2.0, 0.0, 4.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 1.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1.0, 1.0 ] );
+	expectedA = new Float64Array([
+		1.0, 3.0, 0.0,
+		2.0, 4.0, 0.0,
+		0.0, 0.0, 5.0
+	]);
+
+	info = dgebal( 'column-major', 'permutate', 3, A, 3, out, scale );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = scale (row-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		16.0, 16.0, 16.0,
+		0.25, 0.25, 0.25,
+		0.25, 0.25, 0.25
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 2.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 0.125, 0.125 ] );
+	expectedA = new Float64Array([
+		16.0, 2.0, 2.0,
+		2.0, 0.25, 0.25,
+		2.0, 0.25, 0.25
+	]);
+
+	info = dgebal( 'row-major', 'scale', 3, A, 3, out, scale );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = scale (column-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		16.0, 0.25, 0.25,
+		16.0, 0.25, 0.25,
+		16.0, 0.25, 0.25
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 2.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 0.125, 0.125 ] );
+	expectedA = new Float64Array([
+		16.0, 2.0, 2.0,
+		2.0, 0.25, 0.25,
+		2.0, 0.25, 0.25
+	]);
+
+	info = dgebal( 'column-major', 'scale', 3, A, 3, out, scale );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both (row-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 0.0, 2.0,
+		0.0, 5.0, 0.0,
+		100.0, 0.0, 4.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 1.0 ] );
+	expectedScale = new Float64Array( [ 0.125, 1.0, 1.0 ] );
+	expectedA = new Float64Array([
+		1.0, 16.0, 0.0,
+		12.5, 4.0, 0.0,
+		0.0, 0.0, 5.0
+	]);
+
+	info = dgebal( 'row-major', 'both', 3, A, 3, out, scale );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both (column-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 0.0, 100.0,
+		0.0, 5.0, 0.0,
+		2.0, 0.0, 4.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 1.0 ] );
+	expectedScale = new Float64Array( [ 0.125, 1.0, 1.0 ] );
+	expectedA = new Float64Array([
+		1.0, 12.5, 0.0,
+		16.0, 4.0, 0.0,
+		0.0, 0.0, 5.0
+	]);
+
+	info = dgebal( 'column-major', 'both', 3, A, 3, out, scale );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both with complex input (row-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 1.0, 0.0,
+		0.0, 2.0, 0.0,
+		0.0, 0.0, 3.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 0.0 ] );
+	expectedScale = new Float64Array( [ 0.0, 1.0, 2.0 ] );
+	expectedA = new Float64Array([
+		1.0, 1.0, 0.0,
+		0.0, 2.0, 0.0,
+		0.0, 0.0, 3.0
+	]);
+
+	info = dgebal( 'row-major', 'both', 3, A, 3, out, scale );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both with complex input (column-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 0.0, 0.0,
+		1.0, 2.0, 0.0,
+		0.0, 0.0, 3.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 0.0 ] );
+	expectedScale = new Float64Array( [ 0.0, 1.0, 2.0 ] );
+	expectedA = new Float64Array([
+		1.0, 0.0, 0.0,
+		1.0, 2.0, 0.0,
+		0.0, 0.0, 3.0
+	]);
+
+	info = dgebal( 'column-major', 'both', 3, A, 3, out, scale );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both with complex input (row-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 0.0, 2.0,
+		3.0, 4.0, 5.0,
+		6.0, 0.0, 7.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 1.0, 2.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 0.5, 1.0 ] );
+	expectedA = new Float64Array([
+		4.0, 1.5, 5.0,
+		0.0, 1.0, 4.0,
+		0.0, 3.0, 7.0
+	]);
+
+	info = dgebal( 'row-major', 'both', 3, A, 3, out, scale );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both with complex input (column-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 3.0, 6.0,
+		0.0, 4.0, 0.0,
+		2.0, 5.0, 7.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 1.0, 2.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 0.5, 1.0 ] );
+	expectedA = new Float64Array([
+		4.0, 0.0, 0.0,
+		1.5, 1.0, 3.0,
+		5.0, 4.0, 7.0
+	]);
+
+	info = dgebal( 'column-major', 'both', 3, A, 3, out, scale );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = scale with zero norm (row-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 0.0, 4.0,
+		2.0, 0.0, 5.0,
+		3.0, 0.0, 6.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 2.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1.0, 1.0 ] );
+	expectedA = new Float64Array([
+		1.0, 0.0, 4.0,
+		2.0, 0.0, 5.0,
+		3.0, 0.0, 6.0
+	]);
+
+	info = dgebal( 'row-major', 'scale', 3, A, 3, out, scale );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = scale with zero norm (column-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 2.0, 3.0,
+		0.0, 0.0, 0.0,
+		4.0, 5.0, 6.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 2.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1.0, 1.0 ] );
+	expectedA = new Float64Array([
+		1.0, 2.0, 3.0,
+		0.0, 0.0, 0.0,
+		4.0, 5.0, 6.0
+	]);
+
+	info = dgebal( 'column-major', 'scale', 3, A, 3, out, scale );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = scale with small values (row-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0e-4, 1.0, 2.0, 1.0e4,
+		2.0e-4, 1.0, 2.0, 2.0e4,
+		3.0e-4, 1.0, 2.0, 3.0e4,
+		4.0e-4, 1.0, 2.0, 4.0e4
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 4 );
+
+	expectedOut = new Float64Array( [ 0.0, 3.0 ] );
+	expectedScale = new Float64Array( [ 4096.0, 128.0, 128.0, 1.0 ] );
+	expectedA = new Float64Array([
+		1.0e-4, 3.125e-2, 6.25e-2, 2.44140625,
+		6.4e-3, 1.0, 2.0, 1.5625e+2,
+		9.6e-3, 1.0, 2.0, 2.34375e+2,
+		1.6384, 1.28e+2, 2.56e+2, 4.0e+4
+	]);
+
+	info = dgebal( 'row-major', 'scale', 4, A, 4, out, scale );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = scale with small values (column-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0e-4, 2.0e-4, 3.0e-4, 4.0e-4,
+		1.0, 1.0, 1.0, 1.0,
+		2.0, 2.0, 2.0, 2.0,
+		1.0e4, 2.0e4, 3.0e4, 4.0e4
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 4 );
+
+	expectedOut = new Float64Array( [ 0.0, 3.0 ] );
+	expectedScale = new Float64Array( [ 4096.0, 128.0, 128.0, 1.0 ] );
+	expectedA = new Float64Array([
+		1.0e-4, 6.4e-3, 9.6e-3, 1.6384,
+		3.125e-2, 1.0, 1.0, 1.28e+2,
+		6.25e-2, 2.0, 2.0, 2.56e+2,
+		2.44140625, 1.5625e+2, 2.34375e+2, 4.0e+4
+	]);
+
+	info = dgebal( 'column-major', 'scale', 4, A, 4, out, scale );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both with large values (row-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0e30, 1.0, 1.0e-30,
+		1.0e30, 1.0, 1.0e-30,
+		1.0e30, 1.0, 1.0e-30
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 2.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1125899906842624.0, 1.2676506002282294e+30 ] ); // eslint-disable-line max-len
+	expectedA = new Float64Array([
+		1.0e30, 1.1258999068426240e15, 1.2676506002282295,
+		8.8817841970012525e14, 1.0, 1.1258999068426241e-15,
+		7.8886090522101182e-1, 8.8817841970012523e-16, 1.0e-30
+	]);
+
+	info = dgebal( 'row-major', 'both', 3, A, 3, out, scale );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both with large values (column-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0e30, 1.0e30, 1.0e30,
+		1.0, 1.0, 1.0,
+		1.0e-30, 1.0e-30, 1.0e-30
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 2.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1125899906842624.0, 1.2676506002282294e+30 ] ); // eslint-disable-line max-len
+	expectedA = new Float64Array([
+		1.0e30, 8.8817841970012525e14, 7.8886090522101182e-1,
+		1.1258999068426240e15, 1.0, 8.8817841970012523e-16,
+		1.2676506002282295, 1.1258999068426241e-15, 1.0e-30
+	]);
+
+	info = dgebal( 'column-major', 'both', 3, A, 3, out, scale );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.js b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.js
new file mode 100644
index 000000000000..f22291acb9fc
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.js
@@ -0,0 +1,82 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var proxyquire = require( 'proxyquire' );
+var IS_BROWSER = require( '@stdlib/assert/is-browser' );
+var dgebal = 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 dgebal, '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 dgebal.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 dgebal = proxyquire( './../lib', {
+		'@stdlib/utils/try-require': tryRequire
+	});
+
+	t.strictEqual( dgebal, 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 dgebal;
+	var main;
+
+	main = require( './../lib/dgebal.js' );
+
+	dgebal = proxyquire( './../lib', {
+		'@stdlib/utils/try-require': tryRequire
+	});
+
+	t.strictEqual( dgebal, main, 'returns expected value' );
+	t.end();
+
+	function tryRequire() {
+		return new Error( 'Cannot find module' );
+	}
+});
diff --git a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js
new file mode 100644
index 000000000000..c348f6ea25c5
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js
@@ -0,0 +1,1251 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/* eslint-disable array-element-newline, max-lines */
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var Float64Array = require( '@stdlib/array/float64' );
+var dgebal = require( './../lib/ndarray.js' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof dgebal, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 12', function test( t ) {
+	t.strictEqual( dgebal.length, 12, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function throws an error if provided an invalid first argument', function test( t ) {
+	var values;
+	var scale;
+	var out;
+	var A;
+	var i;
+
+	values = [
+		'foo',
+		'bar',
+		'beep',
+		'boop'
+	];
+
+	A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 2 );
+
+	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() {
+			dgebal( value, 2, A, 2, 1, 0, out, 1, 0, scale, 1, 0 );
+		};
+	}
+});
+
+tape( 'the function returns invalid indices and leaves the input array unchanged for none = 0', function test( t ) {
+	var expectedOut;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 2 );
+
+	info = dgebal( 'both', 0, A, 2, 1, 0, out, 1, 0, scale, 1, 0 );
+
+	expectedOut = new Float64Array( [ 0.0, -1.0 ] );
+
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = none (row-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 2.0, 3.0,
+		4.0, 5.0, 6.0,
+		7.0, 8.0, 9.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 2.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1.0, 1.0 ] );
+	expectedA = new Float64Array([
+		1.0, 2.0, 3.0,
+		4.0, 5.0, 6.0,
+		7.0, 8.0, 9.0
+	]);
+
+	info = dgebal( 'none', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 0 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = none (column-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 4.0, 7.0,
+		2.0, 5.0, 8.0,
+		3.0, 6.0, 9.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 2.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1.0, 1.0 ] );
+	expectedA = new Float64Array([
+		1.0, 4.0, 7.0,
+		2.0, 5.0, 8.0,
+		3.0, 6.0, 9.0
+	]);
+
+	info = dgebal( 'both', 3, A, 1, 3, 0, out, 1, 0, scale, 1, 0 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = permutate (row-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 0.0, 2.0,
+		0.0, 5.0, 0.0,
+		3.0, 0.0, 4.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 1.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1.0, 1.0 ] );
+	expectedA = new Float64Array([
+		1.0, 2.0, 0.0,
+		3.0, 4.0, 0.0,
+		0.0, 0.0, 5.0
+	]);
+
+	info = dgebal( 'permutate', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 0 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = permutate (column-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 0.0, 3.0,
+		0.0, 5.0, 0.0,
+		2.0, 0.0, 4.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 1.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1.0, 1.0 ] );
+	expectedA = new Float64Array([
+		1.0, 3.0, 0.0,
+		2.0, 4.0, 0.0,
+		0.0, 0.0, 5.0
+	]);
+
+	info = dgebal( 'both', 3, A, 1, 3, 0, out, 1, 0, scale, 1, 0 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = scale (row-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		16.0, 16.0, 16.0,
+		0.25, 0.25, 0.25,
+		0.25, 0.25, 0.25
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 2.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 0.125, 0.125 ] );
+	expectedA = new Float64Array([
+		16.0, 2.0, 2.0,
+		2.0, 0.25, 0.25,
+		2.0, 0.25, 0.25
+	]);
+
+	info = dgebal( 'scale', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 0 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = scale (column-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		16.0, 0.25, 0.25,
+		16.0, 0.25, 0.25,
+		16.0, 0.25, 0.25
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 2.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 0.125, 0.125 ] );
+	expectedA = new Float64Array([
+		16.0, 2.0, 2.0,
+		2.0, 0.25, 0.25,
+		2.0, 0.25, 0.25
+	]);
+
+	info = dgebal( 'scale', 3, A, 1, 3, 0, out, 1, 0, scale, 1, 0 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both (row-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 0.0, 2.0,
+		0.0, 5.0, 0.0,
+		100.0, 0.0, 4.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 1.0 ] );
+	expectedScale = new Float64Array( [ 0.125, 1.0, 1.0 ] );
+	expectedA = new Float64Array([
+		1.0, 16.0, 0.0,
+		12.5, 4.0, 0.0,
+		0.0, 0.0, 5.0
+	]);
+
+	info = dgebal( 'both', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 0 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both (column-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 0.0, 100.0,
+		0.0, 5.0, 0.0,
+		2.0, 0.0, 4.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 1.0 ] );
+	expectedScale = new Float64Array( [ 0.125, 1.0, 1.0 ] );
+	expectedA = new Float64Array([
+		1.0, 12.5, 0.0,
+		16.0, 4.0, 0.0,
+		0.0, 0.0, 5.0
+	]);
+
+	info = dgebal( 'both', 3, A, 1, 3, 0, out, 1, 0, scale, 1, 0 );
+
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both with complex input (row-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 1.0, 0.0,
+		0.0, 2.0, 0.0,
+		0.0, 0.0, 3.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 0.0 ] );
+	expectedScale = new Float64Array( [ 0.0, 1.0, 2.0 ] );
+	expectedA = new Float64Array([
+		1.0, 1.0, 0.0,
+		0.0, 2.0, 0.0,
+		0.0, 0.0, 3.0
+	]);
+
+	info = dgebal( 'both', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 0 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both with complex input (column-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 0.0, 0.0,
+		1.0, 2.0, 0.0,
+		0.0, 0.0, 3.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 0.0 ] );
+	expectedScale = new Float64Array( [ 0.0, 1.0, 2.0 ] );
+	expectedA = new Float64Array([
+		1.0, 0.0, 0.0,
+		1.0, 2.0, 0.0,
+		0.0, 0.0, 3.0
+	]);
+
+	info = dgebal( 'both', 3, A, 1, 3, 0, out, 1, 0, scale, 1, 0 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both with complex input (row-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 0.0, 2.0,
+		3.0, 4.0, 5.0,
+		6.0, 0.0, 7.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 1.0, 2.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 0.5, 1.0 ] );
+	expectedA = new Float64Array([
+		4.0, 1.5, 5.0,
+		0.0, 1.0, 4.0,
+		0.0, 3.0, 7.0
+	]);
+
+	info = dgebal( 'both', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 0 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both with complex input (column-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 3.0, 6.0,
+		0.0, 4.0, 0.0,
+		2.0, 5.0, 7.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 1.0, 2.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 0.5, 1.0 ] );
+	expectedA = new Float64Array([
+		4.0, 0.0, 0.0,
+		1.5, 1.0, 3.0,
+		5.0, 4.0, 7.0
+	]);
+
+	info = dgebal( 'both', 3, A, 1, 3, 0, out, 1, 0, scale, 1, 0 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = scale with zero norm (row-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 0.0, 4.0,
+		2.0, 0.0, 5.0,
+		3.0, 0.0, 6.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 2.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1.0, 1.0 ] );
+	expectedA = new Float64Array([
+		1.0, 0.0, 4.0,
+		2.0, 0.0, 5.0,
+		3.0, 0.0, 6.0
+	]);
+
+	info = dgebal( 'scale', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 0 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = scale with zero norm (column-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 2.0, 3.0,
+		0.0, 0.0, 0.0,
+		4.0, 5.0, 6.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 2.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1.0, 1.0 ] );
+	expectedA = new Float64Array([
+		1.0, 2.0, 3.0,
+		0.0, 0.0, 0.0,
+		4.0, 5.0, 6.0
+	]);
+
+	info = dgebal( 'scale', 3, A, 1, 3, 0, out, 1, 0, scale, 1, 0 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = scale with small values (row-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0e-4, 1.0, 2.0, 1.0e4,
+		2.0e-4, 1.0, 2.0, 2.0e4,
+		3.0e-4, 1.0, 2.0, 3.0e4,
+		4.0e-4, 1.0, 2.0, 4.0e4
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 4 );
+
+	expectedOut = new Float64Array( [ 0.0, 3.0 ] );
+	expectedScale = new Float64Array( [ 4096.0, 128.0, 128.0, 1.0 ] );
+	expectedA = new Float64Array([
+		1.0e-4, 3.125e-2, 6.25e-2, 2.44140625,
+		6.4e-3, 1.0, 2.0, 1.5625e+2,
+		9.6e-3, 1.0, 2.0, 2.34375e+2,
+		1.6384, 1.28e+2, 2.56e+2, 4.0e+4
+	]);
+
+	info = dgebal( 'scale', 4, A, 4, 1, 0, out, 1, 0, scale, 1, 0 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = scale with small values (column-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0e-4, 2.0e-4, 3.0e-4, 4.0e-4,
+		1.0, 1.0, 1.0, 1.0,
+		2.0, 2.0, 2.0, 2.0,
+		1.0e4, 2.0e4, 3.0e4, 4.0e4
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 4 );
+
+	expectedOut = new Float64Array( [ 0.0, 3.0 ] );
+	expectedScale = new Float64Array( [ 4096.0, 128.0, 128.0, 1.0 ] );
+	expectedA = new Float64Array([
+		1.0e-4, 6.4e-3, 9.6e-3, 1.6384,
+		3.125e-2, 1.0, 1.0, 1.28e+2,
+		6.25e-2, 2.0, 2.0, 2.56e+2,
+		2.44140625, 1.5625e+2, 2.34375e+2, 4.0e+4
+	]);
+
+	info = dgebal( 'scale', 4, A, 1, 4, 0, out, 1, 0, scale, 1, 0 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both with large values (row-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0e30, 1.0, 1.0e-30,
+		1.0e30, 1.0, 1.0e-30,
+		1.0e30, 1.0, 1.0e-30
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 2.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1125899906842624.0, 1.2676506002282294e+30 ] ); // eslint-disable-line max-len
+	expectedA = new Float64Array([
+		1.0e30, 1.1258999068426240e15, 1.2676506002282295,
+		8.8817841970012525e14, 1.0, 1.1258999068426241e-15,
+		7.8886090522101182e-1, 8.8817841970012523e-16, 1.0e-30
+	]);
+
+	info = dgebal( 'both', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 0 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both with large values (column-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0e30, 1.0e30, 1.0e30,
+		1.0, 1.0, 1.0,
+		1.0e-30, 1.0e-30, 1.0e-30
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 2.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1125899906842624.0, 1.2676506002282294e+30 ] ); // eslint-disable-line max-len
+	expectedA = new Float64Array([
+		1.0e30, 8.8817841970012525e14, 7.8886090522101182e-1,
+		1.1258999068426240e15, 1.0, 8.8817841970012523e-16,
+		1.2676506002282295, 1.1258999068426241e-15, 1.0e-30
+	]);
+
+	info = dgebal( 'both', 3, A, 1, 3, 0, out, 1, 0, scale, 1, 0 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = none (row-major) (negative strides)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		9.0, 8.0, 7.0,
+		6.0, 5.0, 4.0,
+		3.0, 2.0, 1.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 2.0, 0.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1.0, 1.0 ] );
+	expectedA = new Float64Array([
+		9.0, 8.0, 7.0,
+		6.0, 5.0, 4.0,
+		3.0, 2.0, 1.0
+	]);
+
+	info = dgebal( 'none', 3, A, -3, -1, 8, out, -1, 1, scale, -1, 2 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = none (column-major) (negative strides)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		9.0, 6.0, 3.0,
+		8.0, 5.0, 2.0,
+		7.0, 4.0, 1.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 2.0, 0.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1.0, 1.0 ] );
+	expectedA = new Float64Array([
+		9.0, 6.0, 3.0,
+		8.0, 5.0, 2.0,
+		7.0, 4.0, 1.0
+	]);
+
+	info = dgebal( 'both', 3, A, -1, -3, 8, out, -1, 1, scale, -1, 2 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = permutate (row-major) (negative strides)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		4.0, 0.0, 3.0,
+		0.0, 5.0, 0.0,
+		2.0, 0.0, 1.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 1.0, 0.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1.0, 1.0 ] );
+
+	expectedA = new Float64Array([
+		5.0, 0.0, 0.0,
+		0.0, 4.0, 3.0,
+		0.0, 2.0, 1.0
+	]);
+
+	info = dgebal( 'permutate', 3, A, -3, -1, 8, out, -1, 1, scale, -1, 2 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = permutate (column-major) (negative strides)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		4.0, 0.0, 2.0,
+		0.0, 5.0, 0.0,
+		3.0, 0.0, 1.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 1.0, 0.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1.0, 1.0 ] );
+	expectedA = new Float64Array([
+		5.0, 0.0, 0.0,
+		0.0, 4.0, 2.0,
+		0.0, 3.0, 1.0
+	]);
+
+	info = dgebal( 'permutate', 3, A, -1, -3, 8, out, -1, 1, scale, -1, 2 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = scale (row-major) (negative strides)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		16.0, 16.0, 16.0,
+		0.25, 0.25, 0.25,
+		0.25, 0.25, 0.25
+	]);
+
+	A = new Float64Array([
+		0.25, 0.25, 0.25,
+		0.25, 0.25, 0.25,
+		16.0, 16.0, 16.0
+	]);
+
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 2.0, 0.0 ] );
+	expectedScale = new Float64Array( [ 0.125, 0.125, 1.0 ] );
+	expectedA = new Float64Array([
+		16.0, 2.0, 2.0,
+		2.0, 0.25, 0.25,
+		2.0, 0.25, 0.25
+	]);
+
+	expectedA = new Float64Array([
+		0.25, 0.25, 2.0,
+		0.25, 0.25, 2.0,
+		2.0, 2.0, 16.0
+	]);
+
+	info = dgebal( 'scale', 3, A, -3, -1, 8, out, -1, 1, scale, -1, 2 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = scale (column-major) (negative strides)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		0.25, 0.25, 16.0,
+		0.25, 0.25, 16.0,
+		0.25, 0.25, 16.0
+	]);
+
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 2.0, 0.0 ] );
+	expectedScale = new Float64Array( [ 0.125, 0.125, 1.0 ] );
+	expectedA = new Float64Array([
+		0.25, 0.25, 2.0,
+		0.25, 0.25, 2.0,
+		2.0, 2.0, 16.0
+	]);
+
+	info = dgebal( 'scale', 3, A, -1, -3, 8, out, -1, 1, scale, -1, 2 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both (row-major) (negative strides)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		4.0, 0.0, 100.0,
+		0.0, 5.0, 0.0,
+		2.0, 0.0, 1.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 1.0, 0.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1.0, 0.125 ] );
+
+	expectedA = new Float64Array([
+		5.0, 0.0, 0.0,
+		0.0, 4.0, 12.5,
+		0.0, 16.0, 1.0
+	]);
+
+	info = dgebal( 'both', 3, A, -3, -1, 8, out, -1, 1, scale, -1, 2 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both (column-major) (negative strides)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		4.0, 0.0, 2.0,
+		0.0, 5.0, 0.0,
+		100.0, 0.0, 1.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 1.0, 0.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1.0, 0.125 ] );
+	expectedA = new Float64Array([
+		5.0, 0.0, 0.0,
+		0.0, 4.0, 16.0,
+		0.0, 12.5, 1.0
+	]);
+
+	info = dgebal( 'both', 3, A, -1, -3, 8, out, -1, 1, scale, -1, 2 );
+
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both with complex input (row-major) (negative strides)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		3.0, 0.0, 0.0,
+		0.0, 2.0, 0.0,
+		0.0, 1.0, 1.0
+	]);
+
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 0.0 ] );
+	expectedScale = new Float64Array( [ 2.0, 1.0, 0.0 ] );
+	expectedA = new Float64Array([
+		3.0, 0.0, 0.0,
+		0.0, 2.0, 0.0,
+		0.0, 1.0, 1.0
+	]);
+
+	info = dgebal( 'both', 3, A, -3, -1, 8, out, -1, 1, scale, -1, 2 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both with complex input (column-major) (negative strides)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		3.0, 0.0, 0.0,
+		0.0, 2.0, 1.0,
+		0.0, 0.0, 1.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 0.0, 0.0 ] );
+	expectedScale = new Float64Array( [ 2.0, 1.0, 0.0 ] );
+
+	expectedA = new Float64Array([
+		3.0, 0.0, 0.0,
+		0.0, 2.0, 1.0,
+		0.0, 0.0, 1.0
+	]);
+
+	info = dgebal( 'both', 3, A, -1, -3, 8, out, -1, 1, scale, -1, 2 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both with complex input (row-major) (negative strides)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		7.0, 0.0, 6.0,
+		5.0, 4.0, 3.0,
+		2.0, 0.0, 1.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 2.0, 1.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 0.5, 1.0 ] );
+	expectedA = new Float64Array([
+		7.0, 3.0, 0.0,
+		4.0, 1.0, 0.0,
+		5.0, 1.5, 4.0
+	]);
+	info = dgebal( 'both', 3, A, -3, -1, 8, out, -1, 1, scale, -1, 2 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = both with complex input (column-major) (negative strides)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		7.0, 5.0, 2.0,
+		0.0, 4.0, 0.0,
+		6.0, 3.0, 1.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 2.0, 1.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 0.5, 1.0 ] );
+
+	expectedA = new Float64Array([
+		7.0, 4.0, 5.0,
+		3.0, 1.0, 1.5,
+		0.0, 0.0, 4.0
+	]);
+
+	info = dgebal( 'both', 3, A, -1, -3, 8, out, -1, 1, scale, -1, 2 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = scale with zero norm (row-major) (negative strides)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		6.0, 0.0, 3.0,
+		5.0, 0.0, 2.0,
+		4.0, 0.0, 1.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 2.0, 0.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1.0, 1.0 ] );
+	expectedA = new Float64Array([
+		6.0, 0.0, 3.0,
+		5.0, 0.0, 2.0,
+		4.0, 0.0, 1.0
+	]);
+
+	info = dgebal( 'scale', 3, A, -3, -1, 8, out, -1, 1, scale, -1, 2 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = scale with zero norm (column-major) (negative strides)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		1.0, 2.0, 3.0,
+		0.0, 0.0, 0.0,
+		4.0, 5.0, 6.0
+	]);
+	A = new Float64Array([
+		6.0, 5.0, 4.0,
+		0.0, 0.0, 0.0,
+		3.0, 2.0, 1.0
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 3 );
+
+	expectedOut = new Float64Array( [ 2.0, 0.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 1.0, 1.0 ] );
+	expectedA = new Float64Array([
+		1.0, 2.0, 3.0,
+		0.0, 0.0, 0.0,
+		4.0, 5.0, 6.0
+	]);
+	expectedA = new Float64Array([
+		6.0, 5.0, 4.0,
+		0.0, 0.0, 0.0,
+		3.0, 2.0, 1.0
+	]);
+
+	info = dgebal( 'scale', 3, A, -1, -3, 8, out, -1, 1, scale, -1, 2 );
+
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = scale with small values (row-major) (negative strides)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		4.0e4, 2.0, 1.0, 4.0e-4,
+		3.0e4, 2.0, 1.0, 3.0e-4,
+		2.0e4, 2.0, 1.0, 2.0e-4,
+		1.0e4, 2.0, 1.0, 1.0e-4
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 4 );
+
+	expectedOut = new Float64Array( [ 3.0, 0.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 128.0, 128.0, 4096.0 ] );
+	expectedA = new Float64Array([
+		4.0e4, 2.56e2, 1.28e2, 1.6384,
+		2.34375e2, 2.0, 1.0, 9.6e-3,
+		1.5625e2, 2.0, 1.0, 6.4e-3,
+		2.44140625, 6.25e-2, 3.125e-2, 1.0e-4
+	]);
+
+	info = dgebal( 'scale', 4, A, -4, -1, 15, out, -1, 1, scale, -1, 3 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns expected values for job = scale with small values (column-major)', function test( t ) {
+	var expectedScale;
+	var expectedOut;
+	var expectedA;
+	var scale;
+	var info;
+	var out;
+	var A;
+
+	A = new Float64Array([
+		4.0e4, 3.0e4, 2.0e4, 1.0e4,
+		2.0, 2.0, 2.0, 2.0,
+		1.0, 1.0, 1.0, 1.0,
+		4.0e-4, 3.0e-4, 2.0e-4, 1.0e-4
+	]);
+	out = new Float64Array( 2 );
+	scale = new Float64Array( 4 );
+
+	expectedOut = new Float64Array( [ 3.0, 0.0 ] );
+	expectedScale = new Float64Array( [ 1.0, 128.0, 128.0, 4096.0 ] );
+	expectedA = new Float64Array([
+		4.0e4, 2.34375e2, 1.5625e2, 2.44140625,
+		2.56e2, 2.0, 2.0, 6.25e-2,
+		1.28e2, 1.0, 1.0, 3.125e-2,
+		1.6384, 9.6e-3, 6.4e-3, 1.0e-4
+	]);
+	info = dgebal( 'scale', 4, A, -1, -4, 15, out, -1, 1, scale, -1, 3 );
+	t.strictEqual( info, 0, 'returns expected value' );
+	t.deepEqual( out, expectedOut, 'returns expected value' );
+	t.deepEqual( A, expectedA, 'returns expected value' );
+	t.deepEqual( scale, expectedScale, 'returns expected value' );
+	t.end();
+});