refactor: update implementation for ndarray, add test, and update descriptions

Author: aman-095

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

@@ -20,7 +20,7 @@ limitations under the License.
 
 # dtrmv
 
-> Perform one of the matrix-vector operations `x = A*x`, or `x = A**T*x`, where `x` is an `N` element vector, and `A` is an `N` by `N` unit, or non-unit, upper or lower triangular matrix.
+> Perform one of the matrix-vector operations `x = A*x` or `x = A**T*x`, where `x` is an `N` element vector and `A` is an `N` by `N` unit, or non-unit, upper or lower triangular matrix.
 
 <section class = "usage">
 
@@ -32,29 +32,29 @@ var dtrmv = require( '@stdlib/blas/base/dtrmv' );
 
 #### dtrmv( order, uplo, trans, diag, N, A, LDA, x, sx )
 
-Performs one of the matrix-vector operations `x = A*x`, or `x = A**T*x`, where `x` is an `N` element vector, and `A` is an `N` by `N` unit, or non-unit, upper or lower triangular matrix.
+Performs one of the matrix-vector operations `x = A*x` or `x = A**T*x`, where `x` is an `N` element vector and `A` is an `N` by `N` unit, or non-unit, upper or lower triangular matrix.
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
 
 var A = new Float64Array( [ 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 0.0, 0.0, 1.0 ] );
 var x = new Float64Array( [ 1.0, 2.0, 3.0 ] );
 
-dtrmv( 'row-major', 'upper', 'none', 'unit', 3, A, 3, x, 1 );
+dtrmv( 'row-major', 'upper', 'no-transpose', 'unit', 3, A, 3, x, 1 );
 // x => <Float64Array>[ 14.0, 8.0, 3.0 ]
 ```
 
 The function has the following parameters:
 
 -   **order**: storage layout.
--   **uplo**: specifies whether the upper or lower triangular part of `A` should be referenced.
--   **trans**: specifies whether the matrix `A` is a non-transpose, transpose, or conjugate-transpose.
--   **diag**: specifies whether or not the matrix `A` is a unit triangular.
+-   **uplo**: specifies whether `A` is an upper or lower triangular matrix.
+-   **trans**: specifies whether `A` should be transposed, conjugate-transposed, or not transposed.
+-   **diag**: specifies whether `A` has a unit diagonal.
 -   **N**: number of elements along each dimension of `A`.
 -   **A**: input matrix stored in linear memory as a [`Float64Array`][mdn-float64array].
 -   **lda**: stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`).
--   **x**: input [`Float64Array`][mdn-float64array].
--   **sx**: index increment for `x`.
+-   **x**: input vector [`Float64Array`][mdn-float64array].
+-   **sx**: `x` stride length.
 
 The stride parameters determine how elements in the input arrays are accessed at runtime. For example, to iterate over the elements of `x` in reverse order,
 
@@ -64,7 +64,7 @@ var Float64Array = require( '@stdlib/array/float64' );
 var A = new Float64Array( [ 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 0.0, 0.0, 1.0 ] );
 var x = new Float64Array( [ 1.0, 2.0, 3.0 ] );
 
-dtrmv( 'row-major', 'upper', 'none', 'unit', 3, A, 3, x, -1 );
+dtrmv( 'row-major', 'upper', 'no-transpose', 'unit', 3, A, 3, x, -1 );
 // x => <Float64Array>[ 1.0, 4.0, 10.0 ]
 ```
 
@@ -82,26 +82,29 @@ var A = new Float64Array( [ 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 0.0, 0.0, 1.0 ] );
 // Create offset views...
 var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
 
-dtrmv( 'row-major', 'upper', 'none', 'unit', 3, A, 3, x1, 1 );
+dtrmv( 'row-major', 'upper', 'no-transpose', 'unit', 3, A, 3, x1, 1 );
 // x0 => <Float64Array>[ 1.0, 6.0, 3.0, 1.0 ]
 ```
 
-#### dtrmv.ndarray( order, uplo, trans, diag, N, A, LDA, x, sx, ox )
+#### dtrmv.ndarray( order, uplo, trans, diag, N, A, sa1, sa2, oa, x, sx, ox )
 
-Performs one of the matrix-vector operations `x = A*x`, or `x = A**T*x`, using alternative indexing semantics, where `x` is an `N` element vector, and `A` is an `N` by `N` unit, or non-unit, upper or lower triangular matrix.
+Performs one of the matrix-vector operations `x = A*x` or `x = A**T*x`, using alternative indexing semantics, where `x` is an `N` element vector and `A` is an `N` by `N` unit, or non-unit, upper or lower triangular matrix.
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
 
 var A = new Float64Array( [ 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 0.0, 0.0, 1.0 ] );
 var x = new Float64Array( [ 1.0, 2.0, 3.0 ] );
 
-dtrmv.ndarray( 'row-major', 'upper', 'none', 'unit', 3, A, 3, 0, x, 1, 0 );
+dtrmv.ndarray( 'row-major', 'upper', 'no-transpose', 'unit', 3, A, 3, 1, 0, x, 1, 0 );
 // x => <Float64Array>[ 14.0, 8.0, 3.0 ]
 ```
 
 The function has the following additional parameters:
 
+-   **sa1**: stride of the first dimension of `A`.
+-   **sa2**: stride of the second dimension of `A`.
+-   **oa**: starting index for `A`.
 -   **ox**: starting index for `x`.
 
 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,
@@ -112,7 +115,7 @@ var Float64Array = require( '@stdlib/array/float64' );
 var A = new Float64Array( [ 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 0.0, 0.0, 1.0 ] );
 var x = new Float64Array( [ 1.0, 2.0, 3.0 ] );
 
-dtrmv.ndarray( 'row-major', 'upper', 'none', 'unit', 3, A, 3, 0, x, -1, 2 );
+dtrmv.ndarray( 'row-major', 'upper', 'no-transpose', 'unit', 3, A, 3, 1, 0, x, -1, 2 );
 // x => <Float64Array>[ 1.0, 4.0, 10.0 ]
 ```
 
@@ -149,7 +152,7 @@ var N = 3;
 var A = discreteUniform( N*N, -10.0, 10.0, opts );
 var x = discreteUniform( N, -10.0, 10.0, opts );
 
-dtrmv( 'row-major', 'upper', 'none', 'unit', 3, A, 3, x, 1 );
+dtrmv( 'row-major', 'upper', 'no-transpose', 'unit', 3, A, 3, x, 1 );
 console.log( x );
 ```
 
@@ -241,7 +244,7 @@ TODO
 
 [blas]: http://www.netlib.org/blas
 
-[dtrmv]: https://www.netlib.org/lapack/explore-html/d6/d1c/group__trmv_ga73370bd6dca01abe05d54ecd1d91ce9a.html#ga73370bd6dca01abe05d54ecd1d91ce9a
+[dtrmv]: https://www.netlib.org/lapack/explore-html/d6/d1c/group__trmv_ga7b90369d2b2b19f78f168e10dd9eb8ad.html#ga7b90369d2b2b19f78f168e10dd9eb8ad
 
 [mdn-float64array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array
 

lib/node_modules/@stdlib/blas/base/dtrmv/benchmark/benchmark.ndarray.js

@@ -62,7 +62,7 @@ function createBenchmark( N ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			z = dtrmv( 'row-major', 'upper', 'transpose', 'non-unit', N, A, N, 0, x, 1, 0 );
+			z = dtrmv( 'row-major', 'upper', 'transpose', 'non-unit', N, A, N, 1, 0, x, 1, 0 );
 			if ( isnan( z[ i%z.length ] ) ) {
 				b.fail( 'should not return NaN' );
 			}

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

@@ -1,8 +1,8 @@
 
 {{alias}}( ord, uplo, trans, diag, N, A, lda, x, sx )
     Performs one of the matrix-vector operations `x = A*x` or `x = A**T*x`,
-    where `x` is an `N` element vector and `A` is an `N` by `N` unit,
-    or non-unit, upper or lower triangular matrix.
+    where `x` is an `N` element vector and `A` is an `N` by `N` unit, or
+    non-unit, upper or lower triangular matrix.
 
     Indexing is relative to the first index. To introduce an offset, use typed
     array views.
@@ -16,15 +16,14 @@
         either 'row-major' or 'column-major'.
 
     uplo: string
-        Specifies whether to reference the upper or lower triangular part of
-        `A`.
+        Specifies whether `A` is an upper or lower triangular matrix.
 
     trans: string
-        Specifies whether the matrix `A` is non-transpose, transpose, or
-        conjugate transpose.
+        Specifies whether `A` should be transposed, conjugate-transposed, or
+        not transposed.
 
     diag: string
-        Specifies whether or not `A` is unit triangular.
+        Specifies whether `A` has a unit diagonal.
 
     N: integer
         Number of elements along each dimension of `A`.
@@ -51,15 +50,15 @@
     --------
     > var x = new {{alias:@stdlib/array/float64}}( [ 1.0, 1.0 ] );
     > var A = new {{alias:@stdlib/array/float64}}( [ 1.0, 2.0, 0.0, 1.0 ] );
-    > {{alias}}( 'row-major', 'upper', 'none', 'unit', 2, A, 2, x, 1 )
+    > {{alias}}( 'row-major', 'upper', 'no-transpose', 'unit', 2, A, 2, x, 1 )
     <Float64Array>[ 3.0, 1.0 ]
 
 
-{{alias}}.ndarray( ord, uplo, trans, diag, N, A, lda, oa, x, sx, ox )
+{{alias}}.ndarray( ord, uplo, trans, diag, N, A, sa1, sa2, oa, x, sx, ox )
     Performs one of the matrix-vector operations `x = A*x` or `x = A**T*x`,
-    using alternative indexing semantics, where `x` is an `N` element
-    vector and `A` is an `N` by `N` unit, or non-unit, upper or lower
-    triangular matrix.
+    using alternative indexing semantics, where `x` is an `N` element vector
+    and `A` is an `N` by `N` unit, or non-unit, upper or lower triangular
+    matrix.
 
     While typed array views mandate a view offset based on the underlying
     buffer, the offset parameters support indexing semantics based on starting
@@ -68,29 +67,30 @@
     Parameters
     ----------
     ord: string
-        Row-major (C-style) or column-major (Fortran-style) ord. Must be
+        Row-major (C-style) or column-major (Fortran-style) order. Must be
         either 'row-major' or 'column-major'.
 
     uplo: string
-        Specifies whether to reference the upper or lower triangular part of
-        `A`.
+        Specifies whether `A` is an upper or lower triangular matrix.
 
     trans: string
-        Specifies whether the matrix `A` is non-transpose, transpose, or
-        conjugate transpose.
+        Specifies whether `A` should be transposed, conjugate-transposed, or
+        not transposed.
 
     diag: string
-        Specifies whether or not `A` is unit triangular.
+        Specifies whether `A` has a unit diagonal.
 
     N: integer
         Number of elements along each dimension of `A`.
 
     A: Float64Array
         Input matrix.
 
-    lda: integer
-        Stride of the first dimension of `A` (a.k.a., leading dimension of the
-        matrix `A`).
+    sa1: integer
+        Stride of the first dimension of `A`.
+
+    sa2: integer
+        Stride of the second dimension of `A`.
 
     oa: integer
         Starting index for `A`.
@@ -115,7 +115,8 @@
     > var A = new {{alias:@stdlib/array/float64}}( [ 1.0, 2.0, 0.0, 1.0 ] );
     > var ord = 'row-major';
     > var uplo = 'upper';
-    > {{alias}}.ndarray( ord, uplo, 'none', 'unit', 2, A, 2, 0, x, 1, 0 )
+    > var trans = 'no-transpose';
+    > {{alias}}.ndarray( ord, uplo, trans, 'unit', 2, A, 2, 1, 0, x, 1, 0 )
     <Float64Array>[ 3.0, 1.0 ]
 
     See Also

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

@@ -30,9 +30,9 @@ interface Routine {
 	* Performs one of the matrix-vector operations `x = A*x` or `x = A**T*x`, where `x` is an `N` element vector and `A` is an `N` by `N` unit, or non-unit, upper or lower triangular matrix.
 	*
 	* @param order - storage layout
-	* @param uplo - specifies whether the upper or lower triangular part of the symmetric matrix `A` is supplied
-	* @param trans - specifies whether the matrix `A` is transposed, conjugate-transposed, or not transposed
-	* @param diag - specifies whether the matrix `A` has a unit diagonal
+	* @param uplo - specifies whether `A` is an upper or lower triangular matrix
+	* @param trans - specifies whether `A` should be transposed, conjugate-transposed, or not transposed
+	* @param diag - specifies whether `A` has a unit diagonal
 	* @param N - number of elements along each dimension in the matrix `A`
 	* @param A - input matrix
 	* @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
@@ -46,7 +46,7 @@ interface Routine {
 	* var A = new Float64Array( [ 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 0.0, 0.0, 1.0 ] );
 	* var x = new Float64Array( [ 1.0, 2.0, 3.0 ] );
 	*
-	* dtrmv( row-major', 'upper', 'none', 'non-unit', 3, A, 3, x, 1 );
+	* dtrmv( row-major', 'upper', 'no-transpose', 'non-unit', 3, A, 3, x, 1 );
 	* // x => <Float64Array>[ 14.0, 8.0, 3.0 ]
 	*/
 	( order: Layout, uplo: MatrixTriangle, trans: TransposeOperation, diag: DiagonalType, N: number, A: Float64Array, LDA: number, x: Float64Array, strideX: number ): Float64Array;
@@ -55,14 +55,15 @@ interface Routine {
 	* Performs one of the matrix-vector operations `x = A*x` or `x = A**T*x`, using alternative indexing semantics, where `x` is an `N` element vector and `A` is an `N` by `N` unit, or non-unit, upper or lower triangular matrix.
 	*
 	* @param order - storage layout
-	* @param uplo - specifies whether the upper or lower triangular part of the symmetric matrix `A` is supplied
-	* @param trans - specifies whether the matrix `A` is transposed, conjugate-transposed, or not transposed
-	* @param diag - specifies whether the matrix `A` has a unit diagonal
+	* @param uplo - specifies whether `A` is an upper or lower triangular matrix
+	* @param trans - specifies whether `A` should be transposed, conjugate-transposed, or not transposed
+	* @param diag - specifies whether `A` has a unit diagonal
 	* @param N - number of elements along each dimension in the matrix `A`
 	* @param A - input matrix
-	* @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
+	* @param strideA1 - stride of the first dimension of `A`
+	* @param strideA2 - stride of the first dimension of `A`
 	* @param offsetA - starting index for `A`
-	* @param x - first input array
+	* @param x - input vector
 	* @param strideX - `x` stride length
 	* @param offsetX - starting index for `x`
 	* @returns `x`
@@ -73,7 +74,7 @@ interface Routine {
 	* var A = new Float64Array( [ 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 0.0, 0.0, 1.0 ] );
 	* var x = new Float64Array( [ 1.0, 2.0, 3.0 ] );
 	*
-	* dtrmv.ndarray( row-major', 'upper', 'none', 'non-unit', 3, A, 3, 0, x, 1, 0 );
+	* dtrmv.ndarray( row-major', 'upper', 'no-transpose', 'non-unit', 3, A, 3, 1, 0, x, 1, 0 );
 	* // x => <Float64Array>[ 14.0, 8.0, 3.0 ]
 	*/
 	ndarray( order: Layout, uplo: MatrixTriangle, trans: TransposeOperation, diag: DiagonalType, N: number, A: Float64Array, LDA: number, x: Float64Array, strideX: number, offsetX: number ): Float64Array;
@@ -83,9 +84,9 @@ interface Routine {
 * Performs one of the matrix-vector operations `x = A*x` or `x = A**T*x`, where `x` is an `N` element vector and `A` is an `N` by `N` unit, or non-unit, upper or lower triangular matrix.
 *
 * @param order - storage layout
-* @param uplo - specifies whether the upper or lower triangular part of the symmetric matrix `A` is supplied
-* @param trans - specifies whether the matrix `A` is transposed, conjugate-transposed, or not transposed
-* @param diag - specifies whether the matrix `A` has a unit diagonal
+* @param uplo - specifies whether `A` is an upper or lower triangular matrix
+* @param trans - specifies whether `A` should be transposed, conjugate-transposed, or not transposed
+* @param diag - specifies whether `A` has a unit diagonal
 * @param N - number of elements along each dimension in the matrix `A`
 * @param A - input matrix
 * @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
@@ -99,7 +100,7 @@ interface Routine {
 * var A = new Float64Array( [ 1.0, 0.0, 0.0, 2.0, 3.0, 0.0, 4.0, 5.0, 6.0 ] );
 * var x = new Float64Array( [ 1.0, 1.0, 1.0 ] );
 *
-* dtrmv( 'row-major', 'lower', 'none', 'non-unit', 3, A, 3, x, 1 );
+* dtrmv( 'row-major', 'lower', 'no-transpose', 'non-unit', 3, A, 3, x, 1 );
 * // x => <Float64Array>[ 1.0, 5.0, 15.0 ]
 *
 * @example
@@ -108,7 +109,7 @@ interface Routine {
 * var A = new Float64Array( [ 1.0, 0.0, 0.0, 2.0, 3.0, 0.0, 4.0, 5.0, 6.0 ] );
 * var x = new Float64Array( [ 1.0, 1.0, 1.0 ] );
 *
-* dtrmv.ndarray( 'row-major', 'lower', 'none', 'non-unit', 3, A, 3, 0, x, 1, 0 );
+* dtrmv.ndarray( 'row-major', 'lower', 'no-transpose', 'non-unit', 3, A, 3, 1, 0, x, 1, 0 );
 * // x => <Float64Array>[ 1.0, 5.0, 15.0 ]
 */
 declare var dtrmv: Routine;