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: na
  - task: lint_repl_help
    status: passed
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: passed
  - 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/dlanv2/README.md

@@ -59,7 +59,7 @@ T = \begin{bmatrix} AA & BB \\
 
 <!-- </equation> -->
 
-2.  `T` is a 2x2 block with complex conjugate eigenvalues:
+2.  `T` is a 2-by-2 block with complex conjugate eigenvalues:
 
 <!-- <equation class="equation" label="eq:complex_schur" align="center" raw="T = \begin{bmatrix} AA & BB \\ CC & AA \end{bmatrix}" alt="Real Schur form with complex eigenvalues."> -->
 
@@ -92,7 +92,7 @@ with `BB*CC < 0`, yielding complex conjugate eigenvalues:
 var dlanv2 = require( '@stdlib/lapack/base/dlanv2' );
 ```
 
-#### dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN )
+#### dlanv2 ( A, B, C, D, rt1r, rt1i, rt2r, rt2i, cs, sn )
 
 Computes the Schur factorization of a real 2-by-2 nonsymmetric matrix `A` in standard form.
 
@@ -120,7 +120,7 @@ dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
 // RT2R => <Float64Array>[ -1.0 ]
 // RT2I => <Float64Array>[ 0.0 ]
 // CS => <Float64Array>[ ~0.93 ]
-// SN => <Float64Array>[ ~0.34 ]
+// SN => <Float64Array>[ ~0.37 ]
 ```
 
 The function has the following parameters:`
@@ -129,12 +129,12 @@ The function has the following parameters:`
 -   **B**: single-element [`Float64Array`][mdn-float64array] containing the element `A(1,2)`.
 -   **C**: single-element [`Float64Array`][mdn-float64array] containing the element `A(2,1)`.
 -   **D**: single-element [`Float64Array`][mdn-float64array] containing the element `A(2,2)`.
--   **RT1R**: single-element output [`Float64Array`][mdn-float64array] to store the real value of the first eigenvector.
--   **RT1I**: single-element output [`Float64Array`][mdn-float64array] to store the imaginary value of the first eigenvector.
--   **RT2R**: single-element output [`Float64Array`][mdn-float64array] to store the real value of the second eigenvector.
--   **RT2I**: single-element output [`Float64Array`][mdn-float64array] to store the imaginary value of the second eigenvector.
--   **CS**: output [`Float64Array`][mdn-float64array] to store the cosine of the rotation.
--   **SN**: output [`Float64Array`][mdn-float64array] to store the sine of the rotation.
+-   **rt1r**: single-element output [`Float64Array`][mdn-float64array] to store the real value of the first eigenvector.
+-   **rt1i**: single-element output [`Float64Array`][mdn-float64array] to store the imaginary value of the first eigenvector.
+-   **rt2r**: single-element output [`Float64Array`][mdn-float64array] to store the real value of the second eigenvector.
+-   **rt2i**: single-element output [`Float64Array`][mdn-float64array] to store the imaginary value of the second eigenvector.
+-   **cs**: output [`Float64Array`][mdn-float64array] to store the cosine of the rotation.
+-   **sn**: output [`Float64Array`][mdn-float64array] to store the sine of the rotation.
 
 Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
 
@@ -177,12 +177,12 @@ dlanv2( A1, B1, C1, D1, RT1R1, RT1I1, RT2R1, RT2I1, CS1, SN1 );
 // RT2R0 => <Float64Array>[ 0.0, -1.0 ]
 // RT2I0 => <Float64Array>[ 0.0, 0.0 ]
 // CS0 => <Float64Array>[ 0.0, ~0.93 ]
-// SN0 => <Float64Array>[ 0.0, ~0.34 ]
+// SN0 => <Float64Array>[ 0.0, ~0.37 ]
 ```
 
 <!-- lint disable maximum-heading-length -->
 
-#### dlanv2.ndarray( A, oa, B, ob, C, oc, D, od, RT1R, or1, RT1I, oi1, RT2R, or2, RT2I, oi2, CS, ocs, SN, osn )
+#### dlanv2.ndarray( A, oa, B, ob, C, oc, D, od, rt1r, or1, rt1i, oi1, rt2r, or2, rt2i, oi2, cs, ocs, sn, osn )
 
 Computes the Schur factorization of a real 2-by-2 nonsymmetric matrix `A` in standard form using alternative indexing semantics.
 
@@ -210,7 +210,7 @@ dlanv2.ndarray( A, 0, B, 0, C, 0, D, 0, RT1R, 0, RT1I, 0, RT2R, 0, RT2I, 0, CS,
 // RT2R => <Float64Array>[ -1.0 ]
 // RT2I => <Float64Array>[ 0.0 ]
 // CS => <Float64Array>[ ~0.93 ]
-// SN => <Float64Array>[ ~0.34 ]
+// SN => <Float64Array>[ ~0.37 ]
 ```
 
 The function has the following parameters:
@@ -223,18 +223,18 @@ The function has the following parameters:
 -   **oc**: starting index for `C`.
 -   **D**: single-element [`Float64Array`][mdn-float64array] containing the element `A(2,2)`.
 -   **od**: starting index for `D`.
--   **RT1R**: single-element output [`Float64Array`][mdn-float64array] to store the real value of the first eigenvector.
--   **or1**: starting index for `RT1R`.
--   **RT1I**: single-element output [`Float64Array`][mdn-float64array] to store the imaginary value of the first eigenvector.
--   **oi1**: starting index for `RT1I`.
--   **RT2R**: single-element output [`Float64Array`][mdn-float64array] to store the real value of the second eigenvector.
--   **or2**: starting index for `RT2R`.
--   **RT2I**: single-element output [`Float64Array`][mdn-float64array] to store the imaginary value of the second eigenvector.
--   **oi2**: starting index for `RT2I`.
--   **CS**: output [`Float64Array`][mdn-float64array] to store the cosine of the rotation.
--   **ocs**: starting index for `CS`.
--   **SN**: output [`Float64Array`][mdn-float64array] to store the sine of the rotation.
--   **osn**: starting index for `SN`.
+-   **rt1r**: single-element output [`Float64Array`][mdn-float64array] to store the real value of the first eigenvector.
+-   **or1**: starting index for `rt1r`.
+-   **rt1i**: single-element output [`Float64Array`][mdn-float64array] to store the imaginary value of the first eigenvector.
+-   **oi1**: starting index for `rt1i`.
+-   **rt2r**: single-element output [`Float64Array`][mdn-float64array] to store the real value of the second eigenvector.
+-   **or2**: starting index for `rt2r`.
+-   **rt2i**: single-element output [`Float64Array`][mdn-float64array] to store the imaginary value of the second eigenvector.
+-   **oi2**: starting index for `rt2i`.
+-   **cs**: output [`Float64Array`][mdn-float64array] to store the cosine of the rotation.
+-   **ocs**: starting index for `cs`.
+-   **sn**: output [`Float64Array`][mdn-float64array] to store the sine of the rotation.
+-   **osn**: starting index for `sn`.
 
 While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameters support indexing semantics based on starting indices. For example,
 
@@ -262,7 +262,7 @@ dlanv2.ndarray( A, 1, B, 1, C, 1, D, 1, RT1R, 1, RT1I, 1, RT2R, 1, RT2I, 1, CS,
 // RT2R => <Float64Array>[ 0.0, -1.0 ]
 // RT2I => <Float64Array>[ 0.0, 0.0 ]
 // CS => <Float64Array>[ 0.0, ~0.93 ]
-// SN => <Float64Array>[ 0.0, ~0.34 ]
+// SN => <Float64Array>[ 0.0, ~0.37 ]
 ```
 
 </section>
@@ -310,17 +310,15 @@ console.log( [ [ A[ 0 ], B[ 0 ] ], [ C[ 0 ], D[ 0 ] ] ] );
 
 dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
 
-console.log( 'the schur factorization of the matrix: ' );
-console.log([
-    [ CS[ 0 ], -SN[ 0 ] ],
-    [ SN[ 0 ], CS[ 0 ] ]
-], '*', [
-    [ A[ 0 ], B[ 0 ] ],
-    [ C[ 0 ], D[ 0 ] ]
-], '*', [
-    [ CS[ 0 ], SN[ 0 ] ],
-    [ -SN[ 0 ], CS[ 0 ] ]
-]);
+console.log( 'Schur factorization: A = QUQ^-1' );
+console.log( 'A:' );
+console.log( [ [ A[ 0 ], B[ 0 ] ], [ C[ 0 ], D[ 0 ] ] ] );
+console.log( 'Q:' );
+console.log( [ [ CS[ 0 ], -SN[ 0 ] ], [ SN[ 0 ], CS[ 0 ] ] ] );
+console.log( 'U:' );
+console.log( [ [ A[ 0 ], B[ 0 ] ], [ C[ 0 ], D[ 0 ] ] ] );
+console.log( 'Q^-1:' );
+console.log( [ [ CS[ 0 ], SN[ 0 ] ], [ -SN[ 0 ], CS[ 0 ] ] ] );
 
 var eigenvalue1 = new Complex128( RT1R[ 0 ], RT1I[ 0 ] );
 var eigenvalue2 = new Complex128( RT2R[ 0 ], RT2I[ 0 ] );

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

@@ -13,13 +13,13 @@
         Q^T *   [ A  B ] * Q = [ AA  BB ]
                 [ C  D ]       [ CC  DD ]
 
-    where Q is a 2x2 rotation matrix:
+    where Q is a 2-by-2 rotation matrix:
 
         Q = [ CS  SN ]
             [ -SN CS ]
 
     and the result is either real upper triangular (real eigenvalues) or
-    2x2 block diagonal (complex conjugate eigenvalues).
+    2-by-2 block diagonal (complex conjugate eigenvalues).
 
     Indexing is relative to the first index. To introduce an offset, use
     typed array views.
@@ -39,44 +39,41 @@
         Input element A(2,2).
 
     RT1R: Float64Array
-        Output: real part of the first eigenvalue.
+        Real part of the first eigenvalue.
 
     RT1I: Float64Array
-        Output: imaginary part of the first eigenvalue.
+        Imaginary part of the first eigenvalue.
 
     RT2R: Float64Array
-        Output: real part of the second eigenvalue.
+        Real part of the second eigenvalue.
 
     RT2I: Float64Array
-        Output: imaginary part of the second eigenvalue.
+        Imaginary part of the second eigenvalue.
 
     CS: Float64Array
-        Output: cosine of the rotation.
+        Cosine of the rotation.
 
     SN: Float64Array
-        Output: sine of the rotation.
+        Sine of the rotation.
 
     Returns
     -------
     undefined
 
     Examples
     --------
-    > var Float64Array = require( '@stdlib/array/float64' );
-    > var dlanv2 = require( '@stdlib/lapack/base/dlanv2' );
-
-    > var A = new Float64Array( [ 4.0 ] );
-    > var B = new Float64Array( [ -5.0 ] );
-    > var C = new Float64Array( [ 2.0 ] );
-    > var D = new Float64Array( [ -3.0 ] );
-    > var RT1R = new Float64Array( 1 );
-    > var RT1I = new Float64Array( 1 );
-    > var RT2R = new Float64Array( 1 );
-    > var RT2I = new Float64Array( 1 );
-    > var CS = new Float64Array( 1 );
-    > var SN = new Float64Array( 1 );
-
-    > dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
+    > var A = new {{alias:@stdlib/array/float64}}( [ 4.0 ] );
+    > var B = new {{alias:@stdlib/array/float64}}( [ -5.0 ] );
+    > var C = new {{alias:@stdlib/array/float64}}( [ 2.0 ] );
+    > var D = new {{alias:@stdlib/array/float64}}( [ -3.0 ] );
+    > var RT1R = new {{alias:@stdlib/array/float64}}( 1 );
+    > var RT1I = new {{alias:@stdlib/array/float64}}( 1 );
+    > var RT2R = new {{alias:@stdlib/array/float64}}( 1 );
+    > var RT2I = new {{alias:@stdlib/array/float64}}( 1 );
+    > var CS = new {{alias:@stdlib/array/float64}}( 1 );
+    > var SN = new {{alias:@stdlib/array/float64}}( 1 );
+
+    > {{alias}}( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
 
     > A
     <Float64Array>[ 2.0 ]
@@ -97,9 +94,10 @@
     > CS
     <Float64Array>[ ~0.93 ]
     > SN
-    <Float64Array>[ ~0.34 ]
+    <Float64Array>[ ~0.37 ]
 
-{{alias}}.ndarray( A,oa,B,ob,C,oc,D,od,R1,or1,I1,oi1,R2,or2,I2,oi2,CS,ocs,SN,osn )
+
+{{alias}}.ndarray(A,oa,B,ob,C,oc,D,od,R1,or1,I1,oi1,R2,or2,I2,oi2,CS,ocs,SN,osn)
 
     Computes the Schur factorization of a 2-by-2 real nonsymmetric matrix
     using alternative indexing semantics.
@@ -115,13 +113,13 @@
         Q^T *   [ A  B ] * Q = [ AA  BB ]
                 [ C  D ]       [ CC  DD ]
 
-    where Q is a 2x2 rotation matrix:
+    where Q is a 2-by-2 rotation matrix:
 
         Q = [ CS  SN ]
             [ -SN CS ]
 
     and the result is either real upper triangular (real eigenvalues) or
-    2x2 block diagonal (complex conjugate eigenvalues).
+    2-by-2 block diagonal (complex conjugate eigenvalues).
 
     While typed array views mandate a view offset based on the underlying
     buffer, the offset parameters support indexing semantics based on starting
@@ -154,57 +152,55 @@
         Starting index for `D`.
 
     R1: Float64Array
-        Output: real part of the first eigenvalue.
+        Real part of the first eigenvalue.
 
     or1: integer
         Starting index for `R1`.
 
     I1: Float64Array
-        Output: imaginary part of the first eigenvalue.
+        Imaginary part of the first eigenvalue.
 
     oi1: integer
         Starting index for `I1`.
 
     R2: Float64Array
-        Output: real part of the second eigenvalue.
+        Real part of the second eigenvalue.
 
     or2: integer
         Starting index for `R2`.
 
     I2: Float64Array
-        Output: imaginary part of the second eigenvalue.
+        Imaginary part of the second eigenvalue.
 
     oi2: integer
         Starting index for `I2`.
 
     CS: Float64Array
-        Output: cosine of the rotation.
+        Cosine of the rotation.
 
     ocs: integer
         Starting index for `CS`.
 
     SN: Float64Array
-        Output: sine of the rotation.
+        Sine of the rotation.
 
     osn: integer
         Starting index for `SN`.
 
     Examples
     --------
-    > var Float64Array = require( '@stdlib/array/float64' );
-    > var A = new Float64Array( [ 0.0, 4.0 ] );
-    > var B = new Float64Array( [ 0.0, -5.0 ] );
-    > var C = new Float64Array( [ 0.0, 2.0 ] );
-    > var D = new Float64Array( [ 0.0, -3.0 ] );
-    > var RT1R = new Float64Array( 2 );
-    > var RT1I = new Float64Array( 2 );
-    > var RT2R = new Float64Array( 2 );
-    > var RT2I = new Float64Array( 2 );
-    > var CS = new Float64Array( 2 );
-    > var SN = new Float64Array( 2 );
-
-    > dlanv2.ndarray( A, 1, B, 1, C, 1, D, 1,
-        RT1R, 1, RT1I, 1, RT2R, 1, RT2I, 1, CS, 1, SN, 1 );
+    > var A = new {{alias:@stdlib/array/float64}}( [ 0.0, 4.0 ] );
+    > var B = new {{alias:@stdlib/array/float64}}( [ 0.0, -5.0 ] );
+    > var C = new {{alias:@stdlib/array/float64}}( [ 0.0, 2.0 ] );
+    > var D = new {{alias:@stdlib/array/float64}}( [ 0.0, -3.0 ] );
+    > var RT1R = new {{alias:@stdlib/array/float64}}( 2 );
+    > var RT1I = new {{alias:@stdlib/array/float64}}( 2 );
+    > var RT2R = new {{alias:@stdlib/array/float64}}( 2 );
+    > var RT2I = new {{alias:@stdlib/array/float64}}( 2 );
+    > var CS = new {{alias:@stdlib/array/float64}}( 2 );
+    > var SN = new {{alias:@stdlib/array/float64}}( 2 );
+
+    > {{alias}}.ndarray(A,1,B,1,C,1,D,1,RT1R,1,RT1I,1,RT2R,1,RT2I,1,CS,1,SN,1);
 
     > A
     <Float64Array>[ 0.0, 2.0 ]
@@ -214,3 +210,6 @@
     <Float64Array>[ 0.0, 2.0 ]
     > RT2R
     <Float64Array>[ 0.0, -1.0 ]
+
+    See Also
+    --------

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

@@ -92,7 +92,7 @@ interface Routine {
 	* // RT2R => <Float64Array>[ -1.0 ]
 	* // RT2I => <Float64Array>[ 0.0 ]
 	* // CS => <Float64Array>[ ~0.93 ]
-	* // SN => <Float64Array>[ ~0.34 ]`
+	* // SN => <Float64Array>[ ~0.37 ]`
 	*/
 	( A: Float64Array, B: Float64Array, C: Float64Array, D: Float64Array, RT1R: Float64Array, RT1I: Float64Array, RT2R: Float64Array, RT2I: Float64Array, CS: Float64Array, SN: Float64Array ): void;
 
@@ -176,7 +176,7 @@ interface Routine {
 	* // RT2R => <Float64Array>[ -1.0 ]
 	* // RT2I => <Float64Array>[ 0.0 ]
 	* // CS => <Float64Array>[ ~0.93 ]
-	* // SN => <Float64Array>[ ~0.34 ]
+	* // SN => <Float64Array>[ ~0.37 ]
 	*/
 	ndarray( A: Float64Array, offsetA: number, B: Float64Array, offsetB: number, C: Float64Array, offsetC: number, D: Float64Array, offsetD: number, RT1R: Float64Array, offsetRT1R: number, RT1I: Float64Array, offsetRT1I: number, RT2R: Float64Array, offsetRT2R: number, RT2I: Float64Array, offsetRT2I: number, CS: Float64Array, offsetCS: number, SN: Float64Array, offsetSN: number ): void;
 }
@@ -251,7 +251,7 @@ interface Routine {
 * // RT2R => <Float64Array>[ -1.0 ]
 * // RT2I => <Float64Array>[ 0.0 ]
 * // CS => <Float64Array>[ ~0.93 ]
-* // SN => <Float64Array>[ ~0.34 ]
+* // SN => <Float64Array>[ ~0.37 ]
 *
 * @example
 * var Float64Array = require( '@stdlib/array/float64' );
@@ -277,7 +277,7 @@ interface Routine {
 * // RT2R => <Float64Array>[ -1.0 ]
 * // RT2I => <Float64Array>[ 0.0 ]
 * // CS => <Float64Array>[ ~0.93 ]
-* // SN => <Float64Array>[ ~0.34 ]
+* // SN => <Float64Array>[ ~0.37 ]
 */
 declare var dlanv2: Routine;
 

lib/node_modules/@stdlib/lapack/base/dlanv2/examples/index.js

@@ -42,17 +42,15 @@ console.log( [ [ A[ 0 ], B[ 0 ] ], [ C[ 0 ], D[ 0 ] ] ] );
 
 dlanv2( A, B, C, D, RT1R, RT1I, RT2R, RT2I, CS, SN );
 
-console.log( 'the schur factorization of the matrix: ' );
-console.log([
-	[ CS[ 0 ], -SN[ 0 ] ],
-	[ SN[ 0 ], CS[ 0 ] ]
-], '*', [
-	[ A[ 0 ], B[ 0 ] ],
-	[ C[ 0 ], D[ 0 ] ]
-], '*', [
-	[ CS[ 0 ], SN[ 0 ] ],
-	[ -SN[ 0 ], CS[ 0 ] ]
-]);
+console.log( 'Schur factorization: A = QUQ^-1' );
+console.log( 'A:' );
+console.log( [ [ A[ 0 ], B[ 0 ] ], [ C[ 0 ], D[ 0 ] ] ] );
+console.log( 'Q:' );
+console.log( [ [ CS[ 0 ], -SN[ 0 ] ], [ SN[ 0 ], CS[ 0 ] ] ] );
+console.log( 'U:' );
+console.log( [ [ A[ 0 ], B[ 0 ] ], [ C[ 0 ], D[ 0 ] ] ] );
+console.log( 'Q^-1:' );
+console.log( [ [ CS[ 0 ], SN[ 0 ] ], [ -SN[ 0 ], CS[ 0 ] ] ] );
 
 var eigenvalue1 = new Complex128( RT1R[ 0 ], RT1I[ 0 ] );
 var eigenvalue2 = new Complex128( RT2R[ 0 ], RT2I[ 0 ] );

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

@@ -127,7 +127,7 @@ var multpl = 4.0;
 * // RT2R => <Float64Array>[ -1.0 ]
 * // RT2I => <Float64Array>[ 0.0 ]
 * // CS => <Float64Array>[ ~0.93 ]
-* // SN => <Float64Array>[ ~0.34 ]
+* // SN => <Float64Array>[ ~0.37 ]
 */
 function dlanv2( A, offsetA, B, offsetB, C, offsetC, D, offsetD, RT1R, offsetRT1R, RT1I, offsetRT1I, RT2R, offsetRT2R, RT2I, offsetRT2I, CS, offsetCS, SN, offsetSN ) {
 	var bcmax;