docs: update docs

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

@@ -112,7 +112,9 @@ The function has the following parameters:
 -   **N**: number of columns in `A`.
 -   **A**: input [`Float64Array`][mdn-float64array].
 -   **LDA**: stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`).
--   **work**: [`Float64Array`][mdn-float64array] used to compute the infinity norm, should have `M` indexed elements if computing the infinity norm otherwise it's fine to pass a dummy array.
+-   **work**: [`Float64Array`][mdn-float64array] used as a temporary workspace.
+
+`work` should have `N` indexed elements if calculating the one norm in a row-major layout and `M` indexed elements if calculating the infinity norm in column-major layout, in all other cases it is fine to pass a dummy [`Float64Array`][mdn-float64array].
 
 Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
 
@@ -175,10 +177,12 @@ The function has the following additional parameters:
 -   **strideA1**: stride of the first dimension of `A`.
 -   **strideA2**: stride of the second dimension of `A`.
 -   **offsetA**: starting index for `A`.
--   **work**: [`Float64Array`][mdn-float64array] used to compute the infinity norm, should have `M` indexed elements if computing the infinity norm otherwise it's fine to pass a dummy array.
+-   **work**: [`Float64Array`][mdn-float64array] used as a temporary workspace
 -   **strideWork**: stride length of `work`.
 -   **offsetWork**: starting index of `work`.
 
+`work` should have `N` indexed elements if calculating the one norm in a row-major layout and `M` indexed elements if calculating the infinity norm in column-major layout, in all other cases it is fine to pass a dummy [`Float64Array`][mdn-float64array].
+
 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 -->

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

@@ -30,8 +30,9 @@
         matrix `A`).
 
     work: Float64Array
-        Work array used to compute the infinity norm, should have `M` indexed
-        elements if computing the infinity norm otherwise pass a dummy array.
+        Temporary workspace array. `work` should have `N` indexed elements if
+        computing the one norm in row-major layout and `M` indexed elements
+        if computing infinity norm in column-major layout.
 
     Returns
     -------
@@ -82,8 +83,9 @@
         Starting index for `A`.
 
     work: Float64Array
-        Work array used to compute the infinity norm, should have `M` indexed
-        elements if computing the infinity norm otherwise pass a dummy array.
+        Temporary workspace array. `work` should have `N` indexed elements if
+        computing the one norm in row-major layout and `M` indexed elements
+        if computing infinity norm in column-major layout.
 
     sw: integer
         Stride length for `work`.

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

@@ -45,18 +45,18 @@ interface Routine {
 	*
 	* ## Notes
 	*
-	* -   use `norm` = `max`, to calculate the element with the largest absolute value
-	* -   use `norm` = `one`, to calculate the one norm
-	* -   use `norm` = `infinity`, to calculate the infinity norm
-	* -   use `norm` = `frobenius`, to calculate the frobenius norm
+	* -   use `norm` = `max` to calculate the element with the largest absolute value
+	* -   use `norm` = `one` to calculate the one norm, work should have `N` indexed elements if row-major layout is used
+	* -   use `norm` = `infinity` to calculate the infinity norm, work should have `M` indexed elements if column-major layout is used
+	* -   use `norm` = `frobenius` to calculate the frobenius norm
 	*
 	* @param order - storage layout
 	* @param norm - specifies the type of norm to be calculated
 	* @param M - number of rows in `A`
 	* @param N - number of columns in `A`
 	* @param A - input array
 	* @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
-	* @param work - only used to compute the infinity norm, should have `M` indexed elements if computing the infinity norm otherwise it's fine to pass a dummy array
+	* @param work - temporary workspace array
 	* @returns required norm value
 	*
 	* @example
@@ -75,10 +75,10 @@ interface Routine {
 	*
 	* ## Notes
 	*
-	* -   use `norm` = `max`, to calculate the element with the largest absolute value
-	* -   use `norm` = `one`, to calculate the one norm
-	* -   use `norm` = `infinity`, to calculate the infinity norm
-	* -   use `norm` = `frobenius`, to calculate the frobenius norm
+	* -   use `norm` = `max` to calculate the element with the largest absolute value
+	* -   use `norm` = `one` to calculate the one norm, work should have `N` indexed elements if row-major layout is used
+	* -   use `norm` = `infinity` to calculate the infinity norm, work should have `M` indexed elements if column-major layout is used
+	* -   use `norm` = `frobenius` to calculate the frobenius norm
 	*
 	* @param norm - specifies the type of norm to be calculated
 	* @param M - number of rows in `A`
@@ -87,7 +87,7 @@ interface Routine {
 	* @param strideA1 - stride of the first dimension of `A`
 	* @param strideA2 - stride of the second dimension of `A`
 	* @param offsetA - starting index of `A`
-	* @param work - only used to compute the infinity norm, should have `M` indexed elements if computing the infinity norm otherwise it's fine to pass a dummy array
+	* @param work - temporary workspace array
 	* @param strideWork - stride length of `work`
 	* @param offsetWork - starting index of `work`
 	* @returns required norm value
@@ -109,18 +109,18 @@ interface Routine {
 *
 * ## Notes
 *
-* -   use `norm` = `max`, to calculate the element with the largest absolute value
-* -   use `norm` = `one`, to calculate the one norm
-* -   use `norm` = `infinity`, to calculate the infinity norm
-* -   use `norm` = `frobenius`, to calculate the frobenius norm
+* -   use `norm` = `max` to calculate the element with the largest absolute value
+* -   use `norm` = `one` to calculate the one norm, work should have `N` indexed elements if row-major layout is used
+* -   use `norm` = `infinity` to calculate the infinity norm, work should have `M` indexed elements if column-major layout is used
+* -   use `norm` = `frobenius` to calculate the frobenius norm
 *
 * @param order - storage layout
 * @param norm - specifies the type of norm to be calculated
 * @param M - number of rows in `A`
 * @param N - number of columns in `A`
 * @param A - input array
 * @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
-* @param work - only used to compute the infinity norm, should have `M` indexed elements if computing the infinity norm otherwise it's fine to pass a dummy array
+* @param work - temporary workspace array
 * @returns required norm value
 *
 * @example

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

@@ -43,7 +43,7 @@ var abs = require( '@stdlib/math/base/special/abs' );
 * @param {integer} strideA1 - stride of the first dimension of `A`
 * @param {integer} strideA2 - stride of the second dimension of `A`
 * @param {NonNegativeInteger} offsetA - starting index of `A`
-* @param {Float64Array} work - work array, should have `N` indexed elements
+* @param {Float64Array} work - work array, should have `N` indexed elements if row-major layout is used
 * @param {integer} strideWork - stride length of `work`
 * @param {NonNegativeInteger} offsetWork - starting index of `work`
 * @returns {number} required norm value
@@ -180,7 +180,7 @@ function maxAbs( M, N, A, strideA1, strideA2, offsetA ) {
 * @param {integer} strideA1 - stride of the first dimension of `A`
 * @param {integer} strideA2 - stride of the second dimension of `A`
 * @param {NonNegativeInteger} offsetA - starting index of `A`
-* @param {Float64Array} work - work array, should have `M` indexed elements
+* @param {Float64Array} work - work array, should have `M` indexed elements if column-major layout is used
 * @param {integer} strideWork - stride length of `work`
 * @param {NonNegativeInteger} offsetWork - starting index of `work`
 * @returns {number} required norm value
@@ -268,30 +268,35 @@ function infinityNorm( M, N, A, strideA1, strideA2, offsetA, work, strideWork, o
 * // returns ~25.5
 */
 function frobeniusNorm( M, N, A, strideA1, strideA2, offsetA ) {
-	var value;
-	var ia1;
 	var out;
+	var da0;
+	var da1;
+	var S1;
+	var S2;
+	var ia;
 	var i;
 
 	out = new Float64Array( [ 0.0, 1.0 ] );
 
 	if ( isRowMajor( [ strideA1, strideA2 ] ) ) {
-		ia1 = offsetA;
-		for ( i = 0; i < M; i++ ) {
-			dlassq( N, A, strideA2, ia1, out[ 0 ], out[ 1 ], out, 1, 0 );
-			ia1 += strideA1;
-		}
-		value = out[ 0 ] * sqrt( out[ 1 ] );
+		S1 = M;
+		S2 = N;
+		da0 = strideA2;
+		da1 = strideA1;
 	} else {
-		ia1 = offsetA;
-		for ( i = 0; i < N; i++ ) {
-			dlassq( M, A, strideA1, ia1, out[ 0 ], out[ 1 ], out, 1, 0 );
-			ia1 += strideA2;
-		}
-		value = out[ 0 ] * sqrt( out[ 1 ] );
+		S1 = N;
+		S2 = M;
+		da0 = strideA1;
+		da1 = strideA2;
 	}
 
-	return value;
+	ia = offsetA;
+	for ( i = 0; i < S1; i++ ) {
+		dlassq( S2, A, da0, ia, out[ 0 ], out[ 1 ], out, 1, 0 );
+		ia += da1;
+	}
+
+	return out[ 0 ] * sqrt( out[ 1 ] );
 }
 
 
@@ -302,10 +307,10 @@ function frobeniusNorm( M, N, A, strideA1, strideA2, offsetA ) {
 *
 * ## Notes
 *
-* -   use `norm` = `max`, to calculate the element with the largest absolute value
-* -   use `norm` = `one`, to calculate the one norm
-* -   use `norm` = `infinity`, to calculate the infinity norm
-* -   use `norm` = `frobenius`, to calculate the frobenius norm
+* -   use `norm` = `max` to calculate the element with the largest absolute value
+* -   use `norm` = `one` to calculate the one norm, work should have `N` indexed elements if row-major layout is used
+* -   use `norm` = `infinity` to calculate the infinity norm, work should have `M` indexed elements if column-major layout is used
+* -   use `norm` = `frobenius` to calculate the frobenius norm
 *
 * @private
 * @param {string} norm - specifies the type of norm to be calculated
@@ -315,7 +320,7 @@ function frobeniusNorm( M, N, A, strideA1, strideA2, offsetA ) {
 * @param {integer} strideA1 - stride of the first dimension of `A`
 * @param {integer} strideA2 - stride of the second dimension of `A`
 * @param {NonNegativeInteger} offsetA - starting index of `A`
-* @param {Float64Array} work - only used to compute the infinity norm, should have `M` indexed elements if computing the infinity norm otherwise it's fine to pass a dummy array
+* @param {Float64Array} work - temporary workspace array
 * @param {integer} strideWork - stride length of `work`
 * @param {NonNegativeInteger} offsetWork - starting index of `work`
 * @returns {number} required norm value

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

@@ -37,10 +37,10 @@ var base = require( './base.js' );
 *
 * ## Notes
 *
-* -   use `norm` = `max`, to calculate the element with the largest absolute value
-* -   use `norm` = `one`, to calculate the one norm
-* -   use `norm` = `infinity`, to calculate the infinity norm
-* -   use `norm` = `frobenius`, to calculate the frobenius norm
+* -   use `norm` = `max` to calculate the element with the largest absolute value
+* -   use `norm` = `one` to calculate the one norm, work should have `N` indexed elements if row-major layout is used
+* -   use `norm` = `infinity` to calculate the infinity norm, work should have `M` indexed elements if column-major layout is used
+* -   use `norm` = `frobenius` to calculate the frobenius norm
 *
 * @private
 * @param {string} order - storage layout
@@ -49,7 +49,7 @@ var base = require( './base.js' );
 * @param {NonNegativeInteger} N - number of columns in `A`
 * @param {Float64Array} A - input array
 * @param {PositiveInteger} LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
-* @param {Float64Array} work - only used to compute the infinity norm, should have `M` indexed elements if computing the infinity norm otherwise it's fine to pass a dummy array
+* @param {Float64Array} work - temporary workspace array
 * @throws {TypeError} first argument must be a valid order
 * @throws {TypeError} second argument must be a valid operation
 * @throws {RangeError} sixth argument must be greater than or equal to max(1,N)

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

@@ -33,10 +33,10 @@ var base = require( './base.js' );
 *
 * ## Notes
 *
-* -   use `norm` = `max`, to calculate the element with the largest absolute value
-* -   use `norm` = `one`, to calculate the one norm
-* -   use `norm` = `infinity`, to calculate the infinity norm
-* -   use `norm` = `frobenius`, to calculate the frobenius norm
+* -   use `norm` = `max` to calculate the element with the largest absolute value
+* -   use `norm` = `one` to calculate the one norm, work should have `N` indexed elements if row-major layout is used
+* -   use `norm` = `infinity` to calculate the infinity norm, work should have `M` indexed elements if column-major layout is used
+* -   use `norm` = `frobenius` to calculate the frobenius norm
 *
 * @param {string} norm - specifies the type of norm to be calculated
 * @param {NonNegativeInteger} M - number of rows in `A`
@@ -45,7 +45,7 @@ var base = require( './base.js' );
 * @param {integer} strideA1 - stride of the first dimension of `A`
 * @param {integer} strideA2 - stride of the second dimension of `A`
 * @param {NonNegativeInteger} offsetA - starting index of `A`
-* @param {Float64Array} work - only used to compute the infinity norm, should have `M` indexed elements if computing the infinity norm otherwise it's fine to pass a dummy array
+* @param {Float64Array} work - temporary workspace array
 * @param {integer} strideWork - stride length of `work`
 * @param {NonNegativeInteger} offsetWork - starting index of `work`
 * @throws {TypeError} first argument must be a valid operation