From 516ab115c6d52f727969775cf236a638e018fc04 Mon Sep 17 00:00:00 2001 From: Prajjwal Bajpai Date: Tue, 2 Jun 2026 00:20:16 +0530 Subject: [PATCH 1/2] feat: add `lapack/base/dorml2` --- 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_pkg_readmes status: na - task: lint_markdown_docs status: na - task: lint_markdown status: na - task: lint_package_json status: passed - 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: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/lapack/base/dorml2/lib/base.js | 172 ++++++ .../@stdlib/lapack/base/dorml2/lib/dorml2.js | 146 +++++ .../@stdlib/lapack/base/dorml2/lib/index.js | 64 ++ .../@stdlib/lapack/base/dorml2/lib/main.js | 35 ++ .../@stdlib/lapack/base/dorml2/lib/ndarray.js | 118 ++++ .../@stdlib/lapack/base/dorml2/package.json | 69 +++ .../base/dorml2/test/fixtures/left_col.json | 45 ++ .../base/dorml2/test/fixtures/left_row.json | 45 ++ .../base/dorml2/test/fixtures/right_col.json | 47 ++ .../base/dorml2/test/fixtures/right_row.json | 47 ++ .../base/dorml2/test/fixtures/trans_left.json | 45 ++ .../dorml2/test/fixtures/trans_right.json | 47 ++ .../lapack/base/dorml2/test/test.dorml2.js | 578 ++++++++++++++++++ .../@stdlib/lapack/base/dorml2/test/test.js | 82 +++ 14 files changed, 1540 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/lib/base.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/lib/dorml2.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/lib/index.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/lib/main.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/lib/ndarray.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/package.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/left_col.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/left_row.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/right_col.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/right_row.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/trans_left.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/trans_right.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/test.dorml2.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/test.js diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dorml2/lib/base.js new file mode 100644 index 000000000000..c75c49430105 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/lib/base.js @@ -0,0 +1,172 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +/* eslint-disable max-len, max-params */ + +'use strict'; + +// MODULES // + +var dlarf1f = require( '@stdlib/lapack/base/dlarf1f' ).ndarray; + + +// FUNCTIONS // + +/** +* Tests whether an operation should be applied to the left side. +* +* @private +* @param {string} side - operation side +* @returns {boolean} boolean indicating if an operation should be applied to the left side +*/ +function isLeftSide( side ) { + return side === 'left'; +} + + +// MAIN // + +/** +* Multiply a general matrix by the orthogonal matrix from a LQ factorization determined by `DGELQF`. +* +* ## Notes +* +* - `Q` is a real orthogonal matrix defined as the product of k elementary reflectors, Q = H(k) . . . H(2) H(1) as returned by `DGELQF`. +* +* - `Q` is of order `M` if SIDE = 'left' and of order `N` if SIDE = 'R'. +* +* - `DORML2` overwrites the general real `M` by `N` matrix `C` with, +* +* - `Q * C` if SIDE = 'left' and TRANS = 'no-transpose', or +* - `Q^T* C` if SIDE = 'left' and TRANS = 'transpose', or +* - `C * Q` if SIDE = 'right' and TRANS = 'no-transpose', or +* - `C * Q**T` if SIDE = 'right' and TRANS = 'transpose'. +* +* @private +* @param {string} side - specifies the side of multiplication with `C` +* @param {string} trans - `'no-transpose'` for `Q`, `'transpose'` for `Q^T` +* @param {NonNegativeInteger} M - number of rows of `C` +* @param {NonNegativeInteger} N - number of columns of `C` +* @param {NonNegativeInteger} K - number of elementary reflectors +* @param {Float64Array} A - reflector vectors from `DGELQ2` +* @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} TAU - scalar factors of reflectors +* @param {integer} strideTAU - stride for TAU +* @param {NonNegativeInteger} offsetTAU - starting index for TAU +* @param {Float64Array} C - input/output matrix +* @param {integer} strideC1 - stride of the first dimension of `C` +* @param {integer} strideC2 - stride of the second dimension of `C` +* @param {NonNegativeInteger} offsetC - starting index for `C` +* @param {Float64Array} WORK - workspace array +* @param {integer} strideWORK - stride for `WORK` +* @param {NonNegativeInteger} offsetWORK - starting index for `WORK` +* @returns {integer} status code (0 if successful) +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var A = new Float64Array( [ 1, 0 ] ); +* var TAU = new Float64Array( [ 2 ] ); +* var C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] ); +* var WORK = new Float64Array( 3 ); +* +* var info = dorml2( 'left', 'no-transpose', 2, 3, 1, A, 2, 1, 0, TAU, 1, 0, C, 3, 1, 0, WORK, 1, 0 ); +* // returns 0 +* // C => [ -1, -3, -5, 2, 4, 6 ] +* // WORK => [ 1, 3, 5 ] +*/ +function dorml2( side, trans, M, N, K, A, strideA1, strideA2, offsetA, TAU, strideTAU, offsetTAU, C, strideC1, strideC2, offsetC, WORK, strideWORK, offsetWORK ) { + var isTrans; + var isLeft; + var idx0; + var idx1; + var idx2; + var mi; + var ni; + var ic; + var jc; + var i1; + var i2; + var i3; + var i; + + isLeft = isLeftSide( side ); + isTrans = ( trans === 'transpose' ); + + // Quick return if possible + if ( M === 0 || N === 0 || K === 0 ) { + return 0; + } + + if ( ( isLeft && !isTrans ) || ( !isLeft && isTrans ) ) { + i1 = 0; + i2 = K - 1; + i3 = 1; + } else { + i1 = K - 1; + i2 = 0; + i3 = -1; + } + + if ( isLeft ) { + ni = N; + jc = 0; + + idx0 = offsetA + ( i1*strideA1 ) + ( i1*strideA2 ); + idx1 = offsetTAU + ( i1*strideTAU ); + idx2 = offsetC + ( i1*strideC1 ) + ( jc*strideC2 ); + for ( i = i1; ( i3 > 0 ) ? ( i <= i2 ) : ( i >= i2 ); i += i3 ) { + // Apply H(i) to C(i:M-1, 0:N-1) + mi = M - i; + ic = i; + + // Apply H(i): the reflector vector is row i of A starting at column i, + dlarf1f( side, mi, ni, A, strideA2, idx0, TAU[ idx1 ], C, strideC1, strideC2, idx2, WORK, strideWORK, offsetWORK ); + idx0 += i3*( strideA1 + strideA2 ); + idx1 += i3*strideTAU; + idx2 += i3*strideC1; + } + } else { + mi = M; + ic = 0; + + idx0 = offsetA + ( i1*strideA1 ) + ( i1*strideA2 ); + idx1 = offsetTAU + ( i1*strideTAU ); + idx2 = offsetC + ( ic*strideC1 ) + ( i1*strideC2 ); + for ( i = i1; ( i3 > 0 ) ? ( i <= i2 ) : ( i >= i2 ); i += i3 ) { + // Apply H(i) to C(0:M-1, i:N-1) + ni = N - i; + jc = i; + + // Apply H(i): the reflector vector is row i of A starting at column i, + dlarf1f( side, mi, ni, A, strideA2, idx0, TAU[ idx1 ], C, strideC1, strideC2, idx2, WORK, strideWORK, offsetWORK ); + idx0 += i3*( strideA1 + strideA2 ); + idx1 += i3*strideTAU; + idx2 += i3*strideC2; + } + } + + return 0; +} + + +// EXPORTS // + +module.exports = dorml2; diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/lib/dorml2.js b/lib/node_modules/@stdlib/lapack/base/dorml2/lib/dorml2.js new file mode 100644 index 000000000000..b27da7497ecd --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/lib/dorml2.js @@ -0,0 +1,146 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +/* eslint-disable max-len, max-params */ + +'use strict'; + +// MODULES // + +var isLayout = require( '@stdlib/blas/base/assert/is-layout' ); +var format = require( '@stdlib/string/format' ); +var isOperationSide = require( '@stdlib/blas/base/assert/is-operation-side' ); +var isRowMajor = require( '@stdlib/ndarray/base/assert/is-row-major-string' ); +var isMatrixTranspose = require( '@stdlib/blas/base/assert/is-transpose-operation' ); +var max = require( '@stdlib/math/base/special/fast/max' ); +var base = require( './base.js' ); + + +// MAIN // + +/** +* Multiply a general matrix by the orthogonal matrix from a LQ factorization determined by `DGELQF`. +* +* ## Notes +* +* - `Q` is a real orthogonal matrix defined as the product of k elementary reflectors, Q = H(k) . . . H(2) H(1) as returned by `DGELQF`. +* +* - `Q` is of order `M` if SIDE = 'left' and of order `N` if SIDE = 'R'. +* +* - `DORML2` overwrites the general real `M` by `N` matrix `C` with, +* +* - `Q * C` if SIDE = 'left' and TRANS = 'no-transpose', or +* - `Q^T* C` if SIDE = 'left' and TRANS = 'transpose', or +* - `C * Q` if SIDE = 'right' and TRANS = 'no-transpose', or +* - `C * Q**T` if SIDE = 'right' and TRANS = 'transpose'. +* +* @param {string} order - storage layout +* @param {string} side - specifies the side of multiplication with `C` +* @param {string} trans - `'no-transpose'` for `Q`, `'transpose'` for `Q^T` +* @param {NonNegativeInteger} M - number of rows of `C` +* @param {NonNegativeInteger} N - number of columns of `C` +* @param {NonNegativeInteger} K - number of elementary reflectors +* @param {Float64Array} A - reflector vectors from `DGELQ2` +* @param {integer} LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) +* @param {Float64Array} TAU - scalar factors of reflectors +* @param {Float64Array} C - input/output matrix +* @param {integer} LDC - stride of the first dimension of `C` (a.k.a., leading dimension of the matrix `C`) +* @param {Float64Array} WORK - workspace array +* @throws {TypeError} first argument must be a valid order +* @throws {TypeError} second argument must be a valid side +* @throws {TypeError} third argument must be a valid transpose operation +* @throws {RangeError} fourth argument must be a non-negative integer +* @throws {RangeError} fifth argument must be a non-negative integer +* @throws {RangeError} sixth argument must be a non-negative integer] +* @throws {RangeError} sixth argument must be smaller than the order of `Q` +* @throws {RangeError} sixth argument must be smaller than the order of `Q` +* @throws {RangeError} eighth argument must be greater than or equal to max(1,K) +* @throws {RangeError} eleventh argument must be greater than or equal to max(1,M) +* @returns {integer} status code (0 if successful) +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var A = new Float64Array( [ 1, 0 ] ); +* var TAU = new Float64Array( [ 2 ] ); +* var C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] ); +* var WORK = new Float64Array( 3 ); +* +* var info = dorml2( 'row-major', 'left', 'no-transpose', 2, 3, 1, A, 1, TAU, C, 2, WORK ); +* // returns 0 +* // C => [ -1, -3, -5, 2, 4, 6 ] +* // WORK => [ 1, 3, 5 ] +*/ +function dorml2( order, side, trans, M, N, K, A, LDA, TAU, C, LDC, WORK ) { + var sa1; + var sa2; + var sc1; + var sc2; + + if ( !isLayout( order ) ) { + throw new TypeError( format( 'invalid argument. First argument must be a valid order. Value: `%s`.', order ) ); + } + if ( !isOperationSide( side ) ) { + throw new TypeError( format( 'invalid argument. Second argument must be a valid operation side. Value: `%s`.', side ) ); + } + if ( !isMatrixTranspose( trans ) ) { + throw new TypeError( format( 'invalid argument. Third argument must be a valid transpose operation. Value: `%s`.', trans ) ); + } + if ( M < 0 ) { + throw new RangeError( format( 'invalid argument. Fourth argument must be a nonnegative integer. Value: `%d`.', M ) ); + } + if ( N < 0 ) { + throw new RangeError( format( 'invalid argument. Fifth argument must be a nonnegative integer. Value: `%d`.', N ) ); + } + if ( K < 0 ) { + throw new RangeError( format( 'invalid argument. Sixth argument must be a nonnegative integer. Value: `%d`.', K ) ); + } + if ( side === 'left' && K > M ) { + throw new RangeError( format( 'invalid argument. Sixth argument must be smaller than the order of `Q`. Value: `%d`.', K ) ); + } + if ( side === 'right' && K > N ) { + throw new RangeError( format( 'invalid argument. Sixth argument must be smaller than the order of `Q`. Value: `%d`.', K ) ); + } + if ( isRowMajor( order ) && LDA < max( 1, K ) ) { + throw new RangeError( format( 'invalid argument. Eighth argument must be greater than or equal to max(1,K). Value: `%d`.', LDA ) ); + } + if ( isRowMajor( order ) && LDC < max( 1, M ) ) { + throw new RangeError( format( 'invalid argument. Eleventh argument must be greater than or equal to max(1,M). Value: `%d`.', LDC ) ); + } + if ( order === 'column-major' ) { + sa1 = 1; + sa2 = LDA; + sc1 = 1; + sc2 = LDC; + } else { + if ( side === 'left' ) { + sa1 = M; + } else { + sa1 = N; + } + sa2 = 1; + sc1 = N; + sc2 = 1; + } + return base( side, trans, M, N, K, A, sa1, sa2, 0, TAU, 1, 0, C, sc1, sc2, 0, WORK, 1, 0 ); +} + + +// EXPORTS // + +module.exports = dorml2; diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dorml2/lib/index.js new file mode 100644 index 000000000000..0e26acc1300b --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/lib/index.js @@ -0,0 +1,64 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +/** +* LAPACK routine to multiply a general matrix by the orthogonal matrix from a LQ factorization determined by `DGELQF`. +* +* @module @stdlib/lapack/base/dorml2 +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* var dorml2 = require( '@stdlib/lapack/base/dorml2' ); +* +* var A = new Float64Array( [ 1, 0 ] ); +* var TAU = new Float64Array( [ 2 ] ); +* var C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] ); +* var WORK = new Float64Array( 3 ); +* +* var info = dorml2( 'row-major', 'left', 'no-transpose', 2, 3, 1, A, 1, TAU, C, 2, WORK ); +* // returns 0 +* // C => [ -1, -3, -5, 2, 4, 6 ] +* // WORK => [ 1, 3, 5 ] +*/ + +// 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 dorml2; +var tmp = tryRequire( join( __dirname, './native.js' ) ); +if ( isError( tmp ) ) { + dorml2 = main; +} else { + dorml2 = tmp; +} + + +// EXPORTS // + +module.exports = dorml2; + +// exports: { "ndarray": "dorml2.ndarray" } diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/lib/main.js b/lib/node_modules/@stdlib/lapack/base/dorml2/lib/main.js new file mode 100644 index 000000000000..3c3a731c3712 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/lib/main.js @@ -0,0 +1,35 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' ); +var dorml2 = require( './dorml2.js' ); +var ndarray = require( './ndarray.js' ); + + +// MAIN // + +setReadOnly( dorml2, 'ndarray', ndarray ); + + +// EXPORTS // + +module.exports = dorml2; diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dorml2/lib/ndarray.js new file mode 100644 index 000000000000..d73e9d602702 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/lib/ndarray.js @@ -0,0 +1,118 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +/* eslint-disable max-len, max-params */ + +'use strict'; + +// MODULES // + +var format = require( '@stdlib/string/format' ); +var isOperationSide = require( '@stdlib/blas/base/assert/is-operation-side' ); +var isMatrixTranspose = require( '@stdlib/blas/base/assert/is-transpose-operation' ); +var base = require( './base.js' ); + + +// MAIN // + +/** +* Multiply a general matrix by the orthogonal matrix from a LQ factorization determined by `DGELQF` using alternative indexing semantics. +* +* ## Notes +* +* - `Q` is a real orthogonal matrix defined as the product of k elementary reflectors, Q = H(k) . . . H(2) H(1) as returned by `DGELQF`. +* +* - `Q` is of order `M` if SIDE = 'left' and of order `N` if SIDE = 'R'. +* +* - `DORML2` overwrites the general real `M` by `N` matrix `C` with, +* +* - `Q * C` if SIDE = 'left' and TRANS = 'no-transpose', or +* - `Q^T* C` if SIDE = 'left' and TRANS = 'transpose', or +* - `C * Q` if SIDE = 'right' and TRANS = 'no-transpose', or +* - `C * Q**T` if SIDE = 'right' and TRANS = 'transpose'. +* +* @param {string} side - specifies the side of multiplication with `C` +* @param {string} trans - `'no-transpose'` for `Q`, `'transpose'` for `Q^T` +* @param {NonNegativeInteger} M - number of rows of `C` +* @param {NonNegativeInteger} N - number of columns of `C` +* @param {NonNegativeInteger} K - number of elementary reflectors +* @param {Float64Array} A - reflector vectors from `DGELQ2` +* @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} TAU - scalar factors of reflectors +* @param {integer} strideTAU - stride for TAU +* @param {NonNegativeInteger} offsetTAU - starting index for TAU +* @param {Float64Array} C - input/output matrix +* @param {integer} strideC1 - stride of the first dimension of `C` +* @param {integer} strideC2 - stride of the second dimension of `C` +* @param {NonNegativeInteger} offsetC - starting index for `C` +* @param {Float64Array} WORK - workspace array +* @param {integer} strideWORK - stride for `WORK` +* @param {NonNegativeInteger} offsetWORK - starting index for `WORK` +* @throws {TypeError} first argument must be a valid side +* @throws {TypeError} second argument must be a valid transpose operation +* @throws {RangeError} third argument must be a non-negative integer +* @throws {RangeError} fourth argument must be a non-negative integer +* @throws {RangeError} fifth argument must be a non-negative integer +* @throws {RangeError} fifth argument must be smaller than the order of `Q` +* @throws {RangeError} fifth argument must be smaller than the order of `Q` +* @returns {integer} status code (0 if successful) +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var A = new Float64Array( [ 1, 0 ] ); +* var TAU = new Float64Array( [ 2 ] ); +* var C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] ); +* var WORK = new Float64Array( 3 ); +* +* var info = dorml2( 'left', 'no-transpose', 2, 3, 1, A, 2, 1, 0, TAU, 1, 0, C, 3, 1, 0, WORK, 1, 0 ); +* // returns 0 +* // C => [ -1, -3, -5, 2, 4, 6 ] +* // WORK => [ 1, 3, 5 ] +*/ +function dorml2( side, trans, M, N, K, A, strideA1, strideA2, offsetA, TAU, strideTAU, offsetTAU, C, strideC1, strideC2, offsetC, WORK, strideWORK, offsetWORK ) { + if ( !isOperationSide( side ) ) { + throw new TypeError( format( 'invalid argument. First argument must be a valid operation side. Value: `%s`.', side ) ); + } + if ( !isMatrixTranspose( trans ) ) { + throw new TypeError( format( 'invalid argument. Second argument must be a valid transpose operation. Value: `%s`.', trans ) ); + } + if ( M < 0 ) { + throw new RangeError( format( 'invalid argument. Third argument must be a nonnegative integer. Value: `%d`.', M ) ); + } + if ( N < 0 ) { + throw new RangeError( format( 'invalid argument. Fourth argument must be a nonnegative integer. Value: `%d`.', N ) ); + } + if ( K < 0 ) { + throw new RangeError( format( 'invalid argument. Fifth argument must be a nonnegative integer. Value: `%d`.', K ) ); + } + if ( side === 'left' && K > M ) { + throw new RangeError( format( 'invalid argument. Fifth argument must be smaller than the order of `Q`. Value: `%d`.', K ) ); + } + if ( side === 'right' && K > N ) { + throw new RangeError( format( 'invalid argument. Fifth argument must be smaller than the order of `Q`. Value: `%d`.', K ) ); + } + return base( side, trans, M, N, K, A, strideA1, strideA2, offsetA, TAU, strideTAU, offsetTAU, C, strideC1, strideC2, offsetC, WORK, strideWORK, offsetWORK ); +} + + +// EXPORTS // + +module.exports = dorml2; diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/package.json b/lib/node_modules/@stdlib/lapack/base/dorml2/package.json new file mode 100644 index 000000000000..1f02a411e5f0 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/package.json @@ -0,0 +1,69 @@ +{ + "name": "@stdlib/lapack/base/dorml2", + "version": "0.0.0", + "description": "LAPACK routine to Multiply a general matrix by the orthogonal matrix from a LQ factorization determined by `DGELQF`.", + "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", + "dorml2", + "reflector", + "linear", + "algebra", + "subroutines", + "array", + "ndarray", + "matrix", + "float64", + "double", + "float64array" + ] +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/left_col.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/left_col.json new file mode 100644 index 000000000000..6bc3cba9f0ff --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/left_col.json @@ -0,0 +1,45 @@ +{ + "order": "column-major", + "side": "left", + "trans": "no-transpose", + + "M": 2, + "N": 3, + "K": 1, + + "A": [ 1, 0 ], + "strideA1": 1, + "strideA2": 1, + "offsetA": 0, + "LDA": 1, + "A_mat": [ + [ 1, 0 ] + ], + + "TAU": [ 2 ], + "strideTAU": 1, + "offsetTAU": 0, + + "C": [ 1, 2, 3, 4, 5, 6 ], + "strideC1": 1, + "strideC2": 2, + "offsetC": 0, + "LDC": 2, + "C_mat": [ + [ 1, 3, 5 ], + [ 2, 4, 6 ] + ], + + "WORK": [ 0, 0, 0 ], + "strideWORK": 1, + "offsetWORK": 0, + + "C_out": [ -1, 2, -3, 4, -5, 6 ], + "C_out_mat": [ + [ -1, -3, -5 ], + [ 2, 4, 6 ] + ], + + "WORK_out": [ 1, 3, 5 ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/left_row.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/left_row.json new file mode 100644 index 000000000000..651a81a5503d --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/left_row.json @@ -0,0 +1,45 @@ +{ + "order": "row-major", + "side": "left", + "trans": "no-transpose", + + "M": 2, + "N": 3, + "K": 1, + + "A": [ 1, 0 ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "LDA": 1, + "A_mat": [ + [ 1, 0 ] + ], + + "TAU": [ 2 ], + "strideTAU": 1, + "offsetTAU": 0, + + "C": [ 1, 3, 5, 2, 4, 6 ], + "strideC1": 3, + "strideC2": 1, + "offsetC": 0, + "LDC": 2, + "C_mat": [ + [ 1, 3, 5 ], + [ 2, 4, 6 ] + ], + + "WORK": [ 0, 0, 0 ], + "strideWORK": 1, + "offsetWORK": 0, + + "C_out": [ -1, -3, -5, 2, 4, 6 ], + "C_out_mat": [ + [ -1, -3, -5 ], + [ 2, 4, 6 ] + ], + + "WORK_out": [ 1, 3, 5 ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/right_col.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/right_col.json new file mode 100644 index 000000000000..4fe0bdb04f4d --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/right_col.json @@ -0,0 +1,47 @@ +{ + "order": "column-major", + "side": "right", + "trans": "no-transpose", + + "M": 3, + "N": 2, + "K": 1, + + "A": [ 1, 0 ], + "strideA1": 1, + "strideA2": 1, + "offsetA": 0, + "LDA": 1, + "A_mat": [ + [ 1, 0 ] + ], + + "TAU": [ 2 ], + "strideTAU": 1, + "offsetTAU": 0, + + "C": [ 1, 2, 3, 4, 5, 6 ], + "strideC1": 1, + "strideC2": 3, + "offsetC": 0, + "LDC": 3, + "C_mat": [ + [ 1, 4 ], + [ 2, 5 ], + [ 3, 6 ] + ], + + "WORK": [ 0, 0, 0 ], + "strideWORK": 1, + "offsetWORK": 0, + + "C_out": [ -1, -2, -3, 4, 5, 6 ], + "C_out_mat": [ + [ -1, 4 ], + [ -2, 5 ], + [ -3, 6 ] + ], + + "WORK_out": [ 1, 2, 3 ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/right_row.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/right_row.json new file mode 100644 index 000000000000..c57f8d35df3d --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/right_row.json @@ -0,0 +1,47 @@ +{ + "order": "row-major", + "side": "right", + "trans": "no-transpose", + + "M": 3, + "N": 2, + "K": 1, + + "A": [ 1, 0 ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "LDA": 1, + "A_mat": [ + [ 1, 0 ] + ], + + "TAU": [ 2 ], + "strideTAU": 1, + "offsetTAU": 0, + + "C": [ 1, 4, 2, 5, 3, 6 ], + "strideC1": 2, + "strideC2": 1, + "offsetC": 0, + "LDC": 3, + "C_mat": [ + [ 1, 4 ], + [ 2, 5 ], + [ 3, 6 ] + ], + + "WORK": [ 0, 0, 0 ], + "strideWORK": 1, + "offsetWORK": 0, + + "C_out": [ -1, 4, -2, 5, -3, 6 ], + "C_out_mat": [ + [ -1, 4 ], + [ -2, 5 ], + [ -3, 6 ] + ], + + "WORK_out": [ 1, 2, 3 ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/trans_left.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/trans_left.json new file mode 100644 index 000000000000..2b2209186719 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/trans_left.json @@ -0,0 +1,45 @@ +{ + "order": "row-major", + "side": "left", + "trans": "transpose", + + "M": 2, + "N": 3, + "K": 1, + + "A": [ 1, 0 ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "LDA": 1, + "A_mat": [ + [ 1, 0 ] + ], + + "TAU": [ 2 ], + "strideTAU": 1, + "offsetTAU": 0, + + "C": [ 1, 3, 5, 2, 4, 6 ], + "strideC1": 3, + "strideC2": 1, + "offsetC": 0, + "LDC": 2, + "C_mat": [ + [ 1, 3, 5 ], + [ 2, 4, 6 ] + ], + + "WORK": [ 0, 0, 0 ], + "strideWORK": 1, + "offsetWORK": 0, + + "C_out": [ -1, -3, -5, 2, 4, 6 ], + "C_out_mat": [ + [ -1, -3, -5 ], + [ 2, 4, 6 ] + ], + + "WORK_out": [ 1, 3, 5 ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/trans_right.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/trans_right.json new file mode 100644 index 000000000000..e58743e8313a --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/trans_right.json @@ -0,0 +1,47 @@ +{ + "order": "row-major", + "side": "right", + "trans": "transpose", + + "M": 3, + "N": 2, + "K": 1, + + "A": [ 1, 0 ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "LDA": 1, + "A_mat": [ + [ 1, 0 ] + ], + + "TAU": [ 2 ], + "strideTAU": 1, + "offsetTAU": 0, + + "C": [ 1, 4, 2, 5, 3, 6 ], + "strideC1": 2, + "strideC2": 1, + "offsetC": 0, + "LDC": 3, + "C_mat": [ + [ 1, 4 ], + [ 2, 5 ], + [ 3, 6 ] + ], + + "WORK": [ 0, 0, 0 ], + "strideWORK": 1, + "offsetWORK": 0, + + "C_out": [ -1, 4, -2, 5, -3, 6 ], + "C_out_mat": [ + [ -1, 4 ], + [ -2, 5 ], + [ -3, 6 ] + ], + + "WORK_out": [ 1, 2, 3 ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/test.dorml2.js b/lib/node_modules/@stdlib/lapack/base/dorml2/test/test.dorml2.js new file mode 100644 index 000000000000..01e63dbba790 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/test.dorml2.js @@ -0,0 +1,578 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var Float64Array = require( '@stdlib/array/float64' ); +var isAlmostEqual = require( '@stdlib/assert/is-almost-equal-float64array' ); +var dorml2 = require( './../lib/dorml2.js' ); + + +// FIXTURES // + +var LEFT_ROW = require( './fixtures/left_row.json' ); +var LEFT_COL = require( './fixtures/left_col.json' ); +var RIGHT_ROW = require( './fixtures/right_row.json' ); +var RIGHT_COL = require( './fixtures/right_col.json' ); +var TRANS_LEFT = require( './fixtures/trans_left.json' ); +var TRANS_RIGHT = require( './fixtures/trans_right.json' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof dorml2, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 12', function test( t ) { + t.strictEqual( dorml2.length, 12, '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 WORK; + var TAU; + var A; + var C; + var i; + + A = new Float64Array( [ 1, 0 ] ); + TAU = new Float64Array( [ 2 ] ); + C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] ); + WORK = new Float64Array( 3 ); + + 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() { + dorml2( value, 'left', 'no-transpose', 2, 3, 1, A, 1, TAU, C, 2, WORK ); + }; + } +}); +tape( 'the function throws an error if provided a second argument which is not a valid operation side', function test( t ) { + var values; + var WORK; + var TAU; + var A; + var C; + var i; + + A = new Float64Array( [ 1, 0 ] ); + TAU = new Float64Array( [ 2 ] ); + C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] ); + WORK = new Float64Array( 3 ); + + 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() { + dorml2( 'row-major', value, 'no-transpose', 2, 3, 1, A, 1, TAU, C, 2, WORK ); + }; + } +}); + +tape( 'the function throws an error if provided a third argument which is not a valid transpose operation', function test( t ) { + var values; + var WORK; + var TAU; + var A; + var C; + var i; + + A = new Float64Array( [ 1, 0 ] ); + TAU = new Float64Array( [ 2 ] ); + C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] ); + WORK = new Float64Array( 3 ); + + 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() { + dorml2( 'row-major', 'left', value, 2, 3, 1, A, 1, TAU, C, 2, WORK ); + }; + } +}); + +tape( 'the function throws an error if provided a fourth argument which is smaller than 0', function test( t ) { + var values; + var WORK; + var TAU; + var A; + var C; + var i; + + A = new Float64Array( [ 1, 0 ] ); + TAU = new Float64Array( [ 2 ] ); + C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] ); + WORK = new Float64Array( 3 ); + + values = [ + -1, + -2, + -3 + ]; + + 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() { + dorml2( 'row-major', 'left', 'no-transpose', value, 3, 1, A, 1, TAU, C, 2, WORK ); + }; + } +}); + +tape( 'the function throws an error if provided a fifth argument which is smaller than 0', function test( t ) { + var values; + var WORK; + var TAU; + var A; + var C; + var i; + + A = new Float64Array( [ 1, 0 ] ); + TAU = new Float64Array( [ 2 ] ); + C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] ); + WORK = new Float64Array( 3 ); + + values = [ + -1, + -2, + -3 + ]; + + 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() { + dorml2( 'row-major', 'left', 'no-transpose', 2, value, 1, A, 1, TAU, C, 2, WORK ); + }; + } +}); + +tape( 'the function throws an error if provided a sixth argument which is smaller than 0', function test( t ) { + var values; + var WORK; + var TAU; + var A; + var C; + var i; + + A = new Float64Array( [ 1, 0 ] ); + TAU = new Float64Array( [ 2 ] ); + C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] ); + WORK = new Float64Array( 3 ); + + values = [ + -1, + -2, + -3 + ]; + + 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() { + dorml2( 'row-major', 'left', 'no-transpose', 2, 3, value, A, 1, TAU, C, 2, WORK ); + }; + } +}); + +tape( 'the function throws an error if provided a sixth argument which is larger than the order of `Q` (left)', function test( t ) { + var values; + var WORK; + var TAU; + var A; + var C; + var i; + + A = new Float64Array( [ 1, 0 ] ); + TAU = new Float64Array( [ 2 ] ); + C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] ); + WORK = new Float64Array( 3 ); + + values = [ + 3, + 4, + 5 + ]; + + 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() { + dorml2( 'row-major', 'left', 'no-transpose', 2, 3, value, A, 1, TAU, C, 2, WORK ); + }; + } +}); + +tape( 'the function throws an error if provided a sixth argument which is larger than the order of `Q` (right)', function test( t ) { + var values; + var WORK; + var TAU; + var A; + var C; + var i; + + A = new Float64Array( [ 1, 0 ] ); + TAU = new Float64Array( [ 2 ] ); + C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] ); + WORK = new Float64Array( 3 ); + + values = [ + 4, + 5, + 6 + ]; + + 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() { + dorml2( 'row-major', 'right', 'no-transpose', 2, 3, value, A, 1, TAU, C, 2, WORK ); + }; + } +}); + +tape( 'the function throws an error if provided an eighth argument which is not a valid LDA value', function test( t ) { + var values; + var WORK; + var TAU; + var A; + var C; + var i; + + A = new Float64Array( [ 1, 0 ] ); + TAU = new Float64Array( [ 2 ] ); + C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] ); + WORK = new Float64Array( 3 ); + + 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() { + dorml2( 'row-major', 'left', 'no-transpose', 2, 3, 1, A, value, TAU, C, 2, WORK ); + }; + } +}); + +tape( 'the function throws an error if provided an eleventh argument which is not a valid LDC value', function test( t ) { + var values; + var WORK; + var TAU; + var A; + var C; + var i; + + A = new Float64Array( [ 1, 0 ] ); + TAU = new Float64Array( [ 2 ] ); + C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] ); + WORK = new Float64Array( 3 ); + + values = [ + 1, + 0, + -1 + ]; + + 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() { + dorml2( 'row-major', 'left', 'no-transpose', 2, 3, 1, A, 1, TAU, C, value, WORK ); + }; + } +}); + +tape( 'the function quick returns when `M`, `N` or `K` is equal to 0', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = LEFT_ROW; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C ); + expectedWORK = new Float64Array( data.WORK ); + + info = dorml2( data.order, data.side, data.trans, 0, 0, 0, A, data.LDA, TAU, C, data.LDC, WORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (left, row-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = LEFT_ROW; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.order, data.side, data.trans, data.M, data.N, data.K, A, data.LDA, TAU, C, data.LDC, WORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (left, column-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = LEFT_COL; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.order, data.side, data.trans, data.M, data.N, data.K, A, data.LDA, TAU, C, data.LDC, WORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (right, row-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = RIGHT_ROW; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.order, data.side, data.trans, data.M, data.N, data.K, A, data.LDA, TAU, C, data.LDC, WORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (right, column-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = RIGHT_COL; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.order, data.side, data.trans, data.M, data.N, data.K, A, data.LDA, TAU, C, data.LDC, WORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (left, row-major, trans)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = TRANS_LEFT; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.order, data.side, data.trans, data.M, data.N, data.K, A, data.LDA, TAU, C, data.LDC, WORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (right, row-major, trans)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = TRANS_RIGHT; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.order, data.side, data.trans, data.M, data.N, data.K, A, data.LDA, TAU, C, data.LDC, WORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/test.js b/lib/node_modules/@stdlib/lapack/base/dorml2/test/test.js new file mode 100644 index 000000000000..712d3e1efffc --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/test.js @@ -0,0 +1,82 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var proxyquire = require( 'proxyquire' ); +var IS_BROWSER = require( '@stdlib/assert/is-browser' ); +var dorml2 = 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 dorml2, '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 dorml2.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 dorml2 = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire + }); + + t.strictEqual( dorml2, 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 dorml2; + var main; + + main = require( './../lib/dorml2.js' ); + + dorml2 = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire + }); + + t.strictEqual( dorml2, main, 'returns expected value' ); + t.end(); + + function tryRequire() { + return new Error( 'Cannot find module' ); + } +}); From 0bb4e0e7c1c5c7624c11bfd5d9a404725c570e8d Mon Sep 17 00:00:00 2001 From: Prajjwal Bajpai Date: Tue, 2 Jun 2026 19:30:41 +0530 Subject: [PATCH 2/2] test: add tests for `ndarray` API --- 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_pkg_readmes status: na - task: lint_markdown_docs status: na - 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: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../test/fixtures/large_strides/left_col.json | 105 ++ .../test/fixtures/large_strides/left_row.json | 105 ++ .../fixtures/large_strides/right_col.json | 109 ++ .../fixtures/large_strides/right_row.json | 109 ++ .../fixtures/large_strides/trans_left.json | 105 ++ .../fixtures/large_strides/trans_right.json | 109 ++ .../test/fixtures/mixed_strides/left_col.json | 84 ++ .../test/fixtures/mixed_strides/left_row.json | 84 ++ .../fixtures/mixed_strides/right_col.json | 88 ++ .../fixtures/mixed_strides/right_row.json | 88 ++ .../fixtures/mixed_strides/trans_left.json | 84 ++ .../fixtures/mixed_strides/trans_right.json | 88 ++ .../fixtures/negative_strides/left_col.json | 84 ++ .../fixtures/negative_strides/left_row.json | 84 ++ .../fixtures/negative_strides/right_col.json | 88 ++ .../fixtures/negative_strides/right_row.json | 88 ++ .../fixtures/negative_strides/trans_left.json | 84 ++ .../negative_strides/trans_right.json | 88 ++ .../test/fixtures/offsets/left_col.json | 90 ++ .../test/fixtures/offsets/left_row.json | 90 ++ .../test/fixtures/offsets/right_col.json | 94 ++ .../test/fixtures/offsets/right_row.json | 94 ++ .../test/fixtures/offsets/trans_left.json | 90 ++ .../test/fixtures/offsets/trans_right.json | 94 ++ .../lapack/base/dorml2/test/test.dorml2.js | 1 + .../lapack/base/dorml2/test/test.ndarray.js | 1148 +++++++++++++++++ 26 files changed, 3375 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/left_col.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/left_row.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/right_col.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/right_row.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/trans_left.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/trans_right.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/left_col.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/left_row.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/right_col.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/right_row.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/trans_left.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/trans_right.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/left_col.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/left_row.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/right_col.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/right_row.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/trans_left.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/trans_right.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/left_col.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/left_row.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/right_col.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/right_row.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/trans_left.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/trans_right.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dorml2/test/test.ndarray.js diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/left_col.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/left_col.json new file mode 100644 index 000000000000..6a9d6c570a79 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/left_col.json @@ -0,0 +1,105 @@ +{ + "order": "column-major", + "side": "left", + "trans": "no-transpose", + "M": 2, + "N": 3, + "K": 1, + "A": [ + 1, + 9999, + 0, + 9999 + ], + "strideA1": 2, + "strideA2": 2, + "offsetA": 0, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 2, + 9999 + ], + "strideTAU": 2, + "offsetTAU": 0, + "C": [ + 1, + 9999, + 2, + 9999, + 3, + 9999, + 4, + 9999, + 5, + 9999, + 6, + 9999 + ], + "strideC1": 2, + "strideC2": 4, + "offsetC": 0, + "LDC": 2, + "C_mat": [ + [ + 1, + 3, + 5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideWORK": 2, + "offsetWORK": 0, + "C_out": [ + -1, + 9999, + 2, + 9999, + -3, + 9999, + 4, + 9999, + -5, + 9999, + 6, + 9999 + ], + "C_out_mat": [ + [ + -1, + -3, + -5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK_out": [ + 1, + 9999, + 3, + 9999, + 5, + 9999 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/left_row.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/left_row.json new file mode 100644 index 000000000000..7d2d3841a741 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/left_row.json @@ -0,0 +1,105 @@ +{ + "order": "row-major", + "side": "left", + "trans": "no-transpose", + "M": 2, + "N": 3, + "K": 1, + "A": [ + 1, + 9999, + 0, + 9999 + ], + "strideA1": 4, + "strideA2": 2, + "offsetA": 0, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 2, + 9999 + ], + "strideTAU": 2, + "offsetTAU": 0, + "C": [ + 1, + 9999, + 3, + 9999, + 5, + 9999, + 2, + 9999, + 4, + 9999, + 6, + 9999 + ], + "strideC1": 6, + "strideC2": 2, + "offsetC": 0, + "LDC": 2, + "C_mat": [ + [ + 1, + 3, + 5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideWORK": 2, + "offsetWORK": 0, + "C_out": [ + -1, + 9999, + -3, + 9999, + -5, + 9999, + 2, + 9999, + 4, + 9999, + 6, + 9999 + ], + "C_out_mat": [ + [ + -1, + -3, + -5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK_out": [ + 1, + 9999, + 3, + 9999, + 5, + 9999 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/right_col.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/right_col.json new file mode 100644 index 000000000000..8f74648d55ca --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/right_col.json @@ -0,0 +1,109 @@ +{ + "order": "column-major", + "side": "right", + "trans": "no-transpose", + "M": 3, + "N": 2, + "K": 1, + "A": [ + 1, + 9999, + 0, + 9999 + ], + "strideA1": 2, + "strideA2": 2, + "offsetA": 0, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 2, + 9999 + ], + "strideTAU": 2, + "offsetTAU": 0, + "C": [ + 1, + 9999, + 2, + 9999, + 3, + 9999, + 4, + 9999, + 5, + 9999, + 6, + 9999 + ], + "strideC1": 2, + "strideC2": 6, + "offsetC": 0, + "LDC": 3, + "C_mat": [ + [ + 1, + 4 + ], + [ + 2, + 5 + ], + [ + 3, + 6 + ] + ], + "WORK": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideWORK": 2, + "offsetWORK": 0, + "C_out": [ + -1, + 9999, + -2, + 9999, + -3, + 9999, + 4, + 9999, + 5, + 9999, + 6, + 9999 + ], + "C_out_mat": [ + [ + -1, + 4 + ], + [ + -2, + 5 + ], + [ + -3, + 6 + ] + ], + "WORK_out": [ + 1, + 9999, + 2, + 9999, + 3, + 9999 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/right_row.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/right_row.json new file mode 100644 index 000000000000..a627bb0bf872 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/right_row.json @@ -0,0 +1,109 @@ +{ + "order": "row-major", + "side": "right", + "trans": "no-transpose", + "M": 3, + "N": 2, + "K": 1, + "A": [ + 1, + 9999, + 0, + 9999 + ], + "strideA1": 4, + "strideA2": 2, + "offsetA": 0, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 2, + 9999 + ], + "strideTAU": 2, + "offsetTAU": 0, + "C": [ + 1, + 9999, + 4, + 9999, + 2, + 9999, + 5, + 9999, + 3, + 9999, + 6, + 9999 + ], + "strideC1": 4, + "strideC2": 2, + "offsetC": 0, + "LDC": 3, + "C_mat": [ + [ + 1, + 4 + ], + [ + 2, + 5 + ], + [ + 3, + 6 + ] + ], + "WORK": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideWORK": 2, + "offsetWORK": 0, + "C_out": [ + -1, + 9999, + 4, + 9999, + -2, + 9999, + 5, + 9999, + -3, + 9999, + 6, + 9999 + ], + "C_out_mat": [ + [ + -1, + 4 + ], + [ + -2, + 5 + ], + [ + -3, + 6 + ] + ], + "WORK_out": [ + 1, + 9999, + 2, + 9999, + 3, + 9999 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/trans_left.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/trans_left.json new file mode 100644 index 000000000000..fc289c49ac8a --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/trans_left.json @@ -0,0 +1,105 @@ +{ + "order": "row-major", + "side": "left", + "trans": "transpose", + "M": 2, + "N": 3, + "K": 1, + "A": [ + 1, + 9999, + 0, + 9999 + ], + "strideA1": 4, + "strideA2": 2, + "offsetA": 0, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 2, + 9999 + ], + "strideTAU": 2, + "offsetTAU": 0, + "C": [ + 1, + 9999, + 3, + 9999, + 5, + 9999, + 2, + 9999, + 4, + 9999, + 6, + 9999 + ], + "strideC1": 6, + "strideC2": 2, + "offsetC": 0, + "LDC": 2, + "C_mat": [ + [ + 1, + 3, + 5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideWORK": 2, + "offsetWORK": 0, + "C_out": [ + -1, + 9999, + -3, + 9999, + -5, + 9999, + 2, + 9999, + 4, + 9999, + 6, + 9999 + ], + "C_out_mat": [ + [ + -1, + -3, + -5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK_out": [ + 1, + 9999, + 3, + 9999, + 5, + 9999 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/trans_right.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/trans_right.json new file mode 100644 index 000000000000..f0df7a38870a --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/large_strides/trans_right.json @@ -0,0 +1,109 @@ +{ + "order": "row-major", + "side": "right", + "trans": "transpose", + "M": 3, + "N": 2, + "K": 1, + "A": [ + 1, + 9999, + 0, + 9999 + ], + "strideA1": 4, + "strideA2": 2, + "offsetA": 0, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 2, + 9999 + ], + "strideTAU": 2, + "offsetTAU": 0, + "C": [ + 1, + 9999, + 4, + 9999, + 2, + 9999, + 5, + 9999, + 3, + 9999, + 6, + 9999 + ], + "strideC1": 4, + "strideC2": 2, + "offsetC": 0, + "LDC": 3, + "C_mat": [ + [ + 1, + 4 + ], + [ + 2, + 5 + ], + [ + 3, + 6 + ] + ], + "WORK": [ + 0, + 9999, + 0, + 9999, + 0, + 9999 + ], + "strideWORK": 2, + "offsetWORK": 0, + "C_out": [ + -1, + 9999, + 4, + 9999, + -2, + 9999, + 5, + 9999, + -3, + 9999, + 6, + 9999 + ], + "C_out_mat": [ + [ + -1, + 4 + ], + [ + -2, + 5 + ], + [ + -3, + 6 + ] + ], + "WORK_out": [ + 1, + 9999, + 2, + 9999, + 3, + 9999 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/left_col.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/left_col.json new file mode 100644 index 000000000000..7462ce9a9200 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/left_col.json @@ -0,0 +1,84 @@ +{ + "order": "column-major", + "side": "left", + "trans": "no-transpose", + "M": 2, + "N": 3, + "K": 1, + "A": [ + 1, + 0 + ], + "strideA1": 1, + "strideA2": 1, + "offsetA": 0, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 2 + ], + "strideTAU": 1, + "offsetTAU": 0, + "C": [ + 5, + 6, + 3, + 4, + 1, + 2 + ], + "strideC1": 1, + "strideC2": -2, + "offsetC": 4, + "LDC": 2, + "C_mat": [ + [ + 1, + 3, + 5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK": [ + 0, + 0, + 0 + ], + "strideWORK": 1, + "offsetWORK": 0, + "C_out": [ + -5, + 6, + -3, + 4, + -1, + 2 + ], + "C_out_mat": [ + [ + -1, + -3, + -5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK_out": [ + 1, + 3, + 5 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/left_row.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/left_row.json new file mode 100644 index 000000000000..70bffe49566a --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/left_row.json @@ -0,0 +1,84 @@ +{ + "order": "row-major", + "side": "left", + "trans": "no-transpose", + "M": 2, + "N": 3, + "K": 1, + "A": [ + 1, + 0 + ], + "strideA1": -2, + "strideA2": 1, + "offsetA": 0, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 2 + ], + "strideTAU": 1, + "offsetTAU": 0, + "C": [ + 2, + 4, + 6, + 1, + 3, + 5 + ], + "strideC1": -3, + "strideC2": 1, + "offsetC": 3, + "LDC": 2, + "C_mat": [ + [ + 1, + 3, + 5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK": [ + 0, + 0, + 0 + ], + "strideWORK": 1, + "offsetWORK": 0, + "C_out": [ + 2, + 4, + 6, + -1, + -3, + -5 + ], + "C_out_mat": [ + [ + -1, + -3, + -5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK_out": [ + 1, + 3, + 5 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/right_col.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/right_col.json new file mode 100644 index 000000000000..3f31de110ea3 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/right_col.json @@ -0,0 +1,88 @@ +{ + "order": "column-major", + "side": "right", + "trans": "no-transpose", + "M": 3, + "N": 2, + "K": 1, + "A": [ + 1, + 0 + ], + "strideA1": 1, + "strideA2": 1, + "offsetA": 0, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 2 + ], + "strideTAU": 1, + "offsetTAU": 0, + "C": [ + 4, + 5, + 6, + 1, + 2, + 3 + ], + "strideC1": 1, + "strideC2": -3, + "offsetC": 3, + "LDC": 3, + "C_mat": [ + [ + 1, + 4 + ], + [ + 2, + 5 + ], + [ + 3, + 6 + ] + ], + "WORK": [ + 0, + 0, + 0 + ], + "strideWORK": 1, + "offsetWORK": 0, + "C_out": [ + 4, + 5, + 6, + -1, + -2, + -3 + ], + "C_out_mat": [ + [ + -1, + 4 + ], + [ + -2, + 5 + ], + [ + -3, + 6 + ] + ], + "WORK_out": [ + 1, + 2, + 3 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/right_row.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/right_row.json new file mode 100644 index 000000000000..c1ed19903c5c --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/right_row.json @@ -0,0 +1,88 @@ +{ + "order": "row-major", + "side": "right", + "trans": "no-transpose", + "M": 3, + "N": 2, + "K": 1, + "A": [ + 1, + 0 + ], + "strideA1": -2, + "strideA2": 1, + "offsetA": 0, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 2 + ], + "strideTAU": 1, + "offsetTAU": 0, + "C": [ + 3, + 6, + 2, + 5, + 1, + 4 + ], + "strideC1": -2, + "strideC2": 1, + "offsetC": 4, + "LDC": 3, + "C_mat": [ + [ + 1, + 4 + ], + [ + 2, + 5 + ], + [ + 3, + 6 + ] + ], + "WORK": [ + 0, + 0, + 0 + ], + "strideWORK": 1, + "offsetWORK": 0, + "C_out": [ + -3, + 6, + -2, + 5, + -1, + 4 + ], + "C_out_mat": [ + [ + -1, + 4 + ], + [ + -2, + 5 + ], + [ + -3, + 6 + ] + ], + "WORK_out": [ + 1, + 2, + 3 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/trans_left.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/trans_left.json new file mode 100644 index 000000000000..54a819df8f2b --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/trans_left.json @@ -0,0 +1,84 @@ +{ + "order": "row-major", + "side": "left", + "trans": "transpose", + "M": 2, + "N": 3, + "K": 1, + "A": [ + 1, + 0 + ], + "strideA1": -2, + "strideA2": 1, + "offsetA": 0, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 2 + ], + "strideTAU": 1, + "offsetTAU": 0, + "C": [ + 2, + 4, + 6, + 1, + 3, + 5 + ], + "strideC1": -3, + "strideC2": 1, + "offsetC": 3, + "LDC": 2, + "C_mat": [ + [ + 1, + 3, + 5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK": [ + 0, + 0, + 0 + ], + "strideWORK": 1, + "offsetWORK": 0, + "C_out": [ + 2, + 4, + 6, + -1, + -3, + -5 + ], + "C_out_mat": [ + [ + -1, + -3, + -5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK_out": [ + 1, + 3, + 5 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/trans_right.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/trans_right.json new file mode 100644 index 000000000000..8d1542f7a55f --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/mixed_strides/trans_right.json @@ -0,0 +1,88 @@ +{ + "order": "row-major", + "side": "right", + "trans": "transpose", + "M": 3, + "N": 2, + "K": 1, + "A": [ + 1, + 0 + ], + "strideA1": -2, + "strideA2": 1, + "offsetA": 0, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 2 + ], + "strideTAU": 1, + "offsetTAU": 0, + "C": [ + 3, + 6, + 2, + 5, + 1, + 4 + ], + "strideC1": -2, + "strideC2": 1, + "offsetC": 4, + "LDC": 3, + "C_mat": [ + [ + 1, + 4 + ], + [ + 2, + 5 + ], + [ + 3, + 6 + ] + ], + "WORK": [ + 0, + 0, + 0 + ], + "strideWORK": 1, + "offsetWORK": 0, + "C_out": [ + -3, + 6, + -2, + 5, + -1, + 4 + ], + "C_out_mat": [ + [ + -1, + 4 + ], + [ + -2, + 5 + ], + [ + -3, + 6 + ] + ], + "WORK_out": [ + 1, + 2, + 3 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/left_col.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/left_col.json new file mode 100644 index 000000000000..ee6a38e72e06 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/left_col.json @@ -0,0 +1,84 @@ +{ + "order": "column-major", + "side": "left", + "trans": "no-transpose", + "M": 2, + "N": 3, + "K": 1, + "A": [ + 0, + 1 + ], + "strideA1": -1, + "strideA2": -1, + "offsetA": 1, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 2 + ], + "strideTAU": -1, + "offsetTAU": 0, + "C": [ + 6, + 5, + 4, + 3, + 2, + 1 + ], + "strideC1": -1, + "strideC2": -2, + "offsetC": 5, + "LDC": 2, + "C_mat": [ + [ + 1, + 3, + 5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK": [ + 0, + 0, + 0 + ], + "strideWORK": -1, + "offsetWORK": 2, + "C_out": [ + 6, + -5, + 4, + -3, + 2, + -1 + ], + "C_out_mat": [ + [ + -1, + -3, + -5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK_out": [ + 5, + 3, + 1 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/left_row.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/left_row.json new file mode 100644 index 000000000000..dfb9b01a0917 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/left_row.json @@ -0,0 +1,84 @@ +{ + "order": "row-major", + "side": "left", + "trans": "no-transpose", + "M": 2, + "N": 3, + "K": 1, + "A": [ + 0, + 1 + ], + "strideA1": -2, + "strideA2": -1, + "offsetA": 1, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 2 + ], + "strideTAU": -1, + "offsetTAU": 0, + "C": [ + 6, + 4, + 2, + 5, + 3, + 1 + ], + "strideC1": -3, + "strideC2": -1, + "offsetC": 5, + "LDC": 2, + "C_mat": [ + [ + 1, + 3, + 5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK": [ + 0, + 0, + 0 + ], + "strideWORK": -1, + "offsetWORK": 2, + "C_out": [ + 6, + 4, + 2, + -5, + -3, + -1 + ], + "C_out_mat": [ + [ + -1, + -3, + -5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK_out": [ + 5, + 3, + 1 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/right_col.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/right_col.json new file mode 100644 index 000000000000..8a0a76b10361 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/right_col.json @@ -0,0 +1,88 @@ +{ + "order": "column-major", + "side": "right", + "trans": "no-transpose", + "M": 3, + "N": 2, + "K": 1, + "A": [ + 0, + 1 + ], + "strideA1": -1, + "strideA2": -1, + "offsetA": 1, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 2 + ], + "strideTAU": -1, + "offsetTAU": 0, + "C": [ + 6, + 5, + 4, + 3, + 2, + 1 + ], + "strideC1": -1, + "strideC2": -3, + "offsetC": 5, + "LDC": 3, + "C_mat": [ + [ + 1, + 4 + ], + [ + 2, + 5 + ], + [ + 3, + 6 + ] + ], + "WORK": [ + 0, + 0, + 0 + ], + "strideWORK": -1, + "offsetWORK": 2, + "C_out": [ + 6, + 5, + 4, + -3, + -2, + -1 + ], + "C_out_mat": [ + [ + -1, + 4 + ], + [ + -2, + 5 + ], + [ + -3, + 6 + ] + ], + "WORK_out": [ + 3, + 2, + 1 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/right_row.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/right_row.json new file mode 100644 index 000000000000..e4f5f796c9f9 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/right_row.json @@ -0,0 +1,88 @@ +{ + "order": "row-major", + "side": "right", + "trans": "no-transpose", + "M": 3, + "N": 2, + "K": 1, + "A": [ + 0, + 1 + ], + "strideA1": -2, + "strideA2": -1, + "offsetA": 1, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 2 + ], + "strideTAU": -1, + "offsetTAU": 0, + "C": [ + 6, + 3, + 5, + 2, + 4, + 1 + ], + "strideC1": -2, + "strideC2": -1, + "offsetC": 5, + "LDC": 3, + "C_mat": [ + [ + 1, + 4 + ], + [ + 2, + 5 + ], + [ + 3, + 6 + ] + ], + "WORK": [ + 0, + 0, + 0 + ], + "strideWORK": -1, + "offsetWORK": 2, + "C_out": [ + 6, + -3, + 5, + -2, + 4, + -1 + ], + "C_out_mat": [ + [ + -1, + 4 + ], + [ + -2, + 5 + ], + [ + -3, + 6 + ] + ], + "WORK_out": [ + 3, + 2, + 1 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/trans_left.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/trans_left.json new file mode 100644 index 000000000000..0919fa0485a9 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/trans_left.json @@ -0,0 +1,84 @@ +{ + "order": "row-major", + "side": "left", + "trans": "transpose", + "M": 2, + "N": 3, + "K": 1, + "A": [ + 0, + 1 + ], + "strideA1": -2, + "strideA2": -1, + "offsetA": 1, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 2 + ], + "strideTAU": -1, + "offsetTAU": 0, + "C": [ + 6, + 4, + 2, + 5, + 3, + 1 + ], + "strideC1": -3, + "strideC2": -1, + "offsetC": 5, + "LDC": 2, + "C_mat": [ + [ + 1, + 3, + 5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK": [ + 0, + 0, + 0 + ], + "strideWORK": -1, + "offsetWORK": 2, + "C_out": [ + 6, + 4, + 2, + -5, + -3, + -1 + ], + "C_out_mat": [ + [ + -1, + -3, + -5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK_out": [ + 5, + 3, + 1 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/trans_right.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/trans_right.json new file mode 100644 index 000000000000..c498499aaca9 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/negative_strides/trans_right.json @@ -0,0 +1,88 @@ +{ + "order": "row-major", + "side": "right", + "trans": "transpose", + "M": 3, + "N": 2, + "K": 1, + "A": [ + 0, + 1 + ], + "strideA1": -2, + "strideA2": -1, + "offsetA": 1, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 2 + ], + "strideTAU": -1, + "offsetTAU": 0, + "C": [ + 6, + 3, + 5, + 2, + 4, + 1 + ], + "strideC1": -2, + "strideC2": -1, + "offsetC": 5, + "LDC": 3, + "C_mat": [ + [ + 1, + 4 + ], + [ + 2, + 5 + ], + [ + 3, + 6 + ] + ], + "WORK": [ + 0, + 0, + 0 + ], + "strideWORK": -1, + "offsetWORK": 2, + "C_out": [ + 6, + -3, + 5, + -2, + 4, + -1 + ], + "C_out_mat": [ + [ + -1, + 4 + ], + [ + -2, + 5 + ], + [ + -3, + 6 + ] + ], + "WORK_out": [ + 3, + 2, + 1 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/left_col.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/left_col.json new file mode 100644 index 000000000000..fb3f82843929 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/left_col.json @@ -0,0 +1,90 @@ +{ + "order": "column-major", + "side": "left", + "trans": "no-transpose", + "M": 2, + "N": 3, + "K": 1, + "A": [ + 9999, + 1, + 0 + ], + "strideA1": 1, + "strideA2": 1, + "offsetA": 1, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 9999, + 2 + ], + "strideTAU": 1, + "offsetTAU": 1, + "C": [ + 9999, + 1, + 2, + 3, + 4, + 5, + 6 + ], + "strideC1": 1, + "strideC2": 2, + "offsetC": 1, + "LDC": 2, + "C_mat": [ + [ + 1, + 3, + 5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK": [ + 9999, + 0, + 0, + 0 + ], + "strideWORK": 1, + "offsetWORK": 1, + "C_out": [ + 9999, + -1, + 2, + -3, + 4, + -5, + 6 + ], + "C_out_mat": [ + [ + -1, + -3, + -5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK_out": [ + 9999, + 1, + 3, + 5 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/left_row.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/left_row.json new file mode 100644 index 000000000000..ebf0a045975c --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/left_row.json @@ -0,0 +1,90 @@ +{ + "order": "row-major", + "side": "left", + "trans": "no-transpose", + "M": 2, + "N": 3, + "K": 1, + "A": [ + 9999, + 1, + 0 + ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 1, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 9999, + 2 + ], + "strideTAU": 1, + "offsetTAU": 1, + "C": [ + 9999, + 1, + 3, + 5, + 2, + 4, + 6 + ], + "strideC1": 3, + "strideC2": 1, + "offsetC": 1, + "LDC": 2, + "C_mat": [ + [ + 1, + 3, + 5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK": [ + 9999, + 0, + 0, + 0 + ], + "strideWORK": 1, + "offsetWORK": 1, + "C_out": [ + 9999, + -1, + -3, + -5, + 2, + 4, + 6 + ], + "C_out_mat": [ + [ + -1, + -3, + -5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK_out": [ + 9999, + 1, + 3, + 5 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/right_col.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/right_col.json new file mode 100644 index 000000000000..6009edc10ca0 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/right_col.json @@ -0,0 +1,94 @@ +{ + "order": "column-major", + "side": "right", + "trans": "no-transpose", + "M": 3, + "N": 2, + "K": 1, + "A": [ + 9999, + 1, + 0 + ], + "strideA1": 1, + "strideA2": 1, + "offsetA": 1, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 9999, + 2 + ], + "strideTAU": 1, + "offsetTAU": 1, + "C": [ + 9999, + 1, + 2, + 3, + 4, + 5, + 6 + ], + "strideC1": 1, + "strideC2": 3, + "offsetC": 1, + "LDC": 3, + "C_mat": [ + [ + 1, + 4 + ], + [ + 2, + 5 + ], + [ + 3, + 6 + ] + ], + "WORK": [ + 9999, + 0, + 0, + 0 + ], + "strideWORK": 1, + "offsetWORK": 1, + "C_out": [ + 9999, + -1, + -2, + -3, + 4, + 5, + 6 + ], + "C_out_mat": [ + [ + -1, + 4 + ], + [ + -2, + 5 + ], + [ + -3, + 6 + ] + ], + "WORK_out": [ + 9999, + 1, + 2, + 3 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/right_row.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/right_row.json new file mode 100644 index 000000000000..f7370211e158 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/right_row.json @@ -0,0 +1,94 @@ +{ + "order": "row-major", + "side": "right", + "trans": "no-transpose", + "M": 3, + "N": 2, + "K": 1, + "A": [ + 9999, + 1, + 0 + ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 1, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 9999, + 2 + ], + "strideTAU": 1, + "offsetTAU": 1, + "C": [ + 9999, + 1, + 4, + 2, + 5, + 3, + 6 + ], + "strideC1": 2, + "strideC2": 1, + "offsetC": 1, + "LDC": 3, + "C_mat": [ + [ + 1, + 4 + ], + [ + 2, + 5 + ], + [ + 3, + 6 + ] + ], + "WORK": [ + 9999, + 0, + 0, + 0 + ], + "strideWORK": 1, + "offsetWORK": 1, + "C_out": [ + 9999, + -1, + 4, + -2, + 5, + -3, + 6 + ], + "C_out_mat": [ + [ + -1, + 4 + ], + [ + -2, + 5 + ], + [ + -3, + 6 + ] + ], + "WORK_out": [ + 9999, + 1, + 2, + 3 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/trans_left.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/trans_left.json new file mode 100644 index 000000000000..e607ee116708 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/trans_left.json @@ -0,0 +1,90 @@ +{ + "order": "row-major", + "side": "left", + "trans": "transpose", + "M": 2, + "N": 3, + "K": 1, + "A": [ + 9999, + 1, + 0 + ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 1, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 9999, + 2 + ], + "strideTAU": 1, + "offsetTAU": 1, + "C": [ + 9999, + 1, + 3, + 5, + 2, + 4, + 6 + ], + "strideC1": 3, + "strideC2": 1, + "offsetC": 1, + "LDC": 2, + "C_mat": [ + [ + 1, + 3, + 5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK": [ + 9999, + 0, + 0, + 0 + ], + "strideWORK": 1, + "offsetWORK": 1, + "C_out": [ + 9999, + -1, + -3, + -5, + 2, + 4, + 6 + ], + "C_out_mat": [ + [ + -1, + -3, + -5 + ], + [ + 2, + 4, + 6 + ] + ], + "WORK_out": [ + 9999, + 1, + 3, + 5 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/trans_right.json b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/trans_right.json new file mode 100644 index 000000000000..42c7b2b095f9 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/fixtures/offsets/trans_right.json @@ -0,0 +1,94 @@ +{ + "order": "row-major", + "side": "right", + "trans": "transpose", + "M": 3, + "N": 2, + "K": 1, + "A": [ + 9999, + 1, + 0 + ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 1, + "LDA": 1, + "A_mat": [ + [ + 1, + 0 + ] + ], + "TAU": [ + 9999, + 2 + ], + "strideTAU": 1, + "offsetTAU": 1, + "C": [ + 9999, + 1, + 4, + 2, + 5, + 3, + 6 + ], + "strideC1": 2, + "strideC2": 1, + "offsetC": 1, + "LDC": 3, + "C_mat": [ + [ + 1, + 4 + ], + [ + 2, + 5 + ], + [ + 3, + 6 + ] + ], + "WORK": [ + 9999, + 0, + 0, + 0 + ], + "strideWORK": 1, + "offsetWORK": 1, + "C_out": [ + 9999, + -1, + 4, + -2, + 5, + -3, + 6 + ], + "C_out_mat": [ + [ + -1, + 4 + ], + [ + -2, + 5 + ], + [ + -3, + 6 + ] + ], + "WORK_out": [ + 9999, + 1, + 2, + 3 + ], + "info": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/test.dorml2.js b/lib/node_modules/@stdlib/lapack/base/dorml2/test/test.dorml2.js index 01e63dbba790..1f6359ab2d45 100644 --- a/lib/node_modules/@stdlib/lapack/base/dorml2/test/test.dorml2.js +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/test.dorml2.js @@ -89,6 +89,7 @@ tape( 'the function throws an error if provided a first argument which is not a }; } }); + tape( 'the function throws an error if provided a second argument which is not a valid operation side', function test( t ) { var values; var WORK; diff --git a/lib/node_modules/@stdlib/lapack/base/dorml2/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dorml2/test/test.ndarray.js new file mode 100644 index 000000000000..a37990b2e100 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dorml2/test/test.ndarray.js @@ -0,0 +1,1148 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var Float64Array = require( '@stdlib/array/float64' ); +var isAlmostEqual = require( '@stdlib/assert/is-almost-equal-float64array' ); +var dorml2 = require( './../lib/ndarray.js' ); + + +// FIXTURES // + +var LEFT_ROW = require( './fixtures/left_row.json' ); +var LEFT_COL = require( './fixtures/left_col.json' ); +var RIGHT_ROW = require( './fixtures/right_row.json' ); +var RIGHT_COL = require( './fixtures/right_col.json' ); +var TRANS_LEFT = require( './fixtures/trans_left.json' ); +var TRANS_RIGHT = require( './fixtures/trans_right.json' ); +var LAR_STR_LEFT_ROW = require( './fixtures/large_strides/left_row.json' ); +var LAR_STR_LEFT_COL = require( './fixtures/large_strides/left_col.json' ); +var LAR_STR_RIGHT_ROW = require( './fixtures/large_strides/right_row.json' ); +var LAR_STR_RIGHT_COL = require( './fixtures/large_strides/right_col.json' ); +var LAR_STR_TRANS_LEFT = require( './fixtures/large_strides/trans_left.json' ); +var LAR_STR_TRANS_RIGHT = require( './fixtures/large_strides/trans_right.json' ); +var MIX_STR_LEFT_ROW = require( './fixtures/mixed_strides/left_row.json' ); +var MIX_STR_LEFT_COL = require( './fixtures/mixed_strides/left_col.json' ); +var MIX_STR_RIGHT_ROW = require( './fixtures/mixed_strides/right_row.json' ); +var MIX_STR_RIGHT_COL = require( './fixtures/mixed_strides/right_col.json' ); +var MIX_STR_TRANS_LEFT = require( './fixtures/mixed_strides/trans_left.json' ); +var MIX_STR_TRANS_RIGHT = require( './fixtures/mixed_strides/trans_right.json' ); +var NEG_STR_LEFT_ROW = require( './fixtures/negative_strides/left_row.json' ); +var NEG_STR_LEFT_COL = require( './fixtures/negative_strides/left_col.json' ); +var NEG_STR_RIGHT_ROW = require( './fixtures/negative_strides/right_row.json' ); +var NEG_STR_RIGHT_COL = require( './fixtures/negative_strides/right_col.json' ); +var NEG_STR_TRANS_LEFT = require( './fixtures/negative_strides/trans_left.json' ); +var NEG_STR_TRANS_RIGHT = require( './fixtures/negative_strides/trans_right.json' ); +var OFF_LEFT_ROW = require( './fixtures/offsets/left_row.json' ); +var OFF_LEFT_COL = require( './fixtures/offsets/left_col.json' ); +var OFF_RIGHT_ROW = require( './fixtures/offsets/right_row.json' ); +var OFF_RIGHT_COL = require( './fixtures/offsets/right_col.json' ); +var OFF_TRANS_LEFT = require( './fixtures/offsets/trans_left.json' ); +var OFF_TRANS_RIGHT = require( './fixtures/offsets/trans_right.json' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof dorml2, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 19', function test( t ) { + t.strictEqual( dorml2.length, 19, 'returns expected value' ); + t.end(); +}); + +tape( 'the function throws an error if provided a first argument which is not a valid operation side', function test( t ) { + var values; + var WORK; + var TAU; + var A; + var C; + var i; + + A = new Float64Array( [ 1, 0 ] ); + TAU = new Float64Array( [ 2 ] ); + C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] ); + WORK = new Float64Array( 3 ); + + 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() { + dorml2( value, 'no-transpose', 2, 3, 1, A, 2, 1, 0, TAU, 1, 0, C, 3, 1, 0, WORK, 1, 0 ); + }; + } +}); + +tape( 'the function throws an error if provided a second argument which is not a valid transpose operation', function test( t ) { + var values; + var WORK; + var TAU; + var A; + var C; + var i; + + A = new Float64Array( [ 1, 0 ] ); + TAU = new Float64Array( [ 2 ] ); + C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] ); + WORK = new Float64Array( 3 ); + + 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() { + dorml2( 'left', value, 2, 3, 1, A, 2, 1, 0, TAU, 1, 0, C, 3, 1, 0, WORK, 1, 0 ); + }; + } +}); + +tape( 'the function throws an error if provided a third argument which is smaller than 0', function test( t ) { + var values; + var WORK; + var TAU; + var A; + var C; + var i; + + A = new Float64Array( [ 1, 0 ] ); + TAU = new Float64Array( [ 2 ] ); + C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] ); + WORK = new Float64Array( 3 ); + + values = [ + -1, + -2, + -3 + ]; + + 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() { + dorml2( 'left', 'no-transpose', value, 3, 1, A, 2, 1, 0, TAU, 1, 0, C, 3, 1, 0, WORK, 1, 0 ); + }; + } +}); + +tape( 'the function throws an error if provided a fourth argument which is smaller than 0', function test( t ) { + var values; + var WORK; + var TAU; + var A; + var C; + var i; + + A = new Float64Array( [ 1, 0 ] ); + TAU = new Float64Array( [ 2 ] ); + C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] ); + WORK = new Float64Array( 3 ); + + values = [ + -1, + -2, + -3 + ]; + + 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() { + dorml2( 'left', 'no-transpose', 2, value, 1, A, 2, 1, 0, TAU, 1, 0, C, 3, 1, 0, WORK, 1, 0 ); + }; + } +}); + +tape( 'the function throws an error if provided a fifth argument which is smaller than 0', function test( t ) { + var values; + var WORK; + var TAU; + var A; + var C; + var i; + + A = new Float64Array( [ 1, 0 ] ); + TAU = new Float64Array( [ 2 ] ); + C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] ); + WORK = new Float64Array( 3 ); + + values = [ + -1, + -2, + -3 + ]; + + 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() { + dorml2( 'left', 'no-transpose', 2, 3, value, A, 2, 1, 0, TAU, 1, 0, C, 3, 1, 0, WORK, 1, 0 ); + }; + } +}); + +tape( 'the function throws an error if provided a sixth argument which is larger than the order of `Q` (left)', function test( t ) { + var values; + var WORK; + var TAU; + var A; + var C; + var i; + + A = new Float64Array( [ 1, 0 ] ); + TAU = new Float64Array( [ 2 ] ); + C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] ); + WORK = new Float64Array( 3 ); + + values = [ + 3, + 4, + 5 + ]; + + 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() { + dorml2( 'left', 'no-transpose', 2, 3, value, A, 2, 1, 0, TAU, 1, 0, C, 3, 1, 0, WORK, 1, 0 ); + }; + } +}); + +tape( 'the function throws an error if provided a sixth argument which is larger than the order of `Q` (right)', function test( t ) { + var values; + var WORK; + var TAU; + var A; + var C; + var i; + + A = new Float64Array( [ 1, 0 ] ); + TAU = new Float64Array( [ 2 ] ); + C = new Float64Array( [ 1, 3, 5, 2, 4, 6 ] ); + WORK = new Float64Array( 3 ); + + values = [ + 4, + 5, + 6 + ]; + + 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() { + dorml2( 'right', 'no-transpose', 2, 3, value, A, 2, 1, 0, TAU, 1, 0, C, 3, 1, 0, WORK, 1, 0 ); + }; + } +}); + +tape( 'the function quick returns when `M`, `N` or `K` is equal to 0', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = LEFT_ROW; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C ); + expectedWORK = new Float64Array( data.WORK ); + + info = dorml2( data.side, data.trans, 0, 0, 0, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (left, row-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = LEFT_ROW; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (left, column-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = LEFT_COL; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (right, row-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = RIGHT_ROW; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (right, column-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = RIGHT_COL; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (left, row-major, trans)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = TRANS_LEFT; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (right, row-major, trans)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = TRANS_RIGHT; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (large stride, left, row-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = LAR_STR_LEFT_ROW; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (large stride, left, column-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = LAR_STR_LEFT_COL; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (large stride, right, row-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = LAR_STR_RIGHT_ROW; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (large stride, right, column-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = LAR_STR_RIGHT_COL; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (large stride, left, row-major, trans)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = LAR_STR_TRANS_LEFT; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (large stride, right, row-major, trans)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = LAR_STR_TRANS_RIGHT; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (mixed stride, left, row-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = MIX_STR_LEFT_ROW; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (mixed stride, left, column-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = MIX_STR_LEFT_COL; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (mixed stride, right, row-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = MIX_STR_RIGHT_ROW; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (mixed stride, right, column-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = MIX_STR_RIGHT_COL; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (mixed stride, left, row-major, trans)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = MIX_STR_TRANS_LEFT; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (mixed stride, right, row-major, trans)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = MIX_STR_TRANS_RIGHT; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (negative stride, left, row-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = NEG_STR_LEFT_ROW; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (negative stride, left, column-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = NEG_STR_LEFT_COL; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (negative stride, right, row-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = NEG_STR_RIGHT_ROW; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (negative stride, right, column-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = NEG_STR_RIGHT_COL; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (negative stride, left, row-major, trans)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = NEG_STR_TRANS_LEFT; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (negative stride, right, row-major, trans)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = NEG_STR_TRANS_RIGHT; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (offset, left, row-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = OFF_LEFT_ROW; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (offset, left, column-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = OFF_LEFT_COL; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (offset, right, row-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = OFF_RIGHT_ROW; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (offset, right, column-major)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = OFF_RIGHT_COL; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (offset, left, row-major, trans)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = OFF_TRANS_LEFT; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function multiplies a general matrix by the orthogonal matrix from a LQ factorization (offset, right, row-major, trans)', function test( t ) { + var expectedWORK; + var expectedC; + var info; + var data; + var WORK; + var TAU; + var A; + var C; + + data = OFF_TRANS_RIGHT; + + A = new Float64Array( data.A ); + TAU = new Float64Array( data.TAU ); + C = new Float64Array( data.C ); + WORK = new Float64Array( data.WORK ); + + expectedC = new Float64Array( data.C_out ); + expectedWORK = new Float64Array( data.WORK_out ); + + info = dorml2( data.side, data.trans, data.M, data.N, data.K, A, data.strideA1, data.strideA2, data.offsetA, TAU, data.strideTAU, data.offsetTAU, C, data.strideC1, data.strideC2, data.offsetC, WORK, data.strideWORK, data.offsetWORK ); + t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( isAlmostEqual( C, expectedC, 1 ), true, 'returns expected value' ); + t.strictEqual( isAlmostEqual( WORK, expectedWORK, 1 ), true, 'returns expected value' ); + t.end(); +});