From 191fc9171cafab1ae66c52237ad2731d6e05fd2d Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Mon, 12 May 2025 07:50:32 +0000 Subject: [PATCH 01/22] feat: add base implementation --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/lapack/base/dgebal/lib/base.js | 283 ++++++++++++++++++ 1 file changed, 283 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dgebal/lib/base.js 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..3519db06a375 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/base.js @@ -0,0 +1,283 @@ +/** +* @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: +* +* - 'N': none, return immediately +* - 'P': permute only +* - 'S': scale only +* - 'B': 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` +* @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( 'B', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 0 ); +* // A => [ 1, 12.5, 0, 16, 200, 0, 0, 0, 3 ] +* // out => [ 0, 1 ] +* // scale => [ 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 === 'N' ) { + 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 !== 'S' ) { + // 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; + + 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; + for ( i = k; i <= l; i++ ) { + scale[ is ] = 1.0; + is += strideScale; + } + + if ( job === 'P' ) { + out[ offsetOut ] = k; // ilo + out[ offsetOut + strideOut ] = l; // ihi + return 0; + } + + // Balance the submatrix in rows K to L, iterative loop for norm reduction + 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; From 08cc97dbd3606ef3fb7dc90cb4cc786e5f83c717 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Mon, 12 May 2025 09:04:03 +0000 Subject: [PATCH 02/22] feat: add main export --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/lapack/base/dgebal/lib/dgebal.js | 96 +++++++++++++++++++ .../@stdlib/lapack/base/dgebal/lib/index.js | 76 +++++++++++++++ .../@stdlib/lapack/base/dgebal/lib/main.js | 35 +++++++ .../@stdlib/lapack/base/dgebal/lib/ndarray.js | 80 ++++++++++++++++ 4 files changed, 287 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dgebal/lib/dgebal.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dgebal/lib/index.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dgebal/lib/main.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dgebal/lib/ndarray.js 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..4ab070999c4a --- /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: +* +* - 'N': none, return immediately +* - 'P': permute only +* - 'S': scale only +* - 'B': 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', 'B', 3, A, 3, out, scale ); +* // A => [ 1, 12.5, 0, 16, 200, 0, 0, 0, 3 ] +* // out => [ 0, 1 ] +* // scale => [ 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 !== 'B' && job !== 'S' && job !== 'P' && job !== 'N' ) { + throw new TypeError( format( 'invalid argument. Second argument must be one of the following: `B`, `S`, `P`, or `N`. 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..8940386fac3b --- /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', 'B', 3, A, 3, out, scale ); +* // A => [ 1, 12.5, 0, 16, 200, 0, 0, 0, 3 ] +* // out => [ 0, 1 ] +* // scale => [ 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( 'B', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 0 ); +* // A => [ 1, 12.5, 0, 16, 200, 0, 0, 0, 3 ] +* // out => [ 0, 1 ] +* // scale => [ 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..89825609aeba --- /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: +* +* - 'N': none, return immediately +* - 'P': permute only +* - 'S': scale only +* - 'B': 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( 'B', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 0 ); +* // A => [ 1, 12.5, 0, 16, 200, 0, 0, 0, 3 ] +* // out => [ 0, 1 ] +* // scale => [ 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 !== 'B' && job !== 'S' && job !== 'P' && job !== 'N' ) { + throw new TypeError( format( 'invalid argument. Second argument must be one of the following: `B`, `S`, `P`, or `N`. 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; From 3a1229838a5b3b18e0b775dd87c57e0ac84a08f2 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Mon, 12 May 2025 18:17:37 +0000 Subject: [PATCH 03/22] test: add initial tests --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/lapack/base/dgebal/lib/base.js | 5 +- .../lapack/base/dgebal/test/test.dgebal.js | 215 ++++++++++++++++++ .../@stdlib/lapack/base/dgebal/test/test.js | 82 +++++++ 3 files changed, 300 insertions(+), 2 deletions(-) create mode 100644 lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dgebal/test/test.js diff --git a/lib/node_modules/@stdlib/lapack/base/dgebal/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/base.js index 3519db06a375..dd6300fa4cc3 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/base.js @@ -46,7 +46,8 @@ var dscal = require( '@stdlib/blas/base/dscal' ).ndarray; * - 'P': permute only * - 'S': scale only * - 'B': both permute and scale -* - The matrix `A` is overwritten by the balanced matrix. +* +* 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 @@ -197,7 +198,7 @@ function dgebal( job, N, A, strideA1, strideA2, offsetA, out, strideOut, offsetO return 0; } - // Balance the submatrix in rows K to L, iterative loop for norm reduction + // 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; 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..34dcfd193ed7 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js @@ -0,0 +1,215 @@ +/** +* @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, 'B', 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', 'B', 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', 'B', 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 = N (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', 'N', 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 = N (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', 'N', 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..235e7935d161 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.js @@ -0,0 +1,82 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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' ); + } +}); From 080ed5038111b94f75d6c0dab859b1c86cdfb369 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Mon, 12 May 2025 19:00:35 +0000 Subject: [PATCH 04/22] test: add P job test --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../lapack/base/dgebal/test/test.dgebal.js | 66 +++++++++++++++++++ 1 file changed, 66 insertions(+) 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 index 34dcfd193ed7..93730d81affe 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js @@ -213,3 +213,69 @@ tape( 'the function returns expected values for job = N (column-major)', functio t.deepEqual( scale, expectedScale, 'returns expected value' ); t.end(); }); + +tape( 'the function returns expected values for job = P (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', 'P', 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 = P (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', 'P', 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(); +}); From 02f5d2d391696817b12650e00ee508242a01fe34 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Mon, 12 May 2025 19:07:04 +0000 Subject: [PATCH 05/22] test: add test for S job --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../lapack/base/dgebal/test/test.dgebal.js | 66 +++++++++++++++++++ 1 file changed, 66 insertions(+) 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 index 93730d81affe..732efcdc21c4 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js @@ -279,3 +279,69 @@ tape( 'the function returns expected values for job = P (column-major)', functio t.deepEqual( scale, expectedScale, 'returns expected value' ); t.end(); }); + +tape( 'the function returns expected values for job = S (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', 'S', 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 = S (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', 'S', 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(); +}); From 0b4af093cfa68c799aafbbce57d202c3bf20ab1f Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Mon, 12 May 2025 19:19:25 +0000 Subject: [PATCH 06/22] test: add test for job = B --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../lapack/base/dgebal/test/test.dgebal.js | 66 +++++++++++++++++++ 1 file changed, 66 insertions(+) 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 index 732efcdc21c4..96344b697b67 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js @@ -345,3 +345,69 @@ tape( 'the function returns expected values for job = S (column-major)', functio t.deepEqual( scale, expectedScale, 'returns expected value' ); t.end(); }); + +tape( 'the function returns expected values for job = B (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', 'B', 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 = B (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', 'B', 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(); +}); From aeaff94777663be43967781b6dc98cc2567528eb Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Mon, 12 May 2025 19:35:20 +0000 Subject: [PATCH 07/22] test: add ndarray tests --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/lapack/base/dgebal/test/test.js | 2 +- .../lapack/base/dgebal/test/test.ndarray.js | 355 ++++++++++++++++++ 2 files changed, 356 insertions(+), 1 deletion(-) create mode 100644 lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js diff --git a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.js b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.js index 235e7935d161..f22291acb9fc 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* 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. 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..6b079260279c --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js @@ -0,0 +1,355 @@ +/** +* @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/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 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( 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 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( 'B', 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 = N (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( 'N', 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 = N (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( 'B', 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 = P (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( 'P', 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 = P (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( 'B', 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 = S (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( 'S', 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 = S (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( 'B', 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 = B (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( 'B', 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 = B (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( 'B', 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(); +}); From 03a6986552d16e5c035e7b675ea2e3aa27f5753b Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Mon, 12 May 2025 19:41:07 +0000 Subject: [PATCH 08/22] chore: cleanup --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/lapack/base/dgebal/test/test.ndarray.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 index 6b079260279c..18df6a4123d4 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js @@ -40,7 +40,7 @@ tape( 'the function has an arity of 12', function test( t ) { t.end(); }); -tape( 'the function throws an error if provided an invalid second argument', function test( t ) { +tape( 'the function throws an error if provided an invalid first argument', function test( t ) { var values; var scale; var out; From 5f956b071a3ff8026f632f80c4b96c4925fb60f9 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Tue, 13 May 2025 05:40:15 +0000 Subject: [PATCH 09/22] test: add tests for empty submatrix --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/lapack/base/dgebal/lib/base.js | 1 + .../lapack/base/dgebal/test/test.dgebal.js | 66 +++++++++++++++++++ 2 files changed, 67 insertions(+) diff --git a/lib/node_modules/@stdlib/lapack/base/dgebal/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/base.js index dd6300fa4cc3..3b48c79f856b 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/base.js @@ -149,6 +149,7 @@ function dgebal( job, N, A, strideA1, strideA2, offsetA, out, strideOut, offsetO } 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 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 index 96344b697b67..ccb6acca625f 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js @@ -411,3 +411,69 @@ tape( 'the function returns expected values for job = B (column-major)', functio t.deepEqual( scale, expectedScale, 'returns expected value' ); t.end(); }); + +tape( 'the function returns expected values for job = B 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', 'B', 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 = B 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', 'B', 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(); +}); From 4ab038041bde6f91ea746d12361763a240a6d700 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Tue, 13 May 2025 10:45:33 +0000 Subject: [PATCH 10/22] test: add more tests --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/lapack/base/dgebal/lib/base.js | 2 +- .../lapack/base/dgebal/test/test.dgebal.js | 66 +++++++++++++++++++ 2 files changed, 67 insertions(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dgebal/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/base.js index 3b48c79f856b..69d733e28e11 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/base.js @@ -187,7 +187,7 @@ function dgebal( job, N, A, strideA1, strideA2, offsetA, out, strideOut, offsetO } // Initialize `scale` for non-permuted submatrix - is = offsetScale; + is = offsetScale + (k*strideScale); for ( i = k; i <= l; i++ ) { scale[ is ] = 1.0; is += strideScale; 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 index ccb6acca625f..b98f429cbad3 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js @@ -477,3 +477,69 @@ tape( 'the function returns expected values for job = B with complex input (colu t.deepEqual( scale, expectedScale, 'returns expected value' ); t.end(); }); + +tape( 'the function returns expected values for job = B 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', 'B', 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 = B 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', 'B', 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(); +}); From 8192ae8180b0590f2b8e8e6bafa4806e6dce4ead Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Tue, 13 May 2025 13:03:27 +0000 Subject: [PATCH 11/22] test: add test for norm = 0 --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../lapack/base/dgebal/test/test.dgebal.js | 66 +++++++++++++++++++ 1 file changed, 66 insertions(+) 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 index b98f429cbad3..3871974f5f0c 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js @@ -543,3 +543,69 @@ tape( 'the function returns expected values for job = B with complex input (colu t.deepEqual( scale, expectedScale, 'returns expected value' ); t.end(); }); + +tape( 'the function returns expected values for job = S 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', 'S', 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 = S 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', 'S', 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(); +}); From f70eec063734fb5c3215a1a469959bddb524b5bd Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Tue, 13 May 2025 14:51:52 +0000 Subject: [PATCH 12/22] test: add test for small values --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../lapack/base/dgebal/test/test.dgebal.js | 70 +++++++++++++++++++ 1 file changed, 70 insertions(+) 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 index 3871974f5f0c..97e5a95c2aff 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js @@ -609,3 +609,73 @@ tape( 'the function returns expected values for job = S with zero norm (column-m t.deepEqual( scale, expectedScale, 'returns expected value' ); t.end(); }); + +tape( 'the function returns expected values for job = S 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', 'S', 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 = S 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', 'S', 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(); +}); From c9ded9845828c57b17447928be11d48ed4d2ec30 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Tue, 13 May 2025 18:37:14 +0000 Subject: [PATCH 13/22] refactor: update job names --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/lapack/base/dgebal/lib/base.js | 16 ++--- .../@stdlib/lapack/base/dgebal/lib/dgebal.js | 14 ++-- .../@stdlib/lapack/base/dgebal/lib/index.js | 4 +- .../@stdlib/lapack/base/dgebal/lib/ndarray.js | 14 ++-- .../lapack/base/dgebal/test/test.dgebal.js | 72 +++++++++---------- .../lapack/base/dgebal/test/test.ndarray.js | 36 +++++----- 6 files changed, 78 insertions(+), 78 deletions(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dgebal/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/base.js index 69d733e28e11..df6482de6d99 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/base.js @@ -42,10 +42,10 @@ var dscal = require( '@stdlib/blas/base/dscal' ).ndarray; * * The job parameter can be one of the following: * -* - 'N': none, return immediately -* - 'P': permute only -* - 'S': scale only -* - 'B': both permute and scale +* - '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. * @@ -71,7 +71,7 @@ var dscal = require( '@stdlib/blas/base/dscal' ).ndarray; * var out = new Float64Array( 2 ); * var scale = new Float64Array( 3 ); * -* dgebal( 'B', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 0 ); +* dgebal( 'both', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 0 ); * // A => [ 1, 12.5, 0, 16, 200, 0, 0, 0, 3 ] * // out => [ 0, 1 ] * // scale => [ 8, 1, 2 ] @@ -110,7 +110,7 @@ function dgebal( job, N, A, strideA1, strideA2, offsetA, out, strideOut, offsetO return 0; } - if ( job === 'N' ) { + if ( job === 'none' ) { is = offsetScale; for ( i = 0; i < N; i++ ) { scale[ is ] = 1.0; @@ -126,7 +126,7 @@ function dgebal( job, N, A, strideA1, strideA2, offsetA, out, strideOut, offsetO k = 0; l = N - 1; - if ( job !== 'S' ) { + if ( job !== 'scale' ) { // Row and column exchange noconv = true; while ( noconv ) { @@ -193,7 +193,7 @@ function dgebal( job, N, A, strideA1, strideA2, offsetA, out, strideOut, offsetO is += strideScale; } - if ( job === 'P' ) { + if ( job === 'permutate' ) { out[ offsetOut ] = k; // ilo out[ offsetOut + strideOut ] = l; // ihi return 0; diff --git a/lib/node_modules/@stdlib/lapack/base/dgebal/lib/dgebal.js b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/dgebal.js index 4ab070999c4a..a5506edd5b38 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/lib/dgebal.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/dgebal.js @@ -35,10 +35,10 @@ var base = require( './base.js' ); * * The job parameter can be one of the following: * -* - 'N': none, return immediately -* - 'P': permute only -* - 'S': scale only -* - 'B': both permute and scale +* - '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 @@ -61,7 +61,7 @@ var base = require( './base.js' ); * var out = new Float64Array( 2 ); * var scale = new Float64Array( 3 ); * -* dgebal( 'row-major', 'B', 3, A, 3, out, scale ); +* dgebal( 'row-major', 'both', 3, A, 3, out, scale ); * // A => [ 1, 12.5, 0, 16, 200, 0, 0, 0, 3 ] * // out => [ 0, 1 ] * // scale => [ 8, 1, 2 ] @@ -73,8 +73,8 @@ function dgebal( order, job, N, A, LDA, out, scale ) { if ( !isLayout( order ) ) { throw new TypeError( format( 'invalid argument. First argument must be a valid order. Value: `%s`.', order ) ); } - if ( job !== 'B' && job !== 'S' && job !== 'P' && job !== 'N' ) { - throw new TypeError( format( 'invalid argument. Second argument must be one of the following: `B`, `S`, `P`, or `N`. Value: `%s`.', job ) ); + 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; diff --git a/lib/node_modules/@stdlib/lapack/base/dgebal/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/index.js index 8940386fac3b..75b2826b6ba8 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/lib/index.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/index.js @@ -31,7 +31,7 @@ * var out = new Float64Array( 2 ); * var scale = new Float64Array( 3 ); * -* dgebal( 'row-major', 'B', 3, A, 3, out, scale ); +* dgebal( 'row-major', 'both', 3, A, 3, out, scale ); * // A => [ 1, 12.5, 0, 16, 200, 0, 0, 0, 3 ] * // out => [ 0, 1 ] * // scale => [ 8, 1, 2 ] @@ -44,7 +44,7 @@ * var out = new Float64Array( 2 ); * var scale = new Float64Array( 3 ); * -* dgebal.ndarray( 'B', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 0 ); +* dgebal.ndarray( 'both', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 0 ); * // A => [ 1, 12.5, 0, 16, 200, 0, 0, 0, 3 ] * // out => [ 0, 1 ] * // scale => [ 8, 1, 2 ] diff --git a/lib/node_modules/@stdlib/lapack/base/dgebal/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/ndarray.js index 89825609aeba..e05576f03767 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/lib/ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/lib/ndarray.js @@ -33,10 +33,10 @@ var base = require( './base.js' ); * * The job parameter can be one of the following: * -* - 'N': none, return immediately -* - 'P': permute only -* - 'S': scale only -* - 'B': both permute and scale +* - '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 @@ -62,14 +62,14 @@ var base = require( './base.js' ); * var out = new Float64Array( 2 ); * var scale = new Float64Array( 3 ); * -* dgebal( 'B', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 0 ); +* dgebal( 'both', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 0 ); * // A => [ 1, 12.5, 0, 16, 200, 0, 0, 0, 3 ] * // out => [ 0, 1 ] * // scale => [ 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 !== 'B' && job !== 'S' && job !== 'P' && job !== 'N' ) { - throw new TypeError( format( 'invalid argument. Second argument must be one of the following: `B`, `S`, `P`, or `N`. Value: `%s`.', job ) ); + 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 } 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 index 97e5a95c2aff..aa0c48681ae9 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js @@ -65,7 +65,7 @@ tape( 'the function throws an error if provided an invalid first argument', func function badValue( value ) { return function badValue() { - dgebal( value, 'B', 2, A, 2, out, scale ); + dgebal( value, 'both', 2, A, 2, out, scale ); }; } }); @@ -123,12 +123,12 @@ tape( 'the function throws an error if provided an invalid second argument', fun function badValue( value ) { return function badValue() { - dgebal( 'row-major', 'B', 2, A, value, out, scale ); + 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 ) { +tape( 'the function returns invalid indices and leaves the input array unchanged for none = 0', function test( t ) { var expectedOut; var scale; var info; @@ -139,7 +139,7 @@ tape( 'the function returns invalid indices and leaves the input array unchanged out = new Float64Array( 2 ); scale = new Float64Array( 2 ); - info = dgebal( 'row-major', 'B', 0, A, 2, out, scale ); + info = dgebal( 'row-major', 'both', 0, A, 2, out, scale ); expectedOut = new Float64Array( [ 0.0, -1.0 ] ); @@ -148,7 +148,7 @@ tape( 'the function returns invalid indices and leaves the input array unchanged t.end(); }); -tape( 'the function returns expected values for job = N (row-major)', function test( t ) { +tape( 'the function returns expected values for job = none (row-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -173,7 +173,7 @@ tape( 'the function returns expected values for job = N (row-major)', function t 7.0, 8.0, 9.0 ]); - info = dgebal( 'row-major', 'N', 3, A, 3, out, scale ); + 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' ); @@ -181,7 +181,7 @@ tape( 'the function returns expected values for job = N (row-major)', function t t.end(); }); -tape( 'the function returns expected values for job = N (column-major)', function test( t ) { +tape( 'the function returns expected values for job = none (column-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -206,7 +206,7 @@ tape( 'the function returns expected values for job = N (column-major)', functio 3.0, 6.0, 9.0 ]); - info = dgebal( 'column-major', 'N', 3, A, 3, out, scale ); + 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' ); @@ -214,7 +214,7 @@ tape( 'the function returns expected values for job = N (column-major)', functio t.end(); }); -tape( 'the function returns expected values for job = P (row-major)', function test( t ) { +tape( 'the function returns expected values for job = permutate (row-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -239,7 +239,7 @@ tape( 'the function returns expected values for job = P (row-major)', function t 0.0, 0.0, 5.0 ]); - info = dgebal( 'row-major', 'P', 3, A, 3, out, scale ); + 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' ); @@ -247,7 +247,7 @@ tape( 'the function returns expected values for job = P (row-major)', function t t.end(); }); -tape( 'the function returns expected values for job = P (column-major)', function test( t ) { +tape( 'the function returns expected values for job = permutate (column-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -272,7 +272,7 @@ tape( 'the function returns expected values for job = P (column-major)', functio 0.0, 0.0, 5.0 ]); - info = dgebal( 'column-major', 'P', 3, A, 3, out, scale ); + 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' ); @@ -280,7 +280,7 @@ tape( 'the function returns expected values for job = P (column-major)', functio t.end(); }); -tape( 'the function returns expected values for job = S (row-major)', function test( t ) { +tape( 'the function returns expected values for job = scale (row-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -305,7 +305,7 @@ tape( 'the function returns expected values for job = S (row-major)', function t 2.0, 0.25, 0.25 ]); - info = dgebal( 'row-major', 'S', 3, A, 3, out, scale ); + 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' ); @@ -313,7 +313,7 @@ tape( 'the function returns expected values for job = S (row-major)', function t t.end(); }); -tape( 'the function returns expected values for job = S (column-major)', function test( t ) { +tape( 'the function returns expected values for job = scale (column-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -338,7 +338,7 @@ tape( 'the function returns expected values for job = S (column-major)', functio 2.0, 0.25, 0.25 ]); - info = dgebal( 'column-major', 'S', 3, A, 3, out, scale ); + 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' ); @@ -346,7 +346,7 @@ tape( 'the function returns expected values for job = S (column-major)', functio t.end(); }); -tape( 'the function returns expected values for job = B (row-major)', function test( t ) { +tape( 'the function returns expected values for job = both (row-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -371,7 +371,7 @@ tape( 'the function returns expected values for job = B (row-major)', function t 0.0, 0.0, 5.0 ]); - info = dgebal( 'row-major', 'B', 3, A, 3, out, scale ); + 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' ); @@ -379,7 +379,7 @@ tape( 'the function returns expected values for job = B (row-major)', function t t.end(); }); -tape( 'the function returns expected values for job = B (column-major)', function test( t ) { +tape( 'the function returns expected values for job = both (column-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -404,7 +404,7 @@ tape( 'the function returns expected values for job = B (column-major)', functio 0.0, 0.0, 5.0 ]); - info = dgebal( 'column-major', 'B', 3, A, 3, out, scale ); + 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' ); @@ -412,7 +412,7 @@ tape( 'the function returns expected values for job = B (column-major)', functio t.end(); }); -tape( 'the function returns expected values for job = B with complex input (row-major)', function test( t ) { +tape( 'the function returns expected values for job = both with complex input (row-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -437,7 +437,7 @@ tape( 'the function returns expected values for job = B with complex input (row- 0.0, 0.0, 3.0 ]); - info = dgebal( 'row-major', 'B', 3, A, 3, out, scale ); + 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' ); @@ -445,7 +445,7 @@ tape( 'the function returns expected values for job = B with complex input (row- t.end(); }); -tape( 'the function returns expected values for job = B with complex input (column-major)', function test( t ) { +tape( 'the function returns expected values for job = both with complex input (column-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -470,7 +470,7 @@ tape( 'the function returns expected values for job = B with complex input (colu 0.0, 0.0, 3.0 ]); - info = dgebal( 'column-major', 'B', 3, A, 3, out, scale ); + 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' ); @@ -478,7 +478,7 @@ tape( 'the function returns expected values for job = B with complex input (colu t.end(); }); -tape( 'the function returns expected values for job = B with complex input (row-major)', function test( t ) { +tape( 'the function returns expected values for job = both with complex input (row-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -503,7 +503,7 @@ tape( 'the function returns expected values for job = B with complex input (row- 0.0, 3.0, 7.0 ]); - info = dgebal( 'row-major', 'B', 3, A, 3, out, scale ); + 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' ); @@ -511,7 +511,7 @@ tape( 'the function returns expected values for job = B with complex input (row- t.end(); }); -tape( 'the function returns expected values for job = B with complex input (column-major)', function test( t ) { +tape( 'the function returns expected values for job = both with complex input (column-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -536,7 +536,7 @@ tape( 'the function returns expected values for job = B with complex input (colu 5.0, 4.0, 7.0 ]); - info = dgebal( 'column-major', 'B', 3, A, 3, out, scale ); + 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' ); @@ -544,7 +544,7 @@ tape( 'the function returns expected values for job = B with complex input (colu t.end(); }); -tape( 'the function returns expected values for job = S with zero norm (row-major)', function test( t ) { +tape( 'the function returns expected values for job = scale with zero norm (row-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -569,7 +569,7 @@ tape( 'the function returns expected values for job = S with zero norm (row-majo 3.0, 0.0, 6.0 ]); - info = dgebal( 'row-major', 'S', 3, A, 3, out, scale ); + 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' ); @@ -577,7 +577,7 @@ tape( 'the function returns expected values for job = S with zero norm (row-majo t.end(); }); -tape( 'the function returns expected values for job = S with zero norm (column-major)', function test( t ) { +tape( 'the function returns expected values for job = scale with zero norm (column-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -602,7 +602,7 @@ tape( 'the function returns expected values for job = S with zero norm (column-m 4.0, 5.0, 6.0 ]); - info = dgebal( 'column-major', 'S', 3, A, 3, out, scale ); + 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' ); @@ -610,7 +610,7 @@ tape( 'the function returns expected values for job = S with zero norm (column-m t.end(); }); -tape( 'the function returns expected values for job = S with small values (row-major)', function test( t ) { +tape( 'the function returns expected values for job = scale with small values (row-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -637,7 +637,7 @@ tape( 'the function returns expected values for job = S with small values (row-m 1.6384, 1.28e+2, 2.56e+2, 4.0e+4 ]); - info = dgebal( 'row-major', 'S', 4, A, 4, out, scale ); + 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' ); @@ -645,7 +645,7 @@ tape( 'the function returns expected values for job = S with small values (row-m t.end(); }); -tape( 'the function returns expected values for job = S with small values (column-major)', function test( t ) { +tape( 'the function returns expected values for job = scale with small values (column-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -672,7 +672,7 @@ tape( 'the function returns expected values for job = S with small values (colum 2.44140625, 1.5625e+2, 2.34375e+2, 4.0e+4 ]); - info = dgebal( 'column-major', 'S', 4, A, 4, out, scale ); + 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' ); 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 index 18df6a4123d4..3e2813a30af3 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js @@ -70,7 +70,7 @@ tape( 'the function throws an error if provided an invalid first argument', func } }); -tape( 'the function returns invalid indices and leaves the input array unchanged for N = 0', function test( t ) { +tape( 'the function returns invalid indices and leaves the input array unchanged for none = 0', function test( t ) { var expectedOut; var scale; var info; @@ -81,7 +81,7 @@ tape( 'the function returns invalid indices and leaves the input array unchanged out = new Float64Array( 2 ); scale = new Float64Array( 2 ); - info = dgebal( 'B', 0, A, 2, 1, 0, out, 1, 0, scale, 1, 0 ); + info = dgebal( 'both', 0, A, 2, 1, 0, out, 1, 0, scale, 1, 0 ); expectedOut = new Float64Array( [ 0.0, -1.0 ] ); @@ -90,7 +90,7 @@ tape( 'the function returns invalid indices and leaves the input array unchanged t.end(); }); -tape( 'the function returns expected values for job = N (row-major)', function test( t ) { +tape( 'the function returns expected values for job = none (row-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -115,7 +115,7 @@ tape( 'the function returns expected values for job = N (row-major)', function t 7.0, 8.0, 9.0 ]); - info = dgebal( 'N', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 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' ); @@ -123,7 +123,7 @@ tape( 'the function returns expected values for job = N (row-major)', function t t.end(); }); -tape( 'the function returns expected values for job = N (column-major)', function test( t ) { +tape( 'the function returns expected values for job = none (column-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -148,7 +148,7 @@ tape( 'the function returns expected values for job = N (column-major)', functio 3.0, 6.0, 9.0 ]); - info = dgebal( 'B', 3, A, 1, 3, 0, out, 1, 0, scale, 1, 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' ); @@ -156,7 +156,7 @@ tape( 'the function returns expected values for job = N (column-major)', functio t.end(); }); -tape( 'the function returns expected values for job = P (row-major)', function test( t ) { +tape( 'the function returns expected values for job = permutate (row-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -181,7 +181,7 @@ tape( 'the function returns expected values for job = P (row-major)', function t 0.0, 0.0, 5.0 ]); - info = dgebal( 'P', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 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' ); @@ -189,7 +189,7 @@ tape( 'the function returns expected values for job = P (row-major)', function t t.end(); }); -tape( 'the function returns expected values for job = P (column-major)', function test( t ) { +tape( 'the function returns expected values for job = permutate (column-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -214,7 +214,7 @@ tape( 'the function returns expected values for job = P (column-major)', functio 0.0, 0.0, 5.0 ]); - info = dgebal( 'B', 3, A, 1, 3, 0, out, 1, 0, scale, 1, 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' ); @@ -222,7 +222,7 @@ tape( 'the function returns expected values for job = P (column-major)', functio t.end(); }); -tape( 'the function returns expected values for job = S (row-major)', function test( t ) { +tape( 'the function returns expected values for job = scale (row-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -247,7 +247,7 @@ tape( 'the function returns expected values for job = S (row-major)', function t 2.0, 0.25, 0.25 ]); - info = dgebal( 'S', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 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' ); @@ -255,7 +255,7 @@ tape( 'the function returns expected values for job = S (row-major)', function t t.end(); }); -tape( 'the function returns expected values for job = S (column-major)', function test( t ) { +tape( 'the function returns expected values for job = scale (column-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -280,7 +280,7 @@ tape( 'the function returns expected values for job = S (column-major)', functio 2.0, 0.25, 0.25 ]); - info = dgebal( 'B', 3, A, 1, 3, 0, out, 1, 0, scale, 1, 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' ); @@ -288,7 +288,7 @@ tape( 'the function returns expected values for job = S (column-major)', functio t.end(); }); -tape( 'the function returns expected values for job = B (row-major)', function test( t ) { +tape( 'the function returns expected values for job = both (row-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -313,7 +313,7 @@ tape( 'the function returns expected values for job = B (row-major)', function t 0.0, 0.0, 5.0 ]); - info = dgebal( 'B', 3, A, 3, 1, 0, out, 1, 0, scale, 1, 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' ); @@ -321,7 +321,7 @@ tape( 'the function returns expected values for job = B (row-major)', function t t.end(); }); -tape( 'the function returns expected values for job = B (column-major)', function test( t ) { +tape( 'the function returns expected values for job = both (column-major)', function test( t ) { var expectedScale; var expectedOut; var expectedA; @@ -346,7 +346,7 @@ tape( 'the function returns expected values for job = B (column-major)', functio 0.0, 0.0, 5.0 ]); - info = dgebal( 'B', 3, A, 1, 3, 0, out, 1, 0, scale, 1, 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' ); From 2c45388da8f4b494d9fcb65f8bd1371b537d8d23 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Tue, 13 May 2025 19:00:56 +0000 Subject: [PATCH 14/22] test: add tests with weird values --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../lapack/base/dgebal/test/test.dgebal.js | 66 +++++++++++++++++++ 1 file changed, 66 insertions(+) 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 index aa0c48681ae9..bc528d51e490 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js @@ -679,3 +679,69 @@ tape( 'the function returns expected values for job = scale with small values (c 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(); +}); From 6d755caa8a6de552a4e66b96d2d2b742c1c19937 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Wed, 14 May 2025 00:42:15 +0530 Subject: [PATCH 15/22] test: add ndarray tests --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../lapack/base/dgebal/test/test.dgebal.js | 2 +- .../lapack/base/dgebal/test/test.ndarray.js | 335 ++++++++++++++++++ 2 files changed, 336 insertions(+), 1 deletion(-) 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 index bc528d51e490..da614f6e9668 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js @@ -128,7 +128,7 @@ tape( 'the function throws an error if provided an invalid second argument', fun } }); -tape( 'the function returns invalid indices and leaves the input array unchanged for none = 0', function test( t ) { +tape( 'the function returns invalid indices and leaves the input array unchanged for N = 0', function test( t ) { var expectedOut; var scale; var info; 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 index 3e2813a30af3..3c14b02eb506 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js @@ -346,6 +346,341 @@ tape( 'the function returns expected values for job = both (column-major)', func 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' ); From 91366cd782e513723dac3f7f8bdce372577971f9 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Wed, 14 May 2025 19:23:04 +0000 Subject: [PATCH 16/22] test: add some tests --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../lapack/base/dgebal/test/test.ndarray.js | 215 +++++++++++++++++- 1 file changed, 214 insertions(+), 1 deletion(-) 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 index 3c14b02eb506..614747678232 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js @@ -280,7 +280,7 @@ tape( 'the function returns expected values for job = scale (column-major)', fun 2.0, 0.25, 0.25 ]); - info = dgebal( 'both', 3, A, 1, 3, 0, out, 1, 0, scale, 1, 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' ); @@ -688,3 +688,216 @@ tape( 'the function returns expected values for job = both with large values (co 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(); +}); From ecf4a87c852da80677b9c035607a71cbb44c2160 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Wed, 14 May 2025 20:02:01 +0000 Subject: [PATCH 17/22] test: more negative stride tests --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../lapack/base/dgebal/test/test.ndarray.js | 202 ++++++++++++++++++ 1 file changed, 202 insertions(+) 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 index 614747678232..0433261fe1f8 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js @@ -901,3 +901,205 @@ tape( 'the function returns expected values for job = scale (column-major) (nega 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(); +}); From 91d0ec8e517e9415da2cef306cc0bf74eba38322 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Wed, 14 May 2025 20:22:55 +0000 Subject: [PATCH 18/22] test: add tests for negative strides --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../lapack/base/dgebal/test/test.ndarray.js | 148 +++++++++++++++++- 1 file changed, 147 insertions(+), 1 deletion(-) 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 index 0433261fe1f8..c348f6ea25c5 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js @@ -16,7 +16,7 @@ * limitations under the License. */ -/* eslint-disable array-element-newline */ +/* eslint-disable array-element-newline, max-lines */ 'use strict'; @@ -1103,3 +1103,149 @@ tape( 'the function returns expected values for job = both with complex input (c 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(); +}); From 7631cbad4df572195ed6a0cb24c2f56f2d38c880 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Wed, 14 May 2025 20:28:32 +0000 Subject: [PATCH 19/22] chore: clean up --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../lapack/base/dgebal/test/test.dgebal.js | 16 ++++++++-------- .../lapack/base/dgebal/test/test.ndarray.js | 16 ++++++++-------- 2 files changed, 16 insertions(+), 16 deletions(-) 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 index da614f6e9668..c6fa133108e6 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.dgebal.js @@ -632,9 +632,9 @@ tape( 'the function returns expected values for job = scale with small values (r 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 + 6.4e-3, 1.0, 2.0, 1.5625e2, + 9.6e-3, 1.0, 2.0, 2.34375e2, + 1.6384, 1.28e2, 2.56e2, 4.0e4 ]); info = dgebal( 'row-major', 'scale', 4, A, 4, out, scale ); @@ -667,9 +667,9 @@ tape( 'the function returns expected values for job = scale with small values (c 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 + 3.125e-2, 1.0, 1.0, 1.28e2, + 6.25e-2, 2.0, 2.0, 2.56e2, + 2.44140625, 1.5625e2, 2.34375e2, 4.0e4 ]); info = dgebal( 'column-major', 'scale', 4, A, 4, out, scale ); @@ -698,7 +698,7 @@ tape( 'the function returns expected values for job = both with large values (ro 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 + expectedScale = new Float64Array( [ 1.0, 1125899906842624.0, 1.2676506002282294e30 ] ); // eslint-disable-line max-len expectedA = new Float64Array([ 1.0e30, 1.1258999068426240e15, 1.2676506002282295, 8.8817841970012525e14, 1.0, 1.1258999068426241e-15, @@ -731,7 +731,7 @@ tape( 'the function returns expected values for job = both with large values (co 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 + expectedScale = new Float64Array( [ 1.0, 1125899906842624.0, 1.2676506002282294e30 ] ); // eslint-disable-line max-len expectedA = new Float64Array([ 1.0e30, 8.8817841970012525e14, 7.8886090522101182e-1, 1.1258999068426240e15, 1.0, 8.8817841970012523e-16, 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 index c348f6ea25c5..a4139b91bb69 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js @@ -575,9 +575,9 @@ tape( 'the function returns expected values for job = scale with small values (r 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 + 6.4e-3, 1.0, 2.0, 1.5625e2, + 9.6e-3, 1.0, 2.0, 2.34375e2, + 1.6384, 1.28e2, 2.56e2, 4.0e4 ]); info = dgebal( 'scale', 4, A, 4, 1, 0, out, 1, 0, scale, 1, 0 ); @@ -610,9 +610,9 @@ tape( 'the function returns expected values for job = scale with small values (c 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 + 3.125e-2, 1.0, 1.0, 1.28e2, + 6.25e-2, 2.0, 2.0, 2.56e2, + 2.44140625, 1.5625e2, 2.34375e2, 4.0e4 ]); info = dgebal( 'scale', 4, A, 1, 4, 0, out, 1, 0, scale, 1, 0 ); @@ -641,7 +641,7 @@ tape( 'the function returns expected values for job = both with large values (ro 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 + expectedScale = new Float64Array( [ 1.0, 1125899906842624.0, 1.2676506002282294e30 ] ); // eslint-disable-line max-len expectedA = new Float64Array([ 1.0e30, 1.1258999068426240e15, 1.2676506002282295, 8.8817841970012525e14, 1.0, 1.1258999068426241e-15, @@ -674,7 +674,7 @@ tape( 'the function returns expected values for job = both with large values (co 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 + expectedScale = new Float64Array( [ 1.0, 1125899906842624.0, 1.2676506002282294e30 ] ); // eslint-disable-line max-len expectedA = new Float64Array([ 1.0e30, 8.8817841970012525e14, 7.8886090522101182e-1, 1.1258999068426240e15, 1.0, 8.8817841970012523e-16, From 7030f4d72bc4a2f99d61cecd6872b886a51d36b5 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Thu, 15 May 2025 07:08:20 +0000 Subject: [PATCH 20/22] test: add offset tests --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../lapack/base/dgebal/test/test.ndarray.js | 565 +++++++++++++++++- 1 file changed, 564 insertions(+), 1 deletion(-) 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 index a4139b91bb69..d6d161ccb44f 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js @@ -70,7 +70,7 @@ tape( 'the function throws an error if provided an invalid first argument', func } }); -tape( 'the function returns invalid indices and leaves the input array unchanged for none = 0', function test( t ) { +tape( 'the function returns invalid indices and leaves the input array unchanged for N = 0', function test( t ) { var expectedOut; var scale; var info; @@ -1249,3 +1249,566 @@ tape( 'the function returns expected values for job = scale with small values (c t.deepEqual( scale, expectedScale, 'returns expected value' ); t.end(); }); + +tape( 'the function returns expected values for job = none (row-major) (offsets)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 0.0, 0.0, + 1.0, 2.0, 3.0, + 4.0, 5.0, 6.0, + 7.0, 8.0, 9.0 + ]); + out = new Float64Array( 3 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 2.0 ] ); + expectedScale = new Float64Array( [ 0.0, 0.0, 0.0, 1.0, 1.0, 1.0 ] ); + expectedA = new Float64Array([ + 0.0, 0.0, + 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, 2, 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 = none (column-major) (offsets)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 0.0, 0.0, + 1.0, 4.0, 7.0, + 2.0, 5.0, 8.0, + 3.0, 6.0, 9.0 + ]); + out = new Float64Array( 3 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 2.0 ] ); + expectedScale = new Float64Array( [ 0.0, 0.0, 0.0, 1.0, 1.0, 1.0 ] ); + expectedA = new Float64Array([ + 0.0, 0.0, + 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, 2, 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 = permutate (row-major) (offsets)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 0.0, 0.0, + 1.0, 0.0, 2.0, + 0.0, 5.0, 0.0, + 3.0, 0.0, 4.0 + ]); + out = new Float64Array( 3 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 1.0 ] ); + expectedScale = new Float64Array( [ 0.0, 0.0, 0.0, 1.0, 1.0, 1.0 ] ); + expectedA = new Float64Array([ + 0.0, 0.0, + 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, 2, 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 = permutate (column-major) (offsets)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 0.0, 0.0, + 1.0, 0.0, 3.0, + 0.0, 5.0, 0.0, + 2.0, 0.0, 4.0 + ]); + out = new Float64Array( 3 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 1.0 ] ); + expectedScale = new Float64Array( [ 0.0, 0.0, 0.0, 1.0, 1.0, 1.0 ] ); + expectedA = new Float64Array([ + 0.0, 0.0, + 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, 2, 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 (row-major) (offsets)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 0.0, 0.0, + 16.0, 16.0, 16.0, + 0.25, 0.25, 0.25, + 0.25, 0.25, 0.25 + ]); + out = new Float64Array( 3 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 2.0 ] ); + expectedScale = new Float64Array( [ 0.0, 0.0, 0.0, 1.0, 0.125, 0.125 ] ); + expectedA = new Float64Array([ + 0.0, 0.0, + 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, 2, 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 (column-major) (offsets)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 0.0, 0.0, + 16.0, 0.25, 0.25, + 16.0, 0.25, 0.25, + 16.0, 0.25, 0.25 + ]); + out = new Float64Array( 3 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 2.0 ] ); + expectedScale = new Float64Array( [ 0.0, 0.0, 0.0, 1.0, 0.125, 0.125 ] ); + expectedA = new Float64Array([ + 0.0, 0.0, + 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, 2, 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 = both (row-major) (offsets)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 0.0, 0.0, + 1.0, 0.0, 2.0, + 0.0, 5.0, 0.0, + 100.0, 0.0, 4.0 + ]); + out = new Float64Array( 3 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 1.0 ] ); + expectedScale = new Float64Array( [ 0.0, 0.0, 0.0, 0.125, 1.0, 1.0 ] ); + expectedA = new Float64Array([ + 0.0, 0.0, + 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, 2, 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 = both (column-major) (offsets)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 0.0, 0.0, + 1.0, 0.0, 100.0, + 0.0, 5.0, 0.0, + 2.0, 0.0, 4.0 + ]); + out = new Float64Array( 3 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 1.0 ] ); + expectedScale = new Float64Array( [ 0.0, 0.0, 0.0, 0.125, 1.0, 1.0 ] ); + expectedA = new Float64Array([ + 0.0, 0.0, + 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, 2, 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 = both with complex input (row-major) (offsets)', 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) (offsets)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 0.0, 0.0, + 1.0, 0.0, 0.0, + 1.0, 2.0, 0.0, + 0.0, 0.0, 3.0 + ]); + out = new Float64Array( 3 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 0.0 ] ); + expectedScale = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 1.0, 2.0 ] ); + expectedA = new Float64Array([ + 0.0, 0.0, + 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, 2, 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 = both with complex input (row-major) (offsets)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 0.0, 0.0, + 1.0, 0.0, 2.0, + 3.0, 4.0, 5.0, + 6.0, 0.0, 7.0 + ]); + out = new Float64Array( 3 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 1.0, 2.0 ] ); + expectedScale = new Float64Array( [ 0.0, 0.0, 0.0, 1.0, 0.5, 1.0 ] ); + expectedA = new Float64Array([ + 0.0, 0.0, + 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, 2, 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 = both with complex input (column-major) (offsets)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 0.0, 0.0, + 1.0, 3.0, 6.0, + 0.0, 4.0, 0.0, + 2.0, 5.0, 7.0 + ]); + out = new Float64Array( 3 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 1.0, 2.0 ] ); + expectedScale = new Float64Array( [ 0.0, 0.0, 0.0, 1.0, 0.5, 1.0 ] ); + expectedA = new Float64Array([ + 0.0, 0.0, + 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, 2, 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 zero norm (row-major) (offsets)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 0.0, 0.0, + 1.0, 0.0, 4.0, + 2.0, 0.0, 5.0, + 3.0, 0.0, 6.0 + ]); + out = new Float64Array( 3 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 2.0 ] ); + expectedScale = new Float64Array( [ 0.0, 0.0, 0.0, 1.0, 1.0, 1.0 ] ); + expectedA = new Float64Array([ + 0.0, 0.0, + 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, 2, 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 zero norm (column-major) (offsets)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 0.0, 0.0, + 1.0, 2.0, 3.0, + 0.0, 0.0, 0.0, + 4.0, 5.0, 6.0 + ]); + out = new Float64Array( 3 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 2.0 ] ); + expectedScale = new Float64Array( [ 0.0, 0.0, 0.0, 1.0, 1.0, 1.0 ] ); + expectedA = new Float64Array([ + 0.0, 0.0, + 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, 2, 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 (row-major) (offsets)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 0.0, 0.0, + 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( 3 ); + scale = new Float64Array( 7 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 3.0 ] ); + expectedScale = new Float64Array( [ 0.0, 0.0, 0.0, 4096.0, 128.0, 128.0, 1.0 ] ); // eslint-disable-line max-len + expectedA = new Float64Array([ + 0.0, 0.0, + 1.0e-4, 3.125e-2, 6.25e-2, 2.44140625, + 6.4e-3, 1.0, 2.0, 1.5625e2, + 9.6e-3, 1.0, 2.0, 2.34375e2, + 1.6384, 1.28e2, 2.56e2, 4.0e4 + ]); + + info = dgebal( 'scale', 4, A, 4, 1, 2, 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) (offsets)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 0.0, 0.0, + 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( 3 ); + scale = new Float64Array( 7 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 3.0 ] ); + expectedScale = new Float64Array( [ 0.0, 0.0, 0.0, 4096.0, 128.0, 128.0, 1.0 ] ); // eslint-disable-line max-len + expectedA = new Float64Array([ + 0.0, 0.0, + 1.0e-4, 6.4e-3, 9.6e-3, 1.6384, + 3.125e-2, 1.0, 1.0, 1.28e2, + 6.25e-2, 2.0, 2.0, 2.56e2, + 2.44140625, 1.5625e2, 2.34375e2, 4.0e4 + ]); + + info = dgebal( 'scale', 4, A, 1, 4, 2, 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(); +}); From f6fcf1d20852e286c9749b42f310fa1cb230cc57 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Thu, 15 May 2025 09:53:27 +0000 Subject: [PATCH 21/22] test: add tests for mixed strides --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../lapack/base/dgebal/test/test.ndarray.js | 470 ++++++++++++++++++ 1 file changed, 470 insertions(+) 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 index d6d161ccb44f..aba2c27d9b6a 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js @@ -1812,3 +1812,473 @@ tape( 'the function returns expected values for job = scale with small values (c t.deepEqual( scale, expectedScale, 'returns expected value' ); t.end(); }); + +tape( 'the function returns expected values for job = none (row-major) (mixed strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 3.0, 2.0, 1.0, + 6.0, 5.0, 4.0, + 9.0, 8.0, 7.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([ + 3.0, 2.0, 1.0, + 6.0, 5.0, 4.0, + 9.0, 8.0, 7.0 + ]); + + info = dgebal( 'none', 3, A, 3, -1, 2, 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) (mixed strides)', 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 + ]); + + A = new Float64Array([ + 7.0, 4.0, 1.0, + 8.0, 5.0, 2.0, + 9.0, 6.0, 3.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([ + 7.0, 4.0, 1.0, + 8.0, 5.0, 2.0, + 9.0, 6.0, 3.0 + ]); + + info = dgebal( 'both', 3, A, -1, 3, 2, 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) (mixed strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 2.0, 0.0, 1.0, + 0.0, 5.0, 0.0, + 4.0, 0.0, 3.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([ + 0.0, 2.0, 1.0, + 0.0, 4.0, 3.0, + 5.0, 0.0, 0.0 + ]); + + info = dgebal( 'permutate', 3, A, 3, -1, 2, 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) (mixed 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, 1.0, + 0.0, 5.0, 0.0, + 4.0, 0.0, 2.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([ + 0.0, 3.0, 1.0, + 0.0, 4.0, 2.0, + 5.0, 0.0, 0.0 + ]); + info = dgebal( 'both', 3, A, -1, 3, 2, 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) (mixed 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 + ]); + + 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([ + 2.0, 2.0, 16.0, + 0.25, 0.25, 2.0, + 0.25, 0.25, 2.0 + ]); + + info = dgebal( 'scale', 3, A, 3, -1, 2, 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) (mixed 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( [ 0.0, 2.0 ] ); + expectedScale = new Float64Array( [ 1.0, 0.125, 0.125 ] ); + expectedA = new Float64Array([ + 2.0, 2.0, 16.0, + 0.25, 0.25, 2.0, + 0.25, 0.25, 2.0 + ]); + + info = dgebal( 'scale', 3, A, -1, 3, 2, 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) (mixed strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 2.0, 0.0, 1.0, + 0.0, 5.0, 0.0, + 4.0, 0.0, 100.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([ + 0.0, 16.0, 1.0, + 0.0, 4.0, 12.5, + 5.0, 0.0, 0.0 + ]); + + info = dgebal( 'both', 3, A, 3, -1, 2, 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) (mixed strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 100.0, 0.0, 1.0, + 0.0, 5.0, 0.0, + 4.0, 0.0, 2.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([ + 0.0, 12.5, 1.0, + 0.0, 4.0, 16.0, + 5.0, 0.0, 0.0 + ]); + info = dgebal( 'both', 3, A, -1, 3, 2, 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) (mixed strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 0.0, 1.0, 1.0, + 0.0, 2.0, 0.0, + 3.0, 0.0, 0.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([ + 0.0, 1.0, 1.0, + 0.0, 2.0, 0.0, + 3.0, 0.0, 0.0 + ]); + + info = dgebal( 'both', 3, A, 3, -1, 2, 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) (mixed strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 0.0, 0.0, 1.0, + 0.0, 2.0, 1.0, + 3.0, 0.0, 0.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([ + 0.0, 0.0, 1.0, + 0.0, 2.0, 1.0, + 3.0, 0.0, 0.0 + ]); + + info = dgebal( 'both', 3, A, -1, 3, 2, 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) (mixed strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 2.0, 0.0, 1.0, + 5.0, 4.0, 3.0, + 7.0, 0.0, 6.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([ + 5.0, 1.5, 4.0, + 4.0, 1.0, 0.0, + 7.0, 3.0, 0.0 + ]); + + info = dgebal( 'both', 3, A, 3, -1, 2, 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) (mixed strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 6.0, 3.0, 1.0, + 0.0, 4.0, 0.0, + 7.0, 5.0, 2.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([ + 0.0, 0.0, 4.0, + 3.0, 1.0, 1.5, + 7.0, 4.0, 5.0 + ]); + info = dgebal( 'both', 3, A, -1, 3, 2, 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) (mixed 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, 1.0, + 5.0, 0.0, 2.0, + 6.0, 0.0, 3.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([ + 4.0, 0.0, 1.0, + 5.0, 0.0, 2.0, + 6.0, 0.0, 3.0 + ]); + + info = dgebal( 'scale', 3, A, 3, -1, 2, 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) (mixed strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 3.0, 2.0, 1.0, + 0.0, 0.0, 0.0, + 6.0, 5.0, 4.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([ + 3.0, 2.0, 1.0, + 0.0, 0.0, 0.0, + 6.0, 5.0, 4.0 + ]); + + info = dgebal( 'scale', 3, A, -1, 3, 2, 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(); +}); From f6054c2784e7d7c8d766051af9ebcedac9372bdb Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Thu, 15 May 2025 11:30:17 +0000 Subject: [PATCH 22/22] test: add tests for large strides --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../lapack/base/dgebal/test/test.ndarray.js | 463 ++++++++++++++++++ 1 file changed, 463 insertions(+) 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 index aba2c27d9b6a..9beebac33266 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgebal/test/test.ndarray.js @@ -2282,3 +2282,466 @@ tape( 'the function returns expected values for job = scale with zero norm (colu t.deepEqual( scale, expectedScale, 'returns expected value' ); t.end(); }); + +tape( 'the function returns expected values for job = none (row-major) (large strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 1.0, 9999.0, 2.0, 9999.0, 3.0, 9999.0, + 4.0, 9999.0, 5.0, 9999.0, 6.0, 9999.0, + 7.0, 9999.0, 8.0, 9999.0, 9.0, 9999.0 + ]); + out = new Float64Array( 4 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 2.0, 0.0 ] ); + expectedScale = new Float64Array( [ 1.0, 0.0, 1.0, 0.0, 1.0, 0.0 ] ); + expectedA = new Float64Array([ + 1.0, 9999.0, 2.0, 9999.0, 3.0, 9999.0, + 4.0, 9999.0, 5.0, 9999.0, 6.0, 9999.0, + 7.0, 9999.0, 8.0, 9999.0, 9.0, 9999.0 + ]); + + info = dgebal( 'none', 3, A, 6, 2, 0, out, 2, 0, scale, 2, 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) (large strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 1.0, 9999.0, 4.0, 9999.0, 7.0, 9999.0, + 2.0, 9999.0, 5.0, 9999.0, 8.0, 9999.0, + 3.0, 9999.0, 6.0, 9999.0, 9.0, 9999.0 + ]); + out = new Float64Array( 4 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 2.0, 0.0 ] ); + expectedScale = new Float64Array( [ 1.0, 0.0, 1.0, 0.0, 1.0, 0.0 ] ); + expectedA = new Float64Array([ + 1.0, 9999.0, 4.0, 9999.0, 7.0, 9999.0, + 2.0, 9999.0, 5.0, 9999.0, 8.0, 9999.0, + 3.0, 9999.0, 6.0, 9999.0, 9.0, 9999.0 + ]); + + info = dgebal( 'both', 3, A, 2, 6, 0, out, 2, 0, scale, 2, 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) (large strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 1.0, 9999.0, 0.0, 9999.0, 2.0, 9999.0, + 0.0, 9999.0, 5.0, 9999.0, 0.0, 9999.0, + 3.0, 9999.0, 0.0, 9999.0, 4.0, 9999.0 + ]); + out = new Float64Array( 4 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 1.0, 0.0 ] ); + expectedScale = new Float64Array( [ 1.0, 0.0, 1.0, 0.0, 1.0, 0.0 ] ); + expectedA = new Float64Array([ + 1.0, 9999.0, 2.0, 9999.0, 0.0, 9999.0, + 3.0, 9999.0, 4.0, 9999.0, 0.0, 9999.0, + 0.0, 9999.0, 0.0, 9999.0, 5.0, 9999.0 + ]); + + info = dgebal( 'permutate', 3, A, 6, 2, 0, out, 2, 0, scale, 2, 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) (large strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 1.0, 9999.0, 0.0, 9999.0, 3.0, 9999.0, + 0.0, 9999.0, 5.0, 9999.0, 0.0, 9999.0, + 2.0, 9999.0, 0.0, 9999.0, 4.0, 9999.0 + ]); + out = new Float64Array( 4 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 1.0, 0.0 ] ); + expectedScale = new Float64Array( [ 1.0, 0.0, 1.0, 0.0, 1.0, 0.0 ] ); + expectedA = new Float64Array([ + 1.0, 9999.0, 3.0, 9999.0, 0.0, 9999.0, + 2.0, 9999.0, 4.0, 9999.0, 0.0, 9999.0, + 0.0, 9999.0, 0.0, 9999.0, 5.0, 9999.0 + ]); + + info = dgebal( 'permutate', 3, A, 6, 2, 0, out, 2, 0, scale, 2, 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) (large strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 16.0, 9999.0, 16.0, 9999.0, 16.0, 9999.0, + 0.25, 9999.0, 0.25, 9999.0, 0.25, 9999.0, + 0.25, 9999.0, 0.25, 9999.0, 0.25, 9999.0 + ]); + out = new Float64Array( 4 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 2.0, 0.0 ] ); + expectedScale = new Float64Array( [ 1.0, 0.0, 0.125, 0.0, 0.125, 0.0 ] ); + expectedA = new Float64Array([ + 16.0, 9999.0, 2.0, 9999.0, 2.0, 9999.0, + 2.0, 9999.0, 0.25, 9999.0, 0.25, 9999.0, + 2.0, 9999.0, 0.25, 9999.0, 0.25, 9999.0 + ]); + + info = dgebal( 'scale', 3, A, 6, 2, 0, out, 2, 0, scale, 2, 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) (large strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 16.0, 9999.0, 0.25, 9999.0, 0.25, 9999.0, + 16.0, 9999.0, 0.25, 9999.0, 0.25, 9999.0, + 16.0, 9999.0, 0.25, 9999.0, 0.25, 9999.0 + ]); + out = new Float64Array( 4 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 2.0, 0.0 ] ); + expectedScale = new Float64Array( [ 1.0, 0.0, 0.125, 0.0, 0.125, 0.0 ] ); + expectedA = new Float64Array([ + 16.0, 9999.0, 2.0, 9999.0, 2.0, 9999.0, + 2.0, 9999.0, 0.25, 9999.0, 0.25, 9999.0, + 2.0, 9999.0, 0.25, 9999.0, 0.25, 9999.0 + ]); + + info = dgebal( 'scale', 3, A, 2, 6, 0, out, 2, 0, scale, 2, 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) (large strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 1.0, 9999.0, 0.0, 9999.0, 2.0, 9999.0, + 0.0, 9999.0, 5.0, 9999.0, 0.0, 9999.0, + 100.0, 9999.0, 0.0, 9999.0, 4.0, 9999.0 + ]); + out = new Float64Array( 4 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 1.0, 0.0 ] ); + expectedScale = new Float64Array( [ 0.125, 0.0, 1.0, 0.0, 1.0, 0.0 ] ); + expectedA = new Float64Array([ + 1.0, 9999.0, 16.0, 9999.0, 0.0, 9999.0, + 12.5, 9999.0, 4.0, 9999.0, 0.0, 9999.0, + 0.0, 9999.0, 0.0, 9999.0, 5.0, 9999.0 + ]); + + info = dgebal( 'both', 3, A, 6, 2, 0, out, 2, 0, scale, 2, 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) (large strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 1.0, 9999.0, 0.0, 9999.0, 100.0, 9999.0, + 0.0, 9999.0, 5.0, 9999.0, 0.0, 9999.0, + 2.0, 9999.0, 0.0, 9999.0, 4.0, 9999.0 + ]); + out = new Float64Array( 4 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 1.0, 0.0 ] ); + expectedScale = new Float64Array( [ 0.125, 0.0, 1.0, 0.0, 1.0, 0.0 ] ); + expectedA = new Float64Array([ + 1.0, 9999.0, 12.5, 9999.0, 0.0, 9999.0, + 16.0, 9999.0, 4.0, 9999.0, 0.0, 9999.0, + 0.0, 9999.0, 0.0, 9999.0, 5.0, 9999.0 + ]); + + info = dgebal( 'both', 3, A, 2, 6, 0, out, 2, 0, scale, 2, 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) (large strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 1.0, 9999.0, 1.0, 9999.0, 0.0, 9999.0, + 0.0, 9999.0, 2.0, 9999.0, 0.0, 9999.0, + 0.0, 9999.0, 0.0, 9999.0, 3.0, 9999.0 + ]); + out = new Float64Array( 4 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + expectedScale = new Float64Array( [ 0.0, 0.0, 1.0, 0.0, 2.0, 0.0 ] ); + expectedA = new Float64Array([ + 1.0, 9999.0, 1.0, 9999.0, 0.0, 9999.0, + 0.0, 9999.0, 2.0, 9999.0, 0.0, 9999.0, + 0.0, 9999.0, 0.0, 9999.0, 3.0, 9999.0 + ]); + + info = dgebal( 'both', 3, A, 6, 2, 0, out, 2, 0, scale, 2, 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) (large strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 1.0, 9999.0, 0.0, 9999.0, 0.0, 9999.0, + 1.0, 9999.0, 2.0, 9999.0, 0.0, 9999.0, + 0.0, 9999.0, 0.0, 9999.0, 3.0, 9999.0 + ]); + out = new Float64Array( 4 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] ); + expectedScale = new Float64Array( [ 0.0, 0.0, 1.0, 0.0, 2.0, 0.0 ] ); + expectedA = new Float64Array([ + 1.0, 9999.0, 0.0, 9999.0, 0.0, 9999.0, + 1.0, 9999.0, 2.0, 9999.0, 0.0, 9999.0, + 0.0, 9999.0, 0.0, 9999.0, 3.0, 9999.0 + ]); + + info = dgebal( 'both', 3, A, 2, 6, 0, out, 2, 0, scale, 2, 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) (large strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 1.0, 9999.0, 0.0, 9999.0, 2.0, 9999.0, + 3.0, 9999.0, 4.0, 9999.0, 5.0, 9999.0, + 6.0, 9999.0, 0.0, 9999.0, 7.0, 9999.0 + ]); + out = new Float64Array( 4 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 1.0, 0.0, 2.0, 0.0 ] ); + expectedScale = new Float64Array( [ 1.0, 0.0, 0.5, 0.0, 1.0, 0.0 ] ); + expectedA = new Float64Array([ + 4.0, 9999.0, 1.5, 9999.0, 5.0, 9999.0, + 0.0, 9999.0, 1.0, 9999.0, 4.0, 9999.0, + 0.0, 9999.0, 3.0, 9999.0, 7.0, 9999.0 + ]); + + info = dgebal( 'both', 3, A, 6, 2, 0, out, 2, 0, scale, 2, 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) (large strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 1.0, 9999.0, 3.0, 9999.0, 6.0, 9999.0, + 0.0, 9999.0, 4.0, 9999.0, 0.0, 9999.0, + 2.0, 9999.0, 5.0, 9999.0, 7.0, 9999.0 + ]); + out = new Float64Array( 4 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 1.0, 0.0, 2.0, 0.0 ] ); + expectedScale = new Float64Array( [ 1.0, 0.0, 0.5, 0.0, 1.0, 0.0 ] ); + expectedA = new Float64Array([ + 4.0, 9999.0, 0.0, 9999.0, 0.0, 9999.0, + 1.5, 9999.0, 1.0, 9999.0, 3.0, 9999.0, + 5.0, 9999.0, 4.0, 9999.0, 7.0, 9999.0 + ]); + + info = dgebal( 'both', 3, A, 2, 6, 0, out, 2, 0, scale, 2, 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) (large strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 1.0, 9999.0, 0.0, 9999.0, 4.0, 9999.0, + 2.0, 9999.0, 0.0, 9999.0, 5.0, 9999.0, + 3.0, 9999.0, 0.0, 9999.0, 6.0, 9999.0 + ]); + out = new Float64Array( 4 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 2.0, 0.0 ] ); + expectedScale = new Float64Array( [ 1.0, 0.0, 1.0, 0.0, 1.0, 0.0 ] ); + expectedA = new Float64Array([ + 1.0, 9999.0, 0.0, 9999.0, 4.0, 9999.0, + 2.0, 9999.0, 0.0, 9999.0, 5.0, 9999.0, + 3.0, 9999.0, 0.0, 9999.0, 6.0, 9999.0 + ]); + + info = dgebal( 'scale', 3, A, 6, 2, 0, out, 2, 0, scale, 2, 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) (large strides)', function test( t ) { + var expectedScale; + var expectedOut; + var expectedA; + var scale; + var info; + var out; + var A; + + A = new Float64Array([ + 1.0, 9999.0, 2.0, 9999.0, 3.0, 9999.0, + 0.0, 9999.0, 0.0, 9999.0, 0.0, 9999.0, + 4.0, 9999.0, 5.0, 9999.0, 6.0, 9999.0 + ]); + out = new Float64Array( 4 ); + scale = new Float64Array( 6 ); + + expectedOut = new Float64Array( [ 0.0, 0.0, 2.0, 0.0 ] ); + expectedScale = new Float64Array( [ 1.0, 0.0, 1.0, 0.0, 1.0, 0.0 ] ); + expectedA = new Float64Array([ + 1.0, 9999.0, 2.0, 9999.0, 3.0, 9999.0, + 0.0, 9999.0, 0.0, 9999.0, 0.0, 9999.0, + 4.0, 9999.0, 5.0, 9999.0, 6.0, 9999.0 + ]); + + info = dgebal( 'scale', 3, A, 2, 6, 0, out, 2, 0, scale, 2, 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(); +});