chore: update implementation

---
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: na
  - 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: ShabiShett07

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

@@ -20,7 +20,7 @@ limitations under the License.
 
 # strsm
 
-> 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 = α * B` or `X * op(A) = α * B` where `α` 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">
 
@@ -30,18 +30,18 @@ limitations under the License.
 var strsm = require( '@stdlib/blas/base/strsm' );
 ```
 
-#### strsm( order, side, uplo, transa, diag, m, n, alpha, A, LDA, B, LDB )
+#### strsm( 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 = α * B` or `X * op(A) = α * B` where `α` 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 Float32Array = require( '@stdlib/array/loat32' );
 
-A = new Float32Array( [ 1.0, 3.0, 0.0, 4.0 ] );
-B = new Float32Array( [ 5.0, 7.0, 0.0, 8.0 ] );
+var A = new Float32Array( [ 1.0, 0.0, 0.0, 2.0, 3.0, 0.0, 4.0, 5.0, 6.0 ] );
+var B = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
 
-strsm( 'row-major', 'left', 'upper', 'no-transpose', 'non-unit', 2, 2, 6.0, A, 2, B, 2 );
-// B => <Float32Array>[ 30.0, 6.0, 0.0, 12.0 ]
+strsm( 'row-major', 'left', 'lower', 'no-transpose', 'unit', 3, 3, 1.0, A, 3, B, 3 );
+// B => <Float32Array>[ 1.0, 2.0, 3.0, 2.0, 1.0, 0.0, -7.0, -5.0, -3.0 ]
 ```
 
 The function has the following parameters:
@@ -51,8 +51,8 @@ The function has the following parameters:
 -   **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.
 -   **diag**: specifies whether or not `A` is unit triangular.
--   **m**: number of rows in `B`.
--   **n**: number of columns in `B`.
+-   **M**: number of rows in `B`.
+-   **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`).
@@ -61,35 +61,35 @@ The function has the following parameters:
 
 Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
 
-<!-- eslint-disable stdlib/capitalized-comments -->
+<!-- eslint-disable stdlib/capitalized-comments, max-len -->
 
 ```javascript
 var Float32Array = require( '@stdlib/array/loat32' );
 
 // Initial arrays...
-var A0 = new Float32Array( [ 0.0, 1.0, 3.0, 0.0, 4.0 ] );
-var B0 = new Float32Array( [ 0.0, 5.0, 7.0, 0.0, 8.0 ] );
+var A0 = new Float32Array( [ 0.0, 1.0, 0.0, 0.0, 2.0, 3.0, 0.0, 4.0, 5.0, 6.0 ] );
+var B0 = new Float32Array( [ 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
 
 // Create offset views...
 var A1 = new Float32Array( A0.buffer, A0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
 var B1 = new Float32Array( B0.buffer, B0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
 
-strsm( 'row-major', 'left', 'upper', 'no-transpose', 'non-unit', 2, 2, 6.0, A1, 2, B1, 2 );
-// B0 => <Float32Array>[ 0.0, 30.0, 6.0, 0.0, 12.0 ]
+strsm( 'row-major', 'left', 'lower', 'no-transpose', 'unit', 3, 3, 1.0, A1, 3, B1, 3 );
+// B0 => <Float32Array>[ 1.0, 2.0, 3.0, 2.0, 1.0, 0.0, -7.0, -5.0, -3.0 ]
 ```
 
-#### strsm.ndarray( s, ul, t, d, m, n, α, A, sa1, sa2, oa, B, sb1, sb2, ob )
+#### strsm.ndarray( s, ul, t, d, M, N, α, A, sa1, sa2, oa, B, sb1, sb2, ob )
 
-Solves matrix equation `op(A) * X = alpha * B` or `X * op(A) = alpha * B` using alternative indexing semantics and 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 = α * B` or `X * op(A) = α * B` using alternative indexing semantics and where `α` 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 Float32Array = require( '@stdlib/array/loat32' );
 
-A = new Float32Array( [ 0.0, 0.0, 1.0, 3.0, 0.0, 4.0 ] );
-B = new Float32Array( [ 0.0, 5.0, 7.0, 0.0, 8.0 ] );
+var A = new Float32Array( [ 1.0, 0.0, 0.0, 2.0, 3.0, 0.0, 4.0, 5.0, 6.0 ] );
+var B = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
 
-strsm.ndarray( 'left', 'upper', 'no-transpose', 'non-unit', 2, 2, 6.0, A, 2, 1, 2, B, 2, 1, 1 );
-// B => <Float32Array>[ 0.0, 30.0, 6.0, 0.0, 12.0 ]
+strsm.ndarray( 'left', 'lower', 'no-transpose', 'unit', 3, 3, 1.0, A, 3, 1, 0, B, 3, 1, 0 );
+// B => <Float32Array>[ 1.0, 2.0, 3.0, 2.0, 1.0, 0.0, -7.0, -5.0, -3.0 ]
 ```
 
 The function has the following parameters:
@@ -98,8 +98,8 @@ The function has the following parameters:
 -   **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.
 -   **diag**: specifies whether or not `A` is unit triangular.
--   **m**: number of rows in `B`.
--   **n**: number of columns in `B`.
+-   **M**: number of rows in `B`.
+-   **N**: number of columns in `B`.
 -   **alpha**: scalar constant.
 -   **A**: input matrix `A`.
 -   **sa1**: stride of the first dimension of `A`.
@@ -112,14 +112,16 @@ The function has the following parameters:
 
 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 -->
+
 ```javascript
 var Float32Array = require( '@stdlib/array/loat32' );
 
-A = new Float32Array( [ 0.0, 0.0, 1.0, 3.0, 0.0, 4.0 ] );
-B = new Float32Array( [ 0.0, 5.0, 7.0, 0.0, 8.0 ] );
+var A = new Float32Array( [ 0.0, 1.0, 0.0, 0.0, 2.0, 3.0, 0.0, 4.0, 5.0, 6.0 ] );
+var B = new Float32Array( [ 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
 
-strsm.ndarray( 'left', 'upper', 'no-transpose', 'non-unit', 2, 2, 6.0, A, 2, 1, 2, B, 2, 1, 1 );
-// B => <Float32Array>[ 0.0, 30.0, 6.0, 0.0, 12.0 ]
+strsm.ndarray( 'left', 'lower', 'no-transpose', 'unit', 3, 3, 1.0, A, 3, 1, 1, B, 3, 1, 1 );
+// B => <Float32Array>[ 0.0, 1.0, 2.0, 3.0, 2.0, 1.0, 0.0, -7.0, -5.0, -3.0 ]
 ```
 
 </section>

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

@@ -27,15 +27,15 @@ import { Layout, MatrixTriangle, DiagonalType, OperationSide, TransposeOperation
 */
 interface Routine {
 	/**
-	* 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`.
+	* Solves matrix equation `op(A) * X = α * B` or `X * op(A) = α * B` where `α` 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 - 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 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 M - number of rows in `B`
+	* @param N - number of columns in `B`
 	* @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`)
@@ -46,23 +46,23 @@ interface Routine {
 	* @example
 	* var Float32Array = require( '@stdlib/array/float32' );
 	*
-	* var A = new Float32Array( [ 1.0, 3.0, 0.0, 4.0 ] );
-	* var B = new Float32Array( [ 5.0, 7.0, 0.0, 8.0 ] );
+	* var A = new Float32Array( [ 1.0, 0.0, 0.0, 2.0, 3.0, 0.0, 4.0, 5.0, 6.0 ] );
+	* var B = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
 	*
-	* strsm( 'row-major', 'left', 'upper', 'no-transpose', 'non-unit', 2, 2, 6.0, A, 2, B, 2 );
-	* // B => <Float32Array>[ 30.0, 0.0, 0.0, 12.0 ]
+	* strsm( 'row-major', 'left', 'lower', 'no-transpose', 'unit', 3, 3, 1.0, A, 3, B, 3 );
+	* // B => <Float32Array>[ 1.0, 2.0, 3.0, 2.0, 1.0, 0.0, -7.0, -5.0, -3.0 ]
 	*/
-	( order: Layout, side: OperationSide, uplo: MatrixTriangle, transa: TransposeOperation, diag: DiagonalType, m: number, n: number, alpha: number, A: Float32Array, LDA: number, B: Float32Array, LDB: number ): Float32Array;
+	( order: Layout, side: OperationSide, uplo: MatrixTriangle, transa: TransposeOperation, diag: DiagonalType, M: number, N: number, alpha: number, A: Float32Array, LDA: number, B: Float32Array, LDB: number ): Float32Array;
 
 	/**
-	* 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`.
+	* Solves matrix equation `op(A) * X = α * B` or `X * op(A) = α * B` using alternative indexing semantics and where `α` 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 side - specifies whether `op( A )` appears on the left or right of `X`
 	* @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 M - number of rows in `B`
+	* @param N - number of columns in `B`
 	* @param alpha - scalar constant
 	* @param A - input matrix `A`
 	* @param strideA1 - stride of the first dimension of `A`
@@ -77,25 +77,25 @@ interface Routine {
 	* @example
 	* var Float32Array = require( '@stdlib/array/float32' );
 	*
-	* var A = new Float32Array( [ 0.0, 0.0, 1.0, 3.0, 0.0, 4.0 ] );
-	* var B = new Float32Array( [ 0.0, 5.0, 7.0, 0.0, 8.0 ] );
+	* var A = new Float32Array( [ 1.0, 0.0, 0.0, 2.0, 3.0, 0.0, 4.0, 5.0, 6.0 ] );
+	* var B = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
 	*
-	* strsm.ndarray( 'left', 'upper', 'no-transpose', 'non-unit', 2, 2, 6.0, A, 2, 1, 2, B, 2, 1, 1 );
-	* // B => <Float32Array>[ 0.0, 30.0, 0.0, 0.0, 12.0 ]
+	* strsm.ndarray( 'left', 'lower', 'no-transpose', 'unit', 3, 3, 1.0, A, 3, 1, 0, B, 3, 1, 0 );
+	* // B => <Float32Array>[ 1.0, 2.0, 3.0, 2.0, 1.0, 0.0, -7.0, -5.0, -3.0 ]
 	*/
-	ndarray( side: OperationSide, uplo: MatrixTriangle, transa: TransposeOperation, diag: DiagonalType, m: number, n: number, alpha: number, A: Float32Array, strideA1: number, strideA2: number, offsetA: number, B: Float32Array, strideB1: number, strideB2: number, offsetB: number ): Float32Array;
+	ndarray( side: OperationSide, uplo: MatrixTriangle, transa: TransposeOperation, diag: DiagonalType, M: number, N: number, alpha: number, A: Float32Array, strideA1: number, strideA2: number, offsetA: number, B: Float32Array, strideB1: number, strideB2: number, offsetB: number ): Float32Array;
 }
 
 /**
-* 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`.
+* Solves matrix equation `op(A) * X = α * B` or `X * op(A) = α * B` where `α` 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 - 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 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 M - number of rows in `B`
+* @param N - number of columns in `B`
 * @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`)
@@ -106,20 +106,20 @@ interface Routine {
 * @example
 * var Float32Array = require( '@stdlib/array/float32' );
 *
-* var A = new Float32Array( [ 1.0, 3.0, 0.0, 4.0 ] );
-* var B = new Float32Array( [ 5.0, 7.0, 0.0, 8.0 ] );
+* var A = new Float32Array( [ 1.0, 0.0, 0.0, 2.0, 3.0, 0.0, 4.0, 5.0, 6.0 ] );
+* var B = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
 *
-* strsm( 'row-major', 'left', 'upper', 'no-transpose', 'non-unit', 2, 2, 6.0, A, 2, B, 2 );
-* // B => <Float32Array>[ 30.0, 0.0, 0.0, 12.0 ]
+* strsm( 'row-major', 'left', 'lower', 'no-transpose', 'unit', 3, 3, 1.0, A, 3, B, 3 );
+* // B => <Float32Array>[ 1.0, 2.0, 3.0, 2.0, 1.0, 0.0, -7.0, -5.0, -3.0 ]
 *
 * @example
 * var Float32Array = require( '@stdlib/array/float32' );
 *
-* var A = new Float32Array( [ 0.0, 0.0, 1.0, 3.0, 0.0, 4.0 ] );
-* var B = new Float32Array( [ 0.0, 5.0, 7.0, 0.0, 8.0 ] );
+* var A = new Float32Array( [ 1.0, 0.0, 0.0, 2.0, 3.0, 0.0, 4.0, 5.0, 6.0 ] );
+* var B = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
 *
-* strsm.ndarray( 'left', 'upper', 'no-transpose', 'non-unit', 2, 2, 6.0, A, 2, 1, 2, B, 2, 1, 1 );
-* // B => <Float32Array>[ 0.0, 30.0, 0.0, 0.0, 12.0 ]
+* strsm.ndarray( 'left', 'lower', 'no-transpose', 'unit', 3, 3, 1.0, A, 3, 1, 0, B, 3, 1, 0 );
+* // B => <Float32Array>[ 1.0, 2.0, 3.0, 2.0, 1.0, 0.0, -7.0, -5.0, -3.0 ]
 */
 declare var strsm: Routine;
 

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

@@ -93,7 +93,7 @@ function zeros( M, N, X, strideX1, strideX2, offsetX ) { // TODO: consider movin
 // MAIN //
 
 /**
-* 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`.
+* Solves matrix equation `op(A) * X = α * B` or `X * op(A) = α * B` where `α` 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} side - specifies whether `op( A )` appears on the left or right of `X`
@@ -116,11 +116,11 @@ function zeros( M, N, X, strideX1, strideX2, offsetX ) { // TODO: consider movin
 * @example
 * var Float32Array = require( '@stdlib/array/float32' );
 *
-* var A = new Float32Array( [ 1.0, 3.0, 0.0, 4.0 ] );
-* var B = new Float32Array( [ 5.0, 6.0, 0.0, 8.0 ] );
+* var A = new Float32Array( [ 1.0, 0.0, 0.0, 2.0, 3.0, 0.0, 4.0, 5.0, 6.0 ] );
+* var B = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
 *
-* strsm( 'left', 'upper', 'no-transpose', 'non-unit', 2, 2, 6.0, A, 2, 1, 0, B, 2, 1, 0 );
-* // B => <Float32Array>[ 30.0, 0.0, 0.0, 12.0 ]
+* strsm( 'left', 'lower', 'no-transpose', 'unit', 3, 3, 1.0, A, 3, 1, 0, B, 3, 1, 0 );
+* // B => <Float32Array>[ 1.0, 2.0, 3.0, 2.0, 1.0, 0.0, -7.0, -5.0, -3.0 ]
 */
 function strsm( side, uplo, transa, diag, M, N, alpha, A, strideA1, strideA2, offsetA, B, strideB1, strideB2, offsetB ) { // eslint-disable-line max-params
 	var nonunit;

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

@@ -19,29 +19,29 @@
 'use strict';
 
 /**
-* BLAS routine to 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`.
+* BLAS routine to solve matrix equation `op(A) * X = α * B` or `X * op(A) = α * B` where `α` 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`.
 *
 * @module @stdlib/blas/base/strsm
 *
 * @example
 * var Float32Array = require( '@stdlib/array/float32' );
 * var strsm = require( '@stdlib/blas/base/strsm' );
 *
-* var A = new Float32Array( [ 1.0, 3.0, 0.0, 4.0 ] );
-* var B = new Float32Array( [ 5.0, 7.0, 0.0, 8.0 ] );
+* var A = new Float32Array( [ 1.0, 0.0, 0.0, 2.0, 3.0, 0.0, 4.0, 5.0, 6.0 ] );
+* var B = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
 *
-* strsm( 'row-major', 'left', 'upper', 'no-transpose', 'non-unit', 2, 2, 6.0, A, 2, B, 2 );
-* // B => <Float32Array>[ 30.0, 0.0, 0.0, 12.0 ]
+* strsm( 'row-major', 'left', 'lower', 'no-transpose', 'unit', 3, 3, 1.0, A, 3, B, 3 );
+* // B => <Float32Array>[ 1.0, 2.0, 3.0, 2.0, 1.0, 0.0, -7.0, -5.0, -3.0 ]
 *
 * @example
 * var Float32Array = require( '@stdlib/array/float32' );
 * var strsm = require( '@stdlib/blas/base/strsm' );
 *
-* var A = new Float32Array( [ 0.0, 0.0, 1.0, 3.0, 0.0, 4.0 ] );
-* var B = new Float32Array( [ 0.0, 5.0, 7.0, 0.0, 8.0 ] );
+* var A = new Float32Array( [ 1.0, 0.0, 0.0, 2.0, 3.0, 0.0, 4.0, 5.0, 6.0 ] );
+* var B = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 ] );
 *
-* strsm.ndarray( 'left', 'upper', 'no-transpose', 'non-unit', 2, 2, 6.0, A, 2, 1, 2, B, 2, 1, 1 );
-* // B => <Float32Array>[ 0.0, 30.0, 6.0, 0.0, 12.0 ]
+* strsm.ndarray( 'left', 'lower', 'no-transpose', 'unit', 3, 3, 1.0, A, 3, 1, 0, B, 3, 1, 0 );
+* // B => <Float32Array>[ 1.0, 2.0, 3.0, 2.0, 1.0, 0.0, -7.0, -5.0, -3.0 ]
 */
 
 // MODULES //