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
---

Author: aayush0325

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.

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 @@
     <Float64Array>[ 0, 2, 2.5, 0.6 ]
     > DU0
     <Float64Array>[ 0, 1, 1 ]
-    > DU2
-    <Float64Array>[ 0 ]
-    > IPIV
-    <Int32Array>[ 0, 1, 2 ]
+    > DU20
+    <Float64Array>[ 0, 0 ]
+    > IPIV0
+    <Int32Array>[ 0, 0, 1, 2 ]
 
 
 {{alias}}.ndarray( N,DL,sdl,odl,D,sd,od,DU,sdu,odu,DU2,sdu2,odu2,IPIV,si,oi )

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
 *

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

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

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