feat: add blas/base/dtrsm

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

@@ -20,7 +20,7 @@ limitations under the License.
 
 # dtrsm
 
-> Solve matrix equation `op(A) * X = alpha * B` or `X * op(A) = alpha * B` where `alpha` is a scalar, `X` and `B` are m by n matrices, `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`. The matrix `X` is overwritten on `B`.
+> Solve matrix equation `op(A) * X = alpha * B` or `X * op(A) = alpha * B` where `alpha` is a scalar, `X` and `B` are m by n matrices, `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`. The matrix `X` is overwritten on `B`.
 
 <section class = "usage">
 
@@ -32,7 +32,7 @@ var dtrsm = require( '@stdlib/blas/base/dtrsm' );
 
 #### dtrsm( order, side, uplo, transa, diag, m, n, alpha, A, LDA, B, LDB )
 
-Solves matrix equation `op(A) * X = alpha * B` or `X * op(A) = alpha * B` where `alpha` is a scalar, `X` and `B` are m by n matrices, `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`. The matrix `X` is overwritten on `B`.
+Solves matrix equation `op(A) * X = alpha * B` or `X * op(A) = alpha * B` where `alpha` is a scalar, `X` and `B` are m by n matrices, `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`. The matrix `X` is overwritten on `B`.
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
@@ -55,9 +55,9 @@ The function has the following parameters:
 -   **n**: number of columns in `B`.
 -   **alpha**: scalar constant.
 -   **A**: input matrix `A`.
--   **LDA**: stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
+-   **LDA**: stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`).
 -   **B**: input matrix `B`.
--   **LDB**: stride of the first dimension of `B` (a.k.a., leading dimension of the matrix `B`)
+-   **LDB**: stride of the first dimension of `B` (a.k.a., leading dimension of the matrix `B`).
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
@@ -84,14 +84,13 @@ var B0 = new Float64Array( [ 0.0, 5.0, 7.0, 0.0, 8.0 ] );
 var A1 = new Float64Array( A0.buffer, A0.BYTES_PER_ELEMENT*1 ); // start at 1st element
 var B1 = new Float64Array( B0.buffer, B0.BYTES_PER_ELEMENT*1 ); // start at 1st element
 
-out = dtrsm( 'row-major', 'left', 'upper', 'none', 'non-unit', 2, 2, 6.0, A1, 2, B1, 2 );
-console.log( out );
+dtrsm( 'row-major', 'left', 'upper', 'none', 'non-unit', 2, 2, 6.0, A1, 2, B1, 2 );
 // B0 => <Float64Array>[ 0.0, 30.0, 6.0, 0.0, 12.0 ]
 ```
 
 #### dtrsm.ndarray( ord, side, ul, ta, diag, m, n, α, A, LDA, oa, B, LDB, ob )
 
-Solves matrix equation `op(A) * X = alpha * B` or `X * op(A) = alpha * B` using alternative indexing semantics where `alpha` is a scalar, `X` and `B` are m by n matrices, `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`. The matrix `X` is overwritten on `B`.
+Solves matrix equation `op(A) * X = alpha * B` or `X * op(A) = alpha * B` using alternative indexing semantics where `alpha` is a scalar, `X` and `B` are m by n matrices, `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`. The matrix `X` is overwritten on `B`.
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );

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

@@ -2,8 +2,8 @@
 {{alias}}( ord, side, uplo, transa, diag, m, n, alpha, A, LDA, B, LDB )
     Solves matrix equation `op(A) * X = alpha * B` or `X * op(A) = alpha * B`
     where `alpha` is a scalar, `X` and `B` are m by n matrices, `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`. The matrix `X` is overwritten on `B`.
+    or non-unit, upper or lower triangular matrix and `op( A )` is one of
+    `op( A ) = A` or `op( A ) = A ** T`. The matrix `X` is overwritten on `B`.
 
     Indexing is relative to the first index. To introduce an offset, use typed
     array views.
@@ -25,7 +25,8 @@
         supplied. Must be either 'upper' or 'lower'.
 
     transa: string
-        Specifies the form of `op( A )` to be used in the matrix multiplication.
+        Specifies the form of `op( A )` to be used in the matrix
+        multiplication.
 
     diag: string
         Specifies whether `A` is unit triangular. Must be either 'unit' or
@@ -64,25 +65,35 @@
     // Standard usage:
     > var A = new {{alias:@stdlib/array/float64}}( [ 1.0, 3.0, 0.0, 4.0 ] );
     > var B = new {{alias:@stdlib/array/float64}}( [ 5.0, 7.0, 0.0, 8.0 ] );
-    > {{alias}}( 'row-major', 'left', 'upper', 'none', 'non-unit', 2, 2, 6.0, A, 2, B, 2 )
+    > var ord = 'row-major';
+    > var sd = 'left';
+    > var ul = 'upper';
+    > var ta = 'none';
+    > var dg = 'non-unit';
+    > {{alias}}( ord, sd, ul, ta, dg, 2, 2, 6.0, A, 2, B, 2 )
     <Float64Array>[ 30.0, 6.0, 0.0, 12.0 ]
 
     // Using typed array views:
     > var A0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 1.0, 3.0, 0.0, 4.0 ] );
     > var B0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 5.0, 7.0, 0.0, 8.0 ] );
     > var A1 = new {{alias:@stdlib/array/float64}}( A0.buffer, A0.BYTES_PER_ELEMENT*1 );
     > var B1 = new {{alias:@stdlib/array/float64}}( B0.buffer, B0.BYTES_PER_ELEMENT*1 );
-    > {{alias}}( 'row-major', 'left', 'upper', 'none', 'non-unit', 2, 2, 6.0, A1, 2, B1, 2 );
+    > var ord = 'row-major';
+    > var sd = 'left';
+    > var ul = 'upper';
+    > var ta = 'none';
+    > var dg = 'non-unit';
+    > {{alias}}( ord, sd, ul, ta, dg, 2, 2, 6.0, A1, 2, B1, 2 );
     > B0
     <Float64Array>[ 0.0, 30.0, 6.0, 0.0, 12.0 ]
 
 
 {{alias}}.ndarray( ord, side, ul, ta, diag, m, n, α, A, LDA, oa, B, LDB, ob )
     Solves matrix equation `op(A) * X = alpha * B` or `X * op(A) = alpha * B`
     using alternative indexing semantics where `alpha` is a scalar, `X` and
-    `B` are m by n matrices, `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`. The matrix `X` is overwritten on `B`.
+    `B` are m by n matrices, `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`. The matrix `X` is overwritten on `B`.
 
     While typed array views mandate a view offset based on the underlying
     buffer, the offset parameters support indexing semantics based on starting
@@ -103,7 +114,8 @@
         supplied. Must be either 'upper' or 'lower'.
 
     ta: string
-        Specifies the form of `op( A )` to be used in the matrix multiplication.
+        Specifies the form of `op( A )` to be used in the matrix
+        multiplication.
 
     diag: string
         Specifies whether `A` is unit triangular. Must be either 'unit' or
@@ -148,13 +160,23 @@
     // Standard usage:
     > var A = new {{alias:@stdlib/array/float64}}( [ 1.0, 3.0, 0.0, 4.0 ] );
     > var B = new {{alias:@stdlib/array/float64}}( [ 5.0, 7.0, 0.0, 8.0 ] );
-    > {{alias}}.ndarray( 'row-major', 'left', 'upper', 'none', 'non-unit', 2, 2, 6.0, A, 2, 0, B, 2, 0 )
+    > var ord = 'row-major';
+    > var sd = 'left';
+    > var ul = 'upper';
+    > var ta = 'none';
+    > var dg = 'non-unit';
+    > {{alias}}.ndarray( ord, sd, ul, ta, dg, 2, 2, 6.0, A, 2, 0, B, 2, 0 )
     <Float64Array>[ 30.0, 6.0, 0.0, 12.0 ]
 
     // Advanced indexing:
     > var A = new {{alias:@stdlib/array/float64}}( [ 0.0, 0.0, 1.0, 3.0, 0.0, 4.0 ] );
     > var B = new {{alias:@stdlib/array/float64}}( [ 0.0, 5.0, 7.0, 0.0, 8.0 ] );
-    > {{alias}}.ndarray( 'row-major', 'left', 'upper', 'none', 'non-unit', 2, 2, 6.0, A, 2, 2, B, 2, 1 )
+    > var ord = 'row-major';
+    > var sd = 'left';
+    > var ul = 'upper';
+    > var ta = 'none';
+    > var dg = 'non-unit';
+    > {{alias}}.ndarray( ord, sd, ul, ta, dg, 2, 2, 6.0, A, 2, 2, B, 2, 1 )
     <Float64Array>[ 0.0, 30.0, 6.0, 0.0, 12.0 ]
 
     See Also

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

@@ -27,16 +27,16 @@ import { Layout, MatrixTriangle, DiagonalType, OperationSide, TransposeOperation
 */
 interface Routine {
 	/**
-	* Solves matrix equation `op(A) * X = alpha * B` or `X * op(A) = alpha * B` where `alpha` is a scalar, `X` and `B` are m by n matrices, `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`. The matrix `X` is overwritten on `B`.
+	* Solves matrix equation `op(A) * X = alpha * B` or `X * op(A) = alpha * B` where `alpha` is a scalar, `X` and `B` are m by n matrices, `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`. The matrix `X` is overwritten on `B`.
 	*
-	* @param order - specifies the memory layout of `A` and `B`
+	* @param order - storage layout of `A` and `B`
 	* @param side - specifies whether `op( A )` appears on the left or right of `X`
-	* @param uplo - specifies whether the matrix `A` is an upper or lower triangular matrix
+	* @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 diag - specifies whether or not `A` is unit triangular
 	* @param m - number of rows in `B`
 	* @param n - number of columns in `B`
-	* @param alpha - scalar alpha
+	* @param alpha - scalar constant
 	* @param A - input matrix `A`
 	* @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
 	* @param B - input matrix `B`
@@ -55,22 +55,22 @@ 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;
 
 	/**
-	* Solves matrix equation `op(A) * X = alpha * B` or `X * op(A) = alpha * B` where `alpha` is a scalar, `X` and `B` are m by n matrices, `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`. The matrix `X` is overwritten on `B`.
+	* Solves matrix equation `op(A) * X = alpha * B` or `X * op(A) = alpha * B` where `alpha` is a scalar, `X` and `B` are m by n matrices, `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`. The matrix `X` is overwritten on `B`.
 	*
-	* @param order - specifies the memory layout of `A` and `B`
+	* @param order - storage layout of `A` and `B`
 	* @param side - specifies whether `op( A )` appears on the left or right of `X`
-	* @param uplo - specifies whether the matrix `A` is an upper or lower triangular matrix
+	* @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 diag - specifies whether or not `A` is unit triangular
 	* @param m - number of rows in `B`
 	* @param n - number of columns in `B`
-	* @param alpha - scalar alpha
+	* @param alpha - scalar constant
 	* @param A - input matrix `A`
 	* @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
-	* @param offsetA - index offset for matrix `A`
+	* @param offsetA - starting `A` index
 	* @param B - input matrix `B`
 	* @param LDB - stride of the first dimension of `B` (a.k.a., leading dimension of the matrix `B`)
-	* @param offsetB - index offset for matrix `B`
+	* @param offsetB - starting `B` index
 	* @returns `B`
 	*
 	* @example
@@ -86,16 +86,16 @@ interface Routine {
 }
 
 /**
-* Solves matrix equation `op(A) * X = alpha * B` or `X * op(A) = alpha * B` where `alpha` is a scalar, `X` and `B` are m by n matrices, `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`. The matrix `X` is overwritten on `B`.
+* Solves matrix equation `op(A) * X = alpha * B` or `X * op(A) = alpha * B` where `alpha` is a scalar, `X` and `B` are m by n matrices, `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`. The matrix `X` is overwritten on `B`.
 *
-* @param order - specifies the memory layout of `A` and `B`
+* @param order - storage layout of `A` and `B`
 * @param side - specifies whether `op( A )` appears on the left or right of `X`
-* @param uplo - specifies whether the matrix `A` is an upper or lower triangular matrix
+* @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 diag - specifies whether or not `A` is unit triangular
 * @param m - number of rows in `B`
 * @param n - number of columns in `B`
-* @param alpha - scalar alpha
+* @param alpha - scalar constant
 * @param A - input matrix `A`
 * @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
 * @param B - input matrix `B`

lib/node_modules/@stdlib/blas/base/dtrsm/examples/index.js

@@ -132,3 +132,10 @@ B = new Float64Array( [ 5.0, 0.0, 7.0, 8.0 ] );
 out = dtrsm( 'row-major', 'right', 'lower', 'transpose', 'non-unit', 2, 2, 6.0, A, 2, B, 2 );
 console.log( out );
 // => <Float64Array>[ 30, -22.5, 42, -19.5 ]
+
+A = new Float64Array( [ 0.0, 0.0, 1.0, 3.0, 0.0, 4.0 ] );
+B = new Float64Array( [ 0.0, 5.0, 7.0, 0.0, 8.0 ] );
+
+out = dtrsm.ndarray( 'row-major', 'left', 'upper', 'none', 'non-unit', 2, 2, 6.0, A, 2, 2, B, 2, 1 );
+console.log( out );
+// => <Float64Array>[ 0.0, 30.0, 6.0, 0.0, 12.0 ]

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

@@ -21,24 +21,24 @@
 // MAIN //
 
 /**
-* Solves matrix equation `op(A) * X = alpha * B` or `X * op(A) = alpha * B` where `alpha` is a scalar, `X` and `B` are m by n matrices, `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`. The matrix `X` is overwritten on `B`.
+* Solves matrix equation `op(A) * X = alpha * B` or `X * op(A) = alpha * B` where `alpha` is a scalar, `X` and `B` are m by n matrices, `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`. The matrix `X` is overwritten on `B`.
 *
 * @private
-* @param {string} order - specifies the memory layout of `A` and `B`
+* @param {string} order - storage layout of `A` and `B`
 * @param {string} side - specifies whether `op( A )` appears on the left or right of `X`
-* @param {string} uplo - specifies whether the matrix `A` is an upper or lower triangular matrix
+* @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} 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`
-* @param {number} alpha - scalar alpha
+* @param {number} alpha - scalar constant
 * @param {Float64Array} A - input matrix `A`
 * @param {NonNegativeInteger} LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
-* @param {NonNegativeInteger} offsetA - index offset for matrix `A`
+* @param {NonNegativeInteger} offsetA - starting `A` index
 * @param {Float64Array} B - input matrix `B`
 * @param {NonNegativeInteger} LDB - stride of the first dimension of `B` (a.k.a., leading dimension of the matrix `B`)
-* @param {NonNegativeInteger} offsetB - index offset for matrix `B`
-* @returns {Float64Array} matrix `B`
+* @param {NonNegativeInteger} offsetB - starting `B` index
+* @returns {Float64Array} `B`
 *
 * @example
 * var Float64Array = require( '@stdlib/array/float64' );
@@ -91,10 +91,10 @@ function dtrsm( order, side, uplo, transa, diag, m, n, alpha, A, LDA, offsetA, B
 					for ( k = m - 1; k >= 0; k-- ) {
 						if ( B[ offsetB + ( j * LDB ) + k ] !== 0 ) { // eslint-disable-line max-depth
 							if ( nounit ) { // eslint-disable-line max-depth
-								B[ offsetB + ( j * LDB ) + k ] /= A[ offsetA + ( k * LDA ) + k ];
+								B[ offsetB + ( j * LDB ) + k ] /= A[ offsetA + ( k * LDA ) + k ]; // eslint-disable-line max-len
 							}
 							for ( i = 0; i < k; i++ ) { // eslint-disable-line max-depth
-								B[ offsetB + ( j * LDB ) + i ] -= B[ offsetB + ( j * LDB ) + k ] * A[ offsetA + ( k * LDA ) + i ];
+								B[ offsetB + ( j * LDB ) + i ] -= B[ offsetB + ( j * LDB ) + k ] * A[ offsetA + ( k * LDA ) + i ]; // eslint-disable-line max-len
 							}
 						}
 					}
@@ -111,10 +111,10 @@ function dtrsm( order, side, uplo, transa, diag, m, n, alpha, A, LDA, offsetA, B
 				for ( k = 0; k < m; k++ ) {
 					if ( B[ offsetB + ( j * LDB ) + k ] !== 0 ) {
 						if ( nounit ) { // eslint-disable-line max-depth
-							B[ offsetB + ( j * LDB ) + k ] /= A[ offsetA + ( k * LDA ) + k ];
+							B[ offsetB + ( j * LDB ) + k ] /= A[ offsetA + ( k * LDA ) + k ]; // eslint-disable-line max-len
 						}
 						for ( i = k + 1; i < m; i++ ) { // eslint-disable-line max-depth
-							B[ offsetB + ( j * LDB ) + i ] -= B[ offsetB + ( j * LDB ) + k ] * A[ offsetA + ( k * LDA ) + i ];
+							B[ offsetB + ( j * LDB ) + i ] -= B[ offsetB + ( j * LDB ) + k ] * A[ offsetA + ( k * LDA ) + i ]; // eslint-disable-line max-len
 						}
 					}
 				}
@@ -127,7 +127,7 @@ function dtrsm( order, side, uplo, transa, diag, m, n, alpha, A, LDA, offsetA, B
 				for ( i = 0; i < m; i++ ) {
 					tmp = alpha * B[ offsetB + ( j * LDB ) + i ];
 					for ( k = 0; k <= i - 1; k++ ) {
-						tmp -= A[ offsetA + ( i * LDA ) + k ] * B[ offsetB + ( j * LDB ) + k ];
+						tmp -= A[ offsetA + ( i * LDA ) + k ] * B[ offsetB + ( j * LDB ) + k ]; // eslint-disable-line max-len
 					}
 					if ( nounit ) {
 						tmp /= A[ offsetA + ( i * LDA ) + i ];
@@ -142,7 +142,7 @@ function dtrsm( order, side, uplo, transa, diag, m, n, alpha, A, LDA, offsetA, B
 			for ( i = m - 1; i >= 0; i-- ) {
 				tmp = alpha * B[ offsetB + ( j * LDB ) + i ];
 				for ( k = i + 1; k < m; k++ ) {
-					tmp -= A[ offsetA + ( i * LDA ) + k ] * B[ offsetB + ( j * LDB ) + k ];
+					tmp -= A[ offsetA + ( i * LDA ) + k ] * B[ offsetB + ( j * LDB ) + k ]; // eslint-disable-line max-len
 				}
 				if ( nounit ) {
 					tmp /= A[ offsetA + ( i * LDA ) + i ];
@@ -165,7 +165,7 @@ function dtrsm( order, side, uplo, transa, diag, m, n, alpha, A, LDA, offsetA, B
 				for ( k = 0; k <= j - 1; k++ ) {
 					if ( A[ offsetA + ( j * LDA ) + k ] !== 0.0 ) {
 						for ( i = 0; i < m; i++ ) { // eslint-disable-line max-depth
-							B[ offsetB + ( j * LDB ) + i ] -= A[ offsetA + ( j * LDA ) + k ] * B[ offsetB + ( k * LDB ) + i ];
+							B[ offsetB + ( j * LDB ) + i ] -= A[ offsetA + ( j * LDA ) + k ] * B[ offsetB + ( k * LDB ) + i ]; // eslint-disable-line max-len
 						}
 					}
 				}
@@ -188,7 +188,7 @@ function dtrsm( order, side, uplo, transa, diag, m, n, alpha, A, LDA, offsetA, B
 			for ( k = j + 1; k < n; k++ ) {
 				if ( A[ offsetA + ( j * LDA ) + k ] !== 0 ) {
 					for ( i = 0; i < m; i++ ) {
-						B[ offsetB + ( j * LDB ) + i ] -= A[ offsetA + ( j * LDA ) + k ] * B[ offsetB + ( k * LDB ) + i ];
+						B[ offsetB + ( j * LDB ) + i ] -= A[ offsetA + ( j * LDA ) + k ] * B[ offsetB + ( k * LDB ) + i ]; // eslint-disable-line max-len
 					}
 				}
 			}
@@ -214,7 +214,7 @@ function dtrsm( order, side, uplo, transa, diag, m, n, alpha, A, LDA, offsetA, B
 				if ( A[ offsetA + ( k * LDA ) + j ] !== 0 ) {
 					tmp = A[ offsetA + ( k * LDA ) + j ];
 					for ( i = 0; i < m; i++ ) {
-						B[ offsetB + ( j * LDB ) + i ] -= tmp * B[ offsetB + ( k * LDB ) + i ];
+						B[ offsetB + ( j * LDB ) + i ] -= tmp * B[ offsetB + ( k * LDB ) + i ]; // eslint-disable-line max-len
 					}
 				}
 			}
@@ -238,7 +238,7 @@ function dtrsm( order, side, uplo, transa, diag, m, n, alpha, A, LDA, offsetA, B
 			if ( A[ offsetA + ( k * LDA ) + j ] !== 0 ) {
 				tmp = A[ offsetA + ( k * LDA ) + j ];
 				for ( i = 0; i < m; i++ ) {
-					B[ offsetB + ( j * LDB ) + i ] -= tmp * B[ offsetB + ( k * LDB ) + i ];
+					B[ offsetB + ( j * LDB ) + i ] -= tmp * B[ offsetB + ( k * LDB ) + i ]; // eslint-disable-line max-len
 				}
 			}
 		}