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: 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/dlarf1f/README.md

@@ -58,7 +58,7 @@ var out = dlarf1f( 'row-major', 'left', 4, 3, V, 1, 1.0, C, 3, work );
 The function has the following parameters:
 
 -   **order**: storage layout.
--   **side**: use `left` to form `H * C` and `right` to from `C * H`.
+-   **side**: specifies the side of multiplication with `C`. Use `left` to form `H * C` and `right` to from `C * H`.
 -   **M**: number of rows in `C`.
 -   **N**: number of columns in `C`.
 -   **V**: the vector `v` in the representation of `H` as a [`Float64Array`][mdn-float64array].
@@ -68,6 +68,11 @@ The function has the following parameters:
 -   **LDC**: stride of the first dimension of `C` (a.k.a., leading dimension of the matrix `C`).
 -   **work**: workspace [`Float64Array`][mdn-float64array].
 
+Based on the `side` of multiplication, the expected storage of the array changes:
+
+-   `work` should have `N` indexed elements if `side` = `left` and `M` indexed elements if `side` = `right`.
+-   `V` should have `1 + (M-1) * abs(incv)` indexed elements if `side` = `left` and `1 + (N-1) * abs(incv)` indexed elements if `side` = `right`.
+
 The sign of the increment parameter `incv` determines the order in which elements of `V` are accessed. For example, to access elements in reverse order,
 
 <!-- eslint-disable max-len -->
@@ -138,7 +143,7 @@ var out = dlarf1f.ndarray( 'left', 4, 3, V, 1, 0, 1.0, C, 3, 1, 0, work, 1, 0 );
 
 The function has the following additional parameters:
 
--   **side**: use `left` to form `H * C` and `right` to from `C * H`.
+-   **side**: specifies the side of multiplication with `C`. Use `left` to form `H * C` and `right` to from `C * H`.
 -   **M**: number of rows in `C`.
 -   **N**: number of columns in `C`.
 -   **V**: the vector `v` in the representation of `H` as a [`Float64Array`][mdn-float64array].
@@ -153,6 +158,11 @@ The function has the following additional parameters:
 -   **sw**: stride length for `work`.
 -   **ow**: starting index for `work`.
 
+Based on the `side` of multiplication, the expected storage of the array changes:
+
+-   `work` should have `N` indexed elements if `side` = `left` and `M` indexed elements if `side` = `right`.
+-   `V` should have `1 + (M-1) * abs(incv)` indexed elements if `side` = `left` and `1 + (N-1) * abs(incv)` indexed elements if `side` = `right`.
+
 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,
 
 <!-- eslint-disable max-len -->
@@ -176,8 +186,6 @@ var out = dlarf1f.ndarray( 'left', 4, 3, V, 1, 2, 1.0, C, 3, 1, 4, work, 1, 0 );
 
 ## Notes
 
--   `work` should have `N` indexed elements if side = `left` and `M` indexed elements if side = `right`.
--   `V` should have `1 + (M-1) * abs(incv)` indexed elements if side = `left` and `1 + (N-1) * abs(incv)` indexed elements if side = `right`.
 -   `C` is overwritten by `H * C` if side = `left` and `C * H` if side = `right`.
 -   `dlarf1f()` corresponds to the [LAPACK][LAPACK] function [`dlarf1f`][lapack-dlarf1f].
 

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

@@ -1,16 +1,16 @@
 
 {{alias}}( order, side, M, N, V, incv, tau, C, LDC, work )
-    Applies a real elementary reflector `H = I - tau * v * v ^ T`
-    to a real M by N matrix `C`.
+    Applies a real elementary reflector `H = I - tau * v * v ^ T` to a
+    real M by N matrix `C`.
 
     Parameters
     ----------
     order: string
         Storage layout. Must be either 'row-major' or 'column-major'.
 
     side: string
-        Specifies whether to form `H * C` ('left') or
-        `C * H` ('right').
+        Specifies the side of multiplication with `C`. Use `left` to form
+        `H * C` and `right` to from `C * H`.
 
     M: integer
         Number of rows in `C`.
@@ -31,8 +31,8 @@
         Input matrix.
 
     LDC: integer
-        Stride of the first dimension of `C` (a.k.a., leading
-        dimension of the matrix `C`).
+        Stride of the first dimension of `C` (a.k.a., leading dimension
+        of the matrix `C`).
 
     work: Float64Array
         Workspace array.
@@ -52,13 +52,14 @@
 
 
 {{alias}}.ndarray( side, M, N, V, sv, ov, tau, C, sc1, sc2, oc, work, sw, ow )
-    Applies a real elementary reflector `H = I - tau * v * v ^ T`
-    to a real M by N matrix `C` using alternative indexing semantics.
+    Applies a real elementary reflector `H = I - tau * v * v ^ T` to a real
+    M by N matrix `C` using alternative indexing semantics.
 
     Parameters
     ----------
     side: string
-        Specifies whether to form `H * C` ('left') or `C * H` ('right').
+        Specifies the side of multiplication with `C`. Use `left` to form
+        `H * C` and `right` to from `C * H`.
 
     M: integer
         Number of rows in `C`.

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

@@ -30,7 +30,7 @@ interface Routine {
 	/**
 	* Applies a real elementary reflector `H = I - tau * v * v ^ T` to a real M by N matrix `C`.
 	*
-	* @param side - use `left` to form `H * C` and `right` to from `C * H`
+	* @param side - specifies the side of multiplication with `C`. Use `left` to form `H * C` and `right` to from `C * H`.
 	* @param M - number of rows in `C`
 	* @param N - number of columns in `C`
 	* @param V - the vector `v` in the representation of `H`
@@ -56,7 +56,7 @@ interface Routine {
 	/**
 	* Applies a real elementary reflector `H = I - tau * v * v ^ T` to a real M by N matrix `C` using alternative indexing semantics.
 	*
-	* @param side - use `left` to form `H * C` and `right` to from `C * H`
+	* @param side - specifies the side of multiplication with `C`. Use `left` to form `H * C` and `right` to from `C * H`.
 	* @param M - number of rows in `C`
 	* @param N - number of columns in `C`
 	* @param V - the vector `v` in the representation of `H`
@@ -88,7 +88,7 @@ interface Routine {
 /**
 * Applies a real elementary reflector `H = I - tau * v * v ^ T` to a real M by N matrix `C`.
 *
-* @param side - use `left` to form `H * C` and `right` to from `C * H`
+* @param side - specifies the side of multiplication with `C`. Use `left` to form `H * C` and `right` to from `C * H`.
 * @param M - number of rows in `C`
 * @param N - number of columns in `C`
 * @param V - the vector `v` in the representation of `H`

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

@@ -29,7 +29,7 @@ var order = 'row-major';
 var strides = shape2strides( shape, order );
 
 // Create a matrix stored in linear memory:
-var C = new Float64Array( [ 1.0, 5.0, 9.0, 2.0, 6.0, 10.0, 3.0, 7.0, 11.0, 4.0, 8.0, 12.0 ] );
+var C = new Float64Array( [ 1.0, 5.0, 9.0, 2.0, 6.0, 10.0, 3.0, 7.0, 11.0, 4.0, 8.0, 12.0 ] ); // eslint-disable-line max-len
 console.log( ndarray2array( C, shape, strides, 0, order ) );
 
 // Define the vector `v` and workspace array:

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

@@ -42,7 +42,7 @@ var dscal = require( '@stdlib/blas/base/dscal' ).ndarray;
 * -   `C` is overwritten by `H * C` if side = `left` and `C * H` if side = `right`.
 *
 * @private
-* @param {string} side - use `left` to form `H * C` and `right` to from `C * H`
+* @param {string} side - specifies the side of multiplication with `C`. Use `left` to form `H * C` and `right` to from `C * H`.
 * @param {NonNegativeInteger} M - number of rows in `C`
 * @param {NonNegativeInteger} N - number of columns in `C`
 * @param {Float64Array} V - the vector `v` in the representation of `H`

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

@@ -41,7 +41,7 @@ var base = require( './base.js' );
 * -   `C` is overwritten by `H * C` if side = `left` and `C * H` if side = `right`.
 *
 * @param {string} order - storage layout
-* @param {string} side - use `left` to form `H * C` and `right` to from `C * H`
+* @param {string} side - specifies the side of multiplication with `C`. Use `left` to form `H * C` and `right` to from `C * H`.
 * @param {NonNegativeInteger} M - number of rows in `C`
 * @param {NonNegativeInteger} N - number of columns in `C`
 * @param {Float64Array} V - the vector `v` in the representation of `H`

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

@@ -37,7 +37,7 @@ var base = require( './base.js' );
 * -   `V` should have `1 + (M-1) * abs(strideV)` indexed elements if side = `left` and `1 + (N-1) * abs(strideV)` indexed elements if side = `right`.
 * -   `C` is overwritten by `H * C` if side = `left` and `C * H` if side = `right`.
 *
-* @param {string} side - use `left` to form `H * C` and `right` to from `C * H`
+* @param {string} side - specifies the side of multiplication with `C`. Use `left` to form `H * C` and `right` to from `C * H`.
 * @param {NonNegativeInteger} M - number of rows in `C`
 * @param {NonNegativeInteger} N - number of columns in `C`
 * @param {Float64Array} V - the vector `v` in the representation of `H`