docs: update description

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

@@ -24,7 +24,7 @@ limitations under the License.
 
 <section class="intro">
 
-`dlartg` constructs a Givens rotation for a two-dimensional vector such that the following equation is satisfied:
+This routine constructs a Givens rotation for a two-dimensional vector such that the following equation is satisfied:
 
 
 <!-- <equation class="equation" label="eq:givens_rotation" align="center" raw="\begin{bmatrix} C & S \\ -S & C \end{bmatrix} \begin{bmatrix} F \\ G \end{bmatrix} = \begin{bmatrix} R \\ 0 \end{bmatrix}
@@ -71,11 +71,11 @@ dlartg( F, G, C, S, R );
 
 The function has the following parameters:
 
--   **F**: single element array representing the first component of the vector to be rotated as a [`Float64Array`][mdn-float64array].
--   **G**: single element array representing the second component of the vector to be rotated as a [`Float64Array`][mdn-float64array].
--   **C**: single element array overwritten by the cosine of the rotation as a [`Float64Array`][mdn-float64array].
--   **S**: single element array overwritten by the sine of the rotation as a [`Float64Array`][mdn-float64array].
--   **R**: single element array overwritten by the length of the rotated vector as a [`Float64Array`][mdn-float64array].
+-   **F**: [`Float64Array`][mdn-float64array] containing a single element representing the first component of the vector to be rotated.
+-   **G**: [`Float64Array`][mdn-float64array] containing a single element representing the second component of the vector to be rotated
+-   **C**: [`Float64Array`][mdn-float64array] containing a single element which is overwritten by the cosine of the rotation.
+-   **S**: [`Float64Array`][mdn-float64array] containing a single element which is overwritten by the sine of the rotation.
+-   **R**: [`Float64Array`][mdn-float64array] containing a single element which is overwritten by the length of the rotated vector.
 
 Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
 
@@ -125,16 +125,16 @@ dlartg.ndarray( F, 0, G, 0, C, 0, S, 0, R, 0 );
 
 The function has the following parameters:
 
--   **F**: single element array representing the first component of the vector to be rotated as a [`Float64Array`][mdn-float64array].
--   **offsetF**: starting index for `F`.
--   **G**: single element array representing the second component of the vector to be rotated as a [`Float64Array`][mdn-float64array].
--   **offsetG**: starting index for `G`.
--   **C**: single element array overwritten by the cosine of the rotation as a [`Float64Array`][mdn-float64array].
--   **offsetC**: starting index for `C`.
--   **S**: single element array overwritten by the sine of the rotation as a [`Float64Array`][mdn-float64array].
--   **offsetS**: starting index for `S`.
--   **R**: single element array overwritten by the length of the rotated vector as a [`Float64Array`][mdn-float64array].
--   **offsetR**: starting index for `R`.
+-   **F**: [`Float64Array`][mdn-float64array] containing a single element representing the first component of the vector to be rotated.
+-   **offsetF**: index of the element in `F`.
+-   **G**: [`Float64Array`][mdn-float64array] containing a single element representing the second component of the vector to be rotated.
+-   **offsetG**: index of the element in `G`.
+-   **C**: [`Float64Array`][mdn-float64array] containing a single element which is overwritten by the cosine of the rotation.
+-   **offsetC**: index of the element in `C`.
+-   **S**: [`Float64Array`][mdn-float64array] containing a single element which is overwritten by the sine of the rotation.
+-   **offsetS**: index of the element in `S`.
+-   **R**: [`Float64Array`][mdn-float64array] containing a single element which is overwritten by the length of the rotated vector.
+-   **offsetR**: index of the element in `R`.
 
 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,
 

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

@@ -64,31 +64,31 @@
         First component of the vector to be rotated.
 
     offsetF: integer
-        Starting index for `F`.
+        Index of the element in `F`.
 
     G: Float64Array
         Second component of the vector to be rotated.
 
     offsetG: integer
-        Starting index for `G`.
+        Index of the element in `G`.
 
     C: Float64Array
         Overwritten by the cosine of the rotation.
 
     offsetC: integer
-        Starting index for `C`.
+        Index of the element in `C`.
 
     S: Float64Array
         Overwritten by the sine of the rotation.
 
     offsetS: integer
-        Starting index for `S`.
+        Index of the element in `S`.
 
     R: Float64Array
         Overwritten by the length of the rotated vector.
 
     offsetR: integer
-        Starting index for `R`.
+        Index of the element in `R`.
 
     Returns
     -------

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

@@ -31,11 +31,11 @@ interface Routine {
 	* \(\begin{bmatrix} C & S \\ -S & C \end{bmatrix} \begin{bmatrix} F \\ G \end{bmatrix} = \begin{bmatrix} R \\ 0 \end{bmatrix}\)
 	* ```
 	*
-	* @param F - single element array representing the first component of the vector to be rotated
-	* @param G - single element array representing the second component of the vector to be rotated
-	* @param C - single element array overwritten by the cosine of the rotation
-	* @param S - single element array overwritten by the sine of the rotation
-	* @param R - single element array overwritten by the length of the rotated vector
+	* @param F - single element array containing the first component of the vector to be rotated
+	* @param G - single element array containing the second component of the vector to be rotated
+	* @param C - single element array which is overwritten by the cosine of the rotation
+	* @param S - single element array which is overwritten by the sine of the rotation
+	* @param R - single element array which is overwritten by the length of the rotated vector
 	* @returns {void}
 	*
 	* @example
@@ -63,16 +63,16 @@ interface Routine {
 	* \(\begin{bmatrix} C & S \\ -S & C \end{bmatrix} \begin{bmatrix} F \\ G \end{bmatrix} = \begin{bmatrix} R \\ 0 \end{bmatrix}\)
 	* ```
 	*
-	* @param F - single element array representing the first component of the vector to be rotated
-	* @param offsetF - starting index for `F`
-	* @param G - single element array representing the second component of the vector to be rotated
-	* @param offsetG - starting index for `G`
-	* @param C - single element array overwritten by the cosine of the rotation
-	* @param offsetC - starting index for `C`
-	* @param S - single element array overwritten by the sine of the rotation
-	* @param offsetS - starting index for `S`
-	* @param R - single element array overwritten by the length of the rotated vector
-	* @param offsetR - starting index for `R`
+	* @param F - single element array containing the first component of the vector to be rotated
+	* @param offsetF - index of the element in `F`
+	* @param G - single element array containing the second component of the vector to be rotated
+	* @param offsetG - index of the element in `G`
+	* @param C - single element array which is overwritten by the cosine of the rotation
+	* @param offsetC - index of the element in `C`
+	* @param S - single element array which is overwritten by the sine of the rotation
+	* @param offsetS - index of the element in `S`
+	* @param R - single element array which is overwritten by the length of the rotated vector
+	* @param offsetR - index of the element in `R`
 	* @returns {void}
 	*
 	* @example
@@ -101,11 +101,11 @@ interface Routine {
 * \(\begin{bmatrix} C & S \\ -S & C \end{bmatrix} \begin{bmatrix} F \\ G \end{bmatrix} = \begin{bmatrix} R \\ 0 \end{bmatrix}\)
 * ```
 *
-* @param F - single element array representing the first component of the vector to be rotated
-* @param G - single element array representing the second component of the vector to be rotated
-* @param C - single element array overwritten by the cosine of the rotation
-* @param S - single element array overwritten by the sine of the rotation
-* @param R - single element array overwritten by the length of the rotated vector
+* @param F - single element array containing the first component of the vector to be rotated
+* @param G - single element array containing the second component of the vector to be rotated
+* @param C - single element array which is overwritten by the cosine of the rotation
+* @param S - single element array which is overwritten by the sine of the rotation
+* @param R - single element array which is overwritten by the length of the rotated vector
 * @returns {void}
 *
 * @example

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

@@ -49,16 +49,16 @@ var rtmax = sqrt( safmax / 2.0 );
 * ```
 *
 * @private
-* @param {Float64Array} F - single element array representing the first component of the vector to be rotated
-* @param {NonNegativeInteger} offsetF - starting index for `F`
-* @param {Float64Array} G - single element array representing the second component of the vector to be rotated
-* @param {NonNegativeInteger} offsetG - starting index for `G`
-* @param {Float64Array} C - single element array overwritten by the cosine of the rotation
-* @param {NonNegativeInteger} offsetC - starting index for `C`
-* @param {Float64Array} S - single element array overwritten by the sine of the rotation
-* @param {NonNegativeInteger} offsetS - starting index for `S`
-* @param {Float64Array} R - single element array overwritten by the length of the rotated vector
-* @param {NonNegativeInteger} offsetR - starting index for `R`
+* @param {Float64Array} F - single element array containing the first component of the vector to be rotated
+* @param {NonNegativeInteger} offsetF - index of the element in `F`
+* @param {Float64Array} G - single element array containing the second component of the vector to be rotated
+* @param {NonNegativeInteger} offsetG - index of the element in `G`
+* @param {Float64Array} C - single element array which is overwritten by the cosine of the rotation
+* @param {NonNegativeInteger} offsetC - index of the element in `C`
+* @param {Float64Array} S - single element array which is overwritten by the sine of the rotation
+* @param {NonNegativeInteger} offsetS - index of the element in `S`
+* @param {Float64Array} R - single element array which is overwritten by the length of the rotated vector
+* @param {NonNegativeInteger} offsetR - index of the element in `R`
 * @returns {void}
 *
 * @example

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

@@ -34,11 +34,11 @@ var base = require( './base.js' );
 * \(\begin{bmatrix} C & S \\ -S & C \end{bmatrix} \begin{bmatrix} F \\ G \end{bmatrix} = \begin{bmatrix} R \\ 0 \end{bmatrix}\)
 * ```
 *
-* @param {Float64Array} F - single element array representing the first component of the vector to be rotated
-* @param {Float64Array} G - single element array representing the second component of the vector to be rotated
-* @param {Float64Array} C - single element array overwritten by the cosine of the rotation
-* @param {Float64Array} S - single element array overwritten by the sine of the rotation
-* @param {Float64Array} R - single element array overwritten by the length of the rotated vector
+* @param {Float64Array} F - single element array containing the first component of the vector to be rotated
+* @param {Float64Array} G - single element array containing the second component of the vector to be rotated
+* @param {Float64Array} C - single element array which is overwritten by the cosine of the rotation
+* @param {Float64Array} S - single element array which is overwritten by the sine of the rotation
+* @param {Float64Array} R - single element array which is overwritten by the length of the rotated vector
 * @returns {void}
 *
 * @example

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

@@ -34,16 +34,16 @@ var base = require( './base.js' );
 * \(\begin{bmatrix} C & S \\ -S & C \end{bmatrix} \begin{bmatrix} F \\ G \end{bmatrix} = \begin{bmatrix} R \\ 0 \end{bmatrix}\)
 * ```
 *
-* @param {Float64Array} F - single element array representing the first component of the vector to be rotated
-* @param {NonNegativeInteger} offsetF - starting index for `F`
-* @param {Float64Array} G - single element array representing the second component of the vector to be rotated
-* @param {NonNegativeInteger} offsetG - starting index for `G`
-* @param {Float64Array} C - single element array overwritten by the cosine of the rotation
-* @param {NonNegativeInteger} offsetC - starting index for `C`
-* @param {Float64Array} S - single element array overwritten by the sine of the rotation
-* @param {NonNegativeInteger} offsetS - starting index for `S`
-* @param {Float64Array} R - single element array overwritten by the length of the rotated vector
-* @param {NonNegativeInteger} offsetR - starting index for `R`
+* @param {Float64Array} F - single element array containing the first component of the vector to be rotated
+* @param {NonNegativeInteger} offsetF - index of the element in `F`
+* @param {Float64Array} G - single element array containing the second component of the vector to be rotated
+* @param {NonNegativeInteger} offsetG - index of the element in `G`
+* @param {Float64Array} C - single element array which is overwritten by the cosine of the rotation
+* @param {NonNegativeInteger} offsetC - index of the element in `C`
+* @param {Float64Array} S - single element array which is overwritten by the sine of the rotation
+* @param {NonNegativeInteger} offsetS - index of the element in `S`
+* @param {Float64Array} R - single element array which is overwritten by the length of the rotated vector
+* @param {NonNegativeInteger} offsetR - index of the element in `R`
 * @returns {void}
 *
 * @example