docs: update 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: passed
  - 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: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---

Author: aayush0325

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.
 
 <section class="usage">
 
@@ -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' );
@@ -46,19 +46,19 @@ var IPIV = new Int32Array( 3 );
 
 dgttrf( 3, DL, D, DU, DU2, IPIV );
 // DL => <Float64Array>[ 0.5, 0.4 ]
-// D => <Float64Array>[ 2, 2.5, 0.6 ]
-// DU => <Float64Array>[ 1, 1 ]
-// DU2 => <Float64Array>[ 0 ]
+// D => <Float64Array>[ 2.0, 2.5, 0.6 ]
+// DU => <Float64Array>[ 1.0, 1.0 ]
+// DU2 => <Float64Array>[ 0.0 ]
 // IPIV => <Int32Array>[ 0, 1, 2 ]
 ```
 
 The function has the following parameters:
 
 -   **N**: order of matrix `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].
+-   **DL**: the sub diagonal elements of `A` as a [`Float64Array`][mdn-float64array]. 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]. 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]. DU is overwritten by the elements of the first super-diagonal of `U`.
+-   **DU2**: 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.
@@ -84,18 +84,18 @@ var DU2 = new Float64Array( DU20.buffer, DU20.BYTES_PER_ELEMENT*1 ); // start at
 var IPIV = new Int32Array( IPIV0.buffer, IPIV0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
 
 dgttrf( 3, DL, D, DU, DU2, IPIV );
-// DL0 => <Float64Array>[ 0, 0.5, 0.4 ]
-// D0 => <Float64Array>[ 0, 2, 2.5, 0.6 ]
-// DU0 => <Float64Array>[ 0, 1, 1 ]
-// DU20 => <Float64Array>[ 0, 0 ]
+// DL0 => <Float64Array>[ 0.0, 0.5, 0.4 ]
+// D0 => <Float64Array>[ 0.0, 2.0, 2.5, 0.6 ]
+// DU0 => <Float64Array>[ 0.0, 1.0, 1.0 ]
+// DU20 => <Float64Array>[ 0.0, 0.0 ]
 // IPIV0 => <Int32Array>[ 0, 0, 1, 2 ]
 ```
 
 <!-- lint disable maximum-heading-length -->
 
 #### 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' );
@@ -105,14 +105,14 @@ 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 );
+var DU2 = new Float64Array( [ 0.0 ] );
+var IPIV = new Int32Array( [ 0, 0, 0 ] );
 
 dgttrf.ndarray( 3, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0 );
 // DL => <Float64Array>[ 0.5, 0.4 ]
-// D => <Float64Array>[ 2, 2.5, 0.6 ]
-// DU => <Float64Array>[ 1, 1 ]
-// DU2 => <Float64Array>[ 0 ]
+// D => <Float64Array>[ 2.0, 2.5, 0.6 ]
+// DU => <Float64Array>[ 1.0, 1.0 ]
+// DU2 => <Float64Array>[ 0.0 ]
 // IPIV => <Int32Array>[ 0, 1, 2 ]
 ```
 
@@ -140,8 +140,8 @@ var Int32Array = require( '@stdlib/array/int32' );
 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 );
+var DU2 = new Float64Array( [ 0.0, 0.0 ] );
+var IPIV = new Int32Array( [ 0, 0, 0, 0 ] );
 
 dgttrf.ndarray( 3, DL, 1, 1, D, 1, 1, DU, 1, 1, DU2, 1, 1, IPIV, 1, 1 );
 // DL => <Float64Array>[ 0.0, 0.5, 0.4 ]
@@ -159,12 +159,11 @@ dgttrf.ndarray( 3, DL, 1, 1, D, 1, 1, DU, 1, 1, DU2, 1, 1, IPIV, 1, 1 );
 
 ## Notes
 
--   Both functions mutate the input arrays `DL`, `D`, `DU`, `DU2` and `IPIV`.
+-   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].

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
@@ -14,21 +14,19 @@
         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.
+        Sub diagonal elements of A. 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.
+        Diagonal elements of A. 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.
+        Super diagonal elements of A. 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.
+        DU2 is overwritten by the elements of the second super-diagonal of U.
 
     IPIV: Int32Array
         Array of pivot indices.
@@ -39,8 +37,6 @@
         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,
@@ -92,7 +88,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.
 
@@ -108,8 +104,8 @@
         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.
+        Sub diagonal elements of A. DL is overwritten by the multipliers that
+        define the matrix L from the LU factorization of A.
 
     sdl: integer
         Stride length for `DL`.
@@ -118,9 +114,8 @@
         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.
+        Diagonal elements of A. 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`.
@@ -129,8 +124,8 @@
         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.
+        Super diagonal elements of A. DU is overwritten by the elements of the
+        first super-diagonal of U.
 
     sdu: integer
         Stride length for `DU`.
@@ -139,8 +134,7 @@
         Starting index for `DU2`.
 
     DU2: Float64Array
-        On exit, DU2 is overwritten by the elements of the second
-        super-diagonal of U.
+        DU2 is overwritten by the elements of the second super-diagonal of U.
 
     sdu2: integer
         Stride length for `DU2`.
@@ -163,8 +157,6 @@
         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,

lib/node_modules/@stdlib/lapack/base/dgttrf/docs/types/index.d.ts

@@ -26,7 +26,6 @@
 * 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 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;
@@ -36,15 +35,15 @@ 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
 	*
-	* -   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.
+	* -   `DL` is overwritten by the multipliers that define the matrix `L` from the `LU` factorization of `A`.
+	* -   `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the `LU` factorization of `A`.
+	* -   `DU` is overwritten by the elements of the first super-diagonal of `U`.
+	* -   `DU2` is overwritten by the elements of the second super-diagonal of `U`.
+	* -   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`
@@ -74,32 +73,32 @@ 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
 	*
-	* -   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.
+	* -   `DL` is overwritten by the multipliers that define the matrix `L` from the `LU` factorization of `A`.
+	* -   `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the `LU` factorization of `A`.
+	* -   `DU` is overwritten by the elements of the first super-diagonal of `U`.
+	* -   `DU2` is overwritten by the elements of the second super-diagonal of `U`.
+	* -   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`
-	* @param sdl - stride length for `DL`
-	* @param odl - starting index of `DL`
+	* @param strideDL - stride length for `DL`
+	* @param offsetDL - starting index of `DL`
 	* @param D - diagonal elements of `A`
-	* @param sd - stride length for `D`
-	* @param od - starting index of `D`
+	* @param strideD - stride length for `D`
+	* @param offsetD - starting index of `D`
 	* @param DU - super diagonal elements of `A`
-	* @param sdu - stride length for `DU`
-	* @param odu - starting index of `DU`
+	* @param strideDU - stride length for `DU`
+	* @param offsetDU - starting index of `DU`
 	* @param DU2 - vector to store the second super diagonal of `U`
-	* @param sdu2 - stride length for `DU2`
-	* @param odu2 - starting index of `DU2`
+	* @param strideDU2 - stride length for `DU2`
+	* @param offsetDU2 - starting index of `DU2`
 	* @param IPIV - vector of pivot indices
-	* @param si - stride length for `IPIV`
-	* @param oi - starting index of `IPIV`
+	* @param strideIPIV - stride length for `IPIV`
+	* @param offsetIPIV - starting index of `IPIV`
 	* @returns status code
 	*
 	* @example
@@ -116,25 +115,25 @@ interface Routine {
 	* // DU2 => <Float64Array>[ 0 ]
 	* // IPIV => <Int32Array>[ 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;
+	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.
+* LAPACK routine to compute an `LU` factorization of a real tridiagonal 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.
+* -   `DL` is overwritten by the multipliers that define the matrix `L` from the `LU` factorization of `A`.
+* -   `D` is overwritten by the diagonal elements of the upper triangular matrix `U` from the `LU` factorization of `A`.
+* -   `DU` is overwritten by the elements of the first super-diagonal of `U`.
+* -   `DU2` is overwritten by the elements of the second super-diagonal of `U`.
+* -   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`
 * @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 DU2 - `DU2` is overwritten by the elements of the second super-diagonal of `U`
 * @param IPIV - vector of pivot indices
 * @returns status code
 *