chore: clean-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: passed
  - task: lint_javascript_benchmarks
    status: passed
  - 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: passed
  - task: lint_license_headers
    status: passed
---

Author: kgryte

lib/node_modules/@stdlib/lapack/base/dlarf1f/README.md

@@ -24,7 +24,7 @@ limitations under the License.
 
 <section class="intro">
 
-In linear algebra, a `Householder transformation` (or an `elementary reflector`) is a linear transformation that describes a reflection about a plane or a hyperplane containing the origin.
+A **Householder transformation** (or an **elementary reflector**) is a linear transformation that describes a reflection about a plane or a hyperplane containing the origin.
 
 </section>
 
@@ -38,7 +38,7 @@ In linear algebra, a `Householder transformation` (or an `elementary reflector`)
 var dlarf1f = require( '@stdlib/lapack/base/dlarf1f' );
 ```
 
-#### dlarf1f( order, side, M, N, V, incv, tau, C, LDC, work )
+#### dlarf1f( order, side, M, N, V, strideV, tau, C, LDC, work )
 
 Applies a real elementary reflector `H = I - tau * v * v^T` to a real M by N matrix `C`.
 
@@ -58,11 +58,11 @@ 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**: specifies the side of multiplication with `C`. Use `'left'` to form `H * C` and `'right'` to form `C * H`.
+-   **side**: specifies the side of multiplication with `C`.
 -   **M**: number of rows in `C`.
 -   **N**: number of columns in `C`.
 -   **V**: the vector `v` as a [`Float64Array`][mdn-float64array].
--   **incv**: stride length for `V`. If `incv` is negative, the elements of `V` are accessed in reverse order.
+-   **strideV**: stride length for `V`. If `strideV` is negative, the elements of `V` are accessed in reverse order.
 -   **tau**: scalar constant.
 -   **C**: input matrix stored in linear memory as a [`Float64Array`][mdn-float64array].
 -   **LDC**: stride of the first dimension of `C` (a.k.a., leading dimension of the matrix `C`).
@@ -71,14 +71,16 @@ The function has the following parameters:
 When `side` is `'left'`,
 
 -   `work` should have `N` indexed elements.
--   `V` should have `1 + (M-1) * abs(incv)` indexed elements.
+-   `V` should have `1 + (M-1) * abs(strideV)` indexed elements.
+-   `C` is overwritten by `H * C`.
 
 When `side` is `'right'`,
 
 -   `work` should have `M` indexed elements.
--   `V` should have `1 + (N-1) * abs(incv)` indexed elements.
+-   `V` should have `1 + (N-1) * abs(strideV)` indexed elements.
+-   `C` is overwritten by `C * H`.
 
-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,
+The sign of the increment parameter `strideV` determines the order in which elements of `V` are accessed. For example, to access elements in reverse order,
 
 <!-- eslint-disable max-len -->
 
@@ -93,7 +95,7 @@ var out = dlarf1f( 'row-major', 'left', 4, 3, V, -1, 1.0, C, 3, work );
 // returns <Float64Array>[ ~-3.80, -8.6, ~-13.4, ~0.56, 1.92, ~3.28, ~1.08, ~1.56, ~2.04, ~1.60, ~1.20, ~0.80 ]
 ```
 
-To perform strided access over `V`, provide an `abs(incv)` value greater than one. For example, to access every other element in `V`,
+To perform strided access over `V`, provide an `abs(strideV)` value greater than one. For example, to access every other element in `V`,
 
 <!-- eslint-disable max-len -->
 
@@ -148,7 +150,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**: specifies the side of multiplication with `C`. Use `'left'` to form `H * C` and `'right'` to form `C * H`.
+-   **side**: specifies the side of multiplication with `C`.
 -   **M**: number of rows in `C`.
 -   **N**: number of columns in `C`.
 -   **V**: the vector `v` as a [`Float64Array`][mdn-float64array].
@@ -166,12 +168,14 @@ The function has the following additional parameters:
 When `side` is `'left'`,
 
 -   `work` should have `N` indexed elements.
--   `V` should have `1 + (M-1) * abs(incv)` indexed elements.
+-   `V` should have `1 + (M-1) * abs(sv)` indexed elements.
+-   `C` is overwritten by `H * C`.
 
 When `side` is `'right'`,
 
 -   `work` should have `M` indexed elements.
--   `V` should have `1 + (N-1) * abs(incv)` indexed elements.
+-   `V` should have `1 + (N-1) * abs(sv)` indexed elements.
+-   `C` is overwritten by `C * H`.
 
 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,
 
@@ -196,7 +200,6 @@ var out = dlarf1f.ndarray( 'left', 4, 3, V, 1, 2, 1.0, C, 3, 1, 4, work, 1, 0 );
 
 ## Notes
 
--   `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].
 
 </section>
@@ -226,7 +229,7 @@ var strides = shape2strides( shape, order );
 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 ] );
 console.log( ndarray2array( C, shape, strides, 0, order ) );
 
-// Define the vector `v` and workspace array:
+// Define the vector `v` and a workspace array:
 var V = new Float64Array( [ 0.5, 0.5, 0.5, 0.5 ] );
 var work = new Float64Array( 3 );
 

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

@@ -60,7 +60,7 @@ function createBenchmark( order, N, side ) {
 	var work = new Float64Array( N );
 	var C = discreteUniform( N*N, 1.0, 10.0, opts );
 	var V = new Float64Array( N );
-	V[ N-1 ] = 1.0; // keeping only the last element non zero to ensure maximum iterations but minimum overflow
+	V[ N-1 ] = 1.0; // keeping only the last element nonzero to ensure maximum iterations but minimum overflow
 	return benchmark;
 
 	/**

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

@@ -67,7 +67,7 @@ function createBenchmark( order, N, side ) {
 	work = new Float64Array( N );
 	C = discreteUniform( N*N, 1.0, 10.0, opts );
 	V = new Float64Array( N );
-	V[ N-1 ] = 1.0; // keeping only the last element non zero to ensure maximum iterations but minimum overflow
+	V[ N-1 ] = 1.0; // keeping only the last element nonzero to ensure maximum iterations but minimum overflow
 	if ( isColumnMajor( order ) ) {
 		sc1 = 1;
 		sc2 = N;

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

@@ -1,7 +1,19 @@
 
-{{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`.
+{{alias}}( order, side, M, N, V, strideV, tau, C, LDC, work )
+    Applies a real elementary reflector `H = I - tau * v * v^T` to a real M by N
+    matrix `C`.
+
+    If `side = 'left'`,
+
+    - `work` should have `N` indexed elements.
+    - `V` should have `1 + (M-1) * abs(strideV)` indexed elements.
+    - `C` is overwritten by `H * C`.
+
+    If `side = 'right'`,
+
+    - `work` should have `M` indexed elements.
+    - `V` should have `1 + (N-1) * abs(strideV)` indexed elements.
+    - `C` is overwritten by `C * H`.
 
     Parameters
     ----------
@@ -21,7 +33,7 @@
     V: Float64Array
         The vector `v`.
 
-    incv: integer
+    strideV: integer
         Stride length for `V`.
 
     tau: number
@@ -52,8 +64,20 @@
 
 
 {{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.
+
+    If `side = 'left'`,
+
+    - `work` should have `N` indexed elements.
+    - `V` should have `1 + (M-1) * abs(sv)` indexed elements.
+    - `C` is overwritten by `H * C`.
+
+    If `side = 'right'`,
+
+    - `work` should have `M` indexed elements.
+    - `V` should have `1 + (N-1) * abs(sv)` indexed elements.
+    - `C` is overwritten by `C * H`.
 
     Parameters
     ----------

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

@@ -18,10 +18,9 @@
 
 // TypeScript Version: 4.1
 
-/**
-* Must be either `'left'` or `'right'`.
-*/
-type Side = 'left' | 'right';
+/// <reference types="@stdlib/types"/>
+
+import { Layout, OperationSide } from '@stdlib/types/blas';
 
 /**
 * Interface describing `dlarf1f`.
@@ -30,14 +29,29 @@ interface Routine {
 	/**
 	* Applies a real elementary reflector `H = I - tau * v * v^T` to a real M by N matrix `C`.
 	*
-	* @param side - specifies the side of multiplication with `C`. Use `'left'` to form `H * C` and `'right'` to form `C * H`.
+	* ## Notes
+	*
+	* -   If `side = 'left'`,
+	*
+	*     -   `work` should have `N` indexed elements.
+	*     -   `V` should have `1 + (M-1) * abs(strideV)` indexed elements.
+	*     -   `C` is overwritten by `H * C`.
+	*
+	* -   If `side = 'right'`,
+	*
+	*     -   `work` should have `M` indexed elements.
+	*     -   `V` should have `1 + (N-1) * abs(strideV)` indexed elements.
+	*     -   `C` is overwritten by `C * H`.
+	*
+	* @param order - storage layout
+	* @param side - specifies the side of multiplication with `C`.
 	* @param M - number of rows in `C`
 	* @param N - number of columns in `C`
 	* @param V - the vector `v`
-	* @param incv - stride length for `V`
+	* @param strideV - stride length for `V`
 	* @param tau - scalar constant
 	* @param C - input matrix
-	* @param ldc - leading dimension of `C`
+	* @param ldc - stride of the first dimension of `C` (a.k.a., leading dimension of the matrix `C`)
 	* @param work - workspace array
 	* @returns `C * H` or `H * C`
 	*
@@ -48,15 +62,29 @@ interface Routine {
 	* var V = new Float64Array( [ 0.5, 0.5, 0.5, 0.5 ] );
 	* var work = new Float64Array( 3 );
 	*
-	* dlarf1f( 'left', 4, 3, V, 1, 1.0, C, 3, work );
+	* dlarf1f( 'row-major', 'left', 4, 3, V, 1, 1.0, C, 3, work );
 	* // returns <Float64Array>[ -4.5, -10.5, -16.5, -0.75, -1.75, -2.75, 0.25, -0.75, -1.75, 1.25,  0.25, -0.75 ]
 	*/
-	( side: Side, M: number, N: number, V: Float64Array, incv: number, tau: number, C: Float64Array, ldc: number, work: Float64Array ): Float64Array;
+	( order: Layout, side: OperationSide, M: number, N: number, V: Float64Array, strideV: number, tau: number, C: Float64Array, ldc: number, work: Float64Array ): Float64Array;
 
 	/**
 	* 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 - specifies the side of multiplication with `C`. Use `'left'` to form `H * C` and `'right'` to form `C * H`.
+	* ## Notes
+	*
+	* -   If `side = 'left'`,
+	*
+	*     -   `work` should have `N` indexed elements.
+	*     -   `V` should have `1 + (M-1) * abs(strideV)` indexed elements.
+	*     -   `C` is overwritten by `H * C`.
+	*
+	* -   If `side = 'right'`,
+	*
+	*     -   `work` should have `M` indexed elements.
+	*     -   `V` should have `1 + (N-1) * abs(strideV)` indexed elements.
+	*     -   `C` is overwritten by `C * H`.
+	*
+	* @param side - specifies the side of multiplication with `C`
 	* @param M - number of rows in `C`
 	* @param N - number of columns in `C`
 	* @param V - the vector `v`
@@ -82,20 +110,35 @@ interface Routine {
 	* dlarf1f.ndarray( 'left', 4, 3, V, 1, 0, 1.0, C, 3, 1, 0, work, 1, 0 );
 	* // returns <Float64Array>[ -4.5, -10.5, -16.5, -0.75, -1.75, -2.75, 0.25, -0.75, -1.75, 1.25,  0.25, -0.75 ]
 	*/
-	ndarray( side: Side, M: number, N: number, V: Float64Array, strideV: number, offsetV: number, tau: number, C: Float64Array, strideC1: number, strideC2: number, offsetC: number, work: Float64Array, strideWork: number, offsetWork: number ): Float64Array;
+	ndarray( side: OperationSide, M: number, N: number, V: Float64Array, strideV: number, offsetV: number, tau: number, C: Float64Array, strideC1: number, strideC2: number, offsetC: number, work: Float64Array, strideWork: number, offsetWork: number ): Float64Array;
 }
 
 /**
 * Applies a real elementary reflector `H = I - tau * v * v^T` to a real M by N matrix `C`.
 *
-* @param side - specifies the side of multiplication with `C`. Use `'left'` to form `H * C` and `'right'` to form `C * H`.
+* ## Notes
+*
+* -   If `side = 'left'`,
+*
+*     -   `work` should have `N` indexed elements.
+*     -   `V` should have `1 + (M-1) * abs(strideV)` indexed elements.
+*     -   `C` is overwritten by `H * C`.
+*
+* -   If `side = 'right'`,
+*
+*     -   `work` should have `M` indexed elements.
+*     -   `V` should have `1 + (N-1) * abs(strideV)` indexed elements.
+*     -   `C` is overwritten by `C * H`.
+*
+* @param order - storage layout
+* @param side - specifies the side of multiplication with `C`
 * @param M - number of rows in `C`
 * @param N - number of columns in `C`
 * @param V - the vector `v`
-* @param incv - stride length for `V`
+* @param strideV - stride length for `V`
 * @param tau - scalar constant
 * @param C - input matrix
-* @param ldc - leading dimension of `C`
+* @param ldc - stride of the first dimension of `C` (a.k.a., leading dimension of the matrix `C`)
 * @param work - workspace array
 * @returns `C * H` or `H * C`
 *
@@ -106,7 +149,7 @@ interface Routine {
 * var V = new Float64Array( [ 0.5, 0.5, 0.5, 0.5 ] );
 * var work = new Float64Array( 3 );
 *
-* dlarf1f( 'left', 4, 3, V, 1, 1.0, C, 3, work );
+* dlarf1f( 'row-major', 'left', 4, 3, V, 1, 1.0, C, 3, work );
 * // returns <Float64Array>[ -4.5, -10.5, -16.5, -0.75, -1.75, -2.75, 0.25, -0.75, -1.75, 1.25,  0.25, -0.75 ]
 *
 * @example