docs: improve documentation description

Author: ShabiShett07

lib/node_modules/@stdlib/blas/base/dtrmm/README.md

@@ -33,7 +33,7 @@ var dtrmm = require( '@stdlib/blas/base/dtrmm' );
 
 #### dtrmm( order, side, uplo, transa, diag, M, N, α, A, LDA, B, LDB )
 
-Performs one of the matrix-matrix operations `B = α * op(A) * B` or `B = α * B * op(A)` where `α` is a scalar, `B` is an `M` by `N` matrix, `A` is a unit, or non-unit, upper or lower triangular matrix and `op( A )` is one of `op( A ) = A` or `op( A ) = A**T`.
+Performs one of the matrix-matrix operations `B = α * op(A) * B` or `B = α * B * op(A)` where `α` is a scalar, `B` is an `M` by `N` matrix, `A` is a unit, or non-unit, upper or lower triangular matrix and `op( A )` is one of `op( A ) = A` or `op( A ) = A^T`.
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
@@ -49,8 +49,8 @@ The function has the following parameters:
 
 -   **order**: storage layout of `A` and `B`.
 -   **side**: specifies whether `op( A )` appears on the left or right side of `B`.
--   **uplo**: specifies whether the upper or lower triangular part of the matrix `A` is supplied.
--   **transa**: specifies the form of `op( A )` to be used in the matrix multiplication.
+-   **uplo**: specifies whether the upper or lower triangular part of the matrix `A` should be referenced.
+-   **transa**: specifies whether `A` should be transposed, conjugate-transposed, or not transposed.
 -   **diag**: specifies whether or not `A` is unit triangular.
 -   **M**: number of rows in `B`.
 -   **N**: number of columns in `B`.
@@ -81,7 +81,7 @@ dtrmm( 'row-major', 'left', 'lower', 'no-transpose', 'unit', 3, 3, 1.0, A1, 3, B
 
 #### dtrmm.ndarray( s, ul, t, d, M, N, α, A, sa1, sa2, oa, B, sb1, sb2, ob )
 
-Performs one of the matrix-matrix operations `B = α * op(A) * B` or `B = α * B * op(A)`, using alternative indexing semantics and where `α` is a scalar, `B` is an `M` by `N` matrix, `A` is a unit, or non-unit, upper or lower triangular matrix and `op( A )` is one of `op( A ) = A` or `op( A ) = A**T`.
+Performs one of the matrix-matrix operations `B = α * op(A) * B` or `B = α * B * op(A)`, using alternative indexing semantics and where `α` is a scalar, `B` is an `M` by `N` matrix, `A` is a unit, or non-unit, upper or lower triangular matrix and `op( A )` is one of `op( A ) = A` or `op( A ) = A^T`.
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
@@ -96,8 +96,8 @@ dtrmm.ndarray( 'left', 'lower', 'no-transpose', 'unit', 3, 3, 1.0, A, 3, 1, 0, B
 The function has the following parameters:
 
 -   **side**: specifies whether `op( A )` appears on the left or right side of `B`.
--   **uplo**: specifies whether the upper or lower triangular part of the matrix `A` is supplied.
--   **transa**: specifies the form of `op( A )` to be used in the matrix multiplication.
+-   **uplo**: specifies whether the upper or lower triangular part of the matrix `A` should be referenced.
+-   **transa**: specifies whether `A` should be transposed, conjugate-transposed, or not transposed.
 -   **diag**: specifies whether or not `A` is unit triangular.
 -   **M**: number of rows in `B`.
 -   **N**: number of columns in `B`.

lib/node_modules/@stdlib/blas/base/dtrmm/docs/repl.txt

@@ -3,7 +3,7 @@
     Performs one of the matrix-matrix operations `B = α * op(A) * B` or
     `B = α * B * op(A)` where `α` is a scalar, `B` is an `M` by `N` matrix, `A`
     is a unit, or non-unit, upper or lower triangular matrix and `op( A )` is
-    one of `op( A ) = A` or `op( A ) = A**T`.
+    one of `op( A ) = A` or `op( A ) = A^T`.
 
     Indexing is relative to the first index. To introduce an offset, use typed
     array views.
@@ -77,7 +77,7 @@
     `B = α * B * op(A)`, using alternative indexing semantics and where `α` is
     a scalar, `B` is an `M` by `N` matrix, `A` is a unit, or non-unit, upper or
     lower triangular matrix and `op( A )` is one of `op( A ) = A` or
-    `op( A ) = A**T`.
+    `op( A ) = A^T`.
 
     While typed array views mandate a view offset based on the underlying
     buffer, the offset parameters support indexing semantics based on starting

lib/node_modules/@stdlib/blas/base/dtrmm/docs/types/index.d.ts

@@ -27,12 +27,12 @@ import { Layout, MatrixTriangle, DiagonalType, OperationSide, TransposeOperation
 */
 interface Routine {
 	/**
-	* Performs one of the matrix-matrix operations `B = α * op(A) * B` or `B = α * B * op(A)` where `α` is a scalar, `B` is an `M` by `N` matrix, `A` is a unit, or non-unit, upper or lower triangular matrix and `op( A )` is one of `op( A ) = A` or `op( A ) = A**T`.
+	* Performs one of the matrix-matrix operations `B = α * op(A) * B` or `B = α * B * op(A)` where `α` is a scalar, `B` is an `M` by `N` matrix, `A` is a unit, or non-unit, upper or lower triangular matrix and `op( A )` is one of `op( A ) = A` or `op( A ) = A^T`.
 	*
 	* @param order - storage layout of `A` and `B`
 	* @param side - specifies whether `op( A )` appears on the left or right side of `B`
-	* @param uplo - specifies whether the upper or lower triangular part of the matrix `A` is supplied
-	* @param transa - specifies the form of `op( A )` to be used in matrix multiplication
+	* @param uplo - specifies whether the upper or lower triangular part of the matrix `A` should be referenced
+	* @param transa - specifies whether `A` should be transposed, conjugate-transposed, or not transposed
 	* @param diag - specifies whether or not `A` is unit triangular
 	* @param M - number of rows in `B`
 	* @param N - number of columns in `B`
@@ -55,11 +55,11 @@ interface Routine {
 	( order: Layout, side: OperationSide, uplo: MatrixTriangle, transa: TransposeOperation, diag: DiagonalType, M: number, N: number, alpha: number, A: Float64Array, LDA: number, B: Float64Array, LDB: number ): Float64Array;
 
 	/**
-	* Performs one of the matrix-matrix operations `B = α * op(A) * B` or `B = α * B * op(A)` using alternative indexing semantics, where `α` is a scalar, `B` is an `M` by `N` matrix, `A` is a unit, or non-unit, upper or lower triangular matrix and `op( A )` is one of `op( A ) = A` or `op( A ) = A**T`.
+	* Performs one of the matrix-matrix operations `B = α * op(A) * B` or `B = α * B * op(A)` using alternative indexing semantics, where `α` is a scalar, `B` is an `M` by `N` matrix, `A` is a unit, or non-unit, upper or lower triangular matrix and `op( A )` is one of `op( A ) = A` or `op( A ) = A^T`.
 	*
 	* @param side - specifies whether `op( A )` appears on the left or right side of `B`
-	* @param uplo - specifies whether the upper or lower triangular part of the matrix `A` is supplied
-	* @param transa - specifies the form of `op( A )` to be used in matrix multiplication
+	* @param uplo - specifies whether the upper or lower triangular part of the matrix `A` should be referenced
+	* @param transa - specifies whether `A` should be transposed, conjugate-transposed, or not transposed
 	* @param diag - specifies whether or not `A` is unit triangular
 	* @param M - number of rows in `B`
 	* @param N - number of columns in `B`
@@ -87,12 +87,12 @@ interface Routine {
 }
 
 /**
-* Performs one of the matrix-matrix operations `B = α * op(A) * B` or `B = α * B * op(A)` where `α` is a scalar, `B` is an `M` by `N` matrix, `A` is a unit, or non-unit, upper or lower triangular matrix and `op( A )` is one of `op( A ) = A` or `op( A ) = A**T`.
+* Performs one of the matrix-matrix operations `B = α * op(A) * B` or `B = α * B * op(A)` where `α` is a scalar, `B` is an `M` by `N` matrix, `A` is a unit, or non-unit, upper or lower triangular matrix and `op( A )` is one of `op( A ) = A` or `op( A ) = A^T`.
 *
 * @param order - storage layout of `A` and `B`
 * @param side - specifies whether `op( A )` appears on the left or right side of `B`
-* @param uplo - specifies whether the upper or lower triangular part of the matrix `A` is supplied
-* @param transa - specifies the form of `op( A )` to be used in matrix multiplication
+* @param uplo - specifies whether the upper or lower triangular part of the matrix `A` should be referenced
+* @param transa - specifies whether `A` should be transposed, conjugate-transposed, or not transposed
 * @param diag - specifies whether or not `A` is unit triangular
 * @param M - number of rows in `B`
 * @param N - number of columns in `B`

lib/node_modules/@stdlib/blas/base/dtrmm/lib/base.js

@@ -92,12 +92,12 @@ function zeros( M, N, X, strideX1, strideX2, offsetX ) { // TODO: consider movin
 // MAIN //
 
 /**
-* Performs one of the matrix-matrix operations `B = α * op(A) * B` or `B = α * B * op(A)` where `α` is a scalar, `B` is an `M` by `N` matrix, `A` is a unit, or non-unit, upper or lower triangular matrix and `op( A )` is one of `op( A ) = A` or `op( A ) = A**T`.
+* Performs one of the matrix-matrix operations `B = α * op(A) * B` or `B = α * B * op(A)` where `α` is a scalar, `B` is an `M` by `N` matrix, `A` is a unit, or non-unit, upper or lower triangular matrix and `op( A )` is one of `op( A ) = A` or `op( A ) = A^T`.
 *
 * @private
 * @param {string} side - specifies whether `op( A )` appears on the left or right side of `B`
-* @param {string} uplo - specifies whether the upper or lower triangular part of the matrix `A` is supplied
-* @param {string} transa - specifies the form of `op( A )` to be used in matrix multiplication
+* @param {string} uplo - specifies whether the upper or lower triangular part of the matrix `A` should be referenced
+* @param {string} transa - specifies whether `A` should be transposed, conjugate-transposed, or not transposed
 * @param {string} diag - specifies whether or not `A` is unit triangular
 * @param {NonNegativeInteger} M - number of rows in `B`
 * @param {NonNegativeInteger} N - number of columns in `B`

lib/node_modules/@stdlib/blas/base/dtrmm/lib/dtrmm.js

@@ -34,12 +34,12 @@ var base = require( './base.js' );
 // MAIN //
 
 /**
-* Performs one of the matrix-matrix operations `B = α * op(A) * B` or `B = α * B * op(A)` where `α` is a scalar, `B` is an `M` by `N` matrix, `A` is a unit, or non-unit, upper or lower triangular matrix and `op( A )` is one of `op( A ) = A` or `op( A ) = A**T`.
+* Performs one of the matrix-matrix operations `B = α * op(A) * B` or `B = α * B * op(A)` where `α` is a scalar, `B` is an `M` by `N` matrix, `A` is a unit, or non-unit, upper or lower triangular matrix and `op( A )` is one of `op( A ) = A` or `op( A ) = A^T`.
 *
 * @param {string} order - storage layout of `A` and `B`
 * @param {string} side - specifies whether `op( A )` appears on the left or right side of `B`
-* @param {string} uplo - specifies whether the upper or lower triangular part of the matrix `A` is supplied
-* @param {string} transa - specifies the form of `op( A )` to be used in matrix multiplication
+* @param {string} uplo - specifies whether the upper or lower triangular part of the matrix `A` should be referenced
+* @param {string} transa - specifies whether `A` should be transposed, conjugate-transposed, or not transposed
 * @param {string} diag - specifies whether or not `A` is unit triangular
 * @param {NonNegativeInteger} M - number of rows in `B`
 * @param {NonNegativeInteger} N - number of columns in `B`
@@ -50,7 +50,7 @@ var base = require( './base.js' );
 * @param {NonNegativeInteger} LDB - stride of the first dimension of `B` (a.k.a., leading dimension of the matrix `B`)
 * @throws {TypeError} first argument must be a valid order
 * @throws {TypeError} second argument must be a valid side
-* @throws {TypeError} third argument must specify whether the lower or upper triangular matrix is supplied
+* @throws {TypeError} third argument must specify whether the lower or upper triangular matrix should be referenced
 * @throws {TypeError} fourth argument must specify correct transpose operation
 * @throws {TypeError} fifth argument must specify whether the matrix is unit triangular or not
 * @throws {RangeError} sixth argument must be a nonnegative integer
@@ -82,7 +82,7 @@ function dtrmm( order, side, uplo, transa, diag, M, N, alpha, A, LDA, B, LDB ) {
 		throw new TypeError( format( 'invalid argument. Second argument must be a valid side. Value: `%s`.', side ) );
 	}
 	if ( !isMatrixTriangle( uplo ) ) {
-		throw new TypeError( format( 'invalid argument. Third argument must specify whether the lower or upper triangular matrix is supplied. Value: `%s`.', uplo ) );
+		throw new TypeError( format( 'invalid argument. Third argument must specify whether the lower or upper triangular matrix should be referenced. Value: `%s`.', uplo ) );
 	}
 	if ( !isTransposeOperation( transa ) ) {
 		throw new TypeError( format( 'invalid argument. Fourth argument must specify correct transpose operation. Value: `%s`.', transa ) );

lib/node_modules/@stdlib/blas/base/dtrmm/lib/index.js

@@ -19,7 +19,7 @@
 'use strict';
 
 /**
-* BLAS level 3 routine to perform one of the matrix-matrix operations `B = α * op(A) * B` or `B = α * B * op(A)` where `α` is a scalar, `B` is an `M` by `N` matrix, `A` is a unit, or non-unit, upper or lower triangular matrix and `op( A )` is one of `op( A ) = A` or `op( A ) = A**T`.
+* BLAS level 3 routine to perform one of the matrix-matrix operations `B = α * op(A) * B` or `B = α * B * op(A)` where `α` is a scalar, `B` is an `M` by `N` matrix, `A` is a unit, or non-unit, upper or lower triangular matrix and `op( A )` is one of `op( A ) = A` or `op( A ) = A^T`.
 *
 * @module @stdlib/blas/base/dtrmm
 *

lib/node_modules/@stdlib/blas/base/dtrmm/lib/ndarray.js

@@ -31,11 +31,11 @@ var base = require( './base.js' );
 // MAIN //
 
 /**
-* Performs one of the matrix-matrix operations `B = α * op(A) * B` or `B = α * B * op(A)` where `α` is a scalar, `B` is an `M` by `N` matrix, `A` is a unit, or non-unit, upper or lower triangular matrix and `op( A )` is one of `op( A ) = A` or `op( A ) = A**T`.
+* Performs one of the matrix-matrix operations `B = α * op(A) * B` or `B = α * B * op(A)` where `α` is a scalar, `B` is an `M` by `N` matrix, `A` is a unit, or non-unit, upper or lower triangular matrix and `op( A )` is one of `op( A ) = A` or `op( A ) = A^T`.
 *
 * @param {string} side - specifies whether `op( A )` appears on the left or right side of `B`
-* @param {string} uplo - specifies whether the upper or lower triangular part of the matrix `A` is supplied
-* @param {string} transa - specifies the form of `op( A )` to be used in matrix multiplication
+* @param {string} uplo - specifies whether the upper or lower triangular part of the matrix `A` should be referenced
+* @param {string} transa - specifies whether `A` should be transposed, conjugate-transposed, or not transposed
 * @param {string} diag - specifies whether or not `A` is unit triangular
 * @param {NonNegativeInteger} M - number of rows in `B`
 * @param {NonNegativeInteger} N - number of columns in `B`
@@ -49,7 +49,7 @@ var base = require( './base.js' );
 * @param {integer} strideB2 - stride of the second dimension of `B`
 * @param {NonNegativeInteger} offsetB - starting index for `B`
 * @throws {TypeError} first argument must be a valid side
-* @throws {TypeError} second argument must specify whether the lower or upper triangular matrix is supplied.
+* @throws {TypeError} second argument must specify whether the lower or upper triangular matrix should be referenced.
 * @throws {TypeError} third argument must specify correct transpose operation
 * @throws {TypeError} fourth argument must specify whether the matrix is unit triangular or not
 * @throws {RangeError} fifth argument must be a nonnegative integer
@@ -72,7 +72,7 @@ function dtrmm( side, uplo, transa, diag, M, N, alpha, A, strideA1, strideA2, of
 		throw new TypeError( format( 'invalid argument. First argument must be a valid side. Value: `%s`.', side ) );
 	}
 	if ( !isMatrixTriangle( uplo ) ) {
-		throw new TypeError( format( 'invalid argument. Second argument must specify whether the lower or upper triangular matrix is supplied. Value: `%s`.', uplo ) );
+		throw new TypeError( format( 'invalid argument. Second argument must specify whether the lower or upper triangular matrix should be referenced. Value: `%s`.', uplo ) );
 	}
 	if ( !isTransposeOperation( transa ) ) {
 		throw new TypeError( format( 'invalid argument. Third argument must specify correct transpose operation. Value: `%s`.', transa ) );