From 1f6e76b509dd9a3e498863c8df1c48edf298deef Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Sun, 8 Jun 2025 15:36:04 +0000 Subject: [PATCH 01/32] feat: add lapack/base/dlatrs --- 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/dlatrs/lib/base.js | 518 ++++++++++++++++++ .../@stdlib/lapack/base/dlatrs/lib/dlange.js | 362 ++++++++++++ 2 files changed, 880 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/lib/dlange.js diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js new file mode 100644 index 000000000000..c41d5ea902b7 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js @@ -0,0 +1,518 @@ +/** +* @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'; + +/* eslint-disable max-len, max-params, max-depth, max-statements, max-lines-per-function, no-lonely-if, max-lines */ + +// MODULES // + +var dlamch = require( '@stdlib/lapack/base/dlamch' ); +var dtrsv = require( '@stdlib/blas/base/dtrsv' ).ndarray; +var idamax = require( '@stdlib/blas/base/idamax' ).ndarray; +var daxpy = require( '@stdlib/blas/base/daxpy' ).ndarray; +var dscal = require( '@stdlib/blas/base/dscal' ).ndarray; +var abs = require( '@stdlib/math/base/special/abs' ); +var max = require( '@stdlib/math/base/special/max' ); +var ddot = require( '@stdlib/blas/base/ddot' ).ndarray; +var min = require( '@stdlib/math/base/special/min' ); +var dasum = require( '@stdlib/blas/base/dasum' ).ndarray; +var dlange = require( './dlange.js' ); + + +// VARIABLES // + +var smlnum = dlamch( 'safe minimum' ) / dlamch( 'precision' ); +var bignum = 1.0 / smlnum; + + +// MAIN // + +/** +* Solves a triangular system of equations with the scale factor set to prevent overflow. +* +* @private +* @param {string} uplo - specifies whether `A` is an upper or lower triangular matrix +* @param {string} trans - specifies whether `A` should be transposed or not transposed +* @param {string} diag - specifies whether `A` has a unit diagonal +* @param {string} normin - specifies whether `CNORM` has been set or not +* @param {NonNegativeInteger} N - number of rows/columns in `A` +* @param {Float64Array} A - input matrix +* @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} X - input vector, specifies the right hand side vector of the equation +* @param {integer} strideX - stride length for `X` +* @param {NonNegativeInteger} offsetX - starting index for `X` +* @param {Float64Array} CNORM - used to store the column norms +* @param {integer} strideCNORM - stride length for `CNORM` +* @param {NonNegativeInteger} offsetCNORM - starting index for `CNORM` +* @returns {number} scaling factor +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var A = new Float64Array( [ 2.0, 1.0, -1.0, 0.0, 3.0, 2.0, 0.0, 0.0, 4.0 ] ); // => [ [ 2.0, 1.0, -1.0 ], [ 0.0, 3.0, 2.0 ], [ 0.0, 0.0, 4.0 ] ] +* var X = new Float64Array( [ 5.0, 10.0, 20,0 ] ); +* var CNORM = new Float64Array( 3 ); +* +* var scale = dlatrs( 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, 1, 0, X, 1, 0, CNORM, 1, 0 ); +* // returns 1.0 +* // X => [ 5.0, 0.0, 5.0 ] +*/ +function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X, strideX, offsetX, CNORM, strideCNORM, offsetCNORM ) { + var jfirst; + var scale; + var jlast; + var tscal; + var uscal; + var GOTO; + var jinc; + var imax; + var tmax; + var xmax; + var grow; + var xbnd; + var tjjs; + var sumj; + var tjj; + var rec; + var ix1; + var ia1; + var ia2; + var ia; + var xj; + var ix; + var ic; + var j; + var i; + + if ( N === 0 ) { + return 1.0; + } + + // Compute the 1 norm of each column excluting the diagonal elements + if ( normin === 'no' ) { + if ( uplo === 'upper' ) { // upper triangular + ic = offsetCNORM; + ia = offsetA; + for ( j = 0; j < N; j++ ) { + CNORM[ ic ] = dasum( j, A, strideA1, ia ); + ia += strideA2; + ic += strideCNORM; + } + } else { // lower triangular + ic = offsetCNORM; + ia = offsetA + strideA1; // follows A( j+1, j ) + for ( j = 0; j < N - 1; j++ ) { + CNORM[ ic ] = dasum( N - ( j + 1 ), A, strideA1, ia ); + ic += strideCNORM; + ia += strideA1 + strideA2; + } + CNORM[ ic ] = 0.0; + } + } + + imax = idamax( N, CNORM, strideCNORM, offsetCNORM ); + tmax = CNORM[ offsetCNORM + ( imax * strideCNORM ) ]; + if ( tmax <= bignum ) { + tscal = 1.0; + } else { + if ( tmax <= dlamch( 'overflow' ) ) { + tscal = 1.0 / ( smlnum * tmax ); + dscal( N, tscal, X, strideX, offsetX ); + } else { + tmax = 0.0; + if ( uplo === 'upper' ) { + ia = offsetA + strideA2; + for ( j = 1; j < N; j++ ) { + tmax = max( dlange( 'max', j, 1, A, strideA1, strideA2, ia ), tmax ); + ia += strideA2; + } + } else { + ia = offsetA + strideA1; + for ( j = 0; j < N - 1; j++ ) { + tmax = max( dlange( 'max', N - ( j + 1 ), 1, A, strideA1, strideA2, ia ), tmax ); + ia += strideA1 + strideA2; + } + } + + if ( tmax <= dlamch( 'overflow' ) ) { + tscal = 1.0 / ( smlnum * tmax ); + ic = offsetCNORM; + ia2 = offsetA; + for ( j = 0; j < N; j++ ) { + if ( CNORM[ ic ] <= dlamch( 'overflow' ) ) { + CNORM[ ic ] *= tscal; + } else { + CNORM[ ic ] = 0.0; + if ( uplo === 'upper' ) { + ia1 = 0; + for ( i = 0; i < j; i++ ) { + CNORM[ ic ] += ( tscal * abs( A[ ia1 + ia2 ] ) ); + ia1 += strideA1; + } + } else { + ia1 = 0; + for ( i = j+1; i < N; i++ ) { + CNORM[ ic ] += ( tscal * abs( A[ ia1 + ia2 ] ) ); + ia1 += strideA1; + } + } + } + ic += strideCNORM; + ia2 += strideA2; + } + } else { + dtrsv( uplo, trans, diag, N, A, strideA1, strideA2, offsetA, X, strideX, offsetX ); + } + } + } + + j = idamax( N, X, strideX, offsetX ); + xmax = abs( X[ offsetX + ( j * strideX ) ] ); + xbnd = xmax; + + if ( trans === 'no-transpose' ) { + if ( uplo === 'upper' ) { + jfirst = N - 1; + jlast = 0; + jinc = -1; + } else { + jfirst = 0; + jlast = N - 1; + jinc = 1; + } + + GOTO = false; + if ( tscal !== 1.0 ) { + grow = 0.0; + GOTO = true; + } + + if ( !GOTO ) { + if ( diag === 'non-unit' ) { + grow = 1.0 / max( xbnd, smlnum ); + xbnd = grow; + ic = offsetCNORM + ( jfirst * strideCNORM ); + ia = offsetA + ( jfirst * ( strideA1 + strideA2 ) ); + for ( j = jfirst; (jinc > 0) ? j <= jlast : j >= jlast; j += jinc ) { + if ( grow <= smlnum ) { + GOTO = true; + break; + } + tjj = abs( A[ ia ] ); + xbnd = min( xbnd, min( 1.0, tjj ) * grow ); + if ( tjj + CNORM[ ic ] >= smlnum ) { + grow *= tjj / ( tjj + CNORM[ ic ] ); + } else { + grow = 0.0; + } + + ia += jinc * ( strideA1 + strideA2 ); + ic += jinc * ( strideCNORM ); + } + if ( !GOTO ) { + grow = xbnd; + } + } else { + grow = min( 1.0, 1.0 / max( xbnd, smlnum ) ); + ic = offsetCNORM + ( jfirst * strideCNORM ); + for ( j = jfirst; (jinc > 0) ? j <= jlast : j >= jlast; j+= jinc ) { + if ( grow <= smlnum ) { + break; + } + grow *= 1.0 / ( 1.0 + CNORM[ ic ] ); + ic += strideCNORM; + } + } + } + } else { + if ( uplo === 'upper' ) { + jfirst = 0; + jlast = N-1; + jinc = 1; + } else { + jfirst = N-1; + jlast = 0; + jinc = -1; + } + + GOTO = false; + if ( tscal !== 1.0 ) { + grow = 0.0; + GOTO = true; + } + + if ( !GOTO ) { + if ( diag === 'non-unit' ) { + grow = 1.0 / max( xbnd, smlnum ); + xbnd = grow; + ia = offsetA + ( jfirst * ( strideA1 + strideA2 ) ); // tracks A( j, j ) + ic = offsetCNORM + ( jfirst * strideCNORM ); // tracks CNORM( j ) + for ( j = jfirst; (jinc > 0) ? j <= jlast : j >= jlast; j+=jinc ) { + if ( grow <= smlnum ) { + GOTO = true; + break; + } + xj = 1.0 + CNORM[ ic ]; + grow = min( grow, xbnd / xj ); + tjj = abs( A[ ia ] ); + if ( xj > tjj ) { + xbnd *= ( tjj / xj ); + } + + ic += jinc * strideCNORM; + ia += jinc * ( strideA1 + strideA2 ); + } + if ( !GOTO ) { + grow = min( grow, xbnd ); + } + } else { + grow = min( 1.0, 1.0 / max( xbnd, smlnum ) ); + ic = offsetCNORM + ( jfirst * strideCNORM ); + for ( j = jfirst; (jinc > 0) ? j <= jlast : j >= jlast; j += jinc ) { + if ( grow <= smlnum ) { + break; + } + xj = 1.0 + CNORM[ ic ]; + grow /= xj; + + ic += jinc * strideCNORM; + } + } + } + } + + if ( grow * tscal > smlnum ) { + dtrsv( uplo, trans, diag, N, A, strideA1, strideA2, offsetA, X, strideX, offsetX ); + scale = 1.0; + } else { + if ( xmax > bignum ) { + scale = bignum / xmax; + dscal( N, scale, X, strideX, offsetX ); + xmax = bignum; + } + + if ( trans === 'no-transpose' ) { + ix = offsetX + ( jfirst * strideX ); // tracks X( j ) + ia = offsetA + ( jfirst * ( strideA1 + strideA2 ) ); // tracks A( j, j ) + ia1 = offsetA + ( jfirst * strideA2 ); // tracks A( 1, j ) + ic = offsetCNORM + ( jfirst * strideCNORM ); // tracks CNORM( j ) + + for ( j = jfirst; (jinc > 0) ? j <= jlast : j >= jlast; j += jinc ) { + xj = abs( X[ ix ] ); + if ( diag === 'non-unit' ) { + tjjs = A[ ia ] * tscal; + } else { + tjjs = tscal; + GOTO = false; + if ( tscal === 1.0 ) { + GOTO = true; + } + } + + if ( !GOTO ) { + tjj = abs( tjjs ); + if ( tjj > smlnum ) { + if ( tjj < 1.0 ) { + if ( xj > tjj * bignum ) { + rec = 1.0 / xj; + dscal( N, rec, X, strideX, offsetX ); + scale *= rec; + xmax *= rec; + } + } + X[ ix ] /= tjjs; + xj = abs( X[ ix ] ); + } else if ( tjj > 0.0 ) { + if ( xj > tjj * bignum ) { + rec = ( tjj * bignum ) / xj; + if ( CNORM[ ic ] > 1.0 ) { + rec /= CNORM[ ic ]; + } + dscal( N, rec, X, strideX, offsetX ); + scale *= rec; + xmax *= rec; + } + X[ ix ] /= tjjs; + xj = abs( X[ ix ] ); + } else { + ix1 = offsetX; + for ( i = 0; i < N; i++ ) { + X[ ix1 ] = 0.0; + ix1 += strideX; + } + scale = 0.0; + xmax = 0.0; + } + } + + if ( xj > 1.0 ) { + rec = 1.0 / xj; + if ( CNORM[ ic ] > ( bignum - xmax ) * rec ) { + rec *= 0.5; + dscal( N, rec, X, strideX, offsetX ); + scale *= rec; + } + } else if ( xj * CNORM[ ic ] > ( bignum - xmax ) ) { + dscal( N, 0.5, X, strideX, offsetX ); + scale *= 0.5; + } + + if ( uplo === 'upper' ) { + if ( j > 0 ) { + daxpy( j, -1 * tscal * X[ ix ], A, strideA1, ia1, X, strideX, offsetX ); + } + i = idamax( j, X, strideX, offsetX ); + xmax = abs( X[ offsetX + ( i * strideX ) ] ); + } else { + if ( j < N - 1 ) { + daxpy( N - ( j + 1 ), -1 * tscal * X[ ix ], A, strideA1, ia + strideA1, X, strideX, ix + strideX ); + i = idamax( N - ( j + 1 ), X, strideX, ix + strideX ); + xmax = abs( X[ offsetX + ( i * strideX ) ] ); + } + } + + ix += jinc * strideX; + ia += jinc * ( strideA1 + strideA2 ); + ia1 += jinc * strideA2; + ic += jinc * strideCNORM; + } + } else { + ix = offsetX + ( jfirst * strideX ); // tracks X( j ) + ia = offsetA + ( jfirst * ( strideA1 + strideA2 ) ); // tracks A( j, j ) + ia1 = offsetA + ( jfirst * strideA2 ); // tracks A( 1, j ) + ic = offsetCNORM + ( jfirst * strideCNORM ); // tracks CNORM( j ) + for ( j = jfirst; (jinc > 0) ? j <= jlast : j >= jlast; j += jinc ) { + xj = abs( X[ ix ] ); + uscal = tscal; + rec = 1.0 / max( xmax, 1.0 ); + if ( CNORM[ ic ] > ( bignum - xj ) * rec ) { + rec *= 0.5; + if ( diag === 'non-unit' ) { + tjjs = A[ ia ] * tscal; + } else { + tjjs = tscal; + } + tjj = abs( tjjs ); + if ( tjj > 1.0 ) { + rec = min( 1.0, rec * tjj ); + uscal /= tjjs; + } + if ( rec < 1.0 ) { + dscal( N, rec, strideX, offsetX ); + scale *= rec; + xmax *= rec; + } + sumj = 0.0; + + if ( uscal === 1.0 ) { + if ( uplo === 'upper' ) { + sumj = ddot( j, A, strideA1, ia1, X, strideX, offsetX ); + } else { + sumj = ddot( N - ( j + 1 ), A, strideA1, ia + strideA1, X, strideX, ix + strideX ); + } + } else { + if ( uplo === 'upper' ) { + ia2 = 0; + ix1 = offsetX; + for ( i = 0; i < j; i++ ) { + sumj += A[ ia1 + ia2 ] * uscal * X[ ix1 ]; + ia2 += strideA1; + ix1 += strideX; + } + } else { + ia2 = ( j + 1 ) * strideA1; + ix1 = offsetX + ( ( j + 1 ) * strideX ); + for ( i = j + 1; i < N; i++ ) { + sumj += A[ ia1 + ia2 ] * uscal * X[ ix1 ]; + ia2 += strideA1; + ix1 += strideX; + } + } + } + } + + if ( uscal === tscal ) { + X[ ix ] -= sumj; + xj = abs( X[ ix ] ); + if ( diag === 'non-unit' ) { + tjjs = A[ ia ] * tscal; + } else { + tjjs = tscal; + GOTO = false; + if ( tscal === 1.0 ) { + GOTO = true; + } + } + + if ( !GOTO ) { + tjj = abs( tjjs ); + if ( tjj > smlnum ) { + if ( tjj < 1.0 ) { + if ( xj > tjj * bignum ) { + rec /= xj; + dscal( N, rec, X, strideX, offsetX ); + scale *= rec; + xmax *= rec; + } + } + X[ ix ] /= tjjs; + } else if ( tjj > 0.0 ) { + if ( xj > tjj * bignum ) { + rec = tjj * bignum / xj; + dscal( N, rec, X, strideX, offsetX ); + xmax *= rec; + scale *= rec; + } + X[ ix ] /= tjjs; + } else { + ix1 = offsetX; + for ( i = 0; i < N; i++ ) { + X[ ix1 ] = 0.0; + ix1 += strideX; + } + X[ ix ] = 1.0; + scale = 0.0; + xmax = 0.0; + } + X[ ix ] = ( X[ ix ] / tjjs ) - sumj; + } + } + + ix += jinc * strideX; + ia += jinc * ( strideA1 + strideA2 ); + ia1 += jinc * strideA2; + ic += jinc * strideCNORM; + } + } + scale /= tscal; + } + + if ( tscal !== 1.0 ) { + dscal( N, 1.0 / tscal, CNORM, strideCNORM, offsetCNORM ); + } + + return scale; +} + + +// EXPORTS // + +module.exports = dlatrs; diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/dlange.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/dlange.js new file mode 100644 index 000000000000..45fe1aca8f5a --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/dlange.js @@ -0,0 +1,362 @@ +/** +* @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 isnan = require( '@stdlib/math/base/assert/is-nan' ); +var dlassq = require( '@stdlib/lapack/base/dlassq' ).ndarray; +var isRowMajor = require( '@stdlib/ndarray/base/assert/is-row-major' ); +var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' ); +var dasum = require( '@stdlib/blas/base/dasum' ).ndarray; +var Float64Array = require( '@stdlib/array/float64' ); +var min = require( '@stdlib/math/base/special/min' ); +var sqrt = require( '@stdlib/math/base/special/sqrt' ); +var abs = require( '@stdlib/math/base/special/abs' ); + + +// FUNCTIONS // + +/** +* Returns the value of the one norm of a real matrix `A`. +* +* @private +* @param {NonNegativeInteger} M - number of rows in `A` +* @param {NonNegativeInteger} N - number of columns in `A` +* @param {Float64Array} A - input array +* @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 of `A` +* @param {Float64Array} work - work array, should have `N` indexed elements if row-major layout is used +* @param {integer} strideWork - stride length of `work` +* @param {NonNegativeInteger} offsetWork - starting index of `work` +* @returns {number} required norm value +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var A = new Float64Array( [ 1.0, 4.0, 7.0, 10.0, 2.0, 5.0, 8.0, 11.0, 3.0, 6.0, 9.0, 12.0 ] ); +* var work = new Float64Array( 4 ); +* +* var out = oneNorm( 3, 4, A, 4, 1, 0, work, 1, 0 ); +* // returns 33.0 +*/ +function oneNorm( M, N, A, strideA1, strideA2, offsetA, work, strideWork, offsetWork ) { // eslint-disable-line max-len + var value; + var temp; + var ia1; + var ia2; + var sum; + var iw; + var i; + var j; + + if ( isRowMajor( [ strideA1, strideA2 ] ) ) { + iw = offsetWork; + for ( i = 0; i < N; i++ ) { + work[ iw ] = 0.0; + iw += strideWork; + } + + ia1 = offsetA; + for ( j = 0; j < M; j++ ) { + ia2 = 0; + iw = offsetWork; + for ( i = 0; i < N; i++ ) { + work[ iw ] += abs( A[ ia1 + ia2 ] ); + iw += strideWork; + ia2 += strideA2; + } + ia1 += strideA1; + } + + value = 0.0; + + iw = offsetWork; + for ( i = 0; i < N; i++ ) { + temp = work[ iw ]; + if ( value < temp || isnan( temp ) ) { + value = temp; + } + iw += strideWork; + } + } else { + value = 0.0; + ia1 = offsetA; + for ( j = 0; j < N; j++ ) { + sum = dasum( M, A, strideA1, ia1 ); + if ( value < sum || isnan( sum ) ) { + value = sum; + } + ia1 += strideA2; + } + } + + return value; +} + +/** +* Returns the absolute value of the maximum element of a real matrix `A`. +* +* @private +* @param {NonNegativeInteger} M - number of rows in `A` +* @param {NonNegativeInteger} N - number of columns in `A` +* @param {Float64Array} A - input array +* @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 of `A` +* @returns {number} required norm value +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var A = new Float64Array( [ 1.0, 4.0, 7.0, 10.0, 2.0, 5.0, 8.0, 11.0, 3.0, 6.0, 9.0, 12.0 ] ); +* +* var out = maxAbs( 3, 4, A, 4, 1, 0 ); +* // returns 12.0 +*/ +function maxAbs( M, N, A, strideA1, strideA2, offsetA ) { + var value; + var temp; + var da0; + var da1; + var ia; + var sa; + var sh; + var S0; + var S1; + var o; + var i; + var j; + + value = 0.0; + + // Resolve the loop interchange order: + o = loopOrder( [ M, N ], [ strideA1, strideA2 ] ); + sh = o.sh; + sa = o.sx; + S0 = sh[ 0 ]; + S1 = sh[ 1 ]; + da0 = sa[ 0 ]; + da1 = sa[ 1 ] - ( S0*sa[0] ); + ia = offsetA; + + for ( i = 0; i < S1; i++ ) { + for ( j = 0; j < S0; j++ ) { + temp = A[ ia ]; + if ( value < temp || isnan( temp ) ) { + value = temp; + } + ia += da0; + } + ia += da1; + } + return value; +} + +/** +* Returns the value of the infinity norm of a real matrix `A`. +* +* @private +* @param {NonNegativeInteger} M - number of rows in `A` +* @param {NonNegativeInteger} N - number of columns in `A` +* @param {Float64Array} A - input array +* @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 of `A` +* @param {Float64Array} work - work array, should have `M` indexed elements if column-major layout is used +* @param {integer} strideWork - stride length of `work` +* @param {NonNegativeInteger} offsetWork - starting index of `work` +* @returns {number} required norm value +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var A = new Float64Array( [ 1.0, 4.0, 7.0, 10.0, 2.0, 5.0, 8.0, 11.0, 3.0, 6.0, 9.0, 12.0 ] ); +* var work = new Float64Array( 3 ); +* +* var out = infinityNorm( 3, 4, A, 4, 1, 0, work, 1, 0 ); +* // returns 30.0 +*/ +function infinityNorm( M, N, A, strideA1, strideA2, offsetA, work, strideWork, offsetWork ) { // eslint-disable-line max-len + var value; + var temp; + var sum; + var ia1; + var ia2; + var iw; + var i; + var j; + + if ( isRowMajor( [ strideA1, strideA2 ] ) ) { + value = 0.0; + ia1 = offsetA; + for ( j = 0; j < M; j++ ) { + sum = dasum( N, A, strideA2, ia1 ); + if ( value < sum || isnan( sum ) ) { + value = sum; + } + ia1 += strideA1; + } + } else { + iw = offsetWork; + for ( i = 0; i < M; i++ ) { + work[ iw ] = 0.0; + iw += strideWork; + } + + ia1 = offsetA; + for ( j = 0; j < N; j++ ) { + ia2 = 0; + iw = offsetWork; + for ( i = 0; i < M; i++ ) { + work[ iw ] += abs( A[ ia1 + ia2 ] ); + iw += strideWork; + ia2 += strideA1; + } + ia1 += strideA2; + } + + value = 0.0; + + iw = offsetWork; + for ( i = 0; i < M; i++ ) { + temp = work[ iw ]; + if ( value < temp || isnan( temp ) ) { + value = temp; + } + iw += strideWork; + } + } + return value; +} + +/** +* Returns the absolute value of the frobenius norm of a real matrix `A`. +* +* @private +* @param {NonNegativeInteger} M - number of rows in `A` +* @param {NonNegativeInteger} N - number of columns in `A` +* @param {Float64Array} A - input array +* @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 of `A` +* @returns {number} required norm value +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var A = new Float64Array( [ 1.0, 4.0, 7.0, 10.0, 2.0, 5.0, 8.0, 11.0, 3.0, 6.0, 9.0, 12.0 ] ); +* +* var out = frobeniusNorm( 3, 4, A, 4, 1, 0 ); +* // returns ~25.5 +*/ +function frobeniusNorm( M, N, A, strideA1, strideA2, offsetA ) { + var out; + var da0; + var da1; + var S1; + var S2; + var ia; + var i; + + out = new Float64Array( [ 0.0, 1.0 ] ); + + if ( isRowMajor( [ strideA1, strideA2 ] ) ) { + S1 = M; + S2 = N; + da0 = strideA2; + da1 = strideA1; + } else { + S1 = N; + S2 = M; + da0 = strideA1; + da1 = strideA2; + } + + ia = offsetA; + for ( i = 0; i < S1; i++ ) { + dlassq( S2, A, da0, ia, out[ 0 ], out[ 1 ], out, 1, 0 ); + ia += da1; + } + + return out[ 0 ] * sqrt( out[ 1 ] ); +} + + +// MAIN // + +/** +* Returns the value of the one norm, or the frobenius norm, or the infinity norm, or the element with the largest absolute value of a real matrix `A`. +* +* ## Notes +* +* - use `norm` = `max` to calculate the element with the largest absolute value +* - use `norm` = `one` to calculate the one norm, work should have `N` indexed elements if row-major layout is used +* - use `norm` = `infinity` to calculate the infinity norm, work should have `M` indexed elements if column-major layout is used +* - use `norm` = `frobenius` to calculate the frobenius norm +* +* @private +* @param {string} norm - specifies the type of norm to be calculated +* @param {NonNegativeInteger} M - number of rows in `A` +* @param {NonNegativeInteger} N - number of columns in `A` +* @param {Float64Array} A - input array +* @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 of `A` +* @param {Float64Array} work - temporary workspace array +* @param {integer} strideWork - stride length of `work` +* @param {NonNegativeInteger} offsetWork - starting index of `work` +* @returns {number} required norm value +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var A = new Float64Array( [ 1.0, 4.0, 7.0, 10.0, 2.0, 5.0, 8.0, 11.0, 3.0, 6.0, 9.0, 12.0 ] ); +* var work = new Float64Array( 3 ); +* +* var out = dlange( 'frobenius', 3, 4, A, 4, 1, 0, work, 1, 0 ); +* // returns ~25.5 +*/ +function dlange( norm, M, N, A, strideA1, strideA2, offsetA, work, strideWork, offsetWork ) { // eslint-disable-line max-len + if ( min( M, N ) === 0 ) { + return 0.0; + } + + if ( norm === 'max' ) { + return maxAbs( M, N, A, strideA1, strideA2, offsetA ); + } + + if ( norm === 'one' ) { + return oneNorm( M, N, A, strideA1, strideA2, offsetA, work, strideWork, offsetWork ); // eslint-disable-line max-len + } + + if ( norm === 'infinity' ) { + return infinityNorm( M, N, A, strideA1, strideA2, offsetA, work, strideWork, offsetWork ); // eslint-disable-line max-len + } + + if ( norm === 'frobenius' ) { + return frobeniusNorm( M, N, A, strideA1, strideA2, offsetA ); + } +} + + +// EXPORTS // + +module.exports = dlange; From 7870b48bbccb18f478f702780a44233c82d1ffae Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Mon, 9 Jun 2025 07:50:54 +0000 Subject: [PATCH 02/32] 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/dlatrs/lib/dlatrs.js | 103 ++++++++++++++++++ .../@stdlib/lapack/base/dlatrs/lib/index.js | 60 ++++++++++ .../@stdlib/lapack/base/dlatrs/lib/main.js | 35 ++++++ .../@stdlib/lapack/base/dlatrs/lib/ndarray.js | 88 +++++++++++++++ 4 files changed, 286 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/lib/dlatrs.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/lib/index.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/lib/main.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/lib/ndarray.js diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/dlatrs.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/dlatrs.js new file mode 100644 index 000000000000..139531268d03 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/dlatrs.js @@ -0,0 +1,103 @@ +/** +* @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 isRowMajor = require( '@stdlib/ndarray/base/assert/is-row-major-string' ); +var isMatrixTriangle = require( '@stdlib/blas/base/assert/is-matrix-triangle' ); +var isDiagonalType = require( '@stdlib/blas/base/assert/is-diagonal-type' ); +var isTransposeOperation = require( '@stdlib/blas/base/assert/is-transpose-operation' ); +var isColumnMajor = require( '@stdlib/ndarray/base/assert/is-column-major-string' ); +var max = require( '@stdlib/math/base/special/max' ); +var format = require( '@stdlib/string/format' ); +var base = require( './base.js' ); + + +// MAIN // + +/** +* Solves a triangular system of equations with the scale factor set to prevent overflow. +* +* @param {string} order - storage layout +* @param {string} uplo - specifies whether `A` is an upper or lower triangular matrix +* @param {string} trans - specifies whether `A` should be transposed or not transposed +* @param {string} diag - specifies whether `A` has a unit diagonal +* @param {string} normin - specifies whether `CNORM` has been set or not +* @param {NonNegativeInteger} N - number of rows/columns in `A` +* @param {Float64Array} A - input matrix +* @param {PositiveInteger} LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) +* @param {Float64Array} X - input vector, specifies the right hand side vector of the equation +* @param {Float64Array} CNORM - used to store the column norms +* @throws {TypeError} first argument must be a valid order +* @throws {TypeError} second argument must be a valid matrix triangle +* @throws {TypeError} third argument must be a valid transpose opeartion +* @throws {TypeError} fourth argument must be a valid diagonal type +* @throws {TypeError} fifth argument must be either yes or no +* @throws {RangeError} eighth argument must be greater than or equal to max(1,N) +* @returns {number} scaling factor +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var A = new Float64Array( [ 2.0, 1.0, -1.0, 0.0, 3.0, 2.0, 0.0, 0.0, 4.0 ] ); // => [ [ 2.0, 1.0, -1.0 ], [ 0.0, 3.0, 2.0 ], [ 0.0, 0.0, 4.0 ] ] +* var X = new Float64Array( [ 5.0, 10.0, 20,0 ] ); +* var CNORM = new Float64Array( 3 ); +* +* var scale = dlatrs( 'row-major', 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, X, CNORM ); +* // returns 1.0 +* // X => [ 5.0, 0.0, 5.0 ] +*/ +function dlatrs( order, uplo, trans, diag, normin, N, A, LDA, X, CNORM ) { + var sa1; + var sa2; + + if ( !isLayout( order ) ) { + throw new TypeError( format( 'invalid argument. First argument must be a valid order. Value: `%s`.', order ) ); + } + if ( !isMatrixTriangle( uplo ) ) { + throw new TypeError( format( 'invalid argument. Second argument must be a valid side. Value: `%s`.', uplo ) ); + } + if ( !isTransposeOperation( trans ) ) { + throw new TypeError( format( 'invalid argument. Third argument must be a valid transpose operation. Value: `%s`.', trans ) ); + } + if ( !isDiagonalType( diag ) ) { + throw new TypeError( format( 'invalid argument. Second argument must be a valid diagonal type. Value: `%s`.', diag ) ); + } + if ( isRowMajor( order ) && LDA < max( 1, N ) ) { + throw new RangeError( format( 'invalid argument. Sixth argument must be greater than or equal to max(1,%d). Value: `%d`.', N, LDA ) ); + } + if ( normin !== 'yes' && normin !== 'no' ) { + throw new TypeError( format( 'invalid argument. Fifth argument must be either yes or no. Value: `%d`.', normin ) ); + } + if ( isColumnMajor( order ) ) { + sa1 = 1; + sa2 = LDA; + } else { // order === 'row-major' + sa1 = LDA; + sa2 = 1; + } + return base( uplo, trans, diag, normin, N, A, sa1, sa2, 0, X, 1, 0, CNORM, 1, 0 ); // eslint-disable-line max-len +} + + +// EXPORTS // + +module.exports = dlatrs; diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/index.js new file mode 100644 index 000000000000..2a249939eb2c --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/index.js @@ -0,0 +1,60 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +/** +* LAPACK routine to solve a triangular system of equations with the scale factor set to prevent overflow. +* +* @module @stdlib/lapack/base/dlatrs +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* var dlatrs = require( '@stdlib/lapack/base/dlatrs' ); +* +* var A = new Float64Array( [ 2.0, 1.0, -1.0, 0.0, 3.0, 2.0, 0.0, 0.0, 4.0 ] ); // => [ [ 2.0, 1.0, -1.0 ], [ 0.0, 3.0, 2.0 ], [ 0.0, 0.0, 4.0 ] ] +* var X = new Float64Array( [ 5.0, 10.0, 20,0 ] ); +* var CNORM = new Float64Array( 3 ); +* +* var scale = dlatrs( 'row-major', 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, X, CNORM ); +* // returns 1.0 +* // X => [ 5.0, 0.0, 5.0 ] +*/ + +// MODULES // + +var join = require( 'path' ).join; +var tryRequire = require( '@stdlib/utils/try-require' ); +var isError = require( '@stdlib/assert/is-error' ); +var main = require( './main.js' ); + + +// MAIN // + +var dlatrs; +var tmp = tryRequire( join( __dirname, './native.js' ) ); +if ( isError( tmp ) ) { + dlatrs = main; +} else { + dlatrs = tmp; +} + + +// EXPORTS // + +module.exports = dlatrs; diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/main.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/main.js new file mode 100644 index 000000000000..74831584ee44 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/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 dlatrs = require( './dlatrs.js' ); +var ndarray = require( './ndarray.js' ); + + +// MAIN // + +setReadOnly( dlatrs, 'ndarray', ndarray ); + + +// EXPORTS // + +module.exports = dlatrs; diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/ndarray.js new file mode 100644 index 000000000000..a7f5fe3a09d1 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/ndarray.js @@ -0,0 +1,88 @@ +/** +* @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'; + +/* eslint-disable max-len, max-params */ + +// MODULES // + +var isMatrixTriangle = require( '@stdlib/blas/base/assert/is-matrix-triangle' ); +var isDiagonalType = require( '@stdlib/blas/base/assert/is-diagonal-type' ); +var isTransposeOperation = require( '@stdlib/blas/base/assert/is-transpose-operation' ); +var format = require( '@stdlib/string/format' ); +var base = require( './base.js' ); + + +// MAIN // + +/** +* Solves a triangular system of equations with the scale factor set to prevent overflow. +* +* @param {string} uplo - specifies whether `A` is an upper or lower triangular matrix +* @param {string} trans - specifies whether `A` should be transposed or not transposed +* @param {string} diag - specifies whether `A` has a unit diagonal +* @param {string} normin - specifies whether `CNORM` has been set or not +* @param {NonNegativeInteger} N - number of rows/columns in `A` +* @param {Float64Array} A - input matrix +* @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} X - input vector, specifies the right hand side vector of the equation +* @param {integer} strideX - stride length for `X` +* @param {NonNegativeInteger} offsetX - starting index for `X` +* @param {Float64Array} CNORM - used to store the column norms +* @param {integer} strideCNORM - stride length for `CNORM` +* @param {NonNegativeInteger} offsetCNORM - starting index for `CNORM` +* @throws {TypeError} first argument must be a valid matrix triangle +* @throws {TypeError} second argument must be a valid transpose opeartion +* @throws {TypeError} third argument must be a valid diagonal type +* @throws {TypeError} fourth argument must be either yes or no +* @returns {number} scaling factor +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var A = new Float64Array( [ 2.0, 1.0, -1.0, 0.0, 3.0, 2.0, 0.0, 0.0, 4.0 ] ); // => [ [ 2.0, 1.0, -1.0 ], [ 0.0, 3.0, 2.0 ], [ 0.0, 0.0, 4.0 ] ] +* var X = new Float64Array( [ 5.0, 10.0, 20,0 ] ); +* var CNORM = new Float64Array( 3 ); +* +* var scale = dlatrs( 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, 1, 0, X, 1, 0, CNORM, 1, 0 ); +* // returns 1.0 +* // X => [ 5.0, 0.0, 5.0 ] +*/ +function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X, strideX, offsetX, CNORM, strideCNORM, offsetCNORM ) { + if ( !isMatrixTriangle( uplo ) ) { + throw new TypeError( format( 'invalid argument. Second argument must be a valid side. Value: `%s`.', uplo ) ); + } + if ( !isTransposeOperation( trans ) ) { + throw new TypeError( format( 'invalid argument. Third argument must be a valid transpose operation. Value: `%s`.', trans ) ); + } + if ( !isDiagonalType( diag ) ) { + throw new TypeError( format( 'invalid argument. Second argument must be a valid diagonal type. Value: `%s`.', diag ) ); + } + if ( normin !== 'yes' && normin !== 'no' ) { + throw new TypeError( format( 'invalid argument. Fifth argument must be either yes or no. Value: `%d`.', normin ) ); + } + return base( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X, strideX, offsetX, CNORM, strideCNORM, offsetCNORM ); +} + + +// EXPORTS // + +module.exports = dlatrs; From 51984dc58bc5b108753d2a047f97ce8d06e5d61f Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Mon, 9 Jun 2025 15:11:06 +0000 Subject: [PATCH 03/32] test: 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/dlatrs/lib/base.js | 1 + .../@stdlib/lapack/base/dlatrs/lib/dlatrs.js | 1 + .../@stdlib/lapack/base/dlatrs/lib/index.js | 1 + .../@stdlib/lapack/base/dlatrs/lib/ndarray.js | 1 + .../base/dlatrs/test/fixtures/col_major.json | 34 ++ .../base/dlatrs/test/fixtures/row_major.json | 34 ++ .../lapack/base/dlatrs/test/test.dlatrs.js | 343 ++++++++++++++++++ .../@stdlib/lapack/base/dlatrs/test/test.js | 82 +++++ 8 files changed, 497 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.js diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js index c41d5ea902b7..b2bd74d188ca 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js @@ -74,6 +74,7 @@ var bignum = 1.0 / smlnum; * var scale = dlatrs( 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, 1, 0, X, 1, 0, CNORM, 1, 0 ); * // returns 1.0 * // X => [ 5.0, 0.0, 5.0 ] +* // CNORM => [ 0.0, 1.0, 3.0 ] */ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X, strideX, offsetX, CNORM, strideCNORM, offsetCNORM ) { var jfirst; diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/dlatrs.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/dlatrs.js index 139531268d03..40cf0fe3139a 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/dlatrs.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/dlatrs.js @@ -64,6 +64,7 @@ var base = require( './base.js' ); * var scale = dlatrs( 'row-major', 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, X, CNORM ); * // returns 1.0 * // X => [ 5.0, 0.0, 5.0 ] +* // CNORM => [ 0.0, 1.0, 3.0 ] */ function dlatrs( order, uplo, trans, diag, normin, N, A, LDA, X, CNORM ) { var sa1; diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/index.js index 2a249939eb2c..14249ecf9e44 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/index.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/index.js @@ -34,6 +34,7 @@ * var scale = dlatrs( 'row-major', 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, X, CNORM ); * // returns 1.0 * // X => [ 5.0, 0.0, 5.0 ] +* // CNORM => [ 0.0, 1.0, 3.0 ] */ // MODULES // diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/ndarray.js index a7f5fe3a09d1..4c27a29ec74e 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/ndarray.js @@ -65,6 +65,7 @@ var base = require( './base.js' ); * var scale = dlatrs( 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, 1, 0, X, 1, 0, CNORM, 1, 0 ); * // returns 1.0 * // X => [ 5.0, 0.0, 5.0 ] +* // CNORM => [ 0.0, 1.0, 3.0 ] */ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X, strideX, offsetX, CNORM, strideCNORM, offsetCNORM ) { if ( !isMatrixTriangle( uplo ) ) { diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/col_major.json new file mode 100644 index 000000000000..2d483b7363f7 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/col_major.json @@ -0,0 +1,34 @@ +{ + "order": "column-major", + + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 2.0, 0.0, 0.0, 1.0, 3.0, 0.0, -1.0, 2.0, 4.0 ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 0, + + "A_mat": [ + [ 2.0, 1.0, -1.0 ], + [ 0.0, 3.0, 2.0 ], + [ 0.0, 0.0, 4.0 ] + ], + + "X": [ 5.0, 10.0, 20.0 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 5.0, 0.0, 5.0 ], + "expectedCNORM": [ 0.0, 1.0, 3.0 ], + "scale": 1.0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/row_major.json new file mode 100644 index 000000000000..a442288a57c8 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/row_major.json @@ -0,0 +1,34 @@ +{ + "order": "row-major", + + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 2.0, 1.0, -1.0, 0.0, 3.0, 2.0, 0.0, 0.0, 4.0 ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 0, + + "A_mat": [ + [ 2.0, 1.0, -1.0 ], + [ 0.0, 3.0, 2.0 ], + [ 0.0, 0.0, 4.0 ] + ], + + "X": [ 5.0, 10.0, 20.0 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 5.0, 0.0, 5.0 ], + "expectedCNORM": [ 0.0, 1.0, 3.0 ], + "scale": 1.0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js new file mode 100644 index 000000000000..287617ddfd0d --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js @@ -0,0 +1,343 @@ +/** +* @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 */ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var Float64Array = require( '@stdlib/array/float64' ); +var dlatrs = require( './../lib/dlatrs.js' ); + + +// FIXTURES // + +var ROW_MAJOR = require( './fixtures/row_major.json' ); +var COL_MAJOR = require( './fixtures/col_major.json' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof dlatrs, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 10', function test( t ) { + t.strictEqual( dlatrs.length, 10, 'returns expected value' ); + t.end(); +}); + +tape( 'the function throws an error if provided a first argument which is not a valid order', function test( t ) { + var values; + var CNORM; + var data; + var A; + var X; + var i; + + data = COL_MAJOR; + + A = new Float64Array( data.A ); + X = new Float64Array( data.X ); + CNORM = new Float64Array( data.CNORM ); + + values = [ + 'foo', + 'bar', + 'beep', + 'boop', + -5, + NaN, + true, + false, + null, + void 0, + [], + {}, + function noop() {} + ]; + + 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() { + dlatrs( value, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + }; + } +}); + +tape( 'the function throws an error if provided a second argument which is not a valid matrix triangle', function test( t ) { + var values; + var CNORM; + var data; + var A; + var X; + var i; + + data = COL_MAJOR; + + A = new Float64Array( data.A ); + X = new Float64Array( data.X ); + CNORM = new Float64Array( data.CNORM ); + + values = [ + 'foo', + 'bar', + 'beep', + 'boop', + -5, + NaN, + true, + false, + null, + void 0, + [], + {}, + function noop() {} + ]; + + 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() { + dlatrs( data.order, value, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + }; + } +}); + +tape( 'the function throws an error if provided a third argument which is not a valid transpose operation', function test( t ) { + var values; + var CNORM; + var data; + var A; + var X; + var i; + + data = COL_MAJOR; + + A = new Float64Array( data.A ); + X = new Float64Array( data.X ); + CNORM = new Float64Array( data.CNORM ); + + values = [ + 'foo', + 'bar', + 'beep', + 'boop', + -5, + NaN, + true, + false, + null, + void 0, + [], + {}, + function noop() {} + ]; + + 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() { + dlatrs( data.order, data.uplo, value, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + }; + } +}); + +tape( 'the function throws an error if provided a fourth argument which is not a valid diagonal type', function test( t ) { + var values; + var CNORM; + var data; + var A; + var X; + var i; + + data = COL_MAJOR; + + A = new Float64Array( data.A ); + X = new Float64Array( data.X ); + CNORM = new Float64Array( data.CNORM ); + + values = [ + 'foo', + 'bar', + 'beep', + 'boop', + -5, + NaN, + true, + false, + null, + void 0, + [], + {}, + function noop() {} + ]; + + 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() { + dlatrs( data.order, data.uplo, data.trans, value, data.normin, data.N, A, data.LDA, X, CNORM ); + }; + } +}); + +tape( 'the function throws an error if provided a fifth argument which is not yes or no', function test( t ) { + var values; + var CNORM; + var data; + var A; + var X; + var i; + + data = COL_MAJOR; + + A = new Float64Array( data.A ); + X = new Float64Array( data.X ); + CNORM = new Float64Array( data.CNORM ); + + values = [ + 'foo', + 'bar', + 'beep', + 'boop', + -5, + NaN, + true, + false, + null, + void 0, + [], + {}, + function noop() {} + ]; + + 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() { + dlatrs( value, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + }; + } +}); + +tape( 'the function throws an error if provided the seventh argument is not a valid LDA value', function test( t ) { + var values; + var CNORM; + var data; + var A; + var X; + var i; + + data = ROW_MAJOR; + + A = new Float64Array( data.A ); + X = new Float64Array( data.X ); + CNORM = new Float64Array( data.CNORM ); + + values = [ + 0, + 1, + 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() { + dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, value, X, CNORM ); + }; + } +}); + +tape( 'the function returns expected output for normal values (row-major)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.js new file mode 100644 index 000000000000..fe1f198c0c31 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.js @@ -0,0 +1,82 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var proxyquire = require( 'proxyquire' ); +var IS_BROWSER = require( '@stdlib/assert/is-browser' ); +var dlatrs = 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 dlatrs, '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 dlatrs.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 dlatrs = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire + }); + + t.strictEqual( dlatrs, 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 dlatrs; + var main; + + main = require( './../lib/dlatrs.js' ); + + dlatrs = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire + }); + + t.strictEqual( dlatrs, main, 'returns expected value' ); + t.end(); + + function tryRequire() { + return new Error( 'Cannot find module' ); + } +}); From ee429f04c8a356cdc516c7f3f1b762dc53fd43ac Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Tue, 10 Jun 2025 04:42:19 +0000 Subject: [PATCH 04/32] test: add lower triangular cases --- 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 --- --- .../fixtures/no_trans_lower_col_major.json | 34 ++++++ .../fixtures/no_trans_lower_row_major.json | 34 ++++++ ...jor.json => no_trans_upper_col_major.json} | 0 ...jor.json => no_trans_upper_row_major.json} | 0 .../lapack/base/dlatrs/test/test.dlatrs.js | 107 ++++++++++++++++-- 5 files changed, 163 insertions(+), 12 deletions(-) create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/no_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/no_trans_lower_row_major.json rename lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/{col_major.json => no_trans_upper_col_major.json} (100%) rename lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/{row_major.json => no_trans_upper_row_major.json} (100%) diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/no_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/no_trans_lower_col_major.json new file mode 100644 index 000000000000..85c8e576db6e --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/no_trans_lower_col_major.json @@ -0,0 +1,34 @@ +{ + "order": "column-major", + + "uplo": "lower", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 2.0, 1.0, -1.0, 0.0, 3.0, 2.0, 0.0, 0.0, 4.0 ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 0, + + "A_mat": [ + [ 2.0, 0.0, 0.0 ], + [ 1.0, 3.0, 0.0 ], + [ -1.0, 2.0, 4.0 ] + ], + + "X": [ 5.0, 10.0, 20.0 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 2.5, 2.5, 4.375 ], + "expectedCNORM": [ 2.0, 2.0, 0.0 ], + "scale": 1.0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/no_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/no_trans_lower_row_major.json new file mode 100644 index 000000000000..270fe94e0316 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/no_trans_lower_row_major.json @@ -0,0 +1,34 @@ +{ + "order": "row-major", + + "uplo": "lower", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 2.0, 0.0, 0.0, 1.0, 3.0, 0.0, -1.0, 2.0, 4.0 ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 0, + + "A_mat": [ + [ 2.0, 0.0, 0.0 ], + [ 1.0, 3.0, 0.0 ], + [ -1.0, 2.0, 4.0 ] + ], + + "X": [ 5.0, 10.0, 20.0 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 2.5, 2.5, 4.375 ], + "expectedCNORM": [ 2.0, 2.0, 0.0 ], + "scale": 1.0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/no_trans_upper_col_major.json similarity index 100% rename from lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/col_major.json rename to lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/no_trans_upper_col_major.json diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/no_trans_upper_row_major.json similarity index 100% rename from lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/row_major.json rename to lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/no_trans_upper_row_major.json diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js index 287617ddfd0d..6519308393dc 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js @@ -29,8 +29,10 @@ var dlatrs = require( './../lib/dlatrs.js' ); // FIXTURES // -var ROW_MAJOR = require( './fixtures/row_major.json' ); -var COL_MAJOR = require( './fixtures/col_major.json' ); +var NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/no_trans_upper_row_major.json' ); +var NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/no_trans_upper_col_major.json' ); +var NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/no_trans_lower_row_major.json' ); +var NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/no_trans_lower_col_major.json' ); // TESTS // @@ -54,7 +56,7 @@ tape( 'the function throws an error if provided a first argument which is not a var X; var i; - data = COL_MAJOR; + data = NO_TRANS_UPPER_COL_MAJOR; A = new Float64Array( data.A ); X = new Float64Array( data.X ); @@ -96,7 +98,7 @@ tape( 'the function throws an error if provided a second argument which is not a var X; var i; - data = COL_MAJOR; + data = NO_TRANS_UPPER_COL_MAJOR; A = new Float64Array( data.A ); X = new Float64Array( data.X ); @@ -138,7 +140,7 @@ tape( 'the function throws an error if provided a third argument which is not a var X; var i; - data = COL_MAJOR; + data = NO_TRANS_UPPER_COL_MAJOR; A = new Float64Array( data.A ); X = new Float64Array( data.X ); @@ -180,7 +182,7 @@ tape( 'the function throws an error if provided a fourth argument which is not a var X; var i; - data = COL_MAJOR; + data = NO_TRANS_UPPER_COL_MAJOR; A = new Float64Array( data.A ); X = new Float64Array( data.X ); @@ -222,7 +224,7 @@ tape( 'the function throws an error if provided a fifth argument which is not ye var X; var i; - data = COL_MAJOR; + data = NO_TRANS_UPPER_COL_MAJOR; A = new Float64Array( data.A ); X = new Float64Array( data.X ); @@ -264,7 +266,7 @@ tape( 'the function throws an error if provided the seventh argument is not a va var X; var i; - data = ROW_MAJOR; + data = NO_TRANS_UPPER_ROW_MAJOR; A = new Float64Array( data.A ); X = new Float64Array( data.X ); @@ -288,7 +290,7 @@ tape( 'the function throws an error if provided the seventh argument is not a va } }); -tape( 'the function returns expected output for normal values (row-major)', function test( t ) { +tape( 'the function returns the arrays unchanged for N = 0', function test( t ) { var expectedCNORM; var expectedX; var scale; @@ -297,7 +299,88 @@ tape( 'the function returns expected output for normal values (row-major)', func var A; var X; - data = ROW_MAJOR; + data = NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.CNORM ); + expectedX = new Float64Array( data.X ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, 0, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (no-transpose)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (no-transpose)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (no-transpose)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NO_TRANS_LOWER_ROW_MAJOR; A = new Float64Array( data.A ); CNORM = new Float64Array( data.CNORM ); @@ -315,7 +398,7 @@ tape( 'the function returns expected output for normal values (row-major)', func t.end(); }); -tape( 'the function returns expected output for normal values (column-major)', function test( t ) { +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (no-transpose)', function test( t ) { var expectedCNORM; var expectedX; var scale; @@ -324,7 +407,7 @@ tape( 'the function returns expected output for normal values (column-major)', f var A; var X; - data = COL_MAJOR; + data = NO_TRANS_LOWER_COL_MAJOR; A = new Float64Array( data.A ); CNORM = new Float64Array( data.CNORM ); From 11847456a4169696c5aa53a12806768ba4715323 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Tue, 10 Jun 2025 13:06:04 +0000 Subject: [PATCH 05/32] test: cleaning 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 --- --- ...=> non_unit_no_trans_lower_col_major.json} | 0 ...=> non_unit_no_trans_lower_row_major.json} | 0 ...=> non_unit_no_trans_upper_col_major.json} | 0 ...=> non_unit_no_trans_upper_row_major.json} | 0 .../lapack/base/dlatrs/test/test.dlatrs.js | 40 +++++++++---------- 5 files changed, 20 insertions(+), 20 deletions(-) rename lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/{no_trans_lower_col_major.json => non_unit_no_trans_lower_col_major.json} (100%) rename lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/{no_trans_lower_row_major.json => non_unit_no_trans_lower_row_major.json} (100%) rename lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/{no_trans_upper_col_major.json => non_unit_no_trans_upper_col_major.json} (100%) rename lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/{no_trans_upper_row_major.json => non_unit_no_trans_upper_row_major.json} (100%) diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/no_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_no_trans_lower_col_major.json similarity index 100% rename from lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/no_trans_lower_col_major.json rename to lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_no_trans_lower_col_major.json diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/no_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_no_trans_lower_row_major.json similarity index 100% rename from lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/no_trans_lower_row_major.json rename to lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_no_trans_lower_row_major.json diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/no_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_no_trans_upper_col_major.json similarity index 100% rename from lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/no_trans_upper_col_major.json rename to lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_no_trans_upper_col_major.json diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/no_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_no_trans_upper_row_major.json similarity index 100% rename from lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/no_trans_upper_row_major.json rename to lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_no_trans_upper_row_major.json diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js index 6519308393dc..e157ecea51c5 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js @@ -16,7 +16,7 @@ * limitations under the License. */ -/* eslint-disable max-len */ +/* eslint-disable max-len, id-length */ 'use strict'; @@ -29,10 +29,10 @@ var dlatrs = require( './../lib/dlatrs.js' ); // FIXTURES // -var NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/no_trans_upper_row_major.json' ); -var NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/no_trans_upper_col_major.json' ); -var NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/no_trans_lower_row_major.json' ); -var NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/no_trans_lower_col_major.json' ); +var NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/non_unit_no_trans_upper_row_major.json' ); +var NON_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/non_unit_no_trans_upper_col_major.json' ); +var NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/non_unit_no_trans_lower_row_major.json' ); +var NON_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/non_unit_no_trans_lower_col_major.json' ); // TESTS // @@ -56,7 +56,7 @@ tape( 'the function throws an error if provided a first argument which is not a var X; var i; - data = NO_TRANS_UPPER_COL_MAJOR; + data = NON_UNIT_NO_TRANS_UPPER_COL_MAJOR; A = new Float64Array( data.A ); X = new Float64Array( data.X ); @@ -98,7 +98,7 @@ tape( 'the function throws an error if provided a second argument which is not a var X; var i; - data = NO_TRANS_UPPER_COL_MAJOR; + data = NON_UNIT_NO_TRANS_UPPER_COL_MAJOR; A = new Float64Array( data.A ); X = new Float64Array( data.X ); @@ -140,7 +140,7 @@ tape( 'the function throws an error if provided a third argument which is not a var X; var i; - data = NO_TRANS_UPPER_COL_MAJOR; + data = NON_UNIT_NO_TRANS_UPPER_COL_MAJOR; A = new Float64Array( data.A ); X = new Float64Array( data.X ); @@ -182,7 +182,7 @@ tape( 'the function throws an error if provided a fourth argument which is not a var X; var i; - data = NO_TRANS_UPPER_COL_MAJOR; + data = NON_UNIT_NO_TRANS_UPPER_COL_MAJOR; A = new Float64Array( data.A ); X = new Float64Array( data.X ); @@ -224,7 +224,7 @@ tape( 'the function throws an error if provided a fifth argument which is not ye var X; var i; - data = NO_TRANS_UPPER_COL_MAJOR; + data = NON_UNIT_NO_TRANS_UPPER_COL_MAJOR; A = new Float64Array( data.A ); X = new Float64Array( data.X ); @@ -266,7 +266,7 @@ tape( 'the function throws an error if provided the seventh argument is not a va var X; var i; - data = NO_TRANS_UPPER_ROW_MAJOR; + data = NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR; A = new Float64Array( data.A ); X = new Float64Array( data.X ); @@ -299,7 +299,7 @@ tape( 'the function returns the arrays unchanged for N = 0', function test( t ) var A; var X; - data = NO_TRANS_UPPER_ROW_MAJOR; + data = NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR; A = new Float64Array( data.A ); CNORM = new Float64Array( data.CNORM ); @@ -317,7 +317,7 @@ tape( 'the function returns the arrays unchanged for N = 0', function test( t ) t.end(); }); -tape( 'the function returns expected output for normal values (row-major) (upper triangular) (no-transpose)', function test( t ) { +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (no-transpose) (non-unit)', function test( t ) { var expectedCNORM; var expectedX; var scale; @@ -326,7 +326,7 @@ tape( 'the function returns expected output for normal values (row-major) (upper var A; var X; - data = NO_TRANS_UPPER_ROW_MAJOR; + data = NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR; A = new Float64Array( data.A ); CNORM = new Float64Array( data.CNORM ); @@ -344,7 +344,7 @@ tape( 'the function returns expected output for normal values (row-major) (upper t.end(); }); -tape( 'the function returns expected output for normal values (column-major) (upper triangular) (no-transpose)', function test( t ) { +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (no-transpose) (non-unit)', function test( t ) { var expectedCNORM; var expectedX; var scale; @@ -353,7 +353,7 @@ tape( 'the function returns expected output for normal values (column-major) (up var A; var X; - data = NO_TRANS_UPPER_COL_MAJOR; + data = NON_UNIT_NO_TRANS_UPPER_COL_MAJOR; A = new Float64Array( data.A ); CNORM = new Float64Array( data.CNORM ); @@ -371,7 +371,7 @@ tape( 'the function returns expected output for normal values (column-major) (up t.end(); }); -tape( 'the function returns expected output for normal values (row-major) (lower triangular) (no-transpose)', function test( t ) { +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (no-transpose) (non-unit)', function test( t ) { var expectedCNORM; var expectedX; var scale; @@ -380,7 +380,7 @@ tape( 'the function returns expected output for normal values (row-major) (lower var A; var X; - data = NO_TRANS_LOWER_ROW_MAJOR; + data = NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR; A = new Float64Array( data.A ); CNORM = new Float64Array( data.CNORM ); @@ -398,7 +398,7 @@ tape( 'the function returns expected output for normal values (row-major) (lower t.end(); }); -tape( 'the function returns expected output for normal values (column-major) (lower triangular) (no-transpose)', function test( t ) { +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (no-transpose) (non-unit)', function test( t ) { var expectedCNORM; var expectedX; var scale; @@ -407,7 +407,7 @@ tape( 'the function returns expected output for normal values (column-major) (lo var A; var X; - data = NO_TRANS_LOWER_COL_MAJOR; + data = NON_UNIT_NO_TRANS_LOWER_COL_MAJOR; A = new Float64Array( data.A ); CNORM = new Float64Array( data.CNORM ); From 025d5f8ae0dcfb568a4d4f92d87c1aed2602728e Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Tue, 10 Jun 2025 14:49:04 +0000 Subject: [PATCH 06/32] test: add transpose cases --- 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 --- --- .../non_unit_trans_lower_col_major.json | 34 ++++++ .../non_unit_trans_lower_row_major.json | 34 ++++++ .../non_unit_trans_upper_col_major.json | 34 ++++++ .../non_unit_trans_upper_row_major.json | 34 ++++++ .../lapack/base/dlatrs/test/test.dlatrs.js | 113 ++++++++++++++++++ 5 files changed, 249 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_trans_upper_row_major.json diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_trans_lower_col_major.json new file mode 100644 index 000000000000..4c855990bb17 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_trans_lower_col_major.json @@ -0,0 +1,34 @@ +{ + "order": "column-major", + + "uplo": "lower", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 2.0, 1.0, -1.0, 0.0, 3.0, 2.0, 0.0, 0.0, 4.0 ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 0, + + "A_mat": [ + [ 2.0, 0.0, 0.0 ], + [ 1.0, 3.0, 0.0 ], + [ -1.0, 2.0, 4.0 ] + ], + + "X": [ 2.0, 5.0, 4.0 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 1.0, 1.0, 1.0 ], + "expectedCNORM": [ 2.0, 2.0, 0.0 ], + "scale": 1.0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_trans_lower_row_major.json new file mode 100644 index 000000000000..0271c89738d2 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_trans_lower_row_major.json @@ -0,0 +1,34 @@ +{ + "order": "row-major", + + "uplo": "lower", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 2.0, 0.0, 0.0, 1.0, 3.0, 0.0, -1.0, 2.0, 4.0 ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 0, + + "A_mat": [ + [ 2.0, 0.0, 0.0 ], + [ 1.0, 3.0, 0.0 ], + [ -1.0, 2.0, 4.0 ] + ], + + "X": [ 2.0, 5.0, 4.0 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 1.0, 1.0, 1.0 ], + "expectedCNORM": [ 2.0, 2.0, 0.0 ], + "scale": 1.0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_trans_upper_col_major.json new file mode 100644 index 000000000000..3ef3961c2378 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_trans_upper_col_major.json @@ -0,0 +1,34 @@ +{ + "order": "column-major", + + "uplo": "upper", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 2.0, 1.0, 0.0, 1.0, 3.0, 0.0, -1.0, 2.0, 4.0 ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 0, + + "A_mat": [ + [ 2.0, 1.0, -1.0 ], + [ 1.0, 3.0, 2.0 ], + [ 0.0, 0.0, 4.0 ] + ], + + "X": [ 2.0, 5.0, 4.0 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 1.0, 1.3333333333333333, 0.58333333333333337 ], + "expectedCNORM": [ 0.0, 1.0, 3.0 ], + "scale": 1.0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_trans_upper_row_major.json new file mode 100644 index 000000000000..340edb41e14c --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/non_unit_trans_upper_row_major.json @@ -0,0 +1,34 @@ +{ + "order": "row-major", + + "uplo": "upper", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 2.0, 1.0, -1.0, 0.0, 3.0, 2.0, 0.0, 0.0, 4.0 ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 0, + + "A_mat": [ + [ 2.0, 1.0, -1.0 ], + [ 1.0, 3.0, 2.0 ], + [ 0.0, 0.0, 4.0 ] + ], + + "X": [ 2.0, 5.0, 4.0 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 1.0, 1.3333333333333333, 0.58333333333333337 ], + "expectedCNORM": [ 0.0, 1.0, 3.0 ], + "scale": 1.0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js index e157ecea51c5..a70eea1c3866 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js @@ -34,6 +34,11 @@ var NON_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/non_unit_no_trans_u var NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/non_unit_no_trans_lower_row_major.json' ); var NON_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/non_unit_no_trans_lower_col_major.json' ); +var NON_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/non_unit_trans_lower_row_major.json' ); +var NON_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/non_unit_trans_lower_col_major.json' ); +var NON_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/non_unit_trans_upper_row_major.json' ); +var NON_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/non_unit_trans_upper_col_major.json' ); + // TESTS // @@ -424,3 +429,111 @@ tape( 'the function returns expected output for normal values (column-major) (lo t.end(); }); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NON_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NON_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NON_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NON_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); From d90cd037828c2e7f6e446c4b9166c4c698fae3ee Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Tue, 10 Jun 2025 16:27:15 +0000 Subject: [PATCH 07/32] test: add more cases for unit diagonal --- 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/dlatrs/lib/base.js | 1 + .../unit_no_trans_lower_col_major.json | 34 ++++++ .../unit_no_trans_lower_row_major.json | 34 ++++++ .../unit_no_trans_upper_col_major.json | 34 ++++++ .../unit_no_trans_upper_row_major.json | 34 ++++++ .../lapack/base/dlatrs/test/test.dlatrs.js | 113 ++++++++++++++++++ 6 files changed, 250 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_no_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_no_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_no_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_no_trans_upper_row_major.json diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js index b2bd74d188ca..2dc85e9848ec 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js @@ -103,6 +103,7 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X var j; var i; + scale = 1.0; if ( N === 0 ) { return 1.0; } diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_no_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_no_trans_lower_col_major.json new file mode 100644 index 000000000000..167ce59f9435 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_no_trans_lower_col_major.json @@ -0,0 +1,34 @@ +{ + "order": "column-major", + + "uplo": "lower", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0, 2.0, 3.0, 0.0, 1.0, -1.0, 0.0, 0.0, 1.0 ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 0, + + "A_mat": [ + [ 1.0, 0.0, 0.0 ], + [ 2.0, 1.0, 0.0 ], + [ 3.0, -1.0, 1.0 ] + ], + + "X": [ 1.0, 3.0, 3.0 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 1.0, 1.0, 1.0 ], + "expectedCNORM": [ 5.0, 1.0, 0.0 ], + "scale": 1.0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_no_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_no_trans_lower_row_major.json new file mode 100644 index 000000000000..8518ca33fef2 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_no_trans_lower_row_major.json @@ -0,0 +1,34 @@ +{ + "order": "row-major", + + "uplo": "lower", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0, 0.0, 0.0, 2.0, 1.0, 0.0, 3.0, -1.0, 1.0 ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 0, + + "A_mat": [ + [ 1.0, 0.0, 0.0 ], + [ 2.0, 1.0, 0.0 ], + [ 3.0, -1.0, 1.0 ] + ], + + "X": [ 1.0, 3.0, 3.0 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 1.0, 1.0, 1.0 ], + "expectedCNORM": [ 5.0, 1.0, 0.0 ], + "scale": 1.0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_no_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_no_trans_upper_col_major.json new file mode 100644 index 000000000000..89f8741de1c0 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_no_trans_upper_col_major.json @@ -0,0 +1,34 @@ +{ + "order": "column-major", + + "uplo": "upper", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0, 0.0, 0.0, 2.0, 1.0, 0.0, -1.0, 3.0, 1.0 ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 0, + + "A_mat": [ + [ 1.0, 2.0, -1.0 ], + [ 0.0, 1.0, 3.0 ], + [ 0.0, 0.0, 1.0 ] + ], + + "X": [ 2.0, 4.0, 1.0 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 1.0, 1.0, 1.0 ], + "expectedCNORM": [ 0.0, 2.0, 4.0 ], + "scale": 1.0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_no_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_no_trans_upper_row_major.json new file mode 100644 index 000000000000..4b73fcf04eed --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_no_trans_upper_row_major.json @@ -0,0 +1,34 @@ +{ + "order": "row-major", + + "uplo": "upper", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0, 2.0, -1.0, 0.0, 1.0, 3.0, 0.0, 0.0, 1.0 ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 0, + + "A_mat": [ + [ 1.0, 2.0, -1.0 ], + [ 0.0, 1.0, 3.0 ], + [ 0.0, 0.0, 1.0 ] + ], + + "X": [ 2.0, 4.0, 1.0 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 1.0, 1.0, 1.0 ], + "expectedCNORM": [ 0.0, 2.0, 4.0 ], + "scale": 1.0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js index a70eea1c3866..58ce973ee75b 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js @@ -39,6 +39,11 @@ var NON_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/non_unit_trans_lower_c var NON_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/non_unit_trans_upper_row_major.json' ); var NON_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/non_unit_trans_upper_col_major.json' ); +var UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/unit_no_trans_lower_row_major.json' ); +var UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/unit_no_trans_lower_col_major.json' ); +var UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/unit_no_trans_upper_row_major.json' ); +var UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/unit_no_trans_upper_col_major.json' ); + // TESTS // @@ -537,3 +542,111 @@ tape( 'the function returns expected output for normal values (column-major) (up t.end(); }); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (no-transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (no-transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (no-transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (no-transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); From 2fc31d0b5d6241138ca279b1869923f244bb1488 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Wed, 11 Jun 2025 05:16:04 +0000 Subject: [PATCH 08/32] test: mmore 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 --- --- .../fixtures/unit_trans_lower_col_major.json | 34 ++++++ .../fixtures/unit_trans_lower_row_major.json | 34 ++++++ .../fixtures/unit_trans_upper_col_major.json | 34 ++++++ .../fixtures/unit_trans_upper_row_major.json | 34 ++++++ .../lapack/base/dlatrs/test/test.dlatrs.js | 113 ++++++++++++++++++ 5 files changed, 249 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_trans_upper_row_major.json diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_trans_lower_col_major.json new file mode 100644 index 000000000000..cd06bd588160 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_trans_lower_col_major.json @@ -0,0 +1,34 @@ +{ + "order": "column-major", + + "uplo": "lower", + "trans": "transpose", + "diag": "unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0, 4.0, 2.0, 0.0, 1.0, -1.0, 0.0, 0.0, 1.0 ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 0, + + "A_mat": [ + [ 1.0, 0.0, 0.0 ], + [ 4.0, 1.0, 0.0 ], + [ 2.0, -1.0, 1.0 ] + ], + + "X": [ 7.0, 0.0, 1.0 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 1.0, 1.0, 1.0 ], + "expectedCNORM": [ 6.0, 1.0, 0.0 ], + "scale": 1.0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_trans_lower_row_major.json new file mode 100644 index 000000000000..2ae89ee1228a --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_trans_lower_row_major.json @@ -0,0 +1,34 @@ +{ + "order": "row-major", + + "uplo": "lower", + "trans": "transpose", + "diag": "unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0, 0.0, 0.0, 4.0, 1.0, 0.0, 2.0, -1.0, 1.0 ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 0, + + "A_mat": [ + [ 1.0, 0.0, 0.0 ], + [ 4.0, 1.0, 0.0 ], + [ 2.0, -1.0, 1.0 ] + ], + + "X": [ 7.0, 0.0, 1.0 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 1.0, 1.0, 1.0 ], + "expectedCNORM": [ 6.0, 1.0, 0.0 ], + "scale": 1.0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_trans_upper_col_major.json new file mode 100644 index 000000000000..b8879864b700 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_trans_upper_col_major.json @@ -0,0 +1,34 @@ +{ + "order": "column-major", + + "uplo": "upper", + "trans": "transpose", + "diag": "unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0, 0.0, 0.0, 2.0, 1.0, 0.0, 3.0, 4.0, 1.0 ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 0, + + "A_mat": [ + [ 1.0, 2.0, 3.0 ], + [ 0.0, 1.0, 4.0 ], + [ 0.0, 0.0, 1.0 ] + ], + + "X": [ 1.0, 3.0, 8.0 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 1.0, 1.0, 1.0 ], + "expectedCNORM": [ 0.0, 2.0, 7.0 ], + "scale": 1.0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_trans_upper_row_major.json new file mode 100644 index 000000000000..f4a2325b203b --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/unit_trans_upper_row_major.json @@ -0,0 +1,34 @@ +{ + "order": "row-major", + + "uplo": "upper", + "trans": "transpose", + "diag": "unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0, 2.0, 3.0, 0.0, 1.0, 4.0, 0.0, 0.0, 1.0 ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 0, + + "A_mat": [ + [ 1.0, 2.0, 3.0 ], + [ 0.0, 1.0, 4.0 ], + [ 0.0, 0.0, 1.0 ] + ], + + "X": [ 1.0, 3.0, 8.0 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 1.0, 1.0, 1.0 ], + "expectedCNORM": [ 0.0, 2.0, 7.0 ], + "scale": 1.0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js index 58ce973ee75b..1ad4060a6054 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js @@ -44,6 +44,11 @@ var UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/unit_no_trans_lower_col var UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/unit_no_trans_upper_row_major.json' ); var UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/unit_no_trans_upper_col_major.json' ); +var UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/unit_trans_lower_row_major.json' ); +var UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/unit_trans_lower_col_major.json' ); +var UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/unit_trans_upper_row_major.json' ); +var UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/unit_trans_upper_col_major.json' ); + // TESTS // @@ -650,3 +655,111 @@ tape( 'the function returns expected output for normal values (column-major) (up t.end(); }); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); From 826c7668eeb4975d2a28852e7d872f5ae06a3846 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Wed, 11 Jun 2025 06:19:15 +0000 Subject: [PATCH 09/32] test: add scaled 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/dlatrs/lib/base.js | 2 +- ...led_non_unit_no_trans_lower_col_major.json | 34 +++++++++++ ...led_non_unit_no_trans_lower_row_major.json | 34 +++++++++++ .../lapack/base/dlatrs/test/test.dlatrs.js | 57 +++++++++++++++++++ 4 files changed, 126 insertions(+), 1 deletion(-) create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_no_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_no_trans_lower_row_major.json diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js index 2dc85e9848ec..549996d41f16 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js @@ -319,11 +319,11 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X for ( j = jfirst; (jinc > 0) ? j <= jlast : j >= jlast; j += jinc ) { xj = abs( X[ ix ] ); + GOTO = false; if ( diag === 'non-unit' ) { tjjs = A[ ia ] * tscal; } else { tjjs = tscal; - GOTO = false; if ( tscal === 1.0 ) { GOTO = true; } diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_no_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_no_trans_lower_col_major.json new file mode 100644 index 000000000000..02890bb6cb1a --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_no_trans_lower_col_major.json @@ -0,0 +1,34 @@ +{ + "order": "column-major", + + "uplo": "lower", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0, 2.0, 3.0, 0.0, 0.1, 4.0, 0.0, 0.0, 0.01 ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 0, + + "A_mat": [ + [ 1.0, 0.0, 0.0 ], + [ 2.0, 0.1, 0.0 ], + [ 3.0, 4.0, 0.01 ] + ], + + "X": [ 1.0e308, 1.0e308, 1.0e308 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 0.5, -5.0, 1900.0 ], + "expectedCNORM": [ 5.0, 4.0, 0.0 ], + "scale": 4.9999999999999995e-309 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_no_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_no_trans_lower_row_major.json new file mode 100644 index 000000000000..e62bea8b7272 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_no_trans_lower_row_major.json @@ -0,0 +1,34 @@ +{ + "order": "row-major", + + "uplo": "lower", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0, 0.0, 0.0, 2.0, 0.1, 0.0, 3.0, 4.0, 0.01 ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 0, + + "A_mat": [ + [ 1.0, 0.0, 0.0 ], + [ 2.0, 0.1, 0.0 ], + [ 3.0, 4.0, 0.01 ] + ], + + "X": [ 1.0e308, 1.0e308, 1.0e308 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 0.5, -5.0, 1900.0 ], + "expectedCNORM": [ 5.0, 4.0, 0.0 ], + "scale": 4.9999999999999995e-309 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js index 1ad4060a6054..334ece5a8d05 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js @@ -49,6 +49,9 @@ var UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/unit_trans_lower_col_major var UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/unit_trans_upper_row_major.json' ); var UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/unit_trans_upper_col_major.json' ); +var SCALED_NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/scaled_non_unit_no_trans_lower_row_major.json' ); +var SCALED_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/scaled_non_unit_no_trans_lower_col_major.json' ); + // TESTS // @@ -763,3 +766,57 @@ tape( 'the function returns expected output for normal values (column-major) (up t.end(); }); + +tape.only( 'the function returns expected output for large values (row-major) (lower triangular) (no-transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (no-transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); From b72dd17c8fe6fa781f7b14c00b814d56c1c11ebd Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Wed, 11 Jun 2025 06:20:06 +0000 Subject: [PATCH 10/32] chore: remove tape.only --- 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 --- --- lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js index 334ece5a8d05..e5d4f1e92bd7 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js @@ -767,7 +767,7 @@ tape( 'the function returns expected output for normal values (column-major) (up t.end(); }); -tape.only( 'the function returns expected output for large values (row-major) (lower triangular) (no-transpose) (non-unit)', function test( t ) { +tape( 'the function returns expected output for large values (row-major) (lower triangular) (no-transpose) (non-unit)', function test( t ) { var expectedCNORM; var expectedX; var scale; From 1959bfe30cd2338ae719da510910d18e87c29060 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Wed, 11 Jun 2025 07:24:03 +0000 Subject: [PATCH 11/32] test: 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: 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 --- --- ...led_non_unit_no_trans_upper_col_major.json | 34 +++++++++++ ...led_non_unit_no_trans_upper_row_major.json | 34 +++++++++++ .../lapack/base/dlatrs/test/test.dlatrs.js | 56 +++++++++++++++++++ 3 files changed, 124 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_no_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_no_trans_upper_row_major.json diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_no_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_no_trans_upper_col_major.json new file mode 100644 index 000000000000..2d54382803c8 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_no_trans_upper_col_major.json @@ -0,0 +1,34 @@ +{ + "order": "column-major", + + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0e-10, 0.0, 0.0, 2.0, 1.0e-20, 0.0, 3.0, 4.0, 1.0e-30 ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 0, + + "A_mat": [ + [ 1.0e-10, 2.0, 3.0 ], + [ 0.0, 1.0e-20, 4.0 ], + [ 0.0, 0.0, 1.0e-30 ] + ], + + "X": [ 1.0e300, 2.0e300, 3.0e300 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 7.9999999999999982e+060, -3.9999999999999995E+050, 9.9999999999999988E+029 ], + "expectedCNORM": [ 0.0, 2.0, 7.0 ], + "scale": 3.3333333333333330E-301 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_no_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_no_trans_upper_row_major.json new file mode 100644 index 000000000000..4795f1555414 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_no_trans_upper_row_major.json @@ -0,0 +1,34 @@ +{ + "order": "row-major", + + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0e-10, 2.0, 3.0, 0.0, 1.0e-20, 4.0, 0.0, 0.0, 1.0e-30 ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 0, + + "A_mat": [ + [ 1.0e-10, 2.0, 3.0 ], + [ 0.0, 1.0e-20, 4.0 ], + [ 0.0, 0.0, 1.0e-30 ] + ], + + "X": [ 1.0e300, 2.0e300, 3.0e300 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 7.9999999999999982e+060, -3.9999999999999995E+050, 9.9999999999999988E+029 ], + "expectedCNORM": [ 0.0, 2.0, 7.0 ], + "scale": 3.3333333333333330E-301 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js index e5d4f1e92bd7..1a9ac49e42a1 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js @@ -51,6 +51,8 @@ var UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/unit_trans_upper_col_major var SCALED_NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/scaled_non_unit_no_trans_lower_row_major.json' ); var SCALED_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/scaled_non_unit_no_trans_lower_col_major.json' ); +var SCALED_NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/scaled_non_unit_no_trans_upper_row_major.json' ); +var SCALED_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/scaled_non_unit_no_trans_upper_col_major.json' ); // TESTS // @@ -820,3 +822,57 @@ tape( 'the function returns expected output for large values (column-major) (low t.end(); }); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (no-transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (no-transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); From 68e1c03dcc56da01c7f0dab32a5ad69918949aca Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Wed, 11 Jun 2025 14:20:23 +0000 Subject: [PATCH 12/32] fix: fix implementation and add 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/dlatrs/lib/base.js | 54 +++++++++--------- ...scaled_non_unit_trans_lower_col_major.json | 34 +++++++++++ ...scaled_non_unit_trans_lower_row_major.json | 34 +++++++++++ .../lapack/base/dlatrs/test/test.dlatrs.js | 57 +++++++++++++++++++ 4 files changed, 153 insertions(+), 26 deletions(-) create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_trans_lower_row_major.json diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js index 549996d41f16..f88bda8ff103 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js @@ -303,7 +303,6 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X if ( grow * tscal > smlnum ) { dtrsv( uplo, trans, diag, N, A, strideA1, strideA2, offsetA, X, strideX, offsetX ); - scale = 1.0; } else { if ( xmax > bignum ) { scale = bignum / xmax; @@ -418,35 +417,35 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X uscal /= tjjs; } if ( rec < 1.0 ) { - dscal( N, rec, strideX, offsetX ); + dscal( N, rec, X, strideX, offsetX ); scale *= rec; xmax *= rec; } - sumj = 0.0; + } - if ( uscal === 1.0 ) { - if ( uplo === 'upper' ) { - sumj = ddot( j, A, strideA1, ia1, X, strideX, offsetX ); - } else { - sumj = ddot( N - ( j + 1 ), A, strideA1, ia + strideA1, X, strideX, ix + strideX ); + sumj = 0.0; // HERE + if ( uscal === 1.0 ) { + if ( uplo === 'upper' ) { + sumj = ddot( j, A, strideA1, ia1, X, strideX, offsetX ); + } else { + sumj = ddot( N - ( j + 1 ), A, strideA1, ia + strideA1, X, strideX, ix + strideX ); + } + } else { + if ( uplo === 'upper' ) { + ia2 = 0; + ix1 = offsetX; + for ( i = 0; i < j; i++ ) { + sumj += A[ ia1 + ia2 ] * uscal * X[ ix1 ]; + ia2 += strideA1; + ix1 += strideX; } } else { - if ( uplo === 'upper' ) { - ia2 = 0; - ix1 = offsetX; - for ( i = 0; i < j; i++ ) { - sumj += A[ ia1 + ia2 ] * uscal * X[ ix1 ]; - ia2 += strideA1; - ix1 += strideX; - } - } else { - ia2 = ( j + 1 ) * strideA1; - ix1 = offsetX + ( ( j + 1 ) * strideX ); - for ( i = j + 1; i < N; i++ ) { - sumj += A[ ia1 + ia2 ] * uscal * X[ ix1 ]; - ia2 += strideA1; - ix1 += strideX; - } + ia2 = ( j + 1 ) * strideA1; + ix1 = offsetX + ( ( j + 1 ) * strideX ); + for ( i = j + 1; i < N; i++ ) { + sumj += A[ ia1 + ia2 ] * uscal * X[ ix1 ]; + ia2 += strideA1; + ix1 += strideX; } } } @@ -469,7 +468,7 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X if ( tjj > smlnum ) { if ( tjj < 1.0 ) { if ( xj > tjj * bignum ) { - rec /= xj; + rec = 1.0 / xj; dscal( N, rec, X, strideX, offsetX ); scale *= rec; xmax *= rec; @@ -494,10 +493,13 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X scale = 0.0; xmax = 0.0; } - X[ ix ] = ( X[ ix ] / tjjs ) - sumj; } + } else { + X[ ix ] = ( X[ ix ] / tjjs ) - sumj; } + xmax = max( xmax, abs( X[ ix ] ) ); + ix += jinc * strideX; ia += jinc * ( strideA1 + strideA2 ); ia1 += jinc * strideA2; diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_trans_lower_col_major.json new file mode 100644 index 000000000000..cfe74034bfb8 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_trans_lower_col_major.json @@ -0,0 +1,34 @@ +{ + "order": "column-major", + + "uplo": "lower", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0e-100, 1.0, 2.0, 0.0, 1.0e-120, 3.0, 0.0, 0.0, 1.0e-140 ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 0, + + "A_mat": [ + [ 1.0e-100, 0.0, 0.0 ], + [ 1.0, 1.0e-120, 0.0 ], + [ 2.0, 3.0, 1.0e-140 ] + ], + + "X": [ 1e100, 2e100, 3e100 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 9.99999999999999996E+219, -9.99999999999999980E+119, 3.33333333333333315E-001 ], + "expectedCNORM": [ 3.0, 3.0, 0.0 ], + "scale": 1.1111111111111112E-241 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_trans_lower_row_major.json new file mode 100644 index 000000000000..f1293abf6bca --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_trans_lower_row_major.json @@ -0,0 +1,34 @@ +{ + "order": "row-major", + + "uplo": "lower", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0e-100, 0.0, 0.0, 1.0, 1.0e-120, 0.0, 2.0, 3.0, 1.0e-140 ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 0, + + "A_mat": [ + [ 1.0e-100, 0.0, 0.0 ], + [ 1.0, 1.0e-120, 0.0 ], + [ 2.0, 3.0, 1.0e-140 ] + ], + + "X": [ 1e100, 2e100, 3e100 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 9.99999999999999996E+219, -9.99999999999999980E+119, 3.33333333333333315E-001 ], + "expectedCNORM": [ 3.0, 3.0, 0.0 ], + "scale": 1.1111111111111112E-241 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js index 1a9ac49e42a1..0e5eb1bc0ea7 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js @@ -54,6 +54,9 @@ var SCALED_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/scaled_non_u var SCALED_NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/scaled_non_unit_no_trans_upper_row_major.json' ); var SCALED_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/scaled_non_unit_no_trans_upper_col_major.json' ); +var SCALED_NON_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/scaled_non_unit_trans_lower_row_major.json' ); +var SCALED_NON_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/scaled_non_unit_trans_lower_col_major.json' ); + // TESTS // @@ -876,3 +879,57 @@ tape( 'the function returns expected output for large values (column-major) (upp t.end(); }); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_NON_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_NON_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); From cd7ce0dceacb14435968d25eb1982dee02043cd8 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Wed, 11 Jun 2025 15:17:58 +0000 Subject: [PATCH 13/32] test: add 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 --- --- ...scaled_non_unit_trans_upper_col_major.json | 34 +++++++++++ ...scaled_non_unit_trans_upper_row_major.json | 34 +++++++++++ .../lapack/base/dlatrs/test/test.dlatrs.js | 56 +++++++++++++++++++ 3 files changed, 124 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_trans_upper_row_major.json diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_trans_upper_col_major.json new file mode 100644 index 000000000000..58a983678ad5 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_trans_upper_col_major.json @@ -0,0 +1,34 @@ +{ + "order": "column-major", + + "uplo": "upper", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0e-100, 0.0, 0.0, 5.0, 1.0e-110, 0.0, 7.0, 8.0, 1.0e-120 ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 0, + + "A_mat": [ + [ 1.0e-100, 5.0, 7.0 ], + [ 0.0, 1.0e-110, 8.0 ], + [ 0.0, 0.0, 1.0e-120 ] + ], + + "X": [ 1e100, 2e100, 3e100 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 2.00000000000000011102E-001, -1.00000000000000002357E+110, 8.00000000000000079653E+230 ], + "expectedCNORM": [ 0.0, 5.0, 15.0 ], + "scale": 2.0000000000000003e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_trans_upper_row_major.json new file mode 100644 index 000000000000..1e3c2bd7debd --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_non_unit_trans_upper_row_major.json @@ -0,0 +1,34 @@ +{ + "order": "row-major", + + "uplo": "upper", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0e-100, 5.0, 7.0, 0.0, 1.0e-110, 8.0, 0.0, 0.0, 1.0e-120 ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 0, + + "A_mat": [ + [ 1.0e-100, 5.0, 7.0 ], + [ 0.0, 1.0e-110, 8.0 ], + [ 0.0, 0.0, 1.0e-120 ] + ], + + "X": [ 1e100, 2e100, 3e100 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 2.00000000000000011102E-001, -1.00000000000000002357E+110, 8.00000000000000079653E+230 ], + "expectedCNORM": [ 0.0, 5.0, 15.0 ], + "scale": 2.0000000000000003e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js index 0e5eb1bc0ea7..e8dc8f5b684a 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js @@ -56,6 +56,8 @@ var SCALED_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/scaled_non_u var SCALED_NON_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/scaled_non_unit_trans_lower_row_major.json' ); var SCALED_NON_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/scaled_non_unit_trans_lower_col_major.json' ); +var SCALED_NON_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/scaled_non_unit_trans_upper_row_major.json' ); +var SCALED_NON_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/scaled_non_unit_trans_upper_col_major.json' ); // TESTS // @@ -933,3 +935,57 @@ tape( 'the function returns expected output for large values (column-major) (low t.end(); }); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_NON_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_NON_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); From 9e42ef583dc0391a9e433305a8614b0b56b87ae3 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Wed, 11 Jun 2025 19:16:43 +0000 Subject: [PATCH 14/32] test: add 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 --- --- .../scaled_unit_no_trans_lower_col_major.json | 34 ++++++ .../scaled_unit_no_trans_lower_row_major.json | 34 ++++++ .../scaled_unit_no_trans_upper_col_major.json | 34 ++++++ .../scaled_unit_no_trans_upper_row_major.json | 34 ++++++ .../lapack/base/dlatrs/test/test.dlatrs.js | 113 ++++++++++++++++++ 5 files changed, 249 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_no_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_no_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_no_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_no_trans_upper_row_major.json diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_no_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_no_trans_lower_col_major.json new file mode 100644 index 000000000000..2a02cd71bbf8 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_no_trans_lower_col_major.json @@ -0,0 +1,34 @@ +{ + "order": "column-major", + + "uplo": "lower", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0, 1e100, 2e100, 0.0, 1.0, 3e100, 0.0, 0.0, 1.0 ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 0, + + "A_mat": [ + [ 1.0, 0.0, 0.0 ], + [ 1e100, 1.0, 0.0 ], + [ 2e100, 3e100, 1.0 ] + ], + + "X": [ 1e100, 2e100, 3e100 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 5.00000000000000009996E-101, -5.00000000000000000000E-001, 1.49999999999999992672E+100 ], + "expectedCNORM": [ 3.00000000000000024198E+100, 3e100, 0.0 ], + "scale": 4.9999999999999999E-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_no_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_no_trans_lower_row_major.json new file mode 100644 index 000000000000..3e9bfe4eaadc --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_no_trans_lower_row_major.json @@ -0,0 +1,34 @@ +{ + "order": "row-major", + + "uplo": "lower", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0, 0.0, 0.0, 1e100, 1.0, 0.0, 2e100, 3e100, 1.0 ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 0, + + "A_mat": [ + [ 1.0, 0.0, 0.0 ], + [ 1e100, 1.0, 0.0 ], + [ 2e100, 3e100, 1.0 ] + ], + + "X": [ 1e100, 2e100, 3e100 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 5.00000000000000009996E-101, -5.00000000000000000000E-001, 1.49999999999999992672E+100 ], + "expectedCNORM": [ 3.00000000000000024198E+100, 3e100, 0.0 ], + "scale": 4.9999999999999999E-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_no_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_no_trans_upper_col_major.json new file mode 100644 index 000000000000..547f5e24e0b2 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_no_trans_upper_col_major.json @@ -0,0 +1,34 @@ +{ + "order": "column-major", + + "uplo": "upper", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0, 0.0, 0.0, 1e100, 1.0, 0.0, 2e100, 3e100, 1.0 ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 0, + + "A_mat": [ + [ 1.0, 1e100, 2e100 ], + [ 0.0, 1.0, 3e100 ], + [ 0.0, 0.0, 1.0 ] + ], + + "X": [ 3e100, 2e100, 1e100 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 5.00000000000000007951E+099, -5.00000000000000000000E-001, 1.66666666666666680573E-101 ], + "expectedCNORM": [ 0.0, 1.00000000000000001590E+100, 4.99999999999999988525E+100 ], + "scale": 1.6666666666666668E-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_no_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_no_trans_upper_row_major.json new file mode 100644 index 000000000000..c2e5b6b9b54f --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_no_trans_upper_row_major.json @@ -0,0 +1,34 @@ +{ + "order": "row-major", + + "uplo": "upper", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0, 1e100, 2e100, 0.0, 1.0, 3e100, 0.0, 0.0, 1.0 ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 0, + + "A_mat": [ + [ 1.0, 1e100, 2e100 ], + [ 0.0, 1.0, 3e100 ], + [ 0.0, 0.0, 1.0 ] + ], + + "X": [ 3e100, 2e100, 1e100 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 5.00000000000000007951E+099, -5.00000000000000000000E-001, 1.66666666666666680573E-101 ], + "expectedCNORM": [ 0.0, 1.00000000000000001590E+100, 4.99999999999999988525E+100 ], + "scale": 1.6666666666666668E-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js index e8dc8f5b684a..6b14932ef835 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js @@ -59,6 +59,11 @@ var SCALED_NON_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/scaled_non_unit var SCALED_NON_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/scaled_non_unit_trans_upper_row_major.json' ); var SCALED_NON_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/scaled_non_unit_trans_upper_col_major.json' ); +var SCALED_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/scaled_unit_no_trans_lower_row_major.json' ); +var SCALED_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/scaled_unit_no_trans_lower_col_major.json' ); +var SCALED_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/scaled_unit_no_trans_upper_row_major.json' ); +var SCALED_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/scaled_unit_no_trans_upper_col_major.json' ); + // TESTS // @@ -989,3 +994,111 @@ tape( 'the function returns expected output for large values (column-major) (upp t.end(); }); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (no-transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (no-transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (no-transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (no-transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); From 82bab6931a95c34ab989860c693d307e6c7654f5 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Wed, 11 Jun 2025 19:49:05 +0000 Subject: [PATCH 15/32] test: add 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 --- --- .../scaled_unit_trans_lower_col_major.json | 34 ++++++ .../scaled_unit_trans_lower_row_major.json | 34 ++++++ .../scaled_unit_trans_upper_col_major.json | 34 ++++++ .../scaled_unit_trans_upper_row_major.json | 34 ++++++ .../lapack/base/dlatrs/test/test.dlatrs.js | 113 ++++++++++++++++++ 5 files changed, 249 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_trans_upper_row_major.json diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_trans_lower_col_major.json new file mode 100644 index 000000000000..4c01934f7899 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_trans_lower_col_major.json @@ -0,0 +1,34 @@ +{ + "order": "column-major", + + "uplo": "lower", + "trans": "transpose", + "diag": "unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0, 4e100, 7e100, 0.0, 1.0, 8e100, 0.0, 0.0, 1.0 ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 0, + + "A_mat": [ + [ 1.0, 0.0, 0.0 ], + [ 4e100, 1.0, 0.0 ], + [ 7e100, 8e100, 1.0 ] + ], + + "X": [ 1e100, 2e100, 3e100 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 2.00000000000000003181E+100, -5.00000000000000000000E-001, 6.25000000000000012495E-102 ], + "expectedCNORM": [ 1.10000000000000003692E+101, 8.00000000000000012722E+100, 0.00000000000000000000E+000 ], + "scale": 2.0833333333333334E-202 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_trans_lower_row_major.json new file mode 100644 index 000000000000..2a75109cd4da --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_trans_lower_row_major.json @@ -0,0 +1,34 @@ +{ + "order": "row-major", + + "uplo": "lower", + "trans": "transpose", + "diag": "unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0, 0.0, 0.0, 4e100, 1.0, 0.0, 7e100, 8e100, 1.0 ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 0, + + "A_mat": [ + [ 1.0, 0.0, 0.0 ], + [ 4e100, 1.0, 0.0 ], + [ 7e100, 8e100, 1.0 ] + ], + + "X": [ 1e100, 2e100, 3e100 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 2.00000000000000003181E+100, -5.00000000000000000000E-001, 6.25000000000000012495E-102 ], + "expectedCNORM": [ 1.10000000000000003692E+101, 8.00000000000000012722E+100, 0.00000000000000000000E+000 ], + "scale": 2.0833333333333334E-202 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_trans_upper_col_major.json new file mode 100644 index 000000000000..be22e7a1fd39 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_trans_upper_col_major.json @@ -0,0 +1,34 @@ +{ + "order": "column-major", + + "uplo": "upper", + "trans": "transpose", + "diag": "unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0, 0.0, 0.0, 2e100, 1.0, 0.0, 3e100, 5e100, 1.0 ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 0, + + "A_mat": [ + [ 1.0, 2e100, 3e100 ], + [ 0.0, 1.0, 5e100 ], + [ 0.0, 0.0, 1.0 ] + ], + + "X": [ 1e100, 2e100, 3e100 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 2.50000000000000004998E-101, -5.00000000000000000000E-001, 2.49999999999999994262E+100 ], + "expectedCNORM": [ 0.0, 2.00000000000000003181E+100, 8.00000000000000012722E+100 ], + "scale": 2.5000000000000000E-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_trans_upper_row_major.json new file mode 100644 index 000000000000..ae92331e949f --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/scaled_unit_trans_upper_row_major.json @@ -0,0 +1,34 @@ +{ + "order": "row-major", + + "uplo": "upper", + "trans": "transpose", + "diag": "unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0, 2e100, 3e100, 0.0, 1.0, 5e100, 0.0, 0.0, 1.0 ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 0, + + "A_mat": [ + [ 1.0, 2e100, 3e100 ], + [ 0.0, 1.0, 5e100 ], + [ 0.0, 0.0, 1.0 ] + ], + + "X": [ 1e100, 2e100, 3e100 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 2.50000000000000004998E-101, -5.00000000000000000000E-001, 2.49999999999999994262E+100 ], + "expectedCNORM": [ 0.0, 2.00000000000000003181E+100, 8.00000000000000012722E+100 ], + "scale": 2.5000000000000000E-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js index 6b14932ef835..1a13ff7d3ddc 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js @@ -64,6 +64,11 @@ var SCALED_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/scaled_unit_no_t var SCALED_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/scaled_unit_no_trans_upper_row_major.json' ); var SCALED_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/scaled_unit_no_trans_upper_col_major.json' ); +var SCALED_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/scaled_unit_trans_lower_row_major.json' ); +var SCALED_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/scaled_unit_trans_lower_col_major.json' ); +var SCALED_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/scaled_unit_trans_upper_row_major.json' ); +var SCALED_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/scaled_unit_trans_upper_col_major.json' ); + // TESTS // @@ -1102,3 +1107,111 @@ tape( 'the function returns expected output for large values (column-major) (upp t.end(); }); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); From 7dc23e45b3b4e1c4c9c0d56cbd43b66cb3ad4e21 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Thu, 12 Jun 2025 05:57:25 +0000 Subject: [PATCH 16/32] test: add large values 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/dlatrs/lib/base.js | 2 +- .../large_off_diagonal_col_major.json | 34 +++++++++++ .../large_off_diagonal_row_major.json | 34 +++++++++++ .../lapack/base/dlatrs/test/test.dlatrs.js | 57 +++++++++++++++++++ 4 files changed, 126 insertions(+), 1 deletion(-) create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_off_diagonal_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_off_diagonal_row_major.json diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js index f88bda8ff103..532d5dfca28c 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js @@ -137,7 +137,7 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X } else { if ( tmax <= dlamch( 'overflow' ) ) { tscal = 1.0 / ( smlnum * tmax ); - dscal( N, tscal, X, strideX, offsetX ); + dscal( N, tscal, CNORM, strideCNORM, offsetCNORM ); } else { tmax = 0.0; if ( uplo === 'upper' ) { diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_off_diagonal_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_off_diagonal_col_major.json new file mode 100644 index 000000000000..e2fdbb39b912 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_off_diagonal_col_major.json @@ -0,0 +1,34 @@ +{ + "order": "column-major", + + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0, 0.0, 0.0, 1e292, 1.0, 0.0, 1e292, 1e292, 1.0 ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 0, + + "A_mat": [ + [ 1.0, 1e292, 1e292 ], + [ 0.0, 1.0, 1e292 ], + [ 0.0, 0.0, 1.0 ] + ], + + "X": [ 1.0, 1.0, 1.0 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 5.0000000000000001E+291, -5.0000000000000000E-001, 4.9999999999999997E-293 ], + "expectedCNORM": [ 0.0, 1e292, 2e292 ], + "scale": 4.9999999999999997E-293 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_off_diagonal_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_off_diagonal_row_major.json new file mode 100644 index 000000000000..2a7176e471f4 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_off_diagonal_row_major.json @@ -0,0 +1,34 @@ +{ + "order": "row-major", + + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + + "N": 3, + "LDA": 3, + + "A": [ 1.0, 1e292, 1e292, 0.0, 1.0, 1e292, 0.0, 0.0, 1.0 ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 0, + + "A_mat": [ + [ 1.0, 1e292, 1e292 ], + [ 0.0, 1.0, 1e292 ], + [ 0.0, 0.0, 1.0 ] + ], + + "X": [ 1.0, 1.0, 1.0 ], + "strideX": 1, + "offsetX": 0, + + "CNORM": [ 0.0, 0.0, 0.0 ], + "strideCNORM": 1, + "offsetCNORM": 0, + + "expectedX": [ 5.0000000000000001E+291, -5.0000000000000000E-001, 4.9999999999999997E-293 ], + "expectedCNORM": [ 0.0, 1e292, 2e292 ], + "scale": 4.9999999999999997E-293 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js index 1a13ff7d3ddc..4b222bb7ccf7 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js @@ -69,6 +69,9 @@ var SCALED_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/scaled_unit_trans_l var SCALED_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/scaled_unit_trans_upper_row_major.json' ); var SCALED_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/scaled_unit_trans_upper_col_major.json' ); +var LARGE_OFF_DIAGONAL_ELEMENTS_ROW_MAJOR = require( './fixtures/large_off_diagonal_row_major.json' ); +var LARGE_OFF_DIAGONAL_ELEMENTS_COL_MAJOR = require( './fixtures/large_off_diagonal_col_major.json' ); + // TESTS // @@ -1215,3 +1218,57 @@ tape( 'the function returns expected output for large values (column-major) (upp t.end(); }); + +tape( 'the function returns expected output for large off diagonal elements (row-major) (upper triangular) (no-transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_OFF_DIAGONAL_ELEMENTS_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large off diagonal elements (column-major) (upper triangular) (no-transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_OFF_DIAGONAL_ELEMENTS_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.order, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); From f60f4c434f7a47f66de7e2a7ab5b8107cb1ccef9 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Fri, 13 Jun 2025 10:01:35 +0000 Subject: [PATCH 17/32] 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: 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/dlatrs/lib/dlatrs.js | 2 +- .../@stdlib/lapack/base/dlatrs/lib/ndarray.js | 8 +- .../large_off_diagonal_col_major.json | 86 ++ .../large_off_diagonal_row_major.json | 86 ++ .../non_unit_no_trans_lower_col_major.json | 86 ++ .../non_unit_no_trans_lower_row_major.json | 86 ++ .../non_unit_no_trans_upper_col_major.json | 86 ++ .../non_unit_no_trans_upper_row_major.json | 86 ++ .../non_unit_trans_lower_col_major.json | 86 ++ .../non_unit_trans_lower_row_major.json | 86 ++ .../non_unit_trans_upper_col_major.json | 86 ++ .../non_unit_trans_upper_row_major.json | 86 ++ ...led_non_unit_no_trans_lower_col_major.json | 86 ++ ...led_non_unit_no_trans_lower_row_major.json | 86 ++ ...led_non_unit_no_trans_upper_col_major.json | 86 ++ ...led_non_unit_no_trans_upper_row_major.json | 86 ++ ...scaled_non_unit_trans_lower_col_major.json | 86 ++ ...scaled_non_unit_trans_lower_row_major.json | 86 ++ ...scaled_non_unit_trans_upper_col_major.json | 86 ++ ...scaled_non_unit_trans_upper_row_major.json | 86 ++ .../scaled_unit_no_trans_lower_col_major.json | 86 ++ .../scaled_unit_no_trans_lower_row_major.json | 86 ++ .../scaled_unit_no_trans_upper_col_major.json | 86 ++ .../scaled_unit_no_trans_upper_row_major.json | 86 ++ .../scaled_unit_trans_lower_col_major.json | 86 ++ .../scaled_unit_trans_lower_row_major.json | 86 ++ .../scaled_unit_trans_upper_col_major.json | 86 ++ .../scaled_unit_trans_upper_row_major.json | 86 ++ .../unit_no_trans_lower_col_major.json | 86 ++ .../unit_no_trans_lower_row_major.json | 86 ++ .../unit_no_trans_upper_col_major.json | 86 ++ .../unit_no_trans_upper_row_major.json | 86 ++ .../unit_trans_lower_col_major.json | 86 ++ .../unit_trans_lower_row_major.json | 86 ++ .../unit_trans_upper_col_major.json | 86 ++ .../unit_trans_upper_row_major.json | 86 ++ .../large_off_diagonal_col_major.json | 65 + .../large_off_diagonal_row_major.json | 65 + .../non_unit_no_trans_lower_col_major.json | 65 + .../non_unit_no_trans_lower_row_major.json | 65 + .../non_unit_no_trans_upper_col_major.json | 65 + .../non_unit_no_trans_upper_row_major.json | 65 + .../non_unit_trans_lower_col_major.json | 65 + .../non_unit_trans_lower_row_major.json | 65 + .../non_unit_trans_upper_col_major.json | 65 + .../non_unit_trans_upper_row_major.json | 65 + ...led_non_unit_no_trans_lower_col_major.json | 65 + ...led_non_unit_no_trans_lower_row_major.json | 65 + ...led_non_unit_no_trans_upper_col_major.json | 65 + ...led_non_unit_no_trans_upper_row_major.json | 65 + ...scaled_non_unit_trans_lower_col_major.json | 65 + ...scaled_non_unit_trans_lower_row_major.json | 65 + ...scaled_non_unit_trans_upper_col_major.json | 65 + ...scaled_non_unit_trans_upper_row_major.json | 65 + .../scaled_unit_no_trans_lower_col_major.json | 65 + .../scaled_unit_no_trans_lower_row_major.json | 65 + .../scaled_unit_no_trans_upper_col_major.json | 65 + .../scaled_unit_no_trans_upper_row_major.json | 65 + .../scaled_unit_trans_lower_col_major.json | 65 + .../scaled_unit_trans_lower_row_major.json | 65 + .../scaled_unit_trans_upper_col_major.json | 65 + .../scaled_unit_trans_upper_row_major.json | 65 + .../unit_no_trans_lower_col_major.json | 65 + .../unit_no_trans_lower_row_major.json | 65 + .../unit_no_trans_upper_col_major.json | 65 + .../unit_no_trans_upper_row_major.json | 65 + .../unit_trans_lower_col_major.json | 65 + .../unit_trans_lower_row_major.json | 65 + .../unit_trans_upper_col_major.json | 65 + .../unit_trans_upper_row_major.json | 65 + .../large_off_diagonal_col_major.json | 67 + .../large_off_diagonal_row_major.json | 67 + .../non_unit_no_trans_lower_col_major.json | 67 + .../non_unit_no_trans_lower_row_major.json | 67 + .../non_unit_no_trans_upper_col_major.json | 67 + .../non_unit_no_trans_upper_row_major.json | 67 + .../non_unit_trans_lower_col_major.json | 67 + .../non_unit_trans_lower_row_major.json | 67 + .../non_unit_trans_upper_col_major.json | 67 + .../non_unit_trans_upper_row_major.json | 67 + ...led_non_unit_no_trans_lower_col_major.json | 67 + ...led_non_unit_no_trans_lower_row_major.json | 67 + ...led_non_unit_no_trans_upper_col_major.json | 67 + ...led_non_unit_no_trans_upper_row_major.json | 67 + ...scaled_non_unit_trans_lower_col_major.json | 67 + ...scaled_non_unit_trans_lower_row_major.json | 67 + ...scaled_non_unit_trans_upper_col_major.json | 67 + ...scaled_non_unit_trans_upper_row_major.json | 67 + .../scaled_unit_no_trans_lower_col_major.json | 67 + .../scaled_unit_no_trans_lower_row_major.json | 67 + .../scaled_unit_no_trans_upper_col_major.json | 67 + .../scaled_unit_no_trans_upper_row_major.json | 67 + .../scaled_unit_trans_lower_col_major.json | 67 + .../scaled_unit_trans_lower_row_major.json | 67 + .../scaled_unit_trans_upper_col_major.json | 67 + .../scaled_unit_trans_upper_row_major.json | 67 + .../unit_no_trans_lower_col_major.json | 67 + .../unit_no_trans_lower_row_major.json | 67 + .../unit_no_trans_upper_col_major.json | 67 + .../unit_no_trans_upper_row_major.json | 67 + .../unit_trans_lower_col_major.json | 67 + .../unit_trans_lower_row_major.json | 67 + .../unit_trans_upper_col_major.json | 67 + .../unit_trans_upper_row_major.json | 67 + .../offsets/large_off_diagonal_col_major.json | 70 + .../offsets/large_off_diagonal_row_major.json | 70 + .../non_unit_no_trans_lower_col_major.json | 70 + .../non_unit_no_trans_lower_row_major.json | 70 + .../non_unit_no_trans_upper_col_major.json | 70 + .../non_unit_no_trans_upper_row_major.json | 70 + .../non_unit_trans_lower_col_major.json | 70 + .../non_unit_trans_lower_row_major.json | 70 + .../non_unit_trans_upper_col_major.json | 70 + .../non_unit_trans_upper_row_major.json | 70 + ...led_non_unit_no_trans_lower_col_major.json | 70 + ...led_non_unit_no_trans_lower_row_major.json | 70 + ...led_non_unit_no_trans_upper_col_major.json | 70 + ...led_non_unit_no_trans_upper_row_major.json | 70 + ...scaled_non_unit_trans_lower_col_major.json | 70 + ...scaled_non_unit_trans_lower_row_major.json | 70 + ...scaled_non_unit_trans_upper_col_major.json | 70 + ...scaled_non_unit_trans_upper_row_major.json | 70 + .../scaled_unit_no_trans_lower_col_major.json | 70 + .../scaled_unit_no_trans_lower_row_major.json | 70 + .../scaled_unit_no_trans_upper_col_major.json | 70 + .../scaled_unit_no_trans_upper_row_major.json | 70 + .../scaled_unit_trans_lower_col_major.json | 70 + .../scaled_unit_trans_lower_row_major.json | 70 + .../scaled_unit_trans_upper_col_major.json | 70 + .../scaled_unit_trans_upper_row_major.json | 70 + .../unit_no_trans_lower_col_major.json | 70 + .../unit_no_trans_lower_row_major.json | 70 + .../unit_no_trans_upper_col_major.json | 70 + .../unit_no_trans_upper_row_major.json | 70 + .../offsets/unit_trans_lower_col_major.json | 70 + .../offsets/unit_trans_lower_row_major.json | 70 + .../offsets/unit_trans_upper_col_major.json | 70 + .../offsets/unit_trans_upper_row_major.json | 70 + .../lapack/base/dlatrs/test/test.ndarray.js | 1200 +++++++++++++++++ 139 files changed, 10997 insertions(+), 5 deletions(-) create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/large_off_diagonal_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/large_off_diagonal_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_no_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_no_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_no_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_no_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_no_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_no_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_no_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_no_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_no_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_no_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_no_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_no_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_no_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_no_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_no_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_no_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/large_off_diagonal_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/large_off_diagonal_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_no_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_no_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_no_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_no_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_no_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_no_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_no_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_no_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_no_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_no_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_no_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_no_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_no_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_no_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_no_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_no_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/large_off_diagonal_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/large_off_diagonal_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_no_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_no_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_no_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_no_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_no_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_no_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_no_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_no_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_no_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_no_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_no_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_no_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_no_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_no_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_no_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_no_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/large_off_diagonal_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/large_off_diagonal_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_no_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_no_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_no_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_no_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_no_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_no_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_no_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_no_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_no_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_no_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_no_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_no_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_no_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_no_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_no_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_no_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_trans_lower_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_trans_lower_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_trans_upper_col_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_trans_upper_row_major.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.ndarray.js diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/dlatrs.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/dlatrs.js index 40cf0fe3139a..e5591db8309c 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/dlatrs.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/dlatrs.js @@ -80,7 +80,7 @@ function dlatrs( order, uplo, trans, diag, normin, N, A, LDA, X, CNORM ) { throw new TypeError( format( 'invalid argument. Third argument must be a valid transpose operation. Value: `%s`.', trans ) ); } if ( !isDiagonalType( diag ) ) { - throw new TypeError( format( 'invalid argument. Second argument must be a valid diagonal type. Value: `%s`.', diag ) ); + throw new TypeError( format( 'invalid argument. Fourth argument must be a valid diagonal type. Value: `%s`.', diag ) ); } if ( isRowMajor( order ) && LDA < max( 1, N ) ) { throw new RangeError( format( 'invalid argument. Sixth argument must be greater than or equal to max(1,%d). Value: `%d`.', N, LDA ) ); diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/ndarray.js index 4c27a29ec74e..a6b101d07edd 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/ndarray.js @@ -69,16 +69,16 @@ var base = require( './base.js' ); */ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X, strideX, offsetX, CNORM, strideCNORM, offsetCNORM ) { if ( !isMatrixTriangle( uplo ) ) { - throw new TypeError( format( 'invalid argument. Second argument must be a valid side. Value: `%s`.', uplo ) ); + throw new TypeError( format( 'invalid argument. First argument must be a valid side. Value: `%s`.', uplo ) ); } if ( !isTransposeOperation( trans ) ) { - throw new TypeError( format( 'invalid argument. Third argument must be a valid transpose operation. Value: `%s`.', trans ) ); + throw new TypeError( format( 'invalid argument. Second argument must be a valid transpose operation. Value: `%s`.', trans ) ); } if ( !isDiagonalType( diag ) ) { - throw new TypeError( format( 'invalid argument. Second argument must be a valid diagonal type. Value: `%s`.', diag ) ); + throw new TypeError( format( 'invalid argument. Third argument must be a valid diagonal type. Value: `%s`.', diag ) ); } if ( normin !== 'yes' && normin !== 'no' ) { - throw new TypeError( format( 'invalid argument. Fifth argument must be either yes or no. Value: `%d`.', normin ) ); + throw new TypeError( format( 'invalid argument. Fourth argument must be either yes or no. Value: `%s`.', normin ) ); } return base( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X, strideX, offsetX, CNORM, strideCNORM, offsetCNORM ); } diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/large_off_diagonal_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/large_off_diagonal_col_major.json new file mode 100644 index 000000000000..9e3570d3e5ee --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/large_off_diagonal_col_major.json @@ -0,0 +1,86 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 9999, + 0, + 9999, + 0, + 9999, + 1e+292, + 9999, + 1, + 9999, + 0, + 9999, + 1e+292, + 9999, + 1e+292, + 9999, + 1, + 9999 + ], + "strideA1": 2, + "strideA2": 6, + "offsetA": 0, + "A_mat": [ + [ + 1, + 1e+292, + 1e+292 + ], + [ + 0, + 1, + 1e+292 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 1, + 9999, + 1, + 9999, + 1, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 5e+291, + 9999, + -0.5, + 9999, + 4.9999999999999997e-293, + 9999 + ], + "expectedCNORM": [ + 0, + 9999, + 1e+292, + 9999, + 2e+292, + 9999 + ], + "scale": 4.9999999999999997e-293 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/large_off_diagonal_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/large_off_diagonal_row_major.json new file mode 100644 index 000000000000..2072114342f7 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/large_off_diagonal_row_major.json @@ -0,0 +1,86 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 9999, + 1e+292, + 9999, + 1e+292, + 9999, + 0, + 9999, + 1, + 9999, + 1e+292, + 9999, + 0, + 9999, + 0, + 9999, + 1, + 9999 + ], + "strideA1": 6, + "strideA2": 2, + "offsetA": 0, + "A_mat": [ + [ + 1, + 1e+292, + 1e+292 + ], + [ + 0, + 1, + 1e+292 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 1, + 9999, + 1, + 9999, + 1, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 5e+291, + 9999, + -0.5, + 9999, + 4.9999999999999997e-293, + 9999 + ], + "expectedCNORM": [ + 0, + 9999, + 1e+292, + 9999, + 2e+292, + 9999 + ], + "scale": 4.9999999999999997e-293 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_no_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_no_trans_lower_col_major.json new file mode 100644 index 000000000000..b442d29c3581 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_no_trans_lower_col_major.json @@ -0,0 +1,86 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 2, + 9999, + 1, + 9999, + -1, + 9999, + 0, + 9999, + 3, + 9999, + 2, + 9999, + 0, + 9999, + 0, + 9999, + 4, + 9999 + ], + "strideA1": 2, + "strideA2": 6, + "offsetA": 0, + "A_mat": [ + [ + 2, + 0, + 0 + ], + [ + 1, + 3, + 0 + ], + [ + -1, + 2, + 4 + ] + ], + "X": [ + 5, + 9999, + 10, + 9999, + 20, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 2.5, + 9999, + 2.5, + 9999, + 4.375, + 9999 + ], + "expectedCNORM": [ + 2, + 9999, + 2, + 9999, + 0, + 9999 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_no_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_no_trans_lower_row_major.json new file mode 100644 index 000000000000..60165810a9ce --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_no_trans_lower_row_major.json @@ -0,0 +1,86 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 2, + 9999, + 0, + 9999, + 0, + 9999, + 1, + 9999, + 3, + 9999, + 0, + 9999, + -1, + 9999, + 2, + 9999, + 4, + 9999 + ], + "strideA1": 6, + "strideA2": 2, + "offsetA": 0, + "A_mat": [ + [ + 2, + 0, + 0 + ], + [ + 1, + 3, + 0 + ], + [ + -1, + 2, + 4 + ] + ], + "X": [ + 5, + 9999, + 10, + 9999, + 20, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 2.5, + 9999, + 2.5, + 9999, + 4.375, + 9999 + ], + "expectedCNORM": [ + 2, + 9999, + 2, + 9999, + 0, + 9999 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_no_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_no_trans_upper_col_major.json new file mode 100644 index 000000000000..13edf87a8de0 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_no_trans_upper_col_major.json @@ -0,0 +1,86 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 2, + 9999, + 0, + 9999, + 0, + 9999, + 1, + 9999, + 3, + 9999, + 0, + 9999, + -1, + 9999, + 2, + 9999, + 4, + 9999 + ], + "strideA1": 2, + "strideA2": 6, + "offsetA": 0, + "A_mat": [ + [ + 2, + 1, + -1 + ], + [ + 0, + 3, + 2 + ], + [ + 0, + 0, + 4 + ] + ], + "X": [ + 5, + 9999, + 10, + 9999, + 20, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 5, + 9999, + 0, + 9999, + 5, + 9999 + ], + "expectedCNORM": [ + 0, + 9999, + 1, + 9999, + 3, + 9999 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_no_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_no_trans_upper_row_major.json new file mode 100644 index 000000000000..f12f9511c331 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_no_trans_upper_row_major.json @@ -0,0 +1,86 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 2, + 9999, + 1, + 9999, + -1, + 9999, + 0, + 9999, + 3, + 9999, + 2, + 9999, + 0, + 9999, + 0, + 9999, + 4, + 9999 + ], + "strideA1": 6, + "strideA2": 2, + "offsetA": 0, + "A_mat": [ + [ + 2, + 1, + -1 + ], + [ + 0, + 3, + 2 + ], + [ + 0, + 0, + 4 + ] + ], + "X": [ + 5, + 9999, + 10, + 9999, + 20, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 5, + 9999, + 0, + 9999, + 5, + 9999 + ], + "expectedCNORM": [ + 0, + 9999, + 1, + 9999, + 3, + 9999 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_trans_lower_col_major.json new file mode 100644 index 000000000000..eba815a965ec --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_trans_lower_col_major.json @@ -0,0 +1,86 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 2, + 9999, + 1, + 9999, + -1, + 9999, + 0, + 9999, + 3, + 9999, + 2, + 9999, + 0, + 9999, + 0, + 9999, + 4, + 9999 + ], + "strideA1": 2, + "strideA2": 6, + "offsetA": 0, + "A_mat": [ + [ + 2, + 0, + 0 + ], + [ + 1, + 3, + 0 + ], + [ + -1, + 2, + 4 + ] + ], + "X": [ + 2, + 9999, + 5, + 9999, + 4, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 1, + 9999, + 1, + 9999, + 1, + 9999 + ], + "expectedCNORM": [ + 2, + 9999, + 2, + 9999, + 0, + 9999 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_trans_lower_row_major.json new file mode 100644 index 000000000000..c1e6f5364a16 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_trans_lower_row_major.json @@ -0,0 +1,86 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 2, + 9999, + 0, + 9999, + 0, + 9999, + 1, + 9999, + 3, + 9999, + 0, + 9999, + -1, + 9999, + 2, + 9999, + 4, + 9999 + ], + "strideA1": 6, + "strideA2": 2, + "offsetA": 0, + "A_mat": [ + [ + 2, + 0, + 0 + ], + [ + 1, + 3, + 0 + ], + [ + -1, + 2, + 4 + ] + ], + "X": [ + 2, + 9999, + 5, + 9999, + 4, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 1, + 9999, + 1, + 9999, + 1, + 9999 + ], + "expectedCNORM": [ + 2, + 9999, + 2, + 9999, + 0, + 9999 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_trans_upper_col_major.json new file mode 100644 index 000000000000..a605ffb41b4f --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_trans_upper_col_major.json @@ -0,0 +1,86 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 2, + 9999, + 1, + 9999, + 0, + 9999, + 1, + 9999, + 3, + 9999, + 0, + 9999, + -1, + 9999, + 2, + 9999, + 4, + 9999 + ], + "strideA1": 2, + "strideA2": 6, + "offsetA": 0, + "A_mat": [ + [ + 2, + 1, + -1 + ], + [ + 1, + 3, + 2 + ], + [ + 0, + 0, + 4 + ] + ], + "X": [ + 2, + 9999, + 5, + 9999, + 4, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 1, + 9999, + 1.3333333333333333, + 9999, + 0.5833333333333334, + 9999 + ], + "expectedCNORM": [ + 0, + 9999, + 1, + 9999, + 3, + 9999 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_trans_upper_row_major.json new file mode 100644 index 000000000000..e733cdb0f364 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/non_unit_trans_upper_row_major.json @@ -0,0 +1,86 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 2, + 9999, + 1, + 9999, + -1, + 9999, + 0, + 9999, + 3, + 9999, + 2, + 9999, + 0, + 9999, + 0, + 9999, + 4, + 9999 + ], + "strideA1": 6, + "strideA2": 2, + "offsetA": 0, + "A_mat": [ + [ + 2, + 1, + -1 + ], + [ + 1, + 3, + 2 + ], + [ + 0, + 0, + 4 + ] + ], + "X": [ + 2, + 9999, + 5, + 9999, + 4, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 1, + 9999, + 1.3333333333333333, + 9999, + 0.5833333333333334, + 9999 + ], + "expectedCNORM": [ + 0, + 9999, + 1, + 9999, + 3, + 9999 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_no_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_no_trans_lower_col_major.json new file mode 100644 index 000000000000..e74d3f8ff86f --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_no_trans_lower_col_major.json @@ -0,0 +1,86 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 9999, + 2, + 9999, + 3, + 9999, + 0, + 9999, + 0.1, + 9999, + 4, + 9999, + 0, + 9999, + 0, + 9999, + 0.01, + 9999 + ], + "strideA1": 2, + "strideA2": 6, + "offsetA": 0, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 2, + 0.1, + 0 + ], + [ + 3, + 4, + 0.01 + ] + ], + "X": [ + 1e+308, + 9999, + 1e+308, + 9999, + 1e+308, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 0.5, + 9999, + -5, + 9999, + 1900, + 9999 + ], + "expectedCNORM": [ + 5, + 9999, + 4, + 9999, + 0, + 9999 + ], + "scale": 5e-309 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_no_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_no_trans_lower_row_major.json new file mode 100644 index 000000000000..63cba1980349 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_no_trans_lower_row_major.json @@ -0,0 +1,86 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 9999, + 0, + 9999, + 0, + 9999, + 2, + 9999, + 0.1, + 9999, + 0, + 9999, + 3, + 9999, + 4, + 9999, + 0.01, + 9999 + ], + "strideA1": 6, + "strideA2": 2, + "offsetA": 0, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 2, + 0.1, + 0 + ], + [ + 3, + 4, + 0.01 + ] + ], + "X": [ + 1e+308, + 9999, + 1e+308, + 9999, + 1e+308, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 0.5, + 9999, + -5, + 9999, + 1900, + 9999 + ], + "expectedCNORM": [ + 5, + 9999, + 4, + 9999, + 0, + 9999 + ], + "scale": 5e-309 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_no_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_no_trans_upper_col_major.json new file mode 100644 index 000000000000..483978bfebe4 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_no_trans_upper_col_major.json @@ -0,0 +1,86 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1e-10, + 9999, + 0, + 9999, + 0, + 9999, + 2, + 9999, + 1e-20, + 9999, + 0, + 9999, + 3, + 9999, + 4, + 9999, + 1e-30, + 9999 + ], + "strideA1": 2, + "strideA2": 6, + "offsetA": 0, + "A_mat": [ + [ + 1e-10, + 2, + 3 + ], + [ + 0, + 1e-20, + 4 + ], + [ + 0, + 0, + 1e-30 + ] + ], + "X": [ + 1e+300, + 9999, + 2e+300, + 9999, + 3e+300, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 7.999999999999998e+60, + 9999, + -3.9999999999999995e+50, + 9999, + 9.999999999999999e+29, + 9999 + ], + "expectedCNORM": [ + 0, + 9999, + 2, + 9999, + 7, + 9999 + ], + "scale": 3.333333333333333e-301 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_no_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_no_trans_upper_row_major.json new file mode 100644 index 000000000000..3e5297b4654f --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_no_trans_upper_row_major.json @@ -0,0 +1,86 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1e-10, + 9999, + 2, + 9999, + 3, + 9999, + 0, + 9999, + 1e-20, + 9999, + 4, + 9999, + 0, + 9999, + 0, + 9999, + 1e-30, + 9999 + ], + "strideA1": 6, + "strideA2": 2, + "offsetA": 0, + "A_mat": [ + [ + 1e-10, + 2, + 3 + ], + [ + 0, + 1e-20, + 4 + ], + [ + 0, + 0, + 1e-30 + ] + ], + "X": [ + 1e+300, + 9999, + 2e+300, + 9999, + 3e+300, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 7.999999999999998e+60, + 9999, + -3.9999999999999995e+50, + 9999, + 9.999999999999999e+29, + 9999 + ], + "expectedCNORM": [ + 0, + 9999, + 2, + 9999, + 7, + 9999 + ], + "scale": 3.333333333333333e-301 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_trans_lower_col_major.json new file mode 100644 index 000000000000..9e96fa972d91 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_trans_lower_col_major.json @@ -0,0 +1,86 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1e-100, + 9999, + 1, + 9999, + 2, + 9999, + 0, + 9999, + 1e-120, + 9999, + 3, + 9999, + 0, + 9999, + 0, + 9999, + 1e-140, + 9999 + ], + "strideA1": 2, + "strideA2": 6, + "offsetA": 0, + "A_mat": [ + [ + 1e-100, + 0, + 0 + ], + [ + 1, + 1e-120, + 0 + ], + [ + 2, + 3, + 1e-140 + ] + ], + "X": [ + 1e+100, + 9999, + 2e+100, + 9999, + 3e+100, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 1e+220, + 9999, + -1e+120, + 9999, + 0.3333333333333333, + 9999 + ], + "expectedCNORM": [ + 3, + 9999, + 3, + 9999, + 0, + 9999 + ], + "scale": 1.1111111111111112e-241 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_trans_lower_row_major.json new file mode 100644 index 000000000000..9c6163d6f338 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_trans_lower_row_major.json @@ -0,0 +1,86 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1e-100, + 9999, + 0, + 9999, + 0, + 9999, + 1, + 9999, + 1e-120, + 9999, + 0, + 9999, + 2, + 9999, + 3, + 9999, + 1e-140, + 9999 + ], + "strideA1": 6, + "strideA2": 2, + "offsetA": 0, + "A_mat": [ + [ + 1e-100, + 0, + 0 + ], + [ + 1, + 1e-120, + 0 + ], + [ + 2, + 3, + 1e-140 + ] + ], + "X": [ + 1e+100, + 9999, + 2e+100, + 9999, + 3e+100, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 1e+220, + 9999, + -1e+120, + 9999, + 0.3333333333333333, + 9999 + ], + "expectedCNORM": [ + 3, + 9999, + 3, + 9999, + 0, + 9999 + ], + "scale": 1.1111111111111112e-241 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_trans_upper_col_major.json new file mode 100644 index 000000000000..be36fb426e17 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_trans_upper_col_major.json @@ -0,0 +1,86 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1e-100, + 9999, + 0, + 9999, + 0, + 9999, + 5, + 9999, + 1e-110, + 9999, + 0, + 9999, + 7, + 9999, + 8, + 9999, + 1e-120, + 9999 + ], + "strideA1": 2, + "strideA2": 6, + "offsetA": 0, + "A_mat": [ + [ + 1e-100, + 5, + 7 + ], + [ + 0, + 1e-110, + 8 + ], + [ + 0, + 0, + 1e-120 + ] + ], + "X": [ + 1e+100, + 9999, + 2e+100, + 9999, + 3e+100, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 0.2, + 9999, + -1e+110, + 9999, + 8e+230, + 9999 + ], + "expectedCNORM": [ + 0, + 9999, + 5, + 9999, + 15, + 9999 + ], + "scale": 2.0000000000000003e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_trans_upper_row_major.json new file mode 100644 index 000000000000..691bdd491b91 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_non_unit_trans_upper_row_major.json @@ -0,0 +1,86 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1e-100, + 9999, + 5, + 9999, + 7, + 9999, + 0, + 9999, + 1e-110, + 9999, + 8, + 9999, + 0, + 9999, + 0, + 9999, + 1e-120, + 9999 + ], + "strideA1": 6, + "strideA2": 2, + "offsetA": 0, + "A_mat": [ + [ + 1e-100, + 5, + 7 + ], + [ + 0, + 1e-110, + 8 + ], + [ + 0, + 0, + 1e-120 + ] + ], + "X": [ + 1e+100, + 9999, + 2e+100, + 9999, + 3e+100, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 0.2, + 9999, + -1e+110, + 9999, + 8e+230, + 9999 + ], + "expectedCNORM": [ + 0, + 9999, + 5, + 9999, + 15, + 9999 + ], + "scale": 2.0000000000000003e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_no_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_no_trans_lower_col_major.json new file mode 100644 index 000000000000..24685dc02e4b --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_no_trans_lower_col_major.json @@ -0,0 +1,86 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 9999, + 1e+100, + 9999, + 2e+100, + 9999, + 0, + 9999, + 1, + 9999, + 3e+100, + 9999, + 0, + 9999, + 0, + 9999, + 1, + 9999 + ], + "strideA1": 2, + "strideA2": 6, + "offsetA": 0, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 1e+100, + 1, + 0 + ], + [ + 2e+100, + 3e+100, + 1 + ] + ], + "X": [ + 1e+100, + 9999, + 2e+100, + 9999, + 3e+100, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 5e-101, + 9999, + -0.5, + 9999, + 1.5e+100, + 9999 + ], + "expectedCNORM": [ + 3.0000000000000002e+100, + 9999, + 3e+100, + 9999, + 0, + 9999 + ], + "scale": 5e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_no_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_no_trans_lower_row_major.json new file mode 100644 index 000000000000..03c39cb1fcb8 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_no_trans_lower_row_major.json @@ -0,0 +1,86 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 9999, + 0, + 9999, + 0, + 9999, + 1e+100, + 9999, + 1, + 9999, + 0, + 9999, + 2e+100, + 9999, + 3e+100, + 9999, + 1, + 9999 + ], + "strideA1": 6, + "strideA2": 2, + "offsetA": 0, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 1e+100, + 1, + 0 + ], + [ + 2e+100, + 3e+100, + 1 + ] + ], + "X": [ + 1e+100, + 9999, + 2e+100, + 9999, + 3e+100, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 5e-101, + 9999, + -0.5, + 9999, + 1.5e+100, + 9999 + ], + "expectedCNORM": [ + 3.0000000000000002e+100, + 9999, + 3e+100, + 9999, + 0, + 9999 + ], + "scale": 5e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_no_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_no_trans_upper_col_major.json new file mode 100644 index 000000000000..a25e3849c251 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_no_trans_upper_col_major.json @@ -0,0 +1,86 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 9999, + 0, + 9999, + 0, + 9999, + 1e+100, + 9999, + 1, + 9999, + 0, + 9999, + 2e+100, + 9999, + 3e+100, + 9999, + 1, + 9999 + ], + "strideA1": 2, + "strideA2": 6, + "offsetA": 0, + "A_mat": [ + [ + 1, + 1e+100, + 2e+100 + ], + [ + 0, + 1, + 3e+100 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 3e+100, + 9999, + 2e+100, + 9999, + 1e+100, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 5e+99, + 9999, + -0.5, + 9999, + 1.6666666666666668e-101, + 9999 + ], + "expectedCNORM": [ + 0, + 9999, + 1e+100, + 9999, + 5e+100, + 9999 + ], + "scale": 1.6666666666666668e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_no_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_no_trans_upper_row_major.json new file mode 100644 index 000000000000..3ea655628369 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_no_trans_upper_row_major.json @@ -0,0 +1,86 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 9999, + 1e+100, + 9999, + 2e+100, + 9999, + 0, + 9999, + 1, + 9999, + 3e+100, + 9999, + 0, + 9999, + 0, + 9999, + 1, + 9999 + ], + "strideA1": 6, + "strideA2": 2, + "offsetA": 0, + "A_mat": [ + [ + 1, + 1e+100, + 2e+100 + ], + [ + 0, + 1, + 3e+100 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 3e+100, + 9999, + 2e+100, + 9999, + 1e+100, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 5e+99, + 9999, + -0.5, + 9999, + 1.6666666666666668e-101, + 9999 + ], + "expectedCNORM": [ + 0, + 9999, + 1e+100, + 9999, + 5e+100, + 9999 + ], + "scale": 1.6666666666666668e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_trans_lower_col_major.json new file mode 100644 index 000000000000..d2d62550fc71 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_trans_lower_col_major.json @@ -0,0 +1,86 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 9999, + 4e+100, + 9999, + 7e+100, + 9999, + 0, + 9999, + 1, + 9999, + 8e+100, + 9999, + 0, + 9999, + 0, + 9999, + 1, + 9999 + ], + "strideA1": 2, + "strideA2": 6, + "offsetA": 0, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 4e+100, + 1, + 0 + ], + [ + 7e+100, + 8e+100, + 1 + ] + ], + "X": [ + 1e+100, + 9999, + 2e+100, + 9999, + 3e+100, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 2e+100, + 9999, + -0.5, + 9999, + 6.25e-102, + 9999 + ], + "expectedCNORM": [ + 1.1e+101, + 9999, + 8e+100, + 9999, + 0, + 9999 + ], + "scale": 2.0833333333333334e-202 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_trans_lower_row_major.json new file mode 100644 index 000000000000..83913261fdd0 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_trans_lower_row_major.json @@ -0,0 +1,86 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 9999, + 0, + 9999, + 0, + 9999, + 4e+100, + 9999, + 1, + 9999, + 0, + 9999, + 7e+100, + 9999, + 8e+100, + 9999, + 1, + 9999 + ], + "strideA1": 6, + "strideA2": 2, + "offsetA": 0, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 4e+100, + 1, + 0 + ], + [ + 7e+100, + 8e+100, + 1 + ] + ], + "X": [ + 1e+100, + 9999, + 2e+100, + 9999, + 3e+100, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 2e+100, + 9999, + -0.5, + 9999, + 6.25e-102, + 9999 + ], + "expectedCNORM": [ + 1.1e+101, + 9999, + 8e+100, + 9999, + 0, + 9999 + ], + "scale": 2.0833333333333334e-202 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_trans_upper_col_major.json new file mode 100644 index 000000000000..98a3539e4907 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_trans_upper_col_major.json @@ -0,0 +1,86 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 9999, + 0, + 9999, + 0, + 9999, + 2e+100, + 9999, + 1, + 9999, + 0, + 9999, + 3e+100, + 9999, + 5e+100, + 9999, + 1, + 9999 + ], + "strideA1": 2, + "strideA2": 6, + "offsetA": 0, + "A_mat": [ + [ + 1, + 2e+100, + 3e+100 + ], + [ + 0, + 1, + 5e+100 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 1e+100, + 9999, + 2e+100, + 9999, + 3e+100, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 2.5e-101, + 9999, + -0.5, + 9999, + 2.5e+100, + 9999 + ], + "expectedCNORM": [ + 0, + 9999, + 2e+100, + 9999, + 8e+100, + 9999 + ], + "scale": 2.5e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_trans_upper_row_major.json new file mode 100644 index 000000000000..4714baf4dce3 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/scaled_unit_trans_upper_row_major.json @@ -0,0 +1,86 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 9999, + 2e+100, + 9999, + 3e+100, + 9999, + 0, + 9999, + 1, + 9999, + 5e+100, + 9999, + 0, + 9999, + 0, + 9999, + 1, + 9999 + ], + "strideA1": 6, + "strideA2": 2, + "offsetA": 0, + "A_mat": [ + [ + 1, + 2e+100, + 3e+100 + ], + [ + 0, + 1, + 5e+100 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 1e+100, + 9999, + 2e+100, + 9999, + 3e+100, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 2.5e-101, + 9999, + -0.5, + 9999, + 2.5e+100, + 9999 + ], + "expectedCNORM": [ + 0, + 9999, + 2e+100, + 9999, + 8e+100, + 9999 + ], + "scale": 2.5e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_no_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_no_trans_lower_col_major.json new file mode 100644 index 000000000000..541ee0c4e1ad --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_no_trans_lower_col_major.json @@ -0,0 +1,86 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 9999, + 2, + 9999, + 3, + 9999, + 0, + 9999, + 1, + 9999, + -1, + 9999, + 0, + 9999, + 0, + 9999, + 1, + 9999 + ], + "strideA1": 2, + "strideA2": 6, + "offsetA": 0, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 2, + 1, + 0 + ], + [ + 3, + -1, + 1 + ] + ], + "X": [ + 1, + 9999, + 3, + 9999, + 3, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 1, + 9999, + 1, + 9999, + 1, + 9999 + ], + "expectedCNORM": [ + 5, + 9999, + 1, + 9999, + 0, + 9999 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_no_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_no_trans_lower_row_major.json new file mode 100644 index 000000000000..b0554db5f3dc --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_no_trans_lower_row_major.json @@ -0,0 +1,86 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 9999, + 0, + 9999, + 0, + 9999, + 2, + 9999, + 1, + 9999, + 0, + 9999, + 3, + 9999, + -1, + 9999, + 1, + 9999 + ], + "strideA1": 6, + "strideA2": 2, + "offsetA": 0, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 2, + 1, + 0 + ], + [ + 3, + -1, + 1 + ] + ], + "X": [ + 1, + 9999, + 3, + 9999, + 3, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 1, + 9999, + 1, + 9999, + 1, + 9999 + ], + "expectedCNORM": [ + 5, + 9999, + 1, + 9999, + 0, + 9999 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_no_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_no_trans_upper_col_major.json new file mode 100644 index 000000000000..36228fefaf14 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_no_trans_upper_col_major.json @@ -0,0 +1,86 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 9999, + 0, + 9999, + 0, + 9999, + 2, + 9999, + 1, + 9999, + 0, + 9999, + -1, + 9999, + 3, + 9999, + 1, + 9999 + ], + "strideA1": 2, + "strideA2": 6, + "offsetA": 0, + "A_mat": [ + [ + 1, + 2, + -1 + ], + [ + 0, + 1, + 3 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 2, + 9999, + 4, + 9999, + 1, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 1, + 9999, + 1, + 9999, + 1, + 9999 + ], + "expectedCNORM": [ + 0, + 9999, + 2, + 9999, + 4, + 9999 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_no_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_no_trans_upper_row_major.json new file mode 100644 index 000000000000..05e9dafcf23c --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_no_trans_upper_row_major.json @@ -0,0 +1,86 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 9999, + 2, + 9999, + -1, + 9999, + 0, + 9999, + 1, + 9999, + 3, + 9999, + 0, + 9999, + 0, + 9999, + 1, + 9999 + ], + "strideA1": 6, + "strideA2": 2, + "offsetA": 0, + "A_mat": [ + [ + 1, + 2, + -1 + ], + [ + 0, + 1, + 3 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 2, + 9999, + 4, + 9999, + 1, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 1, + 9999, + 1, + 9999, + 1, + 9999 + ], + "expectedCNORM": [ + 0, + 9999, + 2, + 9999, + 4, + 9999 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_trans_lower_col_major.json new file mode 100644 index 000000000000..7453f51b6987 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_trans_lower_col_major.json @@ -0,0 +1,86 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 9999, + 4, + 9999, + 2, + 9999, + 0, + 9999, + 1, + 9999, + -1, + 9999, + 0, + 9999, + 0, + 9999, + 1, + 9999 + ], + "strideA1": 2, + "strideA2": 6, + "offsetA": 0, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 4, + 1, + 0 + ], + [ + 2, + -1, + 1 + ] + ], + "X": [ + 7, + 9999, + 0, + 9999, + 1, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 1, + 9999, + 1, + 9999, + 1, + 9999 + ], + "expectedCNORM": [ + 6, + 9999, + 1, + 9999, + 0, + 9999 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_trans_lower_row_major.json new file mode 100644 index 000000000000..50e3a4bdfa24 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_trans_lower_row_major.json @@ -0,0 +1,86 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 9999, + 0, + 9999, + 0, + 9999, + 4, + 9999, + 1, + 9999, + 0, + 9999, + 2, + 9999, + -1, + 9999, + 1, + 9999 + ], + "strideA1": 6, + "strideA2": 2, + "offsetA": 0, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 4, + 1, + 0 + ], + [ + 2, + -1, + 1 + ] + ], + "X": [ + 7, + 9999, + 0, + 9999, + 1, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 1, + 9999, + 1, + 9999, + 1, + 9999 + ], + "expectedCNORM": [ + 6, + 9999, + 1, + 9999, + 0, + 9999 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_trans_upper_col_major.json new file mode 100644 index 000000000000..d6192311a465 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_trans_upper_col_major.json @@ -0,0 +1,86 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 9999, + 0, + 9999, + 0, + 9999, + 2, + 9999, + 1, + 9999, + 0, + 9999, + 3, + 9999, + 4, + 9999, + 1, + 9999 + ], + "strideA1": 2, + "strideA2": 6, + "offsetA": 0, + "A_mat": [ + [ + 1, + 2, + 3 + ], + [ + 0, + 1, + 4 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 1, + 9999, + 3, + 9999, + 8, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 1, + 9999, + 1, + 9999, + 1, + 9999 + ], + "expectedCNORM": [ + 0, + 9999, + 2, + 9999, + 7, + 9999 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_trans_upper_row_major.json new file mode 100644 index 000000000000..9543cfbf103b --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/large_strides/unit_trans_upper_row_major.json @@ -0,0 +1,86 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 9999, + 2, + 9999, + 3, + 9999, + 0, + 9999, + 1, + 9999, + 4, + 9999, + 0, + 9999, + 0, + 9999, + 1, + 9999 + ], + "strideA1": 6, + "strideA2": 2, + "offsetA": 0, + "A_mat": [ + [ + 1, + 2, + 3 + ], + [ + 0, + 1, + 4 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 1, + 9999, + 3, + 9999, + 8, + 9999 + ], + "strideX": 2, + "offsetX": 0, + "CNORM": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideCNORM": 2, + "offsetCNORM": 0, + "expectedX": [ + 1, + 9999, + 1, + 9999, + 1, + 9999 + ], + "expectedCNORM": [ + 0, + 9999, + 2, + 9999, + 7, + 9999 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/large_off_diagonal_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/large_off_diagonal_col_major.json new file mode 100644 index 000000000000..08dc9dcf566d --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/large_off_diagonal_col_major.json @@ -0,0 +1,65 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1e+292, + 1e+292, + 1, + 1e+292, + 1, + 0, + 1, + 0, + 0 + ], + "strideA1": 1, + "strideA2": -3, + "offsetA": 6, + "A_mat": [ + [ + 1, + 1e+292, + 1e+292 + ], + [ + 0, + 1, + 1e+292 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 1, + 1, + 1 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 5e+291, + -0.5, + 4.9999999999999997e-293 + ], + "expectedCNORM": [ + 0, + 1e+292, + 2e+292 + ], + "scale": 4.9999999999999997e-293 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/large_off_diagonal_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/large_off_diagonal_row_major.json new file mode 100644 index 000000000000..56e529094c2d --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/large_off_diagonal_row_major.json @@ -0,0 +1,65 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 0, + 0, + 1, + 0, + 1, + 1e+292, + 1, + 1e+292, + 1e+292 + ], + "strideA1": -3, + "strideA2": 1, + "offsetA": 6, + "A_mat": [ + [ + 1, + 1e+292, + 1e+292 + ], + [ + 0, + 1, + 1e+292 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 1, + 1, + 1 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 5e+291, + -0.5, + 4.9999999999999997e-293 + ], + "expectedCNORM": [ + 0, + 1e+292, + 2e+292 + ], + "scale": 4.9999999999999997e-293 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_no_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_no_trans_lower_col_major.json new file mode 100644 index 000000000000..84f5c3eeaa10 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_no_trans_lower_col_major.json @@ -0,0 +1,65 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 0, + 0, + 4, + 0, + 3, + 2, + 2, + 1, + -1 + ], + "strideA1": 1, + "strideA2": -3, + "offsetA": 6, + "A_mat": [ + [ + 2, + 0, + 0 + ], + [ + 1, + 3, + 0 + ], + [ + -1, + 2, + 4 + ] + ], + "X": [ + 5, + 10, + 20 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 2.5, + 2.5, + 4.375 + ], + "expectedCNORM": [ + 2, + 2, + 0 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_no_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_no_trans_lower_row_major.json new file mode 100644 index 000000000000..4dfc6ccd6dd3 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_no_trans_lower_row_major.json @@ -0,0 +1,65 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + -1, + 2, + 4, + 1, + 3, + 0, + 2, + 0, + 0 + ], + "strideA1": -3, + "strideA2": 1, + "offsetA": 6, + "A_mat": [ + [ + 2, + 0, + 0 + ], + [ + 1, + 3, + 0 + ], + [ + -1, + 2, + 4 + ] + ], + "X": [ + 5, + 10, + 20 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 2.5, + 2.5, + 4.375 + ], + "expectedCNORM": [ + 2, + 2, + 0 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_no_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_no_trans_upper_col_major.json new file mode 100644 index 000000000000..6c53c42a827e --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_no_trans_upper_col_major.json @@ -0,0 +1,65 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + -1, + 2, + 4, + 1, + 3, + 0, + 2, + 0, + 0 + ], + "strideA1": 1, + "strideA2": -3, + "offsetA": 6, + "A_mat": [ + [ + 2, + 1, + -1 + ], + [ + 0, + 3, + 2 + ], + [ + 0, + 0, + 4 + ] + ], + "X": [ + 5, + 10, + 20 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 5, + 0, + 5 + ], + "expectedCNORM": [ + 0, + 1, + 3 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_no_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_no_trans_upper_row_major.json new file mode 100644 index 000000000000..828648d59bae --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_no_trans_upper_row_major.json @@ -0,0 +1,65 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 0, + 0, + 4, + 0, + 3, + 2, + 2, + 1, + -1 + ], + "strideA1": -3, + "strideA2": 1, + "offsetA": 6, + "A_mat": [ + [ + 2, + 1, + -1 + ], + [ + 0, + 3, + 2 + ], + [ + 0, + 0, + 4 + ] + ], + "X": [ + 5, + 10, + 20 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 5, + 0, + 5 + ], + "expectedCNORM": [ + 0, + 1, + 3 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_trans_lower_col_major.json new file mode 100644 index 000000000000..81777534c002 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_trans_lower_col_major.json @@ -0,0 +1,65 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 0, + 0, + 4, + 0, + 3, + 2, + 2, + 1, + -1 + ], + "strideA1": 1, + "strideA2": -3, + "offsetA": 6, + "A_mat": [ + [ + 2, + 0, + 0 + ], + [ + 1, + 3, + 0 + ], + [ + -1, + 2, + 4 + ] + ], + "X": [ + 2, + 5, + 4 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 1, + 1, + 1 + ], + "expectedCNORM": [ + 2, + 2, + 0 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_trans_lower_row_major.json new file mode 100644 index 000000000000..4572d4f65036 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_trans_lower_row_major.json @@ -0,0 +1,65 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + -1, + 2, + 4, + 1, + 3, + 0, + 2, + 0, + 0 + ], + "strideA1": -3, + "strideA2": 1, + "offsetA": 6, + "A_mat": [ + [ + 2, + 0, + 0 + ], + [ + 1, + 3, + 0 + ], + [ + -1, + 2, + 4 + ] + ], + "X": [ + 2, + 5, + 4 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 1, + 1, + 1 + ], + "expectedCNORM": [ + 2, + 2, + 0 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_trans_upper_col_major.json new file mode 100644 index 000000000000..6d27f3b6fb28 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_trans_upper_col_major.json @@ -0,0 +1,65 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + -1, + 2, + 4, + 1, + 3, + 0, + 2, + 1, + 0 + ], + "strideA1": 1, + "strideA2": -3, + "offsetA": 6, + "A_mat": [ + [ + 2, + 1, + -1 + ], + [ + 1, + 3, + 2 + ], + [ + 0, + 0, + 4 + ] + ], + "X": [ + 2, + 5, + 4 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 1, + 1.3333333333333333, + 0.5833333333333334 + ], + "expectedCNORM": [ + 0, + 1, + 3 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_trans_upper_row_major.json new file mode 100644 index 000000000000..c1cb4b871b35 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/non_unit_trans_upper_row_major.json @@ -0,0 +1,65 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 0, + 0, + 4, + 0, + 3, + 2, + 2, + 1, + -1 + ], + "strideA1": -3, + "strideA2": 1, + "offsetA": 6, + "A_mat": [ + [ + 2, + 1, + -1 + ], + [ + 1, + 3, + 2 + ], + [ + 0, + 0, + 4 + ] + ], + "X": [ + 2, + 5, + 4 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 1, + 1.3333333333333333, + 0.5833333333333334 + ], + "expectedCNORM": [ + 0, + 1, + 3 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_no_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_no_trans_lower_col_major.json new file mode 100644 index 000000000000..e321af4334b2 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_no_trans_lower_col_major.json @@ -0,0 +1,65 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 0, + 0, + 0.01, + 0, + 0.1, + 4, + 1, + 2, + 3 + ], + "strideA1": 1, + "strideA2": -3, + "offsetA": 6, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 2, + 0.1, + 0 + ], + [ + 3, + 4, + 0.01 + ] + ], + "X": [ + 1e+308, + 1e+308, + 1e+308 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 0.5, + -5, + 1900 + ], + "expectedCNORM": [ + 5, + 4, + 0 + ], + "scale": 5e-309 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_no_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_no_trans_lower_row_major.json new file mode 100644 index 000000000000..992af4fa9984 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_no_trans_lower_row_major.json @@ -0,0 +1,65 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 3, + 4, + 0.01, + 2, + 0.1, + 0, + 1, + 0, + 0 + ], + "strideA1": -3, + "strideA2": 1, + "offsetA": 6, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 2, + 0.1, + 0 + ], + [ + 3, + 4, + 0.01 + ] + ], + "X": [ + 1e+308, + 1e+308, + 1e+308 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 0.5, + -5, + 1900 + ], + "expectedCNORM": [ + 5, + 4, + 0 + ], + "scale": 5e-309 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_no_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_no_trans_upper_col_major.json new file mode 100644 index 000000000000..38dbf686c527 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_no_trans_upper_col_major.json @@ -0,0 +1,65 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 3, + 4, + 1e-30, + 2, + 1e-20, + 0, + 1e-10, + 0, + 0 + ], + "strideA1": 1, + "strideA2": -3, + "offsetA": 6, + "A_mat": [ + [ + 1e-10, + 2, + 3 + ], + [ + 0, + 1e-20, + 4 + ], + [ + 0, + 0, + 1e-30 + ] + ], + "X": [ + 1e+300, + 2e+300, + 3e+300 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 7.999999999999998e+60, + -3.9999999999999995e+50, + 9.999999999999999e+29 + ], + "expectedCNORM": [ + 0, + 2, + 7 + ], + "scale": 3.333333333333333e-301 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_no_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_no_trans_upper_row_major.json new file mode 100644 index 000000000000..4402520445e2 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_no_trans_upper_row_major.json @@ -0,0 +1,65 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 0, + 0, + 1e-30, + 0, + 1e-20, + 4, + 1e-10, + 2, + 3 + ], + "strideA1": -3, + "strideA2": 1, + "offsetA": 6, + "A_mat": [ + [ + 1e-10, + 2, + 3 + ], + [ + 0, + 1e-20, + 4 + ], + [ + 0, + 0, + 1e-30 + ] + ], + "X": [ + 1e+300, + 2e+300, + 3e+300 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 7.999999999999998e+60, + -3.9999999999999995e+50, + 9.999999999999999e+29 + ], + "expectedCNORM": [ + 0, + 2, + 7 + ], + "scale": 3.333333333333333e-301 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_trans_lower_col_major.json new file mode 100644 index 000000000000..6cbe987de18a --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_trans_lower_col_major.json @@ -0,0 +1,65 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 0, + 0, + 1e-140, + 0, + 1e-120, + 3, + 1e-100, + 1, + 2 + ], + "strideA1": 1, + "strideA2": -3, + "offsetA": 6, + "A_mat": [ + [ + 1e-100, + 0, + 0 + ], + [ + 1, + 1e-120, + 0 + ], + [ + 2, + 3, + 1e-140 + ] + ], + "X": [ + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 1e+220, + -1e+120, + 0.3333333333333333 + ], + "expectedCNORM": [ + 3, + 3, + 0 + ], + "scale": 1.1111111111111112e-241 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_trans_lower_row_major.json new file mode 100644 index 000000000000..c80a8f9be0fa --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_trans_lower_row_major.json @@ -0,0 +1,65 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 2, + 3, + 1e-140, + 1, + 1e-120, + 0, + 1e-100, + 0, + 0 + ], + "strideA1": -3, + "strideA2": 1, + "offsetA": 6, + "A_mat": [ + [ + 1e-100, + 0, + 0 + ], + [ + 1, + 1e-120, + 0 + ], + [ + 2, + 3, + 1e-140 + ] + ], + "X": [ + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 1e+220, + -1e+120, + 0.3333333333333333 + ], + "expectedCNORM": [ + 3, + 3, + 0 + ], + "scale": 1.1111111111111112e-241 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_trans_upper_col_major.json new file mode 100644 index 000000000000..fd7363724782 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_trans_upper_col_major.json @@ -0,0 +1,65 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 7, + 8, + 1e-120, + 5, + 1e-110, + 0, + 1e-100, + 0, + 0 + ], + "strideA1": 1, + "strideA2": -3, + "offsetA": 6, + "A_mat": [ + [ + 1e-100, + 5, + 7 + ], + [ + 0, + 1e-110, + 8 + ], + [ + 0, + 0, + 1e-120 + ] + ], + "X": [ + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 0.2, + -1e+110, + 8e+230 + ], + "expectedCNORM": [ + 0, + 5, + 15 + ], + "scale": 2.0000000000000003e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_trans_upper_row_major.json new file mode 100644 index 000000000000..bee9e164184d --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_non_unit_trans_upper_row_major.json @@ -0,0 +1,65 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 0, + 0, + 1e-120, + 0, + 1e-110, + 8, + 1e-100, + 5, + 7 + ], + "strideA1": -3, + "strideA2": 1, + "offsetA": 6, + "A_mat": [ + [ + 1e-100, + 5, + 7 + ], + [ + 0, + 1e-110, + 8 + ], + [ + 0, + 0, + 1e-120 + ] + ], + "X": [ + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 0.2, + -1e+110, + 8e+230 + ], + "expectedCNORM": [ + 0, + 5, + 15 + ], + "scale": 2.0000000000000003e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_no_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_no_trans_lower_col_major.json new file mode 100644 index 000000000000..6067d0c54dce --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_no_trans_lower_col_major.json @@ -0,0 +1,65 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 0, + 0, + 1, + 0, + 1, + 3e+100, + 1, + 1e+100, + 2e+100 + ], + "strideA1": 1, + "strideA2": -3, + "offsetA": 6, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 1e+100, + 1, + 0 + ], + [ + 2e+100, + 3e+100, + 1 + ] + ], + "X": [ + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 5e-101, + -0.5, + 1.5e+100 + ], + "expectedCNORM": [ + 3.0000000000000002e+100, + 3e+100, + 0 + ], + "scale": 5e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_no_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_no_trans_lower_row_major.json new file mode 100644 index 000000000000..a8dfc865144a --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_no_trans_lower_row_major.json @@ -0,0 +1,65 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 2e+100, + 3e+100, + 1, + 1e+100, + 1, + 0, + 1, + 0, + 0 + ], + "strideA1": -3, + "strideA2": 1, + "offsetA": 6, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 1e+100, + 1, + 0 + ], + [ + 2e+100, + 3e+100, + 1 + ] + ], + "X": [ + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 5e-101, + -0.5, + 1.5e+100 + ], + "expectedCNORM": [ + 3.0000000000000002e+100, + 3e+100, + 0 + ], + "scale": 5e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_no_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_no_trans_upper_col_major.json new file mode 100644 index 000000000000..4c9708b4a2e4 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_no_trans_upper_col_major.json @@ -0,0 +1,65 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 2e+100, + 3e+100, + 1, + 1e+100, + 1, + 0, + 1, + 0, + 0 + ], + "strideA1": 1, + "strideA2": -3, + "offsetA": 6, + "A_mat": [ + [ + 1, + 1e+100, + 2e+100 + ], + [ + 0, + 1, + 3e+100 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 3e+100, + 2e+100, + 1e+100 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 5e+99, + -0.5, + 1.6666666666666668e-101 + ], + "expectedCNORM": [ + 0, + 1e+100, + 5e+100 + ], + "scale": 1.6666666666666668e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_no_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_no_trans_upper_row_major.json new file mode 100644 index 000000000000..10ecd4350731 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_no_trans_upper_row_major.json @@ -0,0 +1,65 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 0, + 0, + 1, + 0, + 1, + 3e+100, + 1, + 1e+100, + 2e+100 + ], + "strideA1": -3, + "strideA2": 1, + "offsetA": 6, + "A_mat": [ + [ + 1, + 1e+100, + 2e+100 + ], + [ + 0, + 1, + 3e+100 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 3e+100, + 2e+100, + 1e+100 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 5e+99, + -0.5, + 1.6666666666666668e-101 + ], + "expectedCNORM": [ + 0, + 1e+100, + 5e+100 + ], + "scale": 1.6666666666666668e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_trans_lower_col_major.json new file mode 100644 index 000000000000..88ff29e28376 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_trans_lower_col_major.json @@ -0,0 +1,65 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 0, + 0, + 1, + 0, + 1, + 8e+100, + 1, + 4e+100, + 7e+100 + ], + "strideA1": 1, + "strideA2": -3, + "offsetA": 6, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 4e+100, + 1, + 0 + ], + [ + 7e+100, + 8e+100, + 1 + ] + ], + "X": [ + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 2e+100, + -0.5, + 6.25e-102 + ], + "expectedCNORM": [ + 1.1e+101, + 8e+100, + 0 + ], + "scale": 2.0833333333333334e-202 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_trans_lower_row_major.json new file mode 100644 index 000000000000..e9204bbaded1 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_trans_lower_row_major.json @@ -0,0 +1,65 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 7e+100, + 8e+100, + 1, + 4e+100, + 1, + 0, + 1, + 0, + 0 + ], + "strideA1": -3, + "strideA2": 1, + "offsetA": 6, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 4e+100, + 1, + 0 + ], + [ + 7e+100, + 8e+100, + 1 + ] + ], + "X": [ + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 2e+100, + -0.5, + 6.25e-102 + ], + "expectedCNORM": [ + 1.1e+101, + 8e+100, + 0 + ], + "scale": 2.0833333333333334e-202 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_trans_upper_col_major.json new file mode 100644 index 000000000000..8eb8d4d335f4 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_trans_upper_col_major.json @@ -0,0 +1,65 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 3e+100, + 5e+100, + 1, + 2e+100, + 1, + 0, + 1, + 0, + 0 + ], + "strideA1": 1, + "strideA2": -3, + "offsetA": 6, + "A_mat": [ + [ + 1, + 2e+100, + 3e+100 + ], + [ + 0, + 1, + 5e+100 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 2.5e-101, + -0.5, + 2.5e+100 + ], + "expectedCNORM": [ + 0, + 2e+100, + 8e+100 + ], + "scale": 2.5e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_trans_upper_row_major.json new file mode 100644 index 000000000000..f611a1fc291d --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/scaled_unit_trans_upper_row_major.json @@ -0,0 +1,65 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 0, + 0, + 1, + 0, + 1, + 5e+100, + 1, + 2e+100, + 3e+100 + ], + "strideA1": -3, + "strideA2": 1, + "offsetA": 6, + "A_mat": [ + [ + 1, + 2e+100, + 3e+100 + ], + [ + 0, + 1, + 5e+100 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 2.5e-101, + -0.5, + 2.5e+100 + ], + "expectedCNORM": [ + 0, + 2e+100, + 8e+100 + ], + "scale": 2.5e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_no_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_no_trans_lower_col_major.json new file mode 100644 index 000000000000..4b874b9db01f --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_no_trans_lower_col_major.json @@ -0,0 +1,65 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 0, + 0, + 1, + 0, + 1, + -1, + 1, + 2, + 3 + ], + "strideA1": 1, + "strideA2": -3, + "offsetA": 6, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 2, + 1, + 0 + ], + [ + 3, + -1, + 1 + ] + ], + "X": [ + 1, + 3, + 3 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 1, + 1, + 1 + ], + "expectedCNORM": [ + 5, + 1, + 0 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_no_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_no_trans_lower_row_major.json new file mode 100644 index 000000000000..5d0fd9090d91 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_no_trans_lower_row_major.json @@ -0,0 +1,65 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 3, + -1, + 1, + 2, + 1, + 0, + 1, + 0, + 0 + ], + "strideA1": -3, + "strideA2": 1, + "offsetA": 6, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 2, + 1, + 0 + ], + [ + 3, + -1, + 1 + ] + ], + "X": [ + 1, + 3, + 3 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 1, + 1, + 1 + ], + "expectedCNORM": [ + 5, + 1, + 0 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_no_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_no_trans_upper_col_major.json new file mode 100644 index 000000000000..751dc2b51fa4 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_no_trans_upper_col_major.json @@ -0,0 +1,65 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + -1, + 3, + 1, + 2, + 1, + 0, + 1, + 0, + 0 + ], + "strideA1": 1, + "strideA2": -3, + "offsetA": 6, + "A_mat": [ + [ + 1, + 2, + -1 + ], + [ + 0, + 1, + 3 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 2, + 4, + 1 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 1, + 1, + 1 + ], + "expectedCNORM": [ + 0, + 2, + 4 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_no_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_no_trans_upper_row_major.json new file mode 100644 index 000000000000..c7033204975d --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_no_trans_upper_row_major.json @@ -0,0 +1,65 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 0, + 0, + 1, + 0, + 1, + 3, + 1, + 2, + -1 + ], + "strideA1": -3, + "strideA2": 1, + "offsetA": 6, + "A_mat": [ + [ + 1, + 2, + -1 + ], + [ + 0, + 1, + 3 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 2, + 4, + 1 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 1, + 1, + 1 + ], + "expectedCNORM": [ + 0, + 2, + 4 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_trans_lower_col_major.json new file mode 100644 index 000000000000..b93faf0cfbed --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_trans_lower_col_major.json @@ -0,0 +1,65 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 0, + 0, + 1, + 0, + 1, + -1, + 1, + 4, + 2 + ], + "strideA1": 1, + "strideA2": -3, + "offsetA": 6, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 4, + 1, + 0 + ], + [ + 2, + -1, + 1 + ] + ], + "X": [ + 7, + 0, + 1 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 1, + 1, + 1 + ], + "expectedCNORM": [ + 6, + 1, + 0 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_trans_lower_row_major.json new file mode 100644 index 000000000000..ac41de0f0e52 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_trans_lower_row_major.json @@ -0,0 +1,65 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 2, + -1, + 1, + 4, + 1, + 0, + 1, + 0, + 0 + ], + "strideA1": -3, + "strideA2": 1, + "offsetA": 6, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 4, + 1, + 0 + ], + [ + 2, + -1, + 1 + ] + ], + "X": [ + 7, + 0, + 1 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 1, + 1, + 1 + ], + "expectedCNORM": [ + 6, + 1, + 0 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_trans_upper_col_major.json new file mode 100644 index 000000000000..e8f0ed4614a4 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_trans_upper_col_major.json @@ -0,0 +1,65 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 3, + 4, + 1, + 2, + 1, + 0, + 1, + 0, + 0 + ], + "strideA1": 1, + "strideA2": -3, + "offsetA": 6, + "A_mat": [ + [ + 1, + 2, + 3 + ], + [ + 0, + 1, + 4 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 1, + 3, + 8 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 1, + 1, + 1 + ], + "expectedCNORM": [ + 0, + 2, + 7 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_trans_upper_row_major.json new file mode 100644 index 000000000000..650daecd6a0e --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/mixed_strides/unit_trans_upper_row_major.json @@ -0,0 +1,65 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 0, + 0, + 1, + 0, + 1, + 4, + 1, + 2, + 3 + ], + "strideA1": -3, + "strideA2": 1, + "offsetA": 6, + "A_mat": [ + [ + 1, + 2, + 3 + ], + [ + 0, + 1, + 4 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 1, + 3, + 8 + ], + "strideX": 1, + "offsetX": 0, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 0, + "expectedX": [ + 1, + 1, + 1 + ], + "expectedCNORM": [ + 0, + 2, + 7 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/large_off_diagonal_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/large_off_diagonal_col_major.json new file mode 100644 index 000000000000..396a5720c5ce --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/large_off_diagonal_col_major.json @@ -0,0 +1,67 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 1e+292, + 1e+292, + 0, + 1, + 1e+292, + 0, + 0, + 1 + ], + "strideA1": -1, + "strideA2": -3, + "offsetA": 8, + "A_mat": [ + [ + 1, + 1e+292, + 1e+292 + ], + [ + 0, + 1, + 1e+292 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 1, + 1, + 1 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 4.9999999999999997e-293, + -0.5, + 5e+291 + ], + "expectedCNORM": [ + 2e+292, + 1e+292, + 0 + ], + "scale": 4.9999999999999997e-293, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/large_off_diagonal_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/large_off_diagonal_row_major.json new file mode 100644 index 000000000000..5459e0286808 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/large_off_diagonal_row_major.json @@ -0,0 +1,67 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 0, + 0, + 1e+292, + 1, + 0, + 1e+292, + 1e+292, + 1 + ], + "strideA1": -3, + "strideA2": -1, + "offsetA": 8, + "A_mat": [ + [ + 1, + 1e+292, + 1e+292 + ], + [ + 0, + 1, + 1e+292 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 1, + 1, + 1 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 4.9999999999999997e-293, + -0.5, + 5e+291 + ], + "expectedCNORM": [ + 2e+292, + 1e+292, + 0 + ], + "scale": 4.9999999999999997e-293, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_no_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_no_trans_lower_col_major.json new file mode 100644 index 000000000000..e5e78138f630 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_no_trans_lower_col_major.json @@ -0,0 +1,67 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 4, + 0, + 0, + 2, + 3, + 0, + -1, + 1, + 2 + ], + "strideA1": -1, + "strideA2": -3, + "offsetA": 8, + "A_mat": [ + [ + 2, + 0, + 0 + ], + [ + 1, + 3, + 0 + ], + [ + -1, + 2, + 4 + ] + ], + "X": [ + 20, + 10, + 5 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 4.375, + 2.5, + 2.5 + ], + "expectedCNORM": [ + 0, + 2, + 2 + ], + "scale": 1, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_no_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_no_trans_lower_row_major.json new file mode 100644 index 000000000000..891460710e65 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_no_trans_lower_row_major.json @@ -0,0 +1,67 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 4, + 2, + -1, + 0, + 3, + 1, + 0, + 0, + 2 + ], + "strideA1": -3, + "strideA2": -1, + "offsetA": 8, + "A_mat": [ + [ + 2, + 0, + 0 + ], + [ + 1, + 3, + 0 + ], + [ + -1, + 2, + 4 + ] + ], + "X": [ + 20, + 10, + 5 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 4.375, + 2.5, + 2.5 + ], + "expectedCNORM": [ + 0, + 2, + 2 + ], + "scale": 1, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_no_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_no_trans_upper_col_major.json new file mode 100644 index 000000000000..2fd73bf79d4c --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_no_trans_upper_col_major.json @@ -0,0 +1,67 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 4, + 2, + -1, + 0, + 3, + 1, + 0, + 0, + 2 + ], + "strideA1": -1, + "strideA2": -3, + "offsetA": 8, + "A_mat": [ + [ + 2, + 1, + -1 + ], + [ + 0, + 3, + 2 + ], + [ + 0, + 0, + 4 + ] + ], + "X": [ + 20, + 10, + 5 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 5, + 0, + 5 + ], + "expectedCNORM": [ + 3, + 1, + 0 + ], + "scale": 1, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_no_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_no_trans_upper_row_major.json new file mode 100644 index 000000000000..6c32c0ee2755 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_no_trans_upper_row_major.json @@ -0,0 +1,67 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 4, + 0, + 0, + 2, + 3, + 0, + -1, + 1, + 2 + ], + "strideA1": -3, + "strideA2": -1, + "offsetA": 8, + "A_mat": [ + [ + 2, + 1, + -1 + ], + [ + 0, + 3, + 2 + ], + [ + 0, + 0, + 4 + ] + ], + "X": [ + 20, + 10, + 5 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 5, + 0, + 5 + ], + "expectedCNORM": [ + 3, + 1, + 0 + ], + "scale": 1, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_trans_lower_col_major.json new file mode 100644 index 000000000000..87da47af7c20 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_trans_lower_col_major.json @@ -0,0 +1,67 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 4, + 0, + 0, + 2, + 3, + 0, + -1, + 1, + 2 + ], + "strideA1": -1, + "strideA2": -3, + "offsetA": 8, + "A_mat": [ + [ + 2, + 0, + 0 + ], + [ + 1, + 3, + 0 + ], + [ + -1, + 2, + 4 + ] + ], + "X": [ + 4, + 5, + 2 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 1, + 1, + 1 + ], + "expectedCNORM": [ + 0, + 2, + 2 + ], + "scale": 1, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_trans_lower_row_major.json new file mode 100644 index 000000000000..d1e864c38588 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_trans_lower_row_major.json @@ -0,0 +1,67 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 4, + 2, + -1, + 0, + 3, + 1, + 0, + 0, + 2 + ], + "strideA1": -3, + "strideA2": -1, + "offsetA": 8, + "A_mat": [ + [ + 2, + 0, + 0 + ], + [ + 1, + 3, + 0 + ], + [ + -1, + 2, + 4 + ] + ], + "X": [ + 4, + 5, + 2 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 1, + 1, + 1 + ], + "expectedCNORM": [ + 0, + 2, + 2 + ], + "scale": 1, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_trans_upper_col_major.json new file mode 100644 index 000000000000..865ce1869de6 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_trans_upper_col_major.json @@ -0,0 +1,67 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 4, + 2, + -1, + 0, + 3, + 1, + 0, + 1, + 2 + ], + "strideA1": -1, + "strideA2": -3, + "offsetA": 8, + "A_mat": [ + [ + 2, + 1, + -1 + ], + [ + 1, + 3, + 2 + ], + [ + 0, + 0, + 4 + ] + ], + "X": [ + 4, + 5, + 2 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 0.5833333333333334, + 1.3333333333333333, + 1 + ], + "expectedCNORM": [ + 3, + 1, + 0 + ], + "scale": 1, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_trans_upper_row_major.json new file mode 100644 index 000000000000..29cdb72547cd --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/non_unit_trans_upper_row_major.json @@ -0,0 +1,67 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 4, + 0, + 0, + 2, + 3, + 0, + -1, + 1, + 2 + ], + "strideA1": -3, + "strideA2": -1, + "offsetA": 8, + "A_mat": [ + [ + 2, + 1, + -1 + ], + [ + 1, + 3, + 2 + ], + [ + 0, + 0, + 4 + ] + ], + "X": [ + 4, + 5, + 2 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 0.5833333333333334, + 1.3333333333333333, + 1 + ], + "expectedCNORM": [ + 3, + 1, + 0 + ], + "scale": 1, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_no_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_no_trans_lower_col_major.json new file mode 100644 index 000000000000..6bf0e68ac7a5 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_no_trans_lower_col_major.json @@ -0,0 +1,67 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 0.01, + 0, + 0, + 4, + 0.1, + 0, + 3, + 2, + 1 + ], + "strideA1": -1, + "strideA2": -3, + "offsetA": 8, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 2, + 0.1, + 0 + ], + [ + 3, + 4, + 0.01 + ] + ], + "X": [ + 1e+308, + 1e+308, + 1e+308 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 1900, + -5, + 0.5 + ], + "expectedCNORM": [ + 0, + 4, + 5 + ], + "scale": 5e-309, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_no_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_no_trans_lower_row_major.json new file mode 100644 index 000000000000..559de217c66e --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_no_trans_lower_row_major.json @@ -0,0 +1,67 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 0.01, + 4, + 3, + 0, + 0.1, + 2, + 0, + 0, + 1 + ], + "strideA1": -3, + "strideA2": -1, + "offsetA": 8, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 2, + 0.1, + 0 + ], + [ + 3, + 4, + 0.01 + ] + ], + "X": [ + 1e+308, + 1e+308, + 1e+308 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 1900, + -5, + 0.5 + ], + "expectedCNORM": [ + 0, + 4, + 5 + ], + "scale": 5e-309, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_no_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_no_trans_upper_col_major.json new file mode 100644 index 000000000000..a03b22481b24 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_no_trans_upper_col_major.json @@ -0,0 +1,67 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1e-30, + 4, + 3, + 0, + 1e-20, + 2, + 0, + 0, + 1e-10 + ], + "strideA1": -1, + "strideA2": -3, + "offsetA": 8, + "A_mat": [ + [ + 1e-10, + 2, + 3 + ], + [ + 0, + 1e-20, + 4 + ], + [ + 0, + 0, + 1e-30 + ] + ], + "X": [ + 3e+300, + 2e+300, + 1e+300 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 9.999999999999999e+29, + -3.9999999999999995e+50, + 7.999999999999998e+60 + ], + "expectedCNORM": [ + 7, + 2, + 0 + ], + "scale": 3.333333333333333e-301, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_no_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_no_trans_upper_row_major.json new file mode 100644 index 000000000000..fd7ba4056f28 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_no_trans_upper_row_major.json @@ -0,0 +1,67 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1e-30, + 0, + 0, + 4, + 1e-20, + 0, + 3, + 2, + 1e-10 + ], + "strideA1": -3, + "strideA2": -1, + "offsetA": 8, + "A_mat": [ + [ + 1e-10, + 2, + 3 + ], + [ + 0, + 1e-20, + 4 + ], + [ + 0, + 0, + 1e-30 + ] + ], + "X": [ + 3e+300, + 2e+300, + 1e+300 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 9.999999999999999e+29, + -3.9999999999999995e+50, + 7.999999999999998e+60 + ], + "expectedCNORM": [ + 7, + 2, + 0 + ], + "scale": 3.333333333333333e-301, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_trans_lower_col_major.json new file mode 100644 index 000000000000..e17bc0b6d366 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_trans_lower_col_major.json @@ -0,0 +1,67 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1e-140, + 0, + 0, + 3, + 1e-120, + 0, + 2, + 1, + 1e-100 + ], + "strideA1": -1, + "strideA2": -3, + "offsetA": 8, + "A_mat": [ + [ + 1e-100, + 0, + 0 + ], + [ + 1, + 1e-120, + 0 + ], + [ + 2, + 3, + 1e-140 + ] + ], + "X": [ + 3e+100, + 2e+100, + 1e+100 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 0.3333333333333333, + -1e+120, + 1e+220 + ], + "expectedCNORM": [ + 0, + 3, + 3 + ], + "scale": 1.1111111111111112e-241, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_trans_lower_row_major.json new file mode 100644 index 000000000000..93385bc69187 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_trans_lower_row_major.json @@ -0,0 +1,67 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1e-140, + 3, + 2, + 0, + 1e-120, + 1, + 0, + 0, + 1e-100 + ], + "strideA1": -3, + "strideA2": -1, + "offsetA": 8, + "A_mat": [ + [ + 1e-100, + 0, + 0 + ], + [ + 1, + 1e-120, + 0 + ], + [ + 2, + 3, + 1e-140 + ] + ], + "X": [ + 3e+100, + 2e+100, + 1e+100 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 0.3333333333333333, + -1e+120, + 1e+220 + ], + "expectedCNORM": [ + 0, + 3, + 3 + ], + "scale": 1.1111111111111112e-241, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_trans_upper_col_major.json new file mode 100644 index 000000000000..4a51d0940add --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_trans_upper_col_major.json @@ -0,0 +1,67 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1e-120, + 8, + 7, + 0, + 1e-110, + 5, + 0, + 0, + 1e-100 + ], + "strideA1": -1, + "strideA2": -3, + "offsetA": 8, + "A_mat": [ + [ + 1e-100, + 5, + 7 + ], + [ + 0, + 1e-110, + 8 + ], + [ + 0, + 0, + 1e-120 + ] + ], + "X": [ + 3e+100, + 2e+100, + 1e+100 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 8e+230, + -1e+110, + 0.2 + ], + "expectedCNORM": [ + 15, + 5, + 0 + ], + "scale": 2.0000000000000003e-201, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_trans_upper_row_major.json new file mode 100644 index 000000000000..d095c339b914 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_non_unit_trans_upper_row_major.json @@ -0,0 +1,67 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1e-120, + 0, + 0, + 8, + 1e-110, + 0, + 7, + 5, + 1e-100 + ], + "strideA1": -3, + "strideA2": -1, + "offsetA": 8, + "A_mat": [ + [ + 1e-100, + 5, + 7 + ], + [ + 0, + 1e-110, + 8 + ], + [ + 0, + 0, + 1e-120 + ] + ], + "X": [ + 3e+100, + 2e+100, + 1e+100 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 8e+230, + -1e+110, + 0.2 + ], + "expectedCNORM": [ + 15, + 5, + 0 + ], + "scale": 2.0000000000000003e-201, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_no_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_no_trans_lower_col_major.json new file mode 100644 index 000000000000..c91f763b95b9 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_no_trans_lower_col_major.json @@ -0,0 +1,67 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 0, + 0, + 3e+100, + 1, + 0, + 2e+100, + 1e+100, + 1 + ], + "strideA1": -1, + "strideA2": -3, + "offsetA": 8, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 1e+100, + 1, + 0 + ], + [ + 2e+100, + 3e+100, + 1 + ] + ], + "X": [ + 3e+100, + 2e+100, + 1e+100 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 1.5e+100, + -0.5, + 5e-101 + ], + "expectedCNORM": [ + 0, + 3e+100, + 3.0000000000000002e+100 + ], + "scale": 5e-201, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_no_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_no_trans_lower_row_major.json new file mode 100644 index 000000000000..5652c94ce8ef --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_no_trans_lower_row_major.json @@ -0,0 +1,67 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 3e+100, + 2e+100, + 0, + 1, + 1e+100, + 0, + 0, + 1 + ], + "strideA1": -3, + "strideA2": -1, + "offsetA": 8, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 1e+100, + 1, + 0 + ], + [ + 2e+100, + 3e+100, + 1 + ] + ], + "X": [ + 3e+100, + 2e+100, + 1e+100 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 1.5e+100, + -0.5, + 5e-101 + ], + "expectedCNORM": [ + 0, + 3e+100, + 3.0000000000000002e+100 + ], + "scale": 5e-201, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_no_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_no_trans_upper_col_major.json new file mode 100644 index 000000000000..d96b8c82e4ea --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_no_trans_upper_col_major.json @@ -0,0 +1,67 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 3e+100, + 2e+100, + 0, + 1, + 1e+100, + 0, + 0, + 1 + ], + "strideA1": -1, + "strideA2": -3, + "offsetA": 8, + "A_mat": [ + [ + 1, + 1e+100, + 2e+100 + ], + [ + 0, + 1, + 3e+100 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 1.6666666666666668e-101, + -0.5, + 5e+99 + ], + "expectedCNORM": [ + 5e+100, + 1e+100, + 0 + ], + "scale": 1.6666666666666668e-201, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_no_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_no_trans_upper_row_major.json new file mode 100644 index 000000000000..79263d579201 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_no_trans_upper_row_major.json @@ -0,0 +1,67 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 0, + 0, + 3e+100, + 1, + 0, + 2e+100, + 1e+100, + 1 + ], + "strideA1": -3, + "strideA2": -1, + "offsetA": 8, + "A_mat": [ + [ + 1, + 1e+100, + 2e+100 + ], + [ + 0, + 1, + 3e+100 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 1.6666666666666668e-101, + -0.5, + 5e+99 + ], + "expectedCNORM": [ + 5e+100, + 1e+100, + 0 + ], + "scale": 1.6666666666666668e-201, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_trans_lower_col_major.json new file mode 100644 index 000000000000..af9e94eb8a48 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_trans_lower_col_major.json @@ -0,0 +1,67 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 0, + 0, + 8e+100, + 1, + 0, + 7e+100, + 4e+100, + 1 + ], + "strideA1": -1, + "strideA2": -3, + "offsetA": 8, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 4e+100, + 1, + 0 + ], + [ + 7e+100, + 8e+100, + 1 + ] + ], + "X": [ + 3e+100, + 2e+100, + 1e+100 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 6.25e-102, + -0.5, + 2e+100 + ], + "expectedCNORM": [ + 0, + 8e+100, + 1.1e+101 + ], + "scale": 2.0833333333333334e-202, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_trans_lower_row_major.json new file mode 100644 index 000000000000..a7d879ca6dbd --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_trans_lower_row_major.json @@ -0,0 +1,67 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 8e+100, + 7e+100, + 0, + 1, + 4e+100, + 0, + 0, + 1 + ], + "strideA1": -3, + "strideA2": -1, + "offsetA": 8, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 4e+100, + 1, + 0 + ], + [ + 7e+100, + 8e+100, + 1 + ] + ], + "X": [ + 3e+100, + 2e+100, + 1e+100 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 6.25e-102, + -0.5, + 2e+100 + ], + "expectedCNORM": [ + 0, + 8e+100, + 1.1e+101 + ], + "scale": 2.0833333333333334e-202, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_trans_upper_col_major.json new file mode 100644 index 000000000000..114f47db36ff --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_trans_upper_col_major.json @@ -0,0 +1,67 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 5e+100, + 3e+100, + 0, + 1, + 2e+100, + 0, + 0, + 1 + ], + "strideA1": -1, + "strideA2": -3, + "offsetA": 8, + "A_mat": [ + [ + 1, + 2e+100, + 3e+100 + ], + [ + 0, + 1, + 5e+100 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 3e+100, + 2e+100, + 1e+100 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 2.5e+100, + -0.5, + 2.5e-101 + ], + "expectedCNORM": [ + 8e+100, + 2e+100, + 0 + ], + "scale": 2.5e-201, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_trans_upper_row_major.json new file mode 100644 index 000000000000..b1c5feedc16d --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/scaled_unit_trans_upper_row_major.json @@ -0,0 +1,67 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 0, + 0, + 5e+100, + 1, + 0, + 3e+100, + 2e+100, + 1 + ], + "strideA1": -3, + "strideA2": -1, + "offsetA": 8, + "A_mat": [ + [ + 1, + 2e+100, + 3e+100 + ], + [ + 0, + 1, + 5e+100 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 3e+100, + 2e+100, + 1e+100 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 2.5e+100, + -0.5, + 2.5e-101 + ], + "expectedCNORM": [ + 8e+100, + 2e+100, + 0 + ], + "scale": 2.5e-201, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_no_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_no_trans_lower_col_major.json new file mode 100644 index 000000000000..b6f48f353483 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_no_trans_lower_col_major.json @@ -0,0 +1,67 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 0, + 0, + -1, + 1, + 0, + 3, + 2, + 1 + ], + "strideA1": -1, + "strideA2": -3, + "offsetA": 8, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 2, + 1, + 0 + ], + [ + 3, + -1, + 1 + ] + ], + "X": [ + 3, + 3, + 1 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 1, + 1, + 1 + ], + "expectedCNORM": [ + 0, + 1, + 5 + ], + "scale": 1, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_no_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_no_trans_lower_row_major.json new file mode 100644 index 000000000000..23b2e1f0033e --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_no_trans_lower_row_major.json @@ -0,0 +1,67 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + -1, + 3, + 0, + 1, + 2, + 0, + 0, + 1 + ], + "strideA1": -3, + "strideA2": -1, + "offsetA": 8, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 2, + 1, + 0 + ], + [ + 3, + -1, + 1 + ] + ], + "X": [ + 3, + 3, + 1 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 1, + 1, + 1 + ], + "expectedCNORM": [ + 0, + 1, + 5 + ], + "scale": 1, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_no_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_no_trans_upper_col_major.json new file mode 100644 index 000000000000..342423403ff9 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_no_trans_upper_col_major.json @@ -0,0 +1,67 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 3, + -1, + 0, + 1, + 2, + 0, + 0, + 1 + ], + "strideA1": -1, + "strideA2": -3, + "offsetA": 8, + "A_mat": [ + [ + 1, + 2, + -1 + ], + [ + 0, + 1, + 3 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 1, + 4, + 2 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 1, + 1, + 1 + ], + "expectedCNORM": [ + 4, + 2, + 0 + ], + "scale": 1, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_no_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_no_trans_upper_row_major.json new file mode 100644 index 000000000000..da76554da8bc --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_no_trans_upper_row_major.json @@ -0,0 +1,67 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 0, + 0, + 3, + 1, + 0, + -1, + 2, + 1 + ], + "strideA1": -3, + "strideA2": -1, + "offsetA": 8, + "A_mat": [ + [ + 1, + 2, + -1 + ], + [ + 0, + 1, + 3 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 1, + 4, + 2 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 1, + 1, + 1 + ], + "expectedCNORM": [ + 4, + 2, + 0 + ], + "scale": 1, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_trans_lower_col_major.json new file mode 100644 index 000000000000..a7120725fcd8 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_trans_lower_col_major.json @@ -0,0 +1,67 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 0, + 0, + -1, + 1, + 0, + 2, + 4, + 1 + ], + "strideA1": -1, + "strideA2": -3, + "offsetA": 8, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 4, + 1, + 0 + ], + [ + 2, + -1, + 1 + ] + ], + "X": [ + 1, + 0, + 7 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 1, + 1, + 1 + ], + "expectedCNORM": [ + 0, + 1, + 6 + ], + "scale": 1, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_trans_lower_row_major.json new file mode 100644 index 000000000000..c4d132cc0865 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_trans_lower_row_major.json @@ -0,0 +1,67 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + -1, + 2, + 0, + 1, + 4, + 0, + 0, + 1 + ], + "strideA1": -3, + "strideA2": -1, + "offsetA": 8, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 4, + 1, + 0 + ], + [ + 2, + -1, + 1 + ] + ], + "X": [ + 1, + 0, + 7 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 1, + 1, + 1 + ], + "expectedCNORM": [ + 0, + 1, + 6 + ], + "scale": 1, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_trans_upper_col_major.json new file mode 100644 index 000000000000..220579719b63 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_trans_upper_col_major.json @@ -0,0 +1,67 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 4, + 3, + 0, + 1, + 2, + 0, + 0, + 1 + ], + "strideA1": -1, + "strideA2": -3, + "offsetA": 8, + "A_mat": [ + [ + 1, + 2, + 3 + ], + [ + 0, + 1, + 4 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 8, + 3, + 1 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 1, + 1, + 1 + ], + "expectedCNORM": [ + 7, + 2, + 0 + ], + "scale": 1, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_trans_upper_row_major.json new file mode 100644 index 000000000000..f8726a35103e --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/negative_strides/unit_trans_upper_row_major.json @@ -0,0 +1,67 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 1, + 0, + 0, + 4, + 1, + 0, + 3, + 2, + 1 + ], + "strideA1": -3, + "strideA2": -1, + "offsetA": 8, + "A_mat": [ + [ + 1, + 2, + 3 + ], + [ + 0, + 1, + 4 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 8, + 3, + 1 + ], + "strideX": -1, + "offsetX": 2, + "CNORM": [ + 0, + 0, + 0 + ], + "strideCNORM": -1, + "offsetCNORM": 2, + "expectedX": [ + 1, + 1, + 1 + ], + "expectedCNORM": [ + 7, + 2, + 0 + ], + "scale": 1, + "offsetExpectedX": 2, + "offsetExpectedCNORM": 2 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/large_off_diagonal_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/large_off_diagonal_col_major.json new file mode 100644 index 000000000000..346e0cf11fa5 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/large_off_diagonal_col_major.json @@ -0,0 +1,70 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1, + 0, + 0, + 1e+292, + 1, + 0, + 1e+292, + 1e+292, + 1 + ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 1, + "A_mat": [ + [ + 1, + 1e+292, + 1e+292 + ], + [ + 0, + 1, + 1e+292 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 9999, + 1, + 1, + 1 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 5e+291, + -0.5, + 4.9999999999999997e-293 + ], + "expectedCNORM": [ + 9999, + 0, + 1e+292, + 2e+292 + ], + "scale": 4.9999999999999997e-293 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/large_off_diagonal_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/large_off_diagonal_row_major.json new file mode 100644 index 000000000000..b5283f552ab0 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/large_off_diagonal_row_major.json @@ -0,0 +1,70 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1, + 1e+292, + 1e+292, + 0, + 1, + 1e+292, + 0, + 0, + 1 + ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 1, + "A_mat": [ + [ + 1, + 1e+292, + 1e+292 + ], + [ + 0, + 1, + 1e+292 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 9999, + 1, + 1, + 1 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 5e+291, + -0.5, + 4.9999999999999997e-293 + ], + "expectedCNORM": [ + 9999, + 0, + 1e+292, + 2e+292 + ], + "scale": 4.9999999999999997e-293 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_no_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_no_trans_lower_col_major.json new file mode 100644 index 000000000000..b7d6619eea1d --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_no_trans_lower_col_major.json @@ -0,0 +1,70 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 2, + 1, + -1, + 0, + 3, + 2, + 0, + 0, + 4 + ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 1, + "A_mat": [ + [ + 2, + 0, + 0 + ], + [ + 1, + 3, + 0 + ], + [ + -1, + 2, + 4 + ] + ], + "X": [ + 9999, + 5, + 10, + 20 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 2.5, + 2.5, + 4.375 + ], + "expectedCNORM": [ + 9999, + 2, + 2, + 0 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_no_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_no_trans_lower_row_major.json new file mode 100644 index 000000000000..bd03cee33e61 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_no_trans_lower_row_major.json @@ -0,0 +1,70 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 2, + 0, + 0, + 1, + 3, + 0, + -1, + 2, + 4 + ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 1, + "A_mat": [ + [ + 2, + 0, + 0 + ], + [ + 1, + 3, + 0 + ], + [ + -1, + 2, + 4 + ] + ], + "X": [ + 9999, + 5, + 10, + 20 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 2.5, + 2.5, + 4.375 + ], + "expectedCNORM": [ + 9999, + 2, + 2, + 0 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_no_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_no_trans_upper_col_major.json new file mode 100644 index 000000000000..9b088717cdf6 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_no_trans_upper_col_major.json @@ -0,0 +1,70 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 2, + 0, + 0, + 1, + 3, + 0, + -1, + 2, + 4 + ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 1, + "A_mat": [ + [ + 2, + 1, + -1 + ], + [ + 0, + 3, + 2 + ], + [ + 0, + 0, + 4 + ] + ], + "X": [ + 9999, + 5, + 10, + 20 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 5, + 0, + 5 + ], + "expectedCNORM": [ + 9999, + 0, + 1, + 3 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_no_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_no_trans_upper_row_major.json new file mode 100644 index 000000000000..96d43cf58dd5 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_no_trans_upper_row_major.json @@ -0,0 +1,70 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 2, + 1, + -1, + 0, + 3, + 2, + 0, + 0, + 4 + ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 1, + "A_mat": [ + [ + 2, + 1, + -1 + ], + [ + 0, + 3, + 2 + ], + [ + 0, + 0, + 4 + ] + ], + "X": [ + 9999, + 5, + 10, + 20 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 5, + 0, + 5 + ], + "expectedCNORM": [ + 9999, + 0, + 1, + 3 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_trans_lower_col_major.json new file mode 100644 index 000000000000..db79aa7d957b --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_trans_lower_col_major.json @@ -0,0 +1,70 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 2, + 1, + -1, + 0, + 3, + 2, + 0, + 0, + 4 + ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 1, + "A_mat": [ + [ + 2, + 0, + 0 + ], + [ + 1, + 3, + 0 + ], + [ + -1, + 2, + 4 + ] + ], + "X": [ + 9999, + 2, + 5, + 4 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 1, + 1, + 1 + ], + "expectedCNORM": [ + 9999, + 2, + 2, + 0 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_trans_lower_row_major.json new file mode 100644 index 000000000000..59b64f34e006 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_trans_lower_row_major.json @@ -0,0 +1,70 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 2, + 0, + 0, + 1, + 3, + 0, + -1, + 2, + 4 + ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 1, + "A_mat": [ + [ + 2, + 0, + 0 + ], + [ + 1, + 3, + 0 + ], + [ + -1, + 2, + 4 + ] + ], + "X": [ + 9999, + 2, + 5, + 4 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 1, + 1, + 1 + ], + "expectedCNORM": [ + 9999, + 2, + 2, + 0 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_trans_upper_col_major.json new file mode 100644 index 000000000000..25d919971657 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_trans_upper_col_major.json @@ -0,0 +1,70 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 2, + 1, + 0, + 1, + 3, + 0, + -1, + 2, + 4 + ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 1, + "A_mat": [ + [ + 2, + 1, + -1 + ], + [ + 1, + 3, + 2 + ], + [ + 0, + 0, + 4 + ] + ], + "X": [ + 9999, + 2, + 5, + 4 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 1, + 1.3333333333333333, + 0.5833333333333334 + ], + "expectedCNORM": [ + 9999, + 0, + 1, + 3 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_trans_upper_row_major.json new file mode 100644 index 000000000000..0ff9a5bc711f --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/non_unit_trans_upper_row_major.json @@ -0,0 +1,70 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 2, + 1, + -1, + 0, + 3, + 2, + 0, + 0, + 4 + ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 1, + "A_mat": [ + [ + 2, + 1, + -1 + ], + [ + 1, + 3, + 2 + ], + [ + 0, + 0, + 4 + ] + ], + "X": [ + 9999, + 2, + 5, + 4 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 1, + 1.3333333333333333, + 0.5833333333333334 + ], + "expectedCNORM": [ + 9999, + 0, + 1, + 3 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_no_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_no_trans_lower_col_major.json new file mode 100644 index 000000000000..886832c8a027 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_no_trans_lower_col_major.json @@ -0,0 +1,70 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1, + 2, + 3, + 0, + 0.1, + 4, + 0, + 0, + 0.01 + ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 1, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 2, + 0.1, + 0 + ], + [ + 3, + 4, + 0.01 + ] + ], + "X": [ + 9999, + 1e+308, + 1e+308, + 1e+308 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 0.5, + -5, + 1900 + ], + "expectedCNORM": [ + 9999, + 5, + 4, + 0 + ], + "scale": 5e-309 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_no_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_no_trans_lower_row_major.json new file mode 100644 index 000000000000..493b5a7e7b64 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_no_trans_lower_row_major.json @@ -0,0 +1,70 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1, + 0, + 0, + 2, + 0.1, + 0, + 3, + 4, + 0.01 + ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 1, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 2, + 0.1, + 0 + ], + [ + 3, + 4, + 0.01 + ] + ], + "X": [ + 9999, + 1e+308, + 1e+308, + 1e+308 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 0.5, + -5, + 1900 + ], + "expectedCNORM": [ + 9999, + 5, + 4, + 0 + ], + "scale": 5e-309 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_no_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_no_trans_upper_col_major.json new file mode 100644 index 000000000000..5985fde241b0 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_no_trans_upper_col_major.json @@ -0,0 +1,70 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1e-10, + 0, + 0, + 2, + 1e-20, + 0, + 3, + 4, + 1e-30 + ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 1, + "A_mat": [ + [ + 1e-10, + 2, + 3 + ], + [ + 0, + 1e-20, + 4 + ], + [ + 0, + 0, + 1e-30 + ] + ], + "X": [ + 9999, + 1e+300, + 2e+300, + 3e+300 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 7.999999999999998e+60, + -3.9999999999999995e+50, + 9.999999999999999e+29 + ], + "expectedCNORM": [ + 9999, + 0, + 2, + 7 + ], + "scale": 3.333333333333333e-301 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_no_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_no_trans_upper_row_major.json new file mode 100644 index 000000000000..e1ee9a1f091a --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_no_trans_upper_row_major.json @@ -0,0 +1,70 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1e-10, + 2, + 3, + 0, + 1e-20, + 4, + 0, + 0, + 1e-30 + ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 1, + "A_mat": [ + [ + 1e-10, + 2, + 3 + ], + [ + 0, + 1e-20, + 4 + ], + [ + 0, + 0, + 1e-30 + ] + ], + "X": [ + 9999, + 1e+300, + 2e+300, + 3e+300 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 7.999999999999998e+60, + -3.9999999999999995e+50, + 9.999999999999999e+29 + ], + "expectedCNORM": [ + 9999, + 0, + 2, + 7 + ], + "scale": 3.333333333333333e-301 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_trans_lower_col_major.json new file mode 100644 index 000000000000..caf6a81ea981 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_trans_lower_col_major.json @@ -0,0 +1,70 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1e-100, + 1, + 2, + 0, + 1e-120, + 3, + 0, + 0, + 1e-140 + ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 1, + "A_mat": [ + [ + 1e-100, + 0, + 0 + ], + [ + 1, + 1e-120, + 0 + ], + [ + 2, + 3, + 1e-140 + ] + ], + "X": [ + 9999, + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 1e+220, + -1e+120, + 0.3333333333333333 + ], + "expectedCNORM": [ + 9999, + 3, + 3, + 0 + ], + "scale": 1.1111111111111112e-241 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_trans_lower_row_major.json new file mode 100644 index 000000000000..890cc33b0082 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_trans_lower_row_major.json @@ -0,0 +1,70 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1e-100, + 0, + 0, + 1, + 1e-120, + 0, + 2, + 3, + 1e-140 + ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 1, + "A_mat": [ + [ + 1e-100, + 0, + 0 + ], + [ + 1, + 1e-120, + 0 + ], + [ + 2, + 3, + 1e-140 + ] + ], + "X": [ + 9999, + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 1e+220, + -1e+120, + 0.3333333333333333 + ], + "expectedCNORM": [ + 9999, + 3, + 3, + 0 + ], + "scale": 1.1111111111111112e-241 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_trans_upper_col_major.json new file mode 100644 index 000000000000..b001f2153a2c --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_trans_upper_col_major.json @@ -0,0 +1,70 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1e-100, + 0, + 0, + 5, + 1e-110, + 0, + 7, + 8, + 1e-120 + ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 1, + "A_mat": [ + [ + 1e-100, + 5, + 7 + ], + [ + 0, + 1e-110, + 8 + ], + [ + 0, + 0, + 1e-120 + ] + ], + "X": [ + 9999, + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 0.2, + -1e+110, + 8e+230 + ], + "expectedCNORM": [ + 9999, + 0, + 5, + 15 + ], + "scale": 2.0000000000000003e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_trans_upper_row_major.json new file mode 100644 index 000000000000..e393cb6b34fe --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_non_unit_trans_upper_row_major.json @@ -0,0 +1,70 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "transpose", + "diag": "non-unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1e-100, + 5, + 7, + 0, + 1e-110, + 8, + 0, + 0, + 1e-120 + ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 1, + "A_mat": [ + [ + 1e-100, + 5, + 7 + ], + [ + 0, + 1e-110, + 8 + ], + [ + 0, + 0, + 1e-120 + ] + ], + "X": [ + 9999, + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 0.2, + -1e+110, + 8e+230 + ], + "expectedCNORM": [ + 9999, + 0, + 5, + 15 + ], + "scale": 2.0000000000000003e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_no_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_no_trans_lower_col_major.json new file mode 100644 index 000000000000..dc19d85c263b --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_no_trans_lower_col_major.json @@ -0,0 +1,70 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1, + 1e+100, + 2e+100, + 0, + 1, + 3e+100, + 0, + 0, + 1 + ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 1, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 1e+100, + 1, + 0 + ], + [ + 2e+100, + 3e+100, + 1 + ] + ], + "X": [ + 9999, + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 5e-101, + -0.5, + 1.5e+100 + ], + "expectedCNORM": [ + 9999, + 3.0000000000000002e+100, + 3e+100, + 0 + ], + "scale": 5e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_no_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_no_trans_lower_row_major.json new file mode 100644 index 000000000000..74622fa19f73 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_no_trans_lower_row_major.json @@ -0,0 +1,70 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1, + 0, + 0, + 1e+100, + 1, + 0, + 2e+100, + 3e+100, + 1 + ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 1, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 1e+100, + 1, + 0 + ], + [ + 2e+100, + 3e+100, + 1 + ] + ], + "X": [ + 9999, + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 5e-101, + -0.5, + 1.5e+100 + ], + "expectedCNORM": [ + 9999, + 3.0000000000000002e+100, + 3e+100, + 0 + ], + "scale": 5e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_no_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_no_trans_upper_col_major.json new file mode 100644 index 000000000000..1e7e8571a22e --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_no_trans_upper_col_major.json @@ -0,0 +1,70 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1, + 0, + 0, + 1e+100, + 1, + 0, + 2e+100, + 3e+100, + 1 + ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 1, + "A_mat": [ + [ + 1, + 1e+100, + 2e+100 + ], + [ + 0, + 1, + 3e+100 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 9999, + 3e+100, + 2e+100, + 1e+100 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 5e+99, + -0.5, + 1.6666666666666668e-101 + ], + "expectedCNORM": [ + 9999, + 0, + 1e+100, + 5e+100 + ], + "scale": 1.6666666666666668e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_no_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_no_trans_upper_row_major.json new file mode 100644 index 000000000000..530214b5d3e6 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_no_trans_upper_row_major.json @@ -0,0 +1,70 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1, + 1e+100, + 2e+100, + 0, + 1, + 3e+100, + 0, + 0, + 1 + ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 1, + "A_mat": [ + [ + 1, + 1e+100, + 2e+100 + ], + [ + 0, + 1, + 3e+100 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 9999, + 3e+100, + 2e+100, + 1e+100 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 5e+99, + -0.5, + 1.6666666666666668e-101 + ], + "expectedCNORM": [ + 9999, + 0, + 1e+100, + 5e+100 + ], + "scale": 1.6666666666666668e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_trans_lower_col_major.json new file mode 100644 index 000000000000..3957675d20e9 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_trans_lower_col_major.json @@ -0,0 +1,70 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1, + 4e+100, + 7e+100, + 0, + 1, + 8e+100, + 0, + 0, + 1 + ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 1, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 4e+100, + 1, + 0 + ], + [ + 7e+100, + 8e+100, + 1 + ] + ], + "X": [ + 9999, + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 2e+100, + -0.5, + 6.25e-102 + ], + "expectedCNORM": [ + 9999, + 1.1e+101, + 8e+100, + 0 + ], + "scale": 2.0833333333333334e-202 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_trans_lower_row_major.json new file mode 100644 index 000000000000..327727281444 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_trans_lower_row_major.json @@ -0,0 +1,70 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1, + 0, + 0, + 4e+100, + 1, + 0, + 7e+100, + 8e+100, + 1 + ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 1, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 4e+100, + 1, + 0 + ], + [ + 7e+100, + 8e+100, + 1 + ] + ], + "X": [ + 9999, + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 2e+100, + -0.5, + 6.25e-102 + ], + "expectedCNORM": [ + 9999, + 1.1e+101, + 8e+100, + 0 + ], + "scale": 2.0833333333333334e-202 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_trans_upper_col_major.json new file mode 100644 index 000000000000..cf73b85990d2 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_trans_upper_col_major.json @@ -0,0 +1,70 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1, + 0, + 0, + 2e+100, + 1, + 0, + 3e+100, + 5e+100, + 1 + ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 1, + "A_mat": [ + [ + 1, + 2e+100, + 3e+100 + ], + [ + 0, + 1, + 5e+100 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 9999, + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 2.5e-101, + -0.5, + 2.5e+100 + ], + "expectedCNORM": [ + 9999, + 0, + 2e+100, + 8e+100 + ], + "scale": 2.5e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_trans_upper_row_major.json new file mode 100644 index 000000000000..ca905724a678 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/scaled_unit_trans_upper_row_major.json @@ -0,0 +1,70 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1, + 2e+100, + 3e+100, + 0, + 1, + 5e+100, + 0, + 0, + 1 + ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 1, + "A_mat": [ + [ + 1, + 2e+100, + 3e+100 + ], + [ + 0, + 1, + 5e+100 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 9999, + 1e+100, + 2e+100, + 3e+100 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 2.5e-101, + -0.5, + 2.5e+100 + ], + "expectedCNORM": [ + 9999, + 0, + 2e+100, + 8e+100 + ], + "scale": 2.5e-201 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_no_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_no_trans_lower_col_major.json new file mode 100644 index 000000000000..567c60d9ddaa --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_no_trans_lower_col_major.json @@ -0,0 +1,70 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1, + 2, + 3, + 0, + 1, + -1, + 0, + 0, + 1 + ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 1, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 2, + 1, + 0 + ], + [ + 3, + -1, + 1 + ] + ], + "X": [ + 9999, + 1, + 3, + 3 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 1, + 1, + 1 + ], + "expectedCNORM": [ + 9999, + 5, + 1, + 0 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_no_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_no_trans_lower_row_major.json new file mode 100644 index 000000000000..7b7be33e6a63 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_no_trans_lower_row_major.json @@ -0,0 +1,70 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1, + 0, + 0, + 2, + 1, + 0, + 3, + -1, + 1 + ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 1, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 2, + 1, + 0 + ], + [ + 3, + -1, + 1 + ] + ], + "X": [ + 9999, + 1, + 3, + 3 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 1, + 1, + 1 + ], + "expectedCNORM": [ + 9999, + 5, + 1, + 0 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_no_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_no_trans_upper_col_major.json new file mode 100644 index 000000000000..d1acd1f777f0 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_no_trans_upper_col_major.json @@ -0,0 +1,70 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1, + 0, + 0, + 2, + 1, + 0, + -1, + 3, + 1 + ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 1, + "A_mat": [ + [ + 1, + 2, + -1 + ], + [ + 0, + 1, + 3 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 9999, + 2, + 4, + 1 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 1, + 1, + 1 + ], + "expectedCNORM": [ + 9999, + 0, + 2, + 4 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_no_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_no_trans_upper_row_major.json new file mode 100644 index 000000000000..a3400e4a895a --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_no_trans_upper_row_major.json @@ -0,0 +1,70 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "no-transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1, + 2, + -1, + 0, + 1, + 3, + 0, + 0, + 1 + ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 1, + "A_mat": [ + [ + 1, + 2, + -1 + ], + [ + 0, + 1, + 3 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 9999, + 2, + 4, + 1 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 1, + 1, + 1 + ], + "expectedCNORM": [ + 9999, + 0, + 2, + 4 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_trans_lower_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_trans_lower_col_major.json new file mode 100644 index 000000000000..0e4857defbdb --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_trans_lower_col_major.json @@ -0,0 +1,70 @@ +{ + "order": "column-major", + "uplo": "lower", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1, + 4, + 2, + 0, + 1, + -1, + 0, + 0, + 1 + ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 1, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 4, + 1, + 0 + ], + [ + 2, + -1, + 1 + ] + ], + "X": [ + 9999, + 7, + 0, + 1 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 1, + 1, + 1 + ], + "expectedCNORM": [ + 9999, + 6, + 1, + 0 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_trans_lower_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_trans_lower_row_major.json new file mode 100644 index 000000000000..177308df8980 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_trans_lower_row_major.json @@ -0,0 +1,70 @@ +{ + "order": "row-major", + "uplo": "lower", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1, + 0, + 0, + 4, + 1, + 0, + 2, + -1, + 1 + ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 1, + "A_mat": [ + [ + 1, + 0, + 0 + ], + [ + 4, + 1, + 0 + ], + [ + 2, + -1, + 1 + ] + ], + "X": [ + 9999, + 7, + 0, + 1 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 1, + 1, + 1 + ], + "expectedCNORM": [ + 9999, + 6, + 1, + 0 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_trans_upper_col_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_trans_upper_col_major.json new file mode 100644 index 000000000000..7e85effdf432 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_trans_upper_col_major.json @@ -0,0 +1,70 @@ +{ + "order": "column-major", + "uplo": "upper", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1, + 0, + 0, + 2, + 1, + 0, + 3, + 4, + 1 + ], + "strideA1": 1, + "strideA2": 3, + "offsetA": 1, + "A_mat": [ + [ + 1, + 2, + 3 + ], + [ + 0, + 1, + 4 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 9999, + 1, + 3, + 8 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 1, + 1, + 1 + ], + "expectedCNORM": [ + 9999, + 0, + 2, + 7 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_trans_upper_row_major.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_trans_upper_row_major.json new file mode 100644 index 000000000000..fb05b7da173c --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/fixtures/offsets/unit_trans_upper_row_major.json @@ -0,0 +1,70 @@ +{ + "order": "row-major", + "uplo": "upper", + "trans": "transpose", + "diag": "unit", + "normin": "no", + "N": 3, + "LDA": 3, + "A": [ + 9999, + 1, + 2, + 3, + 0, + 1, + 4, + 0, + 0, + 1 + ], + "strideA1": 3, + "strideA2": 1, + "offsetA": 1, + "A_mat": [ + [ + 1, + 2, + 3 + ], + [ + 0, + 1, + 4 + ], + [ + 0, + 0, + 1 + ] + ], + "X": [ + 9999, + 1, + 3, + 8 + ], + "strideX": 1, + "offsetX": 1, + "CNORM": [ + 9999, + 0, + 0, + 0 + ], + "strideCNORM": 1, + "offsetCNORM": 1, + "expectedX": [ + 9999, + 1, + 1, + 1 + ], + "expectedCNORM": [ + 9999, + 0, + 2, + 7 + ], + "scale": 1 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.ndarray.js new file mode 100644 index 000000000000..805e776aa0f6 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.ndarray.js @@ -0,0 +1,1200 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +/* eslint-disable max-len, id-length */ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var Float64Array = require( '@stdlib/array/float64' ); +var dlatrs = require( './../lib/ndarray.js' ); + + +// FIXTURES // + +var NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/non_unit_no_trans_upper_row_major.json' ); +var NON_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/non_unit_no_trans_upper_col_major.json' ); +var NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/non_unit_no_trans_lower_row_major.json' ); +var NON_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/non_unit_no_trans_lower_col_major.json' ); + +var NON_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/non_unit_trans_lower_row_major.json' ); +var NON_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/non_unit_trans_lower_col_major.json' ); +var NON_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/non_unit_trans_upper_row_major.json' ); +var NON_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/non_unit_trans_upper_col_major.json' ); + +var UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/unit_no_trans_lower_row_major.json' ); +var UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/unit_no_trans_lower_col_major.json' ); +var UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/unit_no_trans_upper_row_major.json' ); +var UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/unit_no_trans_upper_col_major.json' ); + +var UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/unit_trans_lower_row_major.json' ); +var UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/unit_trans_lower_col_major.json' ); +var UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/unit_trans_upper_row_major.json' ); +var UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/unit_trans_upper_col_major.json' ); + +var SCALED_NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/scaled_non_unit_no_trans_lower_row_major.json' ); +var SCALED_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/scaled_non_unit_no_trans_lower_col_major.json' ); +var SCALED_NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/scaled_non_unit_no_trans_upper_row_major.json' ); +var SCALED_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/scaled_non_unit_no_trans_upper_col_major.json' ); + +var SCALED_NON_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/scaled_non_unit_trans_lower_row_major.json' ); +var SCALED_NON_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/scaled_non_unit_trans_lower_col_major.json' ); +var SCALED_NON_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/scaled_non_unit_trans_upper_row_major.json' ); +var SCALED_NON_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/scaled_non_unit_trans_upper_col_major.json' ); + +var SCALED_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/scaled_unit_no_trans_lower_row_major.json' ); +var SCALED_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/scaled_unit_no_trans_lower_col_major.json' ); +var SCALED_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/scaled_unit_no_trans_upper_row_major.json' ); +var SCALED_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/scaled_unit_no_trans_upper_col_major.json' ); + +var SCALED_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/scaled_unit_trans_lower_row_major.json' ); +var SCALED_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/scaled_unit_trans_lower_col_major.json' ); +var SCALED_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/scaled_unit_trans_upper_row_major.json' ); +var SCALED_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/scaled_unit_trans_upper_col_major.json' ); + +var LARGE_OFF_DIAGONAL_ELEMENTS_ROW_MAJOR = require( './fixtures/large_off_diagonal_row_major.json' ); +var LARGE_OFF_DIAGONAL_ELEMENTS_COL_MAJOR = require( './fixtures/large_off_diagonal_col_major.json' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof dlatrs, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 15', function test( t ) { + t.strictEqual( dlatrs.length, 15, 'returns expected value' ); + t.end(); +}); + +tape( 'the function throws an error if provided the first argument which is not a valid matrix triangle', function test( t ) { + var values; + var CNORM; + var data; + var A; + var X; + var i; + + data = NON_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + X = new Float64Array( data.X ); + CNORM = new Float64Array( data.CNORM ); + + values = [ + 'foo', + 'bar', + 'beep', + 'boop', + -5, + NaN, + true, + false, + null, + void 0, + [], + {}, + function noop() {} + ]; + + 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() { + dlatrs( value, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + }; + } +}); + +tape( 'the function throws an error if provided a second argument which is not a valid transpose operation', function test( t ) { + var values; + var CNORM; + var data; + var A; + var X; + var i; + + data = NON_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + X = new Float64Array( data.X ); + CNORM = new Float64Array( data.CNORM ); + + values = [ + 'foo', + 'bar', + 'beep', + 'boop', + -5, + NaN, + true, + false, + null, + void 0, + [], + {}, + function noop() {} + ]; + + 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() { + dlatrs( data.uplo, value, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + }; + } +}); + +tape( 'the function throws an error if provided a third argument which is not a valid diagonal type', function test( t ) { + var values; + var CNORM; + var data; + var A; + var X; + var i; + + data = NON_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + X = new Float64Array( data.X ); + CNORM = new Float64Array( data.CNORM ); + + values = [ + 'foo', + 'bar', + 'beep', + 'boop', + -5, + NaN, + true, + false, + null, + void 0, + [], + {}, + function noop() {} + ]; + + 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() { + dlatrs( data.uplo, data.trans, value, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + }; + } +}); + +tape( 'the function throws an error if provided a fourth argument which is not yes or no', function test( t ) { + var values; + var CNORM; + var data; + var A; + var X; + var i; + + data = NON_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + X = new Float64Array( data.X ); + CNORM = new Float64Array( data.CNORM ); + + values = [ + 'foo', + 'bar', + 'beep', + 'boop', + -5, + NaN, + true, + false, + null, + void 0, + [], + {}, + function noop() {} + ]; + + 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() { + dlatrs( data.uplo, data.trans, data.diag, value, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + }; + } +}); + +tape( 'the function returns the arrays unchanged for N = 0', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.CNORM ); + expectedX = new Float64Array( data.X ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, 0, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (no-transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (no-transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NON_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (no-transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (no-transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NON_UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NON_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NON_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NON_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NON_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (no-transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (no-transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (no-transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (no-transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (no-transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (no-transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (no-transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (no-transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_NON_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_NON_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_NON_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_NON_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (no-transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (no-transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (no-transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (no-transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (transpose) (unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = SCALED_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large off diagonal elements (row-major) (upper triangular) (no-transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_OFF_DIAGONAL_ELEMENTS_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large off diagonal elements (column-major) (upper triangular) (no-transpose) (non-unit)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_OFF_DIAGONAL_ELEMENTS_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); From 12322bb5a902334f3453ede81146225bcbdb04dc Mon Sep 17 00:00:00 2001 From: Athan Date: Fri, 13 Jun 2025 11:10:48 -0700 Subject: [PATCH 18/32] docs: fix typo Signed-off-by: Athan --- lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js index 532d5dfca28c..66f7fb309a08 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js @@ -108,7 +108,7 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X return 1.0; } - // Compute the 1 norm of each column excluting the diagonal elements + // Compute the 1 norm of each column excluding the diagonal elements if ( normin === 'no' ) { if ( uplo === 'upper' ) { // upper triangular ic = offsetCNORM; From c7f21b8bda3a9d81b6fa687c9f336d5f64ec81f1 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Fri, 13 Jun 2025 19:47:06 +0000 Subject: [PATCH 19/32] test: add offset tests --- .../lapack/base/dlatrs/test/test.ndarray.js | 1092 ++++++++++++++++- 1 file changed, 1091 insertions(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.ndarray.js index 805e776aa0f6..0dd5a34fd576 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.ndarray.js @@ -16,7 +16,7 @@ * limitations under the License. */ -/* eslint-disable max-len, id-length */ +/* eslint-disable max-len, id-length, max-lines */ 'use strict'; @@ -72,6 +72,178 @@ var SCALED_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/scaled_unit_trans_u var LARGE_OFF_DIAGONAL_ELEMENTS_ROW_MAJOR = require( './fixtures/large_off_diagonal_row_major.json' ); var LARGE_OFF_DIAGONAL_ELEMENTS_COL_MAJOR = require( './fixtures/large_off_diagonal_col_major.json' ); +var OFFSET_NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/offsets/non_unit_no_trans_upper_row_major.json' ); +var OFFSET_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/offsets/non_unit_no_trans_upper_col_major.json' ); +var OFFSET_NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/offsets/non_unit_no_trans_lower_row_major.json' ); +var OFFSET_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/offsets/non_unit_no_trans_lower_col_major.json' ); + +var OFFSET_NON_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/offsets/non_unit_trans_lower_row_major.json' ); +var OFFSET_NON_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/offsets/non_unit_trans_lower_col_major.json' ); +var OFFSET_NON_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/offsets/non_unit_trans_upper_row_major.json' ); +var OFFSET_NON_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/offsets/non_unit_trans_upper_col_major.json' ); + +var OFFSET_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/offsets/unit_no_trans_lower_row_major.json' ); +var OFFSET_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/offsets/unit_no_trans_lower_col_major.json' ); +var OFFSET_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/offsets/unit_no_trans_upper_row_major.json' ); +var OFFSET_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/offsets/unit_no_trans_upper_col_major.json' ); + +var OFFSET_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/offsets/unit_trans_lower_row_major.json' ); +var OFFSET_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/offsets/unit_trans_lower_col_major.json' ); +var OFFSET_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/offsets/unit_trans_upper_row_major.json' ); +var OFFSET_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/offsets/unit_trans_upper_col_major.json' ); + +var OFFSET_SCALED_NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/offsets/scaled_non_unit_no_trans_lower_row_major.json' ); +var OFFSET_SCALED_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/offsets/scaled_non_unit_no_trans_lower_col_major.json' ); +var OFFSET_SCALED_NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/offsets/scaled_non_unit_no_trans_upper_row_major.json' ); +var OFFSET_SCALED_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/offsets/scaled_non_unit_no_trans_upper_col_major.json' ); + +var OFFSET_SCALED_NON_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/offsets/scaled_non_unit_trans_lower_row_major.json' ); +var OFFSET_SCALED_NON_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/offsets/scaled_non_unit_trans_lower_col_major.json' ); +var OFFSET_SCALED_NON_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/offsets/scaled_non_unit_trans_upper_row_major.json' ); +var OFFSET_SCALED_NON_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/offsets/scaled_non_unit_trans_upper_col_major.json' ); + +var OFFSET_SCALED_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/offsets/scaled_unit_no_trans_lower_row_major.json' ); +var OFFSET_SCALED_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/offsets/scaled_unit_no_trans_lower_col_major.json' ); +var OFFSET_SCALED_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/offsets/scaled_unit_no_trans_upper_row_major.json' ); +var OFFSET_SCALED_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/offsets/scaled_unit_no_trans_upper_col_major.json' ); + +var OFFSET_SCALED_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/offsets/scaled_unit_trans_lower_row_major.json' ); +var OFFSET_SCALED_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/offsets/scaled_unit_trans_lower_col_major.json' ); +var OFFSET_SCALED_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/offsets/scaled_unit_trans_upper_row_major.json' ); +var OFFSET_SCALED_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/offsets/scaled_unit_trans_upper_col_major.json' ); + +var OFFSET_LARGE_OFF_DIAGONAL_ELEMENTS_ROW_MAJOR = require( './fixtures/offsets/large_off_diagonal_row_major.json' ); +var OFFSET_LARGE_OFF_DIAGONAL_ELEMENTS_COL_MAJOR = require( './fixtures/offsets/large_off_diagonal_col_major.json' ); + +var LARGE_STRIDES_NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/large_strides/non_unit_no_trans_upper_row_major.json' ); +var LARGE_STRIDES_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/large_strides/non_unit_no_trans_upper_col_major.json' ); +var LARGE_STRIDES_NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/large_strides/non_unit_no_trans_lower_row_major.json' ); +var LARGE_STRIDES_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/large_strides/non_unit_no_trans_lower_col_major.json' ); + +var LARGE_STRIDES_NON_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/large_strides/non_unit_trans_lower_row_major.json' ); +var LARGE_STRIDES_NON_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/large_strides/non_unit_trans_lower_col_major.json' ); +var LARGE_STRIDES_NON_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/large_strides/non_unit_trans_upper_row_major.json' ); +var LARGE_STRIDES_NON_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/large_strides/non_unit_trans_upper_col_major.json' ); + +var LARGE_STRIDES_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/large_strides/unit_no_trans_lower_row_major.json' ); +var LARGE_STRIDES_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/large_strides/unit_no_trans_lower_col_major.json' ); +var LARGE_STRIDES_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/large_strides/unit_no_trans_upper_row_major.json' ); +var LARGE_STRIDES_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/large_strides/unit_no_trans_upper_col_major.json' ); + +var LARGE_STRIDES_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/large_strides/unit_trans_lower_row_major.json' ); +var LARGE_STRIDES_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/large_strides/unit_trans_lower_col_major.json' ); +var LARGE_STRIDES_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/large_strides/unit_trans_upper_row_major.json' ); +var LARGE_STRIDES_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/large_strides/unit_trans_upper_col_major.json' ); + +var LARGE_STRIDES_SCALED_NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/large_strides/scaled_non_unit_no_trans_lower_row_major.json' ); +var LARGE_STRIDES_SCALED_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/large_strides/scaled_non_unit_no_trans_lower_col_major.json' ); +var LARGE_STRIDES_SCALED_NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/large_strides/scaled_non_unit_no_trans_upper_row_major.json' ); +var LARGE_STRIDES_SCALED_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/large_strides/scaled_non_unit_no_trans_upper_col_major.json' ); + +var LARGE_STRIDES_SCALED_NON_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/large_strides/scaled_non_unit_trans_lower_row_major.json' ); +var LARGE_STRIDES_SCALED_NON_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/large_strides/scaled_non_unit_trans_lower_col_major.json' ); +var LARGE_STRIDES_SCALED_NON_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/large_strides/scaled_non_unit_trans_upper_row_major.json' ); +var LARGE_STRIDES_SCALED_NON_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/large_strides/scaled_non_unit_trans_upper_col_major.json' ); + +var LARGE_STRIDES_SCALED_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/large_strides/scaled_unit_no_trans_lower_row_major.json' ); +var LARGE_STRIDES_SCALED_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/large_strides/scaled_unit_no_trans_lower_col_major.json' ); +var LARGE_STRIDES_SCALED_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/large_strides/scaled_unit_no_trans_upper_row_major.json' ); +var LARGE_STRIDES_SCALED_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/large_strides/scaled_unit_no_trans_upper_col_major.json' ); + +var LARGE_STRIDES_SCALED_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/large_strides/scaled_unit_trans_lower_row_major.json' ); +var LARGE_STRIDES_SCALED_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/large_strides/scaled_unit_trans_lower_col_major.json' ); +var LARGE_STRIDES_SCALED_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/large_strides/scaled_unit_trans_upper_row_major.json' ); +var LARGE_STRIDES_SCALED_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/large_strides/scaled_unit_trans_upper_col_major.json' ); + +var LARGE_STRIDES_LARGE_OFF_DIAGONAL_ELEMENTS_ROW_MAJOR = require( './fixtures/large_strides/large_off_diagonal_row_major.json' ); +var LARGE_STRIDES_LARGE_OFF_DIAGONAL_ELEMENTS_COL_MAJOR = require( './fixtures/large_strides/large_off_diagonal_col_major.json' ); + +var NEGATIVE_STRIDES_NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/negative_strides/non_unit_no_trans_upper_row_major.json' ); +var NEGATIVE_STRIDES_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/negative_strides/non_unit_no_trans_upper_col_major.json' ); +var NEGATIVE_STRIDES_NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/negative_strides/non_unit_no_trans_lower_row_major.json' ); +var NEGATIVE_STRIDES_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/negative_strides/non_unit_no_trans_lower_col_major.json' ); + +var NEGATIVE_STRIDES_NON_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/negative_strides/non_unit_trans_lower_row_major.json' ); +var NEGATIVE_STRIDES_NON_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/negative_strides/non_unit_trans_lower_col_major.json' ); +var NEGATIVE_STRIDES_NON_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/negative_strides/non_unit_trans_upper_row_major.json' ); +var NEGATIVE_STRIDES_NON_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/negative_strides/non_unit_trans_upper_col_major.json' ); + +var NEGATIVE_STRIDES_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/negative_strides/unit_no_trans_lower_row_major.json' ); +var NEGATIVE_STRIDES_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/negative_strides/unit_no_trans_lower_col_major.json' ); +var NEGATIVE_STRIDES_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/negative_strides/unit_no_trans_upper_row_major.json' ); +var NEGATIVE_STRIDES_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/negative_strides/unit_no_trans_upper_col_major.json' ); + +var NEGATIVE_STRIDES_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/negative_strides/unit_trans_lower_row_major.json' ); +var NEGATIVE_STRIDES_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/negative_strides/unit_trans_lower_col_major.json' ); +var NEGATIVE_STRIDES_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/negative_strides/unit_trans_upper_row_major.json' ); +var NEGATIVE_STRIDES_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/negative_strides/unit_trans_upper_col_major.json' ); + +var NEGATIVE_STRIDES_SCALED_NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/negative_strides/scaled_non_unit_no_trans_lower_row_major.json' ); +var NEGATIVE_STRIDES_SCALED_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/negative_strides/scaled_non_unit_no_trans_lower_col_major.json' ); +var NEGATIVE_STRIDES_SCALED_NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/negative_strides/scaled_non_unit_no_trans_upper_row_major.json' ); +var NEGATIVE_STRIDES_SCALED_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/negative_strides/scaled_non_unit_no_trans_upper_col_major.json' ); + +var NEGATIVE_STRIDES_SCALED_NON_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/negative_strides/scaled_non_unit_trans_lower_row_major.json' ); +var NEGATIVE_STRIDES_SCALED_NON_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/negative_strides/scaled_non_unit_trans_lower_col_major.json' ); +var NEGATIVE_STRIDES_SCALED_NON_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/negative_strides/scaled_non_unit_trans_upper_row_major.json' ); +var NEGATIVE_STRIDES_SCALED_NON_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/negative_strides/scaled_non_unit_trans_upper_col_major.json' ); + +var NEGATIVE_STRIDES_SCALED_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/negative_strides/scaled_unit_no_trans_lower_row_major.json' ); +var NEGATIVE_STRIDES_SCALED_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/negative_strides/scaled_unit_no_trans_lower_col_major.json' ); +var NEGATIVE_STRIDES_SCALED_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/negative_strides/scaled_unit_no_trans_upper_row_major.json' ); +var NEGATIVE_STRIDES_SCALED_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/negative_strides/scaled_unit_no_trans_upper_col_major.json' ); + +var NEGATIVE_STRIDES_SCALED_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/negative_strides/scaled_unit_trans_lower_row_major.json' ); +var NEGATIVE_STRIDES_SCALED_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/negative_strides/scaled_unit_trans_lower_col_major.json' ); +var NEGATIVE_STRIDES_SCALED_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/negative_strides/scaled_unit_trans_upper_row_major.json' ); +var NEGATIVE_STRIDES_SCALED_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/negative_strides/scaled_unit_trans_upper_col_major.json' ); + +var NEGATIVE_STRIDES_LARGE_OFF_DIAGONAL_ELEMENTS_ROW_MAJOR = require( './fixtures/negative_strides/large_off_diagonal_row_major.json' ); +var NEGATIVE_STRIDES_LARGE_OFF_DIAGONAL_ELEMENTS_COL_MAJOR = require( './fixtures/negative_strides/large_off_diagonal_col_major.json' ); + +var MIXED_STRIDES_NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/mixed_strides/non_unit_no_trans_upper_row_major.json' ); +var MIXED_STRIDES_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/mixed_strides/non_unit_no_trans_upper_col_major.json' ); +var MIXED_STRIDES_NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/mixed_strides/non_unit_no_trans_lower_row_major.json' ); +var MIXED_STRIDES_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/mixed_strides/non_unit_no_trans_lower_col_major.json' ); + +var MIXED_STRIDES_NON_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/mixed_strides/non_unit_trans_lower_row_major.json' ); +var MIXED_STRIDES_NON_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/mixed_strides/non_unit_trans_lower_col_major.json' ); +var MIXED_STRIDES_NON_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/mixed_strides/non_unit_trans_upper_row_major.json' ); +var MIXED_STRIDES_NON_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/mixed_strides/non_unit_trans_upper_col_major.json' ); + +var MIXED_STRIDES_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/mixed_strides/unit_no_trans_lower_row_major.json' ); +var MIXED_STRIDES_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/mixed_strides/unit_no_trans_lower_col_major.json' ); +var MIXED_STRIDES_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/mixed_strides/unit_no_trans_upper_row_major.json' ); +var MIXED_STRIDES_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/mixed_strides/unit_no_trans_upper_col_major.json' ); + +var MIXED_STRIDES_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/mixed_strides/unit_trans_lower_row_major.json' ); +var MIXED_STRIDES_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/mixed_strides/unit_trans_lower_col_major.json' ); +var MIXED_STRIDES_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/mixed_strides/unit_trans_upper_row_major.json' ); +var MIXED_STRIDES_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/mixed_strides/unit_trans_upper_col_major.json' ); + +var MIXED_STRIDES_SCALED_NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/mixed_strides/scaled_non_unit_no_trans_lower_row_major.json' ); +var MIXED_STRIDES_SCALED_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/mixed_strides/scaled_non_unit_no_trans_lower_col_major.json' ); +var MIXED_STRIDES_SCALED_NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/mixed_strides/scaled_non_unit_no_trans_upper_row_major.json' ); +var MIXED_STRIDES_SCALED_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/mixed_strides/scaled_non_unit_no_trans_upper_col_major.json' ); + +var MIXED_STRIDES_SCALED_NON_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/mixed_strides/scaled_non_unit_trans_lower_row_major.json' ); +var MIXED_STRIDES_SCALED_NON_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/mixed_strides/scaled_non_unit_trans_lower_col_major.json' ); +var MIXED_STRIDES_SCALED_NON_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/mixed_strides/scaled_non_unit_trans_upper_row_major.json' ); +var MIXED_STRIDES_SCALED_NON_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/mixed_strides/scaled_non_unit_trans_upper_col_major.json' ); + +var MIXED_STRIDES_SCALED_UNIT_NO_TRANS_LOWER_ROW_MAJOR = require( './fixtures/mixed_strides/scaled_unit_no_trans_lower_row_major.json' ); +var MIXED_STRIDES_SCALED_UNIT_NO_TRANS_LOWER_COL_MAJOR = require( './fixtures/mixed_strides/scaled_unit_no_trans_lower_col_major.json' ); +var MIXED_STRIDES_SCALED_UNIT_NO_TRANS_UPPER_ROW_MAJOR = require( './fixtures/mixed_strides/scaled_unit_no_trans_upper_row_major.json' ); +var MIXED_STRIDES_SCALED_UNIT_NO_TRANS_UPPER_COL_MAJOR = require( './fixtures/mixed_strides/scaled_unit_no_trans_upper_col_major.json' ); + +var MIXED_STRIDES_SCALED_UNIT_TRANS_LOWER_ROW_MAJOR = require( './fixtures/mixed_strides/scaled_unit_trans_lower_row_major.json' ); +var MIXED_STRIDES_SCALED_UNIT_TRANS_LOWER_COL_MAJOR = require( './fixtures/mixed_strides/scaled_unit_trans_lower_col_major.json' ); +var MIXED_STRIDES_SCALED_UNIT_TRANS_UPPER_ROW_MAJOR = require( './fixtures/mixed_strides/scaled_unit_trans_upper_row_major.json' ); +var MIXED_STRIDES_SCALED_UNIT_TRANS_UPPER_COL_MAJOR = require( './fixtures/mixed_strides/scaled_unit_trans_upper_col_major.json' ); + +var MIXED_STRIDES_LARGE_OFF_DIAGONAL_ELEMENTS_ROW_MAJOR = require( './fixtures/mixed_strides/large_off_diagonal_row_major.json' ); +var MIXED_STRIDES_LARGE_OFF_DIAGONAL_ELEMENTS_COL_MAJOR = require( './fixtures/mixed_strides/large_off_diagonal_col_major.json' ); + // TESTS // @@ -1198,3 +1370,921 @@ tape( 'the function returns expected output for large off diagonal elements (col t.end(); }); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (no-transpose) (non-unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (no-transpose) (non-unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (no-transpose) (non-unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (no-transpose) (non-unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (transpose) (non-unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_NON_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (transpose) (non-unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_NON_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (transpose) (non-unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_NON_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (transpose) (non-unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_NON_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (no-transpose) (unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (no-transpose) (unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (no-transpose) (unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (no-transpose) (unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (transpose) (unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (transpose) (unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (transpose) (unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (transpose) (unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (no-transpose) (non-unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_SCALED_NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (no-transpose) (non-unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_SCALED_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (no-transpose) (non-unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_SCALED_NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (no-transpose) (non-unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_SCALED_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (transpose) (non-unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_SCALED_NON_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (transpose) (non-unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_SCALED_NON_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (transpose) (non-unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_SCALED_NON_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (transpose) (non-unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_SCALED_NON_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (no-transpose) (unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_SCALED_UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (no-transpose) (unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_SCALED_UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (no-transpose) (unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_SCALED_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (no-transpose) (unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_SCALED_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (transpose) (unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_SCALED_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (transpose) (unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_SCALED_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (transpose) (unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_SCALED_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (transpose) (unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_SCALED_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large off diagonal elements (row-major) (upper triangular) (no-transpose) (non-unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_LARGE_OFF_DIAGONAL_ELEMENTS_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large off diagonal elements (column-major) (upper triangular) (no-transpose) (non-unit) (offsets)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = OFFSET_LARGE_OFF_DIAGONAL_ELEMENTS_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); From 475a274c7f15b44e61c32ae25613efee1dbc9ab1 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Fri, 13 Jun 2025 19:58:28 +0000 Subject: [PATCH 20/32] test: add negative stride test --- .../lapack/base/dlatrs/test/test.ndarray.js | 918 ++++++++++++++++++ 1 file changed, 918 insertions(+) diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.ndarray.js index 0dd5a34fd576..5b345c8814f2 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.ndarray.js @@ -2288,3 +2288,921 @@ tape( 'the function returns expected output for large off diagonal elements (col t.end(); }); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (no-transpose) (non-unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (no-transpose) (non-unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (no-transpose) (non-unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (no-transpose) (non-unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (transpose) (non-unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_NON_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (transpose) (non-unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_NON_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (transpose) (non-unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_NON_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (transpose) (non-unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_NON_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (no-transpose) (unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (no-transpose) (unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (no-transpose) (unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (no-transpose) (unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (transpose) (unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (transpose) (unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (transpose) (unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (transpose) (unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (no-transpose) (non-unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_SCALED_NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (no-transpose) (non-unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_SCALED_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (no-transpose) (non-unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_SCALED_NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (no-transpose) (non-unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_SCALED_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (transpose) (non-unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_SCALED_NON_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (transpose) (non-unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_SCALED_NON_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (transpose) (non-unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_SCALED_NON_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (transpose) (non-unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_SCALED_NON_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (no-transpose) (unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_SCALED_UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (no-transpose) (unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_SCALED_UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (no-transpose) (unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_SCALED_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (no-transpose) (unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_SCALED_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (transpose) (unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_SCALED_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (transpose) (unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_SCALED_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (transpose) (unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_SCALED_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (transpose) (unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_SCALED_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large off diagonal elements (row-major) (upper triangular) (no-transpose) (non-unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_LARGE_OFF_DIAGONAL_ELEMENTS_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large off diagonal elements (column-major) (upper triangular) (no-transpose) (non-unit) (negative strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = NEGATIVE_STRIDES_LARGE_OFF_DIAGONAL_ELEMENTS_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); From d1597852b273416cbe708b6ebcda1263b8537603 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Fri, 13 Jun 2025 20:09:30 +0000 Subject: [PATCH 21/32] test: add large stride tests --- .../lapack/base/dlatrs/test/test.ndarray.js | 920 ++++++++++++++++++ 1 file changed, 920 insertions(+) diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.ndarray.js index 5b345c8814f2..0abcade5e0ac 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.ndarray.js @@ -3206,3 +3206,923 @@ tape( 'the function returns expected output for large off diagonal elements (col t.end(); }); + + + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (no-transpose) (non-unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (no-transpose) (non-unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (no-transpose) (non-unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (no-transpose) (non-unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (transpose) (non-unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_NON_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (transpose) (non-unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_NON_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (transpose) (non-unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_NON_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (transpose) (non-unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_NON_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (no-transpose) (unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (no-transpose) (unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (no-transpose) (unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (no-transpose) (unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (transpose) (unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (transpose) (unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (transpose) (unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (transpose) (unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (no-transpose) (non-unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_SCALED_NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (no-transpose) (non-unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_SCALED_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (no-transpose) (non-unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_SCALED_NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (no-transpose) (non-unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_SCALED_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (transpose) (non-unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_SCALED_NON_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (transpose) (non-unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_SCALED_NON_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (transpose) (non-unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_SCALED_NON_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (transpose) (non-unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_SCALED_NON_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (no-transpose) (unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_SCALED_UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (no-transpose) (unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_SCALED_UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (no-transpose) (unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_SCALED_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (no-transpose) (unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_SCALED_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (transpose) (unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_SCALED_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (transpose) (unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_SCALED_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (transpose) (unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_SCALED_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (transpose) (unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_SCALED_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large off diagonal elements (row-major) (upper triangular) (no-transpose) (non-unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_LARGE_OFF_DIAGONAL_ELEMENTS_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large off diagonal elements (column-major) (upper triangular) (no-transpose) (non-unit) (large strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = LARGE_STRIDES_LARGE_OFF_DIAGONAL_ELEMENTS_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); From 6dbee4cec75d165016b4a5cb0d882f11ad1b0cce Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Fri, 13 Jun 2025 20:20:14 +0000 Subject: [PATCH 22/32] test: add mixed strides 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/dlatrs/test/test.ndarray.js | 920 +++++++++++++++++- 1 file changed, 918 insertions(+), 2 deletions(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.ndarray.js index 0abcade5e0ac..3b1c1411a863 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.ndarray.js @@ -3207,8 +3207,6 @@ tape( 'the function returns expected output for large off diagonal elements (col t.end(); }); - - tape( 'the function returns expected output for normal values (row-major) (upper triangular) (no-transpose) (non-unit) (large strides)', function test( t ) { var expectedCNORM; var expectedX; @@ -4126,3 +4124,921 @@ tape( 'the function returns expected output for large off diagonal elements (col t.end(); }); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (no-transpose) (non-unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (no-transpose) (non-unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (no-transpose) (non-unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (no-transpose) (non-unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (transpose) (non-unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_NON_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (transpose) (non-unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_NON_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (transpose) (non-unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_NON_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (transpose) (non-unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_NON_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (no-transpose) (unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (no-transpose) (unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (no-transpose) (unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (no-transpose) (unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (lower triangular) (transpose) (unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (lower triangular) (transpose) (unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (row-major) (upper triangular) (transpose) (unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for normal values (column-major) (upper triangular) (transpose) (unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (no-transpose) (non-unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_SCALED_NON_UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (no-transpose) (non-unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_SCALED_NON_UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (no-transpose) (non-unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_SCALED_NON_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (no-transpose) (non-unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_SCALED_NON_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (transpose) (non-unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_SCALED_NON_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (transpose) (non-unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_SCALED_NON_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (transpose) (non-unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_SCALED_NON_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (transpose) (non-unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_SCALED_NON_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (no-transpose) (unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_SCALED_UNIT_NO_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (no-transpose) (unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_SCALED_UNIT_NO_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (no-transpose) (unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_SCALED_UNIT_NO_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (no-transpose) (unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_SCALED_UNIT_NO_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (lower triangular) (transpose) (unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_SCALED_UNIT_TRANS_LOWER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (lower triangular) (transpose) (unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_SCALED_UNIT_TRANS_LOWER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (row-major) (upper triangular) (transpose) (unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_SCALED_UNIT_TRANS_UPPER_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large values (column-major) (upper triangular) (transpose) (unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_SCALED_UNIT_TRANS_UPPER_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large off diagonal elements (row-major) (upper triangular) (no-transpose) (non-unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_LARGE_OFF_DIAGONAL_ELEMENTS_ROW_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns expected output for large off diagonal elements (column-major) (upper triangular) (no-transpose) (non-unit) (mixed strides)', function test( t ) { + var expectedCNORM; + var expectedX; + var scale; + var CNORM; + var data; + var A; + var X; + + data = MIXED_STRIDES_LARGE_OFF_DIAGONAL_ELEMENTS_COL_MAJOR; + + A = new Float64Array( data.A ); + CNORM = new Float64Array( data.CNORM ); + X = new Float64Array( data.X ); + + expectedCNORM = new Float64Array( data.expectedCNORM ); + expectedX = new Float64Array( data.expectedX ); + + scale = dlatrs( data.uplo, data.trans, data.diag, data.normin, data.N, A, data.strideA1, data.strideA2, data.offsetA, X, data.strideX, data.offsetX, CNORM, data.strideCNORM, data.offsetCNORM ); + + t.strictEqual( scale, data.scale, 'returns expected value' ); + t.deepEqual( X, expectedX, 'returns expected value' ); + t.deepEqual( CNORM, expectedCNORM, 'returns expected value' ); + + t.end(); +}); From 8147ab4a157f41c5fbef3e38c17072e4e2e9d6be Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Sun, 15 Jun 2025 18:06:19 +0000 Subject: [PATCH 23/32] feat: add examples and benchmarks --- 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: passed - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: passed - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: passed - 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/dlatrs/benchmark/benchmark.js | 141 ++++++++++++++++ .../dlatrs/benchmark/benchmark.ndarray.js | 151 ++++++++++++++++++ .../lapack/base/dlatrs/examples/index.js | 49 ++++++ .../@stdlib/lapack/base/dlatrs/package.json | 72 +++++++++ 4 files changed, 413 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/benchmark/benchmark.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/benchmark/benchmark.ndarray.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/examples/index.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/package.json diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/benchmark/benchmark.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/benchmark/benchmark.js new file mode 100644 index 000000000000..b3ecacc8ba95 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/benchmark/benchmark.js @@ -0,0 +1,141 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var bench = require( '@stdlib/bench' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var Float64Array = require( '@stdlib/array/float64' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var floor = require( '@stdlib/math/base/special/floor' ); +var pkg = require( './../package.json' ).name; +var dlatrs = require( './../lib/dlatrs.js' ); + + +// VARIABLES // + +var LAYOUTS = [ + 'row-major', + 'column-major' +]; +var MATRIX_TRIANGLES = [ + 'upper', + 'lower' +]; +var TRANSPOSE_OPS = [ + 'transpose', + 'no-transpose' +]; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {string} order - storage layout +* @param {PositiveInteger} N - number of elements along each dimension +* @param {string} uplo - specifies whether `A` is an upper or lower triangular matrix +* @param {string} trans - specifies whether `A` should be transposed or not transposed +* @returns {Function} benchmark function +*/ +function createBenchmark( order, N, uplo, trans ) { + var CNORM; + var X; + var A; + + A = uniform( N*N, 2.0, 10.0, { + 'dtype': 'float64' + }); + X = uniform( N, 1.0, 10.0, { + 'dtype': 'float64' + }); + CNORM = new Float64Array( N ); + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var z; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + z = dlatrs( order, uplo, trans, 'non-unit', 'no', N, A, N, X, CNORM ); + if ( isnan( z ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( z ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); + } +} + + +// MAIN // + +/** +* Main execution sequence. +* +* @private +*/ +function main() { + var trans; + var uplo; + var min; + var max; + var ord; + var N; + var f; + var i; + var j; + var k; + var l; + + min = 1; // 10^min + max = 6; // 10^max + + for ( k = 0; k < LAYOUTS.length; k++ ) { + ord = LAYOUTS[ k ]; + for ( i = min; i <= max; i++ ) { + N = floor( pow( pow( 10, i ), 1.0/2.0 ) ); + for ( j = 0; j < MATRIX_TRIANGLES.length; j++ ) { + uplo = MATRIX_TRIANGLES[ j ]; + for ( l = 0; l < TRANSPOSE_OPS.length; l++ ) { + trans = TRANSPOSE_OPS[ l ]; + f = createBenchmark( ord, N, uplo, trans ); + bench( pkg+'::square_matrix:order='+ord+',uplo='+uplo+',trans='+trans+',size='+(N*N), f ); + } + } + } + } +} + +main(); diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/benchmark/benchmark.ndarray.js new file mode 100644 index 000000000000..576cab4474a9 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/benchmark/benchmark.ndarray.js @@ -0,0 +1,151 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var bench = require( '@stdlib/bench' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var Float64Array = require( '@stdlib/array/float64' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var isColumnMajor = require( '@stdlib/ndarray/base/assert/is-column-major-string' ); +var floor = require( '@stdlib/math/base/special/floor' ); +var pkg = require( './../package.json' ).name; +var dlatrs = require( './../lib/ndarray.js' ); + + +// VARIABLES // + +var LAYOUTS = [ + 'row-major', + 'column-major' +]; +var MATRIX_TRIANGLES = [ + 'upper', + 'lower' +]; +var TRANSPOSE_OPS = [ + 'transpose', + 'no-transpose' +]; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {string} order - storage layout +* @param {PositiveInteger} N - number of elements along each dimension +* @param {string} uplo - specifies whether `A` is an upper or lower triangular matrix +* @param {string} trans - specifies whether `A` should be transposed or not transposed +* @returns {Function} benchmark function +*/ +function createBenchmark( order, N, uplo, trans ) { + var CNORM; + var sa1; + var sa2; + var X; + var A; + + A = uniform( N*N, 2.0, 10.0, { + 'dtype': 'float64' + }); + X = uniform( N, 1.0, 10.0, { + 'dtype': 'float64' + }); + if ( isColumnMajor( order ) ) { + sa1 = 1; + sa2 = N; + } else { // order === 'row-major' + sa1 = N; + sa2 = 1; + } + CNORM = new Float64Array( N ); + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var z; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + z = dlatrs( uplo, trans, 'non-unit', 'no', N, A, sa1, sa2, 0, X, 1, 0, CNORM, 1, 0 ); + if ( isnan( z ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( z ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); + } +} + + +// MAIN // + +/** +* Main execution sequence. +* +* @private +*/ +function main() { + var trans; + var uplo; + var min; + var max; + var ord; + var N; + var f; + var i; + var j; + var k; + var l; + + min = 1; // 10^min + max = 6; // 10^max + + for ( k = 0; k < LAYOUTS.length; k++ ) { + ord = LAYOUTS[ k ]; + for ( i = min; i <= max; i++ ) { + N = floor( pow( pow( 10, i ), 1.0/2.0 ) ); + for ( j = 0; j < MATRIX_TRIANGLES.length; j++ ) { + uplo = MATRIX_TRIANGLES[ j ]; + for ( l = 0; l < TRANSPOSE_OPS.length; l++ ) { + trans = TRANSPOSE_OPS[ l ]; + f = createBenchmark( ord, N, uplo, trans ); + bench( pkg+'::square_matrix:order='+ord+',uplo='+uplo+',trans='+trans+',size='+(N*N), f ); + } + } + } + } +} + +main(); diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/examples/index.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/examples/index.js new file mode 100644 index 000000000000..c268931280d2 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/examples/index.js @@ -0,0 +1,49 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +var Float64Array = require( '@stdlib/array/float64' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var ndarray2array = require( '@stdlib/ndarray/base/to-array' ); +var dlatrs = require( './../lib' ); + +// Specify matrix meta data: +var shape = [ 3, 3 ]; +var strides = [ 3, 1 ]; +var offset = 0; +var N = numel( shape ); +var order = 'row-major'; + +// Create a matrix stored in linear memory: +var A = uniform( N, 2.0, 10.0, { + 'dtype': 'float64' +}); + +console.log( ndarray2array( A, shape, strides, offset, order ) ); + +var X = uniform( shape[ 0 ], 0.0, 10.0, { + 'dtype': 'float64' +}); + +var CNORM = new Float64Array( shape[ 0 ] ); + +var scale = dlatrs( order, 'upper', 'no-transpose', 'non-unit', 'no', shape[ 0 ], A, strides[ 0 ], X, CNORM ); +console.log( ndarray2array( A, shape, strides, offset, order ) ); +console.log( 'scaling factor: ', scale ); diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/package.json b/lib/node_modules/@stdlib/lapack/base/dlatrs/package.json new file mode 100644 index 000000000000..e02cc149a934 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/package.json @@ -0,0 +1,72 @@ +{ + "name": "@stdlib/lapack/base/dlatrs", + "version": "0.0.0", + "description": "LAPACK routine to solve a triangular system of equations with the scale factor set to prevent overflow.", + "license": "Apache-2.0", + "author": { + "name": "The Stdlib Authors", + "url": "https://github.com/stdlib-js/stdlib/graphs/contributors" + }, + "contributors": [ + { + "name": "The Stdlib Authors", + "url": "https://github.com/stdlib-js/stdlib/graphs/contributors" + } + ], + "main": "./lib", + "directories": { + "benchmark": "./benchmark", + "doc": "./docs", + "example": "./examples", + "lib": "./lib", + "test": "./test" + }, + "types": "./docs/types", + "scripts": {}, + "homepage": "https://github.com/stdlib-js/stdlib", + "repository": { + "type": "git", + "url": "git://github.com/stdlib-js/stdlib.git" + }, + "bugs": { + "url": "https://github.com/stdlib-js/stdlib/issues" + }, + "dependencies": {}, + "devDependencies": {}, + "engines": { + "node": ">=0.10.0", + "npm": ">2.7.0" + }, + "os": [ + "aix", + "darwin", + "freebsd", + "linux", + "macos", + "openbsd", + "sunos", + "win32", + "windows" + ], + "keywords": [ + "stdlib", + "stdmath", + "mathematics", + "math", + "lapack", + "dlatrs", + "interchange", + "triangular", + "exchange", + "permute", + "permutedims", + "linear", + "algebra", + "subroutines", + "array", + "ndarray", + "float64", + "double", + "float64array" + ] +} From cc6b47ab64c3703fadc30c0b638f35916767adb8 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Sun, 15 Jun 2025 20:45:09 +0000 Subject: [PATCH 24/32] docs: add index.d.ts file --- 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: 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: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../lapack/base/dlatrs/docs/types/index.d.ts | 142 ++++++++++++++++++ 1 file changed, 142 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/docs/types/index.d.ts diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/dlatrs/docs/types/index.d.ts new file mode 100644 index 000000000000..af8c9cacc7ce --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/docs/types/index.d.ts @@ -0,0 +1,142 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +// TypeScript Version: 4.1 + +/// + +import { Layout, DiagonalType, MatrixTriangle, TransposeOperation } from '@stdlib/types/blas'; + +/** +* Specifies whether `CNORM` contains the column norms or do they have to be calculated. +*/ +type Normin = number; + +/** +* Interface describing `dlatrs`. +*/ +interface Routine { + /** + * Solves a triangular system of equations with the scale factor set to prevent overflow. + * + * @param order - storage layout + * @param uplo - specifies whether `A` is an upper or lower triangular matrix + * @param trans - specifies whether `A` should be transposed or not transposed + * @param diag - specifies whether `A` has a unit diagonal + * @param normin - specifies whether `CNORM` has been set or not + * @param N - number of rows/columns in `A` + * @param A - input matrix + * @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) + * @param X - input vector, specifies the right hand side vector of the equation + * @param CNORM - used to store the column norms + * @returns permuted matrix `A` + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var A = new Float64Array( [ 2.0, 1.0, -1.0, 0.0, 3.0, 2.0, 0.0, 0.0, 4.0 ] ); // => [ [ 2.0, 1.0, -1.0 ], [ 0.0, 3.0, 2.0 ], [ 0.0, 0.0, 4.0 ] ] + * var X = new Float64Array( [ 5.0, 10.0, 20,0 ] ); + * var CNORM = new Float64Array( 3 ); + * + * var scale = dlatrs( 'row-major', 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, X, CNORM ); + * // returns 1.0 + * // X => [ 5.0, 0.0, 5.0 ] + * // CNORM => [ 0.0, 1.0, 3.0 ] + */ + ( order: Layout, uplo: MatrixTriangle, trans: TransposeOperation, diag: DiagonalType, normin: Normin, N: number, A: Float64Array, LDA: number, X: Float64Array, CNORM: Float64Array ): number; + + /** + * Solves a triangular system of equations with the scale factor set to prevent overflow using alternative indexing semantics. + * + * @param uplo - specifies whether `A` is an upper or lower triangular matrix + * @param trans - specifies whether `A` should be transposed or not transposed + * @param diag - specifies whether `A` has a unit diagonal + * @param normin - specifies whether `CNORM` has been set or not + * @param N - number of rows/columns in `A` + * @param A - input matrix + * @param strideA1 - stride of the first dimension of `A` + * @param strideA2 - stride of the second dimension of `A` + * @param offsetA - starting index for `A` + * @param X - input vector, specifies the right hand side vector of the equation + * @param strideX - stride length for `X` + * @param offsetX - starting index for `X` + * @param CNORM - used to store the column norms + * @param strideCNORM - stride length for `CNORM` + * @param offsetCNORM - starting index for `CNORM` + * @returns permuted matrix `A` + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var A = new Float64Array( [ 2.0, 1.0, -1.0, 0.0, 3.0, 2.0, 0.0, 0.0, 4.0 ] ); // => [ [ 2.0, 1.0, -1.0 ], [ 0.0, 3.0, 2.0 ], [ 0.0, 0.0, 4.0 ] ] + * var X = new Float64Array( [ 5.0, 10.0, 20,0 ] ); + * var CNORM = new Float64Array( 3 ); + * + * var scale = dlatrs.ndarray( 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, 1, 0, X, 1, 0, CNORM, 1, 0 ); + * // returns 1.0 + * // X => [ 5.0, 0.0, 5.0 ] + * // CNORM => [ 0.0, 1.0, 3.0 ] + */ + ndarray( uplo: MatrixTriangle, trans: TransposeOperation, diag: DiagonalType, normin: Normin, N: number, A: Float64Array, strideA1: number, strideA2: number, offsetA: number, X: Float64Array, strideX: number, offsetX: number, CNORM: Float64Array, strideCNORM: number, offsetCNORM: number ): number; +} + +/** +* Solves a triangular system of equations with the scale factor set to prevent overflow. +* +* @param order - storage layout +* @param uplo - specifies whether `A` is an upper or lower triangular matrix +* @param trans - specifies whether `A` should be transposed or not transposed +* @param diag - specifies whether `A` has a unit diagonal +* @param normin - specifies whether `CNORM` has been set or not +* @param N - number of rows/columns in `A` +* @param A - input matrix +* @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) +* @param X - input vector, specifies the right hand side vector of the equation +* @param CNORM - used to store the column norms +* @returns permuted matrix `A` +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var A = new Float64Array( [ 2.0, 1.0, -1.0, 0.0, 3.0, 2.0, 0.0, 0.0, 4.0 ] ); // => [ [ 2.0, 1.0, -1.0 ], [ 0.0, 3.0, 2.0 ], [ 0.0, 0.0, 4.0 ] ] +* var X = new Float64Array( [ 5.0, 10.0, 20,0 ] ); +* var CNORM = new Float64Array( 3 ); +* +* var scale = dlatrs( 'row-major', 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, X, CNORM ); +* // returns 1.0 +* // X => [ 5.0, 0.0, 5.0 ] +* // CNORM => [ 0.0, 1.0, 3.0 ] +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var A = new Float64Array( [ 2.0, 1.0, -1.0, 0.0, 3.0, 2.0, 0.0, 0.0, 4.0 ] ); // => [ [ 2.0, 1.0, -1.0 ], [ 0.0, 3.0, 2.0 ], [ 0.0, 0.0, 4.0 ] ] +* var X = new Float64Array( [ 5.0, 10.0, 20,0 ] ); +* var CNORM = new Float64Array( 3 ); +* +* var scale = dlatrs.ndarray( 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, 1, 0, X, 1, 0, CNORM, 1, 0 ); +* // returns 1.0 +* // X => [ 5.0, 0.0, 5.0 ] +* // CNORM => [ 0.0, 1.0, 3.0 ] +*/ +declare var dlatrs: Routine; + + +// EXPORTS // + +export = dlatrs; From c8e2e0bfbe4b317f46915f343e2f787388ff2393 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Sun, 15 Jun 2025 21:41:05 +0000 Subject: [PATCH 25/32] docs: add ts test file --- 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: 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: passed - task: lint_typescript_tests status: passed - task: lint_license_headers status: passed --- --- .../lapack/base/dlatrs/docs/types/index.d.ts | 2 +- .../lapack/base/dlatrs/docs/types/test.ts | 480 ++++++++++++++++++ 2 files changed, 481 insertions(+), 1 deletion(-) create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/docs/types/test.ts diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/dlatrs/docs/types/index.d.ts index af8c9cacc7ce..7086f9835053 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/docs/types/index.d.ts @@ -25,7 +25,7 @@ import { Layout, DiagonalType, MatrixTriangle, TransposeOperation } from '@stdli /** * Specifies whether `CNORM` contains the column norms or do they have to be calculated. */ -type Normin = number; +type Normin = 'yes' | 'no'; /** * Interface describing `dlatrs`. diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/docs/types/test.ts b/lib/node_modules/@stdlib/lapack/base/dlatrs/docs/types/test.ts new file mode 100644 index 000000000000..b4e900f64290 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/docs/types/test.ts @@ -0,0 +1,480 @@ +/* +* @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. +*/ + +import dlatrs = require( './index' ); + + +// TESTS // + +// The function returns a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectType number +} + +// The compiler throws an error if the function is provided a first argument which is not a string... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs( 5, 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( true, 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( false, 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( null, 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( void 0, 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( [], 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( {}, 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( ( x: number ): number => x, 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError +} +// The compiler throws an error if the function is provided a second argument which is not a string... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs( 'row-major', 5, 'no-transpose', 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', true, 'no-transpose', 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', false, 'no-transpose', 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', null, 'no-transpose', 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', void 0, 'no-transpose', 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', [], 'no-transpose', 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', {}, 'no-transpose', 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', ( x: number ): number => x, 'no-transpose', 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError +} + +// The compiler throws an error if the function is provided a third argument which is not a string... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs( 'row-major', 'lower', 5, 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', true, 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', false, 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', null, 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', void 0, 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', [], 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', {}, 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', ( x: number ): number => x, 'non-unit', 'no', 2, A, 2, X, CNORM ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fourth argument which is not a string... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs( 'row-major', 'lower', 'no-transpose', 5, 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', true, 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', false, 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', null, 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', void 0, 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', [], 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', {}, 'no', 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', ( x: number ): number => x, 'no', 2, A, 2, X, CNORM ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fifth argument which is not a string... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 5, 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', true, 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', false, 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', null, 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', void 0, 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', [], 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', {}, 2, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', ( x: number ): number => x, 2, A, 2, X, CNORM ); // $ExpectError +} + +// The compiler throws an error if the function is provided a sixth argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', '2', A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', true, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', false, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', null, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', void 0, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', [], A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', {}, A, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', ( x: number ): number => x, A, 2, X, CNORM ); // $ExpectError +} + +// The compiler throws an error if the function is provided a seventh argument which is not a Float64Array... +{ + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, 'A', 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, 5, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, true, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, false, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, null, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, void 0, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, [], 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, {}, 2, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, ( x: number ): number => x, 2, X, CNORM ); // $ExpectError +} + +// The compiler throws an error if the function is provided an eighth argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, '2', X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, true, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, false, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, null, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, void 0, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, [], X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, {}, X, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, ( x: number ): number => x, X, CNORM ); // $ExpectError +} + +// The compiler throws an error if the function is provided a ninth argument which is not a Float64Array... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 'X', CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 5, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, true, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, false, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, null, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, void 0, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, [], CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, {}, CNORM ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, ( x: number ): number => x, CNORM ); // $ExpectError +} + +// The compiler throws an error if the function is provided a tenth argument which is not a Float64Array... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, X, 'CNORM' ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, X, 5 ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, X, true ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, X, false ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, X, null ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, X, void 0 ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, X, [] ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, X, {} ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, X, ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the function is provided an unsupported number of arguments... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs(); // $ExpectError + dlatrs( 'row-major' ); // $ExpectError + dlatrs( 'row-major', 'lower' ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose' ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit' ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no' ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2 ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2 ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, X ); // $ExpectError + dlatrs( 'row-major', 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, X, CNORM, 1 ); // $ExpectError +} + +// Attached to main export is an `ndarray` method which returns a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectType number +} + +// The compiler throws an error if the function is provided a first argument which is not a string... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs.ndarray( 5, 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( true, 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( false, 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( null, 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( void 0, 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( [], 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( {}, 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( ( x: number ): number => x, 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a second argument which is not a string... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs.ndarray( 'lower', 5, 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', true, 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', false, 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', null, 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', void 0, 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', [], 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', {}, 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', ( x: number ): number => x, 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a third argument which is not a string... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs.ndarray( 'lower', 'no-transpose', 2, 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', true, 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', false, 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', null, 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', void 0, 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', [], 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', {}, 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', ( x: number ): number => x, 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fourth argument which is not a string... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 2, 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', true, 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', false, 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', null, 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', void 0, 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', [], 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', {}, 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', ( x: number ): number => x, 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fifth argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', '2', A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', true, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', false, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', null, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', void 0, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', [], A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', {}, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', ( x: number ): number => x, A, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a sixth argument which is not a Float64Array... +{ + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, 'A', 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, 5, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, true, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, false, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, null, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, void 0, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, [], 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, {}, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, ( x: number ): number => x, 2, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a seventh argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, '2', 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, true, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, false, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, null, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, void 0, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, [], 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, {}, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, ( x: number ): number => x, 1, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided an eighth argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, '1', 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, true, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, false, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, null, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, void 0, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, [], 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, {}, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, ( x: number ): number => x, 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a ninth argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, '0', X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, true, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, false, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, null, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, void 0, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, [], X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, {}, X, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, ( x: number ): number => x, X, 1, 0, CNORM, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a tenth argument which is not a Float64Array... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, 'X', 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, 5, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, true, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, false, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, null, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, void 0, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, [], 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, {}, 1, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, ( x: number ): number => x, 1, 0, CNORM, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided an eleventh argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, '1', 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, true, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, false, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, null, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, void 0, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, [], 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, {}, 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, ( x: number ): number => x, 0, CNORM, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a twelvth argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, '0', CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, true, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, false, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, null, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, void 0, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, [], CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, {}, CNORM, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, ( x: number ): number => x, CNORM, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a thirteenth argument which is not a Float64Array... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, 'CNORM', 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, 5, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, true, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, false, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, null, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, void 0, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, [], 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, {}, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, ( x: number ): number => x, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fourteenth argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, '1', 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, true, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, false, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, null, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, void 0, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, [], 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, {}, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, ( x: number ): number => x, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fifteenth argument which is not a number... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, '0' ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, true ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, false ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, null ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, void 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, [] ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, {} ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM, 1, ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the function is provided an unsupported number of arguments... +{ + const A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] ); + const X = new Float64Array( [ 1.0, 2.0 ] ); + const CNORM = new Float64Array( 2 ); + + dlatrs.ndarray(); // $ExpectError + dlatrs.ndarray( 'lower' ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose' ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit' ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no' ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0 ); // $ExpectError + dlatrs.ndarray( 'lower', 'no-transpose', 'non-unit', 'no', 2, A, 2, 1, 0, X, 1, 0, CNORM ); // $ExpectError +} From 4af0a152ab77eafb7b1b5f17201d70571778de9e Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Mon, 16 Jun 2025 07:36:16 +0000 Subject: [PATCH 26/32] docs: add README --- 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: passed - 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/dlatrs/README.md | 343 ++++++++++++++++++ .../@stdlib/lapack/base/dlatrs/lib/ndarray.js | 2 +- 2 files changed, 344 insertions(+), 1 deletion(-) create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/README.md diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/README.md b/lib/node_modules/@stdlib/lapack/base/dlatrs/README.md new file mode 100644 index 000000000000..86e25a18cbf8 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/README.md @@ -0,0 +1,343 @@ + + +# dlatrs + +> LAPACK routine to solve a triangular system of equations with the scale factor set to prevent overflow. + +
+ +The `dlatrs` routine solves a triangular system of linear equations with a scaling factor to prevent overflow. It can handle either the original system or its transpose: + + + +```math +A X = s B \quad \text{or} \quad A^{T} X = s B +``` + + + +where: + +- `A` is an upper or lower triangular matrix, +- `X` is the solution vector, +- `B` is the right-hand side vector, +- `s` is a scaling factor ( 0 < `s` < 1 ) chosen to avoid numerical overflow. + +The routine aims to compute a solution `x` such that the magnitude of all elements in `X` remains safely below the machine overflow threshold. + +If it determines that solving the unscaled system would not lead to overflow, it calls the Level 2 BLAS routine `dtrsv` for a standard triangular solve. Otherwise, `dlatrs` applies additional scaling and iterative techniques to avoid overflow and maintain numerical stability. + +In the presence of a singular matrix `A` (i.e., `A( j, j )` = 0 for some `j`), the scaling factor `s` is set to zero, and a non trivial solution to the homogeneous system: + + + +```math +A X = 0 +``` + + + +is returned instead. + +To ensure stability during the solve, `dlatrs` relies on several internal estimates, including: + +- the off diagonal column norms, +- the scaling factor `s`, +- and an estimate of the maximum element in the intermediate vector `X`. + +The algorithm may scale `X` at various stages using a factor `scale`, such that the final computed result satisfies: + + + +```math +x \leftarrow scale \cdot x +``` + + + +This ensures both correctness and numerical safety when solving the triangular system under limited-precision arithmetic. + +
+ + + +
+ +## Usage + +```javascript +var dlatrs = require( '@stdlib/lapack/base/dlatrs' ); +``` + +#### dlatrs( order, uplo, trans, diag, normin, N, A, LDA, X, CNORM ) + +Solves a triangular system of equations with the scale factor set to prevent overflow. + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); + +var A = new Float64Array( [ 2.0, 1.0, -1.0, 0.0, 3.0, 2.0, 0.0, 0.0, 4.0 ] ); // => [ [ 2.0, 1.0, -1.0 ], [ 0.0, 3.0, 2.0 ], [ 0.0, 0.0, 4.0 ] ] +var X = new Float64Array( [ 5.0, 10.0, 20.0 ] ); +var CNORM = new Float64Array( 3 ); + +var scale = dlatrs( 'row-major', 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, X, CNORM ); +// returns 1.0 +// X => [ 5.0, 0.0, 5.0 ] +// CNORM => [ 0.0, 1.0, 3.0 ] +``` + +The function has the following parameters: + +- **order**: storage layout. +- **uplo**: specifies whether `A` is an upper or lower triangular matrix. +- **trans**: specifies whether `A` should be transposed, conjugate-transposed, or not transposed. +- **diag**: specifies whether `A` has a unit diagonal. +- **normin**: specifies whether `CNORM` has the column norms on entry or not, should be either `yes` or `no`. +- **N**: number of elements along each dimension of `A`. +- **A**: input matrix stored in linear memory as a [`Float64Array`][mdn-float64array]. +- **LDA**: stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`). +- **X**: input vector [`Float64Array`][mdn-float64array] describing the right hand side `B`, should have `N` elements. +- **CNORM**: [`Float64Array`][mdn-float64array] used to store the column norms of `A`, should have `N` elements. + +`X` is overwritten by the solution vector on the left hand side. If `normin` is `yes` then `CNORM` is an input parameter and it should contain the off diagonal column norms of `A`, else `CNORM` is overwritten by the off diagonal column norms computed by the routine + +Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views. + + + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); +var Int32Array = require( '@stdlib/array/int32' ); +var dlatrs = require( '@stdlib/lapack/base/dlatrs' ); + +// Initial arrays... +var A0 = new Float64Array( [ 9999.0, 2.0, 1.0, -1.0, 0.0, 3.0, 2.0, 0.0, 0.0, 4.0 ] ); // => [ [ 2.0, 1.0, -1.0 ], [ 0.0, 3.0, 2.0 ], [ 0.0, 0.0, 4.0 ] ] +var X0 = new Float64Array( [ 9999.0, 5.0, 10.0, 20.0 ] ); +var CNORM0 = new Float64Array( 4 ); + +// Create offset views... +var A = new Float64Array( A0.buffer, A0.BYTES_PER_ELEMENT*1 ); // start at 2nd element +var X = new Float64Array( X0.buffer, X0.BYTES_PER_ELEMENT*1 ); // start at 2nd element +var CNORM = new Float64Array( CNORM0.buffer, CNORM0.BYTES_PER_ELEMENT*1 ); // start at 2nd element + +var scale = dlatrs( 'row-major', 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, X, CNORM ); +// returns 1.0 +// X0 => [ 9999.0, 5.0, 0.0, 5.0 ] +// CNORM0 => [ 0.0, 0.0, 1.0, 3.0 ] +``` + + + +#### dlatrs.ndarray( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X, strideX, offsetX, CNORM, strideCNORM, offsetCNORM ) + +Solves a triangular system of equations with the scale factor set to prevent overflow using alternative indexing semantics. + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); + +var A = new Float64Array( [ 2.0, 1.0, -1.0, 0.0, 3.0, 2.0, 0.0, 0.0, 4.0 ] ); // => [ [ 2.0, 1.0, -1.0 ], [ 0.0, 3.0, 2.0 ], [ 0.0, 0.0, 4.0 ] ] +var X = new Float64Array( [ 5.0, 10.0, 20,0 ] ); +var CNORM = new Float64Array( 3 ); + +var scale = dlatrs( 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, 1, 0, X, 1, 0, CNORM, 1, 0 ); +// returns 1.0 +// X => [ 5.0, 0.0, 5.0 ] +// CNORM => [ 0.0, 1.0, 3.0 ] +``` + +The function has the following additional parameters: + +- **strideA1**: stride of the first dimensiosn of `A`. +- **strideA2**: stride of the second dimension of `A`. +- **offsetA**: starting index for `A`. +- **strideX**: stride length for `X`. +- **offsetX**: starting index for `X`. +- **strideCNORM**: stride length for `CNORM`. +- **offsetCNORM**: starting index for `CNORM`. + +While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameters support indexing semantics based on starting indices. For example, + + + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); + +var A = new Float64Array( [ 9999.0, 2.0, 1.0, -1.0, 0.0, 3.0, 2.0, 0.0, 0.0, 4.0 ] ); // => [ [ 2.0, 1.0, -1.0 ], [ 0.0, 3.0, 2.0 ], [ 0.0, 0.0, 4.0 ] ] +var X = new Float64Array( [ 9999.0, 5.0, 10.0, 20,0 ] ); +var CNORM = new Float64Array( 4 ); + +var scale = dlatrs( 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, 1, 1, X, 1, 1, CNORM, 1, 1 ); +// returns 1.0 +// X => [ 9999.0, 5.0, 0.0, 5.0 ] +// CNORM => [ 0.0, 0.0, 1.0, 3.0 ] +``` + +
+ + + +
+ +## Notes + +- Both functions mutate the input arrays `X` and `CNORM` (if `normin` = `no`). + +- `dlatrs()` corresponds to the [LAPACK][LAPACK] routine [`dlatrs`][lapack-dlatrs]. + +
+ + + +
+ +## Examples + + + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); +var numel = require( '@stdlib/ndarray/base/numel' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var ndarray2array = require( '@stdlib/ndarray/base/to-array' ); +var dlatrs = require( '@stdlib/lapack/base/dlatrs' ); + +// Specify matrix meta data: +var shape = [ 3, 3 ]; +var strides = [ 3, 1 ]; +var offset = 0; +var N = numel( shape ); +var order = 'row-major'; + +// Create a matrix stored in linear memory: +var A = uniform( N, 2.0, 10.0, { + 'dtype': 'float64' +}); + +console.log( ndarray2array( A, shape, strides, offset, order ) ); + +var X = uniform( shape[ 0 ], 0.0, 10.0, { + 'dtype': 'float64' +}); + +var CNORM = new Float64Array( shape[ 0 ] ); + +var scale = dlatrs( order, 'upper', 'no-transpose', 'non-unit', 'no', shape[ 0 ], A, strides[ 0 ], X, CNORM ); +console.log( ndarray2array( A, shape, strides, offset, order ) ); +console.log( 'scaling factor: ', scale ); +``` + +
+ + + + + +* * * + +
+ +## C APIs + + + +
+ +
+ + + + + +
+ +### Usage + +```c +TODO +``` + +#### TODO + +TODO. + +```c +TODO +``` + +TODO + +```c +TODO +``` + +
+ + + + + +
+ +
+ + + + + +
+ +### Examples + +```c +TODO +``` + +
+ + + +
+ + + + + +
+ +
+ + + + + +
+ +[lapack]: https://www.netlib.org/lapack/explore-html/ + +[lapack-dlatrs]: https://www.netlib.org/lapack/explore-html-3.6.1/d8/dc3/dlatrs_8f_aab36439db8d657622a1d296b89d4acc0.html + +[mdn-float64array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array + +[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray + +
+ + diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/ndarray.js index a6b101d07edd..c12823880a6f 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/ndarray.js @@ -32,7 +32,7 @@ var base = require( './base.js' ); // MAIN // /** -* Solves a triangular system of equations with the scale factor set to prevent overflow. +* Solves a triangular system of equations with the scale factor set to prevent overflow using alternative indexing semantics. * * @param {string} uplo - specifies whether `A` is an upper or lower triangular matrix * @param {string} trans - specifies whether `A` should be transposed or not transposed From 1f97555cefaa7227898fb00eebfc85b9e6ee1b8c Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Mon, 16 Jun 2025 07:37:23 +0000 Subject: [PATCH 27/32] docs: add README --- 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: passed - 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: 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 --- --- lib/node_modules/@stdlib/lapack/base/dlatrs/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/README.md b/lib/node_modules/@stdlib/lapack/base/dlatrs/README.md index 86e25a18cbf8..b237cdcbbb12 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/README.md +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/README.md @@ -154,7 +154,7 @@ Solves a triangular system of equations with the scale factor set to prevent ove var Float64Array = require( '@stdlib/array/float64' ); var A = new Float64Array( [ 2.0, 1.0, -1.0, 0.0, 3.0, 2.0, 0.0, 0.0, 4.0 ] ); // => [ [ 2.0, 1.0, -1.0 ], [ 0.0, 3.0, 2.0 ], [ 0.0, 0.0, 4.0 ] ] -var X = new Float64Array( [ 5.0, 10.0, 20,0 ] ); +var X = new Float64Array( [ 5.0, 10.0, 20.0 ] ); var CNORM = new Float64Array( 3 ); var scale = dlatrs( 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, 1, 0, X, 1, 0, CNORM, 1, 0 ); @@ -181,7 +181,7 @@ While [`typed array`][mdn-typed-array] views mandate a view offset based on the var Float64Array = require( '@stdlib/array/float64' ); var A = new Float64Array( [ 9999.0, 2.0, 1.0, -1.0, 0.0, 3.0, 2.0, 0.0, 0.0, 4.0 ] ); // => [ [ 2.0, 1.0, -1.0 ], [ 0.0, 3.0, 2.0 ], [ 0.0, 0.0, 4.0 ] ] -var X = new Float64Array( [ 9999.0, 5.0, 10.0, 20,0 ] ); +var X = new Float64Array( [ 9999.0, 5.0, 10.0, 20.0 ] ); var CNORM = new Float64Array( 4 ); var scale = dlatrs( 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, 1, 1, X, 1, 1, CNORM, 1, 1 ); From 6f9c1d893415540b803a9d0c6f2cd16d3f43fe8b Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Mon, 16 Jun 2025 07:40:08 +0000 Subject: [PATCH 28/32] 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: passed - 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: 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/dlatrs/README.md | 21 +++++++++---------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/README.md b/lib/node_modules/@stdlib/lapack/base/dlatrs/README.md index b237cdcbbb12..77ee6ed4b520 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/README.md +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/README.md @@ -146,7 +146,7 @@ var scale = dlatrs( 'row-major', 'upper', 'no-transpose', 'non-unit', 'no', 3, A -#### dlatrs.ndarray( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X, strideX, offsetX, CNORM, strideCNORM, offsetCNORM ) +#### dlatrs.ndarray( uplo, trans, diag, normin, N, A, sa1, sa2, oa, X, sx, ox, CNORM, sc, oc ) Solves a triangular system of equations with the scale factor set to prevent overflow using alternative indexing semantics. @@ -157,7 +157,7 @@ var A = new Float64Array( [ 2.0, 1.0, -1.0, 0.0, 3.0, 2.0, 0.0, 0.0, 4.0 ] ); // var X = new Float64Array( [ 5.0, 10.0, 20.0 ] ); var CNORM = new Float64Array( 3 ); -var scale = dlatrs( 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, 1, 0, X, 1, 0, CNORM, 1, 0 ); +var scale = dlatrs.ndarray( 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, 1, 0, X, 1, 0, CNORM, 1, 0 ); // returns 1.0 // X => [ 5.0, 0.0, 5.0 ] // CNORM => [ 0.0, 1.0, 3.0 ] @@ -165,13 +165,13 @@ var scale = dlatrs( 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, 1, 0, X, The function has the following additional parameters: -- **strideA1**: stride of the first dimensiosn of `A`. -- **strideA2**: stride of the second dimension of `A`. -- **offsetA**: starting index for `A`. -- **strideX**: stride length for `X`. -- **offsetX**: starting index for `X`. -- **strideCNORM**: stride length for `CNORM`. -- **offsetCNORM**: starting index for `CNORM`. +- **sa1**: stride of the first dimensiosn of `A`. +- **sa2**: stride of the second dimension of `A`. +- **oa**: starting index for `A`. +- **sx**: stride length for `X`. +- **ox**: starting index for `X`. +- **sc**: stride length for `CNORM`. +- **oc**: starting index for `CNORM`. While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameters support indexing semantics based on starting indices. For example, @@ -184,7 +184,7 @@ var A = new Float64Array( [ 9999.0, 2.0, 1.0, -1.0, 0.0, 3.0, 2.0, 0.0, 0.0, 4.0 var X = new Float64Array( [ 9999.0, 5.0, 10.0, 20.0 ] ); var CNORM = new Float64Array( 4 ); -var scale = dlatrs( 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, 1, 1, X, 1, 1, CNORM, 1, 1 ); +var scale = dlatrs.ndarray( 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, 1, 1, X, 1, 1, CNORM, 1, 1 ); // returns 1.0 // X => [ 9999.0, 5.0, 0.0, 5.0 ] // CNORM => [ 0.0, 0.0, 1.0, 3.0 ] @@ -199,7 +199,6 @@ var scale = dlatrs( 'upper', 'no-transpose', 'non-unit', 'no', 3, A, 3, 1, 1, X, ## Notes - Both functions mutate the input arrays `X` and `CNORM` (if `normin` = `no`). - - `dlatrs()` corresponds to the [LAPACK][LAPACK] routine [`dlatrs`][lapack-dlatrs]. From 162195b2e43ec588fc5b9e8b82978acc6f5f47c5 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Mon, 16 Jun 2025 08:41:44 +0000 Subject: [PATCH 29/32] docs: add repl.txt --- 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: passed - task: lint_javascript_src status: na - 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/dlatrs/docs/repl.txt | 151 ++++++++++++++++++ 1 file changed, 151 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dlatrs/docs/repl.txt diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/dlatrs/docs/repl.txt new file mode 100644 index 000000000000..6d9e71b60f5c --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/docs/repl.txt @@ -0,0 +1,151 @@ + +{{alias}}( order, uplo, trans, diag, normin, N, A, LDA, X, CNORM ) + Solves a triangular system of linear equations with a scaling factor + to prevent overflow. It can handle either the original system or its + transpose. + + Indexing is relative to the first index. To introduce an offset, use typed + array views. + + Parameters + ---------- + order: string + Row-major (C-style) or column-major (Fortran-style) order. Must be + either 'row-major' or 'column-major'. + + uplo: string + Specifies whether to copy the upper or lower triangular/trapezoidal part + of a matrix `A`. + + trans: string + Specifies whether `A` should be transposed, conjugate-transposed, or not + transposed. + + diag: string + Specifies whether `A` has a unit diagonal. + + normin: string + Specifies whether `CNORM` has the column norms on entry or not, should + be either `yes` or `no`. + + N: integer + Number of rows/columns in `A`. + + A: Float64Array + Input matrix `A`. + + LDA: integer + Stride of the first dimension of `A` (a.k.a., leading dimension of the + matrix `A`). + + X: Float64Array + Input vector, stores the right hand side vector `B`, overwritten by the + solution vector `X`. + + CNORM: Float64Array + Used to store the column norms of `A`, should have `N` elements. + + Returns + ------- + scale: number + Scaling factor. + + Examples + -------- + > var A = new {{alias:@stdlib/array/float64}}( [ 4.0, 2.0, 0.0, 3.0 ] ); + > var X = new {{alias:@stdlib/array/float64}}( [ 10.0, 9.0 ] ); + > var CNORM = new {{alias:@stdlib/array/float64}}( 2 ); + > var ord = 'row-major'; + > var uplo = 'upper'; + > var tran = 'no-transpose'; + > var diag = 'non-unit'; + > {{alias}}( ord, uplo, tran, diag, 'no', 2, A, 2, X, CNORM ) + 1.0 + > X + [ 1.0, 3.0 ] + > CNORM + [ 0.0, 2.0 ] + + +{{alias}}.ndarray( uplo,tran,dia,norm, N, A,sa1,sa2,oa, X,sx,ox, CNORM,sc,oc ) + Solves a triangular system of linear equations with a scaling factor + to prevent overflow using alternative indexing semantics. It can handle + either the original system or its transpose. + + While typed array views mandate a view offset based on the underlying + buffer, the offset parameters support indexing semantics based on starting + indices. + + Parameters + ---------- + uplo: string + Specifies whether to copy the upper or lower triangular/trapezoidal part + of a matrix `A`. + + tran: string + Specifies whether `A` should be transposed, conjugate-transposed, or not + transposed. + + dia: string + Specifies whether `A` has a unit diagonal. + + norm: string + Specifies whether `CNORM` has the column norms on entry or not, should + be either `yes` or `no`. + + N: integer + Number of rows/columns in `A`. + + A: Float64Array + Input matrix `A`. + + sa1: integer + Stride of the first dimension of `A`. + + sa2: integer + Stride of the second dimension of `A`. + + oa: integer + Starting index for `A`. + + X: Float64Array + Input vector, stores the right hand side vector `B`, overwritten by the + solution vector `X`. + + sx: integer + Index increment for `X`. + + ox: integer + Starting index for `X`. + + CNORM: Float64Array + Used to store the column norms of `A`, should have `N` elements. + + sc: integer + Index increment for `CNORM`. + + oc: integer + Starting index for `CNORM`. + + Returns + ------- + scale: number + Scaling factor. + + Examples + -------- + > var A = new {{alias:@stdlib/array/float64}}( [ 4.0, 2.0, 0.0, 3.0 ] ); + > var X = new {{alias:@stdlib/array/float64}}( [ 10.0, 9.0 ] ); + > var CNORM = new {{alias:@stdlib/array/float64}}( 2 ); + > var uplo = 'upper'; + > var tran = 'no-transpose'; + > var diag = 'non-unit'; + > {{alias}}.ndarray( uplo,tran,diag, 'no', 2, A, 2,1,0, X,1,0, CNORM,1,0 ) + 1.0 + > X + [ 1.0, 3.0 ] + > CNORM + [ 0.0, 2.0 ] + + See Also + -------- From 940a493f68cbc0f4bd9d0bbef4897106bbb42ade Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Mon, 16 Jun 2025 16:36:08 +0000 Subject: [PATCH 30/32] docs: add comments --- 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/dlatrs/lib/base.js | 77 ++++++++++++++++++- 1 file changed, 75 insertions(+), 2 deletions(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js index 66f7fb309a08..9d3f805ede52 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/base.js @@ -130,23 +130,28 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X } } + // Scale the column norms by `tscal` if the maximum element in `CNORM` is greater than `bignum` imax = idamax( N, CNORM, strideCNORM, offsetCNORM ); tmax = CNORM[ offsetCNORM + ( imax * strideCNORM ) ]; if ( tmax <= bignum ) { + // All entries in `CNORM` are valid floating point numbers... tscal = 1.0; } else { + // At least one entry in `CNORM` can't be represented as a floating point number. Find the largest off diagonal element, if this is not `Infinity` use it as `tscal`... if ( tmax <= dlamch( 'overflow' ) ) { tscal = 1.0 / ( smlnum * tmax ); dscal( N, tscal, CNORM, strideCNORM, offsetCNORM ); } else { tmax = 0.0; if ( uplo === 'upper' ) { + // Upper triangular ia = offsetA + strideA2; for ( j = 1; j < N; j++ ) { tmax = max( dlange( 'max', j, 1, A, strideA1, strideA2, ia ), tmax ); ia += strideA2; } } else { + // Lower triangular ia = offsetA + strideA1; for ( j = 0; j < N - 1; j++ ) { tmax = max( dlange( 'max', N - ( j + 1 ), 1, A, strideA1, strideA2, ia ), tmax ); @@ -162,6 +167,7 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X if ( CNORM[ ic ] <= dlamch( 'overflow' ) ) { CNORM[ ic ] *= tscal; } else { + // Recompute the 1 norm without introducing infinity in the summation CNORM[ ic ] = 0.0; if ( uplo === 'upper' ) { ia1 = 0; @@ -181,16 +187,20 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X ia2 += strideA2; } } else { + // At least one entry in `A` is not a valid floating point number, use `dtrsv` to propagate `Infinity` and `NaN` dtrsv( uplo, trans, diag, N, A, strideA1, strideA2, offsetA, X, strideX, offsetX ); + return scale; } } } + // Compute the bound on the computed solution vector to see if `dtrsv` can be used. j = idamax( N, X, strideX, offsetX ); xmax = abs( X[ offsetX + ( j * strideX ) ] ); xbnd = xmax; if ( trans === 'no-transpose' ) { + // Compute the growth in A * X = B if ( uplo === 'upper' ) { jfirst = N - 1; jlast = 0; @@ -209,20 +219,29 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X if ( !GOTO ) { if ( diag === 'non-unit' ) { + /* + A is non-unit and triangular + Compute `grow` = 1 / G( j ), `xbnd` = 1 / M( j ). Initially G( 0 ) = max( X( i ), for 0 <= i < N ) + */ grow = 1.0 / max( xbnd, smlnum ); xbnd = grow; ic = offsetCNORM + ( jfirst * strideCNORM ); ia = offsetA + ( jfirst * ( strideA1 + strideA2 ) ); for ( j = jfirst; (jinc > 0) ? j <= jlast : j >= jlast; j += jinc ) { if ( grow <= smlnum ) { + // Exit the loop if the growth factor is very small. GOTO = true; break; } + + // M( j ) = G( j - 1 ) / abs( A( j, j ) ) tjj = abs( A[ ia ] ); xbnd = min( xbnd, min( 1.0, tjj ) * grow ); if ( tjj + CNORM[ ic ] >= smlnum ) { + // G( j ) = G( j - 1 ) * ( 1 + CNORM( j ) / abs( A( j, j ) ) ) grow *= tjj / ( tjj + CNORM[ ic ] ); } else { + // G( j ) could overflow, set grow to 0 grow = 0.0; } @@ -230,21 +249,29 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X ic += jinc * ( strideCNORM ); } if ( !GOTO ) { + // Control should only reach here if loop exits normally and doesn't "break". grow = xbnd; } } else { + /* + A is unit and triangular. + Compute `grow` = 1 / G( j ), where G( 0 ) = max( X( i ), for 0 <= i < N ) + */ grow = min( 1.0, 1.0 / max( xbnd, smlnum ) ); ic = offsetCNORM + ( jfirst * strideCNORM ); for ( j = jfirst; (jinc > 0) ? j <= jlast : j >= jlast; j+= jinc ) { if ( grow <= smlnum ) { + // Exit the loop if the growth factor is too small. break; } + // G( j ) = G( j - 1 ) * ( 1 + CNORM( j ) ) grow *= 1.0 / ( 1.0 + CNORM[ ic ] ); ic += strideCNORM; } } } } else { + // Compute the growth in A^T * X = B if ( uplo === 'upper' ) { jfirst = 0; jlast = N-1; @@ -263,17 +290,27 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X if ( !GOTO ) { if ( diag === 'non-unit' ) { + /* + A is non-unit triangular. + Compute grow = 1 / G( j ) and xbnd = 1 / M( j ). Initially, M( 0 ) = max( X( i ), for 0 <= i < N ) + */ grow = 1.0 / max( xbnd, smlnum ); xbnd = grow; ia = offsetA + ( jfirst * ( strideA1 + strideA2 ) ); // tracks A( j, j ) ic = offsetCNORM + ( jfirst * strideCNORM ); // tracks CNORM( j ) + for ( j = jfirst; (jinc > 0) ? j <= jlast : j >= jlast; j+=jinc ) { if ( grow <= smlnum ) { + // Exit the loop if grow is too small. GOTO = true; break; } + + // G( j ) = max( G( j - 1 ), M( j - 1 ) * ( 1 + CNORM( j ) ) ) xj = 1.0 + CNORM[ ic ]; grow = min( grow, xbnd / xj ); + + // M( j ) = M( j - 1 ) * ( 1 + CNORM( j ) ) / abs( A( j, j ) ) tjj = abs( A[ ia ] ); if ( xj > tjj ) { xbnd *= ( tjj / xj ); @@ -286,12 +323,19 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X grow = min( grow, xbnd ); } } else { + /* + A is unit triangular + Compute GROW = 1 / G( j ), where G( 0 ) = max( X( i ), for 0 <= i < N ) + */ grow = min( 1.0, 1.0 / max( xbnd, smlnum ) ); ic = offsetCNORM + ( jfirst * strideCNORM ); for ( j = jfirst; (jinc > 0) ? j <= jlast : j >= jlast; j += jinc ) { if ( grow <= smlnum ) { + // Exit the loop if the growth factor is too small break; } + + // G( j ) = ( 1 + CNORM( j ) ) * G( j - 1 ) xj = 1.0 + CNORM[ ic ]; grow /= xj; @@ -302,21 +346,27 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X } if ( grow * tscal > smlnum ) { + // Use the Level 2 BLAS solve if the reciprocal of the bound on elements of X is not too small. dtrsv( uplo, trans, diag, N, A, strideA1, strideA2, offsetA, X, strideX, offsetX ); } else { + // Use a Level 1 BLAS solve, scaling intermediate results. + if ( xmax > bignum ) { + // Scale X so that its components are less than or equal to bignum in absolute value. scale = bignum / xmax; dscal( N, scale, X, strideX, offsetX ); xmax = bignum; } if ( trans === 'no-transpose' ) { + // Solve A * X = B ix = offsetX + ( jfirst * strideX ); // tracks X( j ) ia = offsetA + ( jfirst * ( strideA1 + strideA2 ) ); // tracks A( j, j ) ia1 = offsetA + ( jfirst * strideA2 ); // tracks A( 1, j ) ic = offsetCNORM + ( jfirst * strideCNORM ); // tracks CNORM( j ) for ( j = jfirst; (jinc > 0) ? j <= jlast : j >= jlast; j += jinc ) { + // Compute X( j ) = B( j ) / A( j, j ), scaling X if necessary. xj = abs( X[ ix ] ); GOTO = false; if ( diag === 'non-unit' ) { @@ -330,7 +380,7 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X if ( !GOTO ) { tjj = abs( tjjs ); - if ( tjj > smlnum ) { + if ( tjj > smlnum ) { // abs( A( j, j ) ) > smlnum if ( tjj < 1.0 ) { if ( xj > tjj * bignum ) { rec = 1.0 / xj; @@ -342,9 +392,12 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X X[ ix ] /= tjjs; xj = abs( X[ ix ] ); } else if ( tjj > 0.0 ) { + // 0 < abs( A( j, j ) ) <= smlnum if ( xj > tjj * bignum ) { + // Scale X by ( 1 / abs( X( j ) ) ) * abs( A( j, j ) ) * bignum to avoid overflow when dividing by A( j, j ). rec = ( tjj * bignum ) / xj; if ( CNORM[ ic ] > 1.0 ) { + // Scale by 1 / CNORM( j ) to avoid overflow when multiplying X( j ) times column j rec /= CNORM[ ic ]; } dscal( N, rec, X, strideX, offsetX ); @@ -354,6 +407,7 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X X[ ix ] /= tjjs; xj = abs( X[ ix ] ); } else { + // A( j, j ) = 0: Set X( 1 : N ) = 0, x( j ) = 1, and scale = 0, and compute a solution to A * X = 0 ix1 = offsetX; for ( i = 0; i < N; i++ ) { X[ ix1 ] = 0.0; @@ -364,26 +418,31 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X } } + // Scale X if necessary to avoid overflow when adding a multiple of column j of A if ( xj > 1.0 ) { rec = 1.0 / xj; if ( CNORM[ ic ] > ( bignum - xmax ) * rec ) { + // Scale X by 1 / ( 2 * abs( X( j ) ) ) rec *= 0.5; dscal( N, rec, X, strideX, offsetX ); scale *= rec; } } else if ( xj * CNORM[ ic ] > ( bignum - xmax ) ) { + // Scale X by 0.5 dscal( N, 0.5, X, strideX, offsetX ); scale *= 0.5; } if ( uplo === 'upper' ) { if ( j > 0 ) { + // Compute the update X( 1 : j - 1 ) := X( 1 : j - 1 ) - X( j ) * A( 1 : j - 1, j ) daxpy( j, -1 * tscal * X[ ix ], A, strideA1, ia1, X, strideX, offsetX ); } i = idamax( j, X, strideX, offsetX ); xmax = abs( X[ offsetX + ( i * strideX ) ] ); } else { if ( j < N - 1 ) { + // Compute the update X( j + 1 : N ) := X( j + 1 : N ) - X( j ) * A( j + 1 : N , j ) daxpy( N - ( j + 1 ), -1 * tscal * X[ ix ], A, strideA1, ia + strideA1, X, strideX, ix + strideX ); i = idamax( N - ( j + 1 ), X, strideX, ix + strideX ); xmax = abs( X[ offsetX + ( i * strideX ) ] ); @@ -396,15 +455,18 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X ic += jinc * strideCNORM; } } else { + // Solve A ^ T * X = B ix = offsetX + ( jfirst * strideX ); // tracks X( j ) ia = offsetA + ( jfirst * ( strideA1 + strideA2 ) ); // tracks A( j, j ) ia1 = offsetA + ( jfirst * strideA2 ); // tracks A( 1, j ) ic = offsetCNORM + ( jfirst * strideCNORM ); // tracks CNORM( j ) for ( j = jfirst; (jinc > 0) ? j <= jlast : j >= jlast; j += jinc ) { + // Compute X( j ) = B( j ) - sum A( k , j ) * X( k ). xj = abs( X[ ix ] ); uscal = tscal; rec = 1.0 / max( xmax, 1.0 ); if ( CNORM[ ic ] > ( bignum - xj ) * rec ) { + // If X( j ) could overflow, scale X by 1 / ( 2 * xmax ). rec *= 0.5; if ( diag === 'non-unit' ) { tjjs = A[ ia ] * tscal; @@ -413,6 +475,7 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X } tjj = abs( tjjs ); if ( tjj > 1.0 ) { + // Divide by A( j, j ) when scaling X if A( j, j ) > 1 rec = min( 1.0, rec * tjj ); uscal /= tjjs; } @@ -423,14 +486,16 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X } } - sumj = 0.0; // HERE + sumj = 0.0; if ( uscal === 1.0 ) { + // If the scaling needed for A in the dot product is 1, call ddot to perform the dot product if ( uplo === 'upper' ) { sumj = ddot( j, A, strideA1, ia1, X, strideX, offsetX ); } else { sumj = ddot( N - ( j + 1 ), A, strideA1, ia + strideA1, X, strideX, ix + strideX ); } } else { + // Otherwise, use in-line code for the dot product if ( uplo === 'upper' ) { ia2 = 0; ix1 = offsetX; @@ -464,10 +529,13 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X } if ( !GOTO ) { + // Compute X( j ) = X( j ) / A( j, j ), scaling if necessary tjj = abs( tjjs ); if ( tjj > smlnum ) { + // abs( A( j, j ) ) > smlnum if ( tjj < 1.0 ) { if ( xj > tjj * bignum ) { + // Scale X by 1 / abs( X( j ) ) rec = 1.0 / xj; dscal( N, rec, X, strideX, offsetX ); scale *= rec; @@ -476,7 +544,9 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X } X[ ix ] /= tjjs; } else if ( tjj > 0.0 ) { + // 0 < abs( A( j, j ) ) <= smlnum if ( xj > tjj * bignum ) { + // Scale X by ( 1 / abs( X( j ) ) ) * abs( A( j, j ) ) * bignum rec = tjj * bignum / xj; dscal( N, rec, X, strideX, offsetX ); xmax *= rec; @@ -484,6 +554,7 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X } X[ ix ] /= tjjs; } else { + // A( j, j ) = 0: Set X( 1 : N ) = 0, X( j ) = 1, and scale = 0, and compute a solution to A^T * X = 0 ix1 = offsetX; for ( i = 0; i < N; i++ ) { X[ ix1 ] = 0.0; @@ -495,6 +566,7 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X } } } else { + // Compute X( j ) := X( j ) / A( j, j ) - sumj if the dot product has already been divided by 1 / A( j, j ) X[ ix ] = ( X[ ix ] / tjjs ) - sumj; } @@ -509,6 +581,7 @@ function dlatrs( uplo, trans, diag, normin, N, A, strideA1, strideA2, offsetA, X scale /= tscal; } + // Scale the column norms by 1 / tscal for return if ( tscal !== 1.0 ) { dscal( N, 1.0 / tscal, CNORM, strideCNORM, offsetCNORM ); } From f526e9cc1e6a3b14a846422a5b9ffc1154928ade Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Mon, 16 Jun 2025 16:39:19 +0000 Subject: [PATCH 31/32] chore: copyright years --- 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: 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: passed - task: lint_license_headers status: passed --- --- lib/node_modules/@stdlib/lapack/base/dlatrs/docs/types/test.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/docs/types/test.ts b/lib/node_modules/@stdlib/lapack/base/dlatrs/docs/types/test.ts index b4e900f64290..18cad3e2259b 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/docs/types/test.ts +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/docs/types/test.ts @@ -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. From 53c5b8fcfc477c5bfa636d2211eb8d0bcf00e098 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Mon, 16 Jun 2025 16:43:37 +0000 Subject: [PATCH 32/32] test: add 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 --- --- lib/node_modules/@stdlib/lapack/base/dlatrs/lib/dlatrs.js | 2 +- lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/dlatrs.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/dlatrs.js index e5591db8309c..24edc341a31b 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/dlatrs.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/lib/dlatrs.js @@ -86,7 +86,7 @@ function dlatrs( order, uplo, trans, diag, normin, N, A, LDA, X, CNORM ) { throw new RangeError( format( 'invalid argument. Sixth argument must be greater than or equal to max(1,%d). Value: `%d`.', N, LDA ) ); } if ( normin !== 'yes' && normin !== 'no' ) { - throw new TypeError( format( 'invalid argument. Fifth argument must be either yes or no. Value: `%d`.', normin ) ); + throw new TypeError( format( 'invalid argument. Fifth argument must be either yes or no. Value: `%s`.', normin ) ); } if ( isColumnMajor( order ) ) { sa1 = 1; diff --git a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js index 4b222bb7ccf7..e6dd76b1e165 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js +++ b/lib/node_modules/@stdlib/lapack/base/dlatrs/test/test.dlatrs.js @@ -291,7 +291,7 @@ tape( 'the function throws an error if provided a fifth argument which is not ye function badValue( value ) { return function badValue() { - dlatrs( value, data.uplo, data.trans, data.diag, data.normin, data.N, A, data.LDA, X, CNORM ); + dlatrs( data.order, data.uplo, data.trans, data.diag, value, data.N, A, data.LDA, X, CNORM ); }; } });