chore: update docs and cleanup

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

Author: aayush0325

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

@@ -31,9 +31,9 @@ interface Routine {
 	*
 	* ## Notes
 	*
-	* -   To solve A * X = B (no transpose), use itrans = 0.
-	* -   To solve AT * X = B (transpose), use itrans = 1.
-	* -   To solve AT * X = B (conjugate transpose = transpose), use itrans = 2.
+	* -   To solve `A * X = B` (no transpose), use `itrans` = 0.
+	* -   To solve `AT * X = B` (transpose), use `itrans` = 1.
+	* -   To solve `AT * X = B` (conjugate transpose = transpose), use `itrans` = 2.
 	*
 	* @param order - storage layout of B
 	* @param itrans - specifies the form of the system of equations (0: no transpose, 1: transpose, 2: conjugate transpose)
@@ -69,9 +69,9 @@ interface Routine {
 	*
 	* ## Notes
 	*
-	* -   To solve A * X = B (no transpose), use itrans = 0.
-	* -   To solve AT * X = B (transpose), use itrans = 1.
-	* -   To solve AT * X = B (conjugate transpose = transpose), use itrans = 2.
+	* -   To solve `A * X = B` (no transpose), use `itrans` = 0.
+	* -   To solve `AT * X = B` (transpose), use `itrans` = 1.
+	* -   To solve `AT * X = B` (conjugate transpose = transpose), use `itrans` = 2.
 	*
 	* @param itrans - specifies the form of the system of equations
 	* @param N - order of the matrix A
@@ -119,9 +119,9 @@ interface Routine {
 *
 * ## Notes
 *
-* -   To solve A * X = B (no transpose), use itrans = 0.
-* -   To solve AT * X = B (transpose), use itrans = 1.
-* -   To solve AT * X = B (conjugate transpose = transpose), use itrans = 2.
+* -   To solve `A * X = B` (no transpose), use `itrans` = 0.
+* -   To solve `AT * X = B` (transpose), use `itrans` = 1.
+* -   To solve `AT * X = B` (conjugate transpose = transpose), use `itrans` = 2.
 *
 * @param order - storage layout of B
 * @param itrans - system equation form specification

lib/node_modules/@stdlib/lapack/base/dgtts2/lib/base.js

@@ -23,27 +23,27 @@
 // FUNCTIONS //
 
 /**
-* Solve AT * X = B using the LU factorization of A computed by `dgttrf`, overwriting B with the solution.
+* Solve `AT * X = B` using the LU factorization of A computed by `dgttrf`, overwriting B with the solution.
 *
 * @private
-* @param {NonNegativeInteger} N - order of the matrix A
-* @param {NonNegativeInteger} nrhs - number of right-hand sides, i.e., the number of columns of the matrix B
-* @param {Float64Array} DL - multipliers that define the matrix L
+* @param {NonNegativeInteger} N - order of the matrix `A`
+* @param {NonNegativeInteger} nrhs - number of right-hand sides, i.e., the number of columns of the matrix `B`
+* @param {Float64Array} DL - multipliers that define the matrix `L`
 * @param {integer} strideDL - stride length for DL
 * @param {NonNegativeInteger} offsetDL - starting index of DL
 * @param {Float64Array} D - N diagonal elements of the upper triangular matrix U
 * @param {integer} strideD - stride length for D
 * @param {NonNegativeInteger} offsetD - starting index of D
-* @param {Float64Array} DU - elements of the first super-diagonal of U
+* @param {Float64Array} DU - 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 - elements of the second super-diagonal of U
+* @param {Float64Array} DU2 - 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 - stride length for IPIV
 * @param {NonNegativeInteger} offsetIPIV - starting index for IPIV
-* @param {Float64Array} B - right-hand side matrix B, overwritten by the solution matrix X
+* @param {Float64Array} B - right-hand side matrix B, overwritten by the solution matrix `X`
 * @param {integer} strideB1 - stride of the first dimension of B
 * @param {integer} strideB2 - stride of the second dimension of B
 * @param {NonNegativeInteger} offsetB - starting index of B
@@ -165,27 +165,27 @@ function transpose( N, nrhs, DL, strideDL, offsetDL, D, strideD, offsetD, DU, st
 }
 
 /**
-* Solve A * X = B using the LU factorization of A computed by `dgttrf`, overwriting B with the solution.
+* Solve `A * X = B` using the LU factorization of A computed by `dgttrf`, overwriting B with the solution.
 *
 * @private
-* @param {NonNegativeInteger} N - order of the matrix A
-* @param {NonNegativeInteger} nrhs - number of right-hand sides, i.e., the number of columns of the matrix B
-* @param {Float64Array} DL - multipliers that define the matrix L
+* @param {NonNegativeInteger} N - order of the matrix `A`
+* @param {NonNegativeInteger} nrhs - number of right-hand sides, i.e., the number of columns of the matrix `B`
+* @param {Float64Array} DL - multipliers that define the matrix `L`
 * @param {integer} strideDL - stride length for DL
 * @param {NonNegativeInteger} offsetDL - starting index of DL
 * @param {Float64Array} D - N diagonal elements of the upper triangular matrix U
 * @param {integer} strideD - stride length for D
 * @param {NonNegativeInteger} offsetD - starting index of D
-* @param {Float64Array} DU - elements of the first super-diagonal of U
+* @param {Float64Array} DU - 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 - elements of the second super-diagonal of U
+* @param {Float64Array} DU2 - 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 - stride length for IPIV
 * @param {NonNegativeInteger} offsetIPIV - starting index for IPIV
-* @param {Float64Array} B - right-hand side matrix B, overwritten by the solution matrix X
+* @param {Float64Array} B - right-hand side matrix B, overwritten by the solution matrix `X`
 * @param {integer} strideB1 - stride of the first dimension of B
 * @param {integer} strideB2 - stride of the second dimension of B
 * @param {NonNegativeInteger} offsetB - starting index of B
@@ -312,29 +312,29 @@ function noTranspose( N, nrhs, DL, strideDL, offsetDL, D, strideD, offsetD, DU,
 *
 * ## Notes
 *
-* -   To solve A * X = B (no transpose), use itrans = 0.
-* -   To solve AT * X = B (transpose), use itrans = 1.
-* -   To solve AT * X = B (conjugate transpose = transpose), use itrans = 2.
+* -   To solve `A * X = B` (no transpose), use `itrans` = 0.
+* -   To solve `AT * X = B` (transpose), use `itrans` = 1.
+* -   To solve `AT * X = B` (conjugate transpose = transpose), use `itrans` = 2.
 *
 * @param {integer} itrans - specifies the form of the system of equations
-* @param {NonNegativeInteger} N - order of the matrix A
-* @param {NonNegativeInteger} nrhs - number of right-hand sides, i.e., the number of columns of the matrix B
-* @param {Float64Array} DL - multipliers that define the matrix L
+* @param {NonNegativeInteger} N - order of the matrix `A`
+* @param {NonNegativeInteger} nrhs - number of right-hand sides, i.e., the number of columns of the matrix `B`
+* @param {Float64Array} DL - multipliers that define the matrix `L`
 * @param {integer} strideDL - stride length for DL
 * @param {NonNegativeInteger} offsetDL - starting index of DL
 * @param {Float64Array} D - N diagonal elements of the upper triangular matrix U
 * @param {integer} strideD - stride length for D
 * @param {NonNegativeInteger} offsetD - starting index of D
-* @param {Float64Array} DU - elements of the first super-diagonal of U
+* @param {Float64Array} DU - 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 - elements of the second super-diagonal of U
+* @param {Float64Array} DU2 - 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 - stride length for IPIV
 * @param {NonNegativeInteger} offsetIPIV - starting index for IPIV
-* @param {Float64Array} B - right-hand side matrix B, overwritten by the solution matrix X
+* @param {Float64Array} B - right-hand side matrix B, overwritten by the solution matrix `X`
 * @param {integer} strideB1 - stride of the first dimension of B
 * @param {integer} strideB2 - stride of the second dimension of B
 * @param {NonNegativeInteger} offsetB - starting index of B
@@ -359,7 +359,7 @@ function dgtts2( itrans, N, nrhs, DL, strideDL, offsetDL, D, strideD, offsetD, D
 		return B;
 	}
 	if ( itrans === 0 ) {
-		// Solve A * X = B using the LU factorization of A, overwriting B with the solution
+		// Solve `A * X = B` using the LU factorization of A, overwriting B with the solution
 		return noTranspose( N, nrhs, DL, strideDL, offsetDL, D, strideD, offsetD, DU, strideDU, offsetDU, DU2, strideDU2, offsetDU2, IPIV, strideIPIV, offsetIPIV, B, strideB1, strideB2, offsetB );
 	}
 	// Solve Solve A**T * X = B using the LU factorization of A,  overwriting B with the solution.

lib/node_modules/@stdlib/lapack/base/dgtts2/lib/dgtts2.js

@@ -32,21 +32,21 @@ var base = require( './base.js' );
 *
 * ## Notes
 *
-* -   To solve A * X = B (no transpose), use itrans = 0.
-* -   To solve AT * X = B (transpose), use itrans = 1.
-* -   To solve AT * X = B (conjugate transpose = transpose), use itrans = 2.
+* -   To solve `A * X = B` (no transpose), use `itrans` = 0.
+* -   To solve `AT * X = B` (transpose), use `itrans` = 1.
+* -   To solve `AT * X = B` (conjugate transpose = transpose), use `itrans` = 2.
 *
-* @param {string} order - storage layout of B
+* @param {string} order - storage layout of `B`
 * @param {integer} itrans - specifies the form of the system of equations
-* @param {NonNegativeInteger} N - order of the matrix A
-* @param {NonNegativeInteger} nrhs - number of right-hand sides, i.e., the number of columns of the matrix B
-* @param {Float64Array} DL - multipliers that define the matrix L
-* @param {Float64Array} D - diagonal elements of the upper triangular matrix U
-* @param {Float64Array} DU - elements of the first super-diagonal of U
-* @param {Float64Array} DU2 - elements of the second super-diagonal of U
+* @param {NonNegativeInteger} N - order of the matrix `A`
+* @param {NonNegativeInteger} nrhs - number of right-hand sides, i.e., the number of columns of the matrix `B`
+* @param {Float64Array} DL - multipliers that define the matrix `L`
+* @param {Float64Array} D - diagonal elements of the upper triangular matrix `U`
+* @param {Float64Array} DU - elements of the first super-diagonal of `U`
+* @param {Float64Array} DU2 - elements of the second super-diagonal of `U`
 * @param {Int32Array} IPIV - vector of pivot indices
-* @param {Float64Array} B - right-hand side matrix B, overwritten by the solution matrix X
-* @param {NonNegativeInteger} LDB - leading dimension of array B
+* @param {Float64Array} B - right-hand side matrix B, overwritten by the solution matrix `X`
+* @param {NonNegativeInteger} LDB - leading dimension of array `B`
 * @throws {TypeError} first argument must be a valid order
 * @throws {RangeError} eleventh argument must be greater than or equal to N
 * @returns {Float64Array} The solution matrix X

lib/node_modules/@stdlib/lapack/base/dgtts2/lib/index.js

@@ -36,7 +36,7 @@
 * var B = new Float64Array( [ 7.0, 8.0, 7.0 ] );
 *
 * dgtts2( 'row-major', 1, 3, 1, DL, D, DU, DU2, IPIV, B, 3 );
-* // B => <Float64Array>[ 1.4365079379889456, 1.2539682480442178, 1.5476190504889455 ]
+* // B => <Float64Array>[ ~1.44, ~1.25, ~1.55 ]
 *
 * @example
 * var Float64Array = require( '@stdlib/array/float64' );
@@ -51,7 +51,7 @@
 * var B = new Float64Array( [ 7.0, 8.0, 7.0 ] );
 *
 * dgtts2.ndarray( 1, 3, 1, DL, 1, 0, D, 1, 0, DU, 1, 0, DU2, 1, 0, IPIV, 1, 0, B, 1, 1, 0 );
-* // B => <Float64Array>[ 1.4365079379889456, 1.2539682480442178, 1.5476190504889455 ]
+* // B => <Float64Array>[ ~1.44, ~1.25, ~1.55 ]
 */
 
 // MODULES //

lib/node_modules/@stdlib/lapack/base/dgtts2/lib/ndarray.js

@@ -30,29 +30,29 @@ var base = require( './base.js' );
 *
 * ## Notes
 *
-* -   To solve A * X = B (no transpose), use itrans = 0.
-* -   To solve AT * X = B (transpose), use itrans = 1.
-* -   To solve AT * X = B (conjugate transpose = transpose), use itrans = 2.
+* -   To solve `A * X = B` (no transpose), use `itrans` = 0.
+* -   To solve `AT * X = B` (transpose), use `itrans` = 1.
+* -   To solve `AT * X = B` (conjugate transpose = transpose), use `itrans` = 2.
 *
 * @param {integer} itrans - specifies the form of the system of equations
-* @param {NonNegativeInteger} N - order of the matrix A
-* @param {NonNegativeInteger} nrhs - number of right-hand sides, i.e., the number of columns of the matrix B
-* @param {Float64Array} DL - multipliers that define the matrix L
+* @param {NonNegativeInteger} N - order of the matrix `A`
+* @param {NonNegativeInteger} nrhs - number of right-hand sides, i.e., the number of columns of the matrix `B`
+* @param {Float64Array} DL - multipliers that define the matrix `L`
 * @param {integer} sdl - stride length for DL
 * @param {NonNegativeInteger} odl - starting index of DL
 * @param {Float64Array} D - N diagonal elements of the upper triangular matrix U
 * @param {integer} sd - stride length for D
 * @param {NonNegativeInteger} od - starting index of D
-* @param {Float64Array} DU - elements of the first super-diagonal of U
+* @param {Float64Array} DU - 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 - elements of the second super-diagonal of U
+* @param {Float64Array} DU2 - 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
 * @param {integer} si - stride length for IPIV
 * @param {NonNegativeInteger} oi - starting index for IPIV
-* @param {Float64Array} B - right-hand side matrix B, overwritten by the solution matrix X
+* @param {Float64Array} B - right-hand side matrix B, overwritten by the solution matrix `X`
 * @param {integer} sb1 - stride length for the first dimension of B
 * @param {integer} sb2 - stride for the second dimension of B
 * @param {NonNegativeInteger} ob - starting index of B