chore: code 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: 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: 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/dlascl/README.md

@@ -20,7 +20,7 @@ limitations under the License.
 
 # dlascl
 
-> LAPACK routine to multiply a real M by N matrix `A` by a real scalar `CTO/CFROM`.
+> LAPACK routine to multiply a double-precision floating-point M-by-N matrix `A` by a double-precision floating-point scalar.
 
 <section class="usage">
 
@@ -30,9 +30,9 @@ limitations under the License.
 var dlascl = require( '@stdlib/lapack/base/dlascl' );
 ```
 
-#### dlascl( order, type, KL, KU, CFROM, CTO, M, N, A, LDA )
+#### dlascl( order, type, KL, KU, γ, β, M, N, A, LDA )
 
-Multiplies a real M by N matrix `A` by a real scalar `CTO/CFROM`.
+Multiplies a double-precision floating-point M-by-N matrix `A` by a double-precision floating-point scalar.
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
@@ -46,11 +46,11 @@ dlascl( 'row-major', 'general', 0, 0, 1.0, 2.0, 3, 2, A, 2 );
 The function has the following parameters:
 
 -   **order**: storage layout.
--   **type**: specifies the type of matrix `A` ( should be one of these: `general`, `upper`, `lower`, `upper-hessenberg`, `symmetric-banded-lower`, `symmetric-banded-upper` or `banded` ).
--   **KL**: lower band width of `A`. Referenced only if type is `symmetric-banded-lower` or `banded`.
--   **KU**: upper band width of `A`. Referenced only if type is `symmetric-banded-upper` or `banded`.
--   **CFROM**: the matrix `A` is multiplied by `CTO / CFROM`.
--   **CTO**: the matrix `A` is multiplied by `CTO / CFROM`.
+-   **type**: specifies the type of matrix `A`. Must be one of the following: `'general'`, `'upper'`, `'lower'`, `'upper-hessenberg'`, `'symmetric-banded-lower'`, `'symmetric-banded-upper'`, or `'banded'`.
+-   **KL**: lower bandwidth of `A` (i.e., the number of sub-diagonals). Referenced only if type is `'symmetric-banded-lower'` or `'banded'`.
+-   **KU**: upper bandwidth of `A` (i.e., the number of super-diagonals). Referenced only if type is `'symmetric-banded-upper'` or `'banded'`.
+-   **γ**: the matrix `A` is multiplied by `β/γ`.
+-   **β**: the matrix `A` is multiplied by `β/γ`.
 -   **M**: number of rows in matrix `A`.
 -   **N**: number of columns in matrix `A`.
 -   **A**: input [`Float64Array`][mdn-float64array].
@@ -65,19 +65,19 @@ Note that indexing is relative to the first index. To introduce an offset, use [
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
 
-// Initial arrays...
+// Initial array:
 var A0 = new Float64Array( [ 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
 
-// Create offset views...
+// Create offset view:
 var A1 = new Float64Array( A0.buffer, A0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
 
 dlascl( 'row-major', 'general', 0, 0, 1.0, 2.0, 3, 2, A1, 2 );
 // A0 => <Float64Array>[ 0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0 ]
 ```
 
-#### dlascl.ndarray( type, KL, KU, CFROM, CTO, M, N, A, strideA1, strideA2, offsetA )
+#### dlascl.ndarray( type, KL, KU, γ, β, M, N, A, strideA1, strideA2, offsetA )
 
-Multiplies a real M by N matrix `A` by a real scalar `CTO/CFROM` using alternative indexing semantics.
+Multiplies a double-precision floating-point M-by-N matrix `A` by a double-precision floating-point scalar using alternative indexing semantics.
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
@@ -88,13 +88,13 @@ dlascl.ndarray( 'general', 0, 0, 1.0, 2.0, 3, 2, A, 2, 1, 0 );
 // A => <Float64Array>[ 2.0, 4.0, 6.0, 8.0, 10.0, 12.0 ]
 ```
 
-The function has the following additional parameters:
+The function has the following parameters:
 
--   **type**: specifies the type of matrix `A` ( should be one of these: `general`, `upper`, `lower`, `upper-hessenberg`, `symmetric-banded-lower`, `symmetric-banded-upper` or `banded` ).
--   **KL**: lower band width of `A`. Referenced only if type is `symmetric-banded-lower` or `banded`.
--   **KU**: upper band width of `A`. Referenced only if type is `symmetric-banded-upper` or `banded`.
--   **CFROM**: the matrix `A` is multiplied by `CTO / CFROM`.
--   **CTO**: the matrix `A` is multiplied by `CTO / CFROM`.
+-   **type**: specifies the type of matrix `A`. Must be one of the following: `'general'`, `'upper'`, `'lower'`, `'upper-hessenberg'`, `'symmetric-banded-lower'`, `'symmetric-banded-upper'`, or `'banded'`.
+-   **KL**: lower bandwidth of `A` (i.e., the number of sub-diagonals). Referenced only if type is `'symmetric-banded-lower'` or `'banded'`.
+-   **KU**: upper bandwidth of `A` (i.e., the number of super-diagonals). Referenced only if type is `'symmetric-banded-upper'` or `'banded'`.
+-   **γ**: the matrix `A` is multiplied by `β/γ`.
+-   **β**: the matrix `A` is multiplied by `β/γ`.
 -   **M**: number of rows in matrix `A`.
 -   **N**: number of columns in matrix `A`.
 -   **A**: input [`Float64Array`][mdn-float64array].

lib/node_modules/@stdlib/lapack/base/dlascl/docs/repl.txt

@@ -1,5 +1,6 @@
-{{alias}}( order, type, KL, KU, CFROM, CTO, M, N, A, LDA )
-    Multiplies a real M by N matrix `A` by a real scalar `CTO/CFROM`.
+{{alias}}( order, type, KL, KU, γ, β, M, N, A, LDA )
+    Multiplies a double-precision floating-point M-by-N matrix `A` by a
+    double-precision floating-point scalar.
 
     Indexing is relative to the first index. To introduce an offset, use
     typed array views.
@@ -13,30 +14,30 @@
     type: string
         Specifies the type of matrix `A`.
 
-    KL: nonNegativeInteger
-        Lower band width of `A`. Referenced only if type is
-        `symmetric-banded-lower` or `banded`.
+    KL: integer
+        Lower bandwidth of `A` (i.e., the number of sub-diagonals). Referenced
+        only if type is `symmetric-banded-lower` or `banded`.
 
-    KU: nonNegativeInteger
-        Upper band width of `A`. Referenced only if type is
-        `symmetric-banded-upper` or `banded`.
+    KU: integer
+        Upper bandwidth of `A` (i.e., the number of super-diagonals). Referenced
+        only if type is `symmetric-banded-upper` or `banded`.
 
-    CFROM: number
-        The matrix `A` are multiplied by `CTO / CFROM`.
+    γ: number
+        The matrix `A` is multiplied by `β/γ`.
 
-    CTO: number
-        The matrix `A` are multiplied by `CTO / CFROM`.
+    β: number
+        The matrix `A` is multiplied by `β/γ`.
 
-    M: nonNegativeInteger
+    M: integer
         Number of rows in matrix `A`.
 
-    N: nonNegativeInteger
+    N: integer
         Number of columns in matrix `A`.
 
     A: Float64Array
         Input matrix `A`.
 
-    LDA: positiveInteger
+    LDA: integer
         Stride of the first dimension of `A` (a.k.a., leading dimension of
         the matrix `A`).
 
@@ -52,9 +53,9 @@
     <Float64Array>[ 2.0, 4.0, 6.0, 8.0, 10.0, 12.0 ]
 
 
-{{alias}}.ndarray( type, KL, KU, CFROM, CTO, M, N, A, sa1, sa2, oa )
-    Multiplies a real M by N matrix `A` by a real scalar `CTO/CFROM` using
-    alternative indexing semantics.
+{{alias}}.ndarray( type, KL, KU, γ, β, M, N, A, sa1, sa2, oa )
+    Multiplies a double-precision floating-point M-by-N matrix `A` by a
+    double-precision floating-point scalar using 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
@@ -65,24 +66,24 @@
     type: string
         Specifies the type of matrix `A`.
 
-    KL: nonNegativeInteger
-        Lower band width of `A`. Referenced only if type is
-        `symmetric-banded-lower` or `banded`.
+    KL: integer
+        Lower bandwidth of `A` (i.e., the number of sub-diagonals). Referenced
+        only if type is `symmetric-banded-lower` or `banded`.
 
-    KU: nonNegativeInteger
-        Upper band width of `A`. Referenced only if type is
-        `symmetric-banded-upper` or `banded`.
+    KU: integer
+        Upper bandwidth of `A` (i.e., the number of super-diagonals). Referenced
+        only if type is `symmetric-banded-upper` or `banded`.
 
-    CFROM: number
-        The matrix `A` are multiplied by `CTO / CFROM`.
+    γ: number
+        The matrix `A` is multiplied by `β/γ`.
 
-    CTO: number
-        The matrix `A` are multiplied by `CTO / CFROM`.
+    β: number
+        The matrix `A` is multiplied by `β/γ`.
 
-    M: nonNegativeInteger
+    M: integer
         Number of rows in matrix `A`.
 
-    N: nonNegativeInteger
+    N: integer
         Number of columns in matrix `A`.
 
     A: Float64Array
@@ -94,7 +95,7 @@
     sa2: integer
         Stride of the second dimension of `A`.
 
-    oa: nonNegativeInteger
+    oa: integer
         Starting index for `A`.
 
     Returns

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

@@ -27,14 +27,14 @@ import { Layout } from '@stdlib/types/blas';
 */
 interface Routine {
 	/**
-	* Multiplies a real M by N matrix `A` by a real scalar `CTO/CFROM`.
+	* Multiplies a double-precision floating-point M-by-N matrix `A` by a double-precision floating-point scalar.
 	*
 	* @param order - storage layout
-	* @param type - specifies the type of matrix `A`
-	* @param KL - lower band width of `A`. Referenced only if type is `symmetric-banded-lower` or `banded`.
-	* @param KU - upper band width of `A`. Referenced only if type is `symmetric-banded-upper` or `banded`.
-	* @param CFROM - the matrix `A` is multiplied by `CTO / CFROM`
-	* @param CTO - the matrix `A` is multiplied by `CTO / CFROM`
+	* @param type - specifies the type of matrix `A`. Must be one of the following: `'general'`, `'upper'`, `'lower'`, `'upper-hessenberg'`, `'symmetric-banded-lower'`, `'symmetric-banded-upper'`, or `'banded'`.
+	* @param KL - lower bandwidth of `A` (i.e., the number of sub-diagonals). Referenced only if type is `'symmetric-banded-lower'` or `'banded'`.
+	* @param KU - upper bandwidth of `A` (i.e., the number of super-diagonals). Referenced only if type is `'symmetric-banded-upper'` or `'banded'`.
+	* @param gamma - the matrix `A` is multiplied by `β/γ`
+	* @param beta - the matrix `A` is multiplied by `β/γ`
 	* @param M - number of rows in matrix `A`
 	* @param N - number of columns in matrix `A`
 	* @param A - input matrix
@@ -49,16 +49,16 @@ interface Routine {
 	* dlascl( 'row-major', 'general', 0, 0, 1.0, 2.0, 3, 2, A, 2 );
 	* // A => <Float64Array>[ 2.0, 4.0, 6.0, 8.0, 10.0, 12.0 ]
 	*/
-	( order: Layout, type: string, KL: number, KU: number, CFROM: number, CTO: number, M: number, N: number, A: Float64Array, LDA: number ): Float64Array;
+	( order: Layout, type: string, KL: number, KU: number, gamma: number, beta: number, M: number, N: number, A: Float64Array, LDA: number ): Float64Array;
 
 	/**
-	* Multiplies a real M by N matrix `A` by a real scalar `CTO/CFROM` using alternative indexing semantics.
+	* Multiplies a double-precision floating-point M-by-N matrix `A` by a double-precision floating-point scalar using alternative indexing semantics.
 	*
-	* @param type - specifies the type of matrix `A`
-	* @param KL - lower band width of `A`. Referenced only if type is `symmetric-banded-lower` or `banded`.
-	* @param KU - upper band width of `A`. Referenced only if type is `symmetric-banded-upper` or `banded`.
-	* @param CFROM - the matrix `A` is multiplied by `CTO / CFROM`
-	* @param CTO - the matrix `A` is multiplied by `CTO / CFROM`
+	* @param type - specifies the type of matrix `A`. Must be one of the following: `'general'`, `'upper'`, `'lower'`, `'upper-hessenberg'`, `'symmetric-banded-lower'`, `'symmetric-banded-upper'`, or `'banded'`.
+	* @param KL - lower bandwidth of `A` (i.e., the number of sub-diagonals). Referenced only if type is `'symmetric-banded-lower'` or `'banded'`.
+	* @param KU - upper bandwidth of `A` (i.e., the number of super-diagonals). Referenced only if type is `'symmetric-banded-upper'` or `'banded'`.
+	* @param gamma - the matrix `A` is multiplied by `β/γ`
+	* @param beta - the matrix `A` is multiplied by `β/γ`
 	* @param M - number of rows in matrix `A`
 	* @param N - number of columns in matrix `A`
 	* @param A - input matrix
@@ -75,18 +75,18 @@ interface Routine {
 	* dlascl.ndarray( 'general', 0, 0, 1.0, 2.0, 3, 2, A, 2, 1, 0 );
 	* // A => <Float64Array>[ 2.0, 4.0, 6.0, 8.0, 10.0, 12.0 ]
 	*/
-	ndarray( type: string, KL: number, KU: number, CFROM: number, CTO: number, M: number, N: number, A: Float64Array, strideA1: number, strideA2: number, offsetA: number ): Float64Array;
+	ndarray( type: string, KL: number, KU: number, gamma: number, beta: number, M: number, N: number, A: Float64Array, strideA1: number, strideA2: number, offsetA: number ): Float64Array;
 }
 
 /**
-* Multiplies a real M by N matrix `A` by a real scalar `CTO/CFROM`.
+* Multiplies a double-precision floating-point M-by-N matrix `A` by a double-precision floating-point scalar.
 *
 * @param order - storage layout
-* @param type - specifies the type of matrix `A`
-* @param KL - lower band width of `A`. Referenced only if type is `symmetric-banded-lower` or `banded`.
-* @param KU - upper band width of `A`. Referenced only if type is `symmetric-banded-upper` or `banded`.
-* @param CFROM - the matrix `A` is multiplied by `CTO / CFROM`
-* @param CTO - the matrix `A` is multiplied by `CTO / CFROM`
+* @param type - specifies the type of matrix `A`. Must be one of the following: `'general'`, `'upper'`, `'lower'`, `'upper-hessenberg'`, `'symmetric-banded-lower'`, `'symmetric-banded-upper'`, or `'banded'`.
+* @param KL - lower bandwidth of `A` (i.e., the number of sub-diagonals). Referenced only if type is `'symmetric-banded-lower'` or `'banded'`.
+* @param KU - upper bandwidth of `A` (i.e., the number of super-diagonals). Referenced only if type is `'symmetric-banded-upper'` or `'banded'`.
+* @param gamma - the matrix `A` is multiplied by `β/γ`
+* @param beta - the matrix `A` is multiplied by `β/γ`
 * @param M - number of rows in matrix `A`
 * @param N - number of columns in matrix `A`
 * @param A - input matrix