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

@@ -20,7 +20,7 @@ limitations under the License.
 
 # dlarfg
 
-> LAPACK routine to generate a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; x]` zeros out `X`.
+> LAPACK routine to generate a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; X]` zeros out `X`.
 
 <section class="usage">
 
@@ -32,7 +32,7 @@ var dlarfg = require( '@stdlib/lapack/base/dlarfg' );
 
 #### dlarfg( N, X, incx, out )
 
-Generates a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; x]` zeros out `X`.
+Generates a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; X]` zeros out `X`.
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
@@ -48,9 +48,9 @@ dlarfg( 4, X, 1, out );
 The function has the following parameters:
 
 -   **N**: number of rows/columns of the elementary reflector `H`.
--   **X**: overwritten by the vector `V` on exit, expects `N - 1` indexed elements [`Float64Array`][mdn-float64array].
+-   **X**: a [`Float64Array`][mdn-float64array] which is overwritten by the vector `V`. Should have `N - 1` indexed elements.
 -   **incx**: stride length of `X`.
--   **out**: output [`Float64Array`][mdn-float64array], the first element of `out` represents alpha and the second element of `out` represents `tau`.
+-   **out**: output [`Float64Array`][mdn-float64array]. The first element of `out` represents alpha and the second element of `out` represents `tau`.
 
 Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
 
@@ -74,7 +74,7 @@ dlarfg( 4, X1, 1, out1 );
 
 #### dlarfg.ndarray( N, X, strideX, offsetX, out, strideOut, offsetOut )
 
-Generates a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; x]` zeros out `X` using alternative indexing semantics.
+Generates a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; X]` zeros out `X` using alternative indexing semantics.
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
@@ -90,10 +90,10 @@ dlarfg.ndarray( 4, X, 1, 0, out, 1, 0 );
 The function has the following parameters:
 
 -   **N**: number of rows/columns of the elementary reflector `H`.
--   **X**: overwritten by the vector `V` on exit, expects `N - 1` indexed elements [`Float64Array`][mdn-float64array].
+-   **X**: a [`Float64Array`][mdn-float64array] which is overwritten by the vector `V`. Should have `N - 1` indexed elements.
 -   **strideX**: stride length of `X`.
 -   **offsetX**: starting index of `X`.
--   **out**: output [`Float64Array`][mdn-float64array], the first element of `out` represents alpha and the second element of `out` represents `tau`.
+-   **out**: output [`Float64Array`][mdn-float64array]. The first element of `out` represents alpha and the second element of `out` represents `tau`.
 -   **strideOut**: stride length of `out`.
 -   **offsetOut**: starting index of `out`.
 
@@ -118,9 +118,9 @@ dlarfg.ndarray( 4, X, 1, 1, out, 1, 1 );
 
 ## Notes
 
--   `H` is a Householder matrix with the form `H = I - tau * [1; v] * [1, v^T]`, where `tau` is a scalar and `v` is a vector.
--   the input vector is `[alpha; x]`, where `alpha` is a scalar and `X` is a real `(n-1)`-element vector.
--   the result of applying `H` to `[alpha; x]` is `[beta; 0]`, with `beta` being a scalar and the rest of the vector zeroed.
+-   `H` is a Householder matrix with the form `H = I - tau * [1; V] * [1, V^T]`, where `tau` is a scalar and `V` is a vector.
+-   the input vector is `[alpha; X]`, where `alpha` is a scalar and `X` is a real `(n-1)`-element vector.
+-   the result of applying `H` to `[alpha; X]` is `[beta; 0]`, with `beta` being a scalar and the rest of the vector zeroed.
 -   if all elements of `X` are zero, then `tau = 0` and `H` is the identity matrix.
 -   otherwise, `1 <= tau <= 2`
 -   `dlarfg()` corresponds to the [LAPACK][lapack] routine [`dlarfg`][lapack-dlarfg].

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

@@ -1,12 +1,12 @@
 
 {{alias}}( N, X, incx, out )
     Generates a real elementary reflector `H` of order `N` such that applying
-    `H` to a vector `[alpha; x]` zeros out `X`.
+    `H` to a vector `[alpha; X]` zeros out `X`.
 
-    `H` is a Householder matrix with the form `H = I - tau * [1; v] * [1, v^T]`,
-    where `tau` is a scalar and `v` is a vector. The input vector is
-    `[alpha; x]`, where `alpha` is a scalar and `X` is a real `(n-1)`-element
-    vector. The result of applying `H` to `[alpha; x]` is `[beta; 0]`, with
+    `H` is a Householder matrix with the form `H = I - tau * [1; V] * [1, V^T]`,
+    where `tau` is a scalar and `V` is a vector. The input vector is
+    `[alpha; X]`, where `alpha` is a scalar and `X` is a real `(n-1)`-element
+    vector. The result of applying `H` to `[alpha; X]` is `[beta; 0]`, with
     `beta` being a scalar and the rest of the vector zeroed. If all elements of
     `X` are zero, then `tau = 0` and `H` is the identity matrix. Otherwise,
     `1 <= tau <= 2`.
@@ -43,12 +43,12 @@
 
 {{alias}}.ndarray( N, X, strideX, offsetX, out, strideOut, offsetOut )
     Generates a real elementary reflector `H` of order `N` such that applying
-    `H` to a vector `[alpha; x]` zeros out `X`.
+    `H` to a vector `[alpha; X]` zeros out `X`.
 
-    `H` is a Householder matrix with the form `H = I - tau * [1; v] * [1, v^T]`,
-    where `tau` is a scalar and `v` is a vector. The input vector is
-    `[alpha; x]`, where `alpha` is a scalar and `X` is a real `(n-1)`-element
-    vector. The result of applying `H` to `[alpha; x]` is `[beta; 0]`, with
+    `H` is a Householder matrix with the form `H = I - tau * [1; V] * [1, V^T]`,
+    where `tau` is a scalar and `V` is a vector. The input vector is
+    `[alpha; X]`, where `alpha` is a scalar and `X` is a real `(n-1)`-element
+    vector. The result of applying `H` to `[alpha; X]` is `[beta; 0]`, with
     `beta` being a scalar and the rest of the vector zeroed. If all elements of
     `X` are zero, then `tau = 0` and `H` is the identity matrix. Otherwise,
     `1 <= tau <= 2`.

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

@@ -23,13 +23,13 @@
 */
 interface Routine {
 	/**
-	* Generates a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; x]` zeros out `X`.
+	* Generates a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; X]` zeros out `X`.
 	*
 	* ## Notes
 	*
-	* -   `H` is a Householder matrix with the form `H = I - tau * [1; v] * [1, v^T]`, where `tau` is a scalar and `v` is a vector.
-	* -   the input vector is `[alpha; x]`, where `alpha` is a scalar and `X` is a real `(n-1)`-element vector.
-	* -   the result of applying `H` to `[alpha; x]` is `[beta; 0]`, with `beta` being a scalar and the rest of the vector zeroed.
+	* -   `H` is a Householder matrix with the form `H = I - tau * [1; V] * [1, V^T]`, where `tau` is a scalar and `V` is a vector.
+	* -   the input vector is `[alpha; X]`, where `alpha` is a scalar and `X` is a real `(n-1)`-element vector.
+	* -   the result of applying `H` to `[alpha; X]` is `[beta; 0]`, with `beta` being a scalar and the rest of the vector zeroed.
 	* -   if all elements of `X` are zero, then `tau = 0` and `H` is the identity matrix.
 	* -   otherwise, `1 <= tau <= 2`
 	*
@@ -52,13 +52,13 @@ interface Routine {
 	( N: number, X: Float64Array, incx: number, out: Float64Array ): void;
 
 	/**
-	* Generates a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; x]` zeros out `X`.
+	* Generates a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; X]` zeros out `X`.
 	*
 	* ## Notes
 	*
-	* -   `H` is a Householder matrix with the form `H = I - tau * [1; v] * [1, v^T]`, where `tau` is a scalar and `v` is a vector.
-	* -   the input vector is `[alpha; x]`, where `alpha` is a scalar and `X` is a real `(n-1)`-element vector.
-	* -   the result of applying `H` to `[alpha; x]` is `[beta; 0]`, with `beta` being a scalar and the rest of the vector zeroed.
+	* -   `H` is a Householder matrix with the form `H = I - tau * [1; V] * [1, V^T]`, where `tau` is a scalar and `V` is a vector.
+	* -   the input vector is `[alpha; X]`, where `alpha` is a scalar and `X` is a real `(n-1)`-element vector.
+	* -   the result of applying `H` to `[alpha; X]` is `[beta; 0]`, with `beta` being a scalar and the rest of the vector zeroed.
 	* -   if all elements of `X` are zero, then `tau = 0` and `H` is the identity matrix.
 	* -   otherwise, `1 <= tau <= 2`
 	*
@@ -85,13 +85,13 @@ interface Routine {
 }
 
 /**
-* Generates a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; x]` zeros out `X`.
+* Generates a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; X]` zeros out `X`.
 *
 * ## Notes
 *
-* -   `H` is a Householder matrix with the form `H = I - tau * [1; v] * [1, v^T]`, where `tau` is a scalar and `v` is a vector.
-* -   the input vector is `[alpha; x]`, where `alpha` is a scalar and `X` is a real `(n-1)`-element vector.
-* -   the result of applying `H` to `[alpha; x]` is `[beta; 0]`, with `beta` being a scalar and the rest of the vector zeroed.
+* -   `H` is a Householder matrix with the form `H = I - tau * [1; V] * [1, V^T]`, where `tau` is a scalar and `V` is a vector.
+* -   the input vector is `[alpha; X]`, where `alpha` is a scalar and `X` is a real `(n-1)`-element vector.
+* -   the result of applying `H` to `[alpha; X]` is `[beta; 0]`, with `beta` being a scalar and the rest of the vector zeroed.
 * -   if all elements of `X` are zero, then `tau = 0` and `H` is the identity matrix.
 * -   otherwise, `1 <= tau <= 2`
 *

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

@@ -31,13 +31,13 @@ var dlapy2 = require( '@stdlib/lapack/base/dlapy2' );
 // MAIN //
 
 /**
-* Generates a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; x]` zeros out `X`.
+* Generates a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; X]` zeros out `X`.
 *
 * ## Notes
 *
-* -   `H` is a Householder matrix with the form `H = I - tau * [1; v] * [1, v^T]`, where `tau` is a scalar and `v` is a vector.
-* -   the input vector is `[alpha; x]`, where `alpha` is a scalar and `X` is a real `(n-1)`-element vector.
-* -   the result of applying `H` to `[alpha; x]` is `[beta; 0]`, with `beta` being a scalar and the rest of the vector zeroed.
+* -   `H` is a Householder matrix with the form `H = I - tau * [1; V] * [1, V^T]`, where `tau` is a scalar and `V` is a vector.
+* -   the input vector is `[alpha; X]`, where `alpha` is a scalar and `X` is a real `(n-1)`-element vector.
+* -   the result of applying `H` to `[alpha; X]` is `[beta; 0]`, with `beta` being a scalar and the rest of the vector zeroed.
 * -   if all elements of `X` are zero, then `tau = 0` and `H` is the identity matrix.
 * -   otherwise, `1 <= tau <= 2`
 *
@@ -49,7 +49,7 @@ var dlapy2 = require( '@stdlib/lapack/base/dlapy2' );
 * @param {Float64Array} out - array to store `alpha` and `tau`, first indexed element stores `alpha` and the second indexed element stores `tau`
 * @param {integer} strideOut - stride length for `out`
 * @param {NonNegativeInteger} offsetOut - starting index of `out`
-* @returns {void} overwrites the array `X` and `out` in place
+* @returns {void}
 *
 * @example
 * var Float64Array = require( '@stdlib/array/float64' );
@@ -72,40 +72,37 @@ function dlarfg( N, X, strideX, offsetX, out, strideOut, offsetOut ) {
 	var i;
 
 	if ( N <= 1 ) {
-		tau = 0.0; // tau = 0.0
-		out[ offsetOut + strideOut ] = tau;
+		out[ offsetOut + strideOut ] = 0.0;
 		return;
 	}
 
 	xnorm = dnrm2( N - 1, X, strideX, offsetX );
 	alpha = out[ offsetOut ];
 
 	if ( xnorm === 0.0 ) {
-		tau = 0.0; // tau = 0.0
-		out[ strideOut + offsetOut ] = tau;
+		out[ strideOut + offsetOut ] = 0.0;
 	} else {
 		beta = -1.0 * sign( dlapy2( alpha, xnorm ), alpha );
-		safemin = dlamch( 'S' ) / dlamch( 'E' );
+		safemin = dlamch( 'safemin' ) / dlamch( 'epsilon' );
 		knt = 0;
 		if ( abs( beta ) < safemin ) {
 			rsafmin = 1.0 / safemin;
 			while ( abs( beta ) < safemin && knt < 20 ) {
 				knt += 1;
 				dscal( N-1, rsafmin, X, strideX, offsetX );
 				beta *= rsafmin;
-				alpha *= rsafmin; // alpha *= rsafmin
+				alpha *= rsafmin;
 			}
 			xnorm = dnrm2( N - 1, X, strideX, offsetX );
 			beta = -1.0 * sign( dlapy2( alpha, xnorm ), alpha );
 		}
-		tau = ( beta - alpha ) / beta; // tau = (beta - alpha) / beta
+		tau = ( beta - alpha ) / beta;
 		dscal( N-1, 1.0 / ( alpha - beta ), X, strideX, offsetX );
 		for ( i = 0; i < knt; i++ ) {
 			beta *= safemin;
 		}
-		alpha = beta;
 
-		out[ offsetOut ] = alpha;
+		out[ offsetOut ] = beta;
 		out[ strideOut + offsetOut ] = tau;
 	}
 }

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

@@ -26,21 +26,21 @@ var base = require( './base.js' );
 // MAIN //
 
 /**
-* Generates a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; x]` zeros out `X`.
+* Generates a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; X]` zeros out `X`.
 *
 * ## Notes
 *
-* -   `H` is a Householder matrix with the form `H = I - tau * [1; v] * [1, v^T]`, where `tau` is a scalar and `v` is a vector.
-* -   the input vector is `[alpha; x]`, where `alpha` is a scalar and `X` is a real `(n-1)`-element vector.
-* -   the result of applying `H` to `[alpha; x]` is `[beta; 0]`, with `beta` being a scalar and the rest of the vector zeroed.
+* -   `H` is a Householder matrix with the form `H = I - tau * [1; V] * [1, V^T]`, where `tau` is a scalar and `V` is a vector.
+* -   the input vector is `[alpha; X]`, where `alpha` is a scalar and `X` is a real `(n-1)`-element vector.
+* -   the result of applying `H` to `[alpha; X]` is `[beta; 0]`, with `beta` being a scalar and the rest of the vector zeroed.
 * -   if all elements of `X` are zero, then `tau = 0` and `H` is the identity matrix.
 * -   otherwise, `1 <= tau <= 2`
 *
 * @param {NonNegativeInteger} N - number of rows/columns of the elementary reflector `H`
 * @param {Float64Array} X - overwritten by the vector `V` on exit, expects `N - 1` indexed elements
 * @param {integer} incx - stride length for `X`
 * @param {Float64Array} out - array to store `alpha` and `tau`, first indexed element stores `alpha` and the second indexed element stores `tau`
-* @returns {void} overwrites the array `X` and `out` in place
+* @returns {void}
 *
 * @example
 * var Float64Array = require( '@stdlib/array/float64' );

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

@@ -19,13 +19,13 @@
 'use strict';
 
 /**
-* LAPACK routine to generate a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; x]` zeros out `X`.
+* LAPACK routine to generate a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; X]` zeros out `X`.
 *
 * ## Notes
 *
-* -   `H` is a Householder matrix with the form `H = I - tau * [1; v] * [1, v^T]`, where `tau` is a scalar and `v` is a vector.
-* -   the input vector is `[alpha; x]`, where `alpha` is a scalar and `X` is a real `(n-1)`-element vector.
-* -   the result of applying `H` to `[alpha; x]` is `[beta; 0]`, with `beta` being a scalar and the rest of the vector zeroed.
+* -   `H` is a Householder matrix with the form `H = I - tau * [1; V] * [1, V^T]`, where `tau` is a scalar and `V` is a vector.
+* -   the input vector is `[alpha; X]`, where `alpha` is a scalar and `X` is a real `(n-1)`-element vector.
+* -   the result of applying `H` to `[alpha; X]` is `[beta; 0]`, with `beta` being a scalar and the rest of the vector zeroed.
 * -   if all elements of `X` are zero, then `tau = 0` and `H` is the identity matrix.
 * -   otherwise, `1 <= tau <= 2`
 *

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

@@ -26,13 +26,13 @@ var base = require( './base.js' );
 // MAIN //
 
 /**
-* Generates a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; x]` zeros out `X` using alternative indexing semantics.
+* Generates a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; X]` zeros out `X` using alternative indexing semantics.
 *
 * ## Notes
 *
-* -   `H` is a Householder matrix with the form `H = I - tau * [1; v] * [1, v^T]`, where `tau` is a scalar and `v` is a vector.
-* -   the input vector is `[alpha; x]`, where `alpha` is a scalar and `X` is a real `(n-1)`-element vector.
-* -   the result of applying `H` to `[alpha; x]` is `[beta; 0]`, with `beta` being a scalar and the rest of the vector zeroed.
+* -   `H` is a Householder matrix with the form `H = I - tau * [1; V] * [1, V^T]`, where `tau` is a scalar and `V` is a vector.
+* -   the input vector is `[alpha; X]`, where `alpha` is a scalar and `X` is a real `(n-1)`-element vector.
+* -   the result of applying `H` to `[alpha; X]` is `[beta; 0]`, with `beta` being a scalar and the rest of the vector zeroed.
 * -   if all elements of `X` are zero, then `tau = 0` and `H` is the identity matrix.
 * -   otherwise, `1 <= tau <= 2`
 *
@@ -43,7 +43,7 @@ var base = require( './base.js' );
 * @param {Float64Array} out - array to store `alpha` and `tau`, first indexed element stores `alpha` and the second indexed element stores `tau`
 * @param {integer} strideOut - stride length for `out`
 * @param {NonNegativeInteger} offsetOut - starting index of `out`
-* @returns {void} overwrites the array `X` and `out` in place
+* @returns {void}
 *
 * @example
 * var Float64Array = require( '@stdlib/array/float64' );

lib/node_modules/@stdlib/lapack/base/dlarfg/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stdlib/lapack/base/dlarfg",
   "version": "0.0.0",
-  "description": "LAPACK routine to generate a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; x]` zeros out `X`.",
+  "description": "LAPACK routine to generate a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; X]` zeros out `X`.",
   "license": "Apache-2.0",
   "author": {
     "name": "The Stdlib Authors",