From e62a7ca88c9b8d7b13d2c1bed4970db66aa3441a Mon Sep 17 00:00:00 2001 From: Hemang Chodhary Date: Fri, 16 May 2025 15:35:58 +0530 Subject: [PATCH] feat/dgttrf --- .../lapack/base/dgttrf/benchmark/benchmark.js | 67 ++++++ .../@stdlib/lapack/base/dgttrf/docs/repl.txt | 36 +++ .../lapack/base/dgttrf/docs/types/index.d.ts | 56 +++++ .../lapack/base/dgttrf/docs/types/test.ts | 52 ++++ .../lapack/base/dgttrf/examples/index.js | 28 +++ .../@stdlib/lapack/base/dgttrf/lib/index.js | 42 ++++ .../@stdlib/lapack/base/dgttrf/lib/main.js | 227 ++++++++++++++++++ .../@stdlib/lapack/base/dgttrf/package.json | 67 ++++++ .../base/dgttrf/test/dgttrf_reference.py | 43 ++++ .../test/fixtures/3x3_positive_values.json | 24 ++ .../fixtures/3x3_with_negative_values.json | 24 ++ .../dgttrf/test/fixtures/3x3_with_zeros.json | 24 ++ .../test/fixtures/4x4_random_values.json | 29 +++ .../dgttrf/test/fixtures/5x5_all_ones.json | 34 +++ .../test/fixtures/5x5_alternating_sign.json | 34 +++ .../test/fixtures/5x5_nearly_singular.json | 34 +++ .../test/fixtures/5x5_repeated_values.json | 34 +++ .../test/fixtures/5x5_very_large_values.json | 34 +++ .../test/fixtures/5x5_very_small_values.json | 34 +++ .../dgttrf/test/fixtures/singular_matrix.json | 24 ++ .../lapack/base/dgttrf/test/test.dgttrf.js | 154 ++++++++++++ .../@stdlib/lapack/base/dgttrf/test/test.js | 181 ++++++++++++++ 22 files changed, 1282 insertions(+) create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/benchmark/benchmark.js create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt 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/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/package.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/dgttrf_reference.py create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/3x3_positive_values.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/3x3_with_negative_values.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/3x3_with_zeros.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/4x4_random_values.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_all_ones.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_alternating_sign.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_nearly_singular.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_repeated_values.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_very_large_values.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_very_small_values.json create mode 100644 lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/singular_matrix.json 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 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..919d1b1ba649 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/benchmark/benchmark.js @@ -0,0 +1,67 @@ +/** +* @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 bench = require( '@stdlib/bench' ); +var pkg = require( './../package.json' ).name; +var dgttrf = require( './../lib' ); + + +// MAIN // + +bench( pkg, function benchmark( b ) { + var out; + var du; + var dl; + var d; + var n; + var i; + + n = 1000; + + dl = []; + d = []; + du = []; + + // Fill diagonals with some values: + for ( i = 0; i < n - 1; i++ ) { + dl.push( 2.0 ); + du.push( 1.0 ); + } + for ( i = 0; i < n; i++ ) { + d.push( 4.0 ); + } + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + // Use fresh copies to avoid in-place modification issues: + out = dgttrf( dl.slice(), d.slice(), du.slice() ); + if ( typeof out !== 'object' || out === null ) { + b.fail( 'should return an object' ); + } + } + b.toc(); + if ( typeof out !== 'object' || out === null ) { + b.fail( 'should return an object' ); + } + b.pass( 'benchmark finished' ); + b.end(); +} ); 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..561f41a055c2 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/repl.txt @@ -0,0 +1,36 @@ +{{alias}}( dl, d, du ) + Computes the LU factorization of a real tridiagonal matrix using + partial pivoting. + + Parameters + ---------- + dl: Array + Sub-diagonal (length n-1). + d: Array + Main diagonal (length n). + du: Array + Super-diagonal (length n-1). + + Returns + ------- + out: Object + Factorization result with fields: + - dl: Array, modified sub-diagonal (L multipliers). + - d: Array, modified main diagonal (U diagonal). + - du: Array, modified super-diagonal (U first super-diagonal). + - du2: Array, second super-diagonal (used for pivoting). + - ipiv: Array, pivot indices. + - info: Integer, 0 if successful, or the (1-based) index of + the first zero or NaN pivot. + + Examples + -------- + > var dgttrf = require( '@stdlib/lapack/base/dgttrf' ); + > var dl = [2.0, 3.0]; + > var d = [4.0, 5.0, 6.0]; + > var du = [1.0, 2.0]; + > var out = dgttrf(dl, d, du); + > out; + + 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 new file mode 100644 index 000000000000..f0ece35c47b6 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts @@ -0,0 +1,56 @@ +/* +* @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. +*/ + +// TypeScript Version: 4.1 + +/** +* LU factorization result object. +*/ +interface DgttrfResult { + dl: Array | Float64Array; + d: Array | Float64Array; + du: Array | Float64Array; + du2: Array | Float64Array; + ipiv: Array | Int32Array; + info: number; +} + +/** +* Performs LU factorization of a real tridiagonal matrix A of order n. +* +* @param dl - sub-diagonal array of length n-1 (will be overwritten with multipliers) +* @param d - main diagonal array of length n (will be overwritten with U diagonal) +* @param du - super-diagonal array of length n-1 (will be overwritten with U first super-diagonal) +* @returns factorization result +* +* @example +* var dl = [2.0, 3.0]; +* var d = [4.0, 5.0, 6.0]; +* var du = [1.0, 2.0]; +* var out = dgttrf(dl, d, du); +* // returns { dl: [...], d: [...], du: [...], du2: [...], ipiv: [...], info: 0 } +*/ +declare function dgttrf( + dl: Array | Float64Array, + d: Array | Float64Array, + du: Array | Float64Array +): DgttrfResult; + +// 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..8c31635b613e --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/test.ts @@ -0,0 +1,52 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +import dgttrf = require('./index'); + +// TESTS // + +// The function returns a DgttrfResult object... +{ + const dl = [2.0, 3.0]; + const d = [4.0, 5.0, 6.0]; + const du = [1.0, 2.0]; + const out = dgttrf(dl, d, du); + // $ExpectType { dl: number[] | Float64Array; d: number[] | Float64Array; du: number[] | Float64Array; du2: number[] | Float64Array; ipiv: number[] | Int32Array; info: number; } +} + +// The compiler throws an error if the function is provided arguments of invalid types... +{ + // $ExpectError + dgttrf(1, [4.0, 5.0, 6.0], [1.0, 2.0]); + // $ExpectError + dgttrf([2.0, 3.0], 'foo', [1.0, 2.0]); + // $ExpectError + dgttrf([2.0, 3.0], [4.0, 5.0, 6.0], {}); +} + +// The compiler throws an error if the function is provided an unsupported number of arguments... +{ + // $ExpectError + dgttrf(); + // $ExpectError + dgttrf([2.0, 3.0]); + // $ExpectError + dgttrf([2.0, 3.0], [4.0, 5.0, 6.0]); + // $ExpectError + dgttrf([2.0, 3.0], [4.0, 5.0, 6.0], [1.0, 2.0], [0.0]); +} 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..bf6756ba55a7 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/examples/index.js @@ -0,0 +1,28 @@ +/** +* @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'; + +var dgttrf = require( './../lib' ); + +var dl = [2.0, 3.0]; +var d = [4.0, 5.0, 6.0]; +var du = [1.0, 2.0]; + +var out = dgttrf( dl, d, du ); +console.log( out ); 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..060dcf3b4e93 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/index.js @@ -0,0 +1,42 @@ +/** +* @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'; + +/** +* LU factorization of a real tridiagonal matrix (DGTTRF, LAPACK). +* +* @module @stdlib/lapack/base/dgttrf +* +* @example +* var dgttrf = require( '@stdlib/lapack/base/dgttrf' ); +* var dl = [2.0, 3.0]; +* var d = [4.0, 5.0, 6.0]; +* var du = [1.0, 2.0]; +* var out = dgttrf( dl, d, du ); +* // returns { dl: [...], d: [...], du: [...], du2: [...], ipiv: [...], info: 0 } +*/ + +// MODULES // + +var main = require( './main.js' ); + + +// EXPORTS // + +module.exports = main; 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..50cc0597706d --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/lib/main.js @@ -0,0 +1,227 @@ +/** +* @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'; + +var Float64Array = require( '@stdlib/array/float64' ); +var Int32Array = require( '@stdlib/array/int32' ); +var abs = require( '@stdlib/math/base/special/abs' ); + + +// MAIN // + +/** +* Performs LU factorization of a real tridiagonal matrix A of order n. +* A is represented by its three diagonals: dl (sub-diagonal), d (main), du (super-diagonal). +* This function computes the factorization A = L * U with partial pivoting. +* +* @param {Float64Array|number[]} dl - sub-diagonal array of length n-1 (will be overwritten with multipliers) +* @param {Float64Array|number[]} d - main diagonal array of length n (will be overwritten with U diagonal) +* @param {Float64Array|number[]} du - super-diagonal array of length n-1 (will be overwritten with U first super-diagonal) +* @throws {Error} If inputs are invalid. +* @returns {Object} result - An object with properties: dl, d, du, du2, ipiv, info +* +* @example +* var dl = [2.0, 3.0]; +* var d = [4.0, 5.0, 6.0]; +* var du = [1.0, 2.0]; +* var out = dgttrf(dl, d, du); +* // returns { 'dl': [...], 'd': [...], 'du': [...], 'du2': [...], 'ipiv': [...], 'info': 0 } +*/ +function dgttrf( dl, d, du ) { + var info = 0; + var ipiv; + var temp; + var fact; + var du2; + var n = d.length; + var i; + + if ( n < 1 ) { + throw new Error( 'Invalid input: matrix order n must be at least 1' ); + } + if ( dl.length !== n-1 || du.length !== n-1 ) { + throw new Error( 'Invalid input: dl and du must have lengths n-1' ); + } + du2 = (n > 2) ? new Float64Array( n-2 ) : new Float64Array(0); + ipiv = new Int32Array( n ); + + // Check for NaN in input arrays, set info to first NaN index (1-based) like LAPACK + for ( i = 0; i < dl.length; i++ ) { + if ( dl[i] !== dl[i] ) { + info = i+1; + break; + } + } + if ( info === 0 ) { + for (i = 0; i < d.length; i++) { + if ( d[i] !== d[i] ) { + info = i+1; + break; + } + } + } + if ( info === 0 ) { + for ( i = 0; i < du.length; i++ ) { + if ( du[i] !== du[i] ) { + info = i+1; + break; + } + } + } + if ( info !== 0 ) { + return { + 'dl': dl, + 'd': d, + 'du': du, + 'du2': du2, + 'ipiv': ipiv, + 'info': info + }; + } + + for ( i = 0; i < n; i++ ) { + ipiv[i] = i; + } + + if ( n === 1 ) { + if ( d[0] === 0.0 || d[0] !== d[0] ) { + info = 1; + } + return { + 'dl': dl, + 'd': d, + 'du': du, + 'du2': du2, + 'ipiv': ipiv, + 'info': info + }; + } + if ( n === 2 ) { + // Only one sub/super-diagonal + if ( abs(d[0]) >= abs(dl[0]) ) { + if ( d[0] === 0.0 || d[0] !== d[0] ) { + info = 1; + } + fact = dl[0] / d[0]; + dl[0] = fact; + d[1] -= fact * du[0]; + ipiv[0] = 0; + ipiv[1] = 1; + } else { + if ( dl[0] === 0.0 || dl[0] !== dl[0] ) { + info = 1; + } + fact = d[0] / dl[0]; + temp = d[0]; + d[0] = dl[0]; + dl[0] = fact; + temp = du[0]; + du[0] = d[1]; + d[1] = temp - (fact * d[1]); + ipiv[0] = 1; + ipiv[1] = 1; + } + if ( d[1] === 0.0 || d[1] !== d[1] ) { + if (info === 0) { + info = 2; + } + } + return { + 'dl': dl, + 'd': d, + 'du': du, + 'du2': du2, + 'ipiv': ipiv, + 'info': info + }; + } + // n >= 3 + for ( i = 0; i < n-2; i++ ) { + if ( abs( d[i] ) >= abs( dl[i] ) ) { + if ( d[i] === 0.0 || d[i] !== d[i] ) { + if ( info === 0 ) { + info = i+1; + } + break; + } + fact = dl[i] / d[i]; + dl[i] = fact; + d[i+1] -= (fact * du[i]); + du2[i] = 0.0; + } else if ( dl[i] === 0.0 || dl[i] !== dl[i] ) { + if ( info === 0 ) { + info = i+1; + } + break; + } else { + fact = d[i] / dl[i]; + temp = d[i]; + d[i] = dl[i]; + dl[i] = fact; + temp = du[i]; + du[i] = d[i+1]; + d[i+1] = temp - (fact * d[i+1]); + du2[i] = du[i+1]; + du[i+1] = -(fact * du[i+1]); + ipiv[i] = i+1; + } + } + // Last 2 rows + i = n-2; + if ( info === 0 ) { + if ( abs( d[i] ) >= abs( dl[i] ) ) { + if ( d[i] === 0.0 || d[i] !== d[i] ) { + info = i+1; + } else { + fact = dl[i] / d[i]; + dl[i] = fact; + d[i+1] -= (fact * du[i]); + } + } else if ( dl[i] === 0.0 || dl[i] !== dl[i] ) { + info = i+1; + } else { + fact = d[i] / dl[i]; + temp = d[i]; + d[i] = dl[i]; + dl[i] = fact; + temp = du[i]; + du[i] = d[i+1]; + d[i+1] = temp - (fact * d[i+1]); + ipiv[i] = i+1; + } + if ( d[n-1] === 0.0 || d[n-1] !== d[n-1] ) { + if ( info === 0 ) { + info = n; + } + } + } + return { + 'dl': dl, + 'd': d, + 'du': du, + 'du2': du2, + 'ipiv': ipiv, + 'info': info + }; +} + + +// EXPORTS // + +module.exports = dgttrf; 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..ab9dffaa7c97 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/package.json @@ -0,0 +1,67 @@ +{ + "name": "@stdlib/lapack/base/dgttrf", + "version": "0.0.0", + "description": "LU factorization of a real tridiagonal matrix (DGTTRF routine).", + "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", + "lu", + "factorization", + "linear", + "algebra", + "subroutines", + "float64", + "double", + "tridiagonal" + ] + } diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/dgttrf_reference.py b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/dgttrf_reference.py new file mode 100644 index 000000000000..e4c78e288656 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/dgttrf_reference.py @@ -0,0 +1,43 @@ +import numpy as np +from scipy.linalg.lapack import dgttrf +import json +import os + +def write_fixture(name, dl, d, du): + dl = np.array(dl, dtype=np.float64) + d = np.array(d, dtype=np.float64) + du = np.array(du, dtype=np.float64) + (dl_out, d_out, du_out, du2_out, ipiv, info) = dgttrf(dl.copy(), d.copy(), du.copy()) + output = { + 'dl': dl_out.tolist(), + 'd': d_out.tolist(), + 'du': du_out.tolist(), + 'du2': du2_out.tolist(), + 'ipiv': ipiv.tolist(), + 'info': int(info) + } + fixtures_dir = os.path.join(os.path.dirname(__file__), 'fixtures') + os.makedirs(fixtures_dir, exist_ok=True) + fname = name.replace(' ', '_').lower() + '.json' + with open(os.path.join(fixtures_dir, fname), 'w') as f: + json.dump(output, f, indent=2) + +TEST_CASES = [ + ('3x3 positive values', [2.0, 3.0], [4.0, 5.0, 6.0], [1.0, 2.0]), + ('3x3 with zeros', [0.0, 0.0], [1.0, 0.0, 1.0], [0.0, 0.0]), + ('3x3 with negative values', [-1.0, -2.0], [-3.0, 4.0, -5.0], [-6.0, 7.0]), + ('4x4 random values', [0.5, -1.2, 3.3], [2.1, 0.0, -4.5, 5.5], [1.1, 2.2, -3.3]), + ('Singular matrix', [1.0, 1.0], [0.0, 0.0, 0.0], [1.0, 1.0]), + ('5x5 all ones', [1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1]), + ('5x5 alternating sign', [1, -1, 1, -1], [-1, 1, -1, 1, -1], [-1, 1, -1, 1]), + ('5x5 very large values', [1e10, 1e10, 1e10, 1e10], [1e10, 1e10, 1e10, 1e10, 1e10], [1e10, 1e10, 1e10, 1e10]), + ('5x5 very small values', [1e-10, 1e-10, 1e-10, 1e-10], [1e-10, 1e-10, 1e-10, 1e-10, 1e-10], [1e-10, 1e-10, 1e-10, 1e-10]), + ('5x5 repeated values', [2, 2, 2, 2], [3, 3, 3, 3, 3], [4, 4, 4, 4]), + ('5x5 nearly singular', [1e-12, 1e-12, 1e-12, 1e-12], [1e-12, 1e-12, 1e-12, 1e-12, 1e-12], [1e-12, 1e-12, 1e-12, 1e-12]), +] + +if __name__ == '__main__': + for name, dl, d, du in TEST_CASES: + write_fixture(name, dl, d, du) + print('Fixtures generated.') + diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/3x3_positive_values.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/3x3_positive_values.json new file mode 100644 index 000000000000..8df0df81d859 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/3x3_positive_values.json @@ -0,0 +1,24 @@ +{ + "dl": [ + 0.5, + 0.6666666666666666 + ], + "d": [ + 4.0, + 4.5, + 4.666666666666667 + ], + "du": [ + 1.0, + 2.0 + ], + "du2": [ + 0.0 + ], + "ipiv": [ + 1, + 2, + 3 + ], + "info": 0 +} \ No newline at end of file diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/3x3_with_negative_values.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/3x3_with_negative_values.json new file mode 100644 index 000000000000..4cd71a404d43 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/3x3_with_negative_values.json @@ -0,0 +1,24 @@ +{ + "dl": [ + 0.3333333333333333, + -0.3333333333333333 + ], + "d": [ + -3.0, + 6.0, + -2.666666666666667 + ], + "du": [ + -6.0, + 7.0 + ], + "du2": [ + 0.0 + ], + "ipiv": [ + 1, + 2, + 3 + ], + "info": 0 +} \ No newline at end of file diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/3x3_with_zeros.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/3x3_with_zeros.json new file mode 100644 index 000000000000..e169ffca6a08 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/3x3_with_zeros.json @@ -0,0 +1,24 @@ +{ + "dl": [ + 0.0, + 0.0 + ], + "d": [ + 1.0, + 0.0, + 1.0 + ], + "du": [ + 0.0, + 0.0 + ], + "du2": [ + 0.0 + ], + "ipiv": [ + 1, + 2, + 3 + ], + "info": 2 +} \ No newline at end of file diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/4x4_random_values.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/4x4_random_values.json new file mode 100644 index 000000000000..5c98cb6f4584 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/4x4_random_values.json @@ -0,0 +1,29 @@ +{ + "dl": [ + 0.23809523809523808, + 0.21825396825396828, + 0.9642857142857144 + ], + "d": [ + 2.1, + -1.2, + 3.3, + -4.583333333333334 + ], + "du": [ + 1.1, + -4.5, + 5.5 + ], + "du2": [ + 0.0, + -3.3 + ], + "ipiv": [ + 1, + 3, + 4, + 4 + ], + "info": 0 +} \ No newline at end of file diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_all_ones.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_all_ones.json new file mode 100644 index 000000000000..3083d4af0491 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_all_ones.json @@ -0,0 +1,34 @@ +{ + "dl": [ + 1.0, + 0.0, + 1.0, + 1.0 + ], + "d": [ + 1.0, + 1.0, + 1.0, + 1.0, + 0.0 + ], + "du": [ + 1.0, + 1.0, + -0.0, + 1.0 + ], + "du2": [ + 0.0, + 1.0, + 0.0 + ], + "ipiv": [ + 1, + 3, + 3, + 4, + 5 + ], + "info": 5 +} \ No newline at end of file diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_alternating_sign.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_alternating_sign.json new file mode 100644 index 000000000000..3b3b6943865b --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_alternating_sign.json @@ -0,0 +1,34 @@ +{ + "dl": [ + -1.0, + -0.0, + 1.0, + -1.0 + ], + "d": [ + -1.0, + -1.0, + 1.0, + 1.0, + 0.0 + ], + "du": [ + -1.0, + -1.0, + -0.0, + 1.0 + ], + "du2": [ + 0.0, + -1.0, + 0.0 + ], + "ipiv": [ + 1, + 3, + 3, + 4, + 5 + ], + "info": 5 +} \ No newline at end of file diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_nearly_singular.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_nearly_singular.json new file mode 100644 index 000000000000..5c1ef451d6bc --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_nearly_singular.json @@ -0,0 +1,34 @@ +{ + "dl": [ + 1.0, + 0.0, + 1.0, + 1.0 + ], + "d": [ + 1e-12, + 1e-12, + 1e-12, + 1e-12, + 0.0 + ], + "du": [ + 1e-12, + 1e-12, + -0.0, + 1e-12 + ], + "du2": [ + 0.0, + 1e-12, + 0.0 + ], + "ipiv": [ + 1, + 3, + 3, + 4, + 5 + ], + "info": 5 +} \ No newline at end of file diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_repeated_values.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_repeated_values.json new file mode 100644 index 000000000000..f6abae23cb47 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_repeated_values.json @@ -0,0 +1,34 @@ +{ + "dl": [ + 0.6666666666666666, + 0.16666666666666674, + 0.5714285714285714, + 0.5915492957746479 + ], + "d": [ + 3.0, + 2.0, + 3.5, + 3.380952380952381, + 0.6338028169014085 + ], + "du": [ + 4.0, + 3.0, + -0.666666666666667, + 4.0 + ], + "du2": [ + 0.0, + 4.0, + 0.0 + ], + "ipiv": [ + 1, + 3, + 3, + 4, + 5 + ], + "info": 0 +} \ No newline at end of file diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_very_large_values.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_very_large_values.json new file mode 100644 index 000000000000..33c4d593b2d6 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_very_large_values.json @@ -0,0 +1,34 @@ +{ + "dl": [ + 1.0, + 0.0, + 1.0, + 1.0 + ], + "d": [ + 10000000000.0, + 10000000000.0, + 10000000000.0, + 10000000000.0, + 0.0 + ], + "du": [ + 10000000000.0, + 10000000000.0, + -0.0, + 10000000000.0 + ], + "du2": [ + 0.0, + 10000000000.0, + 0.0 + ], + "ipiv": [ + 1, + 3, + 3, + 4, + 5 + ], + "info": 5 +} \ No newline at end of file diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_very_small_values.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_very_small_values.json new file mode 100644 index 000000000000..339e157c105e --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/5x5_very_small_values.json @@ -0,0 +1,34 @@ +{ + "dl": [ + 1.0, + 0.0, + 1.0, + 1.0 + ], + "d": [ + 1e-10, + 1e-10, + 1e-10, + 1e-10, + 0.0 + ], + "du": [ + 1e-10, + 1e-10, + -0.0, + 1e-10 + ], + "du2": [ + 0.0, + 1e-10, + 0.0 + ], + "ipiv": [ + 1, + 3, + 3, + 4, + 5 + ], + "info": 5 +} \ No newline at end of file diff --git a/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/singular_matrix.json b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/singular_matrix.json new file mode 100644 index 000000000000..40d6843988b5 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/fixtures/singular_matrix.json @@ -0,0 +1,24 @@ +{ + "dl": [ + 0.0, + 1.0 + ], + "d": [ + 1.0, + 1.0, + 0.0 + ], + "du": [ + 0.0, + -0.0 + ], + "du2": [ + 1.0 + ], + "ipiv": [ + 2, + 2, + 3 + ], + "info": 3 +} \ No newline at end of file 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..e1c92f360041 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.dgttrf.js @@ -0,0 +1,154 @@ +const tape = require( 'tape' ); +const dgttrf = require( '@stdlib/lapack/base/dgttrf/lib/main.js' ); +const fs = require( 'fs' ); +const path = require( 'path' ); + + +tape( 'main export is a function', function test( t ) { + t.equal( typeof dgttrf, 'function', 'main export is a function' ); + t.end(); +} ); + +function arraysAlmostEqual( t, a, b, tol, msg ) { + tol = tol === undefined ? 1e-10 : tol; + msg = msg || ''; + const abs = require( '@stdlib/math/base/special/abs' ); + t.equal( a.length, b.length, msg + ' (length)' ); + for ( let i = 0; i < a.length; i++ ) { + // Handle NaN comparison: treat NaN as equal to NaN for fixture robustness + if ( Number.isNaN( a[i] ) && Number.isNaN( b[i] ) ) { + t.ok( true, `${msg} (index ${i}): both NaN` ); + } else { + t.ok( abs( a[i] - b[i] ) < tol, `${msg} (index ${i}): ${a[i]} vs ${b[i]}` ); + } + } +} + +const testCases = [ + { + name: '3x3 positive values', + dl: [ 2.0, 3.0 ], + d: [ 4.0, 5.0, 6.0 ], + du: [ 1.0, 2.0 ] + }, + { + name: '3x3 with zeros', + dl: [ 0.0, 0.0 ], + d: [ 1.0, 0.0, 1.0 ], + du: [ 0.0, 0.0 ] + }, + { + name: '3x3 with negative values', + dl: [ -1.0, -2.0 ], + d: [ -3.0, 4.0, -5.0 ], + du: [ -6.0, 7.0 ] + }, + { + name: '4x4 random values', + dl: [ 0.5, -1.2, 3.3 ], + d: [ 2.1, 0.0, -4.5, 5.5 ], + du: [ 1.1, 2.2, -3.3 ] + }, + { + name: 'Singular matrix', + dl: [ 1.0, 1.0 ], + d: [ 0.0, 0.0, 0.0 ], + du: [ 1.0, 1.0 ] + }, + { + name: '5x5 all ones', + dl: [ 1, 1, 1, 1 ], + d: [ 1, 1, 1, 1, 1 ], + du: [ 1, 1, 1, 1 ] + }, + { + name: '5x5 alternating sign', + dl: [ 1, -1, 1, -1 ], + d: [ -1, 1, -1, 1, -1 ], + du: [ -1, 1, -1, 1 ] + }, + { + name: '5x5 very large values', + dl: [ 1e10, 1e10, 1e10, 1e10 ], + d: [ 1e10, 1e10, 1e10, 1e10, 1e10 ], + du: [ 1e10, 1e10, 1e10, 1e10 ] + }, + { + name: '5x5 very small values', + dl: [ 1e-10, 1e-10, 1e-10, 1e-10 ], + d: [ 1e-10, 1e-10, 1e-10, 1e-10, 1e-10 ], + du: [ 1e-10, 1e-10, 1e-10, 1e-10 ] + }, + { + name: '5x5 repeated values', + dl: [ 2, 2, 2, 2 ], + d: [ 3, 3, 3, 3, 3 ], + du: [ 4, 4, 4, 4 ] + }, + { + name: '5x5 nearly singular', + dl: [ 1e-12, 1e-12, 1e-12, 1e-12 ], + d: [ 1e-12, 1e-12, 1e-12, 1e-12, 1e-12 ], + du: [ 1e-12, 1e-12, 1e-12, 1e-12 ] + } +]; + +testCases.forEach( function runTest( testCase ) { + tape( `dgttrf: JS vs Python LAPACK: ${testCase.name}`, function dgttrfTest( t ) { + // Read fixture + var fixtureName = testCase.name.replace( /\s+/g, '_' ).toLowerCase() + '.json'; + var fixturePath = path.join( __dirname, 'fixtures', fixtureName ); + var pyOut; + try { + pyOut = JSON.parse( fs.readFileSync( fixturePath, 'utf8' ) ); + } catch ( err ) { + t.fail( `Missing or invalid fixture: ${fixturePath}` ); + t.end(); + return; + } + var jsOut; + var jsError; + try { + jsOut = dgttrf( [].concat( testCase.dl ), [].concat( testCase.d ), [].concat( testCase.du ) ); + } catch ( err ) { + jsError = err; + } + // Remove flag functionality: always print on failure only + var failedPin = null; + try { + t.notOk( jsError, `JS should not throw: ${jsError && jsError.message}` ); + try { arraysAlmostEqual( t, jsOut.dl, pyOut.dl, 1e-10, 'dl' ); } catch ( e ) { failedPin = 'dl'; throw e; } + try { arraysAlmostEqual( t, jsOut.d, pyOut.d, 1e-10, 'd' ); } catch ( e ) { failedPin = 'd'; throw e; } + try { arraysAlmostEqual( t, jsOut.du, pyOut.du, 1e-10, 'du' ); } catch ( e ) { failedPin = 'du'; throw e; } + try { arraysAlmostEqual( t, jsOut.du2, pyOut.du2, 1e-10, 'du2' ); } catch ( e ) { failedPin = 'du2'; throw e; } + try { + // Replace Array.from for compatibility: + var jsIpiv = []; + for ( var i = 0; i < jsOut.ipiv.length; i++ ) { + jsIpiv.push( jsOut.ipiv[ i ] ); + } + var pyIpiv0 = []; + for ( var j = 0; j < pyOut.ipiv.length; j++ ) { + pyIpiv0.push( pyOut.ipiv[ j ] - 1 ); + } + t.deepEqual( jsIpiv, pyIpiv0, 'ipiv' ); + } catch ( e ) { failedPin = 'ipiv'; throw e; } + try { + t.equal( jsOut.info === undefined ? 0 : jsOut.info, pyOut.info, 'info' ); + } catch ( e ) { failedPin = 'info'; throw e; } + } catch ( e ) { + console.log( `\n[DEBUG FAIL] Test case: ${testCase.name}` ); + if ( failedPin ) { + console.log( `Failed at pin: ${failedPin}` ); + if ( !jsError ) { + console.log( 'Python:', JSON.stringify( pyOut[ failedPin ], null, 2 ) ); + console.log( 'JS:', JSON.stringify( jsOut[ failedPin ], null, 2 ) ); + } + } else { + console.log( 'General failure:', e.message ); + } + t.fail( e.message ); + } + 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..9ec77b5177e0 --- /dev/null +++ b/lib/node_modules/@stdlib/lapack/base/dgttrf/test/test.js @@ -0,0 +1,181 @@ +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var Float64Array = require( '@stdlib/array/float64' ); +var dgttrf = require( './../lib/main.js' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.equal( typeof dgttrf, 'function', 'main export is a function' ); + t.end(); +} ); + +tape( 'dgttrf: LU factorization of tridiagonal matrix', function testLU( t ) { + var out; + var du; + var dl; + var d; + + dl = new Float64Array( [ 2.0, 3.0 ] ); + d = new Float64Array( [ 4.0, 5.0, 6.0 ] ); + du = new Float64Array( [ 1.0, 2.0 ] ); + out = dgttrf( dl, d, du ); + + t.ok( out, 'returns an object' ); + t.equal( out.dl.length, 2, 'dl length' ); + t.equal( out.d.length, 3, 'd length' ); + t.equal( out.du.length, 2, 'du length' ); + t.equal( out.du2.length, 1, 'du2 length' ); + t.equal( out.ipiv.length, 3, 'ipiv length' ); + t.end(); +} ); + +tape( 'dgttrf: 2x2 matrix, no pivoting', function test2x2NoPivot( t ) { + var out; + var arr; + var du; + var dl; + var d; + + dl = new Float64Array( [ 3.0 ] ); + d = new Float64Array( [ 2.0, 4.0 ] ); + du = new Float64Array( [ 1.0 ] ); + out = dgttrf( dl, d, du ); + arr = function arr( x ) { + var outArr = []; + var i; + for ( i = 0; i < x.length; i++ ) { + outArr.push( x[ i ] ); + } + return outArr; + }; + + t.deepEqual( arr( out.dl ), [ 0.6666666666666666 ], 'dl (L multipliers, LAPACK)' ); + t.deepEqual( arr( out.d ), [ 3.0, -1.6666666666666665 ], 'd (U diagonal, LAPACK)' ); + t.deepEqual( arr( out.du ), [ 4.0 ], 'du (U super-diagonal, LAPACK)' ); + t.deepEqual( arr( out.du2 ), [], 'du2 (second super-diagonal)' ); + t.deepEqual( arr( out.ipiv ), [ 1, 1 ], 'ipiv (pivot indices, LAPACK)' ); + t.end(); +} ); + +tape( 'dgttrf: 2x2 matrix, with pivoting', function test2x2Pivot( t ) { + var out; + var arr; + var du; + var dl; + var d; + + dl = new Float64Array( [ 3.0 ] ); + d = new Float64Array( [ 1.0, 4.0 ] ); + du = new Float64Array( [ 2.0 ] ); + out = dgttrf( dl, d, du ); + arr = function arr( x ) { + var outArr = []; + var i; + for ( i = 0; i < x.length; i++ ) { + outArr.push( x[ i ] ); + } + return outArr; + }; + + t.deepEqual( arr( out.dl ), [ 0.3333333333333333 ], 'dl (L multipliers, LAPACK)' ); + t.deepEqual( arr( out.d ), [ 3.0, 0.6666666666666667 ], 'd (U diagonal, LAPACK)' ); + t.deepEqual( arr( out.du ), [ 4.0 ], 'du (U super-diagonal, LAPACK)' ); + t.deepEqual( arr( out.du2 ), [], 'du2 (second super-diagonal)' ); + t.deepEqual( arr( out.ipiv ), [ 1, 1 ], 'ipiv (pivot indices, LAPACK)' ); + t.end(); +} ); + +tape( 'dgttrf: 1x1 matrix', function test1x1( t ) { + var out; + var arr; + var du; + var dl; + var d; + + dl = new Float64Array( [] ); + d = new Float64Array( [ 5.0 ] ); + du = new Float64Array( [] ); + out = dgttrf( dl, d, du ); + arr = function arr( x ) { + var outArr = []; + var i; + for ( i = 0; i < x.length; i++ ) { + outArr.push( x[ i ] ); + } + return outArr; + }; + + t.deepEqual( arr( out.dl ), [], 'dl (L multipliers)' ); + t.deepEqual( arr( out.d ), [ 5.0 ], 'd (U diagonal)' ); + t.deepEqual( arr( out.du ), [], 'du (U super-diagonal)' ); + t.deepEqual( arr( out.du2 ), [], 'du2 (second super-diagonal)' ); + t.deepEqual( arr( out.ipiv ), [ 0 ], 'ipiv (pivot indices)' ); + t.equal( out.info, 0, 'info should be 0 for nonsingular 1x1' ); + t.end(); +} ); + +tape( 'dgttrf: throws on invalid input sizes', function testInvalidInput( t ) { + var du; + var dl; + var d; + + dl = new Float64Array( [ 1.0, 2.0 ] ); + d = new Float64Array( [ 1.0, 2.0 ] ); + du = new Float64Array( [ 1.0 ] ); + + t.throws( function throwsFn() { + dgttrf( dl, d, du ); + }, /lengths n-1/, 'throws on invalid input sizes' ); + t.end(); +} ); + +tape( 'dgttrf: returns info > 0 on singular matrix', function testSingular( t ) { + var out; + var du; + var dl; + var d; + + dl = new Float64Array( [ 0.0, 0.0 ] ); + d = new Float64Array( [ 0.0, 0.0, 0.0 ] ); + du = new Float64Array( [ 0.0, 0.0 ] ); + out = dgttrf( dl, d, du ); + + t.ok( out.info > 0, 'info > 0 for singular matrix' ); + t.end(); +} ); + +tape( 'dgttrf: returns info > 0 on NaN in input', function testNaNInput( t ) { + var out; + var du; + var dl; + var d; + + dl = new Float64Array( [ NaN, 2.0 ] ); + d = new Float64Array( [ 1.0, NaN, 3.0 ] ); + du = new Float64Array( [ 2.0, NaN ] ); + out = dgttrf( dl, d, du ); + + t.ok( out.info > 0, 'info > 0 for NaN in input' ); + t.end(); +} ); + +tape( 'dgttrf: returns info > 0 on NaN in sub/super-diagonal', function testNaNDiag( t ) { + var out; + var du; + var dl; + var d; + + dl = new Float64Array( [ 1.0, NaN ] ); + d = new Float64Array( [ 2.0, 3.0, 4.0 ] ); + du = new Float64Array( [ NaN, 1.0 ] ); + out = dgttrf( dl, d, du ); + + t.ok( out.info > 0, 'info > 0 for NaN in sub/super-diagonal' ); + t.end(); +} );