chore: code review

aayush0325 · aayush0325 · commit b8653d790581 · 2025-08-27T22:54:39.000+05:30
diff --git a/lib/node_modules/@stdlib/lapack/base/dlarfb/README.md b/lib/node_modules/@stdlib/lapack/base/dlarfb/README.md
@@ -20,7 +20,7 @@ limitations under the License.
 
 # dlarfb
 
-> LAPACK routine to apply a real block reflector `H` or its transpose `H ^ T` to a real `M` by `N` matrix `C`, from either the left or the right.
+> LAPACK routine to apply a real block reflector `H` or its transpose `H^T` to a real `M` by `N` matrix `C`, from either the left or the right.
 
 <section class="usage">
 
@@ -34,7 +34,7 @@ var dlarfb = require( '@stdlib/lapack/base/dlarfb' );
 
 #### dlarfb( order, side, trans, direct, storev, M, N, K, V, LDV, T, LDT, C, LDC, work, LDWORK )
 
-Applies a real block reflector `H` or its transpose `H ^ T` to a real `M` by `N` matrix `C`, from either the left or the right.
+Applies a real block reflector `H` or its transpose `H^T` to a real `M` by `N` matrix `C`, from either the left or the right.
 
 <!-- eslint-disable max-len -->
 
@@ -53,10 +53,10 @@ dlarfb( 'row-major', 'left', 'transpose', 'forward', 'columns', 3, 3, 3, V, 3, T
 The function has the following parameters:
 
 -   **order**: storage layout (`'row-major'` or `'column-major'`).
--   **side**: specifies whether `H` or `H ^ T` is applied from the left or right (`'left'` or `'right'`).
--   **trans**: specifies whether to apply `H` or `H ^ T` (`'no-transpose'` or `'transpose'`).
+-   **side**: specifies whether `H` or `H^T` is applied from the left or right (`'left'` or `'right'`).
+-   **trans**: specifies whether to apply `H` or `H^T` (`'no-transpose'` or `'transpose'`).
 -   **direct**: indicates how `H` is formed from a product of elementary reflectors (`'forward'` or `'backward'`).
--   **storev**: indicates how the vectors which define the elementary reflectors are stored (`'column-major'` or `'row-major'`).
+-   **storev**: indicates how the vectors which define the elementary reflectors are stored (`'columns'` or `'rows'`).
 -   **M**: number of rows of the matrix `C`.
 -   **N**: number of columns of the matrix `C`.
 -   **K**: order of the matrix `T`.
@@ -73,7 +73,7 @@ The function applies the block reflector `H` to matrix `C` according to the spec
 
 #### dlarfb.ndarray( side, trans, direct, storev, M, N, K, V, strideV1, strideV2, offsetV, T, strideT1, strideT2, offsetT, C, strideC1, strideC2, offsetC, work, strideWork1, strideWork2, offsetWork )
 
-Applies a real block reflector `H` or its transpose `H ^ T` to a real `M` by `N` matrix `C`, from either the left or the right, using alternative indexing semantics.
+Applies a real block reflector `H` or its transpose `H^T` to a real `M` by `N` matrix `C`, from either the left or the right, using alternative indexing semantics.
 
 <!-- eslint-disable max-len -->
 
@@ -91,8 +91,8 @@ dlarfb.ndarray( 'left', 'transpose', 'forward', 'columns', 3, 3, 3, V, 3, 1, 0,
 
 The function has the following additional parameters:
 
--   **side**: specifies whether `H` or `H ^ T` is applied from the left or right (`'left'` or `'right'`).
--   **trans**: specifies whether to apply `H` or `H ^ T` (`'no-transpose'` or `'transpose'`).
+-   **side**: specifies whether `H` or `H^T` is applied from the left or right (`'left'` or `'right'`).
+-   **trans**: specifies whether to apply `H` or `H^T` (`'no-transpose'` or `'transpose'`).
 -   **direct**: indicates how `H` is formed from a product of elementary reflectors (`'forward'` or `'backward'`).
 -   **storev**: indicates how the vectors which define the elementary reflectors are stored (`'columns'` or `'rows'`).
 -   **M**: number of rows of the matrix `C`.
diff --git a/lib/node_modules/@stdlib/lapack/base/dlarfb/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/dlarfb/docs/repl.txt
@@ -1,5 +1,5 @@
 {{alias}}( o, si, tr, dir, sto, M, N, K, V, LDV, T, LDT, C, LDC, W, LDWORK )
-    Applies a real block reflector `H` or its transpose `H ^ T` to a real `M` by
+    Applies a real block reflector `H` or its transpose `H^T` to a real `M` by
     `N` matrix `C`, from either the left or the right.
 
     Indexing is relative to the first index. To introduce an offset, use typed
@@ -17,11 +17,11 @@
         either 'row-major' or 'column-major'.
 
     si: string
-        Specifies whether `H` or `H ^ T` is applied from the left or right.
+        Specifies whether `H` or `H^T` is applied from the left or right.
         Must be either 'left' or 'right'.
 
     tr: string
-        Specifies whether to apply `H` or `H ^ T`. Must be either
+        Specifies whether to apply `H` or `H^T`. Must be either
         'no-transpose' or 'transpose'.
 
     dir: string
@@ -86,7 +86,7 @@
 
 
 {{alias}}.ndarray(si,tr,dir,sto,M,N,K,V,sv1,sv2,ov,T,st1,st2,ot,C,sc1,sc2,oc,W,sw1,sw2,ow)
-    Applies a real block reflector `H` or its transpose `H ^ T` to a real `M` by
+    Applies a real block reflector `H` or its transpose `H^T` to a real `M` by
     `N` matrix `C`, from either the left or the right, using alternative
     indexing semantics.
 
@@ -97,11 +97,11 @@
     Parameters
     ----------
     si: string
-        Specifies whether `H` or `H ^ T` is applied from the left or right.
+        Specifies whether `H` or `H^T` is applied from the left or right.
         Must be either 'left' or 'right'.
 
     tr: string
-        Specifies whether to apply `H` or `H ^ T`. Must be either
+        Specifies whether to apply `H` or `H^T`. Must be either
         'no-transpose' or 'transpose'.
 
     dir: string
diff --git a/lib/node_modules/@stdlib/lapack/base/dlarfb/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/dlarfb/docs/types/index.d.ts
@@ -39,7 +39,7 @@ type Direction = 'forward' | 'backward';
 */
 interface Routine {
 	/**
-	* Applies a real block reflector `H` or its transpose `H ^ T` to a real `M` by `N` matrix `C`, from either the left or the right.
+	* Applies a real block reflector `H` or its transpose `H^T` to a real `M` by `N` matrix `C`, from either the left or the right.
 	*
 	* ## Notes
 	*
@@ -49,8 +49,8 @@ interface Routine {
 	* -   `work` is a double-precision array with dimension `(LDWORK,K)`.
 	*
 	* @param order - storage layout
-	* @param side - specifies whether `H` or `H ^ T` is applied from the left or right
-	* @param trans - specifies whether to apply `H` or `H ^ T`
+	* @param side - specifies whether `H` or `H^T` is applied from the left or right
+	* @param trans - specifies whether to apply `H` or `H^T`
 	* @param direct - indicates how `H` is formed from a product of elementary reflectors
 	* @param storev - indicates how the vectors which define the elementary reflectors are stored
 	* @param M - number of rows of the matrix `C`
@@ -81,7 +81,7 @@ interface Routine {
 	( order: Layout, side: OperationSide, trans: TransposeOperation, direct: Direction, storev: MatrixOrientation, M: number, N: number, K: number, V: Float64Array, LDV: number, T: Float64Array, LDT: number, C: Float64Array, LDC: number, work: Float64Array, LDWORK: number ): Float64Array;
 
 	/**
-	* Applies a real block reflector `H` or its transpose `H ^ T` to a real `M` by `N` matrix `C`, from either the left or the right.
+	* Applies a real block reflector `H` or its transpose `H^T` to a real `M` by `N` matrix `C`, from either the left or the right.
 	*
 	* ## Notes
 	*
@@ -90,8 +90,8 @@ interface Routine {
 	* -   `C` is a double-precision array with dimension `(LDC,N)`. On entry, the `M` by `N` matrix `C`. On exit, `C` is overwritten by the desired matrix product.
 	* -   `work` is a double-precision array with dimension `(LDWORK,K)`.
 	*
-	* @param side - specifies whether `H` or `H ^ T` is applied from the left or right
-	* @param trans - specifies whether to apply `H` or `H ^ T`
+	* @param side - specifies whether `H` or `H^T` is applied from the left or right
+	* @param trans - specifies whether to apply `H` or `H^T`
 	* @param direct - indicates how `H` is formed from a product of elementary reflectors
 	* @param storev - indicates how the vectors which define the elementary reflectors are stored
 	* @param M - number of rows of the matrix `C`
@@ -131,7 +131,7 @@ interface Routine {
 }
 
 /**
-* Applies a real block reflector `H` or its transpose `H ^ T` to a real `M` by `N` matrix `C`, from either the left or the right.
+* Applies a real block reflector `H` or its transpose `H^T` to a real `M` by `N` matrix `C`, from either the left or the right.
 *
 * ## Notes
 *
@@ -141,8 +141,8 @@ interface Routine {
 * -   `work` is a double-precision array with dimension `(LDWORK,K)`.
 *
 * @param order - storage layout
-* @param side - specifies whether `H` or `H ^ T` is applied from the left or right
-* @param trans - specifies whether to apply `H` or `H ^ T`
+* @param side - specifies whether `H` or `H^T` is applied from the left or right
+* @param trans - specifies whether to apply `H` or `H^T`
 * @param direct - indicates how `H` is formed from a product of elementary reflectors
 * @param storev - indicates how the vectors which define the elementary reflectors are stored
 * @param M - number of rows of the matrix `C`
diff --git a/lib/node_modules/@stdlib/lapack/base/dlarfb/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dlarfb/lib/base.js
@@ -35,7 +35,7 @@ var rightBackwardRows = require( './right_backward_rows.js' );
 // MAIN //
 
 /**
-* Applies a real block reflector `H` or its transpose `H ^ T` to a real `M` by `N` matrix `C`, from either the left or the right.
+* Applies a real block reflector `H` or its transpose `H^T` to a real `M` by `N` matrix `C`, from either the left or the right.
 *
 * ## Notes
 *
@@ -45,8 +45,8 @@ var rightBackwardRows = require( './right_backward_rows.js' );
 * -   `work` is a double-precision array with dimension `(LDWORK,K)`.
 *
 * @private
-* @param {string} side - specifies whether `H` or `H ^ T` is applied from the left or right
-* @param {string} trans - specifies whether to apply `H` or `H ^ T`
+* @param {string} side - specifies whether `H` or `H^T` is applied from the left or right
+* @param {string} trans - specifies whether to apply `H` or `H^T`
 * @param {string} direct - indicates how `H` is formed from a product of elementary reflectors
 * @param {string} storev - indicates how the vectors which define the elementary reflectors are stored
 * @param {NonNegativeInteger} M - number of rows of the matrix `C`
diff --git a/lib/node_modules/@stdlib/lapack/base/dlarfb/lib/dlarfb.js b/lib/node_modules/@stdlib/lapack/base/dlarfb/lib/dlarfb.js
@@ -34,7 +34,7 @@ var base = require( './base.js' );
 // MAIN //
 
 /**
-* Applies a real block reflector `H` or its transpose `H ^ T` to a real `M` by `N` matrix `C`, from either the left or the right.
+* Applies a real block reflector `H` or its transpose `H^T` to a real `M` by `N` matrix `C`, from either the left or the right.
 *
 * ## Notes
 *
@@ -44,8 +44,8 @@ var base = require( './base.js' );
 * -   `work` is a double-precision array with dimension `(LDWORK,K)`.
 *
 * @param {string} order - storage layout
-* @param {string} side - specifies whether `H` or `H ^ T` is applied from the left or right
-* @param {string} trans - specifies whether to apply `H` or `H ^ T` (`'no-transpose'` or `'transpose'`)
+* @param {string} side - specifies whether `H` or `H^T` is applied from the left or right
+* @param {string} trans - specifies whether to apply `H` or `H^T` (`'no-transpose'` or `'transpose'`)
 * @param {string} direct - indicates how `H` is formed from a product of elementary reflectors (`'forward'` or `'backward'`)
 * @param {string} storev - indicates how the vectors which define the elementary reflectors are stored (`'column-major'` or `'row-major'`)
 * @param {NonNegativeInteger} M - number of rows of the matrix `C`
diff --git a/lib/node_modules/@stdlib/lapack/base/dlarfb/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dlarfb/lib/index.js
@@ -19,7 +19,7 @@
 'use strict';
 
 /**
-* LAPACK routine to apply a real block reflector `H` or its transpose `H ^ T` to a real `M` by `N` matrix `C`, from either the left or the right.
+* LAPACK routine to apply a real block reflector `H` or its transpose `H^T` to a real `M` by `N` matrix `C`, from either the left or the right.
 *
 * ## Notes
 *
diff --git a/lib/node_modules/@stdlib/lapack/base/dlarfb/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlarfb/lib/ndarray.js
@@ -30,7 +30,7 @@ var base = require( './base.js' );
 // MAIN //
 
 /**
-* Applies a real block reflector `H` or its transpose `H ^ T` to a real `M` by `N` matrix `C`, from either the left or the right.
+* Applies a real block reflector `H` or its transpose `H^T` to a real `M` by `N` matrix `C`, from either the left or the right.
 *
 * ## Notes
 *
@@ -39,8 +39,8 @@ var base = require( './base.js' );
 * -   `C` is a double-precision array with dimension `(LDC,N)`. On entry, the `M` by `N` matrix `C`. On exit, `C` is overwritten by the desired matrix product.
 * -   `work` is a double-precision array with dimension `(LDWORK,K)`.
 *
-* @param {string} side - specifies whether `H` or `H ^ T` is applied from the left or right
-* @param {string} trans - specifies whether to apply `H` or `H ^ T`
+* @param {string} side - specifies whether `H` or `H^T` is applied from the left or right
+* @param {string} trans - specifies whether to apply `H` or `H^T`
 * @param {string} direct - indicates how `H` is formed from a product of elementary reflectors
 * @param {string} storev - indicates how the vectors which define the elementary reflectors are stored
 * @param {NonNegativeInteger} M - number of rows of the matrix `C`
diff --git a/lib/node_modules/@stdlib/lapack/base/dlarfb/package.json b/lib/node_modules/@stdlib/lapack/base/dlarfb/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@stdlib/lapack/base/dlarfb",
   "version": "0.0.0",
-  "description": "LAPACK routine to apply a real block reflector `H` or its transpose `H ^ T` to a real `M` by `N` matrix `C`, from either the left or the right.",
+  "description": "LAPACK routine to apply a real block reflector `H` or its transpose `H^T` to a real `M` by `N` matrix `C`, from either the left or the right.",
   "license": "Apache-2.0",
   "author": {
     "name": "The Stdlib Authors",

Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ type Direction = 'forward' \| 'backward';`
`39`	`39`	`*/`
`40`	`40`	`interface Routine {`
`41`	`41`	`/**`
`42`		- * Applies a real block reflector `H` or its transpose `H ^ T` to a real `M` by `N` matrix `C`, from either the left or the right.
	`42`	+ * Applies a real block reflector `H` or its transpose `H^T` to a real `M` by `N` matrix `C`, from either the left or the right.
`43`	`43`	`*`
`44`	`44`	`* ## Notes`
`45`	`45`	`*`
`@@ -49,8 +49,8 @@ interface Routine {`
`49`	`49`	* - `work` is a double-precision array with dimension `(LDWORK,K)`.
`50`	`50`	`*`
`51`	`51`	`* @param order - storage layout`
`52`		- * @param side - specifies whether `H` or `H ^ T` is applied from the left or right
`53`		- * @param trans - specifies whether to apply `H` or `H ^ T`
	`52`	+ * @param side - specifies whether `H` or `H^T` is applied from the left or right
	`53`	+ * @param trans - specifies whether to apply `H` or `H^T`
`54`	`54`	* @param direct - indicates how `H` is formed from a product of elementary reflectors
`55`	`55`	`* @param storev - indicates how the vectors which define the elementary reflectors are stored`
`56`	`56`	* @param M - number of rows of the matrix `C`
`@@ -81,7 +81,7 @@ interface Routine {`
`81`	`81`	`( order: Layout, side: OperationSide, trans: TransposeOperation, direct: Direction, storev: MatrixOrientation, M: number, N: number, K: number, V: Float64Array, LDV: number, T: Float64Array, LDT: number, C: Float64Array, LDC: number, work: Float64Array, LDWORK: number ): Float64Array;`
`82`	`82`
`83`	`83`	`/**`
`84`		- * Applies a real block reflector `H` or its transpose `H ^ T` to a real `M` by `N` matrix `C`, from either the left or the right.
	`84`	+ * Applies a real block reflector `H` or its transpose `H^T` to a real `M` by `N` matrix `C`, from either the left or the right.
`85`	`85`	`*`
`86`	`86`	`* ## Notes`
`87`	`87`	`*`
`@@ -90,8 +90,8 @@ interface Routine {`
`90`	`90`	* - `C` is a double-precision array with dimension `(LDC,N)`. On entry, the `M` by `N` matrix `C`. On exit, `C` is overwritten by the desired matrix product.
`91`	`91`	* - `work` is a double-precision array with dimension `(LDWORK,K)`.
`92`	`92`	`*`
`93`		- * @param side - specifies whether `H` or `H ^ T` is applied from the left or right
`94`		- * @param trans - specifies whether to apply `H` or `H ^ T`
	`93`	+ * @param side - specifies whether `H` or `H^T` is applied from the left or right
	`94`	+ * @param trans - specifies whether to apply `H` or `H^T`
`95`	`95`	* @param direct - indicates how `H` is formed from a product of elementary reflectors
`96`	`96`	`* @param storev - indicates how the vectors which define the elementary reflectors are stored`
`97`	`97`	* @param M - number of rows of the matrix `C`
`@@ -131,7 +131,7 @@ interface Routine {`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`/**`
`134`		-* Applies a real block reflector `H` or its transpose `H ^ T` to a real `M` by `N` matrix `C`, from either the left or the right.
	`134`	+* Applies a real block reflector `H` or its transpose `H^T` to a real `M` by `N` matrix `C`, from either the left or the right.
`135`	`135`	`*`
`136`	`136`	`* ## Notes`
`137`	`137`	`*`
`@@ -141,8 +141,8 @@ interface Routine {`
`141`	`141`	* - `work` is a double-precision array with dimension `(LDWORK,K)`.
`142`	`142`	`*`
`143`	`143`	`* @param order - storage layout`
`144`		-* @param side - specifies whether `H` or `H ^ T` is applied from the left or right
`145`		-* @param trans - specifies whether to apply `H` or `H ^ T`
	`144`	+* @param side - specifies whether `H` or `H^T` is applied from the left or right
	`145`	+* @param trans - specifies whether to apply `H` or `H^T`
`146`	`146`	* @param direct - indicates how `H` is formed from a product of elementary reflectors
`147`	`147`	`* @param storev - indicates how the vectors which define the elementary reflectors are stored`
`148`	`148`	* @param M - number of rows of the matrix `C`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ var rightBackwardRows = require( './right_backward_rows.js' );`
`35`	`35`	`// MAIN //`
`36`	`36`
`37`	`37`	`/**`
`38`		-* Applies a real block reflector `H` or its transpose `H ^ T` to a real `M` by `N` matrix `C`, from either the left or the right.
	`38`	+* Applies a real block reflector `H` or its transpose `H^T` to a real `M` by `N` matrix `C`, from either the left or the right.
`39`	`39`	`*`
`40`	`40`	`* ## Notes`
`41`	`41`	`*`
`@@ -45,8 +45,8 @@ var rightBackwardRows = require( './right_backward_rows.js' );`
`45`	`45`	* - `work` is a double-precision array with dimension `(LDWORK,K)`.
`46`	`46`	`*`
`47`	`47`	`* @private`
`48`		-* @param {string} side - specifies whether `H` or `H ^ T` is applied from the left or right
`49`		-* @param {string} trans - specifies whether to apply `H` or `H ^ T`
	`48`	+* @param {string} side - specifies whether `H` or `H^T` is applied from the left or right
	`49`	+* @param {string} trans - specifies whether to apply `H` or `H^T`
`50`	`50`	* @param {string} direct - indicates how `H` is formed from a product of elementary reflectors
`51`	`51`	`* @param {string} storev - indicates how the vectors which define the elementary reflectors are stored`
`52`	`52`	* @param {NonNegativeInteger} M - number of rows of the matrix `C`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ var base = require( './base.js' );`
`34`	`34`	`// MAIN //`
`35`	`35`
`36`	`36`	`/**`
`37`		-* Applies a real block reflector `H` or its transpose `H ^ T` to a real `M` by `N` matrix `C`, from either the left or the right.
	`37`	+* Applies a real block reflector `H` or its transpose `H^T` to a real `M` by `N` matrix `C`, from either the left or the right.
`38`	`38`	`*`
`39`	`39`	`* ## Notes`
`40`	`40`	`*`
`@@ -44,8 +44,8 @@ var base = require( './base.js' );`
`44`	`44`	* - `work` is a double-precision array with dimension `(LDWORK,K)`.
`45`	`45`	`*`
`46`	`46`	`* @param {string} order - storage layout`
`47`		-* @param {string} side - specifies whether `H` or `H ^ T` is applied from the left or right
`48`		-* @param {string} trans - specifies whether to apply `H` or `H ^ T` (`'no-transpose'` or `'transpose'`)
	`47`	+* @param {string} side - specifies whether `H` or `H^T` is applied from the left or right
	`48`	+* @param {string} trans - specifies whether to apply `H` or `H^T` (`'no-transpose'` or `'transpose'`)
`49`	`49`	* @param {string} direct - indicates how `H` is formed from a product of elementary reflectors (`'forward'` or `'backward'`)
`50`	`50`	* @param {string} storev - indicates how the vectors which define the elementary reflectors are stored (`'column-major'` or `'row-major'`)
`51`	`51`	* @param {NonNegativeInteger} M - number of rows of the matrix `C`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@`
`19`	`19`	`'use strict';`
`20`	`20`
`21`	`21`	`/**`
`22`		-* LAPACK routine to apply a real block reflector `H` or its transpose `H ^ T` to a real `M` by `N` matrix `C`, from either the left or the right.
	`22`	+* LAPACK routine to apply a real block reflector `H` or its transpose `H^T` to a real `M` by `N` matrix `C`, from either the left or the right.
`23`	`23`	`*`
`24`	`24`	`* ## Notes`
`25`	`25`	`*`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ var base = require( './base.js' );`
`30`	`30`	`// MAIN //`
`31`	`31`
`32`	`32`	`/**`
`33`		-* Applies a real block reflector `H` or its transpose `H ^ T` to a real `M` by `N` matrix `C`, from either the left or the right.
	`33`	+* Applies a real block reflector `H` or its transpose `H^T` to a real `M` by `N` matrix `C`, from either the left or the right.
`34`	`34`	`*`
`35`	`35`	`* ## Notes`
`36`	`36`	`*`
`@@ -39,8 +39,8 @@ var base = require( './base.js' );`
`39`	`39`	* - `C` is a double-precision array with dimension `(LDC,N)`. On entry, the `M` by `N` matrix `C`. On exit, `C` is overwritten by the desired matrix product.
`40`	`40`	* - `work` is a double-precision array with dimension `(LDWORK,K)`.
`41`	`41`	`*`
`42`		-* @param {string} side - specifies whether `H` or `H ^ T` is applied from the left or right
`43`		-* @param {string} trans - specifies whether to apply `H` or `H ^ T`
	`42`	+* @param {string} side - specifies whether `H` or `H^T` is applied from the left or right
	`43`	+* @param {string} trans - specifies whether to apply `H` or `H^T`
`44`	`44`	* @param {string} direct - indicates how `H` is formed from a product of elementary reflectors
`45`	`45`	`* @param {string} storev - indicates how the vectors which define the elementary reflectors are stored`
`46`	`46`	* @param {NonNegativeInteger} M - number of rows of the matrix `C`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "@stdlib/lapack/base/dlarfb",`
`3`	`3`	`"version": "0.0.0",`
`4`		- "description": "LAPACK routine to apply a real block reflector `H` or its transpose `H ^ T` to a real `M` by `N` matrix `C`, from either the left or the right.",
	`4`	+ "description": "LAPACK routine to apply a real block reflector `H` or its transpose `H^T` to a real `M` by `N` matrix `C`, from either the left or the right.",
`5`	`5`	`"license": "Apache-2.0",`
`6`	`6`	`"author": {`
`7`	`7`	`"name": "The Stdlib Authors",`