From e31c8b884393c5851db2b9b4540e3ff5d92a5a71 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Sun, 2 Mar 2025 07:08:53 +0000 Subject: [PATCH 01/25] feat: add base algorithm --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/lapack/base/dgttrf/lib/base.js | 146 ++++++++++++++++++ 1 file changed, 146 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js new file mode 100644 index 000000000000..75a7b072f6b5 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js @@ -0,0 +1,146 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var abs = require( '@stdlib/math/base/special/abs' ); + + +// MAIN // + +/** +* Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges. +* +* @private +* @param {NonNegativeInteger} N - order of `A` +* @param {Float64Array} DL - sub diagonal elements of `A` +* @param {integer} strideDL - stride of the sub diagonal elements of `A` +* @param {NonNegativeInteger} offsetDL - offset of the sub diagonal elements of `A` +* @param {Float64Array} D - diagonal elements of `A` +* @param {integer} strideD - stride of the diagonal elements of `A` +* @param {NonNegativeInteger} offsetD - offset of the diagonal elements of `A` +* @param {Float64Array} DU - diagonal elements of `A` +* @param {integer} strideDU - stride of the first super diagonal elements of `A` +* @param {NonNegativeInteger} offsetDU - offset of the first super diagonal elements of `A` +* @param {Float64Array} DU2 - diagonal elements of `A` +* @param {integer} strideDU2 - stride of the second super diagonal elements of `A` +* @param {NonNegativeInteger} offsetDU2 - offset of the second super diagonal elements of `A` +* @param {Int32Array} IPIV - vector of pivot indices +* @param {integer} strideIPIV - `IPIV` stride length +* @param {NonNegativeInteger} offsetIPIV - index offset for `IPIV` +* @returns {integer} status code +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var DL = new Float64Array( [ 1.0, 1.0 ] ); +* var D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); +* var DU = new Float64Array( [ 1.0, 1.0 ] ); +* var DU2 = new Float64Array( [ 0.0 ] ); +* var IPIV = new Int32Array( [ 0, 1, 2 ] ); +* +* dgttrf( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); +* // DL => [ 0.5, 0.4 ] +* // D => [ 2, 2.5, 0.6 ] +* // DU => [ 1, 1 ] +* // DU2 => [ 0 ] +*/ +function dgttrf( N, DL, strideDL, offsetDL, D, strideD, offsetD, DU, strideDU, offsetDU, DU2, strideDU2, offsetDU2, IPIV, strideIPIV, offsetIPIV ) { // eslint-disable-line max-len, max-params + var fact; + var temp; + var idu2; + var idu; + var idl; + var id; + var ip; + var i; + + if ( N === 0 ) { + return 0; + } + + idl = offsetDL; + idu2 = offsetDU2; + + ip = offsetIPIV; + for ( i = 0; i < N; i++ ) { + IPIV[ ip + (strideIPIV*i) ] = i; + } + + idu = offsetDU; + for ( i = 0; i < N-2; i++ ) { + DU2[ idu + (strideDU*i) ] = 0; + } + + idl = offsetDL; + idu2 = offsetDU2; + id = offsetD; + for ( i = 0; i < N-2; i++ ) { + if ( abs( D[ id + (strideD*i) ] ) >= abs( DL[ idl + (strideDL*i) ] ) ) { // no row interchange required + if ( D[ id ] !== 0.0 ) { + fact = DL[ idl + (strideDL*i) ] / D[ id + (strideD*i) ]; + DL[ idl + (strideDL*i) ] = fact; + D[ id + (strideD*(i+1)) ] = D[ id + (strideD*(i+1)) ] - ( fact*DU[ idu + (strideDU*i) ] ); // eslint-disable-line max-len + } + } else { + fact = D[ id+(strideD*i) ] / DL[ idl+(strideDL*i) ]; + D[ id+(strideD*i) ] = DL[ idl+(strideDL*i) ]; + DL[ idl+(strideDL*i) ] = fact; + temp = DU[ idu+(strideDU*i) ]; + DU[ idu+(strideDU*i) ] = D[ id + (strideD*(i+1)) ]; + D[ id+(strideD*(i+1)) ] = temp - ( fact*D[ id+(strideD*(i+1)) ] ); + DU2[ idu2+(strideDU2*i) ] = DU[ idu+(strideDU*(i+1)) ]; + DU[ idu+(strideDU*(i+1)) ] = -fact*DU[ idu+(strideDU*(i+1)) ]; + IPIV[ ip+(strideIPIV*i) ] = i + 1; + } + } + + if ( N > 1 ) { + i = N - 2; + if ( abs( D[ id + (strideD*i) ] ) >= abs( DL[ idl + (strideDL*i) ] ) ) { + if ( D[ id + (strideD*i) ] !== 0 ) { + fact = DL[ idl + (strideDL*i) ] / D[ id + (strideD*i) ]; + DL[ idl + (strideDL*i) ] = fact; + D[ id + (strideD*(i+1)) ] = D[ id + (strideD*(i+1)) ] - (fact*DU[ idu + (strideDU*i) ]); // eslint-disable-line max-len + } + } else { + fact = D[ id+(strideD*i) ] / DL[ idl+(strideDL*i) ]; + D[ id+(strideD*i) ] = DL[ idl+(strideDL*i) ]; + DL[ idl+(strideDL*i) ] = fact; + temp = DU[ idu+(strideDU*i) ]; + DU[ idu+(strideDU*i) ] = D[ id + (strideD*(i+1)) ]; + D[ id+(strideD*(i+1)) ] = temp - ( fact*D[ id+(strideD*(i+1)) ] ); + IPIV[ ip+(strideIPIV*i) ] = i + 1; + } + } + + for ( i = 0; i < N; i++ ) { + if ( D[ id+(strideD*i) ] === 0.0 ) { + return i; + } + } + + return 0; +} + + +// EXPORTS // + +module.exports = dgttrf; From 4686b1aedb9c3fa52df4fb63c1244404ea16844c Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Sun, 2 Mar 2025 07:10:15 +0000 Subject: [PATCH 02/25] fix: remove redundant code --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js index 75a7b072f6b5..ec24219bc194 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js @@ -77,21 +77,19 @@ function dgttrf( N, DL, strideDL, offsetDL, D, strideD, offsetD, DU, strideDU, o } idl = offsetDL; + id = offsetD; + idu = offsetDU; idu2 = offsetDU2; - ip = offsetIPIV; + for ( i = 0; i < N; i++ ) { IPIV[ ip + (strideIPIV*i) ] = i; } - idu = offsetDU; for ( i = 0; i < N-2; i++ ) { DU2[ idu + (strideDU*i) ] = 0; } - idl = offsetDL; - idu2 = offsetDU2; - id = offsetD; for ( i = 0; i < N-2; i++ ) { if ( abs( D[ id + (strideD*i) ] ) >= abs( DL[ idl + (strideDL*i) ] ) ) { // no row interchange required if ( D[ id ] !== 0.0 ) { From 7bcf93ce52f112ba9d0195e263ec88b420bd8126 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Sun, 2 Mar 2025 13:01:09 +0000 Subject: [PATCH 03/25] feat: complete initial implementation for dgttrf --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/lapack/base/dgttrf/lib/dgttrf.js | 66 +++++++++++++++ .../@stdlib/lapack/base/dgttrf/lib/index.js | 80 +++++++++++++++++++ .../@stdlib/lapack/base/dgttrf/lib/main.js | 35 ++++++++ .../@stdlib/lapack/base/dgttrf/lib/ndarray.js | 76 ++++++++++++++++++ 4 files changed, 257 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/lib/main.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js new file mode 100644 index 000000000000..bc864c4d3363 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js @@ -0,0 +1,66 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var format = require( '@stdlib/string/format' ); +var base = require( './base.js' ); + + +// MAIN // + +/** +* Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges. +* +* @param {NonNegativeInteger} N - order of `A` +* @param {Float64Array} DL - sub diagonal elements of `A` +* @param {Float64Array} D - diagonal elements of `A` +* @param {Float64Array} DU - diagonal elements of `A` +* @param {Float64Array} DU2 - diagonal elements of `A` +* @param {Int32Array} IPIV - vector of pivot indices +* @throws {RangeError} first argument must be a nonnegative integer +* @returns {integer} status code +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var DL = new Float64Array( [ 1.0, 1.0 ] ); +* var D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); +* var DU = new Float64Array( [ 1.0, 1.0 ] ); +* var DU2 = new Float64Array( [ 0.0 ] ); +* var IPIV = new Int32Array( [ 0, 1, 2 ] ); +* +* dgttrf( 3, DL, D, DU, DU2, IPIV ); +* // DL => [ 0.5, 0.4 ] +* // D => [ 2, 2.5, 0.6 ] +* // DU => [ 1, 1 ] +* // DU2 => [ 0 ] +*/ +function dgttrf( N, DL, D, DU, DU2, IPIV ) { + if ( N < 0 ) { + throw new RangeError( format( 'invalid argument. First argument must be a nonnegative integer. Value: `%d`.', N ) ); + } + return base( N, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); +} + + +// EXPORTS // + +module.exports = dgttrf; diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js new file mode 100644 index 000000000000..df97b30b7d37 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js @@ -0,0 +1,80 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +/** +* LAPACK routine to compute an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges. +* +* @module @stdlib/lapack/base/dgttrf +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* var dgttrf = require( '@stdlib/lapack/base/dgttrf' ); +* +* var DL = new Float64Array( [ 1.0, 1.0 ] ); +* var D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); +* var DU = new Float64Array( [ 1.0, 1.0 ] ); +* var DU2 = new Float64Array( [ 0.0 ] ); +* var IPIV = new Int32Array( [ 0, 1, 2 ] ); +* +* dgttrf( 3, DL, D, DU, DU2, IPIV ); +* // DL => [ 0.5, 0.4 ] +* // D => [ 2, 2.5, 0.6 ] +* // DU => [ 1, 1 ] +* // DU2 => [ 0 ] +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* var dgttrf = require( '@stdlib/lapack/base/dgttrf' ); +* +* var DL = new Float64Array( [ 1.0, 1.0 ] ); +* var D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); +* var DU = new Float64Array( [ 1.0, 1.0 ] ); +* var DU2 = new Float64Array( [ 0.0 ] ); +* var IPIV = new Int32Array( [ 0, 1, 2 ] ); +* +* dgttrf( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); +* // DL => [ 0.5, 0.4 ] +* // D => [ 2, 2.5, 0.6 ] +* // DU => [ 1, 1 ] +* // DU2 => [ 0 ] +*/ + +// MODULES // + +var join = require( 'path' ).join; +var tryRequire = require( '@stdlib/utils/try-require' ); +var isError = require( '@stdlib/assert/is-error' ); +var main = require( './main.js' ); + + +// MAIN // + +var dgttrf; +var tmp = tryRequire( join( __dirname, './native.js' ) ); +if ( isError( tmp ) ) { + dgttrf = main; +} else { + dgttrf = tmp; +} + + +// EXPORTS // + +module.exports = dgttrf; diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/main.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/main.js new file mode 100644 index 000000000000..ecbc1020047d --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/main.js @@ -0,0 +1,35 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' ); +var dgttrf = require( './dgttrf.js' ); +var ndarray = require( './ndarray.js' ); + + +// MAIN // + +setReadOnly( dgttrf, 'ndarray', ndarray ); + + +// EXPORTS // + +module.exports = dgttrf; diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js new file mode 100644 index 000000000000..0bea2457d585 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js @@ -0,0 +1,76 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var format = require( '@stdlib/string/format' ); +var base = require( './base.js' ); + + +// MAIN // + +/** +* Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges. +* +* @param {NonNegativeInteger} N - order of `A` +* @param {Float64Array} DL - sub diagonal elements of `A` +* @param {integer} strideDL - stride of the sub diagonal elements of `A` +* @param {NonNegativeInteger} offsetDL - offset of the sub diagonal elements of `A` +* @param {Float64Array} D - diagonal elements of `A` +* @param {integer} strideD - stride of the diagonal elements of `A` +* @param {NonNegativeInteger} offsetD - offset of the diagonal elements of `A` +* @param {Float64Array} DU - diagonal elements of `A` +* @param {integer} strideDU - stride of the first super diagonal elements of `A` +* @param {NonNegativeInteger} offsetDU - offset of the first super diagonal elements of `A` +* @param {Float64Array} DU2 - diagonal elements of `A` +* @param {integer} strideDU2 - stride of the second super diagonal elements of `A` +* @param {NonNegativeInteger} offsetDU2 - offset of the second super diagonal elements of `A` +* @param {Int32Array} IPIV - vector of pivot indices +* @param {integer} strideIPIV - `IPIV` stride length +* @param {NonNegativeInteger} offsetIPIV - index offset for `IPIV` +* @throws {RangeError} first argument must be a nonnegative integer +* @returns {integer} status code +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var DL = new Float64Array( [ 1.0, 1.0 ] ); +* var D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); +* var DU = new Float64Array( [ 1.0, 1.0 ] ); +* var DU2 = new Float64Array( [ 0.0 ] ); +* var IPIV = new Int32Array( [ 0, 1, 2 ] ); +* +* dgttrf( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); +* // DL => [ 0.5, 0.4 ] +* // D => [ 2, 2.5, 0.6 ] +* // DU => [ 1, 1 ] +* // DU2 => [ 0 ] +*/ +function dgttrf( N, DL, strideDL, offsetDL, D, strideD, offsetD, DU, strideDU, offsetDU, DU2, strideDU2, offsetDU2, IPIV, strideIPIV, offsetIPIV ) { // eslint-disable-line max-len, max-params + if ( N < 0 ) { + throw new RangeError( format( 'invalid argument. First argument must be a nonnegative integer. Value: `%d`.', N ) ); + } + return base( N, DL, strideDL, offsetDL, D, strideD, offsetD, DU, strideDU, offsetDU, DU2, strideDU2, offsetDU2, IPIV, strideIPIV, offsetIPIV ); // eslint-disable-line max-len +} + + +// EXPORTS // + +module.exports = dgttrf; From 43f57ea253fa6c9511dcdcbd9025e8fdbd967c98 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Mon, 3 Mar 2025 07:05:58 +0000 Subject: [PATCH 04/25] docs: add ts declaration file and test.ts --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: passed - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: passed - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: passed - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: passed - task: lint_license_headers status: passed --- --- .../lapack/base/dgttrf/benchmark/benchmark.js | 102 ++++ .../dgttrf/benchmark/benchmark.ndarray.js | 102 ++++ .../lapack/base/dgttrf/docs/types/index.d.ts | 152 ++++++ .../lapack/base/dgttrf/docs/types/test.ts | 485 ++++++++++++++++++ .../lapack/base/dgttrf/examples/index.js | 44 ++ .../@stdlib/lapack/base/dgttrf/lib/base.js | 5 +- .../@stdlib/lapack/base/dgttrf/lib/dgttrf.js | 5 +- .../@stdlib/lapack/base/dgttrf/lib/index.js | 11 +- .../@stdlib/lapack/base/dgttrf/lib/ndarray.js | 6 +- .../@stdlib/lapack/base/dgttrf/package.json | 69 +++ 10 files changed, 969 insertions(+), 12 deletions(-) create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/benchmark/benchmark.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/benchmark/benchmark.ndarray.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/test.ts create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/examples/index.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/package.json diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/benchmark/benchmark.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/benchmark/benchmark.js new file mode 100644 index 000000000000..8f234b67338c --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/benchmark/benchmark.js @@ -0,0 +1,102 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var bench = require( '@stdlib/bench' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var Int32Array = require( '@stdlib/array/int32' ); +var Float64Array = require( '@stdlib/array/float64' ); +var pkg = require( './../package.json' ).name; +var dgttrf = require( './../lib/dgttrf.js' ); + + +// VARIABLES // + +var options = { + 'dtype': 'float64' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + var IPIV = new Int32Array( len ); + var DU2 = new Float64Array( len-2 ); + var DL = uniform( len-1, 0.0, 100.0, options ); + var DU = uniform( len-1, 0.0, 100.0, options ); + var D = uniform( len, 0.0, 100.0, options ); + return benchmark; + + function benchmark( b ) { + var d; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + d = dgttrf( len, DL, D, DU, DU2, IPIV ); + if ( isnan( d ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( d ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); + } +} + + +// MAIN // + +/** +* Main execution sequence. +* +* @private +*/ +function main() { + var len; + var min; + var max; + var f; + var i; + + min = 1; // 10^min + max = 6; // 10^max + + for ( i = min; i <= max; i++ ) { + len = pow( 10, i ); + f = createBenchmark( len ); + bench( pkg+':len='+len, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/benchmark/benchmark.ndarray.js new file mode 100644 index 000000000000..ddee8c23c626 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/benchmark/benchmark.ndarray.js @@ -0,0 +1,102 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var bench = require( '@stdlib/bench' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var Int32Array = require( '@stdlib/array/int32' ); +var Float64Array = require( '@stdlib/array/float64' ); +var pkg = require( './../package.json' ).name; +var dgttrf = require( './../lib/ndarray.js' ); + + +// VARIABLES // + +var options = { + 'dtype': 'float64' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + var IPIV = new Int32Array( len ); + var DU2 = new Float64Array( len-2 ); + var DL = uniform( len-1, 0.0, 100.0, options ); + var DU = uniform( len-1, 0.0, 100.0, options ); + var D = uniform( len, 0.0, 100.0, options ); + return benchmark; + + function benchmark( b ) { + var d; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + d = dgttrf( len, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // eslint-disable-line max-len + if ( isnan( d ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( d ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); + } +} + + +// MAIN // + +/** +* Main execution sequence. +* +* @private +*/ +function main() { + var len; + var min; + var max; + var f; + var i; + + min = 1; // 10^min + max = 6; // 10^max + + for ( i = min; i <= max; i++ ) { + len = pow( 10, i ); + f = createBenchmark( len ); + bench( pkg+':len='+len, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts new file mode 100644 index 000000000000..1111eb1f9d14 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts @@ -0,0 +1,152 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +// TypeScript Version: 4.1 + +/** +* Status code. +* +* ## Notes +* +* The status code indicates the following conditions: +* +* - if equal to zero, then the factorization was successful. +* - if less than zero, then the k-th argument had an illegal value, where `k = -StatusCode`. +* - if greater than zero, then the leading principal minor of order `k` is not positive, where `k = StatusCode`. If `k < N`, then the factorization could not be completed. If `k = N`, then the factorization was completed, but `D(N) <= 0`, meaning that the matrix `A` is not positive definite. +*/ +type StatusCode = number; + +/** +* Interface describing `dgttrf`. +*/ +interface Routine { + /** + * Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges. + * + * @param N - order of matrix `A` + * @param DL - the `N-1` subdiagonal elements of `A` + * @param D - the `N` diagonal elements of `A` + * @param DU - the `N-1` superdiagonal elements of `A` + * @param DU2 - the `N-2` elements of the second superdiagonal of `A` + * @param IPIV - vector of pivot indices + * @returns status code + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * var Int32Array = require( '@stdlib/array/int32' ); + * + * var DL = new Float64Array( [ 1.0, 1.0 ] ); + * var D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); + * var DU = new Float64Array( [ 1.0, 1.0 ] ); + * var DU2 = new Float64Array( 1 ); + * var IPIV = new Int32Array( 3 ); + * + * dgttrf( 3, DL, D, DU, DU2, IPIV ); + * // DL => [ 0.5, 0.4 ] + * // D => [ 2, 2.5, 0.6 ] + * // DU => [ 1, 1 ] + * // DU2 => [ 0 ] + */ + ( N: number, DL: Float64Array, D: Float64Array, DU: Float64Array, DU2: Float64Array, IPIV: Int32Array ): StatusCode; + + /** + * Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges and alternative indexing semantics. + * + * @param N - order of matrix `A` + * @param DL - the `N-1` subdiagonal elements of `A` + * @param strideDL - stride of the subdiagonal elements of `A` + * @param offsetDL - offset of the subdiagonal elements of `A` + * @param D - the `N` diagonal elements of `A` + * @param strideD - stride of the diagonal elements of `A` + * @param offsetD - offset of the diagonal elements of `A` + * @param DU - the `N-1` superdiagonal elements of `A` + * @param strideDU - stride of the first superdiagonal elements of `A` + * @param offsetDU - offset of the first superdiagonal elements of `A` + * @param DU2 - the `N-2` elements of the second superdiagonal of `A` + * @param strideDU2 - stride of the second superdiagonal elements of `A` + * @param offsetDU2 - offset of the second superdiagonal elements of `A` + * @param IPIV - vector of pivot indices + * @param strideIPIV - `IPIV` stride length + * @param offsetIPIV - index offset for `IPIV` + * @returns status code + * + * @example + * var DL = new Float64Array( [ 1.0, 1.0 ] ); + * var D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); + * var DU = new Float64Array( [ 1.0, 1.0 ] ); + * var DU2 = new Float64Array( 1 ); + * var IPIV = new Int32Array( 3 ); + * + * dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); + * // DL => [ 0.5, 0.4 ] + * // D => [ 2, 2.5, 0.6 ] + * // DU => [ 1, 1 ] + * // DU2 => [ 0 ] + */ + ndarray( N: number, DL: Float64Array, strideDL: number, offsetDL: number, D: Float64Array, strideD: number, offsetD: number, DU: Float64Array, strideDU: number, offsetDU: number, DU2: Float64Array, strideDU2: number, offsetDU2: number, IPIV: Int32Array, strideIPIV: number, offsetIPIV: number ): StatusCode; +} + +/** +* LAPACK routine to compute an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges. +* +* @param N - order of matrix `A` +* @param DL - the `N-1` subdiagonal elements of `A` +* @param D - the `N` diagonal elements of `A` +* @param DU - the `N-1` superdiagonal elements of `A` +* @param DU2 - the `N-2` elements of the second superdiagonal of `A` +* @param IPIV - vector of pivot indices +* @returns status code +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* var Int32Array = require( '@stdlib/array/int32' ); +* +* var DL = new Float64Array( [ 1.0, 1.0 ] ); +* var D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); +* var DU = new Float64Array( [ 1.0, 1.0 ] ); +* var DU2 = new Float64Array( 1 ); +* var IPIV = new Int32Array( 3 ); +* +* dgttrf( 3, DL, D, DU, DU2, IPIV ); +* // DL => [ 0.5, 0.4 ] +* // D => [ 2, 2.5, 0.6 ] +* // DU => [ 1, 1 ] +* // DU2 => [ 0 ] +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* var Int32Array = require( '@stdlib/array/int32' ); +* +* var DL = new Float64Array( [ 1.0, 1.0 ] ); +* var D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); +* var DU = new Float64Array( [ 1.0, 1.0 ] ); +* var DU2 = new Float64Array( 1 ); +* var IPIV = new Int32Array( 3 ); +* +* dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); +* // DL => [ 0.5, 0.4 ] +* // D => [ 2, 2.5, 0.6 ] +* // DU => [ 1, 1 ] +* // DU2 => [ 0 ] +*/ +declare var dgttrf: Routine; + + +// EXPORTS // + +export = dgttrf; diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/test.ts b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/test.ts new file mode 100644 index 000000000000..79e8b3456d02 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/test.ts @@ -0,0 +1,485 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +// TypeScript Version: 4.1 + +import dgttrf = require( './index' ); + +// TESTS // + +// The function returns a number... +{ + const D = new Float64Array( 3 ); + const DL = new Float64Array( 2 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf( 3, DL, D, DU, DU2, IPIV ); // $ExpectType number +} + +// The compiler throws an error if the function is provided a first argument which is not a number... +{ + const D = new Float64Array( 3 ); + const DL = new Float64Array( 2 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf( '5', DL, D, DU, DU2, IPIV ); // $ExpectError + dgttrf( true, DL, D, DU, DU2, IPIV ); // $ExpectError + dgttrf( false, DL, D, DU, DU2, IPIV ); // $ExpectError + dgttrf( null, DL, D, DU, DU2, IPIV ); // $ExpectError + dgttrf( undefined, DL, D, DU, DU2, IPIV ); // $ExpectError + dgttrf( [], DL, D, DU, DU2, IPIV ); // $ExpectError + dgttrf( {}, DL, D, DU, DU2, IPIV ); // $ExpectError + dgttrf( ( x: number ): number => x, DL, D, DU, DU2, IPIV ); // $ExpectError +} + +// The compiler throws an error if the function is provided a second argument which is not a Float64Array... +{ + const D = new Float64Array( 3 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf( 3, '5', D, DU, DU2, IPIV ); // $ExpectError + dgttrf( 3, 5, D, DU, DU2, IPIV ); // $ExpectError + dgttrf( 3, true, D, DU, DU2, IPIV ); // $ExpectError + dgttrf( 3, false, D, DU, DU2, IPIV ); // $ExpectError + dgttrf( 3, null, D, DU, DU2, IPIV ); // $ExpectError + dgttrf( 3, undefined, D, DU, DU2, IPIV ); // $ExpectError + dgttrf( 3, [], D, DU, DU2, IPIV ); // $ExpectError + dgttrf( 3, {}, D, DU, DU2, IPIV ); // $ExpectError + dgttrf( 3, ( x: number ): number => x, D, DU, DU2, IPIV ); // $ExpectError +} + +// The compiler throws an error if the function is provided a third argument which is not a Float64Array... +{ + const DL = new Float64Array( 2 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf( 3, DL, '5', DU, DU2, IPIV ); // $ExpectError + dgttrf( 3, DL, 5, DU, DU2, IPIV ); // $ExpectError + dgttrf( 3, DL, true, DU, DU2, IPIV ); // $ExpectError + dgttrf( 3, DL, false, DU, DU2, IPIV ); // $ExpectError + dgttrf( 3, DL, null, DU, DU2, IPIV ); // $ExpectError + dgttrf( 3, DL, undefined, DU, DU2, IPIV ); // $ExpectError + dgttrf( 3, DL, [], DU, DU2, IPIV ); // $ExpectError + dgttrf( 3, DL, {}, DU, DU2, IPIV ); // $ExpectError + dgttrf( 3, DL, ( x: number ): number => x, DU, DU2, IPIV ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fourth argument which is not a Float64Array... +{ + const DL = new Float64Array( 2 ); + const D = new Float64Array( 3 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf( 3, DL, D, '5', DU2, IPIV ); // $ExpectError + dgttrf( 3, DL, D, 5, DU2, IPIV ); // $ExpectError + dgttrf( 3, DL, D, true, DU2, IPIV ); // $ExpectError + dgttrf( 3, DL, D, false, DU2, IPIV ); // $ExpectError + dgttrf( 3, DL, D, null, DU2, IPIV ); // $ExpectError + dgttrf( 3, DL, D, undefined, DU2, IPIV ); // $ExpectError + dgttrf( 3, DL, D, [], DU2, IPIV ); // $ExpectError + dgttrf( 3, DL, D, {}, DU2, IPIV ); // $ExpectError + dgttrf( 3, DL, D, ( x: number ): number => x, DU2, IPIV ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fifth argument which is not a Float64Array... +{ + const DL = new Float64Array( 2 ); + const D = new Float64Array( 3 ); + const DU = new Float64Array( 2 ); + const IPIV = new Int32Array( 3 ); + + dgttrf( 3, DL, D, DU, '5', IPIV ); // $ExpectError + dgttrf( 3, DL, D, DU, 5, IPIV ); // $ExpectError + dgttrf( 3, DL, D, DU, true, IPIV ); // $ExpectError + dgttrf( 3, DL, D, DU, false, IPIV ); // $ExpectError + dgttrf( 3, DL, D, DU, null, IPIV ); // $ExpectError + dgttrf( 3, DL, D, DU, undefined, IPIV ); // $ExpectError + dgttrf( 3, DL, D, DU, [], IPIV ); // $ExpectError + dgttrf( 3, DL, D, DU, {}, IPIV ); // $ExpectError + dgttrf( 3, DL, D, DU, ( x: number ): number => x, IPIV ); // $ExpectError +} + +// The compiler throws an error if the function is provided a sixth argument which is not an Int32Array... +{ + const DL = new Float64Array( 2 ); + const D = new Float64Array( 3 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + + dgttrf( 3, DL, D, DU, DU2, '5' ); // $ExpectError + dgttrf( 3, DL, D, DU, DU2, 5 ); // $ExpectError + dgttrf( 3, DL, D, DU, DU2, true ); // $ExpectError + dgttrf( 3, DL, D, DU, DU2, false ); // $ExpectError + dgttrf( 3, DL, D, DU, DU2, null ); // $ExpectError + dgttrf( 3, DL, D, DU, DU2, undefined ); // $ExpectError + dgttrf( 3, DL, D, DU, DU2, [] ); // $ExpectError + dgttrf( 3, DL, D, DU, DU2, {} ); // $ExpectError + dgttrf( 3, DL, D, DU, DU2, ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the function is provided an unsupported number of arguments... +{ + const DL = new Float64Array( 2 ); + const D = new Float64Array( 3 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf(); // $ExpectError + dgttrf( 3 ); // $ExpectError + dgttrf( 3, DL ); // $ExpectError + dgttrf( 3, DL, D ); // $ExpectError + dgttrf( 3, DL, D, DU ); // $ExpectError + dgttrf( 3, DL, D, DU, DU2 ); // $ExpectError + dgttrf( 3, DL, D, DU, DU2, IPIV, 10 ); // $ExpectError +} + +// Attached to main export is an `ndarray` method which returns a number... +{ + const DL = new Float64Array( 2 ); + const D = new Float64Array( 3 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectType number +} + +// The compiler throws an error if the function is provided a first argument which is not a number... +{ + const DL = new Float64Array( 2 ); + const D = new Float64Array( 3 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf.ndarray( '5', DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( true, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( false, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( null, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( undefined, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( [], DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( {}, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( ( x: number ): number => x, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a second argument which is not a Float64Array... +{ + const D = new Float64Array( 3 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf.ndarray( 3, '5', 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, 5, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, true, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, false, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, null, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, undefined, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, [], 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, {}, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, ( x: number ): number => x, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a third argument which is not a number... +{ + const DL = new Float64Array( 2 ); + const D = new Float64Array( 3 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf.ndarray( 3, DL, '5', 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, true, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, false, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, null, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, undefined, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, [], 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, {}, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, ( x: number ): number => x, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fourth argument which is not a number... +{ + const DL = new Float64Array( 2 ); + const D = new Float64Array( 3 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf.ndarray( 3, DL, 1, '5', D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, true, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, false, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, null, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, undefined, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, [], D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, {}, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, ( x: number ): number => x, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fifth argument which is not a Float64Array... +{ + const DL = new Float64Array( 2 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf.ndarray( 3, DL, 1, 0, '5', 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, 5, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, true, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, false, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, null, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, undefined, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, [], 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, {}, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, ( x: number ): number => x, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a sixth argument which is not a number... +{ + const DL = new Float64Array( 2 ); + const D = new Float64Array( 3 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf.ndarray( 3, DL, 1, 0, D, '5', 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, true, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, false, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, null, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, undefined, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, [], 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, {}, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, ( x: number ): number => x, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a seventh argument which is not a number... +{ + const DL = new Float64Array( 2 ); + const D = new Float64Array( 3 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf.ndarray( 3, DL, 1, 0, D, 1, '5', DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, true, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, false, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, null, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, undefined, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, [], DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, {}, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, ( x: number ): number => x, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided an eighth argument which is not a Float64Array... +{ + const DL = new Float64Array( 2 ); + const D = new Float64Array( 3 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, '5', 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, 5, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, true, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, false, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, null, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, undefined, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, [], 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, {}, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, ( x: number ): number => x, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a ninth argument which is not a number... +{ + const DL = new Float64Array( 2 ); + const D = new Float64Array( 3 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, '5', 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, true, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, false, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, null, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, undefined, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, [], 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, {}, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, ( x: number ): number => x, 0, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a tenth argument which is not a number... +{ + const DL = new Float64Array( 2 ); + const D = new Float64Array( 3 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, '5', DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, true, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, false, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, null, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, undefined, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, [], DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, {}, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, ( x: number ): number => x, DU2, 1, 0, IPIV, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided an eleventh argument which is not a Float64Array... +{ + const DL = new Float64Array( 2 ); + const D = new Float64Array( 3 ); + const DU = new Float64Array( 2 ); + const IPIV = new Int32Array( 3 ); + + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, '5', 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, 5, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, true, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, false, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, null, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, undefined, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, [], 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, {}, 1, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, ( x: number ): number => x, 1, 0, IPIV, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a twelfth argument which is not a number... +{ + const DL = new Float64Array( 2 ); + const D = new Float64Array( 3 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, '5', 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, true, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, false, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, null, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, undefined, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, [], 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, {}, 0, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, ( x: number ): number => x, 0, IPIV, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a thirteenth argument which is not a number... +{ + const DL = new Float64Array( 2 ); + const D = new Float64Array( 3 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, '5', IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, true, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, false, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, null, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, undefined, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, [], IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, {}, IPIV, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, ( x: number ): number => x, IPIV, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fourteenth argument which is not an Int32Array... +{ + const DL = new Float64Array( 2 ); + const D = new Float64Array( 3 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, '5', 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, 5, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, true, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, false, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, null, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, undefined, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, [], 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, {}, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, ( x: number ): number => x, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fifteenth argument which is not a number... +{ + const DL = new Float64Array( 2 ); + const D = new Float64Array( 3 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, '5', 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, true, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, false, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, null, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, undefined, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, [], 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, {}, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, ( x: number ): number => x, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a sixteenth argument which is not a number... +{ + const DL = new Float64Array( 2 ); + const D = new Float64Array( 3 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, '5' ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, true ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, false ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, null ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, undefined ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, [] ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, {} ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the function is provided an unsupported number of arguments... +{ + const DL = new Float64Array( 2 ); + const D = new Float64Array( 3 ); + const DU = new Float64Array( 2 ); + const DU2 = new Float64Array( 1 ); + const IPIV = new Int32Array( 3 ); + + dgttrf.ndarray(); // $ExpectError + dgttrf.ndarray( 3 ); // $ExpectError + dgttrf.ndarray( 3, DL ); // $ExpectError + dgttrf.ndarray( 3, DL, 1 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1 ); // $ExpectError + dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0, 10 ); // $ExpectError +} diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/examples/index.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/examples/index.js new file mode 100644 index 000000000000..b553e5e91206 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/examples/index.js @@ -0,0 +1,44 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +var Int32Array = require( '@stdlib/array/int32' ); +var Float64Array = require( '@stdlib/array/float64' ); +var dgttrf = require( './../lib' ); + +var N = 9; + +var DL = new Float64Array( [ 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0 ] ); + +var D = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + +var DU = new Float64Array( [ 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0 ] ); + +var DU2 = new Float64Array( N-2 ); + +var IPIV = new Int32Array( N ); + +var info = dgttrf( N, DL, D, DU, DU2, IPIV ); + +console.log( DL ); +console.log( D ); +console.log( DU ); +console.log( DU2 ); +console.log( IPIV ); +console.log( info ); diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js index ec24219bc194..8ace95945d84 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js @@ -49,12 +49,13 @@ var abs = require( '@stdlib/math/base/special/abs' ); * * @example * var Float64Array = require( '@stdlib/array/float64' ); +* var Int32Array = require( '@stdlib/array/int32' ) * * var DL = new Float64Array( [ 1.0, 1.0 ] ); * var D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); * var DU = new Float64Array( [ 1.0, 1.0 ] ); -* var DU2 = new Float64Array( [ 0.0 ] ); -* var IPIV = new Int32Array( [ 0, 1, 2 ] ); +* var DU2 = new Float64Array( 1 ); +* var IPIV = new Int32Array( 3 ); * * dgttrf( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); * // DL => [ 0.5, 0.4 ] diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js index bc864c4d3363..d4402272f7a1 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js @@ -40,12 +40,13 @@ var base = require( './base.js' ); * * @example * var Float64Array = require( '@stdlib/array/float64' ); +* var Int32Array = require( '@stdlib/array/int32' ); * * var DL = new Float64Array( [ 1.0, 1.0 ] ); * var D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); * var DU = new Float64Array( [ 1.0, 1.0 ] ); -* var DU2 = new Float64Array( [ 0.0 ] ); -* var IPIV = new Int32Array( [ 0, 1, 2 ] ); +* var DU2 = new Float64Array( 1 ); +* var IPIV = new Int32Array( 3 ); * * dgttrf( 3, DL, D, DU, DU2, IPIV ); * // DL => [ 0.5, 0.4 ] diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js index df97b30b7d37..80209750b116 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js @@ -30,8 +30,8 @@ * var DL = new Float64Array( [ 1.0, 1.0 ] ); * var D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); * var DU = new Float64Array( [ 1.0, 1.0 ] ); -* var DU2 = new Float64Array( [ 0.0 ] ); -* var IPIV = new Int32Array( [ 0, 1, 2 ] ); +* var DU2 = new Float64Array( 1 ); +* var IPIV = new Int32Array( 3 ); * * dgttrf( 3, DL, D, DU, DU2, IPIV ); * // DL => [ 0.5, 0.4 ] @@ -41,15 +41,16 @@ * * @example * var Float64Array = require( '@stdlib/array/float64' ); +* var Int32Array = require( '@stdlib/array/int32' ); * var dgttrf = require( '@stdlib/lapack/base/dgttrf' ); * * var DL = new Float64Array( [ 1.0, 1.0 ] ); * var D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); * var DU = new Float64Array( [ 1.0, 1.0 ] ); -* var DU2 = new Float64Array( [ 0.0 ] ); -* var IPIV = new Int32Array( [ 0, 1, 2 ] ); +* var DU2 = new Float64Array( 1 ); +* var IPIV = new Int32Array( 3 ); * -* dgttrf( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); +* dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); * // DL => [ 0.5, 0.4 ] * // D => [ 2, 2.5, 0.6 ] * // DU => [ 1, 1 ] diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js index 0bea2457d585..fc4e71f8b47d 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js @@ -27,7 +27,7 @@ var base = require( './base.js' ); // MAIN // /** -* Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges. +* Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges and alternative indexing semantics. * * @param {NonNegativeInteger} N - order of `A` * @param {Float64Array} DL - sub diagonal elements of `A` @@ -54,8 +54,8 @@ var base = require( './base.js' ); * var DL = new Float64Array( [ 1.0, 1.0 ] ); * var D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); * var DU = new Float64Array( [ 1.0, 1.0 ] ); -* var DU2 = new Float64Array( [ 0.0 ] ); -* var IPIV = new Int32Array( [ 0, 1, 2 ] ); +* var DU2 = new Float64Array( 1 ); +* var IPIV = new Int32Array( 3 ); * * dgttrf( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); * // DL => [ 0.5, 0.4 ] diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/package.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/package.json new file mode 100644 index 000000000000..866bf4f455cf --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/package.json @@ -0,0 +1,69 @@ +{ + "name": "@stdlib/lapack/base/dgttrf", + "version": "0.0.0", + "description": "Compute an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges", + "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", + "dgttrf", + "cholesky", + "factorization", + "linear", + "algebra", + "subroutines", + "array", + "ndarray", + "float64", + "double", + "float64array" + ] +} From 13e7f57f94dc695224ad51c316026470aecf046c Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Mon, 3 Mar 2025 07:34:17 +0000 Subject: [PATCH 05/25] docs: update descriptions as per lapack documentation --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- type: pre_push_report description: Results of running various checks prior to pushing changes. report: - task: run_javascript_examples status: na - task: run_c_examples status: na - task: run_cpp_examples status: na - task: run_javascript_readme_examples status: na - task: run_c_benchmarks status: na - task: run_cpp_benchmarks status: na - task: run_fortran_benchmarks status: na - task: run_javascript_benchmarks status: na - task: run_julia_benchmarks status: na - task: run_python_benchmarks status: na - task: run_r_benchmarks status: na - task: run_javascript_tests status: na --- --- .../lapack/base/dgttrf/docs/types/index.d.ts | 46 +++++++++---------- .../@stdlib/lapack/base/dgttrf/lib/base.js | 30 ++++++------ .../@stdlib/lapack/base/dgttrf/lib/dgttrf.js | 10 ++-- .../@stdlib/lapack/base/dgttrf/lib/ndarray.js | 30 ++++++------ 4 files changed, 58 insertions(+), 58 deletions(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts index 1111eb1f9d14..cbe7a17eb179 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts @@ -27,7 +27,7 @@ * * - if equal to zero, then the factorization was successful. * - if less than zero, then the k-th argument had an illegal value, where `k = -StatusCode`. -* - if greater than zero, then the leading principal minor of order `k` is not positive, where `k = StatusCode`. If `k < N`, then the factorization could not be completed. If `k = N`, then the factorization was completed, but `D(N) <= 0`, meaning that the matrix `A` is not positive definite. +* - if greater than zero, then U( k, k ) is exactly zero the factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations, where `k = StatusCode`. */ type StatusCode = number; @@ -39,10 +39,10 @@ interface Routine { * Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges. * * @param N - order of matrix `A` - * @param DL - the `N-1` subdiagonal elements of `A` - * @param D - the `N` diagonal elements of `A` - * @param DU - the `N-1` superdiagonal elements of `A` - * @param DU2 - the `N-2` elements of the second superdiagonal of `A` + * @param DL - sub diagonal elements of `A`. On exit, `DL` is overwritten by the multipliers that define the matrix `L` from the LU factorization of `A`. + * @param D - diagonal elements of `A`. On exit, `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the LU factorization of `A`. + * @param DU - super diagonal elements of `A`. On exit, `DU` is overwritten by the elements of the first super-diagonal of `U`. + * @param DU2 - On exit, `DU2` is overwritten by the elements of the second super-diagonal of `U`. * @param IPIV - vector of pivot indices * @returns status code * @@ -68,21 +68,21 @@ interface Routine { * Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges and alternative indexing semantics. * * @param N - order of matrix `A` - * @param DL - the `N-1` subdiagonal elements of `A` - * @param strideDL - stride of the subdiagonal elements of `A` - * @param offsetDL - offset of the subdiagonal elements of `A` - * @param D - the `N` diagonal elements of `A` - * @param strideD - stride of the diagonal elements of `A` - * @param offsetD - offset of the diagonal elements of `A` - * @param DU - the `N-1` superdiagonal elements of `A` - * @param strideDU - stride of the first superdiagonal elements of `A` - * @param offsetDU - offset of the first superdiagonal elements of `A` - * @param DU2 - the `N-2` elements of the second superdiagonal of `A` - * @param strideDU2 - stride of the second superdiagonal elements of `A` - * @param offsetDU2 - offset of the second superdiagonal elements of `A` + * @param DL - sub diagonal elements of `A`. On exit, `DL` is overwritten by the multipliers that define the matrix `L` from the LU factorization of `A`. + * @param strideDL - stride length for `DL` + * @param offsetDL - starting index of `DL` + * @param D - diagonal elements of `A`. On exit, `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the LU factorization of `A`. + * @param strideD - stride length for `D` + * @param offsetD - starting index of `D` + * @param DU - super diagonal elements of `A`. On exit, `DU` is overwritten by the elements of the first super-diagonal of `U`. + * @param strideDU - stride length for `DU` + * @param offsetDU - starting index of `DU` + * @param DU2 - On exit, `DU2` is overwritten by the elements of the second super-diagonal of `U`. + * @param strideDU2 - stride length for `DU2` + * @param offsetDU2 - starting index of `DU2` * @param IPIV - vector of pivot indices - * @param strideIPIV - `IPIV` stride length - * @param offsetIPIV - index offset for `IPIV` + * @param strideIPIV - stride length for `IPIV` + * @param offsetIPIV - starting index of `IPIV` * @returns status code * * @example @@ -105,10 +105,10 @@ interface Routine { * LAPACK routine to compute an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges. * * @param N - order of matrix `A` -* @param DL - the `N-1` subdiagonal elements of `A` -* @param D - the `N` diagonal elements of `A` -* @param DU - the `N-1` superdiagonal elements of `A` -* @param DU2 - the `N-2` elements of the second superdiagonal of `A` +* @param DL - sub diagonal elements of `A`. On exit, `DL` is overwritten by the multipliers that define the matrix `L` from the LU factorization of `A`. +* @param D - diagonal elements of `A`. On exit, `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the LU factorization of `A`. +* @param DU - super diagonal elements of `A`. On exit, `DU` is overwritten by the elements of the first super-diagonal of `U`. +* @param DU2 - On exit, `DU2` is overwritten by the elements of the second super-diagonal of `U`. * @param IPIV - vector of pivot indices * @returns status code * diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js index 8ace95945d84..4b567b2d4e27 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js @@ -29,22 +29,22 @@ var abs = require( '@stdlib/math/base/special/abs' ); * Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges. * * @private -* @param {NonNegativeInteger} N - order of `A` -* @param {Float64Array} DL - sub diagonal elements of `A` -* @param {integer} strideDL - stride of the sub diagonal elements of `A` -* @param {NonNegativeInteger} offsetDL - offset of the sub diagonal elements of `A` -* @param {Float64Array} D - diagonal elements of `A` -* @param {integer} strideD - stride of the diagonal elements of `A` -* @param {NonNegativeInteger} offsetD - offset of the diagonal elements of `A` -* @param {Float64Array} DU - diagonal elements of `A` -* @param {integer} strideDU - stride of the first super diagonal elements of `A` -* @param {NonNegativeInteger} offsetDU - offset of the first super diagonal elements of `A` -* @param {Float64Array} DU2 - diagonal elements of `A` -* @param {integer} strideDU2 - stride of the second super diagonal elements of `A` -* @param {NonNegativeInteger} offsetDU2 - offset of the second super diagonal elements of `A` +* @param {NonNegativeInteger} N - order of matrix A +* @param {Float64Array} DL - sub diagonal elements of A. On exit, DL is overwritten by the multipliers that define the matrix L from the LU factorization of A. +* @param {integer} strideDL - stride length for `DL` +* @param {NonNegativeInteger} offsetDL - starting index of `DL` +* @param {Float64Array} D - diagonal elements of A. On exit, D is overwritten by the diagonal elements of the upper triangular matrix U from the LU factorization of A. +* @param {integer} strideD - stride length for `D` +* @param {NonNegativeInteger} offsetD - starting index of `D` +* @param {Float64Array} DU - super diagonal elements of A. On exit, DU is overwritten by the elements of the first super-diagonal of U. +* @param {integer} strideDU - stride length for `DU` +* @param {NonNegativeInteger} offsetDU - starting index of `DU` +* @param {Float64Array} DU2 - On exit, DU2 is overwritten by the elements of the second super-diagonal of U. +* @param {integer} strideDU2 - stride length for `DU2` +* @param {NonNegativeInteger} offsetDU2 - starting index of `DU2` * @param {Int32Array} IPIV - vector of pivot indices -* @param {integer} strideIPIV - `IPIV` stride length -* @param {NonNegativeInteger} offsetIPIV - index offset for `IPIV` +* @param {integer} strideIPIV - stride length for `IPIV` +* @param {NonNegativeInteger} offsetIPIV - starting index of `IPIV` * @returns {integer} status code * * @example diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js index d4402272f7a1..c7967678b4c7 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js @@ -29,11 +29,11 @@ var base = require( './base.js' ); /** * Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges. * -* @param {NonNegativeInteger} N - order of `A` -* @param {Float64Array} DL - sub diagonal elements of `A` -* @param {Float64Array} D - diagonal elements of `A` -* @param {Float64Array} DU - diagonal elements of `A` -* @param {Float64Array} DU2 - diagonal elements of `A` +* @param {NonNegativeInteger} N - order of matrix A +* @param {Float64Array} DL - sub diagonal elements of A. On exit, DL is overwritten by the multipliers that define the matrix L from the LU factorization of A. +* @param {Float64Array} D - diagonal elements of A. On exit, D is overwritten by the diagonal elements of the upper triangular matrix U from the LU factorization of A. +* @param {Float64Array} DU - super diagonal elements of A. On exit, DU is overwritten by the elements of the first super-diagonal of U. +* @param {Float64Array} DU2 - On exit, DU2 is overwritten by the elements of the second super-diagonal of U. * @param {Int32Array} IPIV - vector of pivot indices * @throws {RangeError} first argument must be a nonnegative integer * @returns {integer} status code diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js index fc4e71f8b47d..fe299c844255 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js @@ -29,22 +29,22 @@ var base = require( './base.js' ); /** * Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges and alternative indexing semantics. * -* @param {NonNegativeInteger} N - order of `A` -* @param {Float64Array} DL - sub diagonal elements of `A` -* @param {integer} strideDL - stride of the sub diagonal elements of `A` -* @param {NonNegativeInteger} offsetDL - offset of the sub diagonal elements of `A` -* @param {Float64Array} D - diagonal elements of `A` -* @param {integer} strideD - stride of the diagonal elements of `A` -* @param {NonNegativeInteger} offsetD - offset of the diagonal elements of `A` -* @param {Float64Array} DU - diagonal elements of `A` -* @param {integer} strideDU - stride of the first super diagonal elements of `A` -* @param {NonNegativeInteger} offsetDU - offset of the first super diagonal elements of `A` -* @param {Float64Array} DU2 - diagonal elements of `A` -* @param {integer} strideDU2 - stride of the second super diagonal elements of `A` -* @param {NonNegativeInteger} offsetDU2 - offset of the second super diagonal elements of `A` +* @param {NonNegativeInteger} N - order of matrix A +* @param {Float64Array} DL - sub diagonal elements of A. On exit, DL is overwritten by the multipliers that define the matrix L from the LU factorization of A. +* @param {integer} strideDL - stride length for `DL` +* @param {NonNegativeInteger} offsetDL - starting index of `DL` +* @param {Float64Array} D - diagonal elements of A. On exit, D is overwritten by the diagonal elements of the upper triangular matrix U from the LU factorization of A. +* @param {integer} strideD - stride length for `D` +* @param {NonNegativeInteger} offsetD - starting index of `D` +* @param {Float64Array} DU - super diagonal elements of A. On exit, DU is overwritten by the elements of the first super-diagonal of U. +* @param {integer} strideDU - stride length for `DU` +* @param {NonNegativeInteger} offsetDU - starting index of `DU` +* @param {Float64Array} DU2 - On exit, DU2 is overwritten by the elements of the second super-diagonal of U. +* @param {integer} strideDU2 - stride length for `DU2` +* @param {NonNegativeInteger} offsetDU2 - starting index of `DU2` * @param {Int32Array} IPIV - vector of pivot indices -* @param {integer} strideIPIV - `IPIV` stride length -* @param {NonNegativeInteger} offsetIPIV - index offset for `IPIV` +* @param {integer} strideIPIV - stride length for `IPIV` +* @param {NonNegativeInteger} offsetIPIV - starting index of `IPIV` * @throws {RangeError} first argument must be a nonnegative integer * @returns {integer} status code * From 10f32edcc3369f879a63baae9b65fbe1b708ae65 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Mon, 3 Mar 2025 08:47:15 +0000 Subject: [PATCH 06/25] test: add initial tests --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- type: pre_push_report description: Results of running various checks prior to pushing changes. report: - task: run_javascript_examples status: na - task: run_c_examples status: na - task: run_cpp_examples status: na - task: run_javascript_readme_examples status: na - task: run_c_benchmarks status: na - task: run_cpp_benchmarks status: na - task: run_fortran_benchmarks status: na - task: run_javascript_benchmarks status: na - task: run_julia_benchmarks status: na - task: run_python_benchmarks status: na - task: run_r_benchmarks status: na - task: run_javascript_tests status: passed --- --- .../lapack/base/dgttrf/test/test.dgttrf.js | 38 +++++++++ .../@stdlib/lapack/base/dgttrf/test/test.js | 82 +++++++++++++++++++ .../lapack/base/dgttrf/test/test.ndarray.js | 38 +++++++++ 3 files changed, 158 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js new file mode 100644 index 000000000000..6542accdcd02 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js @@ -0,0 +1,38 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var dgttrf = require( './../lib/dgttrf.js' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof dgttrf, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 6', function test( t ) { + t.strictEqual( dgttrf.length, 6, 'returns expected value' ); + t.end(); +}); diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.js new file mode 100644 index 000000000000..f2d3412beb8f --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.js @@ -0,0 +1,82 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var proxyquire = require( 'proxyquire' ); +var IS_BROWSER = require( '@stdlib/assert/is-browser' ); +var dgttrf = 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 dgttrf, '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 dgttrf.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 dgttrf = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire + }); + + t.strictEqual( dgttrf, 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 dgttrf; + var main; + + main = require( './../lib/dgttrf.js' ); + + dgttrf = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire + }); + + t.strictEqual( dgttrf, main, 'returns expected value' ); + t.end(); + + function tryRequire() { + return new Error( 'Cannot find module' ); + } +}); diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js new file mode 100644 index 000000000000..767511a97c0c --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js @@ -0,0 +1,38 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var dgttrf = require( './../lib/ndarray.js' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof dgttrf, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 16', function test( t ) { + t.strictEqual( dgttrf.length, 16, 'returns expected value' ); + t.end(); +}); From 87e755fff4badbaead3925ac197498951fb50115 Mon Sep 17 00:00:00 2001 From: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> Date: Mon, 3 Mar 2025 08:52:50 +0000 Subject: [PATCH 07/25] chore: update copyright years --- lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js | 2 +- lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.js | 2 +- .../@stdlib/lapack/base/dgttrf/test/test.ndarray.js | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js index 6542accdcd02..62bc11d528e6 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 The Stdlib Authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.js index f2d3412beb8f..5824cbe780af 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 The Stdlib Authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js index 767511a97c0c..22c2e704ae60 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 The Stdlib Authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. From 1e5ea18e9a57d1d80af7edb7cf81b0e8c9c21c51 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Mon, 3 Mar 2025 12:17:30 +0000 Subject: [PATCH 08/25] docs: shorter var names and add repl.txt --- type: pre_push_report description: Results of running various checks prior to pushing changes. report: - task: run_javascript_examples status: na - task: run_c_examples status: na - task: run_cpp_examples status: na - task: run_javascript_readme_examples status: na - task: run_c_benchmarks status: na - task: run_cpp_benchmarks status: na - task: run_fortran_benchmarks status: na - task: run_javascript_benchmarks status: na - task: run_julia_benchmarks status: na - task: run_python_benchmarks status: na - task: run_r_benchmarks status: na - task: run_javascript_tests status: na --- --- .../@stdlib/lapack/base/dgttrf/docs/repl.txt | 186 ++++++++++++++++++ .../lapack/base/dgttrf/docs/types/index.d.ts | 22 +-- .../@stdlib/lapack/base/dgttrf/lib/base.js | 88 ++++----- .../@stdlib/lapack/base/dgttrf/lib/ndarray.js | 24 +-- 4 files changed, 253 insertions(+), 67 deletions(-) create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt new file mode 100644 index 000000000000..e31c64639e8c --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt @@ -0,0 +1,186 @@ + +{{alias}}( N, DL, D, DU, DU2, IPIV ) + Computes an LU factorization of a real tri diagonal matrix A using + elimination with partial pivoting and row interchanges. + + Indexing is relative to the first index. To introduce an offset, use typed + array views. + + The function mutates `DL`, `D`, `DU`, `DU2` and `IPIV`. + + Parameters + ---------- + N: integer + Order of matrix `A`. + + DL: Float64Array + Sub diagonal elements of A. On exit, DL is overwritten by the + multipliers that define the matrix L from the LU factorization of A. + + D: Float64Array + Diagonal elements of A. On exit, D is overwritten by the diagonal + elements of the upper triangular matrix U from the LU factorization + of A. + + DU: Float64Array + Super diagonal elements of A. On exit, DU is overwritten by the + elements of the first super-diagonal of U. + + DU2: Float64Array + On exit, DU2 is overwritten by the elements of the second + super-diagonal of U. + + IPIV: Int32Array + Array of pivot indices. + + Returns + ------- + info: integer + Status code. The status code indicates the following conditions: + + - if equal to zero, then the factorization was successful. + - if less than zero, then the k-th argument had an illegal value, where + `k = -info`. + - if greater than zero, then U( k, k ) is exactly zero the factorization + has been completed, but the factor U is exactly singular, and division + by zero will occur if it is used to solve a system of equations, + where `k = StatusCode`. + + Examples + -------- + > var DL = new {{alias:@stdlib/array/float64}}( [ 1.0, 1.0 ] ); + > var D = new {{alias:@stdlib/array/float64}}( [ 2.0, 3.0, 1.0 ] ); + > var DU = new {{alias:@stdlib/array/float64}}( [ 1.0, 1.0 ] ); + > var DU2 = new {{alias:@stdlib/array/float64}}( 1 ); + > var IPIV = new {{alias:@stdlib/array/int32}}( 3 ); + > {{alias}}( 3, DL, D, DU, DU2, IPIV ) + 0 + > DL + [ 0.5, 0.4 ] + > D + [ 2, 2.5, 0.6 ] + > DU + [ 1, 1 ] + > DU2 + [ 0 ] + + // Using typed array views: + > var DL0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 1.0, 1.0 ] ); + > var D0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 2.0, 3.0, 1.0 ] ); + > var DU0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 1.0, 1.0 ] ); + > var DU2 = new {{alias:@stdlib/array/float64}}( 1 ); + > var IPIV = new {{alias:@stdlib/array/int32}}( 3 ); + > DL = new Float64Array( DL0.buffer, DL0.BYTES_PER_ELEMENT*1 ); + > D = new Float64Array( D0.buffer, D0.BYTES_PER_ELEMENT*1 ); + > DU = new Float64Array( DU0.buffer, DU0.BYTES_PER_ELEMENT*1 ); + > {{alias}}( 3, DL, D, DU, DU2, IPIV ) + 0 + > DL + [ 0.5, 0.4 ] + > D + [ 2, 2.5, 0.6 ] + > DU + [ 1, 1 ] + > DU2 + [ 0 ] + + +{{alias}}.ndarray( N, DL, sdl, odl, D, sd, od, DU, sdu, odu, DU2, sdu2, odu2, IPIV, si, oi ) + Computes an LU factorization of a real tri diagonal matrix A using + elimination with partial pivoting and row interchanges and alternative + indexing semantics. + + While typed array views mandate a view offset based on the underlying + buffer, the offset parameters support indexing semantics based on starting + indices. + + The function mutates `DL`, `D`, `DU`, `DU2` and `IPIV`. + + Parameters + ---------- + N: integer + Order of matrix `A`. + + DL: Float64Array + Sub diagonal elements of A. On exit, DL is overwritten by the + multipliers that define the matrix L from the LU factorization of A. + + sdl: integer + Stride length for `DL`. + + odl: integer + Starting index for `DL`. + + D: Float64Array + Diagonal elements of A. On exit, D is overwritten by the diagonal + elements of the upper triangular matrix U from the LU factorization + of A. + + sd: integer + Stride length for `D`. + + od: integer + Starting index for `D`. + + DU: Float64Array + Super diagonal elements of A. On exit, DU is overwritten by the + elements of the first super-diagonal of U. + + sdu: integer + Stride length for `DU`. + + odu: integer + Starting index for `DU2`. + + DU2: Float64Array + On exit, DU2 is overwritten by the elements of the second + super-diagonal of U. + + sdu2: integer + Stride length for `DU2`. + + odu2: integer + Starting index for `DU2`. + + IPIV: Int32Array + Array of pivot indices. + + si: integer + Stride length for `IPIV`. + + oi: integer + Starting index for `IPIV`. + + Returns + ------- + info: integer + Status code. The status code indicates the following conditions: + + - if equal to zero, then the factorization was successful. + - if less than zero, then the k-th argument had an illegal value, where + `k = -info`. + - if greater than zero, then U( k, k ) is exactly zero the factorization + has been completed, but the factor U is exactly singular, and division + by zero will occur if it is used to solve a system of equations, + where `k = StatusCode`. + + Examples + -------- + > var DL = new {{alias:@stdlib/array/float64}}( [ 1.0, 1.0 ] ); + > var D = new {{alias:@stdlib/array/float64}}( [ 2.0, 3.0, 1.0 ] ); + > var DU = new {{alias:@stdlib/array/float64}}( [ 1.0, 1.0 ] ); + > var DU2 = new {{alias:@stdlib/array/float64}}( 1 ); + > var IPIV = new {{alias:@stdlib/array/int32}}( 3 ); + > {{alias}}.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ) + 0 + > DL + [ 0.5, 0.4 ] + > D + [ 2, 2.5, 0.6 ] + > DU + [ 1, 1 ] + > DU2 + [ 0 ] + + See Also + -------- diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts index cbe7a17eb179..00189dcc5a0c 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts @@ -69,20 +69,20 @@ interface Routine { * * @param N - order of matrix `A` * @param DL - sub diagonal elements of `A`. On exit, `DL` is overwritten by the multipliers that define the matrix `L` from the LU factorization of `A`. - * @param strideDL - stride length for `DL` - * @param offsetDL - starting index of `DL` + * @param sdl - stride length for `DL` + * @param odl - starting index of `DL` * @param D - diagonal elements of `A`. On exit, `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the LU factorization of `A`. - * @param strideD - stride length for `D` - * @param offsetD - starting index of `D` + * @param sd - stride length for `D` + * @param od - starting index of `D` * @param DU - super diagonal elements of `A`. On exit, `DU` is overwritten by the elements of the first super-diagonal of `U`. - * @param strideDU - stride length for `DU` - * @param offsetDU - starting index of `DU` + * @param sdu - stride length for `DU` + * @param odu - starting index of `DU` * @param DU2 - On exit, `DU2` is overwritten by the elements of the second super-diagonal of `U`. - * @param strideDU2 - stride length for `DU2` - * @param offsetDU2 - starting index of `DU2` + * @param sdu2 - stride length for `DU2` + * @param odu2 - starting index of `DU2` * @param IPIV - vector of pivot indices - * @param strideIPIV - stride length for `IPIV` - * @param offsetIPIV - starting index of `IPIV` + * @param si - stride length for `IPIV` + * @param oi - starting index of `IPIV` * @returns status code * * @example @@ -98,7 +98,7 @@ interface Routine { * // DU => [ 1, 1 ] * // DU2 => [ 0 ] */ - ndarray( N: number, DL: Float64Array, strideDL: number, offsetDL: number, D: Float64Array, strideD: number, offsetD: number, DU: Float64Array, strideDU: number, offsetDU: number, DU2: Float64Array, strideDU2: number, offsetDU2: number, IPIV: Int32Array, strideIPIV: number, offsetIPIV: number ): StatusCode; + ndarray( N: number, DL: Float64Array, sdl: number, odl: number, D: Float64Array, sd: number, od: number, DU: Float64Array, sdu: number, odu: number, DU2: Float64Array, sdu2: number, odu2: number, IPIV: Int32Array, si: number, oi: number ): StatusCode; } /** diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js index 4b567b2d4e27..5aeea469a769 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js @@ -31,20 +31,20 @@ var abs = require( '@stdlib/math/base/special/abs' ); * @private * @param {NonNegativeInteger} N - order of matrix A * @param {Float64Array} DL - sub diagonal elements of A. On exit, DL is overwritten by the multipliers that define the matrix L from the LU factorization of A. -* @param {integer} strideDL - stride length for `DL` -* @param {NonNegativeInteger} offsetDL - starting index of `DL` +* @param {integer} sdl - stride length for `DL` +* @param {NonNegativeInteger} odl - starting index of `DL` * @param {Float64Array} D - diagonal elements of A. On exit, D is overwritten by the diagonal elements of the upper triangular matrix U from the LU factorization of A. -* @param {integer} strideD - stride length for `D` -* @param {NonNegativeInteger} offsetD - starting index of `D` +* @param {integer} sd - stride length for `D` +* @param {NonNegativeInteger} od - starting index of `D` * @param {Float64Array} DU - super diagonal elements of A. On exit, DU is overwritten by the elements of the first super-diagonal of U. -* @param {integer} strideDU - stride length for `DU` -* @param {NonNegativeInteger} offsetDU - starting index of `DU` +* @param {integer} sdu - stride length for `DU` +* @param {NonNegativeInteger} odu - starting index of `DU` * @param {Float64Array} DU2 - On exit, DU2 is overwritten by the elements of the second super-diagonal of U. -* @param {integer} strideDU2 - stride length for `DU2` -* @param {NonNegativeInteger} offsetDU2 - starting index of `DU2` +* @param {integer} sdu2 - stride length for `DU2` +* @param {NonNegativeInteger} odu2 - starting index of `DU2` * @param {Int32Array} IPIV - vector of pivot indices -* @param {integer} strideIPIV - stride length for `IPIV` -* @param {NonNegativeInteger} offsetIPIV - starting index of `IPIV` +* @param {integer} si - stride length for `IPIV` +* @param {NonNegativeInteger} oi - starting index of `IPIV` * @returns {integer} status code * * @example @@ -63,7 +63,7 @@ var abs = require( '@stdlib/math/base/special/abs' ); * // DU => [ 1, 1 ] * // DU2 => [ 0 ] */ -function dgttrf( N, DL, strideDL, offsetDL, D, strideD, offsetD, DU, strideDU, offsetDU, DU2, strideDU2, offsetDU2, IPIV, strideIPIV, offsetIPIV ) { // eslint-disable-line max-len, max-params +function dgttrf( N, DL, sdl, odl, D, sd, od, DU, sdu, odu, DU2, sdu2, odu2, IPIV, si, oi ) { // eslint-disable-line max-len, max-params var fact; var temp; var idu2; @@ -77,61 +77,61 @@ function dgttrf( N, DL, strideDL, offsetDL, D, strideD, offsetD, DU, strideDU, o return 0; } - idl = offsetDL; - id = offsetD; - idu = offsetDU; - idu2 = offsetDU2; - ip = offsetIPIV; + idl = odl; + id = od; + idu = odu; + idu2 = odu2; + ip = oi; for ( i = 0; i < N; i++ ) { - IPIV[ ip + (strideIPIV*i) ] = i; + IPIV[ ip + (si*i) ] = i; } for ( i = 0; i < N-2; i++ ) { - DU2[ idu + (strideDU*i) ] = 0; + DU2[ idu + (sdu*i) ] = 0; } for ( i = 0; i < N-2; i++ ) { - if ( abs( D[ id + (strideD*i) ] ) >= abs( DL[ idl + (strideDL*i) ] ) ) { // no row interchange required + if ( abs( D[ id + (sd*i) ] ) >= abs( DL[ idl + (sdl*i) ] ) ) { // no row interchange required if ( D[ id ] !== 0.0 ) { - fact = DL[ idl + (strideDL*i) ] / D[ id + (strideD*i) ]; - DL[ idl + (strideDL*i) ] = fact; - D[ id + (strideD*(i+1)) ] = D[ id + (strideD*(i+1)) ] - ( fact*DU[ idu + (strideDU*i) ] ); // eslint-disable-line max-len + fact = DL[ idl + (sdl*i) ] / D[ id + (sd*i) ]; + DL[ idl + (sdl*i) ] = fact; + D[ id + (sd*(i+1)) ] = D[ id + (sd*(i+1)) ] - ( fact*DU[ idu + (sdu*i) ] ); // eslint-disable-line max-len } } else { - fact = D[ id+(strideD*i) ] / DL[ idl+(strideDL*i) ]; - D[ id+(strideD*i) ] = DL[ idl+(strideDL*i) ]; - DL[ idl+(strideDL*i) ] = fact; - temp = DU[ idu+(strideDU*i) ]; - DU[ idu+(strideDU*i) ] = D[ id + (strideD*(i+1)) ]; - D[ id+(strideD*(i+1)) ] = temp - ( fact*D[ id+(strideD*(i+1)) ] ); - DU2[ idu2+(strideDU2*i) ] = DU[ idu+(strideDU*(i+1)) ]; - DU[ idu+(strideDU*(i+1)) ] = -fact*DU[ idu+(strideDU*(i+1)) ]; - IPIV[ ip+(strideIPIV*i) ] = i + 1; + fact = D[ id+(sd*i) ] / DL[ idl+(sdl*i) ]; + D[ id+(sd*i) ] = DL[ idl+(sdl*i) ]; + DL[ idl+(sdl*i) ] = fact; + temp = DU[ idu+(sdu*i) ]; + DU[ idu+(sdu*i) ] = D[ id + (sd*(i+1)) ]; + D[ id+(sd*(i+1)) ] = temp - ( fact*D[ id+(sd*(i+1)) ] ); + DU2[ idu2+(sdu2*i) ] = DU[ idu+(sdu*(i+1)) ]; + DU[ idu+(sdu*(i+1)) ] = -fact*DU[ idu+(sdu*(i+1)) ]; + IPIV[ ip+(si*i) ] = i + 1; } } if ( N > 1 ) { i = N - 2; - if ( abs( D[ id + (strideD*i) ] ) >= abs( DL[ idl + (strideDL*i) ] ) ) { - if ( D[ id + (strideD*i) ] !== 0 ) { - fact = DL[ idl + (strideDL*i) ] / D[ id + (strideD*i) ]; - DL[ idl + (strideDL*i) ] = fact; - D[ id + (strideD*(i+1)) ] = D[ id + (strideD*(i+1)) ] - (fact*DU[ idu + (strideDU*i) ]); // eslint-disable-line max-len + if ( abs( D[ id + (sd*i) ] ) >= abs( DL[ idl + (sdl*i) ] ) ) { + if ( D[ id + (sd*i) ] !== 0 ) { + fact = DL[ idl + (sdl*i) ] / D[ id + (sd*i) ]; + DL[ idl + (sdl*i) ] = fact; + D[ id + (sd*(i+1)) ] = D[ id + (sd*(i+1)) ] - (fact*DU[ idu + (sdu*i) ]); // eslint-disable-line max-len } } else { - fact = D[ id+(strideD*i) ] / DL[ idl+(strideDL*i) ]; - D[ id+(strideD*i) ] = DL[ idl+(strideDL*i) ]; - DL[ idl+(strideDL*i) ] = fact; - temp = DU[ idu+(strideDU*i) ]; - DU[ idu+(strideDU*i) ] = D[ id + (strideD*(i+1)) ]; - D[ id+(strideD*(i+1)) ] = temp - ( fact*D[ id+(strideD*(i+1)) ] ); - IPIV[ ip+(strideIPIV*i) ] = i + 1; + fact = D[ id+(sd*i) ] / DL[ idl+(sdl*i) ]; + D[ id+(sd*i) ] = DL[ idl+(sdl*i) ]; + DL[ idl+(sdl*i) ] = fact; + temp = DU[ idu+(sdu*i) ]; + DU[ idu+(sdu*i) ] = D[ id + (sd*(i+1)) ]; + D[ id+(sd*(i+1)) ] = temp - ( fact*D[ id+(sd*(i+1)) ] ); + IPIV[ ip+(si*i) ] = i + 1; } } for ( i = 0; i < N; i++ ) { - if ( D[ id+(strideD*i) ] === 0.0 ) { + if ( D[ id+(sd*i) ] === 0.0 ) { return i; } } diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js index fe299c844255..f866e066a30a 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js @@ -31,20 +31,20 @@ var base = require( './base.js' ); * * @param {NonNegativeInteger} N - order of matrix A * @param {Float64Array} DL - sub diagonal elements of A. On exit, DL is overwritten by the multipliers that define the matrix L from the LU factorization of A. -* @param {integer} strideDL - stride length for `DL` -* @param {NonNegativeInteger} offsetDL - starting index of `DL` +* @param {integer} sdl - stride length for `DL` +* @param {NonNegativeInteger} odl - starting index of `DL` * @param {Float64Array} D - diagonal elements of A. On exit, D is overwritten by the diagonal elements of the upper triangular matrix U from the LU factorization of A. -* @param {integer} strideD - stride length for `D` -* @param {NonNegativeInteger} offsetD - starting index of `D` +* @param {integer} sd - stride length for `D` +* @param {NonNegativeInteger} od - starting index of `D` * @param {Float64Array} DU - super diagonal elements of A. On exit, DU is overwritten by the elements of the first super-diagonal of U. -* @param {integer} strideDU - stride length for `DU` -* @param {NonNegativeInteger} offsetDU - starting index of `DU` +* @param {integer} sdu - stride length for `DU` +* @param {NonNegativeInteger} odu - starting index of `DU` * @param {Float64Array} DU2 - On exit, DU2 is overwritten by the elements of the second super-diagonal of U. -* @param {integer} strideDU2 - stride length for `DU2` -* @param {NonNegativeInteger} offsetDU2 - starting index of `DU2` +* @param {integer} sdu2 - stride length for `DU2` +* @param {NonNegativeInteger} odu2 - starting index of `DU2` * @param {Int32Array} IPIV - vector of pivot indices -* @param {integer} strideIPIV - stride length for `IPIV` -* @param {NonNegativeInteger} offsetIPIV - starting index of `IPIV` +* @param {integer} si - stride length for `IPIV` +* @param {NonNegativeInteger} oi - starting index of `IPIV` * @throws {RangeError} first argument must be a nonnegative integer * @returns {integer} status code * @@ -63,11 +63,11 @@ var base = require( './base.js' ); * // DU => [ 1, 1 ] * // DU2 => [ 0 ] */ -function dgttrf( N, DL, strideDL, offsetDL, D, strideD, offsetD, DU, strideDU, offsetDU, DU2, strideDU2, offsetDU2, IPIV, strideIPIV, offsetIPIV ) { // eslint-disable-line max-len, max-params +function dgttrf( N, DL, sdl, odl, D, sd, od, DU, sdu, odu, DU2, sdu2, odu2, IPIV, si, oi ) { // eslint-disable-line max-len, max-params if ( N < 0 ) { throw new RangeError( format( 'invalid argument. First argument must be a nonnegative integer. Value: `%d`.', N ) ); } - return base( N, DL, strideDL, offsetDL, D, strideD, offsetD, DU, strideDU, offsetDU, DU2, strideDU2, offsetDU2, IPIV, strideIPIV, offsetIPIV ); // eslint-disable-line max-len + return base( N, DL, sdl, odl, D, sd, od, DU, sdu, odu, DU2, sdu2, odu2, IPIV, si, oi ); // eslint-disable-line max-len } From e88ffbe1c38969d9b6e03e4f59e55dd9e56d1e5e Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Mon, 3 Mar 2025 13:20:59 +0000 Subject: [PATCH 09/25] test: add tests for dgttrf --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- type: pre_push_report description: Results of running various checks prior to pushing changes. report: - task: run_javascript_examples status: na - task: run_c_examples status: na - task: run_cpp_examples status: na - task: run_javascript_readme_examples status: na - task: run_c_benchmarks status: na - task: run_cpp_benchmarks status: na - task: run_fortran_benchmarks status: na - task: run_javascript_benchmarks status: na - task: run_julia_benchmarks status: na - task: run_python_benchmarks status: na - task: run_r_benchmarks status: na - task: run_javascript_tests status: passed --- --- .../@stdlib/lapack/base/dgttrf/lib/dgttrf.js | 1 + .../lapack/base/dgttrf/test/test.dgttrf.js | 166 ++++++++++++++++++ 2 files changed, 167 insertions(+) diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js index c7967678b4c7..5123de3160d2 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js @@ -53,6 +53,7 @@ var base = require( './base.js' ); * // D => [ 2, 2.5, 0.6 ] * // DU => [ 1, 1 ] * // DU2 => [ 0 ] +* // IPIV => [ 0, 1, 2 ] */ function dgttrf( N, DL, D, DU, DU2, IPIV ) { if ( N < 0 ) { diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js index 62bc11d528e6..b8f161068b31 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js @@ -21,9 +21,42 @@ // MODULES // var tape = require( 'tape' ); +var Float64Array = require( '@stdlib/array/float64' ); +var Int32Array = require( '@stdlib/array/int32' ); +var EPS = require( '@stdlib/constants/float64/eps' ); +var abs = require( '@stdlib/math/base/special/abs' ); var dgttrf = require( './../lib/dgttrf.js' ); +// FUNCTIONS // + +/** +* Tests for element-wise approximate equality. +* +* @private +* @param {Object} t - test object +* @param {Collection} actual - actual values +* @param {Collection} expected - expected values +* @param {number} rtol - relative tolerance +*/ +function isApprox( t, actual, expected, rtol ) { + var delta; + var tol; + var i; + + t.strictEqual( actual.length, expected.length, 'returns expected value' ); + for ( i = 0; i < expected.length; i++ ) { + if ( actual[ i ] === expected[ i ] ) { + t.strictEqual( actual[ i ], expected[ i ], 'returns expected value' ); + } else { + delta = abs( actual[ i ] - expected[ i ] ); + tol = rtol * EPS * abs( expected[ i ] ); + t.ok( delta <= tol, 'within tolerance. actual: '+actual[ i ]+'. expected: '+expected[ i ]+'. delta: '+delta+'. tol: '+tol+'.' ); + } + } +} + + // TESTS // tape( 'main export is a function', function test( t ) { @@ -36,3 +69,136 @@ tape( 'the function has an arity of 6', function test( t ) { t.strictEqual( dgttrf.length, 6, 'returns expected value' ); t.end(); }); + +tape( 'the function throws an error if provided a first argument which is less than zero', function test( t ) { + var values; + var IPIV; + var DU2; + var DU; + var DL; + var D; + var i; + + DL = new Float64Array( [ 1.0, 1.0 ] ); + D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); + DU = new Float64Array( [ 1.0, 1.0 ] ); + DU2 = new Float64Array( 1 ); + IPIV = new Int32Array( 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() { + dgttrf( value, DL, D, DU, DU2, IPIV ); + }; + } +}); + +tape( 'the function performs the `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges', function test( t ) { + var expectedIPIV; + var expectedDU2; + var expectedDU; + var expectedDL; + var expectedD; + var info; + var IPIV; + var DU2; + var DU; + var DL; + var D; + var N; + + N = 3; + + DL = new Float64Array( [ 1.0, 1.0 ] ); + D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); + DU = new Float64Array( [ 1.0, 1.0 ] ); + DU2 = new Float64Array( N-2 ); + IPIV = new Int32Array( N ); + + expectedDL = new Float64Array( [ 0.5, 0.4 ] ); + expectedD = new Float64Array( [ 2.0, 2.5, 0.6 ] ); + expectedDU = new Float64Array( [ 1.0, 1.0 ] ); + expectedDU2 = new Float64Array( [ 0.0 ] ); + expectedIPIV = new Int32Array( [ 0, 1, 2 ] ); + + info = dgttrf( N, DL, D, DU, DU2, IPIV ); + t.strictEqual( info, 0, 'returns expected value' ); + t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); + isApprox( t, D, expectedD, 1.0 ); + isApprox( t, DU, expectedDU, 1.0 ); + isApprox( t, DU2, expectedDU2, 1.0 ); + isApprox( t, DL, expectedDL, 1.0 ); + + N = 9; + + DL = new Float64Array( [ 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0 ] ); + D = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + DU = new Float64Array( [ 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0 ] ); + DU2 = new Float64Array( N-2 ); + IPIV = new Int32Array( N ); + + expectedDL = new Float64Array( [ 0.3333333333333333, 0.8181818181818182, 0.6969696969696969, 0.9082568807339449, 0.8493506493506494, -0.7991341991341993, 0.6251127548259066, -0.3327319742618318 ] ); // eslint-disable-line max-len + expectedD = new Float64Array( [ 3.0, 3.6666666666666665, 3.0, 3.3030303030303032, 3.5321100917431192, 3.0, 4.7991341991341994, 3.0, 4.3327319742618320 ] ); // eslint-disable-line max-len + expectedDU = new Float64Array( [ 1.0, -1.3333333333333333, 1.0, -2.7878787878787876, 4.0, 1.0, 3.1965367965367970, 1.0 ] ); // eslint-disable-line max-len + expectedDU2 = new Float64Array( [ 4.0, 0.0, 4.0, 0.0, 0.0, 4.0, 0.0 ] ); + expectedIPIV = new Int32Array( [ 1, 1, 3, 3, 4, 6, 6, 8, 8 ] ); + + info = dgttrf( N, DL, D, DU, DU2, IPIV ); + t.strictEqual( info, 0, 'returns expected value' ); + t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); + isApprox( t, D, expectedD, 1.0 ); + isApprox( t, DU, expectedDU, 1.0 ); + isApprox( t, DU2, expectedDU2, 1.0 ); + isApprox( t, DL, expectedDL, 1.0 ); + + t.end(); +}); + +tape( 'the function leaves the input arrays unchanged when `N` is equal to zero', function test( t ) { + var expectedIPIV; + var expectedDU2; + var expectedDU; + var expectedDL; + var expectedD; + var info; + var IPIV; + var DU2; + var DU; + var DL; + var D; + var N; + + N = 0; + + DL = new Float64Array( [ 1.0, 1.0 ] ); + D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); + DU = new Float64Array( [ 1.0, 1.0 ] ); + DU2 = new Float64Array( 1 ); + IPIV = new Int32Array( 3 ); + + expectedDL = new Float64Array( [ 1.0, 1.0 ] ); + expectedD = new Float64Array( [ 2.0, 3.0, 1.0 ] ); + expectedDU = new Float64Array( [ 1.0, 1.0 ] ); + expectedDU2 = new Float64Array( [ 0.0 ] ); + expectedIPIV = new Int32Array( [ 0, 0, 0 ] ); + + info = dgttrf( N, DL, D, DU, DU2, IPIV ); + t.strictEqual( info, 0, 'returns expected value' ); + t.deepEqual( DU, expectedDU, 'returns expected value' ); + t.deepEqual( DU2, expectedDU2, 'returns expected value' ); + t.deepEqual( D, expectedD, 'returns expected value' ); + t.deepEqual( DL, expectedDL, 'returns expected value' ); + t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); + + t.end(); +}); From b1bed1ba7cc02191de15c1141fd925bc899e13d0 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Mon, 3 Mar 2025 18:35:52 +0000 Subject: [PATCH 10/25] test: add complete tests for dgttrf --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- type: pre_push_report description: Results of running various checks prior to pushing changes. report: - task: run_javascript_examples status: na - task: run_c_examples status: na - task: run_cpp_examples status: na - task: run_javascript_readme_examples status: na - task: run_c_benchmarks status: na - task: run_cpp_benchmarks status: na - task: run_fortran_benchmarks status: na - task: run_javascript_benchmarks status: na - task: run_julia_benchmarks status: na - task: run_python_benchmarks status: na - task: run_r_benchmarks status: na - task: run_javascript_tests status: passed --- --- .../lapack/base/dgttrf/test/test.dgttrf.js | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js index b8f161068b31..c22842fdd610 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js @@ -164,6 +164,29 @@ tape( 'the function performs the `LU` factorization of a real tri diagonal matri t.end(); }); +tape( 'the function returns a non zero status code when a diagonal element is equal to zero', function test( t ) { + var info; + var IPIV; + var DU2; + var DU; + var DL; + var D; + var N; + + N = 3; + + DL = new Float64Array( [ 0.0, 0.0 ] ); + D = new Float64Array( [ 1.0, 1.0, 0.0 ] ); + DU = new Float64Array( [ 2.0, 3.0 ] ); + DU2 = new Float64Array( 1 ); + IPIV = new Int32Array( 3 ); + + info = dgttrf( N, DL, D, DU, DU2, IPIV ); + t.strictEqual( info, 2, 'returns expected value' ); + + t.end(); +}); + tape( 'the function leaves the input arrays unchanged when `N` is equal to zero', function test( t ) { var expectedIPIV; var expectedDU2; From 6e908a9bd7663e74b8d90d8faff38de0367993d1 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Mon, 3 Mar 2025 21:07:45 +0000 Subject: [PATCH 11/25] test: add ndarray tests --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- type: pre_push_report description: Results of running various checks prior to pushing changes. report: - task: run_javascript_examples status: na - task: run_c_examples status: na - task: run_cpp_examples status: na - task: run_javascript_readme_examples status: na - task: run_c_benchmarks status: na - task: run_cpp_benchmarks status: na - task: run_fortran_benchmarks status: na - task: run_javascript_benchmarks status: na - task: run_julia_benchmarks status: na - task: run_python_benchmarks status: na - task: run_r_benchmarks status: na - task: run_javascript_tests status: passed --- --- .../lapack/base/dgttrf/test/test.ndarray.js | 189 ++++++++++++++++++ 1 file changed, 189 insertions(+) diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js index 22c2e704ae60..ab07e3f82d30 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js @@ -21,9 +21,42 @@ // MODULES // var tape = require( 'tape' ); +var Float64Array = require( '@stdlib/array/float64' ); +var Int32Array = require( '@stdlib/array/int32' ); +var EPS = require( '@stdlib/constants/float64/eps' ); +var abs = require( '@stdlib/math/base/special/abs' ); var dgttrf = require( './../lib/ndarray.js' ); +// FUNCTIONS // + +/** +* Tests for element-wise approximate equality. +* +* @private +* @param {Object} t - test object +* @param {Collection} actual - actual values +* @param {Collection} expected - expected values +* @param {number} rtol - relative tolerance +*/ +function isApprox( t, actual, expected, rtol ) { + var delta; + var tol; + var i; + + t.strictEqual( actual.length, expected.length, 'returns expected value' ); + for ( i = 0; i < expected.length; i++ ) { + if ( actual[ i ] === expected[ i ] ) { + t.strictEqual( actual[ i ], expected[ i ], 'returns expected value' ); + } else { + delta = abs( actual[ i ] - expected[ i ] ); + tol = rtol * EPS * abs( expected[ i ] ); + t.ok( delta <= tol, 'within tolerance. actual: '+actual[ i ]+'. expected: '+expected[ i ]+'. delta: '+delta+'. tol: '+tol+'.' ); + } + } +} + + // TESTS // tape( 'main export is a function', function test( t ) { @@ -36,3 +69,159 @@ tape( 'the function has an arity of 16', function test( t ) { t.strictEqual( dgttrf.length, 16, 'returns expected value' ); t.end(); }); + +tape( 'the function throws an error if provided a first argument which is less than zero', function test( t ) { + var values; + var IPIV; + var DU2; + var DU; + var DL; + var D; + var i; + + DL = new Float64Array( [ 1.0, 1.0 ] ); + D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); + DU = new Float64Array( [ 1.0, 1.0 ] ); + DU2 = new Float64Array( 1 ); + IPIV = new Int32Array( 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() { + dgttrf( value, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); + }; + } +}); + +tape( 'the function performs the `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges', function test( t ) { + var expectedIPIV; + var expectedDU2; + var expectedDU; + var expectedDL; + var expectedD; + var info; + var IPIV; + var DU2; + var DU; + var DL; + var D; + var N; + + N = 3; + + DL = new Float64Array( [ 1.0, 1.0 ] ); + D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); + DU = new Float64Array( [ 1.0, 1.0 ] ); + DU2 = new Float64Array( N-2 ); + IPIV = new Int32Array( N ); + + expectedDL = new Float64Array( [ 0.5, 0.4 ] ); + expectedD = new Float64Array( [ 2.0, 2.5, 0.6 ] ); + expectedDU = new Float64Array( [ 1.0, 1.0 ] ); + expectedDU2 = new Float64Array( [ 0.0 ] ); + expectedIPIV = new Int32Array( [ 0, 1, 2 ] ); + + info = dgttrf( N, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); + t.strictEqual( info, 0, 'returns expected value' ); + t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); + isApprox( t, D, expectedD, 1.0 ); + isApprox( t, DU, expectedDU, 1.0 ); + isApprox( t, DU2, expectedDU2, 1.0 ); + isApprox( t, DL, expectedDL, 1.0 ); + + N = 9; + + DL = new Float64Array( [ 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0 ] ); + D = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + DU = new Float64Array( [ 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0 ] ); + DU2 = new Float64Array( N-2 ); + IPIV = new Int32Array( N ); + + expectedDL = new Float64Array( [ 0.3333333333333333, 0.8181818181818182, 0.6969696969696969, 0.9082568807339449, 0.8493506493506494, -0.7991341991341993, 0.6251127548259066, -0.3327319742618318 ] ); // eslint-disable-line max-len + expectedD = new Float64Array( [ 3.0, 3.6666666666666665, 3.0, 3.3030303030303032, 3.5321100917431192, 3.0, 4.7991341991341994, 3.0, 4.3327319742618320 ] ); // eslint-disable-line max-len + expectedDU = new Float64Array( [ 1.0, -1.3333333333333333, 1.0, -2.7878787878787876, 4.0, 1.0, 3.1965367965367970, 1.0 ] ); // eslint-disable-line max-len + expectedDU2 = new Float64Array( [ 4.0, 0.0, 4.0, 0.0, 0.0, 4.0, 0.0 ] ); + expectedIPIV = new Int32Array( [ 1, 1, 3, 3, 4, 6, 6, 8, 8 ] ); + + info = dgttrf( N, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); + t.strictEqual( info, 0, 'returns expected value' ); + t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); + isApprox( t, D, expectedD, 1.0 ); + isApprox( t, DU, expectedDU, 1.0 ); + isApprox( t, DU2, expectedDU2, 1.0 ); + isApprox( t, DL, expectedDL, 1.0 ); + + t.end(); +}); + +tape( 'the function leaves the input arrays unchanged when `N` is equal to zero', function test( t ) { + var expectedIPIV; + var expectedDU2; + var expectedDU; + var expectedDL; + var expectedD; + var info; + var IPIV; + var DU2; + var DU; + var DL; + var D; + var N; + + N = 0; + + DL = new Float64Array( [ 1.0, 1.0 ] ); + D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); + DU = new Float64Array( [ 1.0, 1.0 ] ); + DU2 = new Float64Array( 1 ); + IPIV = new Int32Array( 3 ); + + expectedDL = new Float64Array( [ 1.0, 1.0 ] ); + expectedD = new Float64Array( [ 2.0, 3.0, 1.0 ] ); + expectedDU = new Float64Array( [ 1.0, 1.0 ] ); + expectedDU2 = new Float64Array( [ 0.0 ] ); + expectedIPIV = new Int32Array( [ 0, 0, 0 ] ); + + info = dgttrf( N, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); + t.strictEqual( info, 0, 'returns expected value' ); + t.deepEqual( DU, expectedDU, 'returns expected value' ); + t.deepEqual( DU2, expectedDU2, 'returns expected value' ); + t.deepEqual( D, expectedD, 'returns expected value' ); + t.deepEqual( DL, expectedDL, 'returns expected value' ); + t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns a non zero status code when a diagonal element is equal to zero', function test( t ) { + var info; + var IPIV; + var DU2; + var DU; + var DL; + var D; + var N; + + N = 3; + + DL = new Float64Array( [ 0.0, 0.0 ] ); + D = new Float64Array( [ 1.0, 1.0, 0.0 ] ); + DU = new Float64Array( [ 2.0, 3.0 ] ); + DU2 = new Float64Array( 1 ); + IPIV = new Int32Array( 3 ); + + info = dgttrf( N, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); + t.strictEqual( info, 2, 'returns expected value' ); + + t.end(); +}); From 95bd130df044c7923601102886b4d0b7f7606f79 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Tue, 4 Mar 2025 02:06:45 +0000 Subject: [PATCH 12/25] fix: resolve lint error --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: passed - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- type: pre_push_report description: Results of running various checks prior to pushing changes. report: - task: run_javascript_examples status: na - task: run_c_examples status: na - task: run_cpp_examples status: na - task: run_javascript_readme_examples status: na - task: run_c_benchmarks status: na - task: run_cpp_benchmarks status: na - task: run_fortran_benchmarks status: na - task: run_javascript_benchmarks status: na - task: run_julia_benchmarks status: na - task: run_python_benchmarks status: na - task: run_r_benchmarks status: na - task: run_javascript_tests status: na --- --- lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt index e31c64639e8c..1ad207f74fbc 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt @@ -85,7 +85,7 @@ [ 0 ] -{{alias}}.ndarray( N, DL, sdl, odl, D, sd, od, DU, sdu, odu, DU2, sdu2, odu2, IPIV, si, oi ) +{{alias}}.ndarray( N,DL,sdl,odl,D,sd,od,DU,sdu,odu,DU2,sdu2,odu2,IPIV,si,oi ) Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges and alternative indexing semantics. From 89b7e763fb69dd57f4f3023d45067f82463f30e4 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Tue, 4 Mar 2025 06:20:58 +0000 Subject: [PATCH 13/25] test: complete all tests --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- type: pre_push_report description: Results of running various checks prior to pushing changes. report: - task: run_javascript_examples status: na - task: run_c_examples status: na - task: run_cpp_examples status: na - task: run_javascript_readme_examples status: na - task: run_c_benchmarks status: na - task: run_cpp_benchmarks status: na - task: run_fortran_benchmarks status: na - task: run_javascript_benchmarks status: na - task: run_julia_benchmarks status: na - task: run_python_benchmarks status: na - task: run_r_benchmarks status: na - task: run_javascript_tests status: passed --- --- .../lapack/base/dgttrf/test/test.ndarray.js | 200 ++++++++++++++++++ 1 file changed, 200 insertions(+) diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js index ab07e3f82d30..41db4f4b38f0 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js @@ -164,6 +164,206 @@ tape( 'the function performs the `LU` factorization of a real tri diagonal matri t.end(); }); +tape( 'the function supports providing positive strides', function test( t ) { + var expectedIPIV; + var expectedDU2; + var expectedDU; + var expectedDL; + var expectedD; + var info; + var IPIV; + var DU2; + var DU; + var DL; + var D; + var N; + + N = 3; + + DL = new Float64Array( [ 1.0, 9999.0, 1.0 ] ); + D = new Float64Array( [ 2.0, 9999.0, 3.0, 9999.0, 1.0 ] ); + DU = new Float64Array( [ 1.0, 9999.0, 1.0 ] ); + DU2 = new Float64Array( 2 * (N-2) ); + IPIV = new Int32Array( 2 * N ); + + expectedDL = new Float64Array( [ 0.5, 9999.0, 0.4 ] ); + expectedD = new Float64Array( [ 2.0, 9999.0, 2.5, 9999.0, 0.6 ] ); + expectedDU = new Float64Array( [ 1.0, 9999.0, 1.0 ] ); + expectedDU2 = new Float64Array( [ 0.0, 0.0 ] ); + expectedIPIV = new Int32Array( [ 0, 0, 1, 0, 2, 0 ] ); + + info = dgttrf( N, DL, 2, 0, D, 2, 0, DU, 2, 0, DU2, 2, 0, IPIV, 2, 0 ); + t.strictEqual( info, 0, 'returns expected value' ); + t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); + isApprox( t, D, expectedD, 1.0 ); + isApprox( t, DU, expectedDU, 1.0 ); + isApprox( t, DU2, expectedDU2, 1.0 ); + isApprox( t, DL, expectedDL, 1.0 ); + + N = 9; + + DL = new Float64Array( [ 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0, 3.0 ] ); // eslint-disable-line max-len + D = new Float64Array( [ 1.0, 9999.0, 1.0, 9999.0, 1.0, 9999.0, 1.0, 9999.0, 1.0, 9999.0, 1.0, 9999.0, 1.0, 9999.0, 1.0, 9999.0, 1.0 ] ); // eslint-disable-line max-len + DU = new Float64Array( [ 4.0, 9999.0, 4.0, 9999.0, 4.0, 9999.0, 4.0, 9999.0, 4.0, 9999.0, 4.0, 9999.0, 4.0, 9999.0, 4.0 ] ); // eslint-disable-line max-len + DU2 = new Float64Array( 2 * (N-2) ); + IPIV = new Int32Array( 2 * N ); + + expectedDL = new Float64Array( [ 0.3333333333333333, 9999.0, 0.8181818181818182, 9999.0, 0.6969696969696969, 9999.0, 0.9082568807339449, 9999.0, 0.8493506493506494, 9999.0, -0.7991341991341993, 9999.0, 0.6251127548259066, 9999.0, -0.3327319742618318 ] ); // eslint-disable-line max-len + expectedD = new Float64Array( [ 3.0, 9999.0, 3.6666666666666665, 9999.0, 3.0, 9999.0, 3.3030303030303032, 9999.0, 3.5321100917431192, 9999.0, 3.0, 9999.0, 4.7991341991341994, 9999.0, 3.0, 9999.0, 4.3327319742618320 ] ); // eslint-disable-line max-len + expectedDU = new Float64Array( [ 1.0, 9999.0, -1.3333333333333333, 9999.0, 1.0, 9999.0, -2.7878787878787876, 9999.0, 4.0, 9999.0, 1.0, 9999.0, 3.1965367965367970, 9999.0, 1.0 ] ); // eslint-disable-line max-len + expectedDU2 = new Float64Array( [ 4.0, 0.0, 0.0, 0.0, 4.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.0, 0.0, 0.0, 0.0 ] ); // eslint-disable-line max-len + expectedIPIV = new Int32Array( [ 1, 0, 1, 0, 3, 0, 3, 0, 4, 0, 6, 0, 6, 0, 8, 0, 8, 0 ] ); // eslint-disable-line max-len + + info = dgttrf( N, DL, 2, 0, D, 2, 0, DU, 2, 0, DU2, 2, 0, IPIV, 2, 0 ); + t.strictEqual( info, 0, 'returns expected value' ); + t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); + isApprox( t, D, expectedD, 1.0 ); + isApprox( t, DU, expectedDU, 1.0 ); + isApprox( t, DU2, expectedDU2, 1.0 ); + isApprox( t, DL, expectedDL, 1.0 ); + + t.end(); +}); + +tape( 'the function supports providing negative strides', function test( t ) { + var expectedIPIV; + var expectedDU2; + var expectedDU; + var expectedDL; + var expectedD; + var info; + var IPIV; + var DU2; + var DU; + var DL; + var D; + var N; + + N = 3; + + DL = new Float64Array( [ 1.0, 1.0 ] ); + D = new Float64Array( [ 1.0, 3.0, 2.0 ] ); + DU = new Float64Array( [ 1.0, 1.0 ] ); + DU2 = new Float64Array( N-2 ); + IPIV = new Int32Array( N ); + + expectedDL = new Float64Array( [ 0.4, 0.5 ] ); + expectedD = new Float64Array( [ 0.6, 2.5, 2.0 ] ); + expectedDU = new Float64Array( [ 1.0, 1.0 ] ); + expectedDU2 = new Float64Array( [ 0.0 ] ); + expectedIPIV = new Int32Array( [ 2, 1, 0 ] ); + + info = dgttrf( N, DL, -1, 1, D, -1, 2, DU, -1, 1, DU2, -1, 0, IPIV, -1, 2 ); + t.strictEqual( info, 0, 'returns expected value' ); + t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); + isApprox( t, D, expectedD, 1.0 ); + isApprox( t, DU, expectedDU, 1.0 ); + isApprox( t, DU2, expectedDU2, 1.0 ); + isApprox( t, DL, expectedDL, 1.0 ); + + t.end(); +}); + +tape( 'the function supports providing mixed strides', function test( t ) { + var expectedIPIV; + var expectedDU2; + var expectedDU; + var expectedDL; + var expectedD; + var info; + var IPIV; + var DU2; + var DU; + var DL; + var D; + var N; + + N = 3; + + DL = new Float64Array( [ 1.0, 1.0 ] ); + D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); + DU = new Float64Array( [ 1.0, 1.0 ] ); + DU2 = new Float64Array( N-2 ); + IPIV = new Int32Array( N ); + + expectedDL = new Float64Array( [ 0.4, 0.5 ] ); + expectedD = new Float64Array( [ 2.0, 2.5, 0.6 ] ); + expectedDU = new Float64Array( [ 1.0, 1.0 ] ); + expectedDU2 = new Float64Array( [ 0.0 ] ); + expectedIPIV = new Int32Array( [ 0, 1, 2 ] ); + + info = dgttrf( N, DL, -1, 1, D, 1, 0, DU, -1, 1, DU2, -1, 0, IPIV, 1, 0 ); + t.strictEqual( info, 0, 'returns expected value' ); + t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); + isApprox( t, D, expectedD, 1.0 ); + isApprox( t, DU, expectedDU, 1.0 ); + isApprox( t, DU2, expectedDU2, 1.0 ); + isApprox( t, DL, expectedDL, 1.0 ); + + t.end(); +}); + +tape( 'the function supports providing index offsets', function test( t ) { + var expectedIPIV; + var expectedDU2; + var expectedDU; + var expectedDL; + var expectedD; + var info; + var IPIV; + var DU2; + var DU; + var DL; + var D; + var N; + + N = 3; + + DL = new Float64Array( [ 9999.0, 1.0, 1.0 ] ); + D = new Float64Array( [ 9999.0, 2.0, 3.0, 1.0 ] ); + DU = new Float64Array( [ 9999.0, 1.0, 1.0 ] ); + DU2 = new Float64Array( N-2 + 1 ); + IPIV = new Int32Array( N + 1 ); + + expectedDL = new Float64Array( [ 9999.0, 0.5, 0.4 ] ); + expectedD = new Float64Array( [ 9999.0, 2.0, 2.5, 0.6 ] ); + expectedDU = new Float64Array( [ 9999.0, 1.0, 1.0 ] ); + expectedDU2 = new Float64Array( [ 0.0, 0.0 ] ); + expectedIPIV = new Int32Array( [ 0, 0, 1, 2 ] ); + + info = dgttrf( N, DL, 1, 1, D, 1, 1, DU, 1, 1, DU2, 1, 1, IPIV, 1, 1 ); + t.strictEqual( info, 0, 'returns expected value' ); + t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); + isApprox( t, D, expectedD, 1.0 ); + isApprox( t, DU, expectedDU, 1.0 ); + isApprox( t, DU2, expectedDU2, 1.0 ); + isApprox( t, DL, expectedDL, 1.0 ); + + N = 9; + + DL = new Float64Array( [ 9999.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0 ] ); + D = new Float64Array( [ 9999.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); // eslint-disable-line max-len + DU = new Float64Array( [ 9999.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0 ] ); + DU2 = new Float64Array( N-2 + 1 ); + IPIV = new Int32Array( N + 1 ); + + expectedDL = new Float64Array( [ 9999.0, 0.3333333333333333, 0.8181818181818182, 0.6969696969696969, 0.9082568807339449, 0.8493506493506494, -0.7991341991341993, 0.6251127548259066, -0.3327319742618318 ] ); // eslint-disable-line max-len + expectedD = new Float64Array( [ 9999.0, 3.0, 3.6666666666666665, 3.0, 3.3030303030303032, 3.5321100917431192, 3.0, 4.7991341991341994, 3.0, 4.3327319742618320 ] ); // eslint-disable-line max-len + expectedDU = new Float64Array( [ 9999.0, 1.0, -1.3333333333333333, 1.0, -2.7878787878787876, 4.0, 1.0, 3.1965367965367970, 1.0 ] ); // eslint-disable-line max-len + expectedDU2 = new Float64Array( [ 0.0, 4.0, 0.0, 4.0, 0.0, 0.0, 4.0, 0.0 ] ); // eslint-disable-line max-len + expectedIPIV = new Int32Array( [ 0, 1, 1, 3, 3, 4, 6, 6, 8, 8 ] ); + + info = dgttrf( N, DL, 1, 1, D, 1, 1, DU, 1, 1, DU2, 1, 1, IPIV, 1, 1 ); + t.strictEqual( info, 0, 'returns expected value' ); + t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); + isApprox( t, D, expectedD, 1.0 ); + isApprox( t, DU, expectedDU, 1.0 ); + isApprox( t, DU2, expectedDU2, 1.0 ); + isApprox( t, DL, expectedDL, 1.0 ); + + t.end(); +}); + tape( 'the function leaves the input arrays unchanged when `N` is equal to zero', function test( t ) { var expectedIPIV; var expectedDU2; From 50e4a6457edae7b82410b034ff53c789446dbdce Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Tue, 4 Mar 2025 07:08:48 +0000 Subject: [PATCH 14/25] docs: write some docs --- .../@stdlib/lapack/base/dgttrf/README.md | 284 ++++++++++++++++++ .../@stdlib/lapack/base/dgttrf/docs/repl.txt | 6 + .../lapack/base/dgttrf/docs/types/index.d.ts | 4 + .../lapack/base/dgttrf/examples/index.js | 1 + .../@stdlib/lapack/base/dgttrf/lib/base.js | 1 + .../@stdlib/lapack/base/dgttrf/lib/index.js | 3 + .../@stdlib/lapack/base/dgttrf/lib/ndarray.js | 1 + 7 files changed, 300 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/README.md diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md b/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md new file mode 100644 index 000000000000..cdf705f1e003 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md @@ -0,0 +1,284 @@ + + +# dgttrf + +> Compute an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. + +
+ +## Usage + +```javascript +var dgttrf = require( '@stdlib/lapack/base/dgttrf' ); +``` + +#### dgttrf( N, DL, D, DU, DU2, IPIV ) + +Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); +var Int32Array = require( '@stdlib/array/int32' ); + +var DL = new Float64Array( [ 1.0, 1.0 ] ); +var D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); +var DU = new Float64Array( [ 1.0, 1.0 ] ); +var DU2 = new Float64Array( 1 ); +var IPIV = new Int32Array( 3 ); + +dgttrf( 3, DL, D, DU, DU2, IPIV ); +// DL => [ 0.5, 0.4 ] +// D => [ 2, 2.5, 0.6 ] +// DU => [ 1, 1 ] +// DU2 => [ 0 ] +// IPIV => [ 0, 1, 2 ] +``` + +The function has the following parameters: + +- **N**: order of matrix `A`. +- **DL**: the sub diagonall elements of `A` as a [`Float64Array`][mdn-float64array]. On exit, DL is overwritten by the multipliers that define the matrix `L` from the `LU` factorization of `A`. +- **D**: the diagonal elements of `A` as a [`Float64Array`][mdn-float64array]. On exit, D is overwritten by the diagonal elements of the upper triangular matrix `U` from the `LU` factorization of `A`. +- **DU**: the super diagonal elements of `A` as a [`Float64Array`][mdn-float64array]. On exit, DU is overwritten by the elements of the first super-diagonal of `U`. +- **DU2**: On exit, DU2 is overwritten by the elements of the second super-diagonal of `U` as a [`Float64Array`][mdn-float64array]. +- **IPIV**: vector of pivot indices as a [`Int32Array`][mdn-int32array]. + +Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views. + + + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); + +// Initial arrays... +var D0 = new Float64Array( [ 0.0, 4.0, 5.0, 6.0 ] ); +var E0 = new Float64Array( [ 0.0, 1.0, 2.0 ] ); + +// Create offset views... +var D1 = new Float64Array( D0.buffer, D0.BYTES_PER_ELEMENT*1 ); // start at 2nd element +var E1 = new Float64Array( E0.buffer, E0.BYTES_PER_ELEMENT*1 ); // start at 2nd element + +dgttrf( 3, D1, E1 ); +// D0 => [ 0.0, 4.0, 4.75, ~5.15789 ] +// E0 => [ 0.0, 0.25, ~0.4210 ] +``` + +#### dgttrf.ndarray( N, D, strideD, offsetD, E, strideE, offsetE ) + +Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges and alternative indexing semantics. + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); +var Int32Array = require( '@stdlib/array/int32' ); +var dgttrf = require( '@stdlib/lapack/base/dgttrf' ); + +var DL = new Float64Array( [ 1.0, 1.0 ] ); +var D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); +var DU = new Float64Array( [ 1.0, 1.0 ] ); +var DU2 = new Float64Array( 1 ); +var IPIV = new Int32Array( 3 ); + +dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); +// DL => [ 0.5, 0.4 ] +// D => [ 2, 2.5, 0.6 ] +// DU => [ 1, 1 ] +// DU2 => [ 0 ] +// IPIV => [ 0, 1, 2 ] +``` + +The function has the following additional parameters: + +- **strideD**: stride length for `D`. +- **offsetD**: starting index for `D`. +- **strideE**: stride length for `E`. +- **offsetE**: starting index for `E`. + +While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameters support indexing semantics based on starting indices. For example, + + + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); + +var D = new Float64Array( [ 0.0, 4.0, 5.0, 6.0 ] ); +var E = new Float64Array( [ 0.0, 1.0, 2.0 ] ); + +dgttrf.ndarray( 3, D, 1, 1, E, 1, 1 ); +// D => [ 0.0, 4.0, 4.75, ~5.15789 ] +// E => [ 0.0, 0.25, ~0.4210 ] +``` + +
+ + + +
+ +## Notes + +- Both functions mutate the input arrays `DL`, `D`, `DU`, `DU2` and `IPIV`. + +- Both functions return a status code indicating success or failure. A status code indicates the following conditions: + + - `0`: factorization was successful. + - `<0`: the k-th argument had an illegal value, where `-k` equals the status code value. + - `>0`: `U( k, k )` is exactly zero the factorization has been completed, but the factor `U` is exactly singular, and division + by zero will occur if it is used to solve a system of equations, where `k` equals the status code value. + +- `dgttrf()` corresponds to the [LAPACK][LAPACK] routine [`dgttrf`][lapack-dgttrf]. + +
+ + + +
+ +## Examples + + + +```javascript +var Int32Array = require( '@stdlib/array/int32' ); +var Float64Array = require( '@stdlib/array/float64' ); +var dgttrf = require( '@stdlib/lapack/base/dgttrf' ); + +var N = 9; + +var DL = new Float64Array( [ 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0 ] ); + +var D = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + +var DU = new Float64Array( [ 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0 ] ); + +var DU2 = new Float64Array( N-2 ); + +var IPIV = new Int32Array( N ); + +// Perform the `A = LU` factorization: +var info = dgttrf( N, DL, D, DU, DU2, IPIV ); + +console.log( DL ); +console.log( D ); +console.log( DU ); +console.log( DU2 ); +console.log( IPIV ); +console.log( info ); +``` + +
+ + + + + +* * * + +
+ +## C APIs + + + +
+ +
+ + + + + +
+ +### Usage + +```c +TODO +``` + +#### TODO + +TODO. + +```c +TODO +``` + +TODO + +```c +TODO +``` + +
+ + + + + +
+ +
+ + + + + +
+ +### Examples + +```c +TODO +``` + +
+ + + +
+ + + + + +
+ +
+ + + + + +
+ +[lapack]: https://www.netlib.org/lapack/explore-html/ + +[lapack-dgttrf]: https://www.netlib.org/lapack/explore-html/d6/d46/group__gttrf_ga8d1e46216e6c861c89bd4328b8be52a1.html#ga8d1e46216e6c861c89bd4328b8be52a1 + +[mdn-float64array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array + +[mdn-int32array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int32Array + +[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray + +
+ + diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt index 1ad207f74fbc..06f3708d9338 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt @@ -63,6 +63,8 @@ [ 1, 1 ] > DU2 [ 0 ] + > IPIV + [ 0, 1, 2 ] // Using typed array views: > var DL0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 1.0, 1.0 ] ); @@ -83,6 +85,8 @@ [ 1, 1 ] > DU2 [ 0 ] + > IPIV + [ 0, 1, 2 ] {{alias}}.ndarray( N,DL,sdl,odl,D,sd,od,DU,sdu,odu,DU2,sdu2,odu2,IPIV,si,oi ) @@ -181,6 +185,8 @@ [ 1, 1 ] > DU2 [ 0 ] + > IPIV + [ 0, 1, 2 ] See Also -------- diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts index 00189dcc5a0c..342cda92cd6d 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts @@ -61,6 +61,7 @@ interface Routine { * // D => [ 2, 2.5, 0.6 ] * // DU => [ 1, 1 ] * // DU2 => [ 0 ] + * // IPIV => [ 0, 1, 2 ] */ ( N: number, DL: Float64Array, D: Float64Array, DU: Float64Array, DU2: Float64Array, IPIV: Int32Array ): StatusCode; @@ -97,6 +98,7 @@ interface Routine { * // D => [ 2, 2.5, 0.6 ] * // DU => [ 1, 1 ] * // DU2 => [ 0 ] + * // IPIV => [ 0, 1, 2 ] */ ndarray( N: number, DL: Float64Array, sdl: number, odl: number, D: Float64Array, sd: number, od: number, DU: Float64Array, sdu: number, odu: number, DU2: Float64Array, sdu2: number, odu2: number, IPIV: Int32Array, si: number, oi: number ): StatusCode; } @@ -127,6 +129,7 @@ interface Routine { * // D => [ 2, 2.5, 0.6 ] * // DU => [ 1, 1 ] * // DU2 => [ 0 ] +* // IPIV => [ 0, 1, 2 ] * * @example * var Float64Array = require( '@stdlib/array/float64' ); @@ -143,6 +146,7 @@ interface Routine { * // D => [ 2, 2.5, 0.6 ] * // DU => [ 1, 1 ] * // DU2 => [ 0 ] +* // IPIV => [ 0, 1, 2 ] */ declare var dgttrf: Routine; diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/examples/index.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/examples/index.js index b553e5e91206..1e076ffbd5a7 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/examples/index.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/examples/index.js @@ -34,6 +34,7 @@ var DU2 = new Float64Array( N-2 ); var IPIV = new Int32Array( N ); +// Perform the `A = LU` factorization: var info = dgttrf( N, DL, D, DU, DU2, IPIV ); console.log( DL ); diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js index 5aeea469a769..4a42f9815cf6 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js @@ -62,6 +62,7 @@ var abs = require( '@stdlib/math/base/special/abs' ); * // D => [ 2, 2.5, 0.6 ] * // DU => [ 1, 1 ] * // DU2 => [ 0 ] +* // IPIV => [ 0, 1, 2 ] */ function dgttrf( N, DL, sdl, odl, D, sd, od, DU, sdu, odu, DU2, sdu2, odu2, IPIV, si, oi ) { // eslint-disable-line max-len, max-params var fact; diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js index 80209750b116..4f29baf2d708 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js @@ -25,6 +25,7 @@ * * @example * var Float64Array = require( '@stdlib/array/float64' ); +* var Int32Array = require( '@stdlib/array/int32' ); * var dgttrf = require( '@stdlib/lapack/base/dgttrf' ); * * var DL = new Float64Array( [ 1.0, 1.0 ] ); @@ -38,6 +39,7 @@ * // D => [ 2, 2.5, 0.6 ] * // DU => [ 1, 1 ] * // DU2 => [ 0 ] +* // IPIV => [ 0, 1, 2 ] * * @example * var Float64Array = require( '@stdlib/array/float64' ); @@ -55,6 +57,7 @@ * // D => [ 2, 2.5, 0.6 ] * // DU => [ 1, 1 ] * // DU2 => [ 0 ] +* // IPIV => [ 0, 1, 2 ] */ // MODULES // diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js index f866e066a30a..11cf2e41ffd8 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js @@ -62,6 +62,7 @@ var base = require( './base.js' ); * // D => [ 2, 2.5, 0.6 ] * // DU => [ 1, 1 ] * // DU2 => [ 0 ] +* // IPIV => [ 0, 1, 2 ] */ function dgttrf( N, DL, sdl, odl, D, sd, od, DU, sdu, odu, DU2, sdu2, odu2, IPIV, si, oi ) { // eslint-disable-line max-len, max-params if ( N < 0 ) { From 6ab337bd431c0dac8fe191fb13646cf39376d992 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Tue, 4 Mar 2025 13:34:10 +0000 Subject: [PATCH 15/25] docs: complete writing readme --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: passed - task: lint_package_json status: na - task: lint_repl_help status: passed - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- type: pre_push_report description: Results of running various checks prior to pushing changes. report: - task: run_javascript_examples status: passed - task: run_c_examples status: na - task: run_cpp_examples status: na - task: run_javascript_readme_examples status: passed - task: run_c_benchmarks status: na - task: run_cpp_benchmarks status: na - task: run_fortran_benchmarks status: na - task: run_javascript_benchmarks status: na - task: run_julia_benchmarks status: na - task: run_python_benchmarks status: na - task: run_r_benchmarks status: na - task: run_javascript_tests status: na --- --- .../@stdlib/lapack/base/dgttrf/README.md | 64 +++++++++++++------ .../@stdlib/lapack/base/dgttrf/docs/repl.txt | 12 ++-- 2 files changed, 50 insertions(+), 26 deletions(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md b/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md index cdf705f1e003..b464ae9b4c4c 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md @@ -67,21 +67,33 @@ Note that indexing is relative to the first index. To introduce an offset, use [ ```javascript var Float64Array = require( '@stdlib/array/float64' ); +var Int32Array = require( '@stdlib/array/int32' ); // Initial arrays... -var D0 = new Float64Array( [ 0.0, 4.0, 5.0, 6.0 ] ); -var E0 = new Float64Array( [ 0.0, 1.0, 2.0 ] ); +var DL0 = new Float64Array( [ 0.0, 1.0, 1.0 ] ); +var D0 = new Float64Array( [ 0.0, 2.0, 3.0, 1.0 ] ); +var DU0 = new Float64Array( [ 0.0, 1.0, 1.0 ] ); +var DU20 = new Float64Array( 2 ); +var IPIV0 = new Int32Array( 4 ); // Create offset views... -var D1 = new Float64Array( D0.buffer, D0.BYTES_PER_ELEMENT*1 ); // start at 2nd element -var E1 = new Float64Array( E0.buffer, E0.BYTES_PER_ELEMENT*1 ); // start at 2nd element +var DL = new Float64Array( DL0.buffer, DL0.BYTES_PER_ELEMENT*1 ); // start at 2nd element +var D = new Float64Array( D0.buffer, D0.BYTES_PER_ELEMENT*1 ); // start at 2nd element +var DU = new Float64Array( DU0.buffer, DU0.BYTES_PER_ELEMENT*1 ); // start at 2nd element +var DU2 = new Float64Array( DU20.buffer, DU20.BYTES_PER_ELEMENT*1 ); // start at 2nd element +var IPIV = new Int32Array( IPIV0.buffer, IPIV0.BYTES_PER_ELEMENT*1 ); // start at 2nd element -dgttrf( 3, D1, E1 ); -// D0 => [ 0.0, 4.0, 4.75, ~5.15789 ] -// E0 => [ 0.0, 0.25, ~0.4210 ] +dgttrf( 3, DL, D, DU, DU2, IPIV ); +// DL0 => [ 0, 0.5, 0.4 ] +// D0 => [ 0, 2, 2.5, 0.6 ] +// DU0 => [ 0, 1, 1 ] +// DU20 => [ 0, 0 ] +// IPIV0 => [ 0, 0, 1, 2 ] ``` -#### dgttrf.ndarray( N, D, strideD, offsetD, E, strideE, offsetE ) + + +#### dgttrf.ndarray( N, DL, sdl, odl, D, sd, od, DU, sdu, odu, DU2, sdu2, odu2, IPIV, si, oi ) Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges and alternative indexing semantics. @@ -106,10 +118,16 @@ dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); The function has the following additional parameters: -- **strideD**: stride length for `D`. -- **offsetD**: starting index for `D`. -- **strideE**: stride length for `E`. -- **offsetE**: starting index for `E`. +- **sdl**: stride length for `DL`. +- **odl**: starting index for `DL`. +- **sd**: stride length for `D`. +- **od**: starting index for `D`. +- **sdu**: stride length for `DU`. +- **odu**: starting index for `DU`. +- **sdu2**: stride length for `DU2`. +- **odu2**: starting index for `DU2`. +- **si**: stride length for `IPIV`. +- **oi**: starting index for `IPIV`. While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameters support indexing semantics based on starting indices. For example, @@ -117,13 +135,20 @@ While [`typed array`][mdn-typed-array] views mandate a view offset based on the ```javascript var Float64Array = require( '@stdlib/array/float64' ); +var Int32Array = require( '@stdlib/array/int32' ); -var D = new Float64Array( [ 0.0, 4.0, 5.0, 6.0 ] ); -var E = new Float64Array( [ 0.0, 1.0, 2.0 ] ); - -dgttrf.ndarray( 3, D, 1, 1, E, 1, 1 ); -// D => [ 0.0, 4.0, 4.75, ~5.15789 ] -// E => [ 0.0, 0.25, ~0.4210 ] +var DL = new Float64Array( [ 0.0, 1.0, 1.0 ] ); +var D = new Float64Array( [ 0.0, 2.0, 3.0, 1.0 ] ); +var DU = new Float64Array( [ 0.0, 1.0, 1.0 ] ); +var DU2 = new Float64Array( 2 ); +var IPIV = new Int32Array( 4 ); + +dgttrf.ndarray( 3, DL, 1, 1, D, 1, 1, DU, 1, 1, DU2, 1, 1, IPIV, 1, 1 ); +// DL => [ 0, 0.5, 0.4 ] +// D => [ 0, 2, 2.5, 0.6 ] +// DU => [ 0, 1, 1 ] +// DU2 => [ 0, 0 ] +// IPIV => [ 0, 0, 1, 2 ] ``` @@ -140,8 +165,7 @@ dgttrf.ndarray( 3, D, 1, 1, E, 1, 1 ); - `0`: factorization was successful. - `<0`: the k-th argument had an illegal value, where `-k` equals the status code value. - - `>0`: `U( k, k )` is exactly zero the factorization has been completed, but the factor `U` is exactly singular, and division - by zero will occur if it is used to solve a system of equations, where `k` equals the status code value. + - `>0`: `U( k, k )` is exactly zero the factorization has been completed, but the factor `U` is exactly singular, and division by zero will occur if it is used to solve a system of equations, where `k` equals the status code value. - `dgttrf()` corresponds to the [LAPACK][LAPACK] routine [`dgttrf`][lapack-dgttrf]. diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt index 06f3708d9338..6da339230a98 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt @@ -77,12 +77,12 @@ > DU = new Float64Array( DU0.buffer, DU0.BYTES_PER_ELEMENT*1 ); > {{alias}}( 3, DL, D, DU, DU2, IPIV ) 0 - > DL - [ 0.5, 0.4 ] - > D - [ 2, 2.5, 0.6 ] - > DU - [ 1, 1 ] + > DL0 + [ 0, 0.5, 0.4 ] + > D0 + [ 0, 2, 2.5, 0.6 ] + > DU0 + [ 0, 1, 1 ] > DU2 [ 0 ] > IPIV From 90450eb0b98590419c1962e0449475106870394f Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Tue, 4 Mar 2025 14:11:46 +0000 Subject: [PATCH 16/25] chore: cleaning up --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: passed - task: lint_package_json status: na - task: lint_repl_help status: passed - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- type: pre_push_report description: Results of running various checks prior to pushing changes. report: - task: run_javascript_examples status: na - task: run_c_examples status: na - task: run_cpp_examples status: na - task: run_javascript_readme_examples status: passed - task: run_c_benchmarks status: na - task: run_cpp_benchmarks status: na - task: run_fortran_benchmarks status: na - task: run_javascript_benchmarks status: na - task: run_julia_benchmarks status: na - task: run_python_benchmarks status: na - task: run_r_benchmarks status: na - task: run_javascript_tests status: na --- --- .../@stdlib/lapack/base/dgttrf/README.md | 2 +- .../@stdlib/lapack/base/dgttrf/docs/repl.txt | 14 +++++++----- .../lapack/base/dgttrf/docs/types/index.d.ts | 22 +++++++++---------- .../@stdlib/lapack/base/dgttrf/lib/base.js | 10 ++++----- .../@stdlib/lapack/base/dgttrf/lib/dgttrf.js | 8 +++---- .../@stdlib/lapack/base/dgttrf/lib/ndarray.js | 8 +++---- 6 files changed, 33 insertions(+), 31 deletions(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md b/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md index b464ae9b4c4c..80252f7ece39 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md @@ -2,7 +2,7 @@ @license Apache-2.0 -Copyright (c) 2024 The Stdlib Authors. +Copyright (c) 2025 The Stdlib Authors. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt index 6da339230a98..c7d71cd2a55e 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt @@ -70,11 +70,13 @@ > var DL0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 1.0, 1.0 ] ); > var D0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 2.0, 3.0, 1.0 ] ); > var DU0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 1.0, 1.0 ] ); - > var DU2 = new {{alias:@stdlib/array/float64}}( 1 ); - > var IPIV = new {{alias:@stdlib/array/int32}}( 3 ); + > var DU20 = new {{alias:@stdlib/array/float64}}( 2 ); + > var IPIV0 = new {{alias:@stdlib/array/int32}}( 4 ); > DL = new Float64Array( DL0.buffer, DL0.BYTES_PER_ELEMENT*1 ); > D = new Float64Array( D0.buffer, D0.BYTES_PER_ELEMENT*1 ); > DU = new Float64Array( DU0.buffer, DU0.BYTES_PER_ELEMENT*1 ); + > DU2 = new Float64Array( DU20.buffer, DU20.BYTES_PER_ELEMENT*1 ); + > IPIV = new Int32Array( IPIV0.buffer, IPIV0.BYTES_PER_ELEMENT*1 ); > {{alias}}( 3, DL, D, DU, DU2, IPIV ) 0 > DL0 @@ -83,10 +85,10 @@ [ 0, 2, 2.5, 0.6 ] > DU0 [ 0, 1, 1 ] - > DU2 - [ 0 ] - > IPIV - [ 0, 1, 2 ] + > DU20 + [ 0, 0 ] + > IPIV0 + [ 0, 0, 1, 2 ] {{alias}}.ndarray( N,DL,sdl,odl,D,sd,od,DU,sdu,odu,DU2,sdu2,odu2,IPIV,si,oi ) diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts index 342cda92cd6d..fa07fa66e369 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts @@ -39,10 +39,10 @@ interface Routine { * Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges. * * @param N - order of matrix `A` - * @param DL - sub diagonal elements of `A`. On exit, `DL` is overwritten by the multipliers that define the matrix `L` from the LU factorization of `A`. - * @param D - diagonal elements of `A`. On exit, `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the LU factorization of `A`. - * @param DU - super diagonal elements of `A`. On exit, `DU` is overwritten by the elements of the first super-diagonal of `U`. - * @param DU2 - On exit, `DU2` is overwritten by the elements of the second super-diagonal of `U`. + * @param DL - sub diagonal elements of `A`. On exit, `DL` is overwritten by the multipliers that define the matrix `L` from the LU factorization of `A` + * @param D - diagonal elements of `A`. On exit, `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the LU factorization of `A` + * @param DU - super diagonal elements of `A`. On exit, `DU` is overwritten by the elements of the first super-diagonal of `U` + * @param DU2 - On exit, `DU2` is overwritten by the elements of the second super-diagonal of `U` * @param IPIV - vector of pivot indices * @returns status code * @@ -69,16 +69,16 @@ interface Routine { * Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges and alternative indexing semantics. * * @param N - order of matrix `A` - * @param DL - sub diagonal elements of `A`. On exit, `DL` is overwritten by the multipliers that define the matrix `L` from the LU factorization of `A`. + * @param DL - sub diagonal elements of `A`. On exit, `DL` is overwritten by the multipliers that define the matrix `L` from the LU factorization of `A` * @param sdl - stride length for `DL` * @param odl - starting index of `DL` - * @param D - diagonal elements of `A`. On exit, `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the LU factorization of `A`. + * @param D - diagonal elements of `A`. On exit, `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the LU factorization of `A` * @param sd - stride length for `D` * @param od - starting index of `D` * @param DU - super diagonal elements of `A`. On exit, `DU` is overwritten by the elements of the first super-diagonal of `U`. * @param sdu - stride length for `DU` * @param odu - starting index of `DU` - * @param DU2 - On exit, `DU2` is overwritten by the elements of the second super-diagonal of `U`. + * @param DU2 - On exit, `DU2` is overwritten by the elements of the second super-diagonal of `U` * @param sdu2 - stride length for `DU2` * @param odu2 - starting index of `DU2` * @param IPIV - vector of pivot indices @@ -107,10 +107,10 @@ interface Routine { * LAPACK routine to compute an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges. * * @param N - order of matrix `A` -* @param DL - sub diagonal elements of `A`. On exit, `DL` is overwritten by the multipliers that define the matrix `L` from the LU factorization of `A`. -* @param D - diagonal elements of `A`. On exit, `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the LU factorization of `A`. -* @param DU - super diagonal elements of `A`. On exit, `DU` is overwritten by the elements of the first super-diagonal of `U`. -* @param DU2 - On exit, `DU2` is overwritten by the elements of the second super-diagonal of `U`. +* @param DL - sub diagonal elements of `A`. On exit, `DL` is overwritten by the multipliers that define the matrix `L` from the LU factorization of `A` +* @param D - diagonal elements of `A`. On exit, `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the LU factorization of `A` +* @param DU - super diagonal elements of `A`. On exit, `DU` is overwritten by the elements of the first super-diagonal of `U` +* @param DU2 - On exit, `DU2` is overwritten by the elements of the second super-diagonal of `U` * @param IPIV - vector of pivot indices * @returns status code * diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js index 4a42f9815cf6..9ed36d22d6a7 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js @@ -29,17 +29,17 @@ var abs = require( '@stdlib/math/base/special/abs' ); * Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges. * * @private -* @param {NonNegativeInteger} N - order of matrix A -* @param {Float64Array} DL - sub diagonal elements of A. On exit, DL is overwritten by the multipliers that define the matrix L from the LU factorization of A. +* @param {NonNegativeInteger} N - order of matrix A. +* @param {Float64Array} DL - sub diagonal elements of A. On exit, DL is overwritten by the multipliers that define the matrix L from the LU factorization of A * @param {integer} sdl - stride length for `DL` * @param {NonNegativeInteger} odl - starting index of `DL` -* @param {Float64Array} D - diagonal elements of A. On exit, D is overwritten by the diagonal elements of the upper triangular matrix U from the LU factorization of A. +* @param {Float64Array} D - diagonal elements of A. On exit, D is overwritten by the diagonal elements of the upper triangular matrix U from the LU factorization of A * @param {integer} sd - stride length for `D` * @param {NonNegativeInteger} od - starting index of `D` -* @param {Float64Array} DU - super diagonal elements of A. On exit, DU is overwritten by the elements of the first super-diagonal of U. +* @param {Float64Array} DU - super diagonal elements of A. On exit, DU is overwritten by the elements of the first super-diagonal of U * @param {integer} sdu - stride length for `DU` * @param {NonNegativeInteger} odu - starting index of `DU` -* @param {Float64Array} DU2 - On exit, DU2 is overwritten by the elements of the second super-diagonal of U. +* @param {Float64Array} DU2 - On exit, DU2 is overwritten by the elements of the second super-diagonal of U * @param {integer} sdu2 - stride length for `DU2` * @param {NonNegativeInteger} odu2 - starting index of `DU2` * @param {Int32Array} IPIV - vector of pivot indices diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js index 5123de3160d2..9677791f6337 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js @@ -30,10 +30,10 @@ var base = require( './base.js' ); * Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges. * * @param {NonNegativeInteger} N - order of matrix A -* @param {Float64Array} DL - sub diagonal elements of A. On exit, DL is overwritten by the multipliers that define the matrix L from the LU factorization of A. -* @param {Float64Array} D - diagonal elements of A. On exit, D is overwritten by the diagonal elements of the upper triangular matrix U from the LU factorization of A. -* @param {Float64Array} DU - super diagonal elements of A. On exit, DU is overwritten by the elements of the first super-diagonal of U. -* @param {Float64Array} DU2 - On exit, DU2 is overwritten by the elements of the second super-diagonal of U. +* @param {Float64Array} DL - sub diagonal elements of A. On exit, DL is overwritten by the multipliers that define the matrix L from the LU factorization of A +* @param {Float64Array} D - diagonal elements of A. On exit, D is overwritten by the diagonal elements of the upper triangular matrix U from the LU factorization of A +* @param {Float64Array} DU - super diagonal elements of A. On exit, DU is overwritten by the elements of the first super-diagonal of U +* @param {Float64Array} DU2 - On exit, DU2 is overwritten by the elements of the second super-diagonal of U * @param {Int32Array} IPIV - vector of pivot indices * @throws {RangeError} first argument must be a nonnegative integer * @returns {integer} status code diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js index 11cf2e41ffd8..4ab34bd0ed88 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js @@ -30,16 +30,16 @@ var base = require( './base.js' ); * Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges and alternative indexing semantics. * * @param {NonNegativeInteger} N - order of matrix A -* @param {Float64Array} DL - sub diagonal elements of A. On exit, DL is overwritten by the multipliers that define the matrix L from the LU factorization of A. +* @param {Float64Array} DL - sub diagonal elements of A. On exit, DL is overwritten by the multipliers that define the matrix L from the LU factorization of A * @param {integer} sdl - stride length for `DL` * @param {NonNegativeInteger} odl - starting index of `DL` -* @param {Float64Array} D - diagonal elements of A. On exit, D is overwritten by the diagonal elements of the upper triangular matrix U from the LU factorization of A. +* @param {Float64Array} D - diagonal elements of A. On exit, D is overwritten by the diagonal elements of the upper triangular matrix U from the LU factorization of A * @param {integer} sd - stride length for `D` * @param {NonNegativeInteger} od - starting index of `D` -* @param {Float64Array} DU - super diagonal elements of A. On exit, DU is overwritten by the elements of the first super-diagonal of U. +* @param {Float64Array} DU - super diagonal elements of A. On exit, DU is overwritten by the elements of the first super-diagonal of U * @param {integer} sdu - stride length for `DU` * @param {NonNegativeInteger} odu - starting index of `DU` -* @param {Float64Array} DU2 - On exit, DU2 is overwritten by the elements of the second super-diagonal of U. +* @param {Float64Array} DU2 - On exit, DU2 is overwritten by the elements of the second super-diagonal of U * @param {integer} sdu2 - stride length for `DU2` * @param {NonNegativeInteger} odu2 - starting index of `DU2` * @param {Int32Array} IPIV - vector of pivot indices From 27be42f807c0947c151c137ffd79ffd71bd72236 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Tue, 4 Mar 2025 14:24:03 +0000 Subject: [PATCH 17/25] docs: add comments in base algo for better understanding --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- type: pre_push_report description: Results of running various checks prior to pushing changes. report: - task: run_javascript_examples status: na - task: run_c_examples status: na - task: run_cpp_examples status: na - task: run_javascript_readme_examples status: na - task: run_c_benchmarks status: na - task: run_cpp_benchmarks status: na - task: run_fortran_benchmarks status: na - task: run_javascript_benchmarks status: na - task: run_julia_benchmarks status: na - task: run_python_benchmarks status: na - task: run_r_benchmarks status: na - task: run_javascript_tests status: na --- --- lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js index 9ed36d22d6a7..c932ac1e2763 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js @@ -74,6 +74,7 @@ function dgttrf( N, DL, sdl, odl, D, sd, od, DU, sdu, odu, DU2, sdu2, odu2, IPIV var ip; var i; + // Quick return if possible if ( N === 0 ) { return 0; } @@ -84,22 +85,24 @@ function dgttrf( N, DL, sdl, odl, D, sd, od, DU, sdu, odu, DU2, sdu2, odu2, IPIV idu2 = odu2; ip = oi; + // Initialise ith element of IPIV as i for ( i = 0; i < N; i++ ) { IPIV[ ip + (si*i) ] = i; } + // Initialise ith element of DU2 as 0 for ( i = 0; i < N-2; i++ ) { DU2[ idu + (sdu*i) ] = 0; } for ( i = 0; i < N-2; i++ ) { - if ( abs( D[ id + (sd*i) ] ) >= abs( DL[ idl + (sdl*i) ] ) ) { // no row interchange required + if ( abs( D[ id + (sd*i) ] ) >= abs( DL[ idl + (sdl*i) ] ) ) { // No row interchange required, eleminate ith element of DL if ( D[ id ] !== 0.0 ) { fact = DL[ idl + (sdl*i) ] / D[ id + (sd*i) ]; DL[ idl + (sdl*i) ] = fact; D[ id + (sd*(i+1)) ] = D[ id + (sd*(i+1)) ] - ( fact*DU[ idu + (sdu*i) ] ); // eslint-disable-line max-len } - } else { + } else { // Interchange the ith and (i+1)th rows and eliminate ith element of DL fact = D[ id+(sd*i) ] / DL[ idl+(sdl*i) ]; D[ id+(sd*i) ] = DL[ idl+(sdl*i) ]; DL[ idl+(sdl*i) ] = fact; @@ -131,6 +134,7 @@ function dgttrf( N, DL, sdl, odl, D, sd, od, DU, sdu, odu, DU2, sdu2, odu2, IPIV } } + // Check for a 0 on the diagonal of U for ( i = 0; i < N; i++ ) { if ( D[ id+(sd*i) ] === 0.0 ) { return i; From 2e6fb17bd10c625ebff53b1de40c41400fe96290 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Tue, 4 Mar 2025 19:04:36 +0000 Subject: [PATCH 18/25] docs: add notes in docs --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: passed - task: lint_repl_help status: passed - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- type: pre_push_report description: Results of running various checks prior to pushing changes. report: - task: run_javascript_examples status: na - task: run_c_examples status: na - task: run_cpp_examples status: na - task: run_javascript_readme_examples status: na - task: run_c_benchmarks status: na - task: run_cpp_benchmarks status: na - task: run_fortran_benchmarks status: na - task: run_javascript_benchmarks status: na - task: run_julia_benchmarks status: na - task: run_python_benchmarks status: na - task: run_r_benchmarks status: na - task: run_javascript_tests status: na --- --- .../@stdlib/lapack/base/dgttrf/docs/repl.txt | 4 +- .../lapack/base/dgttrf/docs/types/index.d.ts | 52 ++++++++++++++----- .../@stdlib/lapack/base/dgttrf/lib/base.js | 18 +++++-- .../@stdlib/lapack/base/dgttrf/lib/dgttrf.js | 18 +++++-- .../@stdlib/lapack/base/dgttrf/lib/index.js | 2 +- .../@stdlib/lapack/base/dgttrf/lib/ndarray.js | 20 ++++--- .../@stdlib/lapack/base/dgttrf/package.json | 2 +- 7 files changed, 82 insertions(+), 34 deletions(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt index c7d71cd2a55e..d4fde45d1d91 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt @@ -1,6 +1,6 @@ {{alias}}( N, DL, D, DU, DU2, IPIV ) - Computes an LU factorization of a real tri diagonal matrix A using + Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. Indexing is relative to the first index. To introduce an offset, use typed @@ -92,7 +92,7 @@ {{alias}}.ndarray( N,DL,sdl,odl,D,sd,od,DU,sdu,odu,DU2,sdu2,odu2,IPIV,si,oi ) - Computes an LU factorization of a real tri diagonal matrix A using + Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges and alternative indexing semantics. diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts index fa07fa66e369..c83f293ecdff 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts @@ -36,13 +36,21 @@ type StatusCode = number; */ interface Routine { /** - * Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges. + * Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. + * + * ## Notes + * + * - On exit, `DL` is overwritten by the multipliers that define the matrix `L` from the `LU` factorization of `A`. + * - On exit, `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the `LU` factorization of `A`. + * - On exit, `DU` is overwritten by the elements of the first super-diagonal of `U`. + * - On exit, `DU2` is overwritten by the elements of the second super-diagonal of `U`. + * - On exit, for 0 <= i < n, row i of the matrix was interchanged with row IPIV(i). IPIV(i) will always be either i or i+1; IPIV(i) = i indicates a row interchange was not required. * * @param N - order of matrix `A` - * @param DL - sub diagonal elements of `A`. On exit, `DL` is overwritten by the multipliers that define the matrix `L` from the LU factorization of `A` - * @param D - diagonal elements of `A`. On exit, `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the LU factorization of `A` - * @param DU - super diagonal elements of `A`. On exit, `DU` is overwritten by the elements of the first super-diagonal of `U` - * @param DU2 - On exit, `DU2` is overwritten by the elements of the second super-diagonal of `U` + * @param DL - sub diagonal elements of `A` + * @param D - diagonal elements of `A` + * @param DU - super diagonal elements of `A` + * @param DU2 - vector to store the second super diagonal of `U` * @param IPIV - vector of pivot indices * @returns status code * @@ -66,19 +74,27 @@ interface Routine { ( N: number, DL: Float64Array, D: Float64Array, DU: Float64Array, DU2: Float64Array, IPIV: Int32Array ): StatusCode; /** - * Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges and alternative indexing semantics. + * Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges and alternative indexing semantics. + * + * ## Notes + * + * - On exit, `DL` is overwritten by the multipliers that define the matrix `L` from the `LU` factorization of `A`. + * - On exit, `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the `LU` factorization of `A`. + * - On exit, `DU` is overwritten by the elements of the first super-diagonal of `U`. + * - On exit, `DU2` is overwritten by the elements of the second super-diagonal of `U`. + * - On exit, for 0 <= i < n, row i of the matrix was interchanged with row IPIV(i). IPIV(i) will always be either i or i+1; IPIV(i) = i indicates a row interchange was not required. * * @param N - order of matrix `A` - * @param DL - sub diagonal elements of `A`. On exit, `DL` is overwritten by the multipliers that define the matrix `L` from the LU factorization of `A` + * @param DL - sub diagonal elements of `A` * @param sdl - stride length for `DL` * @param odl - starting index of `DL` - * @param D - diagonal elements of `A`. On exit, `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the LU factorization of `A` + * @param D - diagonal elements of `A` * @param sd - stride length for `D` * @param od - starting index of `D` - * @param DU - super diagonal elements of `A`. On exit, `DU` is overwritten by the elements of the first super-diagonal of `U`. + * @param DU - super diagonal elements of `A` * @param sdu - stride length for `DU` * @param odu - starting index of `DU` - * @param DU2 - On exit, `DU2` is overwritten by the elements of the second super-diagonal of `U` + * @param DU2 - vector to store the second super diagonal of `U` * @param sdu2 - stride length for `DU2` * @param odu2 - starting index of `DU2` * @param IPIV - vector of pivot indices @@ -104,12 +120,20 @@ interface Routine { } /** -* LAPACK routine to compute an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges. +* LAPACK routine to compute an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. +* +* ## Notes +* +* - On exit, `DL` is overwritten by the multipliers that define the matrix `L` from the `LU` factorization of `A`. +* - On exit, `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the `LU` factorization of `A`. +* - On exit, `DU` is overwritten by the elements of the first super-diagonal of `U`. +* - On exit, `DU2` is overwritten by the elements of the second super-diagonal of `U`. +* - On exit, for 0 <= i < n, row i of the matrix was interchanged with row IPIV(i). IPIV(i) will always be either i or i+1; IPIV(i) = i indicates a row interchange was not required. * * @param N - order of matrix `A` -* @param DL - sub diagonal elements of `A`. On exit, `DL` is overwritten by the multipliers that define the matrix `L` from the LU factorization of `A` -* @param D - diagonal elements of `A`. On exit, `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the LU factorization of `A` -* @param DU - super diagonal elements of `A`. On exit, `DU` is overwritten by the elements of the first super-diagonal of `U` +* @param DL - sub diagonal elements of `A` +* @param D - diagonal elements of `A` +* @param DU - super diagonal elements of `A` * @param DU2 - On exit, `DU2` is overwritten by the elements of the second super-diagonal of `U` * @param IPIV - vector of pivot indices * @returns status code diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js index c932ac1e2763..2f7727a78603 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js @@ -26,20 +26,28 @@ var abs = require( '@stdlib/math/base/special/abs' ); // MAIN // /** -* Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges. +* Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. +* +* ## Notes +* +* - On exit, `DL` is overwritten by the multipliers that define the matrix `L` from the `LU` factorization of `A`. +* - On exit, `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the `LU` factorization of `A`. +* - On exit, `DU` is overwritten by the elements of the first super-diagonal of `U`. +* - On exit, `DU2` is overwritten by the elements of the second super-diagonal of `U`. +* - On exit, for 0 <= i < n, row i of the matrix was interchanged with row IPIV(i). IPIV(i) will always be either i or i+1; IPIV(i) = i indicates a row interchange was not required. * * @private * @param {NonNegativeInteger} N - order of matrix A. -* @param {Float64Array} DL - sub diagonal elements of A. On exit, DL is overwritten by the multipliers that define the matrix L from the LU factorization of A +* @param {Float64Array} DL - sub diagonal elements of A. * @param {integer} sdl - stride length for `DL` * @param {NonNegativeInteger} odl - starting index of `DL` -* @param {Float64Array} D - diagonal elements of A. On exit, D is overwritten by the diagonal elements of the upper triangular matrix U from the LU factorization of A +* @param {Float64Array} D - diagonal elements of A. * @param {integer} sd - stride length for `D` * @param {NonNegativeInteger} od - starting index of `D` -* @param {Float64Array} DU - super diagonal elements of A. On exit, DU is overwritten by the elements of the first super-diagonal of U +* @param {Float64Array} DU - super diagonal elements of A. * @param {integer} sdu - stride length for `DU` * @param {NonNegativeInteger} odu - starting index of `DU` -* @param {Float64Array} DU2 - On exit, DU2 is overwritten by the elements of the second super-diagonal of U +* @param {Float64Array} DU2 - vector to store the second super diagonal of `U` * @param {integer} sdu2 - stride length for `DU2` * @param {NonNegativeInteger} odu2 - starting index of `DU2` * @param {Int32Array} IPIV - vector of pivot indices diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js index 9677791f6337..81e6fba44121 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js @@ -27,13 +27,21 @@ var base = require( './base.js' ); // MAIN // /** -* Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges. +* Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. +* +* ## Notes +* +* - On exit, `DL` is overwritten by the multipliers that define the matrix `L` from the `LU` factorization of `A`. +* - On exit, `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the `LU` factorization of `A`. +* - On exit, `DU` is overwritten by the elements of the first super-diagonal of `U`. +* - On exit, `DU2` is overwritten by the elements of the second super-diagonal of `U`. +* - On exit, for 0 <= i < n, row i of the matrix was interchanged with row IPIV(i). IPIV(i) will always be either i or i+1; IPIV(i) = i indicates a row interchange was not required. * * @param {NonNegativeInteger} N - order of matrix A -* @param {Float64Array} DL - sub diagonal elements of A. On exit, DL is overwritten by the multipliers that define the matrix L from the LU factorization of A -* @param {Float64Array} D - diagonal elements of A. On exit, D is overwritten by the diagonal elements of the upper triangular matrix U from the LU factorization of A -* @param {Float64Array} DU - super diagonal elements of A. On exit, DU is overwritten by the elements of the first super-diagonal of U -* @param {Float64Array} DU2 - On exit, DU2 is overwritten by the elements of the second super-diagonal of U +* @param {Float64Array} DL - sub diagonal elements of A. +* @param {Float64Array} D - diagonal elements of A. +* @param {Float64Array} DU - super diagonal elements of A. +* @param {Float64Array} DU2 - vector to store the second super diagonal of `U` * @param {Int32Array} IPIV - vector of pivot indices * @throws {RangeError} first argument must be a nonnegative integer * @returns {integer} status code diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js index 4f29baf2d708..4fb388ab671a 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js @@ -19,7 +19,7 @@ 'use strict'; /** -* LAPACK routine to compute an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges. +* LAPACK routine to compute an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. * * @module @stdlib/lapack/base/dgttrf * diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js index 4ab34bd0ed88..a4108c6938e0 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js @@ -27,19 +27,27 @@ var base = require( './base.js' ); // MAIN // /** -* Computes an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges and alternative indexing semantics. +* Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges and alternative indexing semantics. * -* @param {NonNegativeInteger} N - order of matrix A -* @param {Float64Array} DL - sub diagonal elements of A. On exit, DL is overwritten by the multipliers that define the matrix L from the LU factorization of A +* ## Notes +* +* - On exit, `DL` is overwritten by the multipliers that define the matrix `L` from the `LU` factorization of `A`. +* - On exit, `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the `LU` factorization of `A`. +* - On exit, `DU` is overwritten by the elements of the first super-diagonal of `U`. +* - On exit, `DU2` is overwritten by the elements of the second super-diagonal of `U`. +* - On exit, for 0 <= i < n, row i of the matrix was interchanged with row IPIV(i). IPIV(i) will always be either i or i+1; IPIV(i) = i indicates a row interchange was not required. +* +* @param {NonNegativeInteger} N - order of matrix A. +* @param {Float64Array} DL - sub diagonal elements of A. * @param {integer} sdl - stride length for `DL` * @param {NonNegativeInteger} odl - starting index of `DL` -* @param {Float64Array} D - diagonal elements of A. On exit, D is overwritten by the diagonal elements of the upper triangular matrix U from the LU factorization of A +* @param {Float64Array} D - diagonal elements of A. * @param {integer} sd - stride length for `D` * @param {NonNegativeInteger} od - starting index of `D` -* @param {Float64Array} DU - super diagonal elements of A. On exit, DU is overwritten by the elements of the first super-diagonal of U +* @param {Float64Array} DU - super diagonal elements of A. * @param {integer} sdu - stride length for `DU` * @param {NonNegativeInteger} odu - starting index of `DU` -* @param {Float64Array} DU2 - On exit, DU2 is overwritten by the elements of the second super-diagonal of U +* @param {Float64Array} DU2 - vector to store the second super diagonal of `U` * @param {integer} sdu2 - stride length for `DU2` * @param {NonNegativeInteger} odu2 - starting index of `DU2` * @param {Int32Array} IPIV - vector of pivot indices diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/package.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/package.json index 866bf4f455cf..561a8b1b375c 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/package.json +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/package.json @@ -1,7 +1,7 @@ { "name": "@stdlib/lapack/base/dgttrf", "version": "0.0.0", - "description": "Compute an LU factorization of a real tri diagonal matrix A using elimination with partial pivoting and row interchanges", + "description": "Compute an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges", "license": "Apache-2.0", "author": { "name": "The Stdlib Authors", From 7b8da2ef67cb5d5d7b5c31eee3128ffcb1b5bd21 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Wed, 5 Mar 2025 05:24:39 +0000 Subject: [PATCH 19/25] test: generate fixtures --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- type: pre_push_report description: Results of running various checks prior to pushing changes. report: - task: run_javascript_examples status: na - task: run_c_examples status: na - task: run_cpp_examples status: na - task: run_javascript_readme_examples status: na - task: run_c_benchmarks status: na - task: run_cpp_benchmarks status: na - task: run_fortran_benchmarks status: na - task: run_javascript_benchmarks status: na - task: run_julia_benchmarks status: na - task: run_python_benchmarks status: na - task: run_r_benchmarks status: na - task: run_javascript_tests status: passed --- --- .../fixtures/large_positive_stride_1.json | 30 ++ .../fixtures/large_positive_stride_2.json | 30 ++ .../dgttrf/test/fixtures/mixed_strides.json | 30 ++ .../test/fixtures/negative_strides.json | 30 ++ .../fixtures/positive_stride_no_offset_1.json | 30 ++ .../fixtures/positive_stride_no_offset_2.json | 30 ++ .../fixtures/positive_stride_offset_1.json | 30 ++ .../fixtures/positive_stride_offset_2.json | 30 ++ .../lapack/base/dgttrf/test/test.dgttrf.js | 105 ++++--- .../lapack/base/dgttrf/test/test.ndarray.js | 291 ++++++++++-------- 10 files changed, 466 insertions(+), 170 deletions(-) create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/large_positive_stride_1.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/large_positive_stride_2.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/mixed_strides.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/negative_strides.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_no_offset_1.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_no_offset_2.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_offset_1.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_offset_2.json diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/large_positive_stride_1.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/large_positive_stride_1.json new file mode 100644 index 000000000000..232bcd76030f --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/large_positive_stride_1.json @@ -0,0 +1,30 @@ +{ + "N": 3, + + "DL": [ 1.0, 9999.0, 1.0, 9999.0 ], + "sdl": 2, + "odl": 0, + + "D": [ 2.0, 9999.0, 3.0, 9999.0, 1.0, 9999.0 ], + "sd": 2, + "od": 0, + + "DU": [ 1.0, 9999.0, 1.0, 9999.0 ], + "sdu": 2, + "odu": 0, + + "DU2": [ 0.0, 0.0 ], + "sdu2": 2, + "odu2": 0, + + "IPIV": [ 0, 0, 0, 0, 0, 0 ], + "si": 2, + "oi": 0, + + "expectedDL": [ 0.5, 9999.0, 0.4, 9999.0 ], + "expectedD": [ 2.0, 9999.0, 2.5, 9999.0, 0.6, 9999.0 ], + "expectedDU": [ 1.0, 9999.0, 1.0, 9999.0 ], + "expectedDU2": [ 0.0, 0.0 ], + "expectedIPIV": [ 0, 0, 1, 0, 2, 0 ], + "expectedInfo": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/large_positive_stride_2.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/large_positive_stride_2.json new file mode 100644 index 000000000000..9218f31f9cb1 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/large_positive_stride_2.json @@ -0,0 +1,30 @@ +{ + "N": 9, + + "DL": [ 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0 ], + "sdl": 2, + "odl": 0, + + "D": [ 1.0, 9999.0, 1.0, 9999.0, 1.0, 9999.0, 1.0, 9999.0, 1.0, 9999.0, 1.0, 9999.0, 1.0, 9999.0, 1.0, 9999.0, 1.0, 9999.0 ], + "sd": 2, + "od": 0, + + "DU": [ 4.0, 9999.0, 4.0, 9999.0, 4.0, 9999.0, 4.0, 9999.0, 4.0, 9999.0, 4.0, 9999.0, 4.0, 9999.0, 4.0, 9999.0 ], + "sdu": 2, + "odu": 0, + + "DU2": [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ], + "sdu2": 2, + "odu2": 0, + + "IPIV": [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], + "si": 2, + "oi": 0, + + "expectedDL": [ 0.3333333333333333, 9999.0, 0.8181818181818182, 9999.0, 0.6969696969696969, 9999.0, 0.9082568807339449, 9999.0, 0.8493506493506494, 9999.0, -0.7991341991341993, 9999.0, 0.6251127548259066, 9999.0, -0.3327319742618318, 9999.0 ], + "expectedD": [ 3.0, 9999.0, 3.6666666666666665, 9999.0, 3.0, 9999.0, 3.3030303030303032, 9999.0, 3.5321100917431192, 9999.0, 3.0, 9999.0, 4.7991341991341994, 9999.0, 3.0, 9999.0, 4.3327319742618320, 9999.0 ], + "expectedDU": [ 1.0, 9999.0, -1.3333333333333333, 9999.0, 1.0, 9999.0, -2.7878787878787876, 9999.0, 4.0, 9999.0, 1.0, 9999.0, 3.1965367965367970, 9999.0, 1.0, 9999.0 ], + "expectedDU2": [ 4.0, 0.0, 0.0, 0.0, 4.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.0, 0.0, 0.0, 0.0 ], + "expectedIPIV": [ 1, 0, 1, 0, 3, 0, 3, 0, 4, 0, 6, 0, 6, 0, 8, 0, 8, 0 ], + "expectedInfo": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/mixed_strides.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/mixed_strides.json new file mode 100644 index 000000000000..514ee7f79df1 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/mixed_strides.json @@ -0,0 +1,30 @@ +{ + "N": 3, + + "DL": [ 1.0, 1.0 ], + "sdl": -1, + "odl": 1, + + "D": [ 2.0, 3.0, 1.0 ], + "sd": 1, + "od": 0, + + "DU": [ 1.0, 1.0 ], + "sdu": -1, + "odu": 1, + + "DU2": [ 0.0 ], + "sdu2": -1, + "odu2": 0, + + "IPIV": [ 0, 0, 0 ], + "si": 1, + "oi": 0, + + "expectedDL": [ 0.4, 0.5 ], + "expectedD": [ 2.0, 2.5, 0.6 ], + "expectedDU": [ 1.0, 1.0 ], + "expectedDU2": [ 0.0 ], + "expectedIPIV": [ 0, 1, 2 ], + "expectedInfo": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/negative_strides.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/negative_strides.json new file mode 100644 index 000000000000..9aec6a371b28 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/negative_strides.json @@ -0,0 +1,30 @@ +{ + "N": 3, + + "DL": [ 1.0, 1.0 ], + "sdl": -1, + "odl": 1, + + "D": [ 1.0, 3.0, 2.0 ], + "sd": -1, + "od": 2, + + "DU": [ 1.0, 1.0 ], + "sdu": -1, + "odu": 1, + + "DU2": [ 0.0 ], + "sdu2": -1, + "odu2": 0, + + "IPIV": [ 0, 0, 0 ], + "si": -1, + "oi": 2, + + "expectedDL": [ 0.4, 0.5 ], + "expectedD": [ 0.6, 2.5, 2.0 ], + "expectedDU": [ 1.0, 1.0 ], + "expectedDU2": [ 0.0 ], + "expectedIPIV": [ 2, 1, 0 ], + "expectedInfo": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_no_offset_1.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_no_offset_1.json new file mode 100644 index 000000000000..b9cecc571bf7 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_no_offset_1.json @@ -0,0 +1,30 @@ +{ + "N": 3, + + "DL": [ 1.0, 1.0 ], + "sdl": 1, + "odl": 0, + + "D": [ 2.0, 3.0, 1.0 ], + "sd": 1, + "od": 0, + + "DU": [ 1.0, 1.0 ], + "sdu": 1, + "odu": 0, + + "DU2": [ 0.0 ], + "sdu2": 1, + "odu2": 0, + + "IPIV": [ 0, 0, 0 ], + "si": 1, + "oi": 0, + + "expectedDL": [ 0.5, 0.4 ], + "expectedD": [ 2.0, 2.5, 0.6 ], + "expectedDU": [ 1.0, 1.0 ], + "expectedDU2": [ 0.0 ], + "expectedIPIV": [ 0, 1, 2 ], + "expectedInfo": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_no_offset_2.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_no_offset_2.json new file mode 100644 index 000000000000..02c60436c391 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_no_offset_2.json @@ -0,0 +1,30 @@ +{ + "N": 9, + + "DL": [ 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0 ], + "sdl": 1, + "odl": 0, + + "D": [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ], + "sd": 1, + "od": 0, + + "DU": [ 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0 ], + "sdu": 1, + "odu": 0, + + "DU2": [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ], + "sdu2": 1, + "odu2": 0, + + "IPIV": [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ], + "si": 1, + "oi": 0, + + "expectedDL": [ 0.3333333333333333, 0.8181818181818182, 0.6969696969696969, 0.9082568807339449, 0.8493506493506494, -0.7991341991341993, 0.6251127548259066, -0.3327319742618318 ], + "expectedD": [ 3.0, 3.6666666666666665, 3.0, 3.3030303030303032, 3.5321100917431192, 3.0, 4.7991341991341994, 3.0, 4.3327319742618320 ], + "expectedDU": [ 1.0, -1.3333333333333333, 1.0, -2.7878787878787876, 4.0, 1.0, 3.1965367965367970, 1.0 ], + "expectedDU2": [ 4.0, 0.0, 4.0, 0.0, 0.0, 4.0, 0.0 ], + "expectedIPIV": [ 1, 1, 3, 3, 4, 6, 6, 8, 8 ], + "expectedInfo": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_offset_1.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_offset_1.json new file mode 100644 index 000000000000..eb124b7dd8ae --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_offset_1.json @@ -0,0 +1,30 @@ +{ + "N": 3, + + "DL": [ 0.0, 1.0, 1.0 ], + "sdl": 1, + "odl": 1, + + "D": [ 0.0, 2.0, 3.0, 1.0 ], + "sd": 1, + "od": 1, + + "DU": [ 0.0, 1.0, 1.0 ], + "sdu": 1, + "odu": 1, + + "DU2": [ 0.0, 0.0 ], + "sdu2": 1, + "odu2": 1, + + "IPIV": [ 0, 0, 0, 0 ], + "si": 1, + "oi": 1, + + "expectedDL": [ 0.0, 0.5, 0.4 ], + "expectedD": [ 0.0, 2.0, 2.5, 0.6 ], + "expectedDU": [ 0.0, 1.0, 1.0 ], + "expectedDU2": [ 0.0, 0.0 ], + "expectedIPIV": [ 0, 0, 1, 2 ], + "expectedInfo": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_offset_2.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_offset_2.json new file mode 100644 index 000000000000..54b3e6e0de0f --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_offset_2.json @@ -0,0 +1,30 @@ +{ + "N": 9, + + "DL": [ 0.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0 ], + "sdl": 1, + "odl": 1, + + "D": [ 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ], + "sd": 1, + "od": 1, + + "DU": [ 0.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0 ], + "sdu": 1, + "odu": 1, + + "DU2": [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ], + "sdu2": 1, + "odu2": 1, + + "IPIV": [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], + "si": 1, + "oi": 1, + + "expectedDL": [ 0.0, 0.3333333333333333, 0.8181818181818182, 0.6969696969696969, 0.9082568807339449, 0.8493506493506494, -0.7991341991341993, 0.6251127548259066, -0.3327319742618318 ], + "expectedD": [ 0.0, 3.0, 3.6666666666666665, 3.0, 3.3030303030303032, 3.5321100917431192, 3.0, 4.7991341991341994, 3.0, 4.3327319742618320 ], + "expectedDU": [ 0.0, 1.0, -1.3333333333333333, 1.0, -2.7878787878787876, 4.0, 1.0, 3.1965367965367970, 1.0 ], + "expectedDU2": [ 0.0, 4.0, 0.0, 4.0, 0.0, 0.0, 4.0, 0.0 ], + "expectedIPIV": [ 0, 1, 1, 3, 3, 4, 6, 6, 8, 8 ], + "expectedInfo": 0 +} diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js index c22842fdd610..a329d22777e5 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js @@ -28,6 +28,12 @@ var abs = require( '@stdlib/math/base/special/abs' ); var dgttrf = require( './../lib/dgttrf.js' ); +// FIXTURES // + +var POSITIVE_STRIDES_NO_OFFSET_1 = require( './fixtures/positive_stride_no_offset_1.json' ); // eslint-disable-line id-length +var POSITIVE_STRIDES_NO_OFFSET_2 = require( './fixtures/positive_stride_no_offset_2.json' ); // eslint-disable-line id-length + + // FUNCTIONS // /** @@ -72,6 +78,7 @@ tape( 'the function has an arity of 6', function test( t ) { tape( 'the function throws an error if provided a first argument which is less than zero', function test( t ) { var values; + var data; var IPIV; var DU2; var DU; @@ -79,11 +86,13 @@ tape( 'the function throws an error if provided a first argument which is less t var D; var i; - DL = new Float64Array( [ 1.0, 1.0 ] ); - D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); - DU = new Float64Array( [ 1.0, 1.0 ] ); - DU2 = new Float64Array( 1 ); - IPIV = new Int32Array( 3 ); + data = POSITIVE_STRIDES_NO_OFFSET_1; + + DL = new Float64Array( data.DL ); + D = new Float64Array( data.D ); + DU = new Float64Array( data.DU ); + DU2 = new Float64Array( data.DU2 ); + IPIV = new Int32Array( data.IPIV ); values = [ -1, @@ -109,6 +118,7 @@ tape( 'the function performs the `LU` factorization of a real tri diagonal matri var expectedDU; var expectedDL; var expectedD; + var data; var info; var IPIV; var DU2; @@ -117,44 +127,48 @@ tape( 'the function performs the `LU` factorization of a real tri diagonal matri var D; var N; - N = 3; + data = POSITIVE_STRIDES_NO_OFFSET_1; + + N = data.N; - DL = new Float64Array( [ 1.0, 1.0 ] ); - D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); - DU = new Float64Array( [ 1.0, 1.0 ] ); - DU2 = new Float64Array( N-2 ); - IPIV = new Int32Array( N ); + DL = new Float64Array( data.DL ); + D = new Float64Array( data.D ); + DU = new Float64Array( data.DU ); + DU2 = new Float64Array( data.DU2 ); + IPIV = new Int32Array( data.IPIV ); - expectedDL = new Float64Array( [ 0.5, 0.4 ] ); - expectedD = new Float64Array( [ 2.0, 2.5, 0.6 ] ); - expectedDU = new Float64Array( [ 1.0, 1.0 ] ); - expectedDU2 = new Float64Array( [ 0.0 ] ); - expectedIPIV = new Int32Array( [ 0, 1, 2 ] ); + expectedDL = new Float64Array( data.expectedDL ); + expectedD = new Float64Array( data.expectedD ); + expectedDU = new Float64Array( data.expectedDU ); + expectedDU2 = new Float64Array( data.expectedDU2 ); + expectedIPIV = new Int32Array( data.expectedIPIV ); info = dgttrf( N, DL, D, DU, DU2, IPIV ); - t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); isApprox( t, D, expectedD, 1.0 ); isApprox( t, DU, expectedDU, 1.0 ); isApprox( t, DU2, expectedDU2, 1.0 ); isApprox( t, DL, expectedDL, 1.0 ); - N = 9; + data = POSITIVE_STRIDES_NO_OFFSET_2; + + N = data.N; - DL = new Float64Array( [ 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0 ] ); - D = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); - DU = new Float64Array( [ 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0 ] ); - DU2 = new Float64Array( N-2 ); - IPIV = new Int32Array( N ); + DL = new Float64Array( data.DL ); + D = new Float64Array( data.D ); + DU = new Float64Array( data.DU ); + DU2 = new Float64Array( data.DU2 ); + IPIV = new Int32Array( data.IPIV ); - expectedDL = new Float64Array( [ 0.3333333333333333, 0.8181818181818182, 0.6969696969696969, 0.9082568807339449, 0.8493506493506494, -0.7991341991341993, 0.6251127548259066, -0.3327319742618318 ] ); // eslint-disable-line max-len - expectedD = new Float64Array( [ 3.0, 3.6666666666666665, 3.0, 3.3030303030303032, 3.5321100917431192, 3.0, 4.7991341991341994, 3.0, 4.3327319742618320 ] ); // eslint-disable-line max-len - expectedDU = new Float64Array( [ 1.0, -1.3333333333333333, 1.0, -2.7878787878787876, 4.0, 1.0, 3.1965367965367970, 1.0 ] ); // eslint-disable-line max-len - expectedDU2 = new Float64Array( [ 4.0, 0.0, 4.0, 0.0, 0.0, 4.0, 0.0 ] ); - expectedIPIV = new Int32Array( [ 1, 1, 3, 3, 4, 6, 6, 8, 8 ] ); + expectedDL = new Float64Array( data.expectedDL ); + expectedD = new Float64Array( data.expectedD ); + expectedDU = new Float64Array( data.expectedDU ); + expectedDU2 = new Float64Array( data.expectedDU2 ); + expectedIPIV = new Int32Array( data.expectedIPIV ); info = dgttrf( N, DL, D, DU, DU2, IPIV ); - t.strictEqual( info, 0, 'returns expected value' ); + t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); isApprox( t, D, expectedD, 1.0 ); isApprox( t, DU, expectedDU, 1.0 ); @@ -193,6 +207,7 @@ tape( 'the function leaves the input arrays unchanged when `N` is equal to zero' var expectedDU; var expectedDL; var expectedD; + var data; var info; var IPIV; var DU2; @@ -201,27 +216,29 @@ tape( 'the function leaves the input arrays unchanged when `N` is equal to zero' var D; var N; + data = POSITIVE_STRIDES_NO_OFFSET_1; + N = 0; - DL = new Float64Array( [ 1.0, 1.0 ] ); - D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); - DU = new Float64Array( [ 1.0, 1.0 ] ); - DU2 = new Float64Array( 1 ); - IPIV = new Int32Array( 3 ); + DL = new Float64Array( data.DL ); + D = new Float64Array( data.D ); + DU = new Float64Array( data.DU ); + DU2 = new Float64Array( data.DU2 ); + IPIV = new Int32Array( data.IPIV ); - expectedDL = new Float64Array( [ 1.0, 1.0 ] ); - expectedD = new Float64Array( [ 2.0, 3.0, 1.0 ] ); - expectedDU = new Float64Array( [ 1.0, 1.0 ] ); - expectedDU2 = new Float64Array( [ 0.0 ] ); - expectedIPIV = new Int32Array( [ 0, 0, 0 ] ); + expectedDL = new Float64Array( data.DL ); + expectedD = new Float64Array( data.D ); + expectedDU = new Float64Array( data.DU ); + expectedDU2 = new Float64Array( data.DU2 ); + expectedIPIV = new Int32Array( data.IPIV ); info = dgttrf( N, DL, D, DU, DU2, IPIV ); - t.strictEqual( info, 0, 'returns expected value' ); - t.deepEqual( DU, expectedDU, 'returns expected value' ); - t.deepEqual( DU2, expectedDU2, 'returns expected value' ); - t.deepEqual( D, expectedD, 'returns expected value' ); - t.deepEqual( DL, expectedDL, 'returns expected value' ); + t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); + isApprox( t, D, expectedD, 0.0 ); + isApprox( t, DU, expectedDU, 0.0 ); + isApprox( t, DU2, expectedDU2, 0.0 ); + isApprox( t, DL, expectedDL, 0.0 ); t.end(); }); diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js index 41db4f4b38f0..2df892c7b1b4 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js @@ -28,6 +28,18 @@ var abs = require( '@stdlib/math/base/special/abs' ); var dgttrf = require( './../lib/ndarray.js' ); +// FIXTURES // + +var POSITIVE_STRIDES_NO_OFFSET_1 = require( './fixtures/positive_stride_no_offset_1.json' ); // eslint-disable-line id-length +var POSITIVE_STRIDES_NO_OFFSET_2 = require( './fixtures/positive_stride_no_offset_2.json' ); // eslint-disable-line id-length +var LARGE_POSITIVE_STRIDE_1 = require( './fixtures/large_positive_stride_1.json' ); +var LARGE_POSITIVE_STRIDE_2 = require( './fixtures/large_positive_stride_2.json' ); +var NEGATIVE_STRIDES = require( './fixtures/negative_strides.json' ); +var MIXED_STRIDES = require( './fixtures/mixed_strides.json' ); +var POSITIVE_STRIDES_OFFSET_1 = require( './fixtures/positive_stride_offset_1.json' ); +var POSITIVE_STRIDES_OFFSET_2 = require( './fixtures/positive_stride_offset_2.json' ); + + // FUNCTIONS // /** @@ -72,6 +84,7 @@ tape( 'the function has an arity of 16', function test( t ) { tape( 'the function throws an error if provided a first argument which is less than zero', function test( t ) { var values; + var data; var IPIV; var DU2; var DU; @@ -79,11 +92,13 @@ tape( 'the function throws an error if provided a first argument which is less t var D; var i; - DL = new Float64Array( [ 1.0, 1.0 ] ); - D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); - DU = new Float64Array( [ 1.0, 1.0 ] ); - DU2 = new Float64Array( 1 ); - IPIV = new Int32Array( 3 ); + data = POSITIVE_STRIDES_NO_OFFSET_1; + + DL = new Float64Array( data.DL ); + D = new Float64Array( data.D ); + DU = new Float64Array( data.DU ); + DU2 = new Float64Array( data.DU2 ); + IPIV = new Int32Array( data.IPIV ); values = [ -1, @@ -98,7 +113,7 @@ tape( 'the function throws an error if provided a first argument which is less t function badValue( value ) { return function badValue() { - dgttrf( value, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); + dgttrf( value, DL, data.sdl, data.odl, D, data.sd, data.od, DU, data.sdu, data.odu, DU2, data.sdu2, data.odu2, IPIV, data.si, data.oi ); // eslint-disable-line max-len }; } }); @@ -109,6 +124,7 @@ tape( 'the function performs the `LU` factorization of a real tri diagonal matri var expectedDU; var expectedDL; var expectedD; + var data; var info; var IPIV; var DU2; @@ -117,44 +133,48 @@ tape( 'the function performs the `LU` factorization of a real tri diagonal matri var D; var N; - N = 3; + data = POSITIVE_STRIDES_NO_OFFSET_1; - DL = new Float64Array( [ 1.0, 1.0 ] ); - D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); - DU = new Float64Array( [ 1.0, 1.0 ] ); - DU2 = new Float64Array( N-2 ); - IPIV = new Int32Array( N ); + N = data.N; - expectedDL = new Float64Array( [ 0.5, 0.4 ] ); - expectedD = new Float64Array( [ 2.0, 2.5, 0.6 ] ); - expectedDU = new Float64Array( [ 1.0, 1.0 ] ); - expectedDU2 = new Float64Array( [ 0.0 ] ); - expectedIPIV = new Int32Array( [ 0, 1, 2 ] ); + DL = new Float64Array( data.DL ); + D = new Float64Array( data.D ); + DU = new Float64Array( data.DU ); + DU2 = new Float64Array( data.DU2 ); + IPIV = new Int32Array( data.IPIV ); - info = dgttrf( N, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); - t.strictEqual( info, 0, 'returns expected value' ); + expectedDL = new Float64Array( data.expectedDL ); + expectedD = new Float64Array( data.expectedD ); + expectedDU = new Float64Array( data.expectedDU ); + expectedDU2 = new Float64Array( data.expectedDU2 ); + expectedIPIV = new Int32Array( data.expectedIPIV ); + + info = dgttrf( N, DL, data.sdl, data.odl, D, data.sd, data.od, DU, data.sdu, data.odu, DU2, data.sdu2, data.odu2, IPIV, data.si, data.oi ); // eslint-disable-line max-len + t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); isApprox( t, D, expectedD, 1.0 ); isApprox( t, DU, expectedDU, 1.0 ); isApprox( t, DU2, expectedDU2, 1.0 ); isApprox( t, DL, expectedDL, 1.0 ); - N = 9; + data = POSITIVE_STRIDES_NO_OFFSET_2; - DL = new Float64Array( [ 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0 ] ); - D = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); - DU = new Float64Array( [ 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0 ] ); - DU2 = new Float64Array( N-2 ); - IPIV = new Int32Array( N ); + N = data.N; - expectedDL = new Float64Array( [ 0.3333333333333333, 0.8181818181818182, 0.6969696969696969, 0.9082568807339449, 0.8493506493506494, -0.7991341991341993, 0.6251127548259066, -0.3327319742618318 ] ); // eslint-disable-line max-len - expectedD = new Float64Array( [ 3.0, 3.6666666666666665, 3.0, 3.3030303030303032, 3.5321100917431192, 3.0, 4.7991341991341994, 3.0, 4.3327319742618320 ] ); // eslint-disable-line max-len - expectedDU = new Float64Array( [ 1.0, -1.3333333333333333, 1.0, -2.7878787878787876, 4.0, 1.0, 3.1965367965367970, 1.0 ] ); // eslint-disable-line max-len - expectedDU2 = new Float64Array( [ 4.0, 0.0, 4.0, 0.0, 0.0, 4.0, 0.0 ] ); - expectedIPIV = new Int32Array( [ 1, 1, 3, 3, 4, 6, 6, 8, 8 ] ); + DL = new Float64Array( data.DL ); + D = new Float64Array( data.D ); + DU = new Float64Array( data.DU ); + DU2 = new Float64Array( data.DU2 ); + IPIV = new Int32Array( data.IPIV ); - info = dgttrf( N, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); - t.strictEqual( info, 0, 'returns expected value' ); + expectedDL = new Float64Array( data.expectedDL ); + expectedD = new Float64Array( data.expectedD ); + expectedDU = new Float64Array( data.expectedDU ); + expectedDU2 = new Float64Array( data.expectedDU2 ); + expectedIPIV = new Int32Array( data.expectedIPIV ); + + info = dgttrf( N, DL, data.sdl, data.odl, D, data.sd, data.od, DU, data.sdu, data.odu, DU2, data.sdu2, data.odu2, IPIV, data.si, data.oi ); // eslint-disable-line max-len + t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); isApprox( t, D, expectedD, 1.0 ); isApprox( t, DU, expectedDU, 1.0 ); @@ -170,6 +190,7 @@ tape( 'the function supports providing positive strides', function test( t ) { var expectedDU; var expectedDL; var expectedD; + var data; var info; var IPIV; var DU2; @@ -178,44 +199,48 @@ tape( 'the function supports providing positive strides', function test( t ) { var D; var N; - N = 3; + data = LARGE_POSITIVE_STRIDE_1; + + N = data.N; - DL = new Float64Array( [ 1.0, 9999.0, 1.0 ] ); - D = new Float64Array( [ 2.0, 9999.0, 3.0, 9999.0, 1.0 ] ); - DU = new Float64Array( [ 1.0, 9999.0, 1.0 ] ); - DU2 = new Float64Array( 2 * (N-2) ); - IPIV = new Int32Array( 2 * N ); + DL = new Float64Array( data.DL ); + D = new Float64Array( data.D ); + DU = new Float64Array( data.DU ); + DU2 = new Float64Array( data.DU2 ); + IPIV = new Int32Array( data.IPIV ); - expectedDL = new Float64Array( [ 0.5, 9999.0, 0.4 ] ); - expectedD = new Float64Array( [ 2.0, 9999.0, 2.5, 9999.0, 0.6 ] ); - expectedDU = new Float64Array( [ 1.0, 9999.0, 1.0 ] ); - expectedDU2 = new Float64Array( [ 0.0, 0.0 ] ); - expectedIPIV = new Int32Array( [ 0, 0, 1, 0, 2, 0 ] ); + expectedDL = new Float64Array( data.expectedDL ); + expectedD = new Float64Array( data.expectedD ); + expectedDU = new Float64Array( data.expectedDU ); + expectedDU2 = new Float64Array( data.expectedDU2 ); + expectedIPIV = new Int32Array( data.expectedIPIV ); - info = dgttrf( N, DL, 2, 0, D, 2, 0, DU, 2, 0, DU2, 2, 0, IPIV, 2, 0 ); - t.strictEqual( info, 0, 'returns expected value' ); + info = dgttrf( N, DL, data.sdl, data.odl, D, data.sd, data.od, DU, data.sdu, data.odu, DU2, data.sdu2, data.odu2, IPIV, data.si, data.oi ); // eslint-disable-line max-len + t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); isApprox( t, D, expectedD, 1.0 ); isApprox( t, DU, expectedDU, 1.0 ); isApprox( t, DU2, expectedDU2, 1.0 ); isApprox( t, DL, expectedDL, 1.0 ); - N = 9; + data = LARGE_POSITIVE_STRIDE_2; - DL = new Float64Array( [ 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0, 3.0 ] ); // eslint-disable-line max-len - D = new Float64Array( [ 1.0, 9999.0, 1.0, 9999.0, 1.0, 9999.0, 1.0, 9999.0, 1.0, 9999.0, 1.0, 9999.0, 1.0, 9999.0, 1.0, 9999.0, 1.0 ] ); // eslint-disable-line max-len - DU = new Float64Array( [ 4.0, 9999.0, 4.0, 9999.0, 4.0, 9999.0, 4.0, 9999.0, 4.0, 9999.0, 4.0, 9999.0, 4.0, 9999.0, 4.0 ] ); // eslint-disable-line max-len - DU2 = new Float64Array( 2 * (N-2) ); - IPIV = new Int32Array( 2 * N ); + N = data.N; - expectedDL = new Float64Array( [ 0.3333333333333333, 9999.0, 0.8181818181818182, 9999.0, 0.6969696969696969, 9999.0, 0.9082568807339449, 9999.0, 0.8493506493506494, 9999.0, -0.7991341991341993, 9999.0, 0.6251127548259066, 9999.0, -0.3327319742618318 ] ); // eslint-disable-line max-len - expectedD = new Float64Array( [ 3.0, 9999.0, 3.6666666666666665, 9999.0, 3.0, 9999.0, 3.3030303030303032, 9999.0, 3.5321100917431192, 9999.0, 3.0, 9999.0, 4.7991341991341994, 9999.0, 3.0, 9999.0, 4.3327319742618320 ] ); // eslint-disable-line max-len - expectedDU = new Float64Array( [ 1.0, 9999.0, -1.3333333333333333, 9999.0, 1.0, 9999.0, -2.7878787878787876, 9999.0, 4.0, 9999.0, 1.0, 9999.0, 3.1965367965367970, 9999.0, 1.0 ] ); // eslint-disable-line max-len - expectedDU2 = new Float64Array( [ 4.0, 0.0, 0.0, 0.0, 4.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.0, 0.0, 0.0, 0.0 ] ); // eslint-disable-line max-len - expectedIPIV = new Int32Array( [ 1, 0, 1, 0, 3, 0, 3, 0, 4, 0, 6, 0, 6, 0, 8, 0, 8, 0 ] ); // eslint-disable-line max-len + DL = new Float64Array( data.DL ); + D = new Float64Array( data.D ); + DU = new Float64Array( data.DU ); + DU2 = new Float64Array( data.DU2 ); + IPIV = new Int32Array( data.IPIV ); - info = dgttrf( N, DL, 2, 0, D, 2, 0, DU, 2, 0, DU2, 2, 0, IPIV, 2, 0 ); - t.strictEqual( info, 0, 'returns expected value' ); + expectedDL = new Float64Array( data.expectedDL ); + expectedD = new Float64Array( data.expectedD ); + expectedDU = new Float64Array( data.expectedDU ); + expectedDU2 = new Float64Array( data.expectedDU2 ); + expectedIPIV = new Int32Array( data.expectedIPIV ); + + info = dgttrf( N, DL, data.sdl, data.odl, D, data.sd, data.od, DU, data.sdu, data.odu, DU2, data.sdu2, data.odu2, IPIV, data.si, data.oi ); // eslint-disable-line max-len + t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); isApprox( t, D, expectedD, 1.0 ); isApprox( t, DU, expectedDU, 1.0 ); @@ -231,6 +256,7 @@ tape( 'the function supports providing negative strides', function test( t ) { var expectedDU; var expectedDL; var expectedD; + var data; var info; var IPIV; var DU2; @@ -239,22 +265,24 @@ tape( 'the function supports providing negative strides', function test( t ) { var D; var N; - N = 3; + data = NEGATIVE_STRIDES; + + N = data.N; - DL = new Float64Array( [ 1.0, 1.0 ] ); - D = new Float64Array( [ 1.0, 3.0, 2.0 ] ); - DU = new Float64Array( [ 1.0, 1.0 ] ); - DU2 = new Float64Array( N-2 ); - IPIV = new Int32Array( N ); + DL = new Float64Array( data.DL ); + D = new Float64Array( data.D ); + DU = new Float64Array( data.DU ); + DU2 = new Float64Array( data.DU2 ); + IPIV = new Int32Array( data.IPIV ); - expectedDL = new Float64Array( [ 0.4, 0.5 ] ); - expectedD = new Float64Array( [ 0.6, 2.5, 2.0 ] ); - expectedDU = new Float64Array( [ 1.0, 1.0 ] ); - expectedDU2 = new Float64Array( [ 0.0 ] ); - expectedIPIV = new Int32Array( [ 2, 1, 0 ] ); + expectedDL = new Float64Array( data.expectedDL ); + expectedD = new Float64Array( data.expectedD ); + expectedDU = new Float64Array( data.expectedDU ); + expectedDU2 = new Float64Array( data.expectedDU2 ); + expectedIPIV = new Int32Array( data.expectedIPIV ); - info = dgttrf( N, DL, -1, 1, D, -1, 2, DU, -1, 1, DU2, -1, 0, IPIV, -1, 2 ); - t.strictEqual( info, 0, 'returns expected value' ); + info = dgttrf( N, DL, data.sdl, data.odl, D, data.sd, data.od, DU, data.sdu, data.odu, DU2, data.sdu2, data.odu2, IPIV, data.si, data.oi ); // eslint-disable-line max-len + t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); isApprox( t, D, expectedD, 1.0 ); isApprox( t, DU, expectedDU, 1.0 ); @@ -271,6 +299,7 @@ tape( 'the function supports providing mixed strides', function test( t ) { var expectedDL; var expectedD; var info; + var data; var IPIV; var DU2; var DU; @@ -278,22 +307,24 @@ tape( 'the function supports providing mixed strides', function test( t ) { var D; var N; - N = 3; + data = MIXED_STRIDES; + + N = data.N; - DL = new Float64Array( [ 1.0, 1.0 ] ); - D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); - DU = new Float64Array( [ 1.0, 1.0 ] ); - DU2 = new Float64Array( N-2 ); - IPIV = new Int32Array( N ); + DL = new Float64Array( data.DL ); + D = new Float64Array( data.D ); + DU = new Float64Array( data.DU ); + DU2 = new Float64Array( data.DU2 ); + IPIV = new Int32Array( data.IPIV ); - expectedDL = new Float64Array( [ 0.4, 0.5 ] ); - expectedD = new Float64Array( [ 2.0, 2.5, 0.6 ] ); - expectedDU = new Float64Array( [ 1.0, 1.0 ] ); - expectedDU2 = new Float64Array( [ 0.0 ] ); - expectedIPIV = new Int32Array( [ 0, 1, 2 ] ); + expectedDL = new Float64Array( data.expectedDL ); + expectedD = new Float64Array( data.expectedD ); + expectedDU = new Float64Array( data.expectedDU ); + expectedDU2 = new Float64Array( data.expectedDU2 ); + expectedIPIV = new Int32Array( data.expectedIPIV ); - info = dgttrf( N, DL, -1, 1, D, 1, 0, DU, -1, 1, DU2, -1, 0, IPIV, 1, 0 ); - t.strictEqual( info, 0, 'returns expected value' ); + info = dgttrf( N, DL, data.sdl, data.odl, D, data.sd, data.od, DU, data.sdu, data.odu, DU2, data.sdu2, data.odu2, IPIV, data.si, data.oi ); // eslint-disable-line max-len + t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); isApprox( t, D, expectedD, 1.0 ); isApprox( t, DU, expectedDU, 1.0 ); @@ -309,6 +340,7 @@ tape( 'the function supports providing index offsets', function test( t ) { var expectedDU; var expectedDL; var expectedD; + var data; var info; var IPIV; var DU2; @@ -317,44 +349,48 @@ tape( 'the function supports providing index offsets', function test( t ) { var D; var N; - N = 3; + data = POSITIVE_STRIDES_OFFSET_1; - DL = new Float64Array( [ 9999.0, 1.0, 1.0 ] ); - D = new Float64Array( [ 9999.0, 2.0, 3.0, 1.0 ] ); - DU = new Float64Array( [ 9999.0, 1.0, 1.0 ] ); - DU2 = new Float64Array( N-2 + 1 ); - IPIV = new Int32Array( N + 1 ); + N = data.N; - expectedDL = new Float64Array( [ 9999.0, 0.5, 0.4 ] ); - expectedD = new Float64Array( [ 9999.0, 2.0, 2.5, 0.6 ] ); - expectedDU = new Float64Array( [ 9999.0, 1.0, 1.0 ] ); - expectedDU2 = new Float64Array( [ 0.0, 0.0 ] ); - expectedIPIV = new Int32Array( [ 0, 0, 1, 2 ] ); + DL = new Float64Array( data.DL ); + D = new Float64Array( data.D ); + DU = new Float64Array( data.DU ); + DU2 = new Float64Array( data.DU2 ); + IPIV = new Int32Array( data.IPIV ); - info = dgttrf( N, DL, 1, 1, D, 1, 1, DU, 1, 1, DU2, 1, 1, IPIV, 1, 1 ); - t.strictEqual( info, 0, 'returns expected value' ); + expectedDL = new Float64Array( data.expectedDL ); + expectedD = new Float64Array( data.expectedD ); + expectedDU = new Float64Array( data.expectedDU ); + expectedDU2 = new Float64Array( data.expectedDU2 ); + expectedIPIV = new Int32Array( data.expectedIPIV ); + + info = dgttrf( N, DL, data.sdl, data.odl, D, data.sd, data.od, DU, data.sdu, data.odu, DU2, data.sdu2, data.odu2, IPIV, data.si, data.oi ); // eslint-disable-line max-len + t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); isApprox( t, D, expectedD, 1.0 ); isApprox( t, DU, expectedDU, 1.0 ); isApprox( t, DU2, expectedDU2, 1.0 ); isApprox( t, DL, expectedDL, 1.0 ); - N = 9; + data = POSITIVE_STRIDES_OFFSET_2; + + N = data.N; - DL = new Float64Array( [ 9999.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0 ] ); - D = new Float64Array( [ 9999.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); // eslint-disable-line max-len - DU = new Float64Array( [ 9999.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0 ] ); - DU2 = new Float64Array( N-2 + 1 ); - IPIV = new Int32Array( N + 1 ); + DL = new Float64Array( data.DL ); + D = new Float64Array( data.D ); + DU = new Float64Array( data.DU ); + DU2 = new Float64Array( data.DU2 ); + IPIV = new Int32Array( data.IPIV ); - expectedDL = new Float64Array( [ 9999.0, 0.3333333333333333, 0.8181818181818182, 0.6969696969696969, 0.9082568807339449, 0.8493506493506494, -0.7991341991341993, 0.6251127548259066, -0.3327319742618318 ] ); // eslint-disable-line max-len - expectedD = new Float64Array( [ 9999.0, 3.0, 3.6666666666666665, 3.0, 3.3030303030303032, 3.5321100917431192, 3.0, 4.7991341991341994, 3.0, 4.3327319742618320 ] ); // eslint-disable-line max-len - expectedDU = new Float64Array( [ 9999.0, 1.0, -1.3333333333333333, 1.0, -2.7878787878787876, 4.0, 1.0, 3.1965367965367970, 1.0 ] ); // eslint-disable-line max-len - expectedDU2 = new Float64Array( [ 0.0, 4.0, 0.0, 4.0, 0.0, 0.0, 4.0, 0.0 ] ); // eslint-disable-line max-len - expectedIPIV = new Int32Array( [ 0, 1, 1, 3, 3, 4, 6, 6, 8, 8 ] ); + expectedDL = new Float64Array( data.expectedDL ); + expectedD = new Float64Array( data.expectedD ); + expectedDU = new Float64Array( data.expectedDU ); + expectedDU2 = new Float64Array( data.expectedDU2 ); + expectedIPIV = new Int32Array( data.expectedIPIV ); - info = dgttrf( N, DL, 1, 1, D, 1, 1, DU, 1, 1, DU2, 1, 1, IPIV, 1, 1 ); - t.strictEqual( info, 0, 'returns expected value' ); + info = dgttrf( N, DL, data.sdl, data.odl, D, data.sd, data.od, DU, data.sdu, data.odu, DU2, data.sdu2, data.odu2, IPIV, data.si, data.oi ); // eslint-disable-line max-len + t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); isApprox( t, D, expectedD, 1.0 ); isApprox( t, DU, expectedDU, 1.0 ); @@ -370,6 +406,7 @@ tape( 'the function leaves the input arrays unchanged when `N` is equal to zero' var expectedDU; var expectedDL; var expectedD; + var data; var info; var IPIV; var DU2; @@ -378,27 +415,29 @@ tape( 'the function leaves the input arrays unchanged when `N` is equal to zero' var D; var N; + data = POSITIVE_STRIDES_NO_OFFSET_1; + N = 0; - DL = new Float64Array( [ 1.0, 1.0 ] ); - D = new Float64Array( [ 2.0, 3.0, 1.0 ] ); - DU = new Float64Array( [ 1.0, 1.0 ] ); - DU2 = new Float64Array( 1 ); - IPIV = new Int32Array( 3 ); + DL = new Float64Array( data.DL ); + D = new Float64Array( data.D ); + DU = new Float64Array( data.DU ); + DU2 = new Float64Array( data.DU2 ); + IPIV = new Int32Array( data.IPIV ); - expectedDL = new Float64Array( [ 1.0, 1.0 ] ); - expectedD = new Float64Array( [ 2.0, 3.0, 1.0 ] ); - expectedDU = new Float64Array( [ 1.0, 1.0 ] ); - expectedDU2 = new Float64Array( [ 0.0 ] ); - expectedIPIV = new Int32Array( [ 0, 0, 0 ] ); + expectedDL = new Float64Array( data.DL ); + expectedD = new Float64Array( data.D ); + expectedDU = new Float64Array( data.DU ); + expectedDU2 = new Float64Array( data.DU2 ); + expectedIPIV = new Int32Array( data.IPIV ); - info = dgttrf( N, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 ); - t.strictEqual( info, 0, 'returns expected value' ); - t.deepEqual( DU, expectedDU, 'returns expected value' ); - t.deepEqual( DU2, expectedDU2, 'returns expected value' ); - t.deepEqual( D, expectedD, 'returns expected value' ); - t.deepEqual( DL, expectedDL, 'returns expected value' ); + info = dgttrf( N, DL, data.sdl, data.odl, D, data.sd, data.od, DU, data.sdu, data.odu, DU2, data.sdu2, data.odu2, IPIV, data.si, data.oi ); // eslint-disable-line max-len + t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); + isApprox( t, D, expectedD, 0.0 ); + isApprox( t, DU, expectedDU, 0.0 ); + isApprox( t, DU2, expectedDU2, 0.0 ); + isApprox( t, DL, expectedDL, 0.0 ); t.end(); }); From 78e0cfd8b6c0429a443b07fd39fa9dd53bf44d23 Mon Sep 17 00:00:00 2001 From: Aayush Khanna <96649223+aayush0325@users.noreply.github.com> Date: Mon, 17 Mar 2025 22:22:18 +0530 Subject: [PATCH 20/25] Update lib/node_modules/@stdlib/lapack/base/dgttrf/README.md Co-authored-by: Athan Signed-off-by: Aayush Khanna <96649223+aayush0325@users.noreply.github.com> --- lib/node_modules/@stdlib/lapack/base/dgttrf/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md b/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md index 80252f7ece39..758d1a8bc4d7 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md @@ -55,7 +55,7 @@ dgttrf( 3, DL, D, DU, DU2, IPIV ); The function has the following parameters: - **N**: order of matrix `A`. -- **DL**: the sub diagonall elements of `A` as a [`Float64Array`][mdn-float64array]. On exit, DL is overwritten by the multipliers that define the matrix `L` from the `LU` factorization of `A`. +- **DL**: the sub diagonal elements of `A` as a [`Float64Array`][mdn-float64array]. On exit, DL is overwritten by the multipliers that define the matrix `L` from the `LU` factorization of `A`. - **D**: the diagonal elements of `A` as a [`Float64Array`][mdn-float64array]. On exit, D is overwritten by the diagonal elements of the upper triangular matrix `U` from the `LU` factorization of `A`. - **DU**: the super diagonal elements of `A` as a [`Float64Array`][mdn-float64array]. On exit, DU is overwritten by the elements of the first super-diagonal of `U`. - **DU2**: On exit, DU2 is overwritten by the elements of the second super-diagonal of `U` as a [`Float64Array`][mdn-float64array]. From fef9486667d84179a5ec2eb6405fe979a4fc5f62 Mon Sep 17 00:00:00 2001 From: aayush0325 Date: Sat, 22 Mar 2025 05:04:19 +0000 Subject: [PATCH 21/25] test: use deepEqual instead of isApprox --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../lapack/base/dgttrf/test/test.dgttrf.js | 55 ++-------- .../lapack/base/dgttrf/test/test.ndarray.js | 103 ++++++------------ 2 files changed, 48 insertions(+), 110 deletions(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js index a329d22777e5..2b178a03496c 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js @@ -23,8 +23,6 @@ var tape = require( 'tape' ); var Float64Array = require( '@stdlib/array/float64' ); var Int32Array = require( '@stdlib/array/int32' ); -var EPS = require( '@stdlib/constants/float64/eps' ); -var abs = require( '@stdlib/math/base/special/abs' ); var dgttrf = require( './../lib/dgttrf.js' ); @@ -34,35 +32,6 @@ var POSITIVE_STRIDES_NO_OFFSET_1 = require( './fixtures/positive_stride_no_offse var POSITIVE_STRIDES_NO_OFFSET_2 = require( './fixtures/positive_stride_no_offset_2.json' ); // eslint-disable-line id-length -// FUNCTIONS // - -/** -* Tests for element-wise approximate equality. -* -* @private -* @param {Object} t - test object -* @param {Collection} actual - actual values -* @param {Collection} expected - expected values -* @param {number} rtol - relative tolerance -*/ -function isApprox( t, actual, expected, rtol ) { - var delta; - var tol; - var i; - - t.strictEqual( actual.length, expected.length, 'returns expected value' ); - for ( i = 0; i < expected.length; i++ ) { - if ( actual[ i ] === expected[ i ] ) { - t.strictEqual( actual[ i ], expected[ i ], 'returns expected value' ); - } else { - delta = abs( actual[ i ] - expected[ i ] ); - tol = rtol * EPS * abs( expected[ i ] ); - t.ok( delta <= tol, 'within tolerance. actual: '+actual[ i ]+'. expected: '+expected[ i ]+'. delta: '+delta+'. tol: '+tol+'.' ); - } - } -} - - // TESTS // tape( 'main export is a function', function test( t ) { @@ -146,10 +115,10 @@ tape( 'the function performs the `LU` factorization of a real tri diagonal matri info = dgttrf( N, DL, D, DU, DU2, IPIV ); t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); - isApprox( t, D, expectedD, 1.0 ); - isApprox( t, DU, expectedDU, 1.0 ); - isApprox( t, DU2, expectedDU2, 1.0 ); - isApprox( t, DL, expectedDL, 1.0 ); + t.deepEqual( D, expectedD, 'returns expected value' ); + t.deepEqual( DU, expectedDU, 'returns expected value' ); + t.deepEqual( DU2, expectedDU2, 'returns expected value' ); + t.deepEqual( DL, expectedDL, 'returns expected value' ); data = POSITIVE_STRIDES_NO_OFFSET_2; @@ -170,10 +139,10 @@ tape( 'the function performs the `LU` factorization of a real tri diagonal matri info = dgttrf( N, DL, D, DU, DU2, IPIV ); t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); - isApprox( t, D, expectedD, 1.0 ); - isApprox( t, DU, expectedDU, 1.0 ); - isApprox( t, DU2, expectedDU2, 1.0 ); - isApprox( t, DL, expectedDL, 1.0 ); + t.deepEqual( D, expectedD, 'returns expected value' ); + t.deepEqual( DU, expectedDU, 'returns expected value' ); + t.deepEqual( DU2, expectedDU2, 'returns expected value' ); + t.deepEqual( DL, expectedDL, 'returns expected value' ); t.end(); }); @@ -235,10 +204,10 @@ tape( 'the function leaves the input arrays unchanged when `N` is equal to zero' info = dgttrf( N, DL, D, DU, DU2, IPIV ); t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); - isApprox( t, D, expectedD, 0.0 ); - isApprox( t, DU, expectedDU, 0.0 ); - isApprox( t, DU2, expectedDU2, 0.0 ); - isApprox( t, DL, expectedDL, 0.0 ); + t.deepEqual( D, expectedD, 'returns expected value' ); + t.deepEqual( DU, expectedDU, 'returns expected value' ); + t.deepEqual( DU2, expectedDU2, 'returns expected value' ); + t.deepEqual( DL, expectedDL, 'returns expected value' ); t.end(); }); diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js index 2df892c7b1b4..ab17cb04237a 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.ndarray.js @@ -23,8 +23,6 @@ var tape = require( 'tape' ); var Float64Array = require( '@stdlib/array/float64' ); var Int32Array = require( '@stdlib/array/int32' ); -var EPS = require( '@stdlib/constants/float64/eps' ); -var abs = require( '@stdlib/math/base/special/abs' ); var dgttrf = require( './../lib/ndarray.js' ); @@ -40,35 +38,6 @@ var POSITIVE_STRIDES_OFFSET_1 = require( './fixtures/positive_stride_offset_1.js var POSITIVE_STRIDES_OFFSET_2 = require( './fixtures/positive_stride_offset_2.json' ); -// FUNCTIONS // - -/** -* Tests for element-wise approximate equality. -* -* @private -* @param {Object} t - test object -* @param {Collection} actual - actual values -* @param {Collection} expected - expected values -* @param {number} rtol - relative tolerance -*/ -function isApprox( t, actual, expected, rtol ) { - var delta; - var tol; - var i; - - t.strictEqual( actual.length, expected.length, 'returns expected value' ); - for ( i = 0; i < expected.length; i++ ) { - if ( actual[ i ] === expected[ i ] ) { - t.strictEqual( actual[ i ], expected[ i ], 'returns expected value' ); - } else { - delta = abs( actual[ i ] - expected[ i ] ); - tol = rtol * EPS * abs( expected[ i ] ); - t.ok( delta <= tol, 'within tolerance. actual: '+actual[ i ]+'. expected: '+expected[ i ]+'. delta: '+delta+'. tol: '+tol+'.' ); - } - } -} - - // TESTS // tape( 'main export is a function', function test( t ) { @@ -152,10 +121,10 @@ tape( 'the function performs the `LU` factorization of a real tri diagonal matri info = dgttrf( N, DL, data.sdl, data.odl, D, data.sd, data.od, DU, data.sdu, data.odu, DU2, data.sdu2, data.odu2, IPIV, data.si, data.oi ); // eslint-disable-line max-len t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); - isApprox( t, D, expectedD, 1.0 ); - isApprox( t, DU, expectedDU, 1.0 ); - isApprox( t, DU2, expectedDU2, 1.0 ); - isApprox( t, DL, expectedDL, 1.0 ); + t.deepEqual( D, expectedD, 'returns expected value' ); + t.deepEqual( DU, expectedDU, 'returns expected value' ); + t.deepEqual( DU2, expectedDU2, 'returns expected value' ); + t.deepEqual( DL, expectedDL, 'returns expected value' ); data = POSITIVE_STRIDES_NO_OFFSET_2; @@ -176,10 +145,10 @@ tape( 'the function performs the `LU` factorization of a real tri diagonal matri info = dgttrf( N, DL, data.sdl, data.odl, D, data.sd, data.od, DU, data.sdu, data.odu, DU2, data.sdu2, data.odu2, IPIV, data.si, data.oi ); // eslint-disable-line max-len t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); - isApprox( t, D, expectedD, 1.0 ); - isApprox( t, DU, expectedDU, 1.0 ); - isApprox( t, DU2, expectedDU2, 1.0 ); - isApprox( t, DL, expectedDL, 1.0 ); + t.deepEqual( D, expectedD, 'returns expected value' ); + t.deepEqual( DU, expectedDU, 'returns expected value' ); + t.deepEqual( DU2, expectedDU2, 'returns expected value' ); + t.deepEqual( DL, expectedDL, 'returns expected value' ); t.end(); }); @@ -218,10 +187,10 @@ tape( 'the function supports providing positive strides', function test( t ) { info = dgttrf( N, DL, data.sdl, data.odl, D, data.sd, data.od, DU, data.sdu, data.odu, DU2, data.sdu2, data.odu2, IPIV, data.si, data.oi ); // eslint-disable-line max-len t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); - isApprox( t, D, expectedD, 1.0 ); - isApprox( t, DU, expectedDU, 1.0 ); - isApprox( t, DU2, expectedDU2, 1.0 ); - isApprox( t, DL, expectedDL, 1.0 ); + t.deepEqual( D, expectedD, 'returns expected value' ); + t.deepEqual( DU, expectedDU, 'returns expected value' ); + t.deepEqual( DU2, expectedDU2, 'returns expected value' ); + t.deepEqual( DL, expectedDL, 'returns expected value' ); data = LARGE_POSITIVE_STRIDE_2; @@ -242,10 +211,10 @@ tape( 'the function supports providing positive strides', function test( t ) { info = dgttrf( N, DL, data.sdl, data.odl, D, data.sd, data.od, DU, data.sdu, data.odu, DU2, data.sdu2, data.odu2, IPIV, data.si, data.oi ); // eslint-disable-line max-len t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); - isApprox( t, D, expectedD, 1.0 ); - isApprox( t, DU, expectedDU, 1.0 ); - isApprox( t, DU2, expectedDU2, 1.0 ); - isApprox( t, DL, expectedDL, 1.0 ); + t.deepEqual( D, expectedD, 'returns expected value' ); + t.deepEqual( DU, expectedDU, 'returns expected value' ); + t.deepEqual( DU2, expectedDU2, 'returns expected value' ); + t.deepEqual( DL, expectedDL, 'returns expected value' ); t.end(); }); @@ -284,10 +253,10 @@ tape( 'the function supports providing negative strides', function test( t ) { info = dgttrf( N, DL, data.sdl, data.odl, D, data.sd, data.od, DU, data.sdu, data.odu, DU2, data.sdu2, data.odu2, IPIV, data.si, data.oi ); // eslint-disable-line max-len t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); - isApprox( t, D, expectedD, 1.0 ); - isApprox( t, DU, expectedDU, 1.0 ); - isApprox( t, DU2, expectedDU2, 1.0 ); - isApprox( t, DL, expectedDL, 1.0 ); + t.deepEqual( D, expectedD, 'returns expected value' ); + t.deepEqual( DU, expectedDU, 'returns expected value' ); + t.deepEqual( DU2, expectedDU2, 'returns expected value' ); + t.deepEqual( DL, expectedDL, 'returns expected value' ); t.end(); }); @@ -326,10 +295,10 @@ tape( 'the function supports providing mixed strides', function test( t ) { info = dgttrf( N, DL, data.sdl, data.odl, D, data.sd, data.od, DU, data.sdu, data.odu, DU2, data.sdu2, data.odu2, IPIV, data.si, data.oi ); // eslint-disable-line max-len t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); - isApprox( t, D, expectedD, 1.0 ); - isApprox( t, DU, expectedDU, 1.0 ); - isApprox( t, DU2, expectedDU2, 1.0 ); - isApprox( t, DL, expectedDL, 1.0 ); + t.deepEqual( D, expectedD, 'returns expected value' ); + t.deepEqual( DU, expectedDU, 'returns expected value' ); + t.deepEqual( DU2, expectedDU2, 'returns expected value' ); + t.deepEqual( DL, expectedDL, 'returns expected value' ); t.end(); }); @@ -368,10 +337,10 @@ tape( 'the function supports providing index offsets', function test( t ) { info = dgttrf( N, DL, data.sdl, data.odl, D, data.sd, data.od, DU, data.sdu, data.odu, DU2, data.sdu2, data.odu2, IPIV, data.si, data.oi ); // eslint-disable-line max-len t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); - isApprox( t, D, expectedD, 1.0 ); - isApprox( t, DU, expectedDU, 1.0 ); - isApprox( t, DU2, expectedDU2, 1.0 ); - isApprox( t, DL, expectedDL, 1.0 ); + t.deepEqual( D, expectedD, 'returns expected value' ); + t.deepEqual( DU, expectedDU, 'returns expected value' ); + t.deepEqual( DU2, expectedDU2, 'returns expected value' ); + t.deepEqual( DL, expectedDL, 'returns expected value' ); data = POSITIVE_STRIDES_OFFSET_2; @@ -392,10 +361,10 @@ tape( 'the function supports providing index offsets', function test( t ) { info = dgttrf( N, DL, data.sdl, data.odl, D, data.sd, data.od, DU, data.sdu, data.odu, DU2, data.sdu2, data.odu2, IPIV, data.si, data.oi ); // eslint-disable-line max-len t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); - isApprox( t, D, expectedD, 1.0 ); - isApprox( t, DU, expectedDU, 1.0 ); - isApprox( t, DU2, expectedDU2, 1.0 ); - isApprox( t, DL, expectedDL, 1.0 ); + t.deepEqual( D, expectedD, 'returns expected value' ); + t.deepEqual( DU, expectedDU, 'returns expected value' ); + t.deepEqual( DU2, expectedDU2, 'returns expected value' ); + t.deepEqual( DL, expectedDL, 'returns expected value' ); t.end(); }); @@ -434,10 +403,10 @@ tape( 'the function leaves the input arrays unchanged when `N` is equal to zero' info = dgttrf( N, DL, data.sdl, data.odl, D, data.sd, data.od, DU, data.sdu, data.odu, DU2, data.sdu2, data.odu2, IPIV, data.si, data.oi ); // eslint-disable-line max-len t.strictEqual( info, data.expectedInfo, 'returns expected value' ); t.deepEqual( IPIV, expectedIPIV, 'returns expected value' ); - isApprox( t, D, expectedD, 0.0 ); - isApprox( t, DU, expectedDU, 0.0 ); - isApprox( t, DU2, expectedDU2, 0.0 ); - isApprox( t, DL, expectedDL, 0.0 ); + t.deepEqual( D, expectedD, 'returns expected value' ); + t.deepEqual( DU, expectedDU, 'returns expected value' ); + t.deepEqual( DU2, expectedDU2, 'returns expected value' ); + t.deepEqual( DL, expectedDL, 'returns expected value' ); t.end(); }); From a4fb01d0d52c5f546240bf849edba03f97d43f83 Mon Sep 17 00:00:00 2001 From: Aayush Khanna <96649223+aayush0325@users.noreply.github.com> Date: Fri, 28 Mar 2025 09:21:51 -0700 Subject: [PATCH 22/25] chore: spelling check --- lib/node_modules/@stdlib/lapack/base/dgttrf/README.md | 6 +++--- lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt | 4 ++-- .../@stdlib/lapack/base/dgttrf/docs/types/index.d.ts | 6 +++--- lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js | 2 +- lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js | 2 +- lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js | 2 +- lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js | 2 +- 7 files changed, 12 insertions(+), 12 deletions(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md b/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md index 758d1a8bc4d7..4cc24fe014bf 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md @@ -20,7 +20,7 @@ limitations under the License. # dgttrf -> Compute an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. +> Compute an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges.
@@ -32,7 +32,7 @@ var dgttrf = require( '@stdlib/lapack/base/dgttrf' ); #### dgttrf( N, DL, D, DU, DU2, IPIV ) -Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. +Computes an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges. ```javascript var Float64Array = require( '@stdlib/array/float64' ); @@ -95,7 +95,7 @@ dgttrf( 3, DL, D, DU, DU2, IPIV ); #### dgttrf.ndarray( N, DL, sdl, odl, D, sd, od, DU, sdu, odu, DU2, sdu2, odu2, IPIV, si, oi ) -Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges and alternative indexing semantics. +Computes an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges and alternative indexing semantics. ```javascript var Float64Array = require( '@stdlib/array/float64' ); diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt index d4fde45d1d91..beebf8bee896 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt @@ -1,6 +1,6 @@ {{alias}}( N, DL, D, DU, DU2, IPIV ) - Computes an `LU` factorization of a real tri diagonal matrix `A` using + Computes an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges. Indexing is relative to the first index. To introduce an offset, use typed @@ -92,7 +92,7 @@ {{alias}}.ndarray( N,DL,sdl,odl,D,sd,od,DU,sdu,odu,DU2,sdu2,odu2,IPIV,si,oi ) - Computes an `LU` factorization of a real tri diagonal matrix `A` using + Computes an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges and alternative indexing semantics. diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts index c83f293ecdff..31773a9e8fd9 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts @@ -36,7 +36,7 @@ type StatusCode = number; */ interface Routine { /** - * Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. + * Computes an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges. * * ## Notes * @@ -74,7 +74,7 @@ interface Routine { ( N: number, DL: Float64Array, D: Float64Array, DU: Float64Array, DU2: Float64Array, IPIV: Int32Array ): StatusCode; /** - * Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges and alternative indexing semantics. + * Computes an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges and alternative indexing semantics. * * ## Notes * @@ -120,7 +120,7 @@ interface Routine { } /** -* LAPACK routine to compute an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. +* LAPACK routine to compute an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges. * * ## Notes * diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js index 2f7727a78603..e77b0bc2c1ad 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js @@ -26,7 +26,7 @@ var abs = require( '@stdlib/math/base/special/abs' ); // MAIN // /** -* Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. +* Computes an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges. * * ## Notes * diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js index 81e6fba44121..482943f6be08 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js @@ -27,7 +27,7 @@ var base = require( './base.js' ); // MAIN // /** -* Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. +* Computes an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges. * * ## Notes * diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js index 4fb388ab671a..e4f7211c056e 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js @@ -19,7 +19,7 @@ 'use strict'; /** -* LAPACK routine to compute an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. +* LAPACK routine to compute an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges. * * @module @stdlib/lapack/base/dgttrf * diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js index a4108c6938e0..6c49def4d814 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js @@ -27,7 +27,7 @@ var base = require( './base.js' ); // MAIN // /** -* Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges and alternative indexing semantics. +* Computes an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges and alternative indexing semantics. * * ## Notes * From f5f02139441f517a44d14b38720af580dafd00e2 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Mon, 31 Mar 2025 11:05:15 +0000 Subject: [PATCH 23/25] refactor: precompute indices --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/lapack/base/dgttrf/lib/base.js | 68 +++++++++++-------- 1 file changed, 41 insertions(+), 27 deletions(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js index e77b0bc2c1ad..fffdc9e2702f 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js @@ -78,8 +78,12 @@ function dgttrf( N, DL, sdl, odl, D, sd, od, DU, sdu, odu, DU2, sdu2, odu2, IPIV var idu2; var idu; var idl; + var dli; + var dui; var id; var ip; + var di; + var ii; var i; // Quick return if possible @@ -100,51 +104,61 @@ function dgttrf( N, DL, sdl, odl, D, sd, od, DU, sdu, odu, DU2, sdu2, odu2, IPIV // Initialise ith element of DU2 as 0 for ( i = 0; i < N-2; i++ ) { - DU2[ idu + (sdu*i) ] = 0; + DU2[ idu + dui ] = 0; } for ( i = 0; i < N-2; i++ ) { - if ( abs( D[ id + (sd*i) ] ) >= abs( DL[ idl + (sdl*i) ] ) ) { // No row interchange required, eleminate ith element of DL + di = sd * i; + dli = sdl * i; + ii = si * i; + dui = sdu * i; + + if ( abs( D[ id + di ] ) >= abs( DL[ idl + dli ] ) ) { // No row interchange required, eleminate ith element of DL if ( D[ id ] !== 0.0 ) { - fact = DL[ idl + (sdl*i) ] / D[ id + (sd*i) ]; - DL[ idl + (sdl*i) ] = fact; - D[ id + (sd*(i+1)) ] = D[ id + (sd*(i+1)) ] - ( fact*DU[ idu + (sdu*i) ] ); // eslint-disable-line max-len + fact = DL[ idl + dli ] / D[ id + di ]; + DL[ idl + dli ] = fact; + D[ id + di + sd ] = D[ id + di + sd ] - ( fact*DU[ idu + dui ] ); // eslint-disable-line max-len } } else { // Interchange the ith and (i+1)th rows and eliminate ith element of DL - fact = D[ id+(sd*i) ] / DL[ idl+(sdl*i) ]; - D[ id+(sd*i) ] = DL[ idl+(sdl*i) ]; - DL[ idl+(sdl*i) ] = fact; - temp = DU[ idu+(sdu*i) ]; - DU[ idu+(sdu*i) ] = D[ id + (sd*(i+1)) ]; - D[ id+(sd*(i+1)) ] = temp - ( fact*D[ id+(sd*(i+1)) ] ); - DU2[ idu2+(sdu2*i) ] = DU[ idu+(sdu*(i+1)) ]; - DU[ idu+(sdu*(i+1)) ] = -fact*DU[ idu+(sdu*(i+1)) ]; - IPIV[ ip+(si*i) ] = i + 1; + fact = D[ id + di ] / DL[ idl + dli ]; + D[ id + di ] = DL[ idl + dli ]; + DL[ idl + dli ] = fact; + temp = DU[ idu + dui ]; + DU[ idu + dui ] = D[ id + di + sd ]; + D[ id + di + sd ] = temp - ( fact * D[ id + di + sd ] ); + DU2[ idu2 + ( sdu2 * i ) ] = DU[ idu + dui + sdu ]; + DU[ idu + dui + sdu ] = -fact * DU[ idu + dui + sdu ]; + IPIV[ ip + ii ] = i + 1; } } if ( N > 1 ) { i = N - 2; - if ( abs( D[ id + (sd*i) ] ) >= abs( DL[ idl + (sdl*i) ] ) ) { - if ( D[ id + (sd*i) ] !== 0 ) { - fact = DL[ idl + (sdl*i) ] / D[ id + (sd*i) ]; - DL[ idl + (sdl*i) ] = fact; - D[ id + (sd*(i+1)) ] = D[ id + (sd*(i+1)) ] - (fact*DU[ idu + (sdu*i) ]); // eslint-disable-line max-len + di = sd * i; + dli = sdl * i; + ii = si * i; + dui = sdu * i; + + if ( abs( D[ id + di ] ) >= abs( DL[ idl + dli ] ) ) { + if ( D[ id + di ] !== 0 ) { + fact = DL[ idl + dli ] / D[ id + di ]; + DL[ idl + dli ] = fact; + D[ id + di + sd ] = D[ id + di + sd ] - (fact*DU[ idu + dui ]); } } else { - fact = D[ id+(sd*i) ] / DL[ idl+(sdl*i) ]; - D[ id+(sd*i) ] = DL[ idl+(sdl*i) ]; - DL[ idl+(sdl*i) ] = fact; - temp = DU[ idu+(sdu*i) ]; - DU[ idu+(sdu*i) ] = D[ id + (sd*(i+1)) ]; - D[ id+(sd*(i+1)) ] = temp - ( fact*D[ id+(sd*(i+1)) ] ); - IPIV[ ip+(si*i) ] = i + 1; + fact = D[ id + di ] / DL[ idl + dli ]; + D[ id + di ] = DL[ idl + dli ]; + DL[ idl + dli ] = fact; + temp = DU[ idu + dui ]; + DU[ idu + dui ] = D[ id + di + sd ]; + D[ id + di + sd ] = temp - ( fact * D[ id + di + sd ] ); + IPIV[ ip + ii ] = i + 1; } } // Check for a 0 on the diagonal of U for ( i = 0; i < N; i++ ) { - if ( D[ id+(sd*i) ] === 0.0 ) { + if ( D[ sd * i ] === 0.0 ) { return i; } } From 996cc82b66f1dc74e3b626e655f2417627768004 Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Sat, 5 Apr 2025 13:21:22 +0000 Subject: [PATCH 24/25] chore: spell check --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: passed - task: lint_package_json status: na - task: lint_repl_help status: passed - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- lib/node_modules/@stdlib/lapack/base/dgttrf/README.md | 6 +++--- lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt | 4 ++-- .../@stdlib/lapack/base/dgttrf/docs/types/index.d.ts | 6 +++--- lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js | 4 ++-- lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js | 2 +- lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js | 2 +- lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js | 2 +- 7 files changed, 13 insertions(+), 13 deletions(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md b/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md index 4cc24fe014bf..758d1a8bc4d7 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/README.md @@ -20,7 +20,7 @@ limitations under the License. # dgttrf -> Compute an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges. +> Compute an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges.
@@ -32,7 +32,7 @@ var dgttrf = require( '@stdlib/lapack/base/dgttrf' ); #### dgttrf( N, DL, D, DU, DU2, IPIV ) -Computes an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges. +Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. ```javascript var Float64Array = require( '@stdlib/array/float64' ); @@ -95,7 +95,7 @@ dgttrf( 3, DL, D, DU, DU2, IPIV ); #### dgttrf.ndarray( N, DL, sdl, odl, D, sd, od, DU, sdu, odu, DU2, sdu2, odu2, IPIV, si, oi ) -Computes an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges and alternative indexing semantics. +Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges and alternative indexing semantics. ```javascript var Float64Array = require( '@stdlib/array/float64' ); diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt index beebf8bee896..d4fde45d1d91 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt @@ -1,6 +1,6 @@ {{alias}}( N, DL, D, DU, DU2, IPIV ) - Computes an `LU` factorization of a real tridiagonal matrix `A` using + Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. Indexing is relative to the first index. To introduce an offset, use typed @@ -92,7 +92,7 @@ {{alias}}.ndarray( N,DL,sdl,odl,D,sd,od,DU,sdu,odu,DU2,sdu2,odu2,IPIV,si,oi ) - Computes an `LU` factorization of a real tridiagonal matrix `A` using + Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges and alternative indexing semantics. diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts index 31773a9e8fd9..c83f293ecdff 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts @@ -36,7 +36,7 @@ type StatusCode = number; */ interface Routine { /** - * Computes an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges. + * Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. * * ## Notes * @@ -74,7 +74,7 @@ interface Routine { ( N: number, DL: Float64Array, D: Float64Array, DU: Float64Array, DU2: Float64Array, IPIV: Int32Array ): StatusCode; /** - * Computes an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges and alternative indexing semantics. + * Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges and alternative indexing semantics. * * ## Notes * @@ -120,7 +120,7 @@ interface Routine { } /** -* LAPACK routine to compute an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges. +* LAPACK routine to compute an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. * * ## Notes * diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js index fffdc9e2702f..212c1891f485 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/base.js @@ -26,7 +26,7 @@ var abs = require( '@stdlib/math/base/special/abs' ); // MAIN // /** -* Computes an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges. +* Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. * * ## Notes * @@ -104,7 +104,7 @@ function dgttrf( N, DL, sdl, odl, D, sd, od, DU, sdu, odu, DU2, sdu2, odu2, IPIV // Initialise ith element of DU2 as 0 for ( i = 0; i < N-2; i++ ) { - DU2[ idu + dui ] = 0; + DU2[ idu + (sdu*i) ] = 0; } for ( i = 0; i < N-2; i++ ) { diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js index 482943f6be08..81e6fba44121 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/dgttrf.js @@ -27,7 +27,7 @@ var base = require( './base.js' ); // MAIN // /** -* Computes an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges. +* Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. * * ## Notes * diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js index e4f7211c056e..4fb388ab671a 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js @@ -19,7 +19,7 @@ 'use strict'; /** -* LAPACK routine to compute an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges. +* LAPACK routine to compute an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges. * * @module @stdlib/lapack/base/dgttrf * diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js index 6c49def4d814..a4108c6938e0 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/ndarray.js @@ -27,7 +27,7 @@ var base = require( './base.js' ); // MAIN // /** -* Computes an `LU` factorization of a real tridiagonal matrix `A` using elimination with partial pivoting and row interchanges and alternative indexing semantics. +* Computes an `LU` factorization of a real tri diagonal matrix `A` using elimination with partial pivoting and row interchanges and alternative indexing semantics. * * ## Notes * From 5c80a24daba05c2eae03bf8ccd274b6f4b25aced Mon Sep 17 00:00:00 2001 From: Aayush Khanna Date: Sat, 5 Apr 2025 13:30:16 +0000 Subject: [PATCH 25/25] chore: self review --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../fixtures/large_positive_stride_2.json | 60 +++++++++++++++++-- .../fixtures/positive_stride_no_offset_2.json | 34 ++++++++++- .../fixtures/positive_stride_offset_2.json | 37 +++++++++++- 3 files changed, 121 insertions(+), 10 deletions(-) diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/large_positive_stride_2.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/large_positive_stride_2.json index 9218f31f9cb1..e21f6d0510aa 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/large_positive_stride_2.json +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/large_positive_stride_2.json @@ -1,6 +1,5 @@ { "N": 9, - "DL": [ 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0, 3.0, 9999.0 ], "sdl": 2, "odl": 0, @@ -21,9 +20,62 @@ "si": 2, "oi": 0, - "expectedDL": [ 0.3333333333333333, 9999.0, 0.8181818181818182, 9999.0, 0.6969696969696969, 9999.0, 0.9082568807339449, 9999.0, 0.8493506493506494, 9999.0, -0.7991341991341993, 9999.0, 0.6251127548259066, 9999.0, -0.3327319742618318, 9999.0 ], - "expectedD": [ 3.0, 9999.0, 3.6666666666666665, 9999.0, 3.0, 9999.0, 3.3030303030303032, 9999.0, 3.5321100917431192, 9999.0, 3.0, 9999.0, 4.7991341991341994, 9999.0, 3.0, 9999.0, 4.3327319742618320, 9999.0 ], - "expectedDU": [ 1.0, 9999.0, -1.3333333333333333, 9999.0, 1.0, 9999.0, -2.7878787878787876, 9999.0, 4.0, 9999.0, 1.0, 9999.0, 3.1965367965367970, 9999.0, 1.0, 9999.0 ], + "expectedDL": [ + 0.3333333333333333, + 9999.0, + 0.8181818181818182, + 9999.0, + 0.6969696969696969, + 9999.0, + 0.9082568807339449, + 9999.0, + 0.8493506493506494, + 9999.0, + -0.7991341991341993, + 9999.0, + 0.6251127548259066, + 9999.0, + -0.3327319742618318, + 9999.0 + ], + "expectedD": [ + 3.0, + 9999.0, + 3.6666666666666665, + 9999.0, + 3.0, + 9999.0, + 3.3030303030303032, + 9999.0, + 3.5321100917431192, + 9999.0, + 3.0, + 9999.0, + 4.7991341991341994, + 9999.0, + 3.0, + 9999.0, + 4.3327319742618320, + 9999.0 + ], + "expectedDU": [ + 1.0, + 9999.0, + -1.3333333333333333, + 9999.0, + 1.0, + 9999.0, + -2.7878787878787876, + 9999.0, + 4.0, + 9999.0, + 1.0, + 9999.0, + 3.1965367965367970, + 9999.0, + 1.0, + 9999.0 + ], "expectedDU2": [ 4.0, 0.0, 0.0, 0.0, 4.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.0, 0.0, 0.0, 0.0 ], "expectedIPIV": [ 1, 0, 1, 0, 3, 0, 3, 0, 4, 0, 6, 0, 6, 0, 8, 0, 8, 0 ], "expectedInfo": 0 diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_no_offset_2.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_no_offset_2.json index 02c60436c391..66f0164a1a0f 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_no_offset_2.json +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_no_offset_2.json @@ -21,9 +21,37 @@ "si": 1, "oi": 0, - "expectedDL": [ 0.3333333333333333, 0.8181818181818182, 0.6969696969696969, 0.9082568807339449, 0.8493506493506494, -0.7991341991341993, 0.6251127548259066, -0.3327319742618318 ], - "expectedD": [ 3.0, 3.6666666666666665, 3.0, 3.3030303030303032, 3.5321100917431192, 3.0, 4.7991341991341994, 3.0, 4.3327319742618320 ], - "expectedDU": [ 1.0, -1.3333333333333333, 1.0, -2.7878787878787876, 4.0, 1.0, 3.1965367965367970, 1.0 ], + "expectedDL": [ + 0.3333333333333333, + 0.8181818181818182, + 0.6969696969696969, + 0.9082568807339449, + 0.8493506493506494, + -0.7991341991341993, + 0.6251127548259066, + -0.3327319742618318 + ], + "expectedD": [ + 3.0, + 3.6666666666666665, + 3.0, + 3.3030303030303032, + 3.5321100917431192, + 3.0, + 4.7991341991341994, + 3.0, + 4.3327319742618320 + ], + "expectedDU": [ + 1.0, + -1.3333333333333333, + 1.0, + -2.7878787878787876, + 4.0, + 1.0, + 3.1965367965367970, + 1.0 + ], "expectedDU2": [ 4.0, 0.0, 4.0, 0.0, 0.0, 4.0, 0.0 ], "expectedIPIV": [ 1, 1, 3, 3, 4, 6, 6, 8, 8 ], "expectedInfo": 0 diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_offset_2.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_offset_2.json index 54b3e6e0de0f..066b868c8cc4 100644 --- a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_offset_2.json +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/positive_stride_offset_2.json @@ -21,9 +21,40 @@ "si": 1, "oi": 1, - "expectedDL": [ 0.0, 0.3333333333333333, 0.8181818181818182, 0.6969696969696969, 0.9082568807339449, 0.8493506493506494, -0.7991341991341993, 0.6251127548259066, -0.3327319742618318 ], - "expectedD": [ 0.0, 3.0, 3.6666666666666665, 3.0, 3.3030303030303032, 3.5321100917431192, 3.0, 4.7991341991341994, 3.0, 4.3327319742618320 ], - "expectedDU": [ 0.0, 1.0, -1.3333333333333333, 1.0, -2.7878787878787876, 4.0, 1.0, 3.1965367965367970, 1.0 ], + "expectedDL": [ + 0.0, + 0.3333333333333333, + 0.8181818181818182, + 0.6969696969696969, + 0.9082568807339449, + 0.8493506493506494, + -0.7991341991341993, + 0.6251127548259066, + -0.3327319742618318 + ], + "expectedD": [ + 0.0, + 3.0, + 3.6666666666666665, + 3.0, + 3.3030303030303032, + 3.5321100917431192, + 3.0, + 4.7991341991341994, + 3.0, + 4.3327319742618320 + ], + "expectedDU": [ + 0.0, + 1.0, + -1.3333333333333333, + 1.0, + -2.7878787878787876, + 4.0, + 1.0, + 3.1965367965367970, + 1.0 + ], "expectedDU2": [ 0.0, 4.0, 0.0, 4.0, 0.0, 0.0, 4.0, 0.0 ], "expectedIPIV": [ 0, 1, 1, 3, 3, 4, 6, 6, 8, 8 ], "expectedInfo": 0