From b5d5fb0bb51d325905f4ce66cf4299a79b002df3 Mon Sep 17 00:00:00 2001 From: Om-A-osc Date: Thu, 12 Feb 2026 23:27:44 +0530 Subject: [PATCH 01/12] feat: add implementation of blas/base/zgemv --- 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: passed - task: lint_repl_help status: passed - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: passed - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: passed - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: passed - task: lint_c_examples status: passed - task: lint_c_benchmarks status: passed - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: passed - task: lint_license_headers status: passed --- --- .../@stdlib/blas/base/zgemv/README.md | 400 +++++++ .../blas/base/zgemv/benchmark/benchmark.js | 112 ++ .../base/zgemv/benchmark/benchmark.native.js | 117 ++ .../base/zgemv/benchmark/benchmark.ndarray.js | 112 ++ .../benchmark/benchmark.ndarray.native.js | 117 ++ .../blas/base/zgemv/benchmark/c/Makefile | 146 +++ .../base/zgemv/benchmark/c/benchmark.length.c | 216 ++++ .../@stdlib/blas/base/zgemv/binding.gyp | 265 ++++ .../@stdlib/blas/base/zgemv/docs/repl.txt | 156 +++ .../blas/base/zgemv/docs/types/index.d.ts | 147 +++ .../blas/base/zgemv/docs/types/test.ts | 301 +++++ .../blas/base/zgemv/examples/c/Makefile | 146 +++ .../blas/base/zgemv/examples/c/example.c | 70 ++ .../@stdlib/blas/base/zgemv/examples/index.js | 71 ++ .../@stdlib/blas/base/zgemv/include.gypi | 70 ++ .../zgemv/include/stdlib/blas/base/zgemv.h | 49 + .../include/stdlib/blas/base/zgemv_cblas.h | 49 + .../@stdlib/blas/base/zgemv/lib/base.js | 269 +++++ .../@stdlib/blas/base/zgemv/lib/index.js | 72 ++ .../@stdlib/blas/base/zgemv/lib/main.js | 35 + .../@stdlib/blas/base/zgemv/lib/native.js | 35 + .../@stdlib/blas/base/zgemv/lib/ndarray.js | 94 ++ .../blas/base/zgemv/lib/ndarray.native.js | 91 ++ .../@stdlib/blas/base/zgemv/lib/zgemv.js | 134 +++ .../blas/base/zgemv/lib/zgemv.native.js | 119 ++ .../@stdlib/blas/base/zgemv/manifest.json | 625 ++++++++++ .../@stdlib/blas/base/zgemv/package.json | 79 ++ .../@stdlib/blas/base/zgemv/src/Makefile | 70 ++ .../@stdlib/blas/base/zgemv/src/addon.c | 125 ++ .../@stdlib/blas/base/zgemv/src/zgemv.c | 114 ++ .../@stdlib/blas/base/zgemv/src/zgemv_cblas.c | 41 + .../blas/base/zgemv/src/zgemv_ndarray.c | 189 +++ .../fixtures/column_major_alpha_zero.json | 50 + .../column_major_complex_access_pattern.json | 56 + .../zgemv/test/fixtures/column_major_ct.json | 50 + .../zgemv/test/fixtures/column_major_nt.json | 50 + .../zgemv/test/fixtures/column_major_oa.json | 52 + .../test/fixtures/column_major_sa1_sa2.json | 56 + .../test/fixtures/column_major_sa1_sa2n.json | 56 + .../test/fixtures/column_major_sa1n_sa2.json | 56 + .../test/fixtures/column_major_sa1n_sa2n.json | 56 + .../zgemv/test/fixtures/column_major_t.json | 50 + .../test/fixtures/column_major_x_zeros.json | 50 + .../column_major_x_zeros_beta_one.json | 50 + .../test/fixtures/column_major_xnyn.json | 56 + .../test/fixtures/column_major_xnyp.json | 56 + .../test/fixtures/column_major_xpyn.json | 56 + .../test/fixtures/column_major_xpyp.json | 56 + .../test/fixtures/row_major_alpha_zero.json | 50 + .../row_major_complex_access_pattern.json | 56 + .../zgemv/test/fixtures/row_major_ct.json | 50 + .../zgemv/test/fixtures/row_major_nt.json | 50 + .../zgemv/test/fixtures/row_major_oa.json | 52 + .../test/fixtures/row_major_sa1_sa2.json | 56 + .../test/fixtures/row_major_sa1_sa2n.json | 56 + .../test/fixtures/row_major_sa1n_sa2.json | 56 + .../test/fixtures/row_major_sa1n_sa2n.json | 56 + .../base/zgemv/test/fixtures/row_major_t.json | 50 + .../test/fixtures/row_major_x_zeros.json | 50 + .../fixtures/row_major_x_zeros_beta_one.json | 50 + .../zgemv/test/fixtures/row_major_xnyn.json | 56 + .../zgemv/test/fixtures/row_major_xnyp.json | 56 + .../zgemv/test/fixtures/row_major_xpyn.json | 56 + .../zgemv/test/fixtures/row_major_xpyp.json | 56 + .../@stdlib/blas/base/zgemv/test/test.js | 82 ++ .../blas/base/zgemv/test/test.ndarray.js | 1062 +++++++++++++++++ .../base/zgemv/test/test.ndarray.native.js | 1024 ++++++++++++++++ .../blas/base/zgemv/test/test.zgemv.js | 823 +++++++++++++ .../blas/base/zgemv/test/test.zgemv.native.js | 784 ++++++++++++ 69 files changed, 10123 insertions(+) create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/README.md create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.js create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.native.js create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.js create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.native.js create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/benchmark/c/Makefile create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/benchmark/c/benchmark.length.c create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/binding.gyp create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/docs/repl.txt create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/docs/types/index.d.ts create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/docs/types/test.ts create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/examples/c/Makefile create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/examples/c/example.c create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/examples/index.js create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/include.gypi create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/include/stdlib/blas/base/zgemv.h create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/include/stdlib/blas/base/zgemv_cblas.h create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/lib/base.js create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/lib/index.js create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/lib/main.js create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/lib/native.js create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/lib/ndarray.js create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/lib/ndarray.native.js create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/lib/zgemv.js create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/lib/zgemv.native.js create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/manifest.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/package.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/src/Makefile create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/src/addon.c create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv.c create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv_cblas.c create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv_ndarray.c create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_alpha_zero.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_complex_access_pattern.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_ct.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_nt.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_oa.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1_sa2.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1_sa2n.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1n_sa2.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1n_sa2n.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_t.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_x_zeros.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_x_zeros_beta_one.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xnyn.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xnyp.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xpyn.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xpyp.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_alpha_zero.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_complex_access_pattern.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_ct.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_nt.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_oa.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1_sa2.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1_sa2n.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1n_sa2.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1n_sa2n.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_t.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_x_zeros.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_x_zeros_beta_one.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xnyn.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xnyp.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xpyn.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xpyp.json create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/test.js create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/test.ndarray.js create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/test.ndarray.native.js create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/test.zgemv.js create mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/test.zgemv.native.js diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/README.md b/lib/node_modules/@stdlib/blas/base/zgemv/README.md new file mode 100644 index 000000000000..f1b97ded75b2 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/README.md @@ -0,0 +1,400 @@ + + +# zgemv + +> Perform one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`. + +
+ +## Usage + +```javascript +var zgemv = require( '@stdlib/blas/base/zgemv' ); +``` + +#### zgemv( order, trans, M, N, α, A, LDA, x, sx, β, y, sy ) + +Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, +where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. + + + +```javascript +var Complex128Array = require( '@stdlib/array/complex128' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); + +var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); +var x = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); +var y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0 ] ); + +zgemv( 'row-major', 'no-transpose', 2, 3, new Complex128( 1.0, 0.0 ), A, 3, x, 1, new Complex128( 1.0, 0.0 ), y, 1 ); + +var v = y.get( 0 ); +var re = real( v ); +// returns -2.0 + +var im = imag( v ); +// returns 22.0 +``` + + + +The function has the following parameters: + +- **order**: storage layout. +- **trans**: specifies whether `A` should be transposed, conjugate-transposed, or not transposed. +- **M**: number of rows in the matrix `A`. +- **N**: number of columns in the matrix `A`. +- **α**: scalar constant. +- **A**: input matrix stored in linear memory as a [`Complex128Array`][mdn-complex128array]. +- **LDA**: stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`). +- **x**: input [`Complex128Array`][mdn-complex128array]. +- **sx**: stride length for `x`. +- **β**: scalar constant. +- **y**: output [`Complex128Array`][mdn-complex128array]. +- **sy**: stride length for `y`. + +Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views. + + + + + +```javascript +var Complex128Array = require( '@stdlib/array/complex128' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); + +// Initial arrays... +var x0 = new Complex128Array( [ 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); +var y0 = new Complex128Array( [ 0.0, 0.0, 1.0, 1.0, 1.0, 1.0 ] ); +var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); + +// Create offset views... +var x1 = new Complex128Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element +var y1 = new Complex128Array( y0.buffer, y0.BYTES_PER_ELEMENT*1 ); // start at 2nd element + +zgemv( 'row-major', 'no-transpose', 2, 3, new Complex128( 1.0, 0.0 ), A, 3, x1, -1, new Complex128( 1.0, 0.0 ), y1, -1 ); +``` + + + + + +#### zgemv.ndarray( trans, M, N, α, A, sa1, sa2, oa, x, sx, ox, β, y, sy, oy ) + +Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, using alternative indexing semantics and where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. + + + +```javascript +var Complex128Array = require( '@stdlib/array/complex128' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); + +var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); +var x = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); +var y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0 ] ); + +zgemv.ndarray( 'no-transpose', 2, 3, new Complex128( 1.0, 0.0 ), A, 3, 1, 0, x, 1, 0, new Complex128( 1.0, 0.0 ), y, 1, 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`. +- **oy**: starting index for `y`. + +
+ + + +
+ +## Notes + +- `zgemv()` corresponds to the [BLAS][blas] level 2 function [`zgemv`][blas-zgemv]. + +
+ + + +
+ +## Examples + + + +```javascript +var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ); +var filledarrayBy = require( '@stdlib/array/filled-by' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var zgemv = require( '@stdlib/blas/base/zgemv' ); + +function rand() { + return new Complex128( discreteUniform( 0, 10 ), discreteUniform( -5, 5 ) ); +} + +var M = 3; +var N = 3; + +var A = filledarrayBy( M*N, 'complex128', rand ); +var x = filledarrayBy( N, 'complex128', rand ); +var y = filledarrayBy( M, 'complex128', rand ); + +// eslint-disable-next-line max-len +zgemv( 'row-major', 'no-transpose', M, N, new Complex128( 1.0, 0.0 ), A, N, x, -1, new Complex128( 1.0, 0.0 ), y, -1 ); +console.log( y ); +``` + +
+ + + + + +* * * + +
+ +## C APIs + + + +
+ +
+ + + + + +
+ +### Usage + +```c +#include "stdlib/blas/base/zgemv.h" +``` + +#### c_zgemv( layout, trans, M, N, alpha, \*A, LDA, \*X, strideX, beta, \*Y, strideY ) + +Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. + +```c +#include "stdlib/blas/base/shared.h" +#include "stdlib/complex/float64/ctor.h" + +const stdlib_complex128_t A[] = { + stdlib_complex128( 1.0, 2.0 ), stdlib_complex128( 3.0, 4.0 ), + stdlib_complex128( 5.0, 6.0 ), stdlib_complex128( 7.0, 8.0 ) +}; +const stdlib_complex128_t x[] = { + stdlib_complex128( 1.0, 1.0 ), + stdlib_complex128( 1.0, 1.0 ) +}; +stdlib_complex128_t y[] = { + stdlib_complex128( 0.0, 0.0 ), + stdlib_complex128( 0.0, 0.0 ) +}; + +const stdlib_complex128_t alpha = stdlib_complex128( 1.0, 0.0 ); +const stdlib_complex128_t beta = stdlib_complex128( 0.0, 0.0 ); + +c_zgemv( CblasRowMajor, CblasNoTrans, 2, 2, alpha, (void *)A, 2, (void *)x, 1, beta, (void *)y, 1 ); +``` + +The function accepts the following arguments: + +- **layout**: `[in] CBLAS_LAYOUT` storage layout. +- **trans**: `[in] CBLAS_TRANSPOSE` specifies whether `A` should be transposed, conjugate-transposed, or not transposed. +- **M**: `[in] CBLAS_INT` number of rows in the matrix `A`. +- **N**: `[in] CBLAS_INT` number of columns in the matrix `A`. +- **alpha**: `[in] stdlib_complex128_t` scalar constant. +- **A**: `[in] void*` input matrix. +- **LDA**: `[in] CBLAS_INT` stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`). +- **X**: `[in] void*` first input vector. +- **strideX**: `[in] CBLAS_INT` stride length for `X`. +- **beta**: `[in] stdlib_complex128_t` scalar constant. +- **Y**: `[inout] void*` second input vector. +- **strideY**: `[in] CBLAS_INT` stride length for `Y`. + +```c +void c_zgemv( const CBLAS_LAYOUT layout, const CBLAS_TRANSPOSE trans, const CBLAS_INT M, const CBLAS_INT N, const stdlib_complex128_t alpha, const void *A, const CBLAS_INT LDA, const void *X, const CBLAS_INT strideX, const stdlib_complex128_t beta, void *Y, const CBLAS_INT strideY ) +``` + +#### c_zgemv_ndarray( trans, M, N, alpha, \*A, sa1, sa2, oa, \*X, sx, ox, beta, \*Y, sy, oy ) + +Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, using alternative indexing semantics and where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. + +```c +#include "stdlib/blas/base/shared.h" +#include "stdlib/complex/float64/ctor.h" + +const stdlib_complex128_t A[] = { + stdlib_complex128( 1.0, 2.0 ), stdlib_complex128( 3.0, 4.0 ), + stdlib_complex128( 5.0, 6.0 ), stdlib_complex128( 7.0, 8.0 ) +}; +const stdlib_complex128_t x[] = { + stdlib_complex128( 1.0, 1.0 ), + stdlib_complex128( 1.0, 1.0 ) +}; +stdlib_complex128_t y[] = { + stdlib_complex128( 0.0, 0.0 ), + stdlib_complex128( 0.0, 0.0 ) +}; + +const stdlib_complex128_t alpha = stdlib_complex128( 1.0, 0.0 ); +const stdlib_complex128_t beta = stdlib_complex128( 0.0, 0.0 ); + +c_zgemv_ndarray( CblasNoTrans, 2, 2, alpha, (void *)A, 2, 1, 0, (void *)x, 1, 0, beta, (void *)y, 1, 0 ); +``` + +The function accepts the following arguments: + +- **trans**: `[in] CBLAS_TRANSPOSE` specifies whether `A` should be transposed, conjugate-transposed, or not transposed. +- **M**: `[in] CBLAS_INT` number of rows in the matrix `A`. +- **N**: `[in] CBLAS_INT` number of columns in the matrix `A`. +- **alpha**: `[in] stdlib_complex128_t` scalar constant. +- **A**: `[in] void*` input matrix. +- **sa1**: `[in] CBLAS_INT` stride of the first dimension of `A`. +- **sa2**: `[in] CBLAS_INT` stride of the second dimension of `A`. +- **oa**: `[in] CBLAS_INT` starting index for `A`. +- **X**: `[in] void*` first input vector. +- **sx**: `[in] CBLAS_INT` stride length for `X`. +- **ox**: `[in] CBLAS_INT` starting index for `X`. +- **beta**: `[in] stdlib_complex128_t` scalar constant. +- **Y**: `[inout] void*` second input vector. +- **sy**: `[in] CBLAS_INT` stride length for `Y`. +- **oy**: `[in] CBLAS_INT` starting index for `Y`. + +```c +void c_zgemv_ndarray( const CBLAS_TRANSPOSE trans, const CBLAS_INT M, const CBLAS_INT N, const stdlib_complex128_t alpha, const void *A, const CBLAS_INT strideA1, const CBLAS_INT strideA2, const CBLAS_INT offsetA, const void *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, const stdlib_complex128_t beta, void *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY ) +``` + +
+ + + + + +
+ +
+ + + + + +
+ +### Examples + +```c +#include "stdlib/blas/base/zgemv.h" +#include "stdlib/blas/base/shared.h" +#include "stdlib/complex/float64/ctor.h" +#include "stdlib/complex/float64/real.h" +#include "stdlib/complex/float64/imag.h" +#include + +int main( void ) { + // Define a 2x2 matrix stored in row-major order: + const stdlib_complex128_t A[] = { + stdlib_complex128( 1.0, 2.0 ), stdlib_complex128( 3.0, 4.0 ), + stdlib_complex128( 5.0, 6.0 ), stdlib_complex128( 7.0, 8.0 ) + }; + + // Define `x` and `y` vectors: + const stdlib_complex128_t x[] = { + stdlib_complex128( 1.0, 1.0 ), + stdlib_complex128( 1.0, 1.0 ) + }; + stdlib_complex128_t y[] = { + stdlib_complex128( 0.0, 0.0 ), + stdlib_complex128( 0.0, 0.0 ) + }; + + // Specify the number of elements along each dimension of `A`: + const int M = 2; + const int N = 2; + + // Define alpha and beta: + const stdlib_complex128_t alpha = stdlib_complex128( 1.0, 0.0 ); + const stdlib_complex128_t beta = stdlib_complex128( 0.0, 0.0 ); + + // Perform the matrix-vector operation `y = α*A*x + β*y`: + c_zgemv( CblasRowMajor, CblasNoTrans, M, N, alpha, (void *)A, N, (void *)x, 1, beta, (void *)y, 1 ); + + // Print the result: + for ( int i = 0; i < M; i++ ) { + printf( "y[ %i ] = %lf + %lfi\n", i, stdlib_complex128_real( y[ i ] ), stdlib_complex128_imag( y[ i ] ) ); + } + + // Reset `y`: + y[ 0 ] = stdlib_complex128( 0.0, 0.0 ); + y[ 1 ] = stdlib_complex128( 0.0, 0.0 ); + + // Perform the matrix-vector operation `y = α*A*x + β*y` using alternative indexing semantics: + c_zgemv_ndarray( CblasNoTrans, M, N, alpha, (void *)A, N, 1, 0, (void *)x, 1, 0, beta, (void *)y, 1, 0 ); + + // Print the result: + for ( int i = 0; i < M; i++ ) { + printf( "y[ %i ] = %lf + %lfi\n", i, stdlib_complex128_real( y[ i ] ), stdlib_complex128_imag( y[ i ] ) ); + } +} +``` + +
+ + + +
+ + + + + +
+ +
+ + + + + +
+ +[blas]: http://www.netlib.org/blas + +[blas-zgemv]: https://www.netlib.org/lapack/explore-html/d3/d6f/group__gemv_ga8e2652de3e24bfc49121c62f8edd5d68.html#ga8e2652de3e24bfc49121c62f8edd5d68 + +[mdn-complex128array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Complex128Array + +[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray + +
+ + diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.js new file mode 100644 index 000000000000..2dd78ef71f9d --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.js @@ -0,0 +1,112 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var bench = require( '@stdlib/bench' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var floor = require( '@stdlib/math/base/special/floor' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var pkg = require( './../package.json' ).name; +var zgemv = require( './../lib/zgemv.js' ); + + +// VARIABLES // + +var options = { + 'dtype': 'float64' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} N - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( N ) { + var alpha = new Complex128( 1.0, 0.0 ); + var xbuf = uniform( N * 2, -10.0, 10.0, options ); + var ybuf = uniform( N * 2, -10.0, 10.0, options ); + var Abuf = uniform( N * N * 2, -10.0, 10.0, options ); + var beta = new Complex128( 1.0, 0.0 ); + var x = new Complex128Array( xbuf.buffer ); + var y = new Complex128Array( ybuf.buffer ); + var A = new Complex128Array( Abuf.buffer ); + + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + zgemv( 'row-major', 'no-transpose', N, N, alpha, A, N, x, 1, beta, y, 1 ); + if ( isnan( ybuf[ i % ( N * 2 ) ] ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( ybuf[ i % ( N * 2 ) ] ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); + } +} + + +// MAIN // + +/** +* Main execution sequence. +* +* @private +*/ +function main() { + var min; + var max; + var N; + var f; + var i; + + min = 1; // 10^min + max = 6; // 10^max + + for ( i = min; i <= max; i++ ) { + N = floor( pow( pow( 10, i ), 1.0 / 2.0 ) ); + f = createBenchmark( N ); + bench( pkg + ':size=' + ( N * N ), f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.native.js new file mode 100644 index 000000000000..3a38b290cc2a --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.native.js @@ -0,0 +1,117 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var resolve = require( 'path' ).resolve; +var bench = require( '@stdlib/bench' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var floor = require( '@stdlib/math/base/special/floor' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var tryRequire = require( '@stdlib/utils/try-require' ); +var pkg = require( './../package.json' ).name; + + +// VARIABLES // + +var zgemv = tryRequire( resolve( __dirname, './../lib/zgemv.native.js' ) ); +var opts = { + 'skip': ( zgemv instanceof Error ) +}; +var options = { + 'dtype': 'float64' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} N - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( N ) { + var alpha = new Complex128( 1.0, 0.0 ); + var xbuf = uniform( N * 2, -10.0, 10.0, options ); + var ybuf = uniform( N * 2, -10.0, 10.0, options ); + var Abuf = uniform( N * N * 2, -10.0, 10.0, options ); + var beta = new Complex128( 1.0, 0.0 ); + var x = new Complex128Array( xbuf.buffer ); + var y = new Complex128Array( ybuf.buffer ); + var A = new Complex128Array( Abuf.buffer ); + + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + zgemv( 'row-major', 'no-transpose', N, N, alpha, A, N, x, 1, beta, y, 1 ); + if ( isnan( ybuf[ i % ( N * 2 ) ] ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( ybuf[ i % ( N * 2 ) ] ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); + } +} + + +// MAIN // + +/** +* Main execution sequence. +* +* @private +*/ +function main() { + var min; + var max; + var N; + var f; + var i; + + min = 1; // 10^min + max = 6; // 10^max + + for ( i = min; i <= max; i++ ) { + N = floor( pow( pow( 10, i ), 1.0 / 2.0 ) ); + f = createBenchmark( N ); + bench( pkg + '::native:size=' + ( N * N ), opts, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.js new file mode 100644 index 000000000000..9e994623121d --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.js @@ -0,0 +1,112 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var bench = require( '@stdlib/bench' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var floor = require( '@stdlib/math/base/special/floor' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var pkg = require( './../package.json' ).name; +var zgemv = require( './../lib/ndarray.js' ); + + +// VARIABLES // + +var options = { + 'dtype': 'float64' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} N - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( N ) { + var alpha = new Complex128( 1.0, 0.0 ); + var xbuf = uniform( N * 2, -10.0, 10.0, options ); + var ybuf = uniform( N * 2, -10.0, 10.0, options ); + var Abuf = uniform( N * N * 2, -10.0, 10.0, options ); + var beta = new Complex128( 1.0, 0.0 ); + var x = new Complex128Array( xbuf.buffer ); + var y = new Complex128Array( ybuf.buffer ); + var A = new Complex128Array( Abuf.buffer ); + + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + zgemv( 'no-transpose', N, N, alpha, A, N, 1, 0, x, 1, 0, beta, y, 1, 0 ); + if ( isnan( ybuf[ i % ( N * 2 ) ] ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( ybuf[ i % ( N * 2 ) ] ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); + } +} + + +// MAIN // + +/** +* Main execution sequence. +* +* @private +*/ +function main() { + var min; + var max; + var N; + var f; + var i; + + min = 1; // 10^min + max = 6; // 10^max + + for ( i = min; i <= max; i++ ) { + N = floor( pow( pow( 10, i ), 1.0 / 2.0 ) ); + f = createBenchmark( N ); + bench( pkg + ':ndarray:size=' + ( N * N ), f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.native.js b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.native.js new file mode 100644 index 000000000000..b096386aa6f7 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.native.js @@ -0,0 +1,117 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var resolve = require( 'path' ).resolve; +var bench = require( '@stdlib/bench' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var floor = require( '@stdlib/math/base/special/floor' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var tryRequire = require( '@stdlib/utils/try-require' ); +var pkg = require( './../package.json' ).name; + + +// VARIABLES // + +var zgemv = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) ); +var opts = { + 'skip': ( zgemv instanceof Error ) +}; +var options = { + 'dtype': 'float64' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} N - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( N ) { + var alpha = new Complex128( 1.0, 0.0 ); + var xbuf = uniform( N * 2, -10.0, 10.0, options ); + var ybuf = uniform( N * 2, -10.0, 10.0, options ); + var Abuf = uniform( N * N * 2, -10.0, 10.0, options ); + var beta = new Complex128( 1.0, 0.0 ); + var x = new Complex128Array( xbuf.buffer ); + var y = new Complex128Array( ybuf.buffer ); + var A = new Complex128Array( Abuf.buffer ); + + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + zgemv( 'no-transpose', N, N, alpha, A, N, 1, 0, x, 1, 0, beta, y, 1, 0 ); + if ( isnan( ybuf[ i % ( N * 2 ) ] ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( ybuf[ i % ( N * 2 ) ] ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); + } +} + + +// MAIN // + +/** +* Main execution sequence. +* +* @private +*/ +function main() { + var min; + var max; + var N; + var f; + var i; + + min = 1; // 10^min + max = 6; // 10^max + + for ( i = min; i <= max; i++ ) { + N = floor( pow( pow( 10, i ), 1.0 / 2.0 ) ); + f = createBenchmark( N ); + bench( pkg + '::native:ndarray:size=' + ( N * N ), opts, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/c/Makefile b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/c/Makefile new file mode 100644 index 000000000000..0756dc7da20a --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/c/Makefile @@ -0,0 +1,146 @@ +#/ +# @license Apache-2.0 +# +# Copyright (c) 2026 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#/ + +# VARIABLES # + +ifndef VERBOSE + QUIET := @ +else + QUIET := +endif + +# Determine the OS ([1][1], [2][2]). +# +# [1]: https://en.wikipedia.org/wiki/Uname#Examples +# [2]: http://stackoverflow.com/a/27776822/2225624 +OS ?= $(shell uname) +ifneq (, $(findstring MINGW,$(OS))) + OS := WINNT +else +ifneq (, $(findstring MSYS,$(OS))) + OS := WINNT +else +ifneq (, $(findstring CYGWIN,$(OS))) + OS := WINNT +else +ifneq (, $(findstring Windows_NT,$(OS))) + OS := WINNT +endif +endif +endif +endif + +# Define the program used for compiling C source files: +ifdef C_COMPILER + CC := $(C_COMPILER) +else + CC := gcc +endif + +# Define the command-line options when compiling C files: +CFLAGS ?= \ + -std=c99 \ + -O3 \ + -Wall \ + -pedantic + +# Determine whether to generate position independent code ([1][1], [2][2]). +# +# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options +# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option +ifeq ($(OS), WINNT) + fPIC ?= +else + fPIC ?= -fPIC +endif + +# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`): +INCLUDE ?= + +# List of source files: +SOURCE_FILES ?= + +# List of libraries (e.g., `-lopenblas -lpthread`): +LIBRARIES ?= + +# List of library paths (e.g., `-L /foo/bar -L /beep/boop`): +LIBPATH ?= + +# List of C targets: +c_targets := benchmark.length.out + + +# RULES # + +#/ +# Compiles source files. +# +# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`) +# @param {string} [CFLAGS] - C compiler options +# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`) +# @param {string} [SOURCE_FILES] - list of source files +# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`) +# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`) +# +# @example +# make +# +# @example +# make all +#/ +all: $(c_targets) + +.PHONY: all + +#/ +# Compiles C source files. +# +# @private +# @param {string} CC - C compiler (e.g., `gcc`) +# @param {string} CFLAGS - C compiler options +# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`) +# @param {string} SOURCE_FILES - list of source files +# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`) +# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`) +#/ +$(c_targets): %.out: %.c + $(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES) + +#/ +# Runs compiled benchmarks. +# +# @example +# make run +#/ +run: $(c_targets) + $(QUIET) ./$< + +.PHONY: run + +#/ +# Removes generated files. +# +# @example +# make clean +#/ +clean: + $(QUIET) -rm -f *.o *.out + +.PHONY: clean diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/c/benchmark.length.c b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/c/benchmark.length.c new file mode 100644 index 000000000000..5e2f9087fd10 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/c/benchmark.length.c @@ -0,0 +1,216 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "stdlib/blas/base/zgemv.h" +#include "stdlib/complex/float64/ctor.h" +#include "stdlib/complex/float64/real.h" +#include "stdlib/complex/float64/imag.h" +#include +#include +#include +#include +#include + +#define NAME "zgemv" +#define ITERATIONS 1000000 +#define REPEATS 3 +#define MIN 1 +#define MAX 6 + +/** +* Prints the TAP version. +*/ +static void print_version( void ) { + printf( "TAP version 13\n" ); +} + +/** +* Prints the TAP summary. +* +* @param total total number of tests +* @param passing total number of passing tests +*/ +static void print_summary( int total, int passing ) { + printf( "#\n" ); + printf( "1..%d\n", total ); // TAP plan + printf( "# total %d\n", total ); + printf( "# pass %d\n", passing ); + printf( "#\n" ); + printf( "# ok\n" ); +} + +/** +* Prints benchmarks results. +* +* @param iterations number of iterations +* @param elapsed elapsed time in seconds +*/ +static void print_results( int iterations, double elapsed ) { + double rate = (double)iterations / elapsed; + printf( " ---\n" ); + printf( " iterations: %d\n", iterations ); + printf( " elapsed: %0.9f\n", elapsed ); + printf( " rate: %0.9f\n", rate ); + printf( " ...\n" ); +} + +/** +* Returns a clock time. +* +* @return clock time +*/ +static double tic( void ) { + struct timeval now; + gettimeofday( &now, NULL ); + return (double)now.tv_sec + (double)now.tv_usec/1.0e6; +} + +/** +* Generates a random number on the interval [0,1). +* +* @return random number +*/ +static double rand_double( void ) { + int r = rand(); + return (double)r / ( (double)RAND_MAX + 1.0 ); +} + +/** +* Runs a benchmark. +* +* @param iterations number of iterations +* @param N array dimension size +* @return elapsed time in seconds +*/ +static double benchmark1( int iterations, int N ) { + double elapsed; + stdlib_complex128_t *A; + stdlib_complex128_t *x; + stdlib_complex128_t *y; + stdlib_complex128_t alpha = stdlib_complex128( 1.0, 1.0 ); + stdlib_complex128_t beta = stdlib_complex128( 1.0, 1.0 ); + double t; + int i; + int j; + + A = (stdlib_complex128_t *)malloc( N * N * sizeof(stdlib_complex128_t) ); + x = (stdlib_complex128_t *)malloc( N * sizeof(stdlib_complex128_t) ); + y = (stdlib_complex128_t *)malloc( N * sizeof(stdlib_complex128_t) ); + + for ( i = 0; i < N; i++ ) { + x[ i ] = stdlib_complex128( ( rand_double()*20.0 ) - 10.0, ( rand_double()*20.0 ) - 10.0 ); + y[ i ] = stdlib_complex128( ( rand_double()*20.0 ) - 10.0, ( rand_double()*20.0 ) - 10.0 ); + for ( j = 0; j < N; j++ ) { + A[ (i*N)+j ] = stdlib_complex128( ( rand_double()*20.0 ) - 10.0, ( rand_double()*20.0 ) - 10.0 ); + } + } + t = tic(); + for ( i = 0; i < iterations; i++ ) { + c_zgemv( CblasRowMajor, CblasNoTrans, N, N, alpha, (void *)A, N, (void *)x, 1, beta, (void *)y, 1 ); + if ( stdlib_complex128_real( y[ i%N ] ) != stdlib_complex128_real( y[ i%N ] ) ) { + printf( "should not return NaN\n" ); + break; + } + } + elapsed = tic() - t; + free( A ); + free( x ); + free( y ); + return elapsed; +} + +/** +* Runs a benchmark. +* +* @param iterations number of iterations +* @param N array dimension size +* @return elapsed time in seconds +*/ +static double benchmark2( int iterations, int N ) { + double elapsed; + stdlib_complex128_t *A; + stdlib_complex128_t *x; + stdlib_complex128_t *y; + stdlib_complex128_t alpha = stdlib_complex128( 1.0, 1.0 ); + stdlib_complex128_t beta = stdlib_complex128( 1.0, 1.0 ); + double t; + int i; + int j; + + A = (stdlib_complex128_t *)malloc( N * N * sizeof(stdlib_complex128_t) ); + x = (stdlib_complex128_t *)malloc( N * sizeof(stdlib_complex128_t) ); + y = (stdlib_complex128_t *)malloc( N * sizeof(stdlib_complex128_t) ); + + for ( i = 0; i < N; i++ ) { + x[ i ] = stdlib_complex128( ( rand_double()*20.0 ) - 10.0, ( rand_double()*20.0 ) - 10.0 ); + y[ i ] = stdlib_complex128( ( rand_double()*20.0 ) - 10.0, ( rand_double()*20.0 ) - 10.0 ); + for ( j = 0; j < N; j++ ) { + A[ (i*N)+j ] = stdlib_complex128( ( rand_double()*20.0 ) - 10.0, ( rand_double()*20.0 ) - 10.0 ); + } + } + t = tic(); + for ( i = 0; i < iterations; i++ ) { + c_zgemv_ndarray( CblasNoTrans, N, N, alpha, (void *)A, N, 1, 0, (void *)x, 1, 0, beta, (void *)y, 1, 0 ); + if ( stdlib_complex128_real( y[ i%N ] ) != stdlib_complex128_real( y[ i%N ] ) ) { + printf( "should not return NaN\n" ); + break; + } + } + elapsed = tic() - t; + free( A ); + free( x ); + free( y ); + return elapsed; +} + +/** +* Main execution sequence. +*/ +int main( void ) { + double elapsed; + int count; + int iter; + int N; + int i; + int j; + + // Use the current time to seed the random number generator: + srand( time( NULL ) ); + + print_version(); + count = 0; + for ( i = MIN; i <= MAX; i++ ) { + N = floor( pow( pow( 10, i ), 1.0/2.0 ) ); + iter = ITERATIONS / pow( 10, i-1 ); + for ( j = 0; j < REPEATS; j++ ) { + count += 1; + printf( "# c::%s:size=%d\n", NAME, N*N ); + elapsed = benchmark1( iter, N ); + print_results( iter, elapsed ); + printf( "ok %d benchmark finished\n", count ); + } + for ( j = 0; j < REPEATS; j++ ) { + count += 1; + printf( "# c::%s:ndarray:size=%d\n", NAME, N*N ); + elapsed = benchmark2( iter, N ); + print_results( iter, elapsed ); + printf( "ok %d benchmark finished\n", count ); + } + } + print_summary( count, count ); +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/binding.gyp b/lib/node_modules/@stdlib/blas/base/zgemv/binding.gyp new file mode 100644 index 000000000000..60dce9d0b31a --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/binding.gyp @@ -0,0 +1,265 @@ +# @license Apache-2.0 +# +# Copyright (c) 2026 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# A `.gyp` file for building a Node.js native add-on. +# +# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md +# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md +{ + # List of files to include in this file: + 'includes': [ + './include.gypi', + ], + + # Define variables to be used throughout the configuration for all targets: + 'variables': { + # Target name should match the add-on export name: + 'addon_target_name%': 'addon', + + # Fortran compiler (to override -Dfortran_compiler=): + 'fortran_compiler%': 'gfortran', + + # Fortran compiler flags: + 'fflags': [ + # Specify the Fortran standard to which a program is expected to conform: + '-std=f95', + + # Indicate that the layout is free-form source code: + '-ffree-form', + + # Aggressive optimization: + '-O3', + + # Enable commonly used warning options: + '-Wall', + + # Warn if source code contains problematic language features: + '-Wextra', + + # Warn if a procedure is called without an explicit interface: + '-Wimplicit-interface', + + # Do not transform names of entities specified in Fortran source files by appending underscores (i.e., don't mangle names, thus allowing easier usage in C wrappers): + '-fno-underscoring', + + # Warn if source code contains Fortran 95 extensions and C-language constructs: + '-pedantic', + + # Compile but do not link (output is an object file): + '-c', + ], + + # Set variables based on the host OS: + 'conditions': [ + [ + 'OS=="win"', + { + # Define the object file suffix: + 'obj': 'obj', + }, + { + # Define the object file suffix: + 'obj': 'o', + } + ], # end condition (OS=="win") + ], # end conditions + }, # end variables + + # Define compile targets: + 'targets': [ + + # Target to generate an add-on: + { + # The target name should match the add-on export name: + 'target_name': '<(addon_target_name)', + + # Define dependencies: + 'dependencies': [], + + # Define directories which contain relevant include headers: + 'include_dirs': [ + # Local include directory: + '<@(include_dirs)', + ], + + # List of source files: + 'sources': [ + '<@(src_files)', + ], + + # Settings which should be applied when a target's object files are used as linker input: + 'link_settings': { + # Define libraries: + 'libraries': [ + '<@(libraries)', + ], + + # Define library directories: + 'library_dirs': [ + '<@(library_dirs)', + ], + }, + + # C/C++ compiler flags: + 'cflags': [ + # Enable commonly used warning options: + '-Wall', + + # Aggressive optimization: + '-O3', + ], + + # C specific compiler flags: + 'cflags_c': [ + # Specify the C standard to which a program is expected to conform: + '-std=c99', + ], + + # C++ specific compiler flags: + 'cflags_cpp': [ + # Specify the C++ standard to which a program is expected to conform: + '-std=c++11', + ], + + # Linker flags: + 'ldflags': [], + + # Apply conditions based on the host OS: + 'conditions': [ + [ + 'OS=="mac"', + { + # Linker flags: + 'ldflags': [ + '-undefined dynamic_lookup', + '-Wl,-no-pie', + '-Wl,-search_paths_first', + ], + }, + ], # end condition (OS=="mac") + [ + 'OS!="win"', + { + # C/C++ flags: + 'cflags': [ + # Generate platform-independent code: + '-fPIC', + ], + }, + ], # end condition (OS!="win") + ], # end conditions + + # Define custom build actions for particular inputs: + 'rules': [ + { + # Define a rule for processing Fortran files: + 'extension': 'f', + + # Define the pathnames to be used as inputs when performing processing: + 'inputs': [ + # Full path of the current input: + '<(RULE_INPUT_PATH)' + ], + + # Define the outputs produced during processing: + 'outputs': [ + # Store an output object file in a directory for placing intermediate results (only accessible within a single target): + '<(INTERMEDIATE_DIR)/<(RULE_INPUT_ROOT).<(obj)' + ], + + # Define the rule for compiling Fortran based on the host OS: + 'conditions': [ + [ + 'OS=="win"', + + # Rule to compile Fortran on Windows: + { + 'rule_name': 'compile_fortran_windows', + 'message': 'Compiling Fortran file <(RULE_INPUT_PATH) on Windows...', + + 'process_outputs_as_sources': 0, + + # Define the command-line invocation: + 'action': [ + '<(fortran_compiler)', + '<@(fflags)', + '<@(_inputs)', + '-o', + '<@(_outputs)', + ], + }, + + # Rule to compile Fortran on non-Windows: + { + 'rule_name': 'compile_fortran_linux', + 'message': 'Compiling Fortran file <(RULE_INPUT_PATH) on Linux...', + + 'process_outputs_as_sources': 1, + + # Define the command-line invocation: + 'action': [ + '<(fortran_compiler)', + '<@(fflags)', + '-fPIC', # generate platform-independent code + '<@(_inputs)', + '-o', + '<@(_outputs)', + ], + } + ], # end condition (OS=="win") + ], # end conditions + }, # end rule (extension=="f") + ], # end rules + }, # end target <(addon_target_name) + + # Target to copy a generated add-on to a standard location: + { + 'target_name': 'copy_addon', + + # Declare that the output of this target is not linked: + 'type': 'none', + + # Define dependencies: + 'dependencies': [ + # Require that the add-on be generated before building this target: + '<(addon_target_name)', + ], + + # Define a list of actions: + 'actions': [ + { + 'action_name': 'copy_addon', + 'message': 'Copying addon...', + + # Explicitly list the inputs in the command-line invocation below: + 'inputs': [], + + # Declare the expected outputs: + 'outputs': [ + '<(addon_output_dir)/<(addon_target_name).node', + ], + + # Define the command-line invocation: + 'action': [ + 'cp', + '<(PRODUCT_DIR)/<(addon_target_name).node', + '<(addon_output_dir)/<(addon_target_name).node', + ], + }, + ], # end actions + }, # end target copy_addon + ], # end targets +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/docs/repl.txt b/lib/node_modules/@stdlib/blas/base/zgemv/docs/repl.txt new file mode 100644 index 000000000000..a9b2dd07a572 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/docs/repl.txt @@ -0,0 +1,156 @@ + +{{alias}}( order, trans, M, N, α, A, lda, x, sx, β, y, sy ) + Performs one of the matrix-vector operations `y = α*A*x + β*y`, + `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, where `α` and `β` are + scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. + + Indexing is relative to the first index. To introduce an offset, use typed + array views. + + If `M` or `N` is equal to `0`, the function returns `y` unchanged. + + If `α` equals `0+0i` and `β` equals `1+0i`, the function returns `y` + unchanged. + + Parameters + ---------- + order: string + Row-major (C-style) or column-major (Fortran-style) order. + + trans: string + Specifies whether `A` should be transposed, conjugate-transposed, or not + transposed. + + M: integer + Number of rows in `A`. + + N: integer + Number of columns in `A`. + + α: Complex128 + Scalar constant. + + A: Complex128Array + Input matrix. + + lda: integer + Stride of the first dimension of `A` (a.k.a., leading dimension of the + matrix `A`). + + x: Complex128Array + First input vector. + + sx: integer + Index increment for `x`. + + β: Complex128 + Scalar constant. + + y: Complex128Array + Second input vector. + + sy: integer + Index increment for `y`. + + Returns + ------- + y: Complex128Array + Second input vector. + + Examples + -------- + > var x = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0 ] ); + > var y = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0 ] ); + > var values = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ]; + > var A = new {{alias:@stdlib/array/complex128}}( values ); + > var alpha = new {{alias:@stdlib/complex/float64/ctor}}( 1.0, 0.0 ); + > var beta = new {{alias:@stdlib/complex/float64/ctor}}( 1.0, 0.0 ); + > var ord = 'row-major'; + > var trans = 'no-transpose'; + > {{alias}}( ord, trans, 2, 2, alpha, A, 2, x, 1, beta, y, 1 ) + + > var v = y.get( 0 ); + > var re = {{alias:@stdlib/complex/float64/real}}( v ) + -1.0 + > var im = {{alias:@stdlib/complex/float64/imag}}( v ) + 11.0 + + +{{alias}}.ndarray( trans, M, N, α, A, sa1, sa2, oa, x, sx, ox, β, y, sy, oy ) + Performs one of the matrix-vector operations `y = α*A*x + β*y`, + `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, using alternative indexing + semantics and where `α` and `β` are scalars, `x` and `y` are vectors, and + `A` is an `M` by `N` matrix. + + While typed array views mandate a view offset based on the underlying + buffer, the offset parameters support indexing semantics based on starting + indices. + + Parameters + ---------- + trans: string + Specifies whether `A` should be transposed, conjugate-transposed, or not + transposed. + + M: integer + Number of rows in `A`. + + N: integer + Number of columns in `A`. + + α: Complex128 + Scalar constant. + + A: Complex128Array + Input matrix. + + sa1: integer + Stride of the first dimension of `A`. + + sa2: integer + Stride of the second dimension of `A`. + + oa: integer + Starting index for `A`. + + x: Complex128Array + First input vector. + + sx: integer + Index increment for `x`. + + ox: integer + Starting index for `x`. + + β: Complex128 + Scalar constant. + + y: Complex128Array + Second input vector. + + sy: integer + Index increment for `y`. + + oy: integer + Starting index for `y`. + + Returns + ------- + y: Complex128Array + Second input vector. + + Examples + -------- + > var x = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0 ] ); + > var y = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0 ] ); + > var values = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ]; + > var A = new {{alias:@stdlib/array/complex128}}( values ); + > var alpha = new {{alias:@stdlib/complex/float64/ctor}}( 1.0, 0.0 ); + > var beta = new {{alias:@stdlib/complex/float64/ctor}}( 1.0, 0.0 ); + > var trans = 'no-transpose'; + > {{alias}}.ndarray( trans, 2, 2, alpha, A, 2, 1, 0, x, 1, 0, beta, y, + ... 1, 0 ) + + + See Also + -------- diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/base/zgemv/docs/types/index.d.ts new file mode 100644 index 000000000000..02a6e1dd01e8 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/docs/types/index.d.ts @@ -0,0 +1,147 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +// TypeScript Version: 4.1 + +/// + +import { Layout, TransposeOperation } from '@stdlib/types/blas'; +import { Complex128Array } from '@stdlib/types/array'; +import { Complex128 } from '@stdlib/types/complex'; + +/** +* Interface describing `zgemv`. +*/ +interface Routine { + /** + * Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. + * + * @param order - storage layout + * @param trans - specifies whether `A` should be transposed, conjugate-transposed, or not transposed + * @param M - number of rows in the matrix `A` + * @param N - number of columns in the matrix `A` + * @param alpha - scalar constant + * @param A - input matrix + * @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) + * @param x - first input vector + * @param strideX - `x` stride length + * @param beta - scalar constant + * @param y - second input vector + * @param strideY - `y` stride length + * @returns `y` + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * var Complex128 = require( '@stdlib/complex/float64/ctor' ); + * + * var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + * var x = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0 ] ); + * var y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0 ] ); + * var alpha = new Complex128( 1.0, 0.0 ); + * var beta = new Complex128( 1.0, 0.0 ); + * + * zgemv( 'row-major', 'no-transpose', 2, 2, alpha, A, 2, x, 1, beta, y, 1 ); + * // y => + */ + ( order: Layout, trans: TransposeOperation, M: number, N: number, alpha: Complex128, A: Complex128Array, LDA: number, x: Complex128Array, strideX: number, beta: Complex128, y: Complex128Array, strideY: number ): Complex128Array; + + /** + * Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, using alternative indexing semantics and where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. + * + * @param trans - specifies whether `A` should be transposed, conjugate-transposed, or not transposed + * @param M - number of rows in the matrix `A` + * @param N - number of columns in the matrix `A` + * @param alpha - scalar constant + * @param A - input matrix + * @param strideA1 - stride of the first dimension of `A` + * @param strideA2 - stride of the second dimension of `A` + * @param offsetA - starting index for `A` + * @param x - first input vector + * @param strideX - `x` stride length + * @param offsetX - starting index for `x` + * @param beta - scalar constant + * @param y - second input vector + * @param strideY - `y` stride length + * @param offsetY - starting index for `y` + * @returns `y` + * + * @example + * var Complex128Array = require( '@stdlib/array/complex128' ); + * var Complex128 = require( '@stdlib/complex/float64/ctor' ); + * + * var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + * var x = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0 ] ); + * var y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0 ] ); + * var alpha = new Complex128( 1.0, 0.0 ); + * var beta = new Complex128( 1.0, 0.0 ); + * + * zgemv.ndarray( 'no-transpose', 2, 2, alpha, A, 2, 1, 0, x, 1, 0, beta, y, 1, 0 ); + * // y => + */ + ndarray( trans: TransposeOperation, M: number, N: number, alpha: Complex128, A: Complex128Array, strideA1: number, strideA2: number, offsetA: number, x: Complex128Array, strideX: number, offsetX: number, beta: Complex128, y: Complex128Array, strideY: number, offsetY: number ): Complex128Array; +} + +/** +* Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. +* +* @param order - storage layout +* @param trans - specifies whether `A` should be transposed, conjugate-transposed, or not transposed +* @param M - number of rows in the matrix `A` +* @param N - number of columns in the matrix `A` +* @param alpha - scalar constant +* @param A - input matrix +* @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) +* @param x - first input vector +* @param strideX - `x` stride length +* @param beta - scalar constant +* @param y - second input vector +* @param strideY - `y` stride length +* @returns `y` +* +* @example +* var Complex128Array = require( '@stdlib/array/complex128' ); +* var Complex128 = require( '@stdlib/complex/float64/ctor' ); +* +* var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); +* var x = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0 ] ); +* var y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0 ] ); +* var alpha = new Complex128( 1.0, 0.0 ); +* var beta = new Complex128( 1.0, 0.0 ); +* +* zgemv( 'row-major', 'no-transpose', 2, 2, alpha, A, 2, x, 1, beta, y, 1 ); +* // y => +* +* @example +* var Complex128Array = require( '@stdlib/array/complex128' ); +* var Complex128 = require( '@stdlib/complex/float64/ctor' ); +* +* var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); +* var x = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0 ] ); +* var y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0 ] ); +* var alpha = new Complex128( 1.0, 0.0 ); +* var beta = new Complex128( 1.0, 0.0 ); +* +* zgemv.ndarray( 'no-transpose', 2, 2, alpha, A, 2, 1, 0, x, 1, 0, beta, y, 1, 0 ); +* // y => +*/ +declare var zgemv: Routine; + + +// EXPORTS // + +export = zgemv; diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/docs/types/test.ts b/lib/node_modules/@stdlib/blas/base/zgemv/docs/types/test.ts new file mode 100644 index 000000000000..b84178353be7 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/docs/types/test.ts @@ -0,0 +1,301 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +import Complex128Array = require( '@stdlib/array/complex128' ); +import Complex128 = require( '@stdlib/complex/float64/ctor' ); +import zgemv = require( './index' ); + + +// TESTS // + +// The function returns a Complex128Array... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + + zgemv( 'row-major', 'no-transpose', 10, 10, new Complex128( 1.0, 0.0 ), A, 10, x, 1, new Complex128( 1.0, 0.0 ), y, 1 ); // $ExpectType Complex128Array +} + +// The compiler throws an error if the function is provided a first argument which is not a string... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 1.0, 0.0 ); + const beta = new Complex128( 1.0, 0.0 ); + + zgemv( 10, 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( true, 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( false, 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( null, 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( undefined, 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( [], 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( {}, 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( ( x: number ): number => x, 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a second argument which is not a string... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 1.0, 0.0 ); + const beta = new Complex128( 1.0, 0.0 ); + + zgemv( 'row-major', 10, 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', true, 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', false, 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', null, 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', undefined, 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', [ '1' ], 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', {}, 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', ( x: number ): number => x, 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a third argument which is not a number... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 1.0, 0.0 ); + const beta = new Complex128( 1.0, 0.0 ); + + zgemv( 'row-major', 'no-transpose', '10', 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', true, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', false, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', null, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', undefined, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', [], 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', {}, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', ( x: number ): number => x, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fourth argument which is not a number... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 1.0, 0.0 ); + const beta = new Complex128( 1.0, 0.0 ); + + zgemv( 'row-major', 'no-transpose', 10, '10', alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, true, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, false, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, null, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, undefined, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, [], alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, {}, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, ( x: number ): number => x, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fifth argument which is not a Complex128... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const beta = new Complex128( 1.0, 0.0 ); + + zgemv( 'row-major', 'no-transpose', 10, 10, '10', A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, 10, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, true, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, false, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, null, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, undefined, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, [], A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, {}, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, ( x: number ): number => x, A, 10, x, 1, beta, y, 1 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a sixth argument which is not a Complex128Array... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const alpha = new Complex128( 1.0, 0.0 ); + const beta = new Complex128( 1.0, 0.0 ); + + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, 10, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, '10', 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, true, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, false, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, null, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, undefined, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, [ '1' ], 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, {}, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, ( x: number ): number => x, 10, x, 1, beta, y, 1 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a seventh argument which is not a number... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 1.0, 0.0 ); + const beta = new Complex128( 1.0, 0.0 ); + + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, '10', x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, true, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, false, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, null, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, undefined, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, [], x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, {}, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, ( x: number ): number => x, x, 1, beta, y, 1 ); // $ExpectError +} + +// The compiler throws an error if the function is provided an eighth argument which is not a Complex128Array... +{ + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 1.0, 0.0 ); + const beta = new Complex128( 1.0, 0.0 ); + + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, 10, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, '10', 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, true, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, false, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, null, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, undefined, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, [ '1' ], 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, {}, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, ( x: number ): number => x, 1, beta, y, 1 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a ninth argument which is not a number... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 1.0, 0.0 ); + const beta = new Complex128( 1.0, 0.0 ); + + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, '10', beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, true, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, false, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, null, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, undefined, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, [], beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, {}, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, ( x: number ): number => x, beta, y, 1 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a tenth argument which is not a Complex128... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 1.0, 0.0 ); + + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, '10', y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, 10, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, true, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, false, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, null, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, undefined, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, [], y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, {}, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, ( x: number ): number => x, y, 1 ); // $ExpectError +} + +// The compiler throws an error if the function is provided an eleventh argument which is not a Complex128Array... +{ + const x = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 1.0, 0.0 ); + const beta = new Complex128( 1.0, 0.0 ); + + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, 10, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, '10', 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, true, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, false, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, null, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, undefined, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, [ '1' ], 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, {}, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, ( x: number ): number => x, 1 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a twelfth argument which is not a number... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 1.0, 0.0 ); + const beta = new Complex128( 1.0, 0.0 ); + + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, '10' ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, true ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, false ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, null ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, undefined ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, [] ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, {} ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the function is provided an unsupported number of arguments... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 1.0, 0.0 ); + const beta = new Complex128( 1.0, 0.0 ); + + zgemv( ); // $ExpectError + zgemv( 'row-major' ); // $ExpectError + zgemv( 'row-major', 'no-transpose' ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, 1, 10 ); // $ExpectError +} + +// Attached to main export is an `ndarray` method which returns a Complex128Array... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 1.0, 0.0 ); + const beta = new Complex128( 1.0, 0.0 ); + + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectType Complex128Array +} + +// The compiler throws an error if the function is provided a first argument which is not a string... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 1.0, 0.0 ); + const beta = new Complex128( 1.0, 0.0 ); + + zgemv.ndarray( 10, 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( true, 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( false, 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( null, 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( undefined, 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( [ '1' ], 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( {}, 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( ( x: number ): number => x, 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/examples/c/Makefile b/lib/node_modules/@stdlib/blas/base/zgemv/examples/c/Makefile new file mode 100644 index 000000000000..c8f8e9a1517b --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/examples/c/Makefile @@ -0,0 +1,146 @@ +#/ +# @license Apache-2.0 +# +# Copyright (c) 2026 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#/ + +# VARIABLES # + +ifndef VERBOSE + QUIET := @ +else + QUIET := +endif + +# Determine the OS ([1][1], [2][2]). +# +# [1]: https://en.wikipedia.org/wiki/Uname#Examples +# [2]: http://stackoverflow.com/a/27776822/2225624 +OS ?= $(shell uname) +ifneq (, $(findstring MINGW,$(OS))) + OS := WINNT +else +ifneq (, $(findstring MSYS,$(OS))) + OS := WINNT +else +ifneq (, $(findstring CYGWIN,$(OS))) + OS := WINNT +else +ifneq (, $(findstring Windows_NT,$(OS))) + OS := WINNT +endif +endif +endif +endif + +# Define the program used for compiling C source files: +ifdef C_COMPILER + CC := $(C_COMPILER) +else + CC := gcc +endif + +# Define the command-line options when compiling C files: +CFLAGS ?= \ + -std=c99 \ + -O3 \ + -Wall \ + -pedantic + +# Determine whether to generate position independent code ([1][1], [2][2]). +# +# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options +# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option +ifeq ($(OS), WINNT) + fPIC ?= +else + fPIC ?= -fPIC +endif + +# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`): +INCLUDE ?= + +# List of source files: +SOURCE_FILES ?= + +# List of libraries (e.g., `-lopenblas -lpthread`): +LIBRARIES ?= + +# List of library paths (e.g., `-L /foo/bar -L /beep/boop`): +LIBPATH ?= + +# List of C targets: +c_targets := example.out + + +# RULES # + +#/ +# Compiles source files. +# +# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`) +# @param {string} [CFLAGS] - C compiler options +# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`) +# @param {string} [SOURCE_FILES] - list of source files +# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`) +# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`) +# +# @example +# make +# +# @example +# make all +#/ +all: $(c_targets) + +.PHONY: all + +#/ +# Compiles C source files. +# +# @private +# @param {string} CC - C compiler (e.g., `gcc`) +# @param {string} CFLAGS - C compiler options +# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`) +# @param {string} SOURCE_FILES - list of source files +# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`) +# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`) +#/ +$(c_targets): %.out: %.c + $(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES) + +#/ +# Runs compiled examples. +# +# @example +# make run +#/ +run: $(c_targets) + $(QUIET) ./$< + +.PHONY: run + +#/ +# Removes generated files. +# +# @example +# make clean +#/ +clean: + $(QUIET) -rm -f *.o *.out + +.PHONY: clean diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/examples/c/example.c b/lib/node_modules/@stdlib/blas/base/zgemv/examples/c/example.c new file mode 100644 index 000000000000..e0c5a1cdce29 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/examples/c/example.c @@ -0,0 +1,70 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "stdlib/blas/base/zgemv.h" +#include "stdlib/blas/base/shared.h" +#include "stdlib/complex/float64/ctor.h" +#include "stdlib/complex/float64/real.h" +#include "stdlib/complex/float64/imag.h" +#include + +int main( void ) { + // Define a 2x2 matrix stored in row-major order: + const stdlib_complex128_t A[] = { + stdlib_complex128( 1.0, 2.0 ), stdlib_complex128( 3.0, 4.0 ), + stdlib_complex128( 5.0, 6.0 ), stdlib_complex128( 7.0, 8.0 ) + }; + + // Define `x` and `y` vectors: + const stdlib_complex128_t x[] = { + stdlib_complex128( 1.0, 1.0 ), + stdlib_complex128( 1.0, 1.0 ) + }; + stdlib_complex128_t y[] = { + stdlib_complex128( 0.0, 0.0 ), + stdlib_complex128( 0.0, 0.0 ) + }; + + // Specify the number of elements along each dimension of `A`: + const int M = 2; + const int N = 2; + + // Define alpha and beta: + const stdlib_complex128_t alpha = stdlib_complex128( 1.0, 0.0 ); + const stdlib_complex128_t beta = stdlib_complex128( 0.0, 0.0 ); + + // Perform the matrix-vector operation `y = α*A*x + β*y`: + c_zgemv( CblasRowMajor, CblasNoTrans, M, N, alpha, (void *)A, N, (void *)x, 1, beta, (void *)y, 1 ); + + // Print the result: + for ( int i = 0; i < M; i++ ) { + printf( "y[ %i ] = %lf + %lfi\n", i, stdlib_complex128_real( y[ i ] ), stdlib_complex128_imag( y[ i ] ) ); + } + + // Reset `y`: + y[ 0 ] = stdlib_complex128( 0.0, 0.0 ); + y[ 1 ] = stdlib_complex128( 0.0, 0.0 ); + + // Perform the matrix-vector operation `y = α*A*x + β*y` using alternative indexing semantics: + c_zgemv_ndarray( CblasNoTrans, M, N, alpha, (void *)A, N, 1, 0, (void *)x, 1, 0, beta, (void *)y, 1, 0 ); + + // Print the result: + for ( int i = 0; i < M; i++ ) { + printf( "y[ %i ] = %lf + %lfi\n", i, stdlib_complex128_real( y[ i ] ), stdlib_complex128_imag( y[ i ] ) ); + } +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/examples/index.js b/lib/node_modules/@stdlib/blas/base/zgemv/examples/index.js new file mode 100644 index 000000000000..3d7413c68812 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/examples/index.js @@ -0,0 +1,71 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var Complex128Array = require( '@stdlib/array/complex128' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var zgemv = require( './../lib/zgemv.js' ); + + +// MAIN // + +var A = new Complex128Array([ + 1.0, + 2.0, // A[0,0] + 3.0, + 4.0, // A[0,1] + 5.0, + 6.0, // A[0,2] + 7.0, + 8.0, // A[1,0] + 9.0, + 10.0, // A[1,1] + 11.0, + 12.0 // A[1,2] +]); + +var x = new Complex128Array([ + 1.0, + 1.0, // x[0] + 1.0, + 1.0, // x[1] + 1.0, + 1.0 // x[2] +]); + +var y = new Complex128Array([ + 1.0, + 1.0, // y[0] + 1.0, + 1.0 // y[1] +]); + +var alpha = new Complex128( 1.0, 0.0 ); +var beta = new Complex128( 1.0, 0.0 ); + +console.log( 'Before zgemv:' ); +console.log( y.toString() ); + +// Perform y = α*A*x + β*y +zgemv( 'row-major', 'no-transpose', 2, 3, alpha, A, 3, x, 1, beta, y, 1 ); + +console.log( '\nAfter zgemv:' ); +console.log( y.toString() ); diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/include.gypi b/lib/node_modules/@stdlib/blas/base/zgemv/include.gypi new file mode 100644 index 000000000000..dcb556d250e8 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/include.gypi @@ -0,0 +1,70 @@ +# @license Apache-2.0 +# +# Copyright (c) 2026 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# A GYP include file for building a Node.js native add-on. +# +# Note that nesting variables is required due to how GYP processes a configuration. Any variables defined within a nested 'variables' section is defined in the outer scope. Thus, conditions in the outer variable scope are free to use these variables without running into "variable undefined" errors. +# +# Main documentation: +# +# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md +# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md +# +# Variable nesting hacks: +# +# [3]: https://chromium.googlesource.com/external/skia/gyp/+/master/common_variables.gypi +# [4]: https://src.chromium.org/viewvc/chrome/trunk/src/build/common.gypi?revision=127004 +{ + # Define variables to be used throughout the configuration for all targets: + 'variables': { + 'variables': { + # Host BLAS library (to override -Dblas=): + 'blas%': '', + + # Path to BLAS library (to override -Dblas_dir=): + 'blas_dir%': '', + }, # end variables + + # Source directory: + 'src_dir': './src', + + # Include directories: + 'include_dirs': [ + '<@(blas_dir)', + ' +*/ +function zgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, offsetX, beta, y, strideY, offsetY ) { // eslint-disable-line max-params, max-len + if ( !isMatrixTranspose( trans ) ) { + throw new TypeError( format( 'invalid argument. First argument must be a valid transpose operation. Value: `%s`.', trans ) ); + } + if ( M < 0 ) { + throw new RangeError( format( 'invalid argument. Second argument must be a nonnegative integer. Value: `%d`.', M ) ); + } + if ( N < 0 ) { + throw new RangeError( format( 'invalid argument. Third argument must be a nonnegative integer. Value: `%d`.', N ) ); + } + if ( strideX === 0 ) { + throw new RangeError( format( 'invalid argument. Tenth argument must be non-zero. Value: `%d`.', strideX ) ); + } + if ( strideY === 0 ) { + throw new RangeError( format( 'invalid argument. Fourteenth argument must be non-zero. Value: `%d`.', strideY ) ); + } + // Check if we can early return... + if ( M === 0 || N === 0 || ( real( alpha ) === 0.0 && imag( alpha ) === 0.0 && real( beta ) === 1.0 && imag( beta ) === 0.0 ) ) { + return y; + } + return base( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, offsetX, beta, y, strideY, offsetY ); // eslint-disable-line max-len +} + + +// EXPORTS // + +module.exports = zgemv; diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/lib/ndarray.native.js b/lib/node_modules/@stdlib/blas/base/zgemv/lib/ndarray.native.js new file mode 100644 index 000000000000..8aecdc829ca8 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/lib/ndarray.native.js @@ -0,0 +1,91 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var reinterpret = require( '@stdlib/strided/base/reinterpret-complex128' ); +var resolveTrans = require( '@stdlib/blas/base/transpose-operation-resolve-enum' ); +var format = require( '@stdlib/string/format' ); +var addon = require( './../src/addon.node' ); + + +// MAIN // + +/** +* Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, using alternative indexing semantics and where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. +* +* @param {string} trans - specifies whether `A` should be transposed, conjugate-transposed, or not transposed +* @param {NonNegativeInteger} M - number of rows in the matrix `A` +* @param {NonNegativeInteger} N - number of columns in the matrix `A` +* @param {Complex128} alpha - scalar constant +* @param {Complex128Array} A - input matrix +* @param {integer} strideA1 - stride of the first dimension of `A` +* @param {integer} strideA2 - stride of the second dimension of `A` +* @param {NonNegativeInteger} offsetA - starting index for `A` +* @param {Complex128Array} x - first input vector +* @param {integer} strideX - `x` stride length +* @param {NonNegativeInteger} offsetX - starting index for `x` +* @param {Complex128} beta - scalar constant +* @param {Complex128Array} y - second input vector +* @param {integer} strideY - `y` stride length +* @param {NonNegativeInteger} offsetY - starting index for `y` +* @throws {RangeError} tenth argument must be non-zero +* @throws {RangeError} fourteenth argument must be non-zero +* @returns {Complex128Array} `y` +* +* @example +* var Complex128Array = require( '@stdlib/array/complex128' ); +* var Complex128 = require( '@stdlib/complex/float64/ctor' ); +* +* var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); +* var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); +* var y = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0 ] ); +* +* zgemv( 'no-transpose', 2, 3, new Complex128( 1.0, 0.0 ), A, 3, 1, 0, x, 1, 0, new Complex128( 1.0, 0.0 ), y, 1, 0 ); +* // y => +*/ +function zgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, offsetX, beta, y, strideY, offsetY ) { // eslint-disable-line max-params, max-len + var viewA; + var viewX; + var viewY; + + if ( M < 0 ) { + throw new RangeError( format( 'invalid argument. Second argument must be a nonnegative integer. Value: `%d`.', M ) ); + } + if ( N < 0 ) { + throw new RangeError( format( 'invalid argument. Third argument must be a nonnegative integer. Value: `%d`.', N ) ); + } + if ( strideX === 0 ) { + throw new RangeError( format( 'invalid argument. Tenth argument must be non-zero. Value: `%d`.', strideX ) ); + } + if ( strideY === 0 ) { + throw new RangeError( format( 'invalid argument. Fourteenth argument must be non-zero. Value: `%d`.', strideY ) ); + } + viewA = reinterpret( A, 0 ); + viewX = reinterpret( x, 0 ); + viewY = reinterpret( y, 0 ); + addon.ndarray( resolveTrans( trans ), M, N, alpha, viewA, strideA1, strideA2, offsetA, viewX, strideX, offsetX, beta, viewY, strideY, offsetY ); // eslint-disable-line max-len + return y; +} + + +// EXPORTS // + +module.exports = zgemv; diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/lib/zgemv.js b/lib/node_modules/@stdlib/blas/base/zgemv/lib/zgemv.js new file mode 100644 index 000000000000..742ec854056a --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/lib/zgemv.js @@ -0,0 +1,134 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var isLayout = require( '@stdlib/blas/base/assert/is-layout' ); +var isMatrixTranspose = require( '@stdlib/blas/base/assert/is-transpose-operation' ); +var isColumnMajor = require( '@stdlib/ndarray/base/assert/is-column-major-string' ); +var stride2offset = require( '@stdlib/strided/base/stride2offset' ); +var max = require( '@stdlib/math/base/special/fast/max' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); +var format = require( '@stdlib/string/format' ); +var base = require( './base.js' ); + + +// MAIN // + +/** +* Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. +* +* @param {string} order - storage layout +* @param {string} trans - specifies whether `A` should be transposed, conjugate-transposed, or not transposed +* @param {NonNegativeInteger} M - number of rows in the matrix `A` +* @param {NonNegativeInteger} N - number of columns in the matrix `A` +* @param {Complex128} alpha - scalar constant +* @param {Complex128Array} A - input matrix +* @param {PositiveInteger} LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) +* @param {Complex128Array} x - first input vector +* @param {integer} strideX - `x` stride length +* @param {Complex128} beta - scalar constant +* @param {Complex128Array} y - second input vector +* @param {integer} strideY - `y` stride length +* @throws {TypeError} first argument must be a valid order +* @throws {TypeError} second argument must be a valid transpose operation +* @throws {RangeError} third argument must be a nonnegative integer +* @throws {RangeError} fourth argument must be a nonnegative integer +* @throws {RangeError} seventh argument must be a valid stride +* @throws {RangeError} ninth argument must be non-zero +* @throws {RangeError} twelfth argument must be non-zero +* @returns {Complex128Array} `y` +* +* @example +* var Complex128Array = require( '@stdlib/array/complex128' ); +* var Complex128 = require( '@stdlib/complex/float64/ctor' ); +* +* var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); +* var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); +* var y = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0 ] ); +* +* zgemv( 'row-major', 'no-transpose', 2, 3, new Complex128( 1.0, 0.0 ), A, 3, x, 1, new Complex128( 1.0, 0.0 ), y, 1 ); +* // y => +*/ +function zgemv( order, trans, M, N, alpha, A, LDA, x, strideX, beta, y, strideY ) { // eslint-disable-line max-params, max-len + var iscm; + var vala; + var xlen; + var ylen; + var sa1; + var sa2; + var ox; + var oy; + + if ( !isLayout( order ) ) { + throw new TypeError( format( 'invalid argument. First argument must be a valid order. Value: `%s`.', order ) ); + } + if ( !isMatrixTranspose( trans ) ) { + throw new TypeError( format( 'invalid argument. Second argument must be a valid transpose operation. Value: `%s`.', trans ) ); + } + if ( M < 0 ) { + throw new RangeError( format( 'invalid argument. Third argument must be a nonnegative integer. Value: `%d`.', M ) ); + } + if ( N < 0 ) { + throw new RangeError( format( 'invalid argument. Fourth argument must be a nonnegative integer. Value: `%d`.', N ) ); + } + iscm = isColumnMajor( order ); + if ( iscm ) { + vala = M; + } else { + vala = N; + } + if ( LDA < max( 1, vala ) ) { + throw new RangeError( format( 'invalid argument. Seventh argument must be greater than or equal to max(1,%d). Value: `%d`.', vala, LDA ) ); + } + if ( strideX === 0 ) { + throw new RangeError( format( 'invalid argument. Ninth argument must be non-zero. Value: `%d`.', strideX ) ); + } + if ( strideY === 0 ) { + throw new RangeError( format( 'invalid argument. Twelfth argument must be non-zero. Value: `%d`.', strideY ) ); + } + // Check if we can early return... + if ( M === 0 || N === 0 || ( real( alpha ) === 0.0 && imag( alpha ) === 0.0 && real( beta ) === 1.0 && imag( beta ) === 0.0 ) ) { + return y; + } + if ( trans === 'no-transpose' ) { + xlen = N; + ylen = M; + } else { + xlen = M; + ylen = N; + } + ox = stride2offset( xlen, strideX ); + oy = stride2offset( ylen, strideY ); + if ( iscm ) { + sa1 = 1; + sa2 = LDA; + } else { // order === 'row-major' + sa1 = LDA; + sa2 = 1; + } + return base( trans, M, N, alpha, A, sa1, sa2, 0, x, strideX, ox, beta, y, strideY, oy ); // eslint-disable-line max-len +} + + +// EXPORTS // + +module.exports = zgemv; diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/lib/zgemv.native.js b/lib/node_modules/@stdlib/blas/base/zgemv/lib/zgemv.native.js new file mode 100644 index 000000000000..27f3d11f6e4c --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/lib/zgemv.native.js @@ -0,0 +1,119 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var isLayout = require( '@stdlib/blas/base/assert/is-layout' ); +var isMatrixTranspose = require( '@stdlib/blas/base/assert/is-transpose-operation' ); +var isColumnMajor = require( '@stdlib/ndarray/base/assert/is-column-major-string' ); +var max = require( '@stdlib/math/base/special/fast/max' ); +var reinterpret = require( '@stdlib/strided/base/reinterpret-complex128' ); +var resolveOrder = require( '@stdlib/blas/base/layout-resolve-enum' ); +var resolveTrans = require( '@stdlib/blas/base/transpose-operation-resolve-enum' ); +var real = require( '@stdlib/complex/float64/real' ); +var imag = require( '@stdlib/complex/float64/imag' ); +var format = require( '@stdlib/string/format' ); +var addon = require( './../src/addon.node' ); + + +// MAIN // + +/** +* Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. +* +* @param {string} order - storage layout +* @param {string} trans - specifies whether `A` should be transposed, conjugate-transposed, or not transposed +* @param {NonNegativeInteger} M - number of rows in the matrix `A` +* @param {NonNegativeInteger} N - number of columns in the matrix `A` +* @param {Complex128} alpha - scalar constant +* @param {Complex128Array} A - input matrix +* @param {PositiveInteger} LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) +* @param {Complex128Array} x - first input vector +* @param {integer} strideX - `x` stride length +* @param {Complex128} beta - scalar constant +* @param {Complex128Array} y - second input vector +* @param {integer} strideY - `y` stride length +* @throws {TypeError} first argument must be a valid order +* @throws {TypeError} second argument must be a valid transpose operation +* @throws {RangeError} third argument must be a nonnegative integer +* @throws {RangeError} fourth argument must be a nonnegative integer +* @throws {RangeError} seventh argument must be a valid stride +* @throws {RangeError} ninth argument must be non-zero +* @throws {RangeError} twelfth argument must be non-zero +* @returns {Complex128Array} `y` +* +* @example +* var Complex128Array = require( '@stdlib/array/complex128' ); +* var Complex128 = require( '@stdlib/complex/float64/ctor' ); +* +* var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); +* var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); +* var y = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0 ] ); +* +* zgemv( 'row-major', 'no-transpose', 2, 3, new Complex128( 1.0, 0.0 ), A, 3, x, 1, new Complex128( 1.0, 0.0 ), y, 1 ); +* // y => +*/ +function zgemv( order, trans, M, N, alpha, A, LDA, x, strideX, beta, y, strideY ) { // eslint-disable-line max-params, max-len + var viewA; + var viewX; + var viewY; + var vala; + + if ( !isLayout( order ) ) { + throw new TypeError( format( 'invalid argument. First argument must be a valid order. Value: `%s`.', order ) ); + } + if ( !isMatrixTranspose( trans ) ) { + throw new TypeError( format( 'invalid argument. Second argument must be a valid transpose operation. Value: `%s`.', trans ) ); + } + if ( M < 0 ) { + throw new RangeError( format( 'invalid argument. Third argument must be a nonnegative integer. Value: `%d`.', M ) ); + } + if ( N < 0 ) { + throw new RangeError( format( 'invalid argument. Fourth argument must be a nonnegative integer. Value: `%d`.', N ) ); + } + if ( strideX === 0 ) { + throw new RangeError( format( 'invalid argument. Ninth argument must be non-zero. Value: `%d`.', strideX ) ); + } + if ( strideY === 0 ) { + throw new RangeError( format( 'invalid argument. Twelfth argument must be non-zero. Value: `%d`.', strideY ) ); + } + if ( isColumnMajor( order ) ) { + vala = M; + } else { + vala = N; + } + if ( LDA < max( 1, vala ) ) { + throw new RangeError( format( 'invalid argument. Seventh argument must be greater than or equal to max(1,%d). Value: `%d`.', vala, LDA ) ); + } + // Check if we can early return... + if ( M === 0 || N === 0 || ( real( alpha ) === 0.0 && imag( alpha ) === 0.0 && real( beta ) === 1.0 && imag( beta ) === 0.0 ) ) { + return y; + } + viewA = reinterpret( A, 0 ); + viewX = reinterpret( x, 0 ); + viewY = reinterpret( y, 0 ); + addon( resolveOrder( order ), resolveTrans( trans ), M, N, alpha, viewA, LDA, viewX, strideX, beta, viewY, strideY ); // eslint-disable-line max-len + return y; +} + + +// EXPORTS // + +module.exports = zgemv; diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/manifest.json b/lib/node_modules/@stdlib/blas/base/zgemv/manifest.json new file mode 100644 index 000000000000..235ccd2cfe1c --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/manifest.json @@ -0,0 +1,625 @@ +{ + "options": { + "task": "build", + "os": "linux", + "blas": "", + "wasm": false + }, + "fields": [ + { + "field": "src", + "resolve": true, + "relative": true + }, + { + "field": "include", + "resolve": true, + "relative": true + }, + { + "field": "libraries", + "resolve": false, + "relative": false + }, + { + "field": "libpath", + "resolve": true, + "relative": false + } + ], + "confs": [ + { + "task": "build", + "os": "linux", + "blas": "", + "wasm": false, + "src": [ + "./src/zgemv.c", + "./src/zgemv_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/xerbla", + "@stdlib/blas/base/zscal", + "@stdlib/blas/ext/base/zfill", + "@stdlib/strided/base/stride2offset", + "@stdlib/ndarray/base/assert/is-row-major", + "@stdlib/complex/float64/ctor", + "@stdlib/complex/float64/base/mul", + "@stdlib/complex/float64/base/add", + "@stdlib/complex/float64/conj", + "@stdlib/complex/float64/base/assert/is-equal", + "@stdlib/napi/export", + "@stdlib/napi/argv", + "@stdlib/napi/argv-int64", + "@stdlib/napi/argv-int32", + "@stdlib/napi/argv-complex128", + "@stdlib/napi/argv-strided-complex128array", + "@stdlib/napi/argv-strided-complex128array2d" + ] + }, + { + "task": "benchmark", + "os": "linux", + "blas": "", + "wasm": false, + "src": [ + "./src/zgemv.c", + "./src/zgemv_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/xerbla", + "@stdlib/blas/base/zscal", + "@stdlib/blas/ext/base/zfill", + "@stdlib/strided/base/stride2offset", + "@stdlib/ndarray/base/assert/is-row-major", + "@stdlib/complex/float64/ctor", + "@stdlib/complex/float64/base/mul", + "@stdlib/complex/float64/base/add", + "@stdlib/complex/float64/conj", + "@stdlib/complex/float64/base/assert/is-equal" + ] + }, + { + "task": "examples", + "os": "linux", + "blas": "", + "wasm": false, + "src": [ + "./src/zgemv.c", + "./src/zgemv_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/xerbla", + "@stdlib/blas/base/zscal", + "@stdlib/blas/ext/base/zfill", + "@stdlib/strided/base/stride2offset", + "@stdlib/ndarray/base/assert/is-row-major", + "@stdlib/complex/float64/ctor", + "@stdlib/complex/float64/base/mul", + "@stdlib/complex/float64/base/add", + "@stdlib/complex/float64/conj", + "@stdlib/complex/float64/base/assert/is-equal" + ] + }, + { + "task": "build", + "os": "linux", + "blas": "openblas", + "wasm": false, + "src": [ + "./src/zgemv_cblas.c", + "./src/zgemv_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [ + "-lopenblas", + "-lpthread" + ], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/xerbla", + "@stdlib/blas/base/zscal", + "@stdlib/blas/ext/base/zfill", + "@stdlib/strided/base/stride2offset", + "@stdlib/ndarray/base/assert/is-row-major", + "@stdlib/complex/float64/ctor", + "@stdlib/complex/float64/base/mul", + "@stdlib/complex/float64/base/add", + "@stdlib/complex/float64/conj", + "@stdlib/complex/float64/base/assert/is-equal", + "@stdlib/napi/export", + "@stdlib/napi/argv", + "@stdlib/napi/argv-int64", + "@stdlib/napi/argv-int32", + "@stdlib/napi/argv-complex128", + "@stdlib/napi/argv-strided-complex128array", + "@stdlib/napi/argv-strided-complex128array2d" + ] + }, + { + "task": "benchmark", + "os": "linux", + "blas": "openblas", + "wasm": false, + "src": [ + "./src/zgemv_cblas.c", + "./src/zgemv_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [ + "-lopenblas", + "-lpthread" + ], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/xerbla", + "@stdlib/blas/base/zscal", + "@stdlib/blas/ext/base/zfill", + "@stdlib/strided/base/stride2offset", + "@stdlib/ndarray/base/assert/is-row-major", + "@stdlib/complex/float64/ctor", + "@stdlib/complex/float64/base/mul", + "@stdlib/complex/float64/base/add", + "@stdlib/complex/float64/conj", + "@stdlib/complex/float64/base/assert/is-equal" + ] + }, + { + "task": "examples", + "os": "linux", + "blas": "openblas", + "wasm": false, + "src": [ + "./src/zgemv_cblas.c", + "./src/zgemv_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [ + "-lopenblas", + "-lpthread" + ], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/xerbla", + "@stdlib/blas/base/zscal", + "@stdlib/blas/ext/base/zfill", + "@stdlib/strided/base/stride2offset", + "@stdlib/ndarray/base/assert/is-row-major", + "@stdlib/complex/float64/ctor", + "@stdlib/complex/float64/base/mul", + "@stdlib/complex/float64/base/add", + "@stdlib/complex/float64/conj", + "@stdlib/complex/float64/base/assert/is-equal" + ] + }, + { + "task": "build", + "os": "mac", + "blas": "", + "wasm": false, + "src": [ + "./src/zgemv.c", + "./src/zgemv_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/xerbla", + "@stdlib/blas/base/zscal", + "@stdlib/blas/ext/base/zfill", + "@stdlib/strided/base/stride2offset", + "@stdlib/ndarray/base/assert/is-row-major", + "@stdlib/complex/float64/ctor", + "@stdlib/complex/float64/base/mul", + "@stdlib/complex/float64/base/add", + "@stdlib/complex/float64/conj", + "@stdlib/complex/float64/base/assert/is-equal", + "@stdlib/napi/export", + "@stdlib/napi/argv", + "@stdlib/napi/argv-int64", + "@stdlib/napi/argv-int32", + "@stdlib/napi/argv-complex128", + "@stdlib/napi/argv-strided-complex128array", + "@stdlib/napi/argv-strided-complex128array2d" + ] + }, + { + "task": "benchmark", + "os": "mac", + "blas": "", + "wasm": false, + "src": [ + "./src/zgemv.c", + "./src/zgemv_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/xerbla", + "@stdlib/blas/base/zscal", + "@stdlib/blas/ext/base/zfill", + "@stdlib/strided/base/stride2offset", + "@stdlib/ndarray/base/assert/is-row-major", + "@stdlib/complex/float64/ctor", + "@stdlib/complex/float64/base/mul", + "@stdlib/complex/float64/base/add", + "@stdlib/complex/float64/conj", + "@stdlib/complex/float64/base/assert/is-equal" + ] + }, + { + "task": "examples", + "os": "mac", + "blas": "", + "wasm": false, + "src": [ + "./src/zgemv.c", + "./src/zgemv_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/xerbla", + "@stdlib/blas/base/zscal", + "@stdlib/blas/ext/base/zfill", + "@stdlib/strided/base/stride2offset", + "@stdlib/ndarray/base/assert/is-row-major", + "@stdlib/complex/float64/ctor", + "@stdlib/complex/float64/base/mul", + "@stdlib/complex/float64/base/add", + "@stdlib/complex/float64/conj", + "@stdlib/complex/float64/base/assert/is-equal" + ] + }, + { + "task": "build", + "os": "mac", + "blas": "apple_accelerate_framework", + "wasm": false, + "src": [ + "./src/zgemv_cblas.c", + "./src/zgemv_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [ + "-lblas" + ], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/xerbla", + "@stdlib/blas/base/zscal", + "@stdlib/blas/ext/base/zfill", + "@stdlib/strided/base/stride2offset", + "@stdlib/ndarray/base/assert/is-row-major", + "@stdlib/complex/float64/ctor", + "@stdlib/complex/float64/base/mul", + "@stdlib/complex/float64/base/add", + "@stdlib/complex/float64/conj", + "@stdlib/complex/float64/base/assert/is-equal", + "@stdlib/napi/export", + "@stdlib/napi/argv", + "@stdlib/napi/argv-int64", + "@stdlib/napi/argv-int32", + "@stdlib/napi/argv-double", + "@stdlib/napi/argv-strided-float64array", + "@stdlib/napi/argv-strided-float64array2d" + ] + }, + { + "task": "benchmark", + "os": "mac", + "blas": "apple_accelerate_framework", + "wasm": false, + "src": [ + "./src/zgemv_cblas.c", + "./src/zgemv_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [ + "-lblas" + ], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/xerbla", + "@stdlib/blas/base/zscal", + "@stdlib/blas/ext/base/zfill", + "@stdlib/strided/base/stride2offset", + "@stdlib/ndarray/base/assert/is-row-major", + "@stdlib/complex/float64/ctor", + "@stdlib/complex/float64/base/mul", + "@stdlib/complex/float64/base/add", + "@stdlib/complex/float64/conj", + "@stdlib/complex/float64/base/assert/is-equal" + ] + }, + { + "task": "examples", + "os": "mac", + "blas": "apple_accelerate_framework", + "wasm": false, + "src": [ + "./src/zgemv_cblas.c", + "./src/zgemv_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [ + "-lblas" + ], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/xerbla", + "@stdlib/blas/base/dscal", + "@stdlib/blas/ext/base/dfill", + "@stdlib/strided/base/stride2offset", + "@stdlib/ndarray/base/assert/is-row-major" + ] + }, + { + "task": "build", + "os": "mac", + "blas": "openblas", + "wasm": false, + "src": [ + "./src/zgemv_cblas.c", + "./src/zgemv_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [ + "-lopenblas", + "-lpthread" + ], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/xerbla", + "@stdlib/blas/base/zscal", + "@stdlib/blas/ext/base/zfill", + "@stdlib/strided/base/stride2offset", + "@stdlib/ndarray/base/assert/is-row-major", + "@stdlib/complex/float64/ctor", + "@stdlib/complex/float64/base/mul", + "@stdlib/complex/float64/base/add", + "@stdlib/complex/float64/conj", + "@stdlib/complex/float64/base/assert/is-equal", + "@stdlib/napi/export", + "@stdlib/napi/argv", + "@stdlib/napi/argv-int64", + "@stdlib/napi/argv-int32", + "@stdlib/napi/argv-complex128", + "@stdlib/napi/argv-strided-complex128array", + "@stdlib/napi/argv-strided-complex128array2d" + ] + }, + { + "task": "benchmark", + "os": "mac", + "blas": "openblas", + "wasm": false, + "src": [ + "./src/zgemv_cblas.c", + "./src/zgemv_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [ + "-lopenblas", + "-lpthread" + ], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/xerbla", + "@stdlib/blas/base/zscal", + "@stdlib/blas/ext/base/zfill", + "@stdlib/strided/base/stride2offset", + "@stdlib/ndarray/base/assert/is-row-major", + "@stdlib/complex/float64/ctor", + "@stdlib/complex/float64/base/mul", + "@stdlib/complex/float64/base/add", + "@stdlib/complex/float64/conj", + "@stdlib/complex/float64/base/assert/is-equal" + ] + }, + { + "task": "examples", + "os": "mac", + "blas": "openblas", + "wasm": false, + "src": [ + "./src/zgemv_cblas.c", + "./src/zgemv_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [ + "-lopenblas", + "-lpthread" + ], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/xerbla", + "@stdlib/blas/base/zscal", + "@stdlib/blas/ext/base/zfill", + "@stdlib/strided/base/stride2offset", + "@stdlib/ndarray/base/assert/is-row-major", + "@stdlib/complex/float64/ctor", + "@stdlib/complex/float64/base/mul", + "@stdlib/complex/float64/base/add", + "@stdlib/complex/float64/conj", + "@stdlib/complex/float64/base/assert/is-equal" + ] + }, + { + "task": "build", + "os": "win", + "blas": "", + "wasm": false, + "src": [ + "./src/zgemv.c", + "./src/zgemv_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/xerbla", + "@stdlib/blas/base/zscal", + "@stdlib/blas/ext/base/zfill", + "@stdlib/strided/base/stride2offset", + "@stdlib/ndarray/base/assert/is-row-major", + "@stdlib/complex/float64/ctor", + "@stdlib/complex/float64/base/mul", + "@stdlib/complex/float64/base/add", + "@stdlib/complex/float64/conj", + "@stdlib/complex/float64/base/assert/is-equal", + "@stdlib/napi/export", + "@stdlib/napi/argv", + "@stdlib/napi/argv-int64", + "@stdlib/napi/argv-int32", + "@stdlib/napi/argv-complex128", + "@stdlib/napi/argv-strided-complex128array", + "@stdlib/napi/argv-strided-complex128array2d" + ] + }, + { + "task": "benchmark", + "os": "win", + "blas": "", + "wasm": false, + "src": [ + "./src/zgemv.c", + "./src/zgemv_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/xerbla", + "@stdlib/blas/base/zscal", + "@stdlib/blas/ext/base/zfill", + "@stdlib/strided/base/stride2offset", + "@stdlib/ndarray/base/assert/is-row-major", + "@stdlib/complex/float64/ctor", + "@stdlib/complex/float64/base/mul", + "@stdlib/complex/float64/base/add", + "@stdlib/complex/float64/conj", + "@stdlib/complex/float64/base/assert/is-equal" + ] + }, + { + "task": "examples", + "os": "win", + "blas": "", + "wasm": false, + "src": [ + "./src/zgemv.c", + "./src/zgemv_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/xerbla", + "@stdlib/blas/base/zscal", + "@stdlib/blas/ext/base/zfill", + "@stdlib/strided/base/stride2offset", + "@stdlib/ndarray/base/assert/is-row-major", + "@stdlib/complex/float64/ctor", + "@stdlib/complex/float64/base/mul", + "@stdlib/complex/float64/base/add", + "@stdlib/complex/float64/conj", + "@stdlib/complex/float64/base/assert/is-equal" + ] + }, + { + "task": "build", + "os": "", + "blas": "", + "wasm": true, + "src": [ + "./src/zgemv.c", + "./src/zgemv_ndarray.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/shared", + "@stdlib/blas/base/xerbla", + "@stdlib/blas/base/zscal", + "@stdlib/blas/ext/base/zfill", + "@stdlib/strided/base/stride2offset", + "@stdlib/ndarray/base/assert/is-row-major", + "@stdlib/complex/float64/ctor", + "@stdlib/complex/float64/base/mul", + "@stdlib/complex/float64/base/add", + "@stdlib/complex/float64/conj", + "@stdlib/complex/float64/base/assert/is-equal" + ] + } + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/package.json b/lib/node_modules/@stdlib/blas/base/zgemv/package.json new file mode 100644 index 000000000000..8a47e3e56444 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/package.json @@ -0,0 +1,79 @@ +{ + "name": "@stdlib/blas/base/zgemv", + "version": "0.0.0", + "description": "Perform one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`.", + "license": "Apache-2.0", + "author": { + "name": "The Stdlib Authors", + "url": "https://github.com/stdlib-js/stdlib/graphs/contributors" + }, + "contributors": [ + { + "name": "The Stdlib Authors", + "url": "https://github.com/stdlib-js/stdlib/graphs/contributors" + } + ], + "main": "./lib", + "browser": "./lib/main.js", + "gypfile": true, + "directories": { + "benchmark": "./benchmark", + "doc": "./docs", + "example": "./examples", + "include": "./include", + "lib": "./lib", + "src": "./src", + "test": "./test" + }, + "types": "./docs/types", + "scripts": {}, + "homepage": "https://github.com/stdlib-js/stdlib", + "repository": { + "type": "git", + "url": "git://github.com/stdlib-js/stdlib.git" + }, + "bugs": { + "url": "https://github.com/stdlib-js/stdlib/issues" + }, + "dependencies": {}, + "devDependencies": {}, + "engines": { + "node": ">=0.10.0", + "npm": ">2.7.0" + }, + "os": [ + "aix", + "darwin", + "freebsd", + "linux", + "macos", + "openbsd", + "sunos", + "win32", + "windows" + ], + "keywords": [ + "stdlib", + "stdmath", + "mathematics", + "math", + "blas", + "level 2", + "zgemv", + "gemv", + "linear", + "algebra", + "subroutines", + "array", + "ndarray", + "complex", + "complex128", + "complex64", + "complex-numbers", + "double", + "dbl", + "float64", + "float64array", + "complex128array" + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/src/Makefile b/lib/node_modules/@stdlib/blas/base/zgemv/src/Makefile new file mode 100644 index 000000000000..2caf905cedbe --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/src/Makefile @@ -0,0 +1,70 @@ +#/ +# @license Apache-2.0 +# +# Copyright (c) 2026 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#/ + +# VARIABLES # + +ifndef VERBOSE + QUIET := @ +else + QUIET := +endif + +# Determine the OS ([1][1], [2][2]). +# +# [1]: https://en.wikipedia.org/wiki/Uname#Examples +# [2]: http://stackoverflow.com/a/27776822/2225624 +OS ?= $(shell uname) +ifneq (, $(findstring MINGW,$(OS))) + OS := WINNT +else +ifneq (, $(findstring MSYS,$(OS))) + OS := WINNT +else +ifneq (, $(findstring CYGWIN,$(OS))) + OS := WINNT +else +ifneq (, $(findstring Windows_NT,$(OS))) + OS := WINNT +endif +endif +endif +endif + + +# RULES # + +#/ +# Removes generated files for building an add-on. +# +# @example +# make clean-addon +#/ +clean-addon: + $(QUIET) -rm -f *.o *.node + +.PHONY: clean-addon + +#/ +# Removes generated files. +# +# @example +# make clean +#/ +clean: clean-addon + +.PHONY: clean diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/src/addon.c b/lib/node_modules/@stdlib/blas/base/zgemv/src/addon.c new file mode 100644 index 000000000000..b6aa741b25d3 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/src/addon.c @@ -0,0 +1,125 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "stdlib/blas/base/zgemv.h" +#include "stdlib/blas/base/shared.h" +#include "stdlib/complex/float64/ctor.h" +#include "stdlib/napi/export.h" +#include "stdlib/napi/argv.h" +#include "stdlib/napi/argv_int64.h" +#include "stdlib/napi/argv_int32.h" +#include "stdlib/napi/argv_complex128.h" +#include "stdlib/napi/argv_strided_complex128array.h" +#include "stdlib/napi/argv_strided_complex128array2d.h" +#include + +/** +* Receives JavaScript callback invocation data. +* +* @param env environment under which the function is invoked +* @param info callback data +* @return Node-API value +*/ +static napi_value addon( napi_env env, napi_callback_info info ) { + CBLAS_INT xlen; + CBLAS_INT ylen; + CBLAS_INT sa1; + CBLAS_INT sa2; + + STDLIB_NAPI_ARGV( env, info, argv, argc, 12 ); + + STDLIB_NAPI_ARGV_INT32( env, layout, argv, 0 ); + STDLIB_NAPI_ARGV_INT32( env, trans, argv, 1 ); + + STDLIB_NAPI_ARGV_INT64( env, M, argv, 2 ); + STDLIB_NAPI_ARGV_INT64( env, N, argv, 3 ); + STDLIB_NAPI_ARGV_INT64( env, strideX, argv, 8 ); + STDLIB_NAPI_ARGV_INT64( env, strideY, argv, 11 ); + STDLIB_NAPI_ARGV_INT64( env, LDA, argv, 6 ); + + STDLIB_NAPI_ARGV_COMPLEX128( env, alpha, argv, 4 ); + STDLIB_NAPI_ARGV_COMPLEX128( env, beta, argv, 9 ); + + if ( trans == CblasNoTrans ) { + xlen = N; + ylen = M; + } else { + xlen = M; + ylen = N; + } + if ( layout == CblasColMajor ) { + sa1 = 1; + sa2 = LDA; + } else { // layout == CblasRowMajor + sa1 = LDA; + sa2 = 1; + } + STDLIB_NAPI_ARGV_STRIDED_COMPLEX128ARRAY( env, X, xlen, strideX, argv, 7 ); + STDLIB_NAPI_ARGV_STRIDED_COMPLEX128ARRAY( env, Y, ylen, strideY, argv, 10 ); + STDLIB_NAPI_ARGV_STRIDED_COMPLEX128ARRAY2D( env, A, M, N, sa1, sa2, argv, 5 ); + + API_SUFFIX(c_zgemv)( layout, trans, M, N, alpha, A, LDA, X, strideX, beta, Y, strideY ); + + return NULL; +} + +/** +* Receives JavaScript callback invocation data. +* +* @param env environment under which the function is invoked +* @param info callback data +* @return Node-API value +*/ +static napi_value addon_method( napi_env env, napi_callback_info info ) { + CBLAS_INT xlen; + CBLAS_INT ylen; + + STDLIB_NAPI_ARGV( env, info, argv, argc, 15 ); + + STDLIB_NAPI_ARGV_INT32( env, trans, argv, 0 ); + + STDLIB_NAPI_ARGV_INT64( env, M, argv, 1 ); + STDLIB_NAPI_ARGV_INT64( env, N, argv, 2 ); + STDLIB_NAPI_ARGV_INT64( env, strideX, argv, 9 ); + STDLIB_NAPI_ARGV_INT64( env, offsetX, argv, 10 ); + STDLIB_NAPI_ARGV_INT64( env, strideY, argv, 13 ); + STDLIB_NAPI_ARGV_INT64( env, offsetY, argv, 14 ); + STDLIB_NAPI_ARGV_INT64( env, strideA1, argv, 5 ); + STDLIB_NAPI_ARGV_INT64( env, strideA2, argv, 6 ); + STDLIB_NAPI_ARGV_INT64( env, offsetA, argv, 7 ); + + STDLIB_NAPI_ARGV_COMPLEX128( env, alpha, argv, 3 ); + STDLIB_NAPI_ARGV_COMPLEX128( env, beta, argv, 11 ); + + if ( trans == CblasNoTrans ) { + xlen = N; + ylen = M; + } else { + xlen = M; + ylen = N; + } + STDLIB_NAPI_ARGV_STRIDED_COMPLEX128ARRAY( env, X, xlen, strideX, argv, 8 ); + STDLIB_NAPI_ARGV_STRIDED_COMPLEX128ARRAY( env, Y, ylen, strideY, argv, 12 ); + STDLIB_NAPI_ARGV_STRIDED_COMPLEX128ARRAY2D( env, A, M, N, strideA1, strideA2, argv, 4 ); + + API_SUFFIX(c_zgemv_ndarray)( trans, M, N, alpha, A, strideA1, strideA2, offsetA, X, strideX, offsetX, beta, Y, strideY, offsetY ); + + return NULL; +} + +STDLIB_NAPI_MODULE_EXPORT_FCN_WITH_METHOD( addon, "ndarray", addon_method ) diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv.c b/lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv.c new file mode 100644 index 000000000000..23ad8213bfd5 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv.c @@ -0,0 +1,114 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "stdlib/blas/base/zgemv.h" +#include "stdlib/blas/base/shared.h" +#include "stdlib/blas/base/xerbla.h" +#include "stdlib/complex/float64/ctor.h" +#include "stdlib/complex/float64/base/assert/is_equal.h" +#include "stdlib/strided/base/stride2offset.h" + +/** +* Performs one of the matrix-vector operations `Y = α*A*X + β*Y`, `Y = α*A^T*X + β*Y`, or `Y = α*A^H*X + β*Y`, where `α` and `β` are scalars, `X` and `Y` are vectors, and `A` is an `M` by `N` matrix. +* +* @param layout storage layout +* @param trans specifies whether `A` should be transposed, conjugate-transposed, or not transposed +* @param M number of rows in the matrix `A` +* @param N number of columns in the matrix `A` +* @param alpha scalar constant +* @param A input matrix +* @param LDA stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) +* @param X first input vector +* @param strideX `X` stride length +* @param beta scalar constant +* @param Y second input vector +* @param strideY `Y` stride length +*/ +void API_SUFFIX(c_zgemv)( const CBLAS_LAYOUT layout, const CBLAS_TRANSPOSE trans, const CBLAS_INT M, const CBLAS_INT N, const stdlib_complex128_t alpha, const void *A, const CBLAS_INT LDA, const void *X, const CBLAS_INT strideX, const stdlib_complex128_t beta, void *Y, const CBLAS_INT strideY ) { + CBLAS_INT vala; + CBLAS_INT xlen; + CBLAS_INT ylen; + CBLAS_INT sa1; + CBLAS_INT sa2; + CBLAS_INT ox; + CBLAS_INT oy; + CBLAS_INT v; + + // Perform input argument validation... + if ( layout != CblasRowMajor && layout != CblasColMajor ) { + c_xerbla( 1, "c_zgemv", "Error: invalid argument. First argument must be a valid storage layout. Value: `%d`.", layout ); + return; + } + if ( trans != CblasTrans && trans != CblasConjTrans && trans != CblasNoTrans ) { + c_xerbla( 2, "c_zgemv", "Error: invalid argument. Second argument must be a valid transpose operation. Value: `%d`.", trans ); + return; + } + if ( M < 0 ) { + c_xerbla( 3, "c_zgemv", "Error: invalid argument. Third argument must be a nonnegative integer. Value: `%d`.", M ); + return; + } + if ( N < 0 ) { + c_xerbla( 4, "c_zgemv", "Error: invalid argument. Fourth argument must be a nonnegative integer. Value: `%d`.", N ); + return; + } + if ( strideX == 0 ) { + c_xerbla( 9, "c_zgemv", "Error: invalid argument. Ninth argument must be nonzero. Value: `%d`.", strideX ); + return; + } + if ( strideY == 0 ) { + c_xerbla( 12, "c_zgemv", "Error: invalid argument. Twelfth argument must be nonzero. Value: `%d`.", strideY ); + return; + } + if ( layout == CblasColMajor ) { + v = M; + } else { + v = N; + } + // max(1, v) + if ( v < 1 ) { + vala = 1; + } else { + vala = v; + } + if ( LDA < v ) { + c_xerbla( 10, "c_zgemv", "Error: invalid argument. Seventh argument must be greater than or equal to max(1,%d). Value: `%d`.", vala, LDA ); + return; + } + // Check if we can early return... + if ( M == 0 || N == 0 || ( stdlib_base_complex128_is_equal( alpha, stdlib_complex128( 0.0, 0.0 ) ) && stdlib_base_complex128_is_equal( beta, stdlib_complex128( 1.0, 0.0 ) ) ) ) { + return; + } + if ( trans == CblasNoTrans ) { + xlen = N; + ylen = M; + } else { + xlen = M; + ylen = N; + } + if ( layout == CblasColMajor ) { + sa1 = 1; + sa2 = LDA; + } else { // layout == CblasRowMajor + sa1 = LDA; + sa2 = 1; + } + ox = stdlib_strided_stride2offset( xlen, strideX ); + oy = stdlib_strided_stride2offset( ylen, strideY ); + API_SUFFIX(c_zgemv_ndarray)( trans, M, N, alpha, A, sa1, sa2, 0, X, strideX, ox, beta, Y, strideY, oy ); + return; +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv_cblas.c b/lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv_cblas.c new file mode 100644 index 000000000000..bb283ad8c444 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv_cblas.c @@ -0,0 +1,41 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "stdlib/blas/base/zgemv.h" +#include "stdlib/blas/base/zgemv_cblas.h" +#include "stdlib/blas/base/shared.h" + +/** +* Performs one of the matrix-vector operations `Y = α*A*X + β*Y`, `Y = α*A^T*X + β*Y`, or `Y = α*A^H*X + β*Y`, where `α` and `β` are scalars, `X` and `Y` are vectors, and `A` is an `M` by `N` matrix. +* +* @param layout storage layout +* @param trans specifies whether `A` should be transposed, conjugate-transposed, or not transposed +* @param M number of rows in the matrix `A` +* @param N number of columns in the matrix `A` +* @param alpha scalar constant +* @param A input matrix +* @param LDA stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) +* @param X first input vector +* @param strideX `X` stride length +* @param beta scalar constant +* @param Y second input vector +* @param strideY `Y` stride length +*/ +void API_SUFFIX(c_zgemv)( const CBLAS_LAYOUT layout, const CBLAS_TRANSPOSE trans, const CBLAS_INT M, const CBLAS_INT N, const stdlib_complex128_t alpha, const void *A, const CBLAS_INT LDA, const void *X, const CBLAS_INT strideX, const stdlib_complex128_t beta, void *Y, const CBLAS_INT strideY ) { + API_SUFFIX(cblas_zgemv)( layout, trans, M, N, &alpha, A, LDA, X, strideX, &beta, Y, strideY ); +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv_ndarray.c b/lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv_ndarray.c new file mode 100644 index 000000000000..32503a83c610 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv_ndarray.c @@ -0,0 +1,189 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "stdlib/blas/base/zgemv.h" +#include "stdlib/blas/base/shared.h" +#include "stdlib/blas/base/xerbla.h" +#include "stdlib/blas/base/zscal.h" +#include "stdlib/blas/ext/base/zfill.h" +#include "stdlib/complex/float64/ctor.h" +#include "stdlib/complex/float64/base/mul.h" +#include "stdlib/complex/float64/base/add.h" +#include "stdlib/complex/float64/conj.h" +#include "stdlib/complex/float64/base/assert/is_equal.h" +#include "stdlib/ndarray/base/assert/is_row_major.h" +#include + +/** +* Performs one of the matrix-vector operations `Y = α*A*X + β*Y`, `Y = α*A^T*X + β*Y`, or `Y = α*A^H*X + β*Y`, using alternative indexing semantics and where `α` and `β` are scalars, `X` and `Y` are vectors, and `A` is an `M` by `N` matrix. +* +* @param trans specifies whether `A` should be transposed, conjugate-transposed, or not transposed +* @param M number of rows in the matrix `A` +* @param N number of columns in the matrix `A` +* @param alpha scalar constant +* @param A input matrix +* @param strideA1 stride of the first dimension of `A` +* @param strideA2 stride of the second dimension of `A` +* @param offsetA starting index for `A` +* @param X first input vector +* @param strideX `X` stride length +* @param offsetX starting index for `X` +* @param beta scalar constant +* @param Y second input vector +* @param strideY `Y` stride length +* @param offsetY starting index for `Y` +*/ +void API_SUFFIX(c_zgemv_ndarray)( const CBLAS_TRANSPOSE trans, const CBLAS_INT M, const CBLAS_INT N, const stdlib_complex128_t alpha, const void *A, const CBLAS_INT strideA1, const CBLAS_INT strideA2, const CBLAS_INT offsetA, const void *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, const stdlib_complex128_t beta, void *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY ) { + const stdlib_complex128_t *xp = (stdlib_complex128_t *)X; + stdlib_complex128_t *yp = (stdlib_complex128_t *)Y; + const stdlib_complex128_t *ap = (stdlib_complex128_t *)A; + stdlib_complex128_t zero = stdlib_complex128( 0.0, 0.0 ); + stdlib_complex128_t one = stdlib_complex128( 1.0, 0.0 ); + int64_t sa[ 2 ]; + CBLAS_INT xlen; + CBLAS_INT ylen; + CBLAS_INT da0; + CBLAS_INT da1; + CBLAS_INT ix; + CBLAS_INT iy; + CBLAS_INT ia; + CBLAS_INT i0; + CBLAS_INT i1; + stdlib_complex128_t tmp; + stdlib_complex128_t aval; + bool isrm; + + // Note on variable naming convention: da#, i# where # corresponds to the loop number, with `0` being the innermost loop... + + // Perform input argument validation... + if ( trans != CblasTrans && trans != CblasConjTrans && trans != CblasNoTrans ) { + c_xerbla( 1, "c_zgemv_ndarray", "Error: invalid argument. First argument must be a valid transpose operation. Value: `%d`.", trans ); + return; + } + if ( M < 0 ) { + c_xerbla( 2, "c_zgemv_ndarray", "Error: invalid argument. Second argument must be a nonnegative integer. Value: `%d`.", M ); + return; + } + if ( N < 0 ) { + c_xerbla( 3, "c_zgemv_ndarray", "Error: invalid argument. Third argument must be a nonnegative integer. Value: `%d`.", N ); + return; + } + if ( strideX == 0 ) { + c_xerbla( 10, "c_zgemv_ndarray", "Error: invalid argument. Tenth argument must be nonzero. Value: `%d`.", strideX ); + return; + } + if ( strideY == 0 ) { + c_xerbla( 14, "c_zgemv_ndarray", "Error: invalid argument. Fourteenth argument must be nonzero. Value: `%d`.", strideY ); + return; + } + // Check whether we can avoid computation altogether... + if ( M == 0 || N == 0 || ( stdlib_base_complex128_is_equal( alpha, zero ) && stdlib_base_complex128_is_equal( beta, one ) ) ) { + return; + } + // Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments... + sa[ 0 ] = strideA1; + sa[ 1 ] = strideA2; + isrm = stdlib_ndarray_is_row_major( 2, sa ); + if ( trans == CblasNoTrans ) { + xlen = N; + ylen = M; + } else { + xlen = M; + ylen = N; + } + // Y = beta * Y + if ( stdlib_base_complex128_is_equal( beta, zero ) ) { + API_SUFFIX(stdlib_strided_zfill_ndarray)( ylen, zero, Y, strideY, offsetY ); + } else if ( !stdlib_base_complex128_is_equal( beta, one ) ) { + API_SUFFIX(c_zscal_ndarray)( ylen, beta, Y, strideY, offsetY ); + } + if ( stdlib_base_complex128_is_equal( alpha, zero ) ) { + return; + } + + // Form: Y = α*A*X + Y + if ( + ( !isrm && trans == CblasNoTrans ) || + ( isrm && trans != CblasNoTrans ) + ) { + if ( isrm ) { + // For row-major matrices, the last dimension has the fastest changing index... + da0 = strideA2; // offset increment for innermost loop + da1 = strideA1 - ( ylen*strideA2 ); // offset increment for outermost loop + } else { // isColMajor + // For column-major matrices, the first dimension has the fastest changing index... + da0 = strideA1; // offset increment for innermost loop + da1 = strideA2 - ( ylen*strideA1 ); // offset increment for outermost loop + } + ia = offsetA; + ix = offsetX; + for ( i1 = 0; i1 < xlen; i1++ ) { + tmp = stdlib_base_complex128_mul( alpha, xp[ ix ] ); + if ( !stdlib_base_complex128_is_equal( tmp, zero ) ) { + iy = offsetY; + for ( i0 = 0; i0 < ylen; i0++ ) { + if ( trans == CblasConjTrans ) { + aval = stdlib_complex128_conj( ap[ ia ] ); + } else { + aval = ap[ ia ]; + } + yp[ iy ] = stdlib_base_complex128_add( yp[ iy ], stdlib_base_complex128_mul( aval, tmp ) ); + iy += strideY; + ia += da0; + } + } else { + ia += da0 * ylen; + } + ix += strideX; + ia += da1; + } + return; + } + // Form: Y = α*A^T*X + Y or Y = α*A^H*X + Y + + // ( !isrm && trans != CblasNoTrans ) || ( isrm && trans == CblasNoTrans ) + if ( isrm ) { + // For row-major matrices, the last dimension has the fastest changing index... + da0 = strideA2; // offset increment for innermost loop + da1 = strideA1 - ( xlen*strideA2 ); // offset increment for outermost loop + } else { // isColMajor + // For column-major matrices, the first dimension has the fastest changing index... + da0 = strideA1; // offset increment for innermost loop + da1 = strideA2 - ( xlen*strideA1 ); // offset increment for outermost loop + } + ia = offsetA; + iy = offsetY; + for ( i1 = 0; i1 < ylen; i1++ ) { + tmp = zero; + ix = offsetX; + for ( i0 = 0; i0 < xlen; i0++ ) { + if ( trans == CblasConjTrans ) { + aval = stdlib_complex128_conj( ap[ ia ] ); + } else { + aval = ap[ ia ]; + } + tmp = stdlib_base_complex128_add( tmp, stdlib_base_complex128_mul( aval, xp[ ix ] ) ); + ix += strideX; + ia += da0; + } + yp[ iy ] = stdlib_base_complex128_add( yp[ iy ], stdlib_base_complex128_mul( alpha, tmp ) ); + iy += strideY; + ia += da1; + } + return; +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_alpha_zero.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_alpha_zero.json new file mode 100644 index 000000000000..b6ab90f41293 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_alpha_zero.json @@ -0,0 +1,50 @@ +{ + "order": "column-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 0.0, + 0.0 + ], + "beta": [ + 2.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 3.0, + 1.5, + 2.0, + 1.0, + 4.0, + 2.0 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": 1, + "strideA2": 2, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 2.0, + 0.6, + 4.0, + 1.2 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_complex_access_pattern.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_complex_access_pattern.json new file mode 100644 index 000000000000..e63864a0a03a --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_complex_access_pattern.json @@ -0,0 +1,56 @@ +{ + "order": "column-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 0.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 3.0, + 1.5, + 2.0, + 1.0, + 4.0, + 2.0 + ], + "x": [ + 2.0, + -0.4, + 0.0, + 0.0, + 1.0, + -0.2 + ], + "y": [ + 2.0, + 0.6, + 0.0, + 0.0, + 1.0, + 0.3 + ], + "strideA1": 1, + "strideA2": 2, + "offsetA": 0, + "strideX": -2, + "offsetX": 2, + "strideY": -2, + "offsetY": 2, + "y_out": [ + 12.100000000000001, + 3.3, + 0.0, + 0.0, + 5.5, + 1.5 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_ct.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_ct.json new file mode 100644 index 000000000000..60597fa59360 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_ct.json @@ -0,0 +1,50 @@ +{ + "order": "column-major", + "trans": "conjugate-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 1.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 3.0, + 1.5, + 2.0, + 1.0, + 4.0, + 2.0 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": 1, + "strideA2": 2, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 7.300000000000001, + -4.6000000000000005, + 11.0, + -6.4 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_nt.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_nt.json new file mode 100644 index 000000000000..8feb90240c58 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_nt.json @@ -0,0 +1,50 @@ +{ + "order": "column-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 1.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 3.0, + 1.5, + 2.0, + 1.0, + 4.0, + 2.0 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": 1, + "strideA2": 2, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 6.5, + 1.8, + 14.100000000000001, + 3.9 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_oa.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_oa.json new file mode 100644 index 000000000000..206664c55a26 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_oa.json @@ -0,0 +1,52 @@ +{ + "order": "column-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 0.0, + 0.0 + ], + "lda": 2, + "A": [ + 0.0, + 0.0, + 1.0, + 0.5, + 3.0, + 1.5, + 2.0, + 1.0, + 4.0, + 2.0 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": 1, + "strideA2": 2, + "offsetA": 1, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 5.5, + 1.5, + 12.100000000000001, + 3.3 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1_sa2.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1_sa2.json new file mode 100644 index 000000000000..1be051cdc97b --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1_sa2.json @@ -0,0 +1,56 @@ +{ + "order": "column-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 0.0, + 0.0 + ], + "lda": 4, + "A": [ + 1.0, + 0.5, + 0.0, + 0.0, + 3.0, + 1.5, + 0.0, + 0.0, + 2.0, + 1.0, + 0.0, + 0.0, + 4.0, + 2.0 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": 2, + "strideA2": 4, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 5.5, + 1.5, + 12.100000000000001, + 3.3 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1_sa2n.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1_sa2n.json new file mode 100644 index 000000000000..c9dbe756ff96 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1_sa2n.json @@ -0,0 +1,56 @@ +{ + "order": "column-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 0.0, + 0.0 + ], + "lda": -4, + "A": [ + 2.0, + 1.0, + 0.0, + 0.0, + 4.0, + 2.0, + 0.0, + 0.0, + 1.0, + 0.5, + 0.0, + 0.0, + 3.0, + 1.5 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": 2, + "strideA2": -4, + "offsetA": 4, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 5.5, + 1.5, + 12.100000000000001, + 3.3 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1n_sa2.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1n_sa2.json new file mode 100644 index 000000000000..dca6d21793ad --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1n_sa2.json @@ -0,0 +1,56 @@ +{ + "order": "column-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 0.0, + 0.0 + ], + "lda": 4, + "A": [ + 3.0, + 1.5, + 0.0, + 0.0, + 1.0, + 0.5, + 0.0, + 0.0, + 4.0, + 2.0, + 0.0, + 0.0, + 2.0, + 1.0 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": -2, + "strideA2": 4, + "offsetA": 2, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 5.5, + 1.5, + 12.100000000000001, + 3.3 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1n_sa2n.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1n_sa2n.json new file mode 100644 index 000000000000..bf610f620123 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1n_sa2n.json @@ -0,0 +1,56 @@ +{ + "order": "column-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 0.0, + 0.0 + ], + "lda": -4, + "A": [ + 4.0, + 2.0, + 0.0, + 0.0, + 2.0, + 1.0, + 0.0, + 0.0, + 3.0, + 1.5, + 0.0, + 0.0, + 1.0, + 0.5 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": -2, + "strideA2": -4, + "offsetA": 6, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 5.5, + 1.5, + 12.100000000000001, + 3.3 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_t.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_t.json new file mode 100644 index 000000000000..aec0ea1fdbc0 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_t.json @@ -0,0 +1,50 @@ +{ + "order": "column-major", + "trans": "transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 1.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 3.0, + 1.5, + 2.0, + 1.0, + 4.0, + 2.0 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": 1, + "strideA2": 2, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 8.7, + 2.3999999999999995, + 13.0, + 3.6 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_x_zeros.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_x_zeros.json new file mode 100644 index 000000000000..62b34d2be1fa --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_x_zeros.json @@ -0,0 +1,50 @@ +{ + "order": "column-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 2.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 3.0, + 1.5, + 2.0, + 1.0, + 4.0, + 2.0 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": 1, + "strideA2": 2, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 7.5, + 2.1, + 16.1, + 4.5 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_x_zeros_beta_one.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_x_zeros_beta_one.json new file mode 100644 index 000000000000..8feb90240c58 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_x_zeros_beta_one.json @@ -0,0 +1,50 @@ +{ + "order": "column-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 1.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 3.0, + 1.5, + 2.0, + 1.0, + 4.0, + 2.0 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": 1, + "strideA2": 2, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 6.5, + 1.8, + 14.100000000000001, + 3.9 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xnyn.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xnyn.json new file mode 100644 index 000000000000..e63864a0a03a --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xnyn.json @@ -0,0 +1,56 @@ +{ + "order": "column-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 0.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 3.0, + 1.5, + 2.0, + 1.0, + 4.0, + 2.0 + ], + "x": [ + 2.0, + -0.4, + 0.0, + 0.0, + 1.0, + -0.2 + ], + "y": [ + 2.0, + 0.6, + 0.0, + 0.0, + 1.0, + 0.3 + ], + "strideA1": 1, + "strideA2": 2, + "offsetA": 0, + "strideX": -2, + "offsetX": 2, + "strideY": -2, + "offsetY": 2, + "y_out": [ + 12.100000000000001, + 3.3, + 0.0, + 0.0, + 5.5, + 1.5 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xnyp.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xnyp.json new file mode 100644 index 000000000000..3f4e4c1316c8 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xnyp.json @@ -0,0 +1,56 @@ +{ + "order": "column-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 0.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 3.0, + 1.5, + 2.0, + 1.0, + 4.0, + 2.0 + ], + "x": [ + 2.0, + -0.4, + 0.0, + 0.0, + 1.0, + -0.2 + ], + "y": [ + 1.0, + 0.3, + 0.0, + 0.0, + 2.0, + 0.6 + ], + "strideA1": 1, + "strideA2": 2, + "offsetA": 0, + "strideX": -2, + "offsetX": 2, + "strideY": 2, + "offsetY": 0, + "y_out": [ + 5.5, + 1.5, + 0.0, + 0.0, + 12.100000000000001, + 3.3 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xpyn.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xpyn.json new file mode 100644 index 000000000000..0c1f96e8c1af --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xpyn.json @@ -0,0 +1,56 @@ +{ + "order": "column-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 0.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 3.0, + 1.5, + 2.0, + 1.0, + 4.0, + 2.0 + ], + "x": [ + 1.0, + -0.2, + 0.0, + 0.0, + 2.0, + -0.4 + ], + "y": [ + 2.0, + 0.6, + 0.0, + 0.0, + 1.0, + 0.3 + ], + "strideA1": 1, + "strideA2": 2, + "offsetA": 0, + "strideX": 2, + "offsetX": 0, + "strideY": -2, + "offsetY": 2, + "y_out": [ + 12.100000000000001, + 3.3, + 0.0, + 0.0, + 5.5, + 1.5 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xpyp.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xpyp.json new file mode 100644 index 000000000000..8d70016dce07 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xpyp.json @@ -0,0 +1,56 @@ +{ + "order": "column-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 0.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 3.0, + 1.5, + 2.0, + 1.0, + 4.0, + 2.0 + ], + "x": [ + 1.0, + -0.2, + 0.0, + 0.0, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 0.0, + 0.0, + 2.0, + 0.6 + ], + "strideA1": 1, + "strideA2": 2, + "offsetA": 0, + "strideX": 2, + "offsetX": 0, + "strideY": 2, + "offsetY": 0, + "y_out": [ + 5.5, + 1.5, + 0.0, + 0.0, + 12.100000000000001, + 3.3 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_alpha_zero.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_alpha_zero.json new file mode 100644 index 000000000000..8ecc1664f588 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_alpha_zero.json @@ -0,0 +1,50 @@ +{ + "order": "row-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 0.0, + 0.0 + ], + "beta": [ + 2.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 2.0, + 1.0, + 3.0, + 1.5, + 4.0, + 2.0 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 2.0, + 0.6, + 4.0, + 1.2 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_complex_access_pattern.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_complex_access_pattern.json new file mode 100644 index 000000000000..8226a0051f02 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_complex_access_pattern.json @@ -0,0 +1,56 @@ +{ + "order": "row-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 0.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 2.0, + 1.0, + 3.0, + 1.5, + 4.0, + 2.0 + ], + "x": [ + 2.0, + -0.4, + 0.0, + 0.0, + 1.0, + -0.2 + ], + "y": [ + 2.0, + 0.6, + 0.0, + 0.0, + 1.0, + 0.3 + ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "strideX": -2, + "offsetX": 2, + "strideY": -2, + "offsetY": 2, + "y_out": [ + 12.100000000000001, + 3.3, + 0.0, + 0.0, + 5.5, + 1.5 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_ct.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_ct.json new file mode 100644 index 000000000000..9a8cf8cca2af --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_ct.json @@ -0,0 +1,50 @@ +{ + "order": "row-major", + "trans": "conjugate-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 1.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 2.0, + 1.0, + 3.0, + 1.5, + 4.0, + 2.0 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 7.300000000000001, + -4.6000000000000005, + 11.0, + -6.4 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_nt.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_nt.json new file mode 100644 index 000000000000..7486ac067efd --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_nt.json @@ -0,0 +1,50 @@ +{ + "order": "row-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 1.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 2.0, + 1.0, + 3.0, + 1.5, + 4.0, + 2.0 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 6.5, + 1.8, + 14.100000000000001, + 3.9 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_oa.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_oa.json new file mode 100644 index 000000000000..cf300b01f685 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_oa.json @@ -0,0 +1,52 @@ +{ + "order": "row-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 0.0, + 0.0 + ], + "lda": 2, + "A": [ + 0.0, + 0.0, + 1.0, + 0.5, + 2.0, + 1.0, + 3.0, + 1.5, + 4.0, + 2.0 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 1, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 5.5, + 1.5, + 12.100000000000001, + 3.3 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1_sa2.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1_sa2.json new file mode 100644 index 000000000000..5707a554df86 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1_sa2.json @@ -0,0 +1,56 @@ +{ + "order": "row-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 0.0, + 0.0 + ], + "lda": 4, + "A": [ + 1.0, + 0.5, + 0.0, + 0.0, + 2.0, + 1.0, + 0.0, + 0.0, + 3.0, + 1.5, + 0.0, + 0.0, + 4.0, + 2.0 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": 4, + "strideA2": 2, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 5.5, + 1.5, + 12.100000000000001, + 3.3 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1_sa2n.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1_sa2n.json new file mode 100644 index 000000000000..16dccfb59f53 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1_sa2n.json @@ -0,0 +1,56 @@ +{ + "order": "row-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 0.0, + 0.0 + ], + "lda": 4, + "A": [ + 2.0, + 1.0, + 0.0, + 0.0, + 1.0, + 0.5, + 0.0, + 0.0, + 4.0, + 2.0, + 0.0, + 0.0, + 3.0, + 1.5 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": 4, + "strideA2": -2, + "offsetA": 2, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 5.5, + 1.5, + 12.100000000000001, + 3.3 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1n_sa2.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1n_sa2.json new file mode 100644 index 000000000000..a461f586ee30 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1n_sa2.json @@ -0,0 +1,56 @@ +{ + "order": "row-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 0.0, + 0.0 + ], + "lda": -4, + "A": [ + 3.0, + 1.5, + 0.0, + 0.0, + 4.0, + 2.0, + 0.0, + 0.0, + 1.0, + 0.5, + 0.0, + 0.0, + 2.0, + 1.0 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": -4, + "strideA2": 2, + "offsetA": 4, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 5.5, + 1.5, + 12.100000000000001, + 3.3 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1n_sa2n.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1n_sa2n.json new file mode 100644 index 000000000000..27d3007ee66f --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1n_sa2n.json @@ -0,0 +1,56 @@ +{ + "order": "row-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 0.0, + 0.0 + ], + "lda": -4, + "A": [ + 4.0, + 2.0, + 0.0, + 0.0, + 3.0, + 1.5, + 0.0, + 0.0, + 2.0, + 1.0, + 0.0, + 0.0, + 1.0, + 0.5 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": -4, + "strideA2": -2, + "offsetA": 6, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 5.5, + 1.5, + 12.100000000000001, + 3.3 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_t.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_t.json new file mode 100644 index 000000000000..21d5a97e8ebe --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_t.json @@ -0,0 +1,50 @@ +{ + "order": "row-major", + "trans": "transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 1.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 2.0, + 1.0, + 3.0, + 1.5, + 4.0, + 2.0 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 8.7, + 2.3999999999999995, + 13.0, + 3.6 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_x_zeros.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_x_zeros.json new file mode 100644 index 000000000000..86e2ab6f3239 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_x_zeros.json @@ -0,0 +1,50 @@ +{ + "order": "row-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 2.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 2.0, + 1.0, + 3.0, + 1.5, + 4.0, + 2.0 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 7.5, + 2.1, + 16.1, + 4.5 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_x_zeros_beta_one.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_x_zeros_beta_one.json new file mode 100644 index 000000000000..7486ac067efd --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_x_zeros_beta_one.json @@ -0,0 +1,50 @@ +{ + "order": "row-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 1.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 2.0, + 1.0, + 3.0, + 1.5, + 4.0, + 2.0 + ], + "x": [ + 1.0, + -0.2, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 2.0, + 0.6 + ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ + 6.5, + 1.8, + 14.100000000000001, + 3.9 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xnyn.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xnyn.json new file mode 100644 index 000000000000..8226a0051f02 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xnyn.json @@ -0,0 +1,56 @@ +{ + "order": "row-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 0.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 2.0, + 1.0, + 3.0, + 1.5, + 4.0, + 2.0 + ], + "x": [ + 2.0, + -0.4, + 0.0, + 0.0, + 1.0, + -0.2 + ], + "y": [ + 2.0, + 0.6, + 0.0, + 0.0, + 1.0, + 0.3 + ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "strideX": -2, + "offsetX": 2, + "strideY": -2, + "offsetY": 2, + "y_out": [ + 12.100000000000001, + 3.3, + 0.0, + 0.0, + 5.5, + 1.5 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xnyp.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xnyp.json new file mode 100644 index 000000000000..300fe26908e9 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xnyp.json @@ -0,0 +1,56 @@ +{ + "order": "row-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 0.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 2.0, + 1.0, + 3.0, + 1.5, + 4.0, + 2.0 + ], + "x": [ + 2.0, + -0.4, + 0.0, + 0.0, + 1.0, + -0.2 + ], + "y": [ + 1.0, + 0.3, + 0.0, + 0.0, + 2.0, + 0.6 + ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "strideX": -2, + "offsetX": 2, + "strideY": 2, + "offsetY": 0, + "y_out": [ + 5.5, + 1.5, + 0.0, + 0.0, + 12.100000000000001, + 3.3 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xpyn.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xpyn.json new file mode 100644 index 000000000000..9c52a145d2d3 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xpyn.json @@ -0,0 +1,56 @@ +{ + "order": "row-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 0.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 2.0, + 1.0, + 3.0, + 1.5, + 4.0, + 2.0 + ], + "x": [ + 1.0, + -0.2, + 0.0, + 0.0, + 2.0, + -0.4 + ], + "y": [ + 2.0, + 0.6, + 0.0, + 0.0, + 1.0, + 0.3 + ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "strideX": 2, + "offsetX": 0, + "strideY": -2, + "offsetY": 2, + "y_out": [ + 12.100000000000001, + 3.3, + 0.0, + 0.0, + 5.5, + 1.5 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xpyp.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xpyp.json new file mode 100644 index 000000000000..116d94508c76 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xpyp.json @@ -0,0 +1,56 @@ +{ + "order": "row-major", + "trans": "no-transpose", + "M": 2, + "N": 2, + "alpha": [ + 1.0, + 0.0 + ], + "beta": [ + 0.0, + 0.0 + ], + "lda": 2, + "A": [ + 1.0, + 0.5, + 2.0, + 1.0, + 3.0, + 1.5, + 4.0, + 2.0 + ], + "x": [ + 1.0, + -0.2, + 0.0, + 0.0, + 2.0, + -0.4 + ], + "y": [ + 1.0, + 0.3, + 0.0, + 0.0, + 2.0, + 0.6 + ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "strideX": 2, + "offsetX": 0, + "strideY": 2, + "offsetY": 0, + "y_out": [ + 5.5, + 1.5, + 0.0, + 0.0, + 12.100000000000001, + 3.3 + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/test.js b/lib/node_modules/@stdlib/blas/base/zgemv/test/test.js new file mode 100644 index 000000000000..b9fefec94352 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/test.js @@ -0,0 +1,82 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var proxyquire = require( 'proxyquire' ); +var IS_BROWSER = require( '@stdlib/assert/is-browser' ); +var zgemv = require( './../lib' ); + + +// VARIABLES // + +var opts = { + 'skip': IS_BROWSER +}; + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof zgemv, 'function', 'main export is a function' ); + t.end(); +} ); + +tape( 'attached to the main export is a method providing an ndarray interface', function test( t ) { + t.strictEqual( typeof zgemv.ndarray, 'function', 'method is a function' ); + t.end(); +} ); + +tape( 'if a native implementation is available, the main export is the native implementation', opts, function test( t ) { + var zgemv = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire + }); + + t.strictEqual( zgemv, mock, 'returns expected value' ); + t.end(); + + function tryRequire() { + return mock; + } + + function mock() { + // Mock... + } +} ); + +tape( 'if a native implementation is not available, the main export is a JavaScript implementation', opts, function test( t ) { + var zgemv; + var main; + + main = require( './../lib/zgemv.js' ); + + zgemv = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire + }); + + t.strictEqual( zgemv, main, 'returns expected value' ); + t.end(); + + function tryRequire() { + return new Error( 'Cannot find module' ); + } +} ); diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/zgemv/test/test.ndarray.js new file mode 100644 index 000000000000..8a7e7a17eed9 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/test.ndarray.js @@ -0,0 +1,1062 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +/* eslint-disable max-len */ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var isAlmostSameValueComplex128Array = require( '@stdlib/assert/is-almost-same-value-complex128array' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var zgemv = require( './../lib/ndarray.js' ); + + +// FIXTURES // + +var cap = require( './fixtures/column_major_complex_access_pattern.json' ); +var cnt = require( './fixtures/column_major_nt.json' ); +var ct = require( './fixtures/column_major_t.json' ); +var cct = require( './fixtures/column_major_ct.json' ); +var coa = require( './fixtures/column_major_oa.json' ); +var csa1sa2 = require( './fixtures/column_major_sa1_sa2.json' ); +var csa1nsa2 = require( './fixtures/column_major_sa1n_sa2.json' ); +var csa1sa2n = require( './fixtures/column_major_sa1_sa2n.json' ); +var csa1nsa2n = require( './fixtures/column_major_sa1n_sa2n.json' ); +var cxnyn = require( './fixtures/column_major_xnyn.json' ); +var cxpyn = require( './fixtures/column_major_xpyn.json' ); +var cxnyp = require( './fixtures/column_major_xnyp.json' ); +var cxpyp = require( './fixtures/column_major_xpyp.json' ); +var cx = require( './fixtures/column_major_x_zeros.json' ); +var cxb = require( './fixtures/column_major_x_zeros_beta_one.json' ); +var ca = require( './fixtures/column_major_alpha_zero.json' ); +var rap = require( './fixtures/row_major_complex_access_pattern.json' ); +var rnt = require( './fixtures/row_major_nt.json' ); +var rt = require( './fixtures/row_major_t.json' ); +var rct = require( './fixtures/row_major_ct.json' ); +var roa = require( './fixtures/row_major_oa.json' ); +var rsa1sa2 = require( './fixtures/row_major_sa1_sa2.json' ); +var rsa1nsa2 = require( './fixtures/row_major_sa1n_sa2.json' ); +var rsa1sa2n = require( './fixtures/row_major_sa1_sa2n.json' ); +var rsa1nsa2n = require( './fixtures/row_major_sa1n_sa2n.json' ); +var rxnyn = require( './fixtures/row_major_xnyn.json' ); +var rxpyn = require( './fixtures/row_major_xpyn.json' ); +var rxnyp = require( './fixtures/row_major_xnyp.json' ); +var rxpyp = require( './fixtures/row_major_xpyp.json' ); +var rx = require( './fixtures/row_major_x_zeros.json' ); +var rxb = require( './fixtures/row_major_x_zeros_beta_one.json' ); +var ra = require( './fixtures/row_major_alpha_zero.json' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof zgemv, 'function', 'main export is a function' ); + t.end(); +} ); + +tape( 'the function has an arity of 15', function test( t ) { + t.strictEqual( zgemv.length, 15, 'returns expected value' ); + t.end(); +} ); + +tape( 'the function throws an error if provided an invalid first argument', function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + 'foo', + 'bar', + 'beep', + 'boop' + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( value, data.M, data.N, alpha, new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), data.strideX, data.offsetX, beta, new Complex128Array( data.y ), data.strideY, data.offsetY ); + }; + } +} ); + +tape( 'the function throws an error if provided an invalid second argument', function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + -1, + -2, + -3 + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( data.trans, value, data.N, alpha, new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), data.strideX, data.offsetX, beta, new Complex128Array( data.y ), data.strideY, data.offsetY ); + }; + } +} ); + +tape( 'the function throws an error if provided an invalid third argument', function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + -1, + -2, + -3 + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( data.trans, data.M, value, alpha, new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), data.strideX, data.offsetX, beta, new Complex128Array( data.y ), data.strideY, data.offsetY ); + }; + } +} ); + +tape( 'the function throws an error if provided an invalid tenth argument', function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + 0 + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( data.trans, data.M, data.N, alpha, new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), value, data.offsetX, beta, new Complex128Array( data.y ), data.strideY, data.offsetY ); + }; + } +} ); + +tape( 'the function throws an error if provided an invalid fourteenth argument', function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + 0 + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( data.trans, data.M, data.N, alpha, new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), data.strideX, data.offsetX, beta, new Complex128Array( data.y ), value, data.offsetY ); + }; + } +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A*x + β*y` (row-major, no-transpose)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rnt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A*x + β*y` (column-major, no-transpose)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cnt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A^T*x + β*y` (row-major, transpose)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A^T*x + β*y` (column-major, transpose)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = ct; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A^H*x + β*y` (row-major, conjugate-transpose)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rct; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A^H*x + β*y` (column-major, conjugate-transpose)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cct; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function returns a reference to the output vector (row-major)', function test( t ) { + var data; + var out; + var a; + var x; + var y; + + data = rnt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'same reference' ); + + t.end(); +} ); + +tape( 'the function returns a reference to the output vector (column-major)', function test( t ) { + var data; + var out; + var a; + var x; + var y; + + data = cnt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'same reference' ); + + t.end(); +} ); + +tape( 'if either `M` or `N` is `0`, the function returns the output vector unchanged (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rnt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y ); + + out = zgemv( data.trans, 0, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + out = zgemv( data.trans, data.M, 0, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if either `M` or `N` is `0`, the function returns the output vector unchanged (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cnt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y ); + + out = zgemv( data.trans, 0, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + out = zgemv( data.trans, data.M, 0, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `α` is `0+0i` and `β` is `1+0i`, the function returns the output vector unchanged (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rnt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( 0.0, 0.0 ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( 1.0, 0.0 ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `α` is `0+0i` and `β` is `1+0i`, the function returns the output vector unchanged (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cnt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( 0.0, 0.0 ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( 1.0, 0.0 ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `x` contains only zeros and `β` is `1+0i`, the function returns the output vector unchanged (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rxb; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `x` contains only zeros and `β` is `1+0i`, the function returns the output vector unchanged (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cxb; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `α` is `0+0i`, the function scales the output vector by `β` (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = ra; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `α` is `0+0i`, the function scales the output vector by `β` (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = ca; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `x` contains only zeros and `β` is not `1+0i`, the function scales the output vector by `β` (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rx; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `x` contains only zeros and `β` is not `1`, the function scales the output vector by `β` (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cx; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying the strides of the first and second dimensions of `A` (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rsa1sa2; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying the strides of the first and second dimensions of `A` (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = csa1sa2; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports a negative stride for the first dimension of `A` (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rsa1nsa2; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports a negative stride for the first dimension of `A` (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = csa1nsa2; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports a negative stride for the second matrix dimension (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rsa1sa2n; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports a negative stride for the second matrix dimension (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = csa1sa2n; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports negative strides for both matrix dimensions (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rsa1nsa2n; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports negative strides for both matrix dimensions (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = csa1nsa2n; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying an offset for `A` (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = roa; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying an offset for `A` (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = coa; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying `x` and `y` strides (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rxpyp; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying `x` and `y` strides (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cxpyp; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying a negative `x` stride (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rxnyp; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying a negative `x` stride (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cxnyp; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying a negative `y` stride (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rxpyn; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying a negative `y` stride (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cxpyn; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying negative strides for `x` and `y` (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rxnyn; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying negative strides for `x` and `y` (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cxnyn; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports complex access patterns (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rap; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports complex access patterns (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cap; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/test.ndarray.native.js b/lib/node_modules/@stdlib/blas/base/zgemv/test/test.ndarray.native.js new file mode 100644 index 000000000000..b97312c5f79d --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/test.ndarray.native.js @@ -0,0 +1,1024 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var resolve = require( 'path' ).resolve; +var tape = require( 'tape' ); +var isAlmostSameValueComplex128Array = require( '@stdlib/assert/is-almost-same-value-complex128array' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var tryRequire = require( '@stdlib/utils/try-require' ); + + +// VARIABLES // + +var zgemv = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) ); +var opts = { + 'skip': ( zgemv instanceof Error ) +}; + + +// FIXTURES // + +var cap = require( './fixtures/column_major_complex_access_pattern.json' ); +var cnt = require( './fixtures/column_major_nt.json' ); +var ct = require( './fixtures/column_major_t.json' ); +var cct = require( './fixtures/column_major_ct.json' ); +var coa = require( './fixtures/column_major_oa.json' ); +var csa1sa2 = require( './fixtures/column_major_sa1_sa2.json' ); +var csa1nsa2 = require( './fixtures/column_major_sa1n_sa2.json' ); +var csa1sa2n = require( './fixtures/column_major_sa1_sa2n.json' ); +var csa1nsa2n = require( './fixtures/column_major_sa1n_sa2n.json' ); +var cxnyn = require( './fixtures/column_major_xnyn.json' ); +var cxpyn = require( './fixtures/column_major_xpyn.json' ); +var cxnyp = require( './fixtures/column_major_xnyp.json' ); +var cxpyp = require( './fixtures/column_major_xpyp.json' ); +var cx = require( './fixtures/column_major_x_zeros.json' ); +var cxb = require( './fixtures/column_major_x_zeros_beta_one.json' ); +var ca = require( './fixtures/column_major_alpha_zero.json' ); +var rap = require( './fixtures/row_major_complex_access_pattern.json' ); +var rnt = require( './fixtures/row_major_nt.json' ); +var rt = require( './fixtures/row_major_t.json' ); +var rct = require( './fixtures/row_major_ct.json' ); +var roa = require( './fixtures/row_major_oa.json' ); +var rsa1sa2 = require( './fixtures/row_major_sa1_sa2.json' ); +var rsa1nsa2 = require( './fixtures/row_major_sa1n_sa2.json' ); +var rsa1sa2n = require( './fixtures/row_major_sa1_sa2n.json' ); +var rsa1nsa2n = require( './fixtures/row_major_sa1n_sa2n.json' ); +var rxnyn = require( './fixtures/row_major_xnyn.json' ); +var rxpyn = require( './fixtures/row_major_xpyn.json' ); +var rxnyp = require( './fixtures/row_major_xnyp.json' ); +var rxpyp = require( './fixtures/row_major_xpyp.json' ); +var rx = require( './fixtures/row_major_x_zeros.json' ); +var rxb = require( './fixtures/row_major_x_zeros_beta_one.json' ); +var ra = require( './fixtures/row_major_alpha_zero.json' ); + + +// TESTS // + +tape( 'main export is a function', opts, function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof zgemv, 'function', 'main export is a function' ); + t.end(); +} ); + +tape( 'the function has an arity of 15', opts, function test( t ) { + t.strictEqual( zgemv.length, 15, 'returns expected value' ); + t.end(); +} ); + +tape( 'the function throws an error if provided an invalid first argument', opts, function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + 'foo', + 'bar', + 'beep', + 'boop' + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( value, data.M, data.N, alpha, new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), data.strideX, data.offsetX, beta, new Complex128Array( data.y ), data.strideY, data.offsetY ); + }; + } +} ); + +tape( 'the function throws an error if provided an invalid second argument', opts, function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + -1, + -2, + -3 + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( data.trans, value, data.N, alpha, new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), data.strideX, data.offsetX, beta, new Complex128Array( data.y ), data.strideY, data.offsetY ); + }; + } +} ); + +tape( 'the function throws an error if provided an invalid third argument', opts, function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + -1, + -2, + -3 + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( data.trans, data.M, value, alpha, new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), data.strideX, data.offsetX, beta, new Complex128Array( data.y ), data.strideY, data.offsetY ); + }; + } +} ); + +tape( 'the function throws an error if provided an invalid tenth argument', opts, function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + 0 + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( data.trans, data.M, data.N, alpha, new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), value, data.offsetX, beta, new Complex128Array( data.y ), data.strideY, data.offsetY ); + }; + } +} ); + +tape( 'the function throws an error if provided an invalid fourteenth argument', opts, function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + 0 + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( data.trans, data.M, data.N, alpha, new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), data.strideX, data.offsetX, beta, new Complex128Array( data.y ), value, data.offsetY ); + }; + } +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A*x + β*y` (row-major, no-transpose)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rnt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A*x + β*y` (column-major, no-transpose)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cnt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A^T*x + β*y` (row-major, transpose)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A^T*x + β*y` (column-major, transpose)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = ct; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A^H*x + β*y` (row-major, conjugate-transpose)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rct; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A^H*x + β*y` (column-major, conjugate-transpose)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cct; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function returns a reference to the output vector', opts, function test( t ) { + var data; + var out; + var a; + var x; + var y; + + data = rnt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'same reference' ); + + t.end(); +} ); + +tape( 'if either `M` or `N` is `0`, the function returns the output vector unchanged', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rnt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y ); + + out = zgemv( data.trans, 0, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + out = zgemv( data.trans, data.M, 0, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `α` is `0+0i` and `β` is `1+0i`, the function returns the output vector unchanged (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rnt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( 0.0, 0.0 ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( 1.0, 0.0 ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `α` is `0+0i` and `β` is `1+0i`, the function returns the output vector unchanged (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cnt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( 0.0, 0.0 ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( 1.0, 0.0 ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `x` contains only zeros and `β` is `1+0i`, the function returns the output vector unchanged (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rxb; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `x` contains only zeros and `β` is `1+0i`, the function returns the output vector unchanged (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cxb; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `α` is `0+0i`, the function scales the output vector by `β` (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = ra; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `α` is `0+0i`, the function scales the output vector by `β` (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = ca; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `x` contains only zeros and `β` is not `1+0i`, the function scales the output vector by `β` (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rx; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `x` contains only zeros and `β` is not `1`, the function scales the output vector by `β` (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cx; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying the strides of the first and second dimensions of `A` (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rsa1sa2; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying the strides of the first and second dimensions of `A` (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = csa1sa2; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports a negative stride for the first dimension of `A` (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rsa1nsa2; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports a negative stride for the first dimension of `A` (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = csa1nsa2; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports a negative stride for the second matrix dimension (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rsa1sa2n; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports a negative stride for the second matrix dimension (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = csa1sa2n; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports negative strides for both matrix dimensions (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rsa1nsa2n; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports negative strides for both matrix dimensions (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = csa1nsa2n; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying an offset for `A` (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = roa; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying an offset for `A` (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = coa; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying `x` and `y` strides (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rxpyp; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying `x` and `y` strides (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cxpyp; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying a negative `x` stride (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rxnyp; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying a negative `x` stride (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cxnyp; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying a negative `y` stride (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rxpyn; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying a negative `y` stride (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cxpyn; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying negative strides for `x` and `y` (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rxnyn; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying negative strides for `x` and `y` (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cxnyn; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports complex access patterns (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rap; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports complex access patterns (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cap; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); + + t.end(); +} ); diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/test.zgemv.js b/lib/node_modules/@stdlib/blas/base/zgemv/test/test.zgemv.js new file mode 100644 index 000000000000..67ffdfd8a258 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/test.zgemv.js @@ -0,0 +1,823 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var isAlmostSameValueComplex128Array = require( '@stdlib/assert/is-almost-same-value-complex128array' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var zgemv = require( './../lib/zgemv.js' ); + + +// FIXTURES // + +var cnt = require( './fixtures/column_major_nt.json' ); +var ct = require( './fixtures/column_major_t.json' ); +var cct = require( './fixtures/column_major_ct.json' ); +var cxnyn = require( './fixtures/column_major_xnyn.json' ); +var cxpyn = require( './fixtures/column_major_xpyn.json' ); +var cxnyp = require( './fixtures/column_major_xnyp.json' ); +var cxpyp = require( './fixtures/column_major_xpyp.json' ); +var cx = require( './fixtures/column_major_x_zeros.json' ); +var cxb = require( './fixtures/column_major_x_zeros_beta_one.json' ); +var ca = require( './fixtures/column_major_alpha_zero.json' ); +var rnt = require( './fixtures/row_major_nt.json' ); +var rt = require( './fixtures/row_major_t.json' ); +var rct = require( './fixtures/row_major_ct.json' ); +var rxnyn = require( './fixtures/row_major_xnyn.json' ); +var rxpyn = require( './fixtures/row_major_xpyn.json' ); +var rxnyp = require( './fixtures/row_major_xnyp.json' ); +var rxpyp = require( './fixtures/row_major_xpyp.json' ); +var rx = require( './fixtures/row_major_x_zeros.json' ); +var rxb = require( './fixtures/row_major_x_zeros_beta_one.json' ); +var ra = require( './fixtures/row_major_alpha_zero.json' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof zgemv, 'function', 'main export is a function' ); + t.end(); +} ); + +tape( 'the function has an arity of 12', function test( t ) { + t.strictEqual( zgemv.length, 12, 'returns expected value' ); + t.end(); +} ); + +tape( 'the function throws an error if provided an invalid first argument', function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + 'foo', + 'bar', + 'beep', + 'boop' + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( value, data.trans, data.M, data.N, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, beta, new Complex128Array( data.y ), data.strideY ); + }; + } +} ); + +tape( 'the function throws an error if provided an invalid second argument', function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + 'foo', + 'bar', + 'beep', + 'boop' + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( data.order, value, data.M, data.N, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, beta, new Complex128Array( data.y ), data.strideY ); + }; + } +} ); + +tape( 'the function throws an error if provided an invalid third argument', function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + -1, + -2, + -3 + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( data.order, data.trans, value, data.N, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, beta, new Complex128Array( data.y ), data.strideY ); + }; + } +} ); + +tape( 'the function throws an error if provided an invalid fourth argument', function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + -1, + -2, + -3 + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( data.order, data.trans, data.M, value, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, beta, new Complex128Array( data.y ), data.strideY ); + }; + } +} ); + +tape( 'the function throws an error if provided an invalid ninth argument', function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + 0 + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( data.order, data.trans, data.M, data.N, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), value, beta, new Complex128Array( data.y ), data.strideY ); + }; + } +} ); + +tape( 'the function throws an error if provided an invalid twelfth argument', function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + 0 + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( data.order, data.trans, data.M, data.N, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, beta, new Complex128Array( data.y ), value ); + }; + } +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A*x + β*y` (row-major, no-transpose)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rnt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A*x + β*y` (column-major, no-transpose)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cnt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A^T*x + β*y` (row-major, transpose)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A^T*x + β*y` (column-major, transpose)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = ct; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A^H*x + β*y` (row-major, conjugate-transpose)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rct; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A^H*x + β*y` (column-major, conjugate-transpose)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cct; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function returns a reference to the output vector (row-major)', function test( t ) { + var data; + var out; + var a; + var x; + var y; + + data = rt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function returns a reference to the output vector (column-major)', function test( t ) { + var data; + var out; + var a; + var x; + var y; + + data = ct; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if either `M` or `N` is `0`, the function returns the output vector unchanged (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y ); + + out = zgemv( data.order, data.trans, 0, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + out = zgemv( data.order, data.trans, data.M, 0, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if either `M` or `N` is `0`, the function returns the output vector unchanged (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = ct; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y ); + + out = zgemv( data.order, data.trans, 0, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + out = zgemv( data.order, data.trans, data.M, 0, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `α` is `0+0i` and `β` is `1+0i`, the function returns the output vector unchanged (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( 0.0, 0.0 ), a, data.lda, x, data.strideX, new Complex128( 1.0, 0.0 ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `α` is `0+0i` and `β` is `1+0i`, the function returns the output vector unchanged (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = ct; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( 0.0, 0.0 ), a, data.lda, x, data.strideX, new Complex128( 1.0, 0.0 ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `x` contains only zeros and `β` is `1+0i`, the function returns the output vector unchanged (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rxb; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `x` contains only zeros and `β` is `1+0i`, the function returns the output vector unchanged (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cxb; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `α` is `0+0i`, the function scales the output vector by `β` (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = ra; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `α` is `0+0i`, the function scales the output vector by `β` (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = ca; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `x` contains only zeros and `β` is not `1+0i`, the function scales the output vector by `β` (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rx; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `x` contains only zeros and `β` is not `1+0i`, the function scales the output vector by `β` (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cx; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying `x` and `y` strides (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rxpyp; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying `x` and `y` strides (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cxpyp; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying a negative `x` stride (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rxnyp; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying a negative `x` stride (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cxnyp; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying a negative `y` stride (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rxpyn; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying a negative `y` stride (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cxpyn; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports complex access patterns (row-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rxnyn; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports complex access patterns (column-major)', function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cxnyn; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/test.zgemv.native.js b/lib/node_modules/@stdlib/blas/base/zgemv/test/test.zgemv.native.js new file mode 100644 index 000000000000..5c5dd168a17d --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/test.zgemv.native.js @@ -0,0 +1,784 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var resolve = require( 'path' ).resolve; +var tape = require( 'tape' ); +var isAlmostSameValueComplex128Array = require( '@stdlib/assert/is-almost-same-value-complex128array' ); +var Complex128Array = require( '@stdlib/array/complex128' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var tryRequire = require( '@stdlib/utils/try-require' ); + + +// VARIABLES // + +var zgemv = tryRequire( resolve( __dirname, './../lib/zgemv.native.js' ) ); +var opts = { + 'skip': ( zgemv instanceof Error ) +}; + + +// FIXTURES // + +var cnt = require( './fixtures/column_major_nt.json' ); +var ct = require( './fixtures/column_major_t.json' ); +var cct = require( './fixtures/column_major_ct.json' ); +var cxnyn = require( './fixtures/column_major_xnyn.json' ); +var cxpyn = require( './fixtures/column_major_xpyn.json' ); +var cxnyp = require( './fixtures/column_major_xnyp.json' ); +var cxpyp = require( './fixtures/column_major_xpyp.json' ); +var cx = require( './fixtures/column_major_x_zeros.json' ); +var cxb = require( './fixtures/column_major_x_zeros_beta_one.json' ); +var ca = require( './fixtures/column_major_alpha_zero.json' ); +var rnt = require( './fixtures/row_major_nt.json' ); +var rt = require( './fixtures/row_major_t.json' ); +var rct = require( './fixtures/row_major_ct.json' ); +var rxnyn = require( './fixtures/row_major_xnyn.json' ); +var rxpyn = require( './fixtures/row_major_xpyn.json' ); +var rxnyp = require( './fixtures/row_major_xnyp.json' ); +var rxpyp = require( './fixtures/row_major_xpyp.json' ); +var rx = require( './fixtures/row_major_x_zeros.json' ); +var rxb = require( './fixtures/row_major_x_zeros_beta_one.json' ); +var ra = require( './fixtures/row_major_alpha_zero.json' ); + + +// TESTS // + +tape( 'main export is a function', opts, function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof zgemv, 'function', 'main export is a function' ); + t.end(); +} ); + +tape( 'the function has an arity of 12', opts, function test( t ) { + t.strictEqual( zgemv.length, 12, 'returns expected value' ); + t.end(); +} ); + +tape( 'the function throws an error if provided an invalid first argument', opts, function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + 'foo', + 'bar', + 'beep', + 'boop' + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( value, data.trans, data.M, data.N, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, beta, new Complex128Array( data.y ), data.strideY ); + }; + } +} ); + +tape( 'the function throws an error if provided an invalid second argument', opts, function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + 'foo', + 'bar', + 'beep', + 'boop' + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( data.order, value, data.M, data.N, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, beta, new Complex128Array( data.y ), data.strideY ); + }; + } +} ); + +tape( 'the function throws an error if provided an invalid third argument', opts, function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + -1, + -2, + -3 + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( data.order, data.trans, value, data.N, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, beta, new Complex128Array( data.y ), data.strideY ); + }; + } +} ); + +tape( 'the function throws an error if provided an invalid fourth argument', opts, function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + -1, + -2, + -3 + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( data.order, data.trans, data.M, value, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, beta, new Complex128Array( data.y ), data.strideY ); + }; + } +} ); + +tape( 'the function throws an error if provided an invalid ninth argument', opts, function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + 0 + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( data.order, data.trans, data.M, data.N, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), value, beta, new Complex128Array( data.y ), data.strideY ); + }; + } +} ); + +tape( 'the function throws an error if provided an invalid twelfth argument', opts, function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + 0 + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); + var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); + zgemv( data.order, data.trans, data.M, data.N, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, beta, new Complex128Array( data.y ), value ); + }; + } +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A*x + β*y` (row-major, no-transpose)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rnt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A*x + β*y` (column-major, no-transpose)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cnt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A^T*x + β*y` (row-major, transpose)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A^T*x + β*y` (column-major, transpose)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = ct; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A^H*x + β*y` (row-major, conjugate-transpose)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rct; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function performs the matrix-vector operation `y = α*A^H*x + β*y` (column-major, conjugate-transpose)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cct; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function returns a reference to the output vector', opts, function test( t ) { + var data; + var out; + var a; + var x; + var y; + + data = rnt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'same reference' ); + + t.end(); +} ); + +tape( 'if either `M` or `N` is `0`, the function returns the output vector unchanged', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rnt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y ); + + out = zgemv( data.order, data.trans, 0, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + out = zgemv( data.order, data.trans, data.M, 0, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `α` is `0+0i` and `β` is `1+0i`, the function returns the output vector unchanged (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rnt; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( 0.0, 0.0 ), a, data.lda, x, data.strideX, new Complex128( 1.0, 0.0 ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `α` is `0+0i` and `β` is `1+0i`, the function returns the output vector unchanged (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = ct; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( 0.0, 0.0 ), a, data.lda, x, data.strideX, new Complex128( 1.0, 0.0 ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `x` contains only zeros and `β` is `1+0i`, the function returns the output vector unchanged (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rxb; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `x` contains only zeros and `β` is `1+0i`, the function returns the output vector unchanged (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cxb; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `α` is `0+0i`, the function scales the output vector by `β` (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = ra; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `α` is `0+0i`, the function scales the output vector by `β` (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = ca; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `x` contains only zeros and `β` is not `1+0i`, the function scales the output vector by `β` (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rx; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'if `x` contains only zeros and `β` is not `1`, the function scales the output vector by `β` (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cx; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying `x` and `y` strides (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rxpyp; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying `x` and `y` strides (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cxpyp; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying a negative `x` stride (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rxnyp; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying a negative `x` stride (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cxnyp; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying a negative `y` stride (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rxpyn; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports specifying a negative `y` stride (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cxpyn; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports complex access patterns (row-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = rxnyn; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); + +tape( 'the function supports complex access patterns (column-major)', opts, function test( t ) { + var expected; + var data; + var out; + var a; + var x; + var y; + + data = cxnyn; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + + t.end(); +} ); From e13d23ecbe76fdfc239cf8c046e2f0c096aaf07b Mon Sep 17 00:00:00 2001 From: Om-A-osc Date: Thu, 12 Feb 2026 23:35:39 +0530 Subject: [PATCH 02/12] bench: use string interpolation in blas/base/zgemv --- 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: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: passed - 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 --- --- .../@stdlib/blas/base/zgemv/benchmark/benchmark.js | 3 ++- .../@stdlib/blas/base/zgemv/benchmark/benchmark.native.js | 3 ++- .../@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.js | 3 ++- .../blas/base/zgemv/benchmark/benchmark.ndarray.native.js | 3 ++- 4 files changed, 8 insertions(+), 4 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.js index 2dd78ef71f9d..91f57a1a8718 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.js +++ b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.js @@ -25,6 +25,7 @@ var uniform = require( '@stdlib/random/array/uniform' ); var isnan = require( '@stdlib/math/base/assert/is-nan' ); var pow = require( '@stdlib/math/base/special/pow' ); var floor = require( '@stdlib/math/base/special/floor' ); +var format = require( '@stdlib/string/format' ); var Complex128Array = require( '@stdlib/array/complex128' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); var pkg = require( './../package.json' ).name; @@ -105,7 +106,7 @@ function main() { for ( i = min; i <= max; i++ ) { N = floor( pow( pow( 10, i ), 1.0 / 2.0 ) ); f = createBenchmark( N ); - bench( pkg + ':size=' + ( N * N ), f ); + bench( format( '%s:size=%d', pkg, N * N ), f ); } } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.native.js index 3a38b290cc2a..cc535c9b7958 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.native.js +++ b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.native.js @@ -25,6 +25,7 @@ var bench = require( '@stdlib/bench' ); var uniform = require( '@stdlib/random/array/uniform' ); var isnan = require( '@stdlib/math/base/assert/is-nan' ); var pow = require( '@stdlib/math/base/special/pow' ); +var format = require( '@stdlib/string/format' ); var floor = require( '@stdlib/math/base/special/floor' ); var Complex128Array = require( '@stdlib/array/complex128' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); @@ -110,7 +111,7 @@ function main() { for ( i = min; i <= max; i++ ) { N = floor( pow( pow( 10, i ), 1.0 / 2.0 ) ); f = createBenchmark( N ); - bench( pkg + '::native:size=' + ( N * N ), opts, f ); + bench( format( '%s::native:size=%d', pkg, N * N ), opts, f ); } } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.js index 9e994623121d..eccf79dad38e 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.js @@ -24,6 +24,7 @@ var bench = require( '@stdlib/bench' ); var uniform = require( '@stdlib/random/array/uniform' ); var isnan = require( '@stdlib/math/base/assert/is-nan' ); var pow = require( '@stdlib/math/base/special/pow' ); +var format= require( '@stdlib/string/format' ); var floor = require( '@stdlib/math/base/special/floor' ); var Complex128Array = require( '@stdlib/array/complex128' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); @@ -105,7 +106,7 @@ function main() { for ( i = min; i <= max; i++ ) { N = floor( pow( pow( 10, i ), 1.0 / 2.0 ) ); f = createBenchmark( N ); - bench( pkg + ':ndarray:size=' + ( N * N ), f ); + bench( format( '%s:ndarray:size=%d', pkg, N * N ), f ); } } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.native.js b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.native.js index b096386aa6f7..caa313a9fa10 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.native.js +++ b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.native.js @@ -25,6 +25,7 @@ var bench = require( '@stdlib/bench' ); var uniform = require( '@stdlib/random/array/uniform' ); var isnan = require( '@stdlib/math/base/assert/is-nan' ); var pow = require( '@stdlib/math/base/special/pow' ); +var format = require( '@stdlib/string/format' ); var floor = require( '@stdlib/math/base/special/floor' ); var Complex128Array = require( '@stdlib/array/complex128' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); @@ -110,7 +111,7 @@ function main() { for ( i = min; i <= max; i++ ) { N = floor( pow( pow( 10, i ), 1.0 / 2.0 ) ); f = createBenchmark( N ); - bench( pkg + '::native:ndarray:size=' + ( N * N ), opts, f ); + bench( format( '%s::native:ndarray:size=%d', pkg, N * N ), opts, f ); } } From b078985a37c4ec8b20635181b11477bde0e62a31 Mon Sep 17 00:00:00 2001 From: Om-A-osc Date: Fri, 13 Feb 2026 17:19:55 +0530 Subject: [PATCH 03/12] fix: addressing first round comments --- 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: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: passed - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: passed - 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 --- --- .../blas/base/zgemv/benchmark/benchmark.ndarray.js | 2 +- .../@stdlib/blas/base/zgemv/examples/index.js | 2 +- .../@stdlib/blas/base/zgemv/manifest.json | 11 ++++++++--- 3 files changed, 10 insertions(+), 5 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.js index eccf79dad38e..9738357792a5 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.js @@ -24,7 +24,7 @@ var bench = require( '@stdlib/bench' ); var uniform = require( '@stdlib/random/array/uniform' ); var isnan = require( '@stdlib/math/base/assert/is-nan' ); var pow = require( '@stdlib/math/base/special/pow' ); -var format= require( '@stdlib/string/format' ); +var format = require( '@stdlib/string/format' ); var floor = require( '@stdlib/math/base/special/floor' ); var Complex128Array = require( '@stdlib/array/complex128' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/examples/index.js b/lib/node_modules/@stdlib/blas/base/zgemv/examples/index.js index 3d7413c68812..237160ed6144 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/examples/index.js +++ b/lib/node_modules/@stdlib/blas/base/zgemv/examples/index.js @@ -22,7 +22,7 @@ var Complex128Array = require( '@stdlib/array/complex128' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); -var zgemv = require( './../lib/zgemv.js' ); +var zgemv = require( './../lib' ); // MAIN // diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/manifest.json b/lib/node_modules/@stdlib/blas/base/zgemv/manifest.json index 235ccd2cfe1c..791d7564e73f 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/manifest.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/manifest.json @@ -396,10 +396,15 @@ "dependencies": [ "@stdlib/blas/base/shared", "@stdlib/blas/base/xerbla", - "@stdlib/blas/base/dscal", - "@stdlib/blas/ext/base/dfill", + "@stdlib/blas/base/zscal", + "@stdlib/blas/ext/base/zfill", "@stdlib/strided/base/stride2offset", - "@stdlib/ndarray/base/assert/is-row-major" + "@stdlib/ndarray/base/assert/is-row-major", + "@stdlib/complex/float64/ctor", + "@stdlib/complex/float64/base/mul", + "@stdlib/complex/float64/base/add", + "@stdlib/complex/float64/conj", + "@stdlib/complex/float64/base/assert/is-equal" ] }, { From 2cce4c55901087609ad6d06acc73e4b2cdd4ecca Mon Sep 17 00:00:00 2001 From: kaustubh Date: Mon, 11 May 2026 12:02:02 +0530 Subject: [PATCH 04/12] refactor JS Benchmarks --- .../blas/base/zgemv/benchmark/benchmark.js | 41 ++++++++++++------- .../base/zgemv/benchmark/benchmark.native.js | 37 +++++++++++------ .../base/zgemv/benchmark/benchmark.ndarray.js | 41 ++++++++++++------- .../benchmark/benchmark.ndarray.native.js | 37 +++++++++++------ 4 files changed, 100 insertions(+), 56 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.js index 91f57a1a8718..981343dae61f 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.js +++ b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.js @@ -25,9 +25,9 @@ var uniform = require( '@stdlib/random/array/uniform' ); var isnan = require( '@stdlib/math/base/assert/is-nan' ); var pow = require( '@stdlib/math/base/special/pow' ); var floor = require( '@stdlib/math/base/special/floor' ); -var format = require( '@stdlib/string/format' ); var Complex128Array = require( '@stdlib/array/complex128' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var format = require( '@stdlib/string/format' ); var pkg = require( './../package.json' ).name; var zgemv = require( './../lib/zgemv.js' ); @@ -45,18 +45,28 @@ var options = { * Creates a benchmark function. * * @private -* @param {PositiveInteger} N - array length +* @param {PositiveInteger} N - array dimension size * @returns {Function} benchmark function */ function createBenchmark( N ) { - var alpha = new Complex128( 1.0, 0.0 ); - var xbuf = uniform( N * 2, -10.0, 10.0, options ); - var ybuf = uniform( N * 2, -10.0, 10.0, options ); - var Abuf = uniform( N * N * 2, -10.0, 10.0, options ); - var beta = new Complex128( 1.0, 0.0 ); - var x = new Complex128Array( xbuf.buffer ); - var y = new Complex128Array( ybuf.buffer ); - var A = new Complex128Array( Abuf.buffer ); + var alpha; + var beta; + var xbuf; + var ybuf; + var Abuf; + var x; + var y; + var A; + + xbuf = uniform( N*2, -100.0, 100.0, options ); + x = new Complex128Array( xbuf.buffer ); + ybuf = uniform( N*2, -100.0, 100.0, options ); + y = new Complex128Array( ybuf.buffer ); + Abuf = uniform( (N*N)*2, -100.0, 100.0, options ); + A = new Complex128Array( Abuf.buffer ); + + alpha = new Complex128( 0.5, 0.5 ); + beta = new Complex128( 0.5, -0.5 ); return benchmark; @@ -68,16 +78,17 @@ function createBenchmark( N ) { */ function benchmark( b ) { var i; + var z; b.tic(); for ( i = 0; i < b.iterations; i++ ) { - zgemv( 'row-major', 'no-transpose', N, N, alpha, A, N, x, 1, beta, y, 1 ); - if ( isnan( ybuf[ i % ( N * 2 ) ] ) ) { + z = zgemv( 'row-major', 'no-transpose', N, N, alpha, A, N, x, 1, beta, y, 1 ); + if ( isnan( z[ i%z.length ] ) ) { b.fail( 'should not return NaN' ); } } b.toc(); - if ( isnan( ybuf[ i % ( N * 2 ) ] ) ) { + if ( isnan( z[ i%z.length ] ) ) { b.fail( 'should not return NaN' ); } b.pass( 'benchmark finished' ); @@ -104,9 +115,9 @@ function main() { max = 6; // 10^max for ( i = min; i <= max; i++ ) { - N = floor( pow( pow( 10, i ), 1.0 / 2.0 ) ); + N = floor( pow( pow( 10, i ), 1.0/2.0 ) ); f = createBenchmark( N ); - bench( format( '%s:size=%d', pkg, N * N ), f ); + bench( format( '%s:size=%d', pkg, N*N ), f ); } } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.native.js index cc535c9b7958..0a805c16b3fa 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.native.js +++ b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.native.js @@ -54,14 +54,24 @@ var options = { * @returns {Function} benchmark function */ function createBenchmark( N ) { - var alpha = new Complex128( 1.0, 0.0 ); - var xbuf = uniform( N * 2, -10.0, 10.0, options ); - var ybuf = uniform( N * 2, -10.0, 10.0, options ); - var Abuf = uniform( N * N * 2, -10.0, 10.0, options ); - var beta = new Complex128( 1.0, 0.0 ); - var x = new Complex128Array( xbuf.buffer ); - var y = new Complex128Array( ybuf.buffer ); - var A = new Complex128Array( Abuf.buffer ); + var alpha; + var beta; + var xbuf; + var ybuf; + var Abuf; + var x; + var y; + var A; + + xbuf = uniform( N*2, -100.0, 100.0, options ); + x = new Complex128Array( xbuf.buffer ); + ybuf = uniform( N*2, -100.0, 100.0, options ); + y = new Complex128Array( ybuf.buffer ); + Abuf = uniform( (N*N)*2, -100.0, 100.0, options ); + A = new Complex128Array( Abuf.buffer ); + + alpha = new Complex128( 0.5, 0.5 ); + beta = new Complex128( 0.5, -0.5 ); return benchmark; @@ -73,16 +83,17 @@ function createBenchmark( N ) { */ function benchmark( b ) { var i; + var z; b.tic(); for ( i = 0; i < b.iterations; i++ ) { - zgemv( 'row-major', 'no-transpose', N, N, alpha, A, N, x, 1, beta, y, 1 ); - if ( isnan( ybuf[ i % ( N * 2 ) ] ) ) { + z = zgemv( 'row-major', 'no-transpose', N, N, alpha, A, N, x, 1, beta, y, 1 ); + if ( isnan( z[ i%z.length ] ) ) { b.fail( 'should not return NaN' ); } } b.toc(); - if ( isnan( ybuf[ i % ( N * 2 ) ] ) ) { + if ( isnan( z[ i%z.length ] ) ) { b.fail( 'should not return NaN' ); } b.pass( 'benchmark finished' ); @@ -109,9 +120,9 @@ function main() { max = 6; // 10^max for ( i = min; i <= max; i++ ) { - N = floor( pow( pow( 10, i ), 1.0 / 2.0 ) ); + N = floor( pow( pow( 10, i ), 1.0/2.0 ) ); f = createBenchmark( N ); - bench( format( '%s::native:size=%d', pkg, N * N ), opts, f ); + bench( format( '%s::native:size=%d', pkg, N*N ), opts, f ); } } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.js index 9738357792a5..8b26a4bd2cfb 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.js @@ -24,10 +24,10 @@ var bench = require( '@stdlib/bench' ); var uniform = require( '@stdlib/random/array/uniform' ); var isnan = require( '@stdlib/math/base/assert/is-nan' ); var pow = require( '@stdlib/math/base/special/pow' ); -var format = require( '@stdlib/string/format' ); var floor = require( '@stdlib/math/base/special/floor' ); var Complex128Array = require( '@stdlib/array/complex128' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var format = require( '@stdlib/string/format' ); var pkg = require( './../package.json' ).name; var zgemv = require( './../lib/ndarray.js' ); @@ -45,18 +45,28 @@ var options = { * Creates a benchmark function. * * @private -* @param {PositiveInteger} N - array length +* @param {PositiveInteger} N - array dimension size * @returns {Function} benchmark function */ function createBenchmark( N ) { - var alpha = new Complex128( 1.0, 0.0 ); - var xbuf = uniform( N * 2, -10.0, 10.0, options ); - var ybuf = uniform( N * 2, -10.0, 10.0, options ); - var Abuf = uniform( N * N * 2, -10.0, 10.0, options ); - var beta = new Complex128( 1.0, 0.0 ); - var x = new Complex128Array( xbuf.buffer ); - var y = new Complex128Array( ybuf.buffer ); - var A = new Complex128Array( Abuf.buffer ); + var alpha; + var beta; + var xbuf; + var ybuf; + var Abuf; + var x; + var y; + var A; + + xbuf = uniform( N*2, -100.0, 100.0, options ); + x = new Complex128Array( xbuf.buffer ); + ybuf = uniform( N*2, -100.0, 100.0, options ); + y = new Complex128Array( ybuf.buffer ); + Abuf = uniform( (N*N)*2, -100.0, 100.0, options ); + A = new Complex128Array( Abuf.buffer ); + + alpha = new Complex128( 0.5, 0.5 ); + beta = new Complex128( 0.5, -0.5 ); return benchmark; @@ -68,16 +78,17 @@ function createBenchmark( N ) { */ function benchmark( b ) { var i; + var z; b.tic(); for ( i = 0; i < b.iterations; i++ ) { - zgemv( 'no-transpose', N, N, alpha, A, N, 1, 0, x, 1, 0, beta, y, 1, 0 ); - if ( isnan( ybuf[ i % ( N * 2 ) ] ) ) { + z = zgemv( 'no-transpose', N, N, alpha, A, 1, N, 0, x, 1, 0, beta, y, 1, 0 ); + if ( isnan( z[ i%z.length ] ) ) { b.fail( 'should not return NaN' ); } } b.toc(); - if ( isnan( ybuf[ i % ( N * 2 ) ] ) ) { + if ( isnan( z[ i%z.length ] ) ) { b.fail( 'should not return NaN' ); } b.pass( 'benchmark finished' ); @@ -104,9 +115,9 @@ function main() { max = 6; // 10^max for ( i = min; i <= max; i++ ) { - N = floor( pow( pow( 10, i ), 1.0 / 2.0 ) ); + N = floor( pow( pow( 10, i ), 1.0/2.0 ) ); f = createBenchmark( N ); - bench( format( '%s:ndarray:size=%d', pkg, N * N ), f ); + bench( format( '%s:ndarray:size=%d', pkg, N*N ), f ); } } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.native.js b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.native.js index caa313a9fa10..c9121e3b8202 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.native.js +++ b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.native.js @@ -54,14 +54,24 @@ var options = { * @returns {Function} benchmark function */ function createBenchmark( N ) { - var alpha = new Complex128( 1.0, 0.0 ); - var xbuf = uniform( N * 2, -10.0, 10.0, options ); - var ybuf = uniform( N * 2, -10.0, 10.0, options ); - var Abuf = uniform( N * N * 2, -10.0, 10.0, options ); - var beta = new Complex128( 1.0, 0.0 ); - var x = new Complex128Array( xbuf.buffer ); - var y = new Complex128Array( ybuf.buffer ); - var A = new Complex128Array( Abuf.buffer ); + var alpha; + var beta; + var xbuf; + var ybuf; + var Abuf; + var x; + var y; + var A; + + xbuf = uniform( N*2, -100.0, 100.0, options ); + x = new Complex128Array( xbuf.buffer ); + ybuf = uniform( N*2, -100.0, 100.0, options ); + y = new Complex128Array( ybuf.buffer ); + Abuf = uniform( (N*N)*2, -100.0, 100.0, options ); + A = new Complex128Array( Abuf.buffer ); + + alpha = new Complex128( 0.5, 0.5 ); + beta = new Complex128( 0.5, -0.5 ); return benchmark; @@ -73,16 +83,17 @@ function createBenchmark( N ) { */ function benchmark( b ) { var i; + var z; b.tic(); for ( i = 0; i < b.iterations; i++ ) { - zgemv( 'no-transpose', N, N, alpha, A, N, 1, 0, x, 1, 0, beta, y, 1, 0 ); - if ( isnan( ybuf[ i % ( N * 2 ) ] ) ) { + z = zgemv( 'no-transpose', N, N, alpha, A, N, 1, 0, x, 1, 0, beta, y, 1, 0 ); + if ( isnan( z[ i%z.length ] ) ) { b.fail( 'should not return NaN' ); } } b.toc(); - if ( isnan( ybuf[ i % ( N * 2 ) ] ) ) { + if ( isnan( z[ i%z.length ] ) ) { b.fail( 'should not return NaN' ); } b.pass( 'benchmark finished' ); @@ -109,9 +120,9 @@ function main() { max = 6; // 10^max for ( i = min; i <= max; i++ ) { - N = floor( pow( pow( 10, i ), 1.0 / 2.0 ) ); + N = floor( pow( pow( 10, i ), 1.0/2.0 ) ); f = createBenchmark( N ); - bench( format( '%s::native:ndarray:size=%d', pkg, N * N ), opts, f ); + bench( format( '%s::native:ndarray:size=%d', pkg, N*N ), opts, f ); } } From 3c07cb002f0abb3f14dec196a65454974daeefec Mon Sep 17 00:00:00 2001 From: kaustubh Date: Mon, 11 May 2026 13:12:25 +0530 Subject: [PATCH 05/12] docs: refactor and cleanup --- .../@stdlib/blas/base/zgemv/docs/repl.txt | 88 +++-- .../blas/base/zgemv/docs/types/index.d.ts | 66 ++-- .../blas/base/zgemv/docs/types/test.ts | 347 ++++++++++++++++-- 3 files changed, 403 insertions(+), 98 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/docs/repl.txt b/lib/node_modules/@stdlib/blas/base/zgemv/docs/repl.txt index a9b2dd07a572..e8dc031338a6 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/docs/repl.txt +++ b/lib/node_modules/@stdlib/blas/base/zgemv/docs/repl.txt @@ -1,15 +1,15 @@ {{alias}}( order, trans, M, N, α, A, lda, x, sx, β, y, sy ) - Performs one of the matrix-vector operations `y = α*A*x + β*y`, - `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, where `α` and `β` are - scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. + Performs one of the matrix-vector operations `y = α*A*x + β*y` or + `y = α*A**T*x + β*y` or `y = α*A^T*x + β*y`, where `α` and `β` are scalars, + `x` and `y` are vectors, and `A` is an `M` by `N` matrix. Indexing is relative to the first index. To introduce an offset, use typed array views. If `M` or `N` is equal to `0`, the function returns `y` unchanged. - If `α` equals `0+0i` and `β` equals `1+0i`, the function returns `y` + If `α` equals `0 + 0i` and `β` equals `1 + 0i`, the function returns `y` unchanged. Parameters @@ -59,26 +59,52 @@ Examples -------- - > var x = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0 ] ); - > var y = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0 ] ); - > var values = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ]; - > var A = new {{alias:@stdlib/array/complex128}}( values ); - > var alpha = new {{alias:@stdlib/complex/float64/ctor}}( 1.0, 0.0 ); - > var beta = new {{alias:@stdlib/complex/float64/ctor}}( 1.0, 0.0 ); - > var ord = 'row-major'; + // Standard usage: + > var x = new {{alias:@stdlib/array/complex128}}([ 1.0, 1.0, 2.0, 2.0 ]); + > var y = new {{alias:@stdlib/array/complex128}}([ 1.0, 1.0, 2.0, 2.0 ]); + > var buf = [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ]; + > var A = new {{alias:@stdlib/array/complex128}}( buf ); + > var alpha = new {{alias:@stdlib/complex/float64/ctor}}( 0.5, 0.5 ); + > var beta = new {{alias:@stdlib/complex/float64/ctor}}( 0.5, -0.5 ); + > var ord = 'column-major'; > var trans = 'no-transpose'; > {{alias}}( ord, trans, 2, 2, alpha, A, 2, x, 1, beta, y, 1 ) - - > var v = y.get( 0 ); - > var re = {{alias:@stdlib/complex/float64/real}}( v ) - -1.0 - > var im = {{alias:@stdlib/complex/float64/imag}}( v ) - 11.0 + [ -6.0, 7.0, -8.0, 10.0 ] + + // Advanced indexing: + > x = new {{alias:@stdlib/array/complex128}}([ 2.0, 2.0, 1.0, 1.0 ]); + > y = new {{alias:@stdlib/array/complex128}}([ 2.0, 2.0, 1.0, 1.0 ]); + > buf = [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ]; + > A = new {{alias:@stdlib/array/complex128}}( buf ); + > alpha = new {{alias:@stdlib/complex/float64/ctor}}( 0.5, 0.5 ); + > beta = new {{alias:@stdlib/complex/float64/ctor}}( 0.5, -0.5 ); + > ord = 'column-major'; + > trans = 'no-transpose'; + > {{alias}}( ord, trans, 2, 2, alpha, A, 2, x, -1, beta, y, -1 ) + [ -8.0, 10.0, -6.0, 7.0 ] + + // Using typed array views: + > var x0buf = [ 0.0, 0.0, 1.0, 1.0, 2.0, 2.0 ]; + > var x0 = new {{alias:@stdlib/array/complex128}}( x0buf ); + > var y0buf = [ 0.0, 0.0, 1.0, 1.0, 2.0, 2.0 ]; + > var y0 = new {{alias:@stdlib/array/complex128}}( y0buf ); + > var x0bytes = x0.BYTES_PER_ELEMENT*1; + > var x1 = new {{alias:@stdlib/array/complex128}}( x0.buffer, x0bytes ); + > var y0bytes = y0.BYTES_PER_ELEMENT*1; + > var y1 = new {{alias:@stdlib/array/complex128}}( y0.buffer, y0bytes ); + > buf = [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ]; + > A = new {{alias:@stdlib/array/complex128}}( buf ); + > alpha = new {{alias:@stdlib/complex/float64/ctor}}( 0.5, 0.5 ); + > beta = new {{alias:@stdlib/complex/float64/ctor}}( 0.5, -0.5 ); + > ord = 'column-major'; + > trans = 'no-transpose'; + > {{alias}}( ord, trans, 2, 2, alpha, A, 2, x1, 1, beta, y1, 1 ) + [ -6.0, 7.0, -8.0, 10.0 ] {{alias}}.ndarray( trans, M, N, α, A, sa1, sa2, oa, x, sx, ox, β, y, sy, oy ) Performs one of the matrix-vector operations `y = α*A*x + β*y`, - `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, using alternative indexing + `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y` using alternative indexing semantics and where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. @@ -111,7 +137,7 @@ Stride of the second dimension of `A`. oa: integer - Starting index for `A`. + Starting index (offset) for `A`. x: Complex128Array First input vector. @@ -120,7 +146,7 @@ Index increment for `x`. ox: integer - Starting index for `x`. + Starting index (offset) for `x`. β: Complex128 Scalar constant. @@ -132,7 +158,7 @@ Index increment for `y`. oy: integer - Starting index for `y`. + Starting index (offset) for `y`. Returns ------- @@ -141,16 +167,16 @@ Examples -------- - > var x = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0 ] ); - > var y = new {{alias:@stdlib/array/complex128}}( [ 1.0, 1.0, 1.0, 1.0 ] ); - > var values = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ]; - > var A = new {{alias:@stdlib/array/complex128}}( values ); - > var alpha = new {{alias:@stdlib/complex/float64/ctor}}( 1.0, 0.0 ); - > var beta = new {{alias:@stdlib/complex/float64/ctor}}( 1.0, 0.0 ); - > var trans = 'no-transpose'; - > {{alias}}.ndarray( trans, 2, 2, alpha, A, 2, 1, 0, x, 1, 0, beta, y, - ... 1, 0 ) - + > x = new {{alias:@stdlib/array/complex128}}([ 1.0, 1.0, 2.0, 2.0 ]); + > y = new {{alias:@stdlib/array/complex128}}([ 1.0, 1.0, 2.0, 2.0 ]); + > buf = [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ]; + > A = new {{alias:@stdlib/array/complex128}}( buf ); + > alpha = new {{alias:@stdlib/complex/float64/ctor}}( 0.5, 0.5 ); + > beta = new {{alias:@stdlib/complex/float64/ctor}}( 0.5, -0.5 ); + > ord = 'column-major'; + > trans = 'no-transpose'; + > {{alias}}.ndarray(trans,2,2,alpha,A,1,2,0,x,1,0,beta,y,1,0) + [ -6.0, 7.0, -8.0, 10.0 ] See Also -------- diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/base/zgemv/docs/types/index.d.ts index 02a6e1dd01e8..97e027a9625f 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/blas/base/zgemv/docs/types/index.d.ts @@ -20,8 +20,8 @@ /// -import { Layout, TransposeOperation } from '@stdlib/types/blas'; import { Complex128Array } from '@stdlib/types/array'; +import { Layout, TransposeOperation } from '@stdlib/types/blas'; import { Complex128 } from '@stdlib/types/complex'; /** @@ -29,7 +29,7 @@ import { Complex128 } from '@stdlib/types/complex'; */ interface Routine { /** - * Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. + * Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y`, where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. * * @param order - storage layout * @param trans - specifies whether `A` should be transposed, conjugate-transposed, or not transposed @@ -37,7 +37,7 @@ interface Routine { * @param N - number of columns in the matrix `A` * @param alpha - scalar constant * @param A - input matrix - * @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) + * @param LDA - stride of the first dimension of `A` * @param x - first input vector * @param strideX - `x` stride length * @param beta - scalar constant @@ -49,19 +49,19 @@ interface Routine { * var Complex128Array = require( '@stdlib/array/complex128' ); * var Complex128 = require( '@stdlib/complex/float64/ctor' ); * - * var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); - * var x = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0 ] ); - * var y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0 ] ); - * var alpha = new Complex128( 1.0, 0.0 ); - * var beta = new Complex128( 1.0, 0.0 ); + * var A = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ] ); + * var x = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0 ] ); + * var y = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); + * var alpha = new Complex128( 0.5, 0.5 ); + * var beta = new Complex128( 0.5, -0.5 ); * - * zgemv( 'row-major', 'no-transpose', 2, 2, alpha, A, 2, x, 1, beta, y, 1 ); - * // y => + * zgemv( 'column-major', 'no-transpose', 4, 2, alpha, A, 4, x, 1, beta, y, 1 ); + * // y => [ -10.0, 11.0, -12.0, 14.0, -14.0, 17.0, -16.0, 20.0 ] */ ( order: Layout, trans: TransposeOperation, M: number, N: number, alpha: Complex128, A: Complex128Array, LDA: number, x: Complex128Array, strideX: number, beta: Complex128, y: Complex128Array, strideY: number ): Complex128Array; /** - * Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, using alternative indexing semantics and where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. + * Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y`, using alternative indexing semantics and where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. * * @param trans - specifies whether `A` should be transposed, conjugate-transposed, or not transposed * @param M - number of rows in the matrix `A` @@ -84,20 +84,20 @@ interface Routine { * var Complex128Array = require( '@stdlib/array/complex128' ); * var Complex128 = require( '@stdlib/complex/float64/ctor' ); * - * var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); - * var x = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0 ] ); - * var y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0 ] ); - * var alpha = new Complex128( 1.0, 0.0 ); - * var beta = new Complex128( 1.0, 0.0 ); + * var A = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ] ); + * var x = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0 ] ); + * var y = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); + * var alpha = new Complex128( 0.5, 0.5 ); + * var beta = new Complex128( 0.5, -0.5 ); * - * zgemv.ndarray( 'no-transpose', 2, 2, alpha, A, 2, 1, 0, x, 1, 0, beta, y, 1, 0 ); - * // y => + * zgemv.ndarray( 'no-transpose', 4, 2, alpha, A, 1, 4, 0, x, 1, 0, beta, y, 1, 0 ); + * // y => [ -10.0, 11.0, -12.0, 14.0, -14.0, 17.0, -16.0, 20.0 ] */ ndarray( trans: TransposeOperation, M: number, N: number, alpha: Complex128, A: Complex128Array, strideA1: number, strideA2: number, offsetA: number, x: Complex128Array, strideX: number, offsetX: number, beta: Complex128, y: Complex128Array, strideY: number, offsetY: number ): Complex128Array; } /** -* Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. +* Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y`, where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. * * @param order - storage layout * @param trans - specifies whether `A` should be transposed, conjugate-transposed, or not transposed @@ -117,27 +117,27 @@ interface Routine { * var Complex128Array = require( '@stdlib/array/complex128' ); * var Complex128 = require( '@stdlib/complex/float64/ctor' ); * -* var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); -* var x = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0 ] ); -* var y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0 ] ); -* var alpha = new Complex128( 1.0, 0.0 ); -* var beta = new Complex128( 1.0, 0.0 ); +* var A = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ] ); +* var x = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0 ] ); +* var y = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); +* var alpha = new Complex128( 0.5, 0.5 ); +* var beta = new Complex128( 0.5, -0.5 ); * -* zgemv( 'row-major', 'no-transpose', 2, 2, alpha, A, 2, x, 1, beta, y, 1 ); -* // y => +* zgemv( 'column-major', 'no-transpose', 4, 2, alpha, A, 4, x, 1, beta, y, 1 ); +* // y => [ -10.0, 11.0, -12.0, 14.0, -14.0, 17.0, -16.0, 20.0 ] * * @example * var Complex128Array = require( '@stdlib/array/complex128' ); * var Complex128 = require( '@stdlib/complex/float64/ctor' ); * -* var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); -* var x = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0 ] ); -* var y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0 ] ); -* var alpha = new Complex128( 1.0, 0.0 ); -* var beta = new Complex128( 1.0, 0.0 ); +* var A = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ] ); +* var x = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0 ] ); +* var y = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); +* var alpha = new Complex128( 0.5, 0.5 ); +* var beta = new Complex128( 0.5, -0.5 ); * -* zgemv.ndarray( 'no-transpose', 2, 2, alpha, A, 2, 1, 0, x, 1, 0, beta, y, 1, 0 ); -* // y => +* zgemv.ndarray( 'no-transpose', 4, 2, alpha, A, 1, 4, 0, x, 1, 0, beta, y, 1, 0 ); +* // y => [ -10.0, 11.0, -12.0, 14.0, -14.0, 17.0, -16.0, 20.0 ] */ declare var zgemv: Routine; diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/docs/types/test.ts b/lib/node_modules/@stdlib/blas/base/zgemv/docs/types/test.ts index b84178353be7..e29851831b7b 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/docs/types/test.ts +++ b/lib/node_modules/@stdlib/blas/base/zgemv/docs/types/test.ts @@ -28,8 +28,10 @@ import zgemv = require( './index' ); const x = new Complex128Array( 10 ); const y = new Complex128Array( 10 ); const A = new Complex128Array( 20 ); + const alpha = new Complex128( 1.0, 0.0 ); + const beta = new Complex128( 1.0, 0.0 ); - zgemv( 'row-major', 'no-transpose', 10, 10, new Complex128( 1.0, 0.0 ), A, 10, x, 1, new Complex128( 1.0, 0.0 ), y, 1 ); // $ExpectType Complex128Array + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectType Complex128Array } // The compiler throws an error if the function is provided a first argument which is not a string... @@ -37,8 +39,8 @@ import zgemv = require( './index' ); const x = new Complex128Array( 10 ); const y = new Complex128Array( 10 ); const A = new Complex128Array( 20 ); - const alpha = new Complex128( 1.0, 0.0 ); - const beta = new Complex128( 1.0, 0.0 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); zgemv( 10, 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError zgemv( true, 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError @@ -55,15 +57,15 @@ import zgemv = require( './index' ); const x = new Complex128Array( 10 ); const y = new Complex128Array( 10 ); const A = new Complex128Array( 20 ); - const alpha = new Complex128( 1.0, 0.0 ); - const beta = new Complex128( 1.0, 0.0 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); zgemv( 'row-major', 10, 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError zgemv( 'row-major', true, 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError zgemv( 'row-major', false, 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError zgemv( 'row-major', null, 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError zgemv( 'row-major', undefined, 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError - zgemv( 'row-major', [ '1' ], 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + zgemv( 'row-major', [], 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError zgemv( 'row-major', {}, 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError zgemv( 'row-major', ( x: number ): number => x, 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError } @@ -73,8 +75,8 @@ import zgemv = require( './index' ); const x = new Complex128Array( 10 ); const y = new Complex128Array( 10 ); const A = new Complex128Array( 20 ); - const alpha = new Complex128( 1.0, 0.0 ); - const beta = new Complex128( 1.0, 0.0 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); zgemv( 'row-major', 'no-transpose', '10', 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError zgemv( 'row-major', 'no-transpose', true, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError @@ -91,8 +93,8 @@ import zgemv = require( './index' ); const x = new Complex128Array( 10 ); const y = new Complex128Array( 10 ); const A = new Complex128Array( 20 ); - const alpha = new Complex128( 1.0, 0.0 ); - const beta = new Complex128( 1.0, 0.0 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); zgemv( 'row-major', 'no-transpose', 10, '10', alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError zgemv( 'row-major', 'no-transpose', 10, true, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError @@ -109,10 +111,9 @@ import zgemv = require( './index' ); const x = new Complex128Array( 10 ); const y = new Complex128Array( 10 ); const A = new Complex128Array( 20 ); - const beta = new Complex128( 1.0, 0.0 ); + const beta = new Complex128( 0.5, -0.5 ); zgemv( 'row-major', 'no-transpose', 10, 10, '10', A, 10, x, 1, beta, y, 1 ); // $ExpectError - zgemv( 'row-major', 'no-transpose', 10, 10, 10, A, 10, x, 1, beta, y, 1 ); // $ExpectError zgemv( 'row-major', 'no-transpose', 10, 10, true, A, 10, x, 1, beta, y, 1 ); // $ExpectError zgemv( 'row-major', 'no-transpose', 10, 10, false, A, 10, x, 1, beta, y, 1 ); // $ExpectError zgemv( 'row-major', 'no-transpose', 10, 10, null, A, 10, x, 1, beta, y, 1 ); // $ExpectError @@ -126,8 +127,8 @@ import zgemv = require( './index' ); { const x = new Complex128Array( 10 ); const y = new Complex128Array( 10 ); - const alpha = new Complex128( 1.0, 0.0 ); - const beta = new Complex128( 1.0, 0.0 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); zgemv( 'row-major', 'no-transpose', 10, 10, alpha, 10, 10, x, 1, beta, y, 1 ); // $ExpectError zgemv( 'row-major', 'no-transpose', 10, 10, alpha, '10', 10, x, 1, beta, y, 1 ); // $ExpectError @@ -145,8 +146,8 @@ import zgemv = require( './index' ); const x = new Complex128Array( 10 ); const y = new Complex128Array( 10 ); const A = new Complex128Array( 20 ); - const alpha = new Complex128( 1.0, 0.0 ); - const beta = new Complex128( 1.0, 0.0 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, '10', x, 1, beta, y, 1 ); // $ExpectError zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, true, x, 1, beta, y, 1 ); // $ExpectError @@ -162,8 +163,8 @@ import zgemv = require( './index' ); { const y = new Complex128Array( 10 ); const A = new Complex128Array( 20 ); - const alpha = new Complex128( 1.0, 0.0 ); - const beta = new Complex128( 1.0, 0.0 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, 10, 1, beta, y, 1 ); // $ExpectError zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, '10', 1, beta, y, 1 ); // $ExpectError @@ -181,8 +182,8 @@ import zgemv = require( './index' ); const x = new Complex128Array( 10 ); const y = new Complex128Array( 10 ); const A = new Complex128Array( 20 ); - const alpha = new Complex128( 1.0, 0.0 ); - const beta = new Complex128( 1.0, 0.0 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, '10', beta, y, 1 ); // $ExpectError zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, true, beta, y, 1 ); // $ExpectError @@ -199,10 +200,10 @@ import zgemv = require( './index' ); const x = new Complex128Array( 10 ); const y = new Complex128Array( 10 ); const A = new Complex128Array( 20 ); - const alpha = new Complex128( 1.0, 0.0 ); + const alpha = new Complex128( 0.5, 0.5 ); zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, '10', y, 1 ); // $ExpectError - zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, 10, y, 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, 1.0, y, 1 ); // $ExpectError zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, true, y, 1 ); // $ExpectError zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, false, y, 1 ); // $ExpectError zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, null, y, 1 ); // $ExpectError @@ -216,8 +217,8 @@ import zgemv = require( './index' ); { const x = new Complex128Array( 10 ); const A = new Complex128Array( 20 ); - const alpha = new Complex128( 1.0, 0.0 ); - const beta = new Complex128( 1.0, 0.0 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, 10, 1 ); // $ExpectError zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, '10', 1 ); // $ExpectError @@ -225,7 +226,7 @@ import zgemv = require( './index' ); zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, false, 1 ); // $ExpectError zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, null, 1 ); // $ExpectError zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, undefined, 1 ); // $ExpectError - zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, [ '1' ], 1 ); // $ExpectError + zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, [], 1 ); // $ExpectError zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, {}, 1 ); // $ExpectError zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, ( x: number ): number => x, 1 ); // $ExpectError } @@ -235,8 +236,8 @@ import zgemv = require( './index' ); const x = new Complex128Array( 10 ); const y = new Complex128Array( 10 ); const A = new Complex128Array( 20 ); - const alpha = new Complex128( 1.0, 0.0 ); - const beta = new Complex128( 1.0, 0.0 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, '10' ); // $ExpectError zgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, true ); // $ExpectError @@ -253,10 +254,10 @@ import zgemv = require( './index' ); const x = new Complex128Array( 10 ); const y = new Complex128Array( 10 ); const A = new Complex128Array( 20 ); - const alpha = new Complex128( 1.0, 0.0 ); - const beta = new Complex128( 1.0, 0.0 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); - zgemv( ); // $ExpectError + zgemv(); // $ExpectError zgemv( 'row-major' ); // $ExpectError zgemv( 'row-major', 'no-transpose' ); // $ExpectError zgemv( 'row-major', 'no-transpose', 10 ); // $ExpectError @@ -276,8 +277,8 @@ import zgemv = require( './index' ); const x = new Complex128Array( 10 ); const y = new Complex128Array( 10 ); const A = new Complex128Array( 20 ); - const alpha = new Complex128( 1.0, 0.0 ); - const beta = new Complex128( 1.0, 0.0 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectType Complex128Array } @@ -287,8 +288,8 @@ import zgemv = require( './index' ); const x = new Complex128Array( 10 ); const y = new Complex128Array( 10 ); const A = new Complex128Array( 20 ); - const alpha = new Complex128( 1.0, 0.0 ); - const beta = new Complex128( 1.0, 0.0 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); zgemv.ndarray( 10, 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError zgemv.ndarray( true, 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError @@ -299,3 +300,281 @@ import zgemv = require( './index' ); zgemv.ndarray( {}, 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError zgemv.ndarray( ( x: number ): number => x, 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError } + +// The compiler throws an error if the function is provided a second argument which is not a number... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); + + zgemv.ndarray( 'no-transpose', '10', 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', true, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', false, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', null, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', undefined, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', [], 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', {}, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', ( x: number ): number => x, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a third argument which is not a number... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); + + zgemv.ndarray( 'no-transpose', 10, '10', alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, true, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, false, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, null, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, undefined, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, [], alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, {}, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, ( x: number ): number => x, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fourth argument which is not a Complex128... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const beta = new Complex128( 0.5, -0.5 ); + + zgemv.ndarray( 'no-transpose', 10, 10, '10', A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, 10, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, true, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, false, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, null, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, undefined, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, [], A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, {}, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, ( x: number ): number => x, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fifth argument which is not a Complex128Array... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); + + zgemv.ndarray( 'no-transpose', 10, 10, alpha, 10, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, '10', 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, true, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, false, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, null, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, undefined, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, [], 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, {}, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, ( x: number ): number => x, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a sixth argument which is not a number... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); + + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, '10', 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, true, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, false, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, null, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, undefined, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, [], 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, {}, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, ( x: number ): number => x, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a seventh argument which is not a number... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); + + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, '10', 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, true, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, false, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, null, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, undefined, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, [], 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, {}, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, ( x: number ): number => x, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided an eighth argument which is not a number... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); + + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, '10', x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, true, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, false, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, null, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, undefined, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, [], x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, {}, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, ( x: number ): number => x, x, 1, 0, beta, y, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a ninth argument which is not a Complex128Array... +{ + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); + + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, 10, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, '10', 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, true, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, false, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, null, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, undefined, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, [], 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, {}, 1, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, ( x: number ): number => x, 1, 0, beta, y, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a tenth argument which is not a number... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); + + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, '10', 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, true, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, false, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, null, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, undefined, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, [], 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, {}, 0, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, ( x: number ): number => x, 0, beta, y, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided an eleventh argument which is not a number... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); + + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, '10', beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, true, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, false, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, null, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, undefined, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, [], beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, {}, beta, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, ( x: number ): number => x, beta, y, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a twelfth argument which is not a Complex128... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 0.5, 0.5 ); + + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, '10', y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, 10, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, true, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, false, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, null, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, undefined, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, [], y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, {}, y, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, ( x: number ): number => x, y, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a thirteenth argument which is not a Complex128Array... +{ + const x = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); + + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, 10, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, '10', 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, true, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, false, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, null, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, undefined, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, [], 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, {}, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, ( x: number ): number => x, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fourteenth argument which is not a number... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); + + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, '10', 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, true, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, false, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, null, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, undefined, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, [], 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, {}, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, ( x: number ): number => x, 0 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a fifteenth argument which is not a number... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); + + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, '10' ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, true ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, false ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, null ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, undefined ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, [] ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, {} ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided an unsupported number of arguments... +{ + const x = new Complex128Array( 10 ); + const y = new Complex128Array( 10 ); + const A = new Complex128Array( 20 ); + const alpha = new Complex128( 0.5, 0.5 ); + const beta = new Complex128( 0.5, -0.5 ); + + zgemv.ndarray(); // $ExpectError + zgemv.ndarray( 'no-transpose' ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1 ); // $ExpectError + zgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0, 10 ); // $ExpectError +} From 41cddc6fa373186c4eb7eb40fbf355ed0e01a8ae Mon Sep 17 00:00:00 2001 From: kaustubh Date: Mon, 11 May 2026 13:18:35 +0530 Subject: [PATCH 06/12] refactor examples in index.js --- .../@stdlib/blas/base/zgemv/examples/index.js | 60 ++++++------------- 1 file changed, 19 insertions(+), 41 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/examples/index.js b/lib/node_modules/@stdlib/blas/base/zgemv/examples/index.js index 237160ed6144..a7dc8e9429a5 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/examples/index.js +++ b/lib/node_modules/@stdlib/blas/base/zgemv/examples/index.js @@ -18,54 +18,32 @@ 'use strict'; -// MODULES // - -var Complex128Array = require( '@stdlib/array/complex128' ); +var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ); +var filledarrayBy = require( '@stdlib/array/filled-by' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var logEach = require( '@stdlib/console/log-each' ); var zgemv = require( './../lib' ); +function rand() { + return new Complex128( discreteUniform( 0, 10 ), discreteUniform( -5, 5 ) ); +} -// MAIN // - -var A = new Complex128Array([ - 1.0, - 2.0, // A[0,0] - 3.0, - 4.0, // A[0,1] - 5.0, - 6.0, // A[0,2] - 7.0, - 8.0, // A[1,0] - 9.0, - 10.0, // A[1,1] - 11.0, - 12.0 // A[1,2] -]); +var M = 3; +var N = 3; -var x = new Complex128Array([ - 1.0, - 1.0, // x[0] - 1.0, - 1.0, // x[1] - 1.0, - 1.0 // x[2] -]); +var x = filledarrayBy( N, 'complex128', rand ); +var y = filledarrayBy( M, 'complex128', rand ); +var A = filledarrayBy( M*N, 'complex128', rand ); -var y = new Complex128Array([ - 1.0, - 1.0, // y[0] - 1.0, - 1.0 // y[1] -]); +var alpha = new Complex128( 2.0, 3.0 ); +var beta = new Complex128( 3.0, -2.0 ); -var alpha = new Complex128( 1.0, 0.0 ); -var beta = new Complex128( 1.0, 0.0 ); +zgemv( 'row-major', 'no-transpose', M, N, alpha, A, M, x, 1, beta, y, 1 ); -console.log( 'Before zgemv:' ); -console.log( y.toString() ); +// Print the results: +logEach( '%s', y ); -// Perform y = α*A*x + β*y -zgemv( 'row-major', 'no-transpose', 2, 3, alpha, A, 3, x, 1, beta, y, 1 ); +zgemv.ndarray( 'no-transpose', M, N, alpha, A, 1, M, 0, x, 1, 0, beta, y, 1, 0 ); -console.log( '\nAfter zgemv:' ); -console.log( y.toString() ); +// Print the results: +logEach( '%s', y ); From 3dc5ed0c7717239d06989160010ba3a99cedc80c Mon Sep 17 00:00:00 2001 From: kaustubh Date: Mon, 11 May 2026 13:25:36 +0530 Subject: [PATCH 07/12] refactor base.js acc to latest cgemv --- .../@stdlib/blas/base/zgemv/lib/base.js | 210 ++++++++---------- 1 file changed, 93 insertions(+), 117 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/lib/base.js b/lib/node_modules/@stdlib/blas/base/zgemv/lib/base.js index b33cdd4325c4..ba82c8785d1a 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/lib/base.js +++ b/lib/node_modules/@stdlib/blas/base/zgemv/lib/base.js @@ -23,11 +23,10 @@ var isRowMajor = require( '@stdlib/ndarray/base/assert/is-row-major' ); var zfill = require( '@stdlib/blas/ext/base/zfill' ).ndarray; var zscal = require( '@stdlib/blas/base/zscal' ).ndarray; -var reinterpret = require( '@stdlib/strided/base/reinterpret-complex128' ); var real = require( '@stdlib/complex/float64/real' ); var imag = require( '@stdlib/complex/float64/imag' ); -var mul = require( '@stdlib/complex/float64/base/mul' ); -var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var reinterpret = require( '@stdlib/strided/base/reinterpret-complex128' ); +var muladd = require( '@stdlib/complex/float64/base/mul-add' ).assign; // FUNCTIONS // @@ -51,34 +50,15 @@ var Complex128 = require( '@stdlib/complex/float64/ctor' ); * var bool = isTransposed( 'no-transpose' ); * // returns false */ -function isTransposed( str ) { +function isTransposed( str ) { // TODO: consider moving to a separate helper utility package return ( str !== 'no-transpose' ); } -/** -* Tests whether to use conjugation when transposing. -* -* @private -* @param {string} str - input string -* @returns {boolean} boolean indicating whether to conjugate -* -* @example -* var bool = isConjugate( 'conjugate-transpose' ); -* // returns true -* -* @example -* var bool = isConjugate( 'transpose' ); -* // returns false -*/ -function isConjugate( str ) { - return ( str === 'conjugate-transpose' ); -} - // MAIN // /** -* Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. +* Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y`, where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. * * @private * @param {string} trans - specifies whether `A` should be transposed, conjugate-transposed, or not transposed @@ -102,37 +82,49 @@ function isConjugate( str ) { * var Complex128Array = require( '@stdlib/array/complex128' ); * var Complex128 = require( '@stdlib/complex/float64/ctor' ); * -* var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); -* var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); -* var y = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0 ] ); +* var A = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ] ); +* var x = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0 ] ); +* var y = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); +* var alpha = new Complex128( 0.5, 0.5 ); +* var beta = new Complex128( 0.5, -0.5 ); * -* zgemv( 'no-transpose', 2, 3, new Complex128( 1.0, 0.0 ), A, 3, 1, 0, x, 1, 0, new Complex128( 1.0, 0.0 ), y, 1, 0 ); +* zgemv( 'no-transpose', 4, 2, alpha, A, 1, 4, 0, x, 1, 0, beta, y, 1, 0 ); +* // y => [ -10.0, 11.0, -12.0, 14.0, -14.0, 17.0, -16.0, 20.0 ] */ function zgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, offsetX, beta, y, strideY, offsetY ) { // eslint-disable-line max-params, max-len + var realpha; + var imalpha; + var rebeta; + var imbeta; var viewA; var viewX; var viewY; + var retmp; + var imtmp; var isrm; var xlen; var ylen; - var tmp; - var are; - var aim; + var sign; + var sa1; + var sa2; var da0; var da1; - var vre; - var vim; - var tre; - var tim; - var sgn; - var sa; + var rea; + var ima; + var rex; + var imx; var ix; var iy; - var ia; - var i1; + var oa; + var ox; + var oy; + var sx; + var sy; var i0; + var i1; + var ia; - // Note on variable naming convention: da#, i# where # corresponds to the loop number, with `0` being the innermost loop... + // Note on variable naming convention: sa#, ix#, i# where # corresponds to the loop number, with `0` being the innermost loop... isrm = isRowMajor( [ strideA1, strideA2 ] ); if ( isTransposed( trans ) ) { @@ -142,30 +134,37 @@ function zgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, xlen = N; ylen = M; } + // Decompose scalars into real and imaginary components: + rebeta = real( beta ); + imbeta = imag( beta ); + realpha = real( alpha ); + imalpha = imag( alpha ); // y = beta*y - if ( real( beta ) === 0.0 && imag( beta ) === 0.0 ) { - zfill( ylen, new Complex128( 0.0, 0.0 ), y, strideY, offsetY ); - } else if ( real( beta ) !== 1.0 || imag( beta ) !== 0.0 ) { + if ( rebeta === 0.0 && imbeta === 0.0 ) { + zfill( ylen, beta, y, strideY, offsetY ); + } else if ( rebeta !== 1.0 || imbeta !== 0.0 ) { zscal( ylen, beta, y, strideY, offsetY ); } - if ( real( alpha ) === 0.0 && imag( alpha ) === 0.0 ) { + if ( realpha === 0.0 && imalpha === 0.0 ) { return y; } - - // Reinterpret complex arrays as real arrays: + // Reinterpret arrays as real-valued views of interleaved real and imaginary components: viewA = reinterpret( A, 0 ); viewX = reinterpret( x, 0 ); viewY = reinterpret( y, 0 ); - - // Adjust strides and offsets for real arrays (each complex number = 2 doubles): - sa = strideA1 * 2; - strideA2 *= 2; - strideX *= 2; - strideY *= 2; - offsetA *= 2; - offsetX *= 2; - offsetY *= 2; + if ( trans === 'conjugate-transpose' ) { + sign = -1; + } else { + sign = 1; + } + oa = offsetA * 2; + sa1 = strideA1 * 2; + sa2 = strideA2 * 2; + ox = offsetX * 2; + oy = offsetY * 2; + sx = strideX * 2; + sy = strideY * 2; // Form: y = α*A*x + y if ( @@ -174,90 +173,67 @@ function zgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, ) { if ( isrm ) { // For row-major matrices, the last dimension has the fastest changing index... - da0 = strideA2; // offset increment for innermost loop - da1 = sa - ( ylen * strideA2 ); // offset increment for outermost loop + da0 = sa2; // stride for innermost loop + da1 = sa1 - (ylen*sa2); // stride for outermost loop } else { // isColMajor // For column-major matrices, the first dimension has the fastest changing index... - da0 = sa; // offset increment for innermost loop - da1 = strideA2 - ( ylen * sa ); // offset increment for outermost loop + da0 = sa1; // stride for innermost loop + da1 = sa2 - (ylen*sa1); // stride for outermost loop } - sgn = ( isConjugate( trans ) ) ? -1.0 : 1.0; - ia = offsetA; - ix = offsetX; + ia = oa; + ix = ox; for ( i1 = 0; i1 < xlen; i1++ ) { - // tmp = alpha * x[ ix ] - tmp = mul( alpha, x.get( ix / 2 ) ); - tre = real( tmp ); - tim = imag( tmp ); - - if ( tre !== 0.0 || tim !== 0.0 ) { - iy = offsetY; + rex = viewX[ ix ]; + imx = viewX[ ix+1 ]; + retmp = (realpha*rex) - (imalpha*imx); + imtmp = (realpha*imx) + (imalpha*rex); + if ( retmp === 0.0 && imtmp === 0.0 ) { + ia += da0 * ylen; + } else { + iy = oy; for ( i0 = 0; i0 < ylen; i0++ ) { - // y[ iy ] += A[ ia ] * tmp - are = viewA[ ia ]; - aim = viewA[ ia + 1 ] * sgn; - vre = viewY[ iy ]; - vim = viewY[ iy + 1 ]; - - // Complex multiply: ( are + aim*i ) * ( tre + tim*i ) - viewY[ iy ] = vre + ( ( are * tre ) - ( aim * tim ) ); - viewY[ iy + 1 ] = vim + ( ( are * tim ) + ( aim * tre ) ); - - iy += strideY; + rea = viewA[ ia ]; + ima = sign * viewA[ ia+1 ]; + muladd( rea, ima, retmp, imtmp, viewY[ iy ], viewY[ iy+1 ], viewY, 1, iy ); // eslint-disable-line max-len + iy += sy; ia += da0; } - } else { - ia += da0 * ylen; } - ix += strideX; + ix += sx; ia += da1; } return y; } + // Form: y = α*A^T*x + y - // Form: y = α*A^T*x + y or y = α*A^H*x + y // ( !isrm && isTransposed( trans ) ) || ( isrm && !isTransposed( trans ) ) if ( isrm ) { // For row-major matrices, the last dimension has the fastest changing index... - da0 = strideA2; // offset increment for innermost loop - da1 = sa - ( xlen * strideA2 ); // offset increment for outermost loop - } else { // isColMajor + da0 = sa2; // stride for innermost loop + da1 = sa1 - (xlen*sa2); // stride for outermost loop + } else { // For column-major matrices, the first dimension has the fastest changing index... - da0 = sa; // offset increment for innermost loop - da1 = strideA2 - ( xlen * sa ); // offset increment for outermost loop + da0 = sa1; // stride for innermost loop + da1 = sa2 - (xlen*sa1); // stride for outermost loop } - sgn = ( isConjugate( trans ) ) ? -1.0 : 1.0; - ia = offsetA; - iy = offsetY; + ia = oa; + iy = oy; for ( i1 = 0; i1 < ylen; i1++ ) { - tre = 0.0; - tim = 0.0; - ix = offsetX; + retmp = 0.0; + imtmp = 0.0; + ix = ox; for ( i0 = 0; i0 < xlen; i0++ ) { - are = viewA[ ia ]; - aim = viewA[ ia + 1 ] * sgn; - - vre = viewX[ ix ]; - vim = viewX[ ix + 1 ]; - - // tmp += A[ ia ] * x[ ix ] (complex multiply and accumulate) - tre += ( ( are * vre ) - ( aim * vim ) ); - tim += ( ( are * vim ) + ( aim * vre ) ); - - ix += strideX; + rea = viewA[ ia ]; + ima = sign * viewA[ ia+1 ]; + rex = viewX[ ix ]; + imx = viewX[ ix+1 ]; + retmp = retmp + (rea*rex) - (ima*imx); + imtmp = imtmp + (rea*imx) + (ima*rex); + ix += sx; ia += da0; } - // y[ iy ] += alpha * tmp - vre = viewY[ iy ]; - vim = viewY[ iy + 1 ]; - - // alpha * ( tre + tim*i ) - are = real( alpha ); - aim = imag( alpha ); - viewY[ iy ] = vre + ( ( are * tre ) - ( aim * tim ) ); - viewY[ iy + 1 ] = vim + ( ( are * tim ) + ( aim * tre ) ); - - iy += strideY; + muladd( realpha, imalpha, retmp, imtmp, viewY[ iy ], viewY[ iy+1 ], viewY, 1, iy ); // eslint-disable-line max-len + iy += sy; ia += da1; } return y; From 4ec8d008b3503b9a34d8836c7c56a09367410496 Mon Sep 17 00:00:00 2001 From: kaustubh Date: Mon, 11 May 2026 13:36:46 +0530 Subject: [PATCH 08/12] refactor other core JS files --- .../@stdlib/blas/base/zgemv/lib/index.js | 24 ++++++++++++------- .../@stdlib/blas/base/zgemv/lib/ndarray.js | 18 +++++++------- .../@stdlib/blas/base/zgemv/lib/zgemv.js | 20 ++++++++-------- 3 files changed, 34 insertions(+), 28 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/lib/index.js b/lib/node_modules/@stdlib/blas/base/zgemv/lib/index.js index 9d4c5b35ec3b..0ba78ce72e53 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/lib/index.js +++ b/lib/node_modules/@stdlib/blas/base/zgemv/lib/index.js @@ -19,7 +19,7 @@ 'use strict'; /** -* BLAS level 2 routine to perform one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. +* BLAS level 2 routine to perform one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y`, where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. * * @module @stdlib/blas/base/zgemv * @@ -28,22 +28,28 @@ * var Complex128 = require( '@stdlib/complex/float64/ctor' ); * var zgemv = require( '@stdlib/blas/base/zgemv' ); * -* var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); -* var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); -* var y = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0 ] ); +* var A = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ] ); +* var x = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0 ] ); +* var y = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); +* var alpha = new Complex128( 0.5, 0.5 ); +* var beta = new Complex128( 0.5, -0.5 ); * -* zgemv( 'row-major', 'no-transpose', 2, 3, new Complex128( 1.0, 0.0 ), A, 3, x, 1, new Complex128( 1.0, 0.0 ), y, 1 ); +* zgemv( 'column-major', 'no-transpose', 4, 2, alpha, A, 4, x, 1, beta, y, 1 ); +* // y => [ -10.0, 11.0, -12.0, 14.0, -14.0, 17.0, -16.0, 20.0 ] * * @example * var Complex128Array = require( '@stdlib/array/complex128' ); * var Complex128 = require( '@stdlib/complex/float64/ctor' ); * var zgemv = require( '@stdlib/blas/base/zgemv' ); * -* var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); -* var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); -* var y = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0 ] ); +* var A = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ] ); +* var x = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0 ] ); +* var y = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); +* var alpha = new Complex128( 0.5, 0.5 ); +* var beta = new Complex128( 0.5, -0.5 ); * -* zgemv.ndarray( 'no-transpose', 2, 3, new Complex128( 1.0, 0.0 ), A, 3, 1, 0, x, 1, 0, new Complex128( 1.0, 0.0 ), y, 1, 0 ); +* zgemv.ndarray( 'no-transpose', 4, 2, alpha, A, 1, 4, 0, x, 1, 0, beta, y, 1, 0 ); +* // y => [ -10.0, 11.0, -12.0, 14.0, -14.0, 17.0, -16.0, 20.0 ] */ // MODULES // diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/lib/ndarray.js b/lib/node_modules/@stdlib/blas/base/zgemv/lib/ndarray.js index 445aa1deb2a7..01372d2e6cb6 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/lib/ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/zgemv/lib/ndarray.js @@ -21,8 +21,6 @@ // MODULES // var isMatrixTranspose = require( '@stdlib/blas/base/assert/is-transpose-operation' ); -var real = require( '@stdlib/complex/float64/real' ); -var imag = require( '@stdlib/complex/float64/imag' ); var format = require( '@stdlib/string/format' ); var base = require( './base.js' ); @@ -30,7 +28,7 @@ var base = require( './base.js' ); // MAIN // /** -* Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. +* Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y`, where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. * * @param {string} trans - specifies whether `A` should be transposed, conjugate-transposed, or not transposed * @param {NonNegativeInteger} M - number of rows in the matrix `A` @@ -58,12 +56,14 @@ var base = require( './base.js' ); * var Complex128Array = require( '@stdlib/array/complex128' ); * var Complex128 = require( '@stdlib/complex/float64/ctor' ); * -* var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); -* var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); -* var y = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0 ] ); +* var A = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ] ); +* var x = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0 ] ); +* var y = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); +* var alpha = new Complex128( 0.5, 0.5 ); +* var beta = new Complex128( 0.5, -0.5 ); * -* zgemv( 'no-transpose', 2, 3, new Complex128( 1.0, 0.0 ), A, 3, 1, 0, x, 1, 0, new Complex128( 1.0, 0.0 ), y, 1, 0 ); -* // y => +* zgemv( 'no-transpose', 4, 2, alpha, A, 1, 4, 0, x, 1, 0, beta, y, 1, 0 ); +* // y => [ -10.0, 11.0, -12.0, 14.0, -14.0, 17.0, -16.0, 20.0 ] */ function zgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, offsetX, beta, y, strideY, offsetY ) { // eslint-disable-line max-params, max-len if ( !isMatrixTranspose( trans ) ) { @@ -82,7 +82,7 @@ function zgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, throw new RangeError( format( 'invalid argument. Fourteenth argument must be non-zero. Value: `%d`.', strideY ) ); } // Check if we can early return... - if ( M === 0 || N === 0 || ( real( alpha ) === 0.0 && imag( alpha ) === 0.0 && real( beta ) === 1.0 && imag( beta ) === 0.0 ) ) { + if ( M === 0 || N === 0 ) { return y; } return base( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, offsetX, beta, y, strideY, offsetY ); // eslint-disable-line max-len diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/lib/zgemv.js b/lib/node_modules/@stdlib/blas/base/zgemv/lib/zgemv.js index 742ec854056a..eecd97900cc1 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/lib/zgemv.js +++ b/lib/node_modules/@stdlib/blas/base/zgemv/lib/zgemv.js @@ -25,8 +25,6 @@ var isMatrixTranspose = require( '@stdlib/blas/base/assert/is-transpose-operatio var isColumnMajor = require( '@stdlib/ndarray/base/assert/is-column-major-string' ); var stride2offset = require( '@stdlib/strided/base/stride2offset' ); var max = require( '@stdlib/math/base/special/fast/max' ); -var real = require( '@stdlib/complex/float64/real' ); -var imag = require( '@stdlib/complex/float64/imag' ); var format = require( '@stdlib/string/format' ); var base = require( './base.js' ); @@ -34,7 +32,7 @@ var base = require( './base.js' ); // MAIN // /** -* Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. +* Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y`, where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. * * @param {string} order - storage layout * @param {string} trans - specifies whether `A` should be transposed, conjugate-transposed, or not transposed @@ -42,7 +40,7 @@ var base = require( './base.js' ); * @param {NonNegativeInteger} N - number of columns in the matrix `A` * @param {Complex128} alpha - scalar constant * @param {Complex128Array} A - input matrix -* @param {PositiveInteger} LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) +* @param {PositiveInteger} LDA - stride of the first dimension of `A` * @param {Complex128Array} x - first input vector * @param {integer} strideX - `x` stride length * @param {Complex128} beta - scalar constant @@ -61,12 +59,14 @@ var base = require( './base.js' ); * var Complex128Array = require( '@stdlib/array/complex128' ); * var Complex128 = require( '@stdlib/complex/float64/ctor' ); * -* var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); -* var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); -* var y = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0 ] ); +* var A = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ] ); +* var x = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0 ] ); +* var y = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); +* var alpha = new Complex128( 0.5, 0.5 ); +* var beta = new Complex128( 0.5, -0.5 ); * -* zgemv( 'row-major', 'no-transpose', 2, 3, new Complex128( 1.0, 0.0 ), A, 3, x, 1, new Complex128( 1.0, 0.0 ), y, 1 ); -* // y => +* zgemv( 'column-major', 'no-transpose', 4, 2, alpha, A, 4, x, 1, beta, y, 1 ); +* // y => [ -10.0, 11.0, -12.0, 14.0, -14.0, 17.0, -16.0, 20.0 ] */ function zgemv( order, trans, M, N, alpha, A, LDA, x, strideX, beta, y, strideY ) { // eslint-disable-line max-params, max-len var iscm; @@ -106,7 +106,7 @@ function zgemv( order, trans, M, N, alpha, A, LDA, x, strideX, beta, y, strideY throw new RangeError( format( 'invalid argument. Twelfth argument must be non-zero. Value: `%d`.', strideY ) ); } // Check if we can early return... - if ( M === 0 || N === 0 || ( real( alpha ) === 0.0 && imag( alpha ) === 0.0 && real( beta ) === 1.0 && imag( beta ) === 0.0 ) ) { + if ( M === 0 || N === 0 ) { return y; } if ( trans === 'no-transpose' ) { From 374b2ca6a821e6c7f040016de10328016b2bb9be Mon Sep 17 00:00:00 2001 From: kaustubh Date: Mon, 11 May 2026 22:19:24 +0530 Subject: [PATCH 09/12] Refactor/Update Test structure --- .../@stdlib/blas/base/zgemv/test/test.js | 12 +- .../blas/base/zgemv/test/test.ndarray.js | 601 +++++++++++++----- .../blas/base/zgemv/test/test.zgemv.js | 453 +++++++++---- 3 files changed, 749 insertions(+), 317 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/test.js b/lib/node_modules/@stdlib/blas/base/zgemv/test/test.js index b9fefec94352..ae878c7d29c2 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/test.js +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/test.js @@ -39,12 +39,12 @@ tape( 'main export is a function', function test( t ) { t.ok( true, __filename ); t.strictEqual( typeof zgemv, 'function', 'main export is a function' ); t.end(); -} ); +}); tape( 'attached to the main export is a method providing an ndarray interface', function test( t ) { t.strictEqual( typeof zgemv.ndarray, 'function', 'method is a function' ); t.end(); -} ); +}); tape( 'if a native implementation is available, the main export is the native implementation', opts, function test( t ) { var zgemv = proxyquire( './../lib', { @@ -59,9 +59,9 @@ tape( 'if a native implementation is available, the main export is the native im } function mock() { - // Mock... + // Mock Native Implementation... } -} ); +}); tape( 'if a native implementation is not available, the main export is a JavaScript implementation', opts, function test( t ) { var zgemv; @@ -73,10 +73,10 @@ tape( 'if a native implementation is not available, the main export is a JavaScr '@stdlib/utils/try-require': tryRequire }); - t.strictEqual( zgemv, main, 'returns expected value' ); + t.strictEqual( zgemv, main, 'returns Javascript implementation' ); t.end(); function tryRequire() { return new Error( 'Cannot find module' ); } -} ); +}); diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/zgemv/test/test.ndarray.js index 8a7e7a17eed9..6c57c57fc6b6 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/test.ndarray.js @@ -23,7 +23,7 @@ // MODULES // var tape = require( 'tape' ); -var isAlmostSameValueComplex128Array = require( '@stdlib/assert/is-almost-same-value-complex128array' ); +var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' ); var Complex128Array = require( '@stdlib/array/complex128' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); var zgemv = require( './../lib/ndarray.js' ); @@ -71,12 +71,12 @@ tape( 'main export is a function', function test( t ) { t.ok( true, __filename ); t.strictEqual( typeof zgemv, 'function', 'main export is a function' ); t.end(); -} ); +}); tape( 'the function has an arity of 15', function test( t ) { t.strictEqual( zgemv.length, 15, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function throws an error if provided an invalid first argument', function test( t ) { var values; @@ -99,12 +99,10 @@ tape( 'the function throws an error if provided an invalid first argument', func function badValue( value ) { return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( value, data.M, data.N, alpha, new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), data.strideX, data.offsetX, beta, new Complex128Array( data.y ), data.strideY, data.offsetY ); + zgemv( value, data.M, data.N, new Complex128( data.alpha[0], data.alpha[1] ), new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), data.strideX, data.offsetX, new Complex128( data.beta[0], data.beta[1] ), new Complex128Array( data.y ), data.strideY, data.offsetY ); }; } -} ); +}); tape( 'the function throws an error if provided an invalid second argument', function test( t ) { var values; @@ -126,12 +124,10 @@ tape( 'the function throws an error if provided an invalid second argument', fun function badValue( value ) { return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( data.trans, value, data.N, alpha, new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), data.strideX, data.offsetX, beta, new Complex128Array( data.y ), data.strideY, data.offsetY ); + zgemv( data.trans, value, data.N, new Complex128( data.alpha[0], data.alpha[1] ), new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), data.strideX, data.offsetX, new Complex128( data.beta[0], data.beta[1] ), new Complex128Array( data.y ), data.strideY, data.offsetY ); }; } -} ); +}); tape( 'the function throws an error if provided an invalid third argument', function test( t ) { var values; @@ -153,12 +149,10 @@ tape( 'the function throws an error if provided an invalid third argument', func function badValue( value ) { return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( data.trans, data.M, value, alpha, new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), data.strideX, data.offsetX, beta, new Complex128Array( data.y ), data.strideY, data.offsetY ); + zgemv( data.trans, data.M, value, new Complex128( data.alpha[0], data.alpha[1] ), new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), data.strideX, data.offsetX, new Complex128( data.beta[0], data.beta[1] ), new Complex128Array( data.y ), data.strideY, data.offsetY ); }; } -} ); +}); tape( 'the function throws an error if provided an invalid tenth argument', function test( t ) { var values; @@ -178,12 +172,10 @@ tape( 'the function throws an error if provided an invalid tenth argument', func function badValue( value ) { return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( data.trans, data.M, data.N, alpha, new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), value, data.offsetX, beta, new Complex128Array( data.y ), data.strideY, data.offsetY ); + zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[0], data.alpha[1] ), new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), value, data.offsetX, new Complex128( data.beta[0], data.beta[1] ), new Complex128Array( data.y ), data.strideY, data.offsetY ); }; } -} ); +}); tape( 'the function throws an error if provided an invalid fourteenth argument', function test( t ) { var values; @@ -203,16 +195,16 @@ tape( 'the function throws an error if provided an invalid fourteenth argument', function badValue( value ) { return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( data.trans, data.M, data.N, alpha, new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), data.strideX, data.offsetX, beta, new Complex128Array( data.y ), value, data.offsetY ); + zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[0], data.alpha[1] ), new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), data.strideX, data.offsetX, new Complex128( data.beta[0], data.beta[1] ), new Complex128Array( data.y ), value, data.offsetY ); }; } -} ); +}); -tape( 'the function performs the matrix-vector operation `y = α*A*x + β*y` (row-major, no-transpose)', function test( t ) { +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y` (row-major, no-transpose)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -224,18 +216,23 @@ tape( 'the function performs the matrix-vector operation `y = α*A*x + β*y` (ro x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'the function performs the matrix-vector operation `y = α*A*x + β*y` (column-major, no-transpose)', function test( t ) { +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y` (column-major, no-transpose)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -247,19 +244,23 @@ tape( 'the function performs the matrix-vector operation `y = α*A*x + β*y` (co x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); - expected = new Complex128Array( data.y_out ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + expected = new Complex128Array( data.y_out ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'the function performs the matrix-vector operation `y = α*A^T*x + β*y` (row-major, transpose)', function test( t ) { +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y` (row-major, transpose)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -271,18 +272,23 @@ tape( 'the function performs the matrix-vector operation `y = α*A^T*x + β*y` ( x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'the function performs the matrix-vector operation `y = α*A^T*x + β*y` (column-major, transpose)', function test( t ) { +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y` (column-major, transpose)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -294,18 +300,23 @@ tape( 'the function performs the matrix-vector operation `y = α*A^T*x + β*y` ( x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'the function performs the matrix-vector operation `y = α*A^H*x + β*y` (row-major, conjugate-transpose)', function test( t ) { +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y` (row-major, conjugate-transpose)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -317,18 +328,23 @@ tape( 'the function performs the matrix-vector operation `y = α*A^H*x + β*y` ( x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'the function performs the matrix-vector operation `y = α*A^H*x + β*y` (column-major, conjugate-transpose)', function test( t ) { +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y` (column-major, conjugate-transpose)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -340,152 +356,191 @@ tape( 'the function performs the matrix-vector operation `y = α*A^H*x + β*y` ( x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'the function returns a reference to the output vector (row-major)', function test( t ) { +tape( 'the function returns a reference to the second input vector (row-major)', function test( t ) { + var alpha; var data; + var beta; var out; var a; var x; var y; - data = rnt; + data = rt; a = new Complex128Array( data.A ); x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( out, y, 'same reference' ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); t.end(); -} ); +}); -tape( 'the function returns a reference to the output vector (column-major)', function test( t ) { +tape( 'the function returns a reference to the second input vector (column-major)', function test( t ) { + var alpha; var data; + var beta; var out; var a; var x; var y; - data = cnt; + data = ct; a = new Complex128Array( data.A ); x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( out, y, 'same reference' ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); t.end(); -} ); +}); -tape( 'if either `M` or `N` is `0`, the function returns the output vector unchanged (row-major)', function test( t ) { +tape( 'if either `M` or `N` is `0`, the function returns the second input vector unchanged (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; var y; - data = rnt; + data = rt; a = new Complex128Array( data.A ); x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y ); - out = zgemv( data.trans, 0, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, 0, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); - out = zgemv( data.trans, data.M, 0, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, 0, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'if either `M` or `N` is `0`, the function returns the output vector unchanged (column-major)', function test( t ) { +tape( 'if either `M` or `N` is `0`, the function returns the second input vector unchanged (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; var y; - data = cnt; + data = ct; a = new Complex128Array( data.A ); x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y ); - out = zgemv( data.trans, 0, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, 0, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); - out = zgemv( data.trans, data.M, 0, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, 0, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'if `α` is `0+0i` and `β` is `1+0i`, the function returns the output vector unchanged (row-major)', function test( t ) { +tape( 'if `α` is `0` and `β` is `1`, the function returns the second input vector unchanged (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; var y; - data = rnt; + data = rt; a = new Complex128Array( data.A ); x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( 0.0, 0.0 ); + beta = new Complex128( 1.0, 0.0 ); + expected = new Complex128Array( data.y ); - out = zgemv( data.trans, data.M, data.N, new Complex128( 0.0, 0.0 ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( 1.0, 0.0 ), y, data.strideY, data.offsetY ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'if `α` is `0+0i` and `β` is `1+0i`, the function returns the output vector unchanged (column-major)', function test( t ) { +tape( 'if `α` is `0` and `β` is `1`, the function returns the second input vector unchanged (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; var y; - data = cnt; + data = ct; a = new Complex128Array( data.A ); x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( 0.0, 0.0 ); + beta = new Complex128( 1.0, 0.0 ); + expected = new Complex128Array( data.y ); - out = zgemv( data.trans, data.M, data.N, new Complex128( 0.0, 0.0 ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( 1.0, 0.0 ), y, data.strideY, data.offsetY ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'if `x` contains only zeros and `β` is `1+0i`, the function returns the output vector unchanged (row-major)', function test( t ) { +tape( 'if `x` contains only zeros and `β` is `1`, the function returns the second input vector unchanged (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -497,18 +552,23 @@ tape( 'if `x` contains only zeros and `β` is `1+0i`, the function returns the o x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'if `x` contains only zeros and `β` is `1+0i`, the function returns the output vector unchanged (column-major)', function test( t ) { +tape( 'if `x` contains only zeros and `β` is `1`, the function returns the second input vector unchanged (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -520,18 +580,23 @@ tape( 'if `x` contains only zeros and `β` is `1+0i`, the function returns the o x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'if `α` is `0+0i`, the function scales the output vector by `β` (row-major)', function test( t ) { +tape( 'if `α` is `0`, the function scales the second input vector by `β` (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -543,18 +608,23 @@ tape( 'if `α` is `0+0i`, the function scales the output vector by `β` (row-maj x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'if `α` is `0+0i`, the function scales the output vector by `β` (column-major)', function test( t ) { +tape( 'if `α` is `0`, the function scales the second input vector by `β` (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -566,18 +636,77 @@ tape( 'if `α` is `0+0i`, the function scales the output vector by `β` (column- x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if `α` is `0` and `β` is `0`, the function zeros the second input vector (row-major)', function test( t ) { + var expected; + var alpha; + var data; + var beta; + var out; + var a; + var x; + var y; + + data = ra; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + alpha = new Complex128( 0.0, 0.0 ); + beta = new Complex128( 0.0, 0.0 ); + + expected = new Complex128Array( y.length ); + + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'if `x` contains only zeros and `β` is not `1+0i`, the function scales the output vector by `β` (row-major)', function test( t ) { +tape( 'if `α` is `0` and `β` is `0`, the function zeros the second input vector (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; + var out; + var a; + var x; + var y; + + data = ca; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + alpha = new Complex128( 0.0, 0.0 ); + beta = new Complex128( 0.0, 0.0 ); + + expected = new Complex128Array( y.length ); + + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if `x` contains only zeros and `β` is not `1`, the function scales the second input vector by `β` (row-major)', function test( t ) { + var expected; + var alpha; + var data; + var beta; var out; var a; var x; @@ -589,18 +718,23 @@ tape( 'if `x` contains only zeros and `β` is not `1+0i`, the function scales th x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'if `x` contains only zeros and `β` is not `1`, the function scales the output vector by `β` (column-major)', function test( t ) { +tape( 'if `x` contains only zeros and `β` is not `1`, the function scales the second input vector by `β` (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -612,18 +746,23 @@ tape( 'if `x` contains only zeros and `β` is not `1`, the function scales the o x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports specifying the strides of the first and second dimensions of `A` (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -635,17 +774,23 @@ tape( 'the function supports specifying the strides of the first and second dime x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports specifying the strides of the first and second dimensions of `A` (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -657,17 +802,23 @@ tape( 'the function supports specifying the strides of the first and second dime x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports a negative stride for the first dimension of `A` (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -679,17 +830,23 @@ tape( 'the function supports a negative stride for the first dimension of `A` (r x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports a negative stride for the first dimension of `A` (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -701,17 +858,23 @@ tape( 'the function supports a negative stride for the first dimension of `A` (c x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'the function supports a negative stride for the second matrix dimension (row-major)', function test( t ) { +tape( 'the function supports a negative stride for the second dimension of `A` (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -723,17 +886,23 @@ tape( 'the function supports a negative stride for the second matrix dimension ( x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'the function supports a negative stride for the second matrix dimension (column-major)', function test( t ) { +tape( 'the function supports a negative stride for the second dimension of `A` (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -745,17 +914,23 @@ tape( 'the function supports a negative stride for the second matrix dimension ( x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'the function supports negative strides for both matrix dimensions (row-major)', function test( t ) { +tape( 'the function supports negative strides for `A` (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -767,17 +942,23 @@ tape( 'the function supports negative strides for both matrix dimensions (row-ma x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'the function supports negative strides for both matrix dimensions (column-major)', function test( t ) { +tape( 'the function supports negative strides for `A` (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -789,17 +970,23 @@ tape( 'the function supports negative strides for both matrix dimensions (column x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'the function supports specifying an offset for `A` (row-major)', function test( t ) { +tape( 'the function supports specifying an offset parameter for `A` (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -811,17 +998,23 @@ tape( 'the function supports specifying an offset for `A` (row-major)', function x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'the function supports specifying an offset for `A` (column-major)', function test( t ) { +tape( 'the function supports specifying an offset parameter for `A` (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -833,17 +1026,23 @@ tape( 'the function supports specifying an offset for `A` (column-major)', funct x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports specifying `x` and `y` strides (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -855,17 +1054,23 @@ tape( 'the function supports specifying `x` and `y` strides (row-major)', functi x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports specifying `x` and `y` strides (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -877,17 +1082,23 @@ tape( 'the function supports specifying `x` and `y` strides (column-major)', fun x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports specifying a negative `x` stride (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -899,17 +1110,23 @@ tape( 'the function supports specifying a negative `x` stride (row-major)', func x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports specifying a negative `x` stride (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -921,17 +1138,23 @@ tape( 'the function supports specifying a negative `x` stride (column-major)', f x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports specifying a negative `y` stride (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -943,17 +1166,23 @@ tape( 'the function supports specifying a negative `y` stride (row-major)', func x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports specifying a negative `y` stride (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -965,17 +1194,23 @@ tape( 'the function supports specifying a negative `y` stride (column-major)', f x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports specifying negative strides for `x` and `y` (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -987,17 +1222,23 @@ tape( 'the function supports specifying negative strides for `x` and `y` (row-ma x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports specifying negative strides for `x` and `y` (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -1009,17 +1250,23 @@ tape( 'the function supports specifying negative strides for `x` and `y` (column x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports complex access patterns (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -1031,17 +1278,23 @@ tape( 'the function supports complex access patterns (row-major)', function test x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports complex access patterns (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -1053,10 +1306,14 @@ tape( 'the function supports complex access patterns (column-major)', function t x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + out = zgemv( data.trans, data.M, data.N, alpha, a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, beta, y, data.strideY, data.offsetY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/test.zgemv.js b/lib/node_modules/@stdlib/blas/base/zgemv/test/test.zgemv.js index 67ffdfd8a258..651669dfb4c4 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/test.zgemv.js +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/test.zgemv.js @@ -16,12 +16,14 @@ * limitations under the License. */ +/* eslint-disable max-len */ + 'use strict'; // MODULES // var tape = require( 'tape' ); -var isAlmostSameValueComplex128Array = require( '@stdlib/assert/is-almost-same-value-complex128array' ); +var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' ); var Complex128Array = require( '@stdlib/array/complex128' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); var zgemv = require( './../lib/zgemv.js' ); @@ -57,12 +59,12 @@ tape( 'main export is a function', function test( t ) { t.ok( true, __filename ); t.strictEqual( typeof zgemv, 'function', 'main export is a function' ); t.end(); -} ); +}); tape( 'the function has an arity of 12', function test( t ) { t.strictEqual( zgemv.length, 12, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function throws an error if provided an invalid first argument', function test( t ) { var values; @@ -85,12 +87,10 @@ tape( 'the function throws an error if provided an invalid first argument', func function badValue( value ) { return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( value, data.trans, data.M, data.N, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, beta, new Complex128Array( data.y ), data.strideY ); + zgemv( value, data.trans, data.M, data.N, new Complex128( data.alpha[0], data.alpha[1] ), new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, new Complex128( data.beta[0], data.beta[1] ), new Complex128Array( data.y ), data.strideY ); }; } -} ); +}); tape( 'the function throws an error if provided an invalid second argument', function test( t ) { var values; @@ -113,12 +113,10 @@ tape( 'the function throws an error if provided an invalid second argument', fun function badValue( value ) { return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( data.order, value, data.M, data.N, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, beta, new Complex128Array( data.y ), data.strideY ); + zgemv( data.order, value, data.M, data.N, new Complex128( data.alpha[0], data.alpha[1] ), new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, new Complex128( data.beta[0], data.beta[1] ), new Complex128Array( data.y ), data.strideY ); }; } -} ); +}); tape( 'the function throws an error if provided an invalid third argument', function test( t ) { var values; @@ -140,12 +138,10 @@ tape( 'the function throws an error if provided an invalid third argument', func function badValue( value ) { return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( data.order, data.trans, value, data.N, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, beta, new Complex128Array( data.y ), data.strideY ); + zgemv( data.order, data.trans, value, data.N, new Complex128( data.alpha[0], data.alpha[1] ), new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, new Complex128( data.beta[0], data.beta[1] ), new Complex128Array( data.y ), data.strideY ); }; } -} ); +}); tape( 'the function throws an error if provided an invalid fourth argument', function test( t ) { var values; @@ -167,12 +163,36 @@ tape( 'the function throws an error if provided an invalid fourth argument', fun function badValue( value ) { return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( data.order, data.trans, data.M, value, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, beta, new Complex128Array( data.y ), data.strideY ); + zgemv( data.order, data.trans, data.M, value, new Complex128( data.alpha[0], data.alpha[1] ), new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, new Complex128( data.beta[0], data.beta[1] ), new Complex128Array( data.y ), data.strideY ); + }; + } +}); + +tape( 'the function throws an error if provided an invalid seventh argument', function test( t ) { + var values; + var data; + var i; + + data = rnt; + + values = [ + 0, + -1, + -2, + -3 + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[0], data.alpha[1] ), new Complex128Array( data.A ), value, new Complex128Array( data.x ), data.strideX, new Complex128( data.beta[0], data.beta[1] ), new Complex128Array( data.y ), data.strideY ); }; } -} ); +}); tape( 'the function throws an error if provided an invalid ninth argument', function test( t ) { var values; @@ -192,12 +212,10 @@ tape( 'the function throws an error if provided an invalid ninth argument', func function badValue( value ) { return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( data.order, data.trans, data.M, data.N, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), value, beta, new Complex128Array( data.y ), data.strideY ); + zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[0], data.alpha[1] ), new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), value, new Complex128( data.beta[0], data.beta[1] ), new Complex128Array( data.y ), data.strideY ); }; } -} ); +}); tape( 'the function throws an error if provided an invalid twelfth argument', function test( t ) { var values; @@ -217,16 +235,16 @@ tape( 'the function throws an error if provided an invalid twelfth argument', fu function badValue( value ) { return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( data.order, data.trans, data.M, data.N, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, beta, new Complex128Array( data.y ), value ); + zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[0], data.alpha[1] ), new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, new Complex128( data.beta[0], data.beta[1] ), new Complex128Array( data.y ), value ); }; } -} ); +}); -tape( 'the function performs the matrix-vector operation `y = α*A*x + β*y` (row-major, no-transpose)', function test( t ) { +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y` (row-major, no-transpose)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -238,18 +256,23 @@ tape( 'the function performs the matrix-vector operation `y = α*A*x + β*y` (ro x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'the function performs the matrix-vector operation `y = α*A*x + β*y` (column-major, no-transpose)', function test( t ) { +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y` (column-major, no-transpose)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -261,18 +284,23 @@ tape( 'the function performs the matrix-vector operation `y = α*A*x + β*y` (co x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'the function performs the matrix-vector operation `y = α*A^T*x + β*y` (row-major, transpose)', function test( t ) { +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y` (row-major, transpose)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -284,18 +312,23 @@ tape( 'the function performs the matrix-vector operation `y = α*A^T*x + β*y` ( x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'the function performs the matrix-vector operation `y = α*A^T*x + β*y` (column-major, transpose)', function test( t ) { +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y` (column-major, transpose)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -307,18 +340,23 @@ tape( 'the function performs the matrix-vector operation `y = α*A^T*x + β*y` ( x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'the function performs the matrix-vector operation `y = α*A^H*x + β*y` (row-major, conjugate-transpose)', function test( t ) { +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y` (row-major, conjugate-transpose)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -330,18 +368,23 @@ tape( 'the function performs the matrix-vector operation `y = α*A^H*x + β*y` ( x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'the function performs the matrix-vector operation `y = α*A^H*x + β*y` (column-major, conjugate-transpose)', function test( t ) { +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y` (column-major, conjugate-transpose)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -353,17 +396,46 @@ tape( 'the function performs the matrix-vector operation `y = α*A^H*x + β*y` ( x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns a reference to the second input vector (column-major)', function test( t ) { + var alpha; + var data; + var beta; + var out; + var a; + var x; + var y; + + data = ct; + + a = new Complex128Array( data.A ); + x = new Complex128Array( data.x ); + y = new Complex128Array( data.y ); + + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); t.end(); -} ); +}); -tape( 'the function returns a reference to the output vector (row-major)', function test( t ) { +tape( 'if either `M` or `N` is `0`, the function returns the second input vector unchanged (row-major)', function test( t ) { + var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -375,14 +447,27 @@ tape( 'the function returns a reference to the output vector (row-major)', funct x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + + expected = new Complex128Array( data.y ); + + out = zgemv( data.order, data.trans, 0, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); + + out = zgemv( data.order, data.trans, data.M, 0, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'the function returns a reference to the output vector (column-major)', function test( t ) { +tape( 'if either `M` or `N` is `0`, the function returns the second input vector unchanged (column-major)', function test( t ) { + var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -394,15 +479,27 @@ tape( 'the function returns a reference to the output vector (column-major)', fu x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + + expected = new Complex128Array( data.y ); + + out = zgemv( data.order, data.trans, 0, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); + + out = zgemv( data.order, data.trans, data.M, 0, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'if either `M` or `N` is `0`, the function returns the output vector unchanged (row-major)', function test( t ) { +tape( 'if `α` is `0` and `β` is `1`, the function returns the second input vector unchanged (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -414,22 +511,23 @@ tape( 'if either `M` or `N` is `0`, the function returns the output vector uncha x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); - expected = new Complex128Array( data.y ); + alpha = new Complex128( 0.0, 0.0 ); + beta = new Complex128( 1.0, 0.0 ); - out = zgemv( data.order, data.trans, 0, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + expected = new Complex128Array( data.y ); - out = zgemv( data.order, data.trans, data.M, 0, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'if either `M` or `N` is `0`, the function returns the output vector unchanged (column-major)', function test( t ) { +tape( 'if `α` is `0` and `β` is `1`, the function returns the second input vector unchanged (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -441,114 +539,135 @@ tape( 'if either `M` or `N` is `0`, the function returns the output vector uncha x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); - expected = new Complex128Array( data.y ); + alpha = new Complex128( 0.0, 0.0 ); + beta = new Complex128( 1.0, 0.0 ); - out = zgemv( data.order, data.trans, 0, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + expected = new Complex128Array( data.y ); - out = zgemv( data.order, data.trans, data.M, 0, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'if `α` is `0+0i` and `β` is `1+0i`, the function returns the output vector unchanged (row-major)', function test( t ) { +tape( 'if `x` contains only zeros and `β` is `1`, the function returns the second input vector unchanged (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; var y; - data = rt; + data = rxb; a = new Complex128Array( data.A ); x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); - expected = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( 0.0, 0.0 ), a, data.lda, x, data.strideX, new Complex128( 1.0, 0.0 ), y, data.strideY ); + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'if `α` is `0+0i` and `β` is `1+0i`, the function returns the output vector unchanged (column-major)', function test( t ) { +tape( 'if `x` contains only zeros and `β` is `1`, the function returns the second input vector unchanged (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; var y; - data = ct; + data = cxb; a = new Complex128Array( data.A ); x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); - expected = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( 0.0, 0.0 ), a, data.lda, x, data.strideX, new Complex128( 1.0, 0.0 ), y, data.strideY ); + expected = new Complex128Array( data.y_out ); + + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'if `x` contains only zeros and `β` is `1+0i`, the function returns the output vector unchanged (row-major)', function test( t ) { +tape( 'if `α` is `0`, the function scales the second input vector by `β` (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; var y; - data = rxb; + data = ra; a = new Complex128Array( data.A ); x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( 0.0, 0.0 ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'if `x` contains only zeros and `β` is `1+0i`, the function returns the output vector unchanged (column-major)', function test( t ) { +tape( 'if `α` is `0`, the function scales the second input vector by `β` (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; var y; - data = cxb; + data = ca; a = new Complex128Array( data.A ); x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( 0.0, 0.0 ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'if `α` is `0+0i`, the function scales the output vector by `β` (row-major)', function test( t ) { +tape( 'if `α` is `0` and `β` is `0`, the function zeros the second input vector (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -560,18 +679,22 @@ tape( 'if `α` is `0+0i`, the function scales the output vector by `β` (row-maj x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); - expected = new Complex128Array( data.y_out ); + alpha = new Complex128( 0.0, 0.0 ); + beta = new Complex128( 0.0, 0.0 ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + expected = new Complex128Array( y.length ); + + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'if `α` is `0+0i`, the function scales the output vector by `β` (column-major)', function test( t ) { +tape( 'if `α` is `0` and `β` is `0`, the function zeros the second input vector (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -583,18 +706,22 @@ tape( 'if `α` is `0+0i`, the function scales the output vector by `β` (column- x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); - expected = new Complex128Array( data.y_out ); + alpha = new Complex128( 0.0, 0.0 ); + beta = new Complex128( 0.0, 0.0 ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + expected = new Complex128Array( y.length ); + + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'if `x` contains only zeros and `β` is not `1+0i`, the function scales the output vector by `β` (row-major)', function test( t ) { +tape( 'if `x` contains only zeros and `β` is not `1`, the function scales the second input vector by `β` (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -606,18 +733,23 @@ tape( 'if `x` contains only zeros and `β` is not `1+0i`, the function scales th x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); -tape( 'if `x` contains only zeros and `β` is not `1+0i`, the function scales the output vector by `β` (column-major)', function test( t ) { +tape( 'if `x` contains only zeros and `β` is not `1`, the function scales the second input vector by `β` (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -629,18 +761,23 @@ tape( 'if `x` contains only zeros and `β` is not `1+0i`, the function scales th x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports specifying `x` and `y` strides (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -652,18 +789,23 @@ tape( 'the function supports specifying `x` and `y` strides (row-major)', functi x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports specifying `x` and `y` strides (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -675,18 +817,23 @@ tape( 'the function supports specifying `x` and `y` strides (column-major)', fun x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports specifying a negative `x` stride (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -698,18 +845,23 @@ tape( 'the function supports specifying a negative `x` stride (row-major)', func x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports specifying a negative `x` stride (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -721,18 +873,23 @@ tape( 'the function supports specifying a negative `x` stride (column-major)', f x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports specifying a negative `y` stride (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -744,18 +901,23 @@ tape( 'the function supports specifying a negative `y` stride (row-major)', func x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports specifying a negative `y` stride (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -767,18 +929,23 @@ tape( 'the function supports specifying a negative `y` stride (column-major)', f x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports complex access patterns (row-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -790,18 +957,23 @@ tape( 'the function supports complex access patterns (row-major)', function test x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); tape( 'the function supports complex access patterns (column-major)', function test( t ) { var expected; + var alpha; var data; + var beta; var out; var a; var x; @@ -813,11 +985,14 @@ tape( 'the function supports complex access patterns (column-major)', function t x = new Complex128Array( data.x ); y = new Complex128Array( data.y ); + alpha = new Complex128( data.alpha[0], data.alpha[1] ); + beta = new Complex128( data.beta[0], data.beta[1] ); + expected = new Complex128Array( data.y_out ); - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); + out = zgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); + t.strictEqual( isSameComplex128Array( out, expected ), true, 'returns expected value' ); t.end(); -} ); +}); From e816e5daeaef95ef1f15e2705f149dd9419286e4 Mon Sep 17 00:00:00 2001 From: kaustubh Date: Mon, 11 May 2026 22:39:21 +0530 Subject: [PATCH 10/12] Cleanup Readme and Package.json --- .../@stdlib/blas/base/zgemv/README.md | 134 ++++++++++++------ .../@stdlib/blas/base/zgemv/package.json | 2 +- 2 files changed, 91 insertions(+), 45 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/README.md b/lib/node_modules/@stdlib/blas/base/zgemv/README.md index f1b97ded75b2..d69cee70212d 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/README.md +++ b/lib/node_modules/@stdlib/blas/base/zgemv/README.md @@ -20,7 +20,7 @@ limitations under the License. # zgemv -> Perform one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`. +> Perform one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y`.
@@ -32,33 +32,25 @@ var zgemv = require( '@stdlib/blas/base/zgemv' ); #### zgemv( order, trans, M, N, α, A, LDA, x, sx, β, y, sy ) -Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, -where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. +Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y` where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. ```javascript var Complex128Array = require( '@stdlib/array/complex128' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); -var real = require( '@stdlib/complex/float64/real' ); -var imag = require( '@stdlib/complex/float64/imag' ); -var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); -var x = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); -var y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0 ] ); +var A = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ] ); +var x = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0 ] ); +var y = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); -zgemv( 'row-major', 'no-transpose', 2, 3, new Complex128( 1.0, 0.0 ), A, 3, x, 1, new Complex128( 1.0, 0.0 ), y, 1 ); +var alpha = new Complex128( 0.5, 0.5 ); +var beta = new Complex128( 0.5, -0.5 ); -var v = y.get( 0 ); -var re = real( v ); -// returns -2.0 - -var im = imag( v ); -// returns 22.0 +zgemv( 'column-major', 'no-transpose', 4, 2, alpha, A, 4, x, 1, beta, y, 1 ); +// y => [ -10.0, 11.0, -12.0, 14.0, -14.0, 17.0, -16.0, 20.0 ] ``` - - The function has the following parameters: - **order**: storage layout. @@ -66,14 +58,33 @@ The function has the following parameters: - **M**: number of rows in the matrix `A`. - **N**: number of columns in the matrix `A`. - **α**: scalar constant. -- **A**: input matrix stored in linear memory as a [`Complex128Array`][mdn-complex128array]. +- **A**: input matrix stored in linear memory as a [`Complex128Array`][@stdlib/array/complex128]. - **LDA**: stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`). -- **x**: input [`Complex128Array`][mdn-complex128array]. +- **x**: input [`Complex128Array`][@stdlib/array/complex128]. - **sx**: stride length for `x`. - **β**: scalar constant. -- **y**: output [`Complex128Array`][mdn-complex128array]. +- **y**: output [`Complex128Array`][@stdlib/array/complex128]. - **sy**: stride length for `y`. +The stride parameters determine how elements are accessed. For example, to iterate over every other element in `x` and `y`, + + + +```javascript +var Complex128Array = require( '@stdlib/array/complex128' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); + +var A = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ] ); +var x = new Complex128Array( [ 1.0, 1.0, 0.0, 0.0, 2.0, 2.0, 0.0, 0.0 ] ); +var y = new Complex128Array( [ 1.0, 1.0, 0.0, 0.0, 2.0, 2.0, 0.0, 0.0, 3.0, 3.0, 0.0, 0.0, 4.0, 4.0 ] ); + +var alpha = new Complex128( 0.5, 0.5 ); +var beta = new Complex128( 0.5, -0.5 ); + +zgemv( 'column-major', 'no-transpose', 4, 2, alpha, A, 4, x, 2, beta, y, 2 ); +// y => [ -10.0, 11.0, 0.0, 0.0, -12.0, 14.0, 0.0, 0.0, -14.0, 17.0, 0.0, 0.0, -16.0, 20.0 ] +``` + Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views. @@ -85,24 +96,26 @@ var Complex128Array = require( '@stdlib/array/complex128' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); // Initial arrays... -var x0 = new Complex128Array( [ 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); -var y0 = new Complex128Array( [ 0.0, 0.0, 1.0, 1.0, 1.0, 1.0 ] ); -var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); +var x0 = new Complex128Array( [ 0.0, 0.0, 1.0, 1.0, 2.0, 2.0 ] ); +var y0 = new Complex128Array( [ 0.0, 0.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); +var A = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ] ); + +var alpha = new Complex128( 0.5, 0.5 ); +var beta = new Complex128( 0.5, -0.5 ); // Create offset views... -var x1 = new Complex128Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element -var y1 = new Complex128Array( y0.buffer, y0.BYTES_PER_ELEMENT*1 ); // start at 2nd element +var x1 = new Complex128Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd complex element +var y1 = new Complex128Array( y0.buffer, y0.BYTES_PER_ELEMENT*1 ); // start at 2nd complex element -zgemv( 'row-major', 'no-transpose', 2, 3, new Complex128( 1.0, 0.0 ), A, 3, x1, -1, new Complex128( 1.0, 0.0 ), y1, -1 ); +zgemv( 'column-major', 'no-transpose', 4, 2, alpha, A, 4, x1, 1, beta, y1, 1 ); +// y1 => [ -10.0, 11.0, -12.0, 14.0, -14.0, 17.0, -16.0, 20.0 ] ``` - - #### zgemv.ndarray( trans, M, N, α, A, sa1, sa2, oa, x, sx, ox, β, y, sy, oy ) -Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, using alternative indexing semantics and where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. +Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y` using alternative indexing semantics and where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. @@ -110,14 +123,16 @@ Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x var Complex128Array = require( '@stdlib/array/complex128' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); -var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); -var x = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); -var y = new Complex128Array( [ 1.0, 1.0, 1.0, 1.0 ] ); +var A = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ] ); +var x = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0 ] ); +var y = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); -zgemv.ndarray( 'no-transpose', 2, 3, new Complex128( 1.0, 0.0 ), A, 3, 1, 0, x, 1, 0, new Complex128( 1.0, 0.0 ), y, 1, 0 ); -``` +var alpha = new Complex128( 0.5, 0.5 ); +var beta = new Complex128( 0.5, -0.5 ); - +zgemv.ndarray( 'no-transpose', 4, 2, alpha, A, 1, 4, 0, x, 1, 0, beta, y, 1, 0 ); +// y => [ -10.0, 11.0, -12.0, 14.0, -14.0, 17.0, -16.0, 20.0 ] +``` The function has the following additional parameters: @@ -127,6 +142,25 @@ The function has the following additional parameters: - **ox**: starting index for `x`. - **oy**: starting index for `y`. +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, + + + +```javascript +var Complex128Array = require( '@stdlib/array/complex128' ); +var Complex128 = require( '@stdlib/complex/float64/ctor' ); + +var A = new Complex128Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ] ); +var x = new Complex128Array( [ 0.0, 0.0, 1.0, 1.0, 2.0, 2.0 ] ); +var y = new Complex128Array( [ 4.0, 4.0, 0.0, 0.0, 3.0, 3.0, 0.0, 0.0, 2.0, 2.0, 0.0, 0.0, 1.0, 1.0 ] ); + +var alpha = new Complex128( 0.5, 0.5 ); +var beta = new Complex128( 0.5, -0.5 ); + +zgemv.ndarray( 'no-transpose', 4, 2, alpha, A, 1, 4, 0, x, 1, 1, beta, y, -2, 6 ); +// y => [ -16.0, 20.0, 0.0, 0.0, -14.0, 17.0, 0.0, 0.0, -12.0, 14.0, 0.0, 0.0, -10.0, 11.0 ] +``` +
@@ -135,7 +169,7 @@ The function has the following additional parameters: ## Notes -- `zgemv()` corresponds to the [BLAS][blas] level 2 function [`zgemv`][blas-zgemv]. +- `zgemv()` corresponds to the [BLAS][blas] level 2 function [`zgemv`][zgemv]. @@ -147,14 +181,17 @@ The function has the following additional parameters: + + ```javascript var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ); -var filledarrayBy = require( '@stdlib/array/filled-by' ); var Complex128 = require( '@stdlib/complex/float64/ctor' ); +var filledarrayBy = require( '@stdlib/array/filled-by' ); +var logEach = require( '@stdlib/console/log-each' ); var zgemv = require( '@stdlib/blas/base/zgemv' ); function rand() { - return new Complex128( discreteUniform( 0, 10 ), discreteUniform( -5, 5 ) ); + return new Complex128( discreteUniform( 0, 255 ), discreteUniform( -128, 127 ) ); } var M = 3; @@ -164,9 +201,18 @@ var A = filledarrayBy( M*N, 'complex128', rand ); var x = filledarrayBy( N, 'complex128', rand ); var y = filledarrayBy( M, 'complex128', rand ); -// eslint-disable-next-line max-len -zgemv( 'row-major', 'no-transpose', M, N, new Complex128( 1.0, 0.0 ), A, N, x, -1, new Complex128( 1.0, 0.0 ), y, -1 ); -console.log( y ); +var alpha = new Complex128( 0.5, 0.5 ); +var beta = new Complex128( 0.5, -0.5 ); + +zgemv( 'column-major', 'no-transpose', M, N, alpha, A, 4, x, 1, beta, y, 1 ); + +// Print the results: +logEach( '%s', x ); + +zgemv.ndarray( 'no-transpose', M, N, alpha, A, 1, 4, 0, x, 1, 0, beta, y, 1, 0 ); + +// Print the results: +logEach( '%s', x ); ``` @@ -389,12 +435,12 @@ int main( void ) { [blas]: http://www.netlib.org/blas -[blas-zgemv]: https://www.netlib.org/lapack/explore-html/d3/d6f/group__gemv_ga8e2652de3e24bfc49121c62f8edd5d68.html#ga8e2652de3e24bfc49121c62f8edd5d68 - -[mdn-complex128array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Complex128Array +[zgemv]: https://www.netlib.org/lapack/explore-html/d3/d6f/group__gemv_ga8e2652de3e24bfc49121c62f8edd5d68.html#ga8e2652de3e24bfc49121c62f8edd5d68 [mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray +[@stdlib/array/complex128]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/complex128 + diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/package.json b/lib/node_modules/@stdlib/blas/base/zgemv/package.json index 8a47e3e56444..1f9b9d85c7e5 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/package.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/package.json @@ -1,7 +1,7 @@ { "name": "@stdlib/blas/base/zgemv", "version": "0.0.0", - "description": "Perform one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`.", + "description": "Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y`.", "license": "Apache-2.0", "author": { "name": "The Stdlib Authors", From 5bff6fe633b653f5f679af5e6390d1a50a81e4d4 Mon Sep 17 00:00:00 2001 From: kaustubh Date: Tue, 12 May 2026 12:56:44 +0530 Subject: [PATCH 11/12] Update the Formatting for fixtures --- .../fixtures/column_major_alpha_zero.json | 72 ++++++----------- .../column_major_complex_access_pattern.json | 75 +++++------------- .../zgemv/test/fixtures/column_major_ct.json | 72 ++++++----------- .../zgemv/test/fixtures/column_major_nt.json | 72 ++++++----------- .../zgemv/test/fixtures/column_major_oa.json | 71 +++++------------ .../test/fixtures/column_major_sa1_sa2.json | 75 +++++------------- .../test/fixtures/column_major_sa1_sa2n.json | 75 +++++------------- .../test/fixtures/column_major_sa1n_sa2.json | 75 +++++------------- .../test/fixtures/column_major_sa1n_sa2n.json | 75 +++++------------- .../zgemv/test/fixtures/column_major_t.json | 72 ++++++----------- .../test/fixtures/column_major_x_zeros.json | 72 ++++++----------- .../column_major_x_zeros_beta_one.json | 72 ++++++----------- .../test/fixtures/column_major_xnyn.json | 78 ++++++------------- .../test/fixtures/column_major_xnyp.json | 78 ++++++------------- .../test/fixtures/column_major_xpyn.json | 78 ++++++------------- .../test/fixtures/column_major_xpyp.json | 78 ++++++------------- .../test/fixtures/row_major_alpha_zero.json | 72 ++++++----------- .../row_major_complex_access_pattern.json | 75 +++++------------- .../zgemv/test/fixtures/row_major_ct.json | 72 ++++++----------- .../zgemv/test/fixtures/row_major_nt.json | 72 ++++++----------- .../zgemv/test/fixtures/row_major_oa.json | 71 +++++------------ .../test/fixtures/row_major_sa1_sa2.json | 75 +++++------------- .../test/fixtures/row_major_sa1_sa2n.json | 75 +++++------------- .../test/fixtures/row_major_sa1n_sa2.json | 75 +++++------------- .../test/fixtures/row_major_sa1n_sa2n.json | 75 +++++------------- .../base/zgemv/test/fixtures/row_major_t.json | 72 ++++++----------- .../test/fixtures/row_major_x_zeros.json | 72 ++++++----------- .../fixtures/row_major_x_zeros_beta_one.json | 72 ++++++----------- .../zgemv/test/fixtures/row_major_xnyn.json | 78 ++++++------------- .../zgemv/test/fixtures/row_major_xnyp.json | 78 ++++++------------- .../zgemv/test/fixtures/row_major_xpyn.json | 78 ++++++------------- .../zgemv/test/fixtures/row_major_xpyp.json | 78 ++++++------------- 32 files changed, 732 insertions(+), 1648 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_alpha_zero.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_alpha_zero.json index b6ab90f41293..62aec9742f6d 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_alpha_zero.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_alpha_zero.json @@ -1,50 +1,26 @@ { - "order": "column-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 0.0, - 0.0 - ], - "beta": [ - 2.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 3.0, - 1.5, - 2.0, - 1.0, - 4.0, - 2.0 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": 1, - "strideA2": 2, - "offsetA": 0, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 2.0, - 0.6, - 4.0, - 1.2 - ] + "order": "column-major", + "trans": "no-transpose", + "M": 4, + "N": 2, + "alpha": [ 0.0, 0.0 ], + "beta": [ 0.5, -0.5 ], + "lda": 4, + "A": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ], + "A_mat": [ + [ 1.0, 1.0, 5.0, 5.0 ], + [ 2.0, 2.0, 6.0, 6.0 ], + [ 3.0, 3.0, 7.0, 7.0 ], + [ 4.0, 4.0, 8.0, 8.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0 ], + "y": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ], + "strideA1": 1, + "strideA2": 4, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_complex_access_pattern.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_complex_access_pattern.json index e63864a0a03a..6406f1728712 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_complex_access_pattern.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_complex_access_pattern.json @@ -1,56 +1,23 @@ { - "order": "column-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 0.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 3.0, - 1.5, - 2.0, - 1.0, - 4.0, - 2.0 - ], - "x": [ - 2.0, - -0.4, - 0.0, - 0.0, - 1.0, - -0.2 - ], - "y": [ - 2.0, - 0.6, - 0.0, - 0.0, - 1.0, - 0.3 - ], - "strideA1": 1, - "strideA2": 2, - "offsetA": 0, - "strideX": -2, - "offsetX": 2, - "strideY": -2, - "offsetY": 2, - "y_out": [ - 12.100000000000001, - 3.3, - 0.0, - 0.0, - 5.5, - 1.5 - ] + "trans": "no-transpose", + "strideA1": -2, + "strideA2": -5, + "offsetA": 14, + "strideX": -1, + "offsetX": 2, + "strideY": -1, + "offsetY": 2, + "M": 3, + "N": 3, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "A": [ 9.0, 9.0, 999.0, 999.0, 8.0, 8.0, 999.0, 999.0, 7.0, 7.0, 6.0, 6.0, 999.0, 999.0, 5.0, 5.0, 999.0, 999.0, 4.0, 4.0, 3.0, 3.0, 999.0, 999.0, 2.0, 2.0, 999.0, 999.0, 1.0, 1.0 ], + "A_mat": [ + [ 1.0, 1.0, 4.0, 4.0, 7.0, 7.0 ], + [ 2.0, 2.0, 5.0, 5.0, 8.0, 8.0 ], + [ 3.0, 3.0, 6.0, 6.0, 9.0, 9.0 ] + ], + "x": [ 3.0, 3.0, 2.0, 2.0, 1.0, 1.0 ], + "y": [ 3.0, 4.0, 2.0, 3.0, 1.0, 2.0 ], + "y_out": [ -38.5, 42.5, -33.5, 36.5, -28.5, 30.5 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_ct.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_ct.json index 60597fa59360..8e34d636b595 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_ct.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_ct.json @@ -1,50 +1,26 @@ { - "order": "column-major", - "trans": "conjugate-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 1.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 3.0, - 1.5, - 2.0, - 1.0, - 4.0, - 2.0 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": 1, - "strideA2": 2, - "offsetA": 0, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 7.300000000000001, - -4.6000000000000005, - 11.0, - -6.4 - ] + "order": "column-major", + "trans": "conjugate-transpose", + "M": 4, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "lda": 4, + "A": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ], + "A_mat": [ + [ 1.0, 1.0, 5.0, 5.0 ], + [ 2.0, 2.0, 6.0, 6.0 ], + [ 3.0, 3.0, 7.0, 7.0 ], + [ 4.0, 4.0, 8.0, 8.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0], + "y": [ 1.0, 1.0, 2.0, 2.0 ], + "strideA1": 1, + "strideA2": 4, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ 31, 30, 72, 70 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_nt.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_nt.json index 8feb90240c58..994e05f83b84 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_nt.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_nt.json @@ -1,50 +1,26 @@ { - "order": "column-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 1.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 3.0, - 1.5, - 2.0, - 1.0, - 4.0, - 2.0 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": 1, - "strideA2": 2, - "offsetA": 0, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 6.5, - 1.8, - 14.100000000000001, - 3.9 - ] + "order": "column-major", + "trans": "no-transpose", + "M": 4, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "lda": 4, + "A": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ], + "A_mat": [ + [ 1.0, 1.0, 5.0, 5.0 ], + [ 2.0, 2.0, 6.0, 6.0 ], + [ 3.0, 3.0, 7.0, 7.0 ], + [ 4.0, 4.0, 8.0, 8.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0 ], + "y": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ], + "strideA1": 1, + "strideA2": 4, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ -10.0, 11.0, -12.0, 14.0, -14.0, 17.0, -16.0, 20.0 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_oa.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_oa.json index 206664c55a26..3c778c62ed8c 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_oa.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_oa.json @@ -1,52 +1,23 @@ { - "order": "column-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 0.0, - 0.0 - ], - "lda": 2, - "A": [ - 0.0, - 0.0, - 1.0, - 0.5, - 3.0, - 1.5, - 2.0, - 1.0, - 4.0, - 2.0 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": 1, - "strideA2": 2, - "offsetA": 1, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 5.5, - 1.5, - 12.100000000000001, - 3.3 - ] + "trans": "no-transpose", + "M": 3, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "A": [ 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 1.0, 1.0, 999.0, 999.0, 2.0, 2.0, 999.0, 999.0, 3.0, 3.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 4.0, 4.0, 999.0, 999.0, 5.0, 5.0, 999.0, 999.0, 6.0, 6.0 ], + "A_mat": [ + [ 1.0, 1.0, 4.0, 4.0 ], + [ 2.0, 2.0, 5.0, 5.0 ], + [ 3.0, 3.0, 6.0, 6.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0 ], + "y": [ 1.0, 2.0, 2.0, 3.0, 3.0, 4.0 ], + "strideA1": 2, + "strideA2": 10, + "offsetA": 5, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ -7.5, 9.5, -9.5, 12.5, -11.5, 15.5 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1_sa2.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1_sa2.json index 1be051cdc97b..807af427ed00 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1_sa2.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1_sa2.json @@ -1,56 +1,23 @@ { - "order": "column-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 0.0, - 0.0 - ], - "lda": 4, - "A": [ - 1.0, - 0.5, - 0.0, - 0.0, - 3.0, - 1.5, - 0.0, - 0.0, - 2.0, - 1.0, - 0.0, - 0.0, - 4.0, - 2.0 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": 2, - "strideA2": 4, - "offsetA": 0, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 5.5, - 1.5, - 12.100000000000001, - 3.3 - ] + "trans": "no-transpose", + "M": 3, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "A": [ 1.0, 1.0, 999.0, 999.0, 2.0, 2.0, 999.0, 999.0, 3.0, 3.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 4.0, 4.0, 999.0, 999.0, 5.0, 5.0, 999.0, 999.0, 6.0, 6.0 ], + "A_mat": [ + [ 1.0, 1.0, 4.0, 4.0 ], + [ 2.0, 2.0, 5.0, 5.0 ], + [ 3.0, 3.0, 6.0, 6.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0 ], + "y": [ 1.0, 2.0, 2.0, 3.0, 3.0, 4.0 ], + "strideA1": 2, + "strideA2": 10, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ -7.5, 9.5, -9.5, 12.5, -11.5, 15.5 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1_sa2n.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1_sa2n.json index c9dbe756ff96..6e749b464198 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1_sa2n.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1_sa2n.json @@ -1,56 +1,23 @@ { - "order": "column-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 0.0, - 0.0 - ], - "lda": -4, - "A": [ - 2.0, - 1.0, - 0.0, - 0.0, - 4.0, - 2.0, - 0.0, - 0.0, - 1.0, - 0.5, - 0.0, - 0.0, - 3.0, - 1.5 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": 2, - "strideA2": -4, - "offsetA": 4, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 5.5, - 1.5, - 12.100000000000001, - 3.3 - ] + "trans": "no-transpose", + "M": 3, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "A": [ 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 4.0, 4.0, 999.0, 999.0, 5.0, 5.0, 999.0, 999.0, 6.0, 6.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 1.0, 1.0, 999.0, 999.0, 2.0, 2.0, 999.0, 999.0, 3.0, 3.0 ], + "A_mat": [ + [ 1.0, 1.0, 4.0, 4.0 ], + [ 2.0, 2.0, 5.0, 5.0 ], + [ 3.0, 3.0, 6.0, 6.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0 ], + "y": [ 1.0, 2.0, 2.0, 3.0, 3.0, 4.0 ], + "strideA1": 2, + "strideA2": -10, + "offsetA": 15, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ -7.5, 9.5, -9.5, 12.5, -11.5, 15.5 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1n_sa2.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1n_sa2.json index dca6d21793ad..2eadf7172502 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1n_sa2.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1n_sa2.json @@ -1,56 +1,23 @@ { - "order": "column-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 0.0, - 0.0 - ], - "lda": 4, - "A": [ - 3.0, - 1.5, - 0.0, - 0.0, - 1.0, - 0.5, - 0.0, - 0.0, - 4.0, - 2.0, - 0.0, - 0.0, - 2.0, - 1.0 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": -2, - "strideA2": 4, - "offsetA": 2, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 5.5, - 1.5, - 12.100000000000001, - 3.3 - ] + "trans": "no-transpose", + "M": 3, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "A": [ 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 3.0, 3.0, 999.0, 999.0, 2.0, 2.0, 999.0, 999.0, 1.0, 1.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 6.0, 6.0, 999.0, 999.0, 5.0, 5.0, 999.0, 999.0, 4.0, 4.0 ], + "A_mat": [ + [ 1.0, 1.0, 4.0, 4.0 ], + [ 2.0, 2.0, 5.0, 5.0 ], + [ 3.0, 3.0, 6.0, 6.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0 ], + "y": [ 1.0, 2.0, 2.0, 3.0, 3.0, 4.0 ], + "strideA1": -2, + "strideA2": 10, + "offsetA": 9, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ -7.5, 9.5, -9.5, 12.5, -11.5, 15.5 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1n_sa2n.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1n_sa2n.json index bf610f620123..ec811967e285 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1n_sa2n.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_sa1n_sa2n.json @@ -1,56 +1,23 @@ { - "order": "column-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 0.0, - 0.0 - ], - "lda": -4, - "A": [ - 4.0, - 2.0, - 0.0, - 0.0, - 2.0, - 1.0, - 0.0, - 0.0, - 3.0, - 1.5, - 0.0, - 0.0, - 1.0, - 0.5 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": -2, - "strideA2": -4, - "offsetA": 6, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 5.5, - 1.5, - 12.100000000000001, - 3.3 - ] + "trans": "no-transpose", + "M": 3, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "A": [ 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 6.0, 6.0, 999.0, 999.0, 5.0, 5.0, 999.0, 999.0, 4.0, 4.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 3.0, 3.0, 999.0, 999.0, 2.0, 2.0, 999.0, 999.0, 1.0, 1.0 ], + "A_mat": [ + [ 1.0, 1.0, 4.0, 4.0 ], + [ 2.0, 2.0, 5.0, 5.0 ], + [ 3.0, 3.0, 6.0, 6.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0 ], + "y": [ 1.0, 2.0, 2.0, 3.0, 3.0, 4.0 ], + "strideA1": -2, + "strideA2": -10, + "offsetA": 19, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ -7.5, 9.5, -9.5, 12.5, -11.5, 15.5 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_t.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_t.json index aec0ea1fdbc0..8c4b2b2fa2b8 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_t.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_t.json @@ -1,50 +1,26 @@ { - "order": "column-major", - "trans": "transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 1.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 3.0, - 1.5, - 2.0, - 1.0, - 4.0, - 2.0 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": 1, - "strideA2": 2, - "offsetA": 0, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 8.7, - 2.3999999999999995, - 13.0, - 3.6 - ] + "order": "column-major", + "trans": "transpose", + "M": 4, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "lda": 4, + "A": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ], + "A_mat": [ + [ 1.0, 1.0, 5.0, 5.0 ], + [ 2.0, 2.0, 6.0, 6.0 ], + [ 3.0, 3.0, 7.0, 7.0 ], + [ 4.0, 4.0, 8.0, 8.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0], + "y": [ 1.0, 1.0, 2.0, 2.0 ], + "strideA1": 1, + "strideA2": 4, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ -29.0, 30.0, -68.0, 70.0 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_x_zeros.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_x_zeros.json index 62b34d2be1fa..e96e0ec25727 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_x_zeros.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_x_zeros.json @@ -1,50 +1,26 @@ { - "order": "column-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 2.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 3.0, - 1.5, - 2.0, - 1.0, - 4.0, - 2.0 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": 1, - "strideA2": 2, - "offsetA": 0, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 7.5, - 2.1, - 16.1, - 4.5 - ] + "order": "column-major", + "trans": "no-transpose", + "M": 4, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "lda": 4, + "A": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ], + "A_mat": [ + [ 1.0, 1.0, 5.0, 5.0 ], + [ 2.0, 2.0, 6.0, 6.0 ], + [ 3.0, 3.0, 7.0, 7.0 ], + [ 4.0, 4.0, 8.0, 8.0 ] + ], + "x": [ 0.0, 0.0, 0.0, 0.0 ], + "y": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ], + "strideA1": 1, + "strideA2": 4, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_x_zeros_beta_one.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_x_zeros_beta_one.json index 8feb90240c58..831993bb51f1 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_x_zeros_beta_one.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_x_zeros_beta_one.json @@ -1,50 +1,26 @@ { - "order": "column-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 1.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 3.0, - 1.5, - 2.0, - 1.0, - 4.0, - 2.0 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": 1, - "strideA2": 2, - "offsetA": 0, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 6.5, - 1.8, - 14.100000000000001, - 3.9 - ] + "order": "column-major", + "trans": "no-transpose", + "M": 4, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 1.0, 0.0 ], + "lda": 4, + "A": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ], + "A_mat": [ + [ 1.0, 1.0, 5.0, 5.0 ], + [ 2.0, 2.0, 6.0, 6.0 ], + [ 3.0, 3.0, 7.0, 7.0 ], + [ 4.0, 4.0, 8.0, 8.0 ] + ], + "x": [ 0.0, 0.0, 0.0, 0.0 ], + "y": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ], + "strideA1": 1, + "strideA2": 4, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xnyn.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xnyn.json index e63864a0a03a..55d37dd07f8e 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xnyn.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xnyn.json @@ -1,56 +1,26 @@ { - "order": "column-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 0.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 3.0, - 1.5, - 2.0, - 1.0, - 4.0, - 2.0 - ], - "x": [ - 2.0, - -0.4, - 0.0, - 0.0, - 1.0, - -0.2 - ], - "y": [ - 2.0, - 0.6, - 0.0, - 0.0, - 1.0, - 0.3 - ], - "strideA1": 1, - "strideA2": 2, - "offsetA": 0, - "strideX": -2, - "offsetX": 2, - "strideY": -2, - "offsetY": 2, - "y_out": [ - 12.100000000000001, - 3.3, - 0.0, - 0.0, - 5.5, - 1.5 - ] + "order": "column-major", + "trans": "no-transpose", + "M": 4, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "lda": 4, + "A": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ], + "A_mat": [ + [ 1.0, 1.0, 5.0, 5.0 ], + [ 2.0, 2.0, 6.0, 6.0 ], + [ 3.0, 3.0, 7.0, 7.0 ], + [ 4.0, 4.0, 8.0, 8.0 ] + ], + "x": [ 2.0, 2.0, 1.0, 1.0 ], + "y": [ 4.0, 4.0, 3.0, 3.0, 2.0, 2.0, 1.0, 1.0 ], + "strideA1": 1, + "strideA2": 4, + "offsetA": 0, + "strideX": -1, + "offsetX": 1, + "strideY": -1, + "offsetY": 3, + "y_out": [ -16.0, 20.0, -14.0, 17.0, -12.0, 14.0, -10.0, 11.0 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xnyp.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xnyp.json index 3f4e4c1316c8..25d87bb2258a 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xnyp.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xnyp.json @@ -1,56 +1,26 @@ { - "order": "column-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 0.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 3.0, - 1.5, - 2.0, - 1.0, - 4.0, - 2.0 - ], - "x": [ - 2.0, - -0.4, - 0.0, - 0.0, - 1.0, - -0.2 - ], - "y": [ - 1.0, - 0.3, - 0.0, - 0.0, - 2.0, - 0.6 - ], - "strideA1": 1, - "strideA2": 2, - "offsetA": 0, - "strideX": -2, - "offsetX": 2, - "strideY": 2, - "offsetY": 0, - "y_out": [ - 5.5, - 1.5, - 0.0, - 0.0, - 12.100000000000001, - 3.3 - ] + "order": "column-major", + "trans": "no-transpose", + "M": 4, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "lda": 4, + "A": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ], + "A_mat": [ + [ 1.0, 1.0, 5.0, 5.0 ], + [ 2.0, 2.0, 6.0, 6.0 ], + [ 3.0, 3.0, 7.0, 7.0 ], + [ 4.0, 4.0, 8.0, 8.0 ] + ], + "x": [ 2.0, 2.0, 1.0, 1.0 ], + "y": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ], + "strideA1": 1, + "strideA2": 4, + "offsetA": 0, + "strideX": -1, + "offsetX": 1, + "strideY": 1, + "offsetY": 0, + "y_out": [ -10.0, 11.0, -12.0, 14.0, -14.0, 17.0, -16.0, 20.0 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xpyn.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xpyn.json index 0c1f96e8c1af..3b39aa86c196 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xpyn.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xpyn.json @@ -1,56 +1,26 @@ { - "order": "column-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 0.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 3.0, - 1.5, - 2.0, - 1.0, - 4.0, - 2.0 - ], - "x": [ - 1.0, - -0.2, - 0.0, - 0.0, - 2.0, - -0.4 - ], - "y": [ - 2.0, - 0.6, - 0.0, - 0.0, - 1.0, - 0.3 - ], - "strideA1": 1, - "strideA2": 2, - "offsetA": 0, - "strideX": 2, - "offsetX": 0, - "strideY": -2, - "offsetY": 2, - "y_out": [ - 12.100000000000001, - 3.3, - 0.0, - 0.0, - 5.5, - 1.5 - ] + "order": "column-major", + "trans": "no-transpose", + "M": 4, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "lda": 4, + "A": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ], + "A_mat": [ + [ 1.0, 1.0, 5.0, 5.0 ], + [ 2.0, 2.0, 6.0, 6.0 ], + [ 3.0, 3.0, 7.0, 7.0 ], + [ 4.0, 4.0, 8.0, 8.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0 ], + "y": [ 4.0, 4.0, 3.0, 3.0, 2.0, 2.0, 1.0, 1.0 ], + "strideA1": 1, + "strideA2": 4, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": -1, + "offsetY": 3, + "y_out": [ -16.0, 20.0, -14.0, 17.0, -12.0, 14.0, -10.0, 11.0 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xpyp.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xpyp.json index 8d70016dce07..994e05f83b84 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xpyp.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/column_major_xpyp.json @@ -1,56 +1,26 @@ { - "order": "column-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 0.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 3.0, - 1.5, - 2.0, - 1.0, - 4.0, - 2.0 - ], - "x": [ - 1.0, - -0.2, - 0.0, - 0.0, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 0.0, - 0.0, - 2.0, - 0.6 - ], - "strideA1": 1, - "strideA2": 2, - "offsetA": 0, - "strideX": 2, - "offsetX": 0, - "strideY": 2, - "offsetY": 0, - "y_out": [ - 5.5, - 1.5, - 0.0, - 0.0, - 12.100000000000001, - 3.3 - ] + "order": "column-major", + "trans": "no-transpose", + "M": 4, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "lda": 4, + "A": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0, 7.0, 8.0, 8.0 ], + "A_mat": [ + [ 1.0, 1.0, 5.0, 5.0 ], + [ 2.0, 2.0, 6.0, 6.0 ], + [ 3.0, 3.0, 7.0, 7.0 ], + [ 4.0, 4.0, 8.0, 8.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0 ], + "y": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ], + "strideA1": 1, + "strideA2": 4, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ -10.0, 11.0, -12.0, 14.0, -14.0, 17.0, -16.0, 20.0 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_alpha_zero.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_alpha_zero.json index 8ecc1664f588..80a3da689b9d 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_alpha_zero.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_alpha_zero.json @@ -1,50 +1,26 @@ { - "order": "row-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 0.0, - 0.0 - ], - "beta": [ - 2.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 2.0, - 1.0, - 3.0, - 1.5, - 4.0, - 2.0 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": 2, - "strideA2": 1, - "offsetA": 0, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 2.0, - 0.6, - 4.0, - 1.2 - ] + "order": "row-major", + "trans": "no-transpose", + "M": 4, + "N": 2, + "alpha": [ 0.0, 0.0 ], + "beta": [ 0.5, -0.5 ], + "lda": 2, + "A": [ 1.0, 1.0, 5.0, 5.0, 2.0, 2.0, 6.0, 6.0, 3.0, 3.0, 7.0, 7.0, 4.0, 4.0, 8.0, 8.0 ], + "A_mat": [ + [ 1.0, 1.0, 5.0, 5.0 ], + [ 2.0, 2.0, 6.0, 6.0 ], + [ 3.0, 3.0, 7.0, 7.0 ], + [ 4.0, 4.0, 8.0, 8.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0 ], + "y": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_complex_access_pattern.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_complex_access_pattern.json index 8226a0051f02..c1755fb65807 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_complex_access_pattern.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_complex_access_pattern.json @@ -1,56 +1,23 @@ { - "order": "row-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 0.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 2.0, - 1.0, - 3.0, - 1.5, - 4.0, - 2.0 - ], - "x": [ - 2.0, - -0.4, - 0.0, - 0.0, - 1.0, - -0.2 - ], - "y": [ - 2.0, - 0.6, - 0.0, - 0.0, - 1.0, - 0.3 - ], - "strideA1": 2, - "strideA2": 1, - "offsetA": 0, - "strideX": -2, - "offsetX": 2, - "strideY": -2, - "offsetY": 2, - "y_out": [ - 12.100000000000001, - 3.3, - 0.0, - 0.0, - 5.5, - 1.5 - ] + "trans": "no-transpose", + "strideA1": -6, + "strideA2": -1, + "offsetA": 14, + "strideX": -1, + "offsetX": 2, + "strideY": -1, + "offsetY": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "M": 3, + "N": 3, + "A": [ 9.0, 9.0, 6.0, 6.0, 3.0, 3.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 8.0, 8.0, 5.0, 5.0, 2.0, 2.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 7.0, 7.0, 4.0, 4.0, 1.0, 1.0 ], + "A_mat": [ + [ 1.0, 1.0, 4.0, 4.0, 7.0, 7.0 ], + [ 2.0, 2.0, 5.0, 5.0, 8.0, 8.0 ], + [ 3.0, 3.0, 6.0, 6.0, 9.0, 9.0 ] + ], + "x": [ 3.0, 3.0, 2.0, 2.0, 1.0, 1.0 ], + "y": [ 3.0, 4.0, 2.0, 3.0, 1.0, 2.0 ], + "y_out": [ -38.5, 42.5, -33.5, 36.5, -28.5, 30.5 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_ct.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_ct.json index 9a8cf8cca2af..1a533b9d5a74 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_ct.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_ct.json @@ -1,50 +1,26 @@ { - "order": "row-major", - "trans": "conjugate-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 1.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 2.0, - 1.0, - 3.0, - 1.5, - 4.0, - 2.0 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": 2, - "strideA2": 1, - "offsetA": 0, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 7.300000000000001, - -4.6000000000000005, - 11.0, - -6.4 - ] + "order": "row-major", + "trans": "conjugate-transpose", + "M": 4, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "lda": 2, + "A": [ 1.0, 1.0, 5.0, 5.0, 2.0, 2.0, 6.0, 6.0, 3.0, 3.0, 7.0, 7.0, 4.0, 4.0, 8.0, 8.0 ], + "A_mat": [ + [ 1.0, 1.0, 5.0, 5.0 ], + [ 2.0, 2.0, 6.0, 6.0 ], + [ 3.0, 3.0, 7.0, 7.0 ], + [ 4.0, 4.0, 8.0, 8.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ], + "y": [ 1.0, 1.0, 2.0, 2.0 ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ 31, 30, 72, 70 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_nt.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_nt.json index 7486ac067efd..acc5cb255fd5 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_nt.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_nt.json @@ -1,50 +1,26 @@ { - "order": "row-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 1.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 2.0, - 1.0, - 3.0, - 1.5, - 4.0, - 2.0 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": 2, - "strideA2": 1, - "offsetA": 0, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 6.5, - 1.8, - 14.100000000000001, - 3.9 - ] + "order": "row-major", + "trans": "no-transpose", + "M": 4, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "lda": 2, + "A": [ 1.0, 1.0, 5.0, 5.0, 2.0, 2.0, 6.0, 6.0, 3.0, 3.0, 7.0, 7.0, 4.0, 4.0, 8.0, 8.0 ], + "A_mat": [ + [ 1.0, 1.0, 5.0, 5.0 ], + [ 2.0, 2.0, 6.0, 6.0 ], + [ 3.0, 3.0, 7.0, 7.0 ], + [ 4.0, 4.0, 8.0, 8.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0 ], + "y": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ -10.0, 11.0, -12.0, 14.0, -14.0, 17.0, -16.0, 20.0 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_oa.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_oa.json index cf300b01f685..cd0e233f10d2 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_oa.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_oa.json @@ -1,52 +1,23 @@ { - "order": "row-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 0.0, - 0.0 - ], - "lda": 2, - "A": [ - 0.0, - 0.0, - 1.0, - 0.5, - 2.0, - 1.0, - 3.0, - 1.5, - 4.0, - 2.0 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": 2, - "strideA2": 1, - "offsetA": 1, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 5.5, - 1.5, - 12.100000000000001, - 3.3 - ] + "trans": "no-transpose", + "M": 3, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "A": [ 999.0, 999.0, 1.0, 1.0, 999.0, 999.0, 4.0, 4.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 2.0, 2.0, 999.0, 999.0, 5.0, 5.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 3.0, 3.0, 999.0, 999.0, 6.0, 6.0 ], + "A_mat": [ + [ 1.0, 1.0, 4.0, 4.0 ], + [ 2.0, 2.0, 5.0, 5.0 ], + [ 3.0, 3.0, 6.0, 6.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0 ], + "y": [ 1.0, 2.0, 2.0, 3.0, 3.0, 4.0 ], + "strideA1": 10, + "strideA2": 2, + "offsetA": 1, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ -7.5, 9.5, -9.5, 12.5, -11.5, 15.5 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1_sa2.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1_sa2.json index 5707a554df86..a61467b5d4b6 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1_sa2.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1_sa2.json @@ -1,56 +1,23 @@ { - "order": "row-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 0.0, - 0.0 - ], - "lda": 4, - "A": [ - 1.0, - 0.5, - 0.0, - 0.0, - 2.0, - 1.0, - 0.0, - 0.0, - 3.0, - 1.5, - 0.0, - 0.0, - 4.0, - 2.0 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": 4, - "strideA2": 2, - "offsetA": 0, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 5.5, - 1.5, - 12.100000000000001, - 3.3 - ] + "trans": "no-transpose", + "M": 3, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "A": [ 1.0, 1.0, 999.0, 999.0, 4.0, 4.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 2.0, 2.0, 999.0, 999.0, 5.0, 5.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 3.0, 3.0, 999.0, 999.0, 6.0, 6.0 ], + "A_mat": [ + [ 1.0, 1.0, 4.0, 4.0 ], + [ 2.0, 2.0, 5.0, 5.0 ], + [ 3.0, 3.0, 6.0, 6.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0 ], + "y": [ 1.0, 2.0, 2.0, 3.0, 3.0, 4.0 ], + "strideA1": 8, + "strideA2": 2, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ -7.5, 9.5, -9.5, 12.5, -11.5, 15.5 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1_sa2n.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1_sa2n.json index 16dccfb59f53..ad7954a998b0 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1_sa2n.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1_sa2n.json @@ -1,56 +1,23 @@ { - "order": "row-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 0.0, - 0.0 - ], - "lda": 4, - "A": [ - 2.0, - 1.0, - 0.0, - 0.0, - 1.0, - 0.5, - 0.0, - 0.0, - 4.0, - 2.0, - 0.0, - 0.0, - 3.0, - 1.5 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": 4, - "strideA2": -2, - "offsetA": 2, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 5.5, - 1.5, - 12.100000000000001, - 3.3 - ] + "trans": "no-transpose", + "M": 3, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "A": [ 999.0, 999.0, 4.0, 4.0, 999.0, 999.0, 1.0, 1.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 5.0, 5.0, 999.0, 999.0, 2.0, 2.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 6.0, 6.0, 999.0, 999.0, 3.0, 3.0 ], + "A_mat": [ + [ 1.0, 1.0, 4.0, 4.0 ], + [ 2.0, 2.0, 5.0, 5.0 ], + [ 3.0, 3.0, 6.0, 6.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0 ], + "y": [ 1.0, 2.0, 2.0, 3.0, 3.0, 4.0 ], + "strideA1": 10, + "strideA2": -2, + "offsetA": 3, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ -7.5, 9.5, -9.5, 12.5, -11.5, 15.5 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1n_sa2.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1n_sa2.json index a461f586ee30..706215a47ae9 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1n_sa2.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1n_sa2.json @@ -1,56 +1,23 @@ { - "order": "row-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 0.0, - 0.0 - ], - "lda": -4, - "A": [ - 3.0, - 1.5, - 0.0, - 0.0, - 4.0, - 2.0, - 0.0, - 0.0, - 1.0, - 0.5, - 0.0, - 0.0, - 2.0, - 1.0 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": -4, - "strideA2": 2, - "offsetA": 4, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 5.5, - 1.5, - 12.100000000000001, - 3.3 - ] + "trans": "no-transpose", + "M": 3, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "A": [ 999.0, 999.0, 3.0, 3.0, 999.0, 999.0, 6.0, 6.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 2.0, 2.0, 999.0, 999.0, 5.0, 5.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 1.0, 1.0, 999.0, 999.0, 4.0, 4.0 ], + "A_mat": [ + [ 1.0, 1.0, 4.0, 4.0 ], + [ 2.0, 2.0, 5.0, 5.0 ], + [ 3.0, 3.0, 6.0, 6.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0 ], + "y": [ 1.0, 2.0, 2.0, 3.0, 3.0, 4.0 ], + "strideA1": -10, + "strideA2": 2, + "offsetA": 21, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ -7.5, 9.5, -9.5, 12.5, -11.5, 15.5 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1n_sa2n.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1n_sa2n.json index 27d3007ee66f..435660e4a45e 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1n_sa2n.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_sa1n_sa2n.json @@ -1,56 +1,23 @@ { - "order": "row-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 0.0, - 0.0 - ], - "lda": -4, - "A": [ - 4.0, - 2.0, - 0.0, - 0.0, - 3.0, - 1.5, - 0.0, - 0.0, - 2.0, - 1.0, - 0.0, - 0.0, - 1.0, - 0.5 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": -4, - "strideA2": -2, - "offsetA": 6, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 5.5, - 1.5, - 12.100000000000001, - 3.3 - ] + "trans": "no-transpose", + "M": 3, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "A": [ 999.0, 999.0, 6.0, 6.0, 999.0, 999.0, 3.0, 3.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 5.0, 5.0, 999.0, 999.0, 2.0, 2.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 999.0, 4.0, 4.0, 999.0, 999.0, 1.0, 1.0 ], + "A_mat": [ + [ 1.0, 1.0, 4.0, 4.0 ], + [ 2.0, 2.0, 5.0, 5.0 ], + [ 3.0, 3.0, 6.0, 6.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0 ], + "y": [ 1.0, 2.0, 2.0, 3.0, 3.0, 4.0 ], + "strideA1": -10, + "strideA2": -2, + "offsetA": 23, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ -7.5, 9.5, -9.5, 12.5, -11.5, 15.5 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_t.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_t.json index 21d5a97e8ebe..f6a46ba3560c 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_t.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_t.json @@ -1,50 +1,26 @@ { - "order": "row-major", - "trans": "transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 1.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 2.0, - 1.0, - 3.0, - 1.5, - 4.0, - 2.0 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": 2, - "strideA2": 1, - "offsetA": 0, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 8.7, - 2.3999999999999995, - 13.0, - 3.6 - ] + "order": "row-major", + "trans": "transpose", + "M": 4, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "lda": 2, + "A": [ 1.0, 1.0, 5.0, 5.0, 2.0, 2.0, 6.0, 6.0, 3.0, 3.0, 7.0, 7.0, 4.0, 4.0, 8.0, 8.0 ], + "A_mat": [ + [ 1.0, 1.0, 5.0, 5.0 ], + [ 2.0, 2.0, 6.0, 6.0 ], + [ 3.0, 3.0, 7.0, 7.0 ], + [ 4.0, 4.0, 8.0, 8.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ], + "y": [ 1.0, 1.0, 2.0, 2.0 ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ -29.0, 30.0, -68.0, 70.0 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_x_zeros.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_x_zeros.json index 86e2ab6f3239..9659ac5fcb3d 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_x_zeros.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_x_zeros.json @@ -1,50 +1,26 @@ { - "order": "row-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 2.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 2.0, - 1.0, - 3.0, - 1.5, - 4.0, - 2.0 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": 2, - "strideA2": 1, - "offsetA": 0, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 7.5, - 2.1, - 16.1, - 4.5 - ] + "order": "row-major", + "trans": "no-transpose", + "M": 4, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "lda": 2, + "A": [ 1.0, 1.0, 5.0, 5.0, 2.0, 2.0, 6.0, 6.0, 3.0, 3.0, 7.0, 7.0, 4.0, 4.0, 8.0, 8.0 ], + "A_mat": [ + [ 1.0, 1.0, 5.0, 5.0 ], + [ 2.0, 2.0, 6.0, 6.0 ], + [ 3.0, 3.0, 7.0, 7.0 ], + [ 4.0, 4.0, 8.0, 8.0 ] + ], + "x": [ 0.0, 0.0, 0.0, 0.0 ], + "y": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ 1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_x_zeros_beta_one.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_x_zeros_beta_one.json index 7486ac067efd..1ba1c7827ba8 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_x_zeros_beta_one.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_x_zeros_beta_one.json @@ -1,50 +1,26 @@ { - "order": "row-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 1.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 2.0, - 1.0, - 3.0, - 1.5, - 4.0, - 2.0 - ], - "x": [ - 1.0, - -0.2, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 2.0, - 0.6 - ], - "strideA1": 2, - "strideA2": 1, - "offsetA": 0, - "strideX": 1, - "offsetX": 0, - "strideY": 1, - "offsetY": 0, - "y_out": [ - 6.5, - 1.8, - 14.100000000000001, - 3.9 - ] + "order": "row-major", + "trans": "no-transpose", + "M": 4, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 1.0, 0.0 ], + "lda": 2, + "A": [ 1.0, 1.0, 5.0, 5.0, 2.0, 2.0, 6.0, 6.0, 3.0, 3.0, 7.0, 7.0, 4.0, 4.0, 8.0, 8.0 ], + "A_mat": [ + [ 1.0, 1.0, 5.0, 5.0 ], + [ 2.0, 2.0, 6.0, 6.0 ], + [ 3.0, 3.0, 7.0, 7.0 ], + [ 4.0, 4.0, 8.0, 8.0 ] + ], + "x": [ 0.0, 0.0, 0.0, 0.0 ], + "y": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xnyn.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xnyn.json index 8226a0051f02..70ab1be836b1 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xnyn.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xnyn.json @@ -1,56 +1,26 @@ { - "order": "row-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 0.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 2.0, - 1.0, - 3.0, - 1.5, - 4.0, - 2.0 - ], - "x": [ - 2.0, - -0.4, - 0.0, - 0.0, - 1.0, - -0.2 - ], - "y": [ - 2.0, - 0.6, - 0.0, - 0.0, - 1.0, - 0.3 - ], - "strideA1": 2, - "strideA2": 1, - "offsetA": 0, - "strideX": -2, - "offsetX": 2, - "strideY": -2, - "offsetY": 2, - "y_out": [ - 12.100000000000001, - 3.3, - 0.0, - 0.0, - 5.5, - 1.5 - ] + "order": "row-major", + "trans": "no-transpose", + "M": 4, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "lda": 2, + "A": [ 1.0, 1.0, 5.0, 5.0, 2.0, 2.0, 6.0, 6.0, 3.0, 3.0, 7.0, 7.0, 4.0, 4.0, 8.0, 8.0 ], + "A_mat": [ + [ 1.0, 1.0, 5.0, 5.0 ], + [ 2.0, 2.0, 6.0, 6.0 ], + [ 3.0, 3.0, 7.0, 7.0 ], + [ 4.0, 4.0, 8.0, 8.0 ] + ], + "x": [ 2.0, 2.0, 1.0, 1.0 ], + "y": [ 4.0, 4.0, 3.0, 3.0, 2.0, 2.0, 1.0, 1.0 ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "strideX": -1, + "offsetX": 1, + "strideY": -1, + "offsetY": 3, + "y_out": [ -16.0, 20.0, -14.0, 17.0, -12.0, 14.0, -10.0, 11.0 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xnyp.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xnyp.json index 300fe26908e9..31c5851bf84b 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xnyp.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xnyp.json @@ -1,56 +1,26 @@ { - "order": "row-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 0.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 2.0, - 1.0, - 3.0, - 1.5, - 4.0, - 2.0 - ], - "x": [ - 2.0, - -0.4, - 0.0, - 0.0, - 1.0, - -0.2 - ], - "y": [ - 1.0, - 0.3, - 0.0, - 0.0, - 2.0, - 0.6 - ], - "strideA1": 2, - "strideA2": 1, - "offsetA": 0, - "strideX": -2, - "offsetX": 2, - "strideY": 2, - "offsetY": 0, - "y_out": [ - 5.5, - 1.5, - 0.0, - 0.0, - 12.100000000000001, - 3.3 - ] + "order": "row-major", + "trans": "no-transpose", + "M": 4, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "lda": 2, + "A": [ 1.0, 1.0, 5.0, 5.0, 2.0, 2.0, 6.0, 6.0, 3.0, 3.0, 7.0, 7.0, 4.0, 4.0, 8.0, 8.0 ], + "A_mat": [ + [ 1.0, 1.0, 5.0, 5.0 ], + [ 2.0, 2.0, 6.0, 6.0 ], + [ 3.0, 3.0, 7.0, 7.0 ], + [ 4.0, 4.0, 8.0, 8.0 ] + ], + "x": [ 2.0, 2.0, 1.0, 1.0 ], + "y": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "strideX": -1, + "offsetX": 1, + "strideY": 1, + "offsetY": 0, + "y_out": [ -10.0, 11.0, -12.0, 14.0, -14.0, 17.0, -16.0, 20.0 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xpyn.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xpyn.json index 9c52a145d2d3..e1869ba5cac8 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xpyn.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xpyn.json @@ -1,56 +1,26 @@ { - "order": "row-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 0.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 2.0, - 1.0, - 3.0, - 1.5, - 4.0, - 2.0 - ], - "x": [ - 1.0, - -0.2, - 0.0, - 0.0, - 2.0, - -0.4 - ], - "y": [ - 2.0, - 0.6, - 0.0, - 0.0, - 1.0, - 0.3 - ], - "strideA1": 2, - "strideA2": 1, - "offsetA": 0, - "strideX": 2, - "offsetX": 0, - "strideY": -2, - "offsetY": 2, - "y_out": [ - 12.100000000000001, - 3.3, - 0.0, - 0.0, - 5.5, - 1.5 - ] + "order": "row-major", + "trans": "no-transpose", + "M": 4, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "lda": 2, + "A": [ 1.0, 1.0, 5.0, 5.0, 2.0, 2.0, 6.0, 6.0, 3.0, 3.0, 7.0, 7.0, 4.0, 4.0, 8.0, 8.0 ], + "A_mat": [ + [ 1.0, 1.0, 5.0, 5.0 ], + [ 2.0, 2.0, 6.0, 6.0 ], + [ 3.0, 3.0, 7.0, 7.0 ], + [ 4.0, 4.0, 8.0, 8.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0 ], + "y": [ 4.0, 4.0, 3.0, 3.0, 2.0, 2.0, 1.0, 1.0 ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": -1, + "offsetY": 3, + "y_out": [ -16.0, 20.0, -14.0, 17.0, -12.0, 14.0, -10.0, 11.0 ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xpyp.json b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xpyp.json index 116d94508c76..acc5cb255fd5 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xpyp.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/fixtures/row_major_xpyp.json @@ -1,56 +1,26 @@ { - "order": "row-major", - "trans": "no-transpose", - "M": 2, - "N": 2, - "alpha": [ - 1.0, - 0.0 - ], - "beta": [ - 0.0, - 0.0 - ], - "lda": 2, - "A": [ - 1.0, - 0.5, - 2.0, - 1.0, - 3.0, - 1.5, - 4.0, - 2.0 - ], - "x": [ - 1.0, - -0.2, - 0.0, - 0.0, - 2.0, - -0.4 - ], - "y": [ - 1.0, - 0.3, - 0.0, - 0.0, - 2.0, - 0.6 - ], - "strideA1": 2, - "strideA2": 1, - "offsetA": 0, - "strideX": 2, - "offsetX": 0, - "strideY": 2, - "offsetY": 0, - "y_out": [ - 5.5, - 1.5, - 0.0, - 0.0, - 12.100000000000001, - 3.3 - ] + "order": "row-major", + "trans": "no-transpose", + "M": 4, + "N": 2, + "alpha": [ 0.5, 0.5 ], + "beta": [ 0.5, -0.5 ], + "lda": 2, + "A": [ 1.0, 1.0, 5.0, 5.0, 2.0, 2.0, 6.0, 6.0, 3.0, 3.0, 7.0, 7.0, 4.0, 4.0, 8.0, 8.0 ], + "A_mat": [ + [ 1.0, 1.0, 5.0, 5.0 ], + [ 2.0, 2.0, 6.0, 6.0 ], + [ 3.0, 3.0, 7.0, 7.0 ], + [ 4.0, 4.0, 8.0, 8.0 ] + ], + "x": [ 1.0, 1.0, 2.0, 2.0 ], + "y": [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ], + "strideA1": 2, + "strideA2": 1, + "offsetA": 0, + "strideX": 1, + "offsetX": 0, + "strideY": 1, + "offsetY": 0, + "y_out": [ -10.0, 11.0, -12.0, 14.0, -14.0, 17.0, -16.0, 20.0 ] } From 8dcc5c0a76faf81e2c6d027d8d7aab1f6ee7cc3f Mon Sep 17 00:00:00 2001 From: kaustubh Date: Tue, 12 May 2026 23:55:56 +0530 Subject: [PATCH 12/12] Convert zgemv into plain JS implementation --- .../@stdlib/blas/base/zgemv/README.md | 146 +-- .../base/zgemv/benchmark/benchmark.native.js | 129 --- .../benchmark/benchmark.ndarray.native.js | 129 --- .../blas/base/zgemv/benchmark/c/Makefile | 146 --- .../base/zgemv/benchmark/c/benchmark.length.c | 216 ---- .../@stdlib/blas/base/zgemv/binding.gyp | 265 ----- .../blas/base/zgemv/examples/c/Makefile | 146 --- .../blas/base/zgemv/examples/c/example.c | 70 -- .../@stdlib/blas/base/zgemv/include.gypi | 70 -- .../zgemv/include/stdlib/blas/base/zgemv.h | 49 - .../include/stdlib/blas/base/zgemv_cblas.h | 49 - .../@stdlib/blas/base/zgemv/lib/native.js | 35 - .../blas/base/zgemv/lib/ndarray.native.js | 91 -- .../blas/base/zgemv/lib/zgemv.native.js | 119 -- .../@stdlib/blas/base/zgemv/manifest.json | 630 ---------- .../@stdlib/blas/base/zgemv/package.json | 10 - .../@stdlib/blas/base/zgemv/src/Makefile | 70 -- .../@stdlib/blas/base/zgemv/src/addon.c | 125 -- .../@stdlib/blas/base/zgemv/src/zgemv.c | 114 -- .../@stdlib/blas/base/zgemv/src/zgemv_cblas.c | 41 - .../blas/base/zgemv/src/zgemv_ndarray.c | 189 --- .../@stdlib/blas/base/zgemv/test/test.js | 6 +- .../base/zgemv/test/test.ndarray.native.js | 1024 ----------------- .../blas/base/zgemv/test/test.zgemv.native.js | 784 ------------- 24 files changed, 10 insertions(+), 4643 deletions(-) delete mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.native.js delete mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.native.js delete mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/benchmark/c/Makefile delete mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/benchmark/c/benchmark.length.c delete mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/binding.gyp delete mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/examples/c/Makefile delete mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/examples/c/example.c delete mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/include.gypi delete mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/include/stdlib/blas/base/zgemv.h delete mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/include/stdlib/blas/base/zgemv_cblas.h delete mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/lib/native.js delete mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/lib/ndarray.native.js delete mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/lib/zgemv.native.js delete mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/manifest.json delete mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/src/Makefile delete mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/src/addon.c delete mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv.c delete mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv_cblas.c delete mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv_ndarray.c delete mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/test.ndarray.native.js delete mode 100644 lib/node_modules/@stdlib/blas/base/zgemv/test/test.zgemv.native.js diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/README.md b/lib/node_modules/@stdlib/blas/base/zgemv/README.md index d69cee70212d..c2ba4c3d6f4c 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/README.md +++ b/lib/node_modules/@stdlib/blas/base/zgemv/README.md @@ -242,102 +242,21 @@ logEach( '%s', x ); ### Usage ```c -#include "stdlib/blas/base/zgemv.h" +TODO ``` -#### c_zgemv( layout, trans, M, N, alpha, \*A, LDA, \*X, strideX, beta, \*Y, strideY ) +#### TODO -Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. +TODO. ```c -#include "stdlib/blas/base/shared.h" -#include "stdlib/complex/float64/ctor.h" - -const stdlib_complex128_t A[] = { - stdlib_complex128( 1.0, 2.0 ), stdlib_complex128( 3.0, 4.0 ), - stdlib_complex128( 5.0, 6.0 ), stdlib_complex128( 7.0, 8.0 ) -}; -const stdlib_complex128_t x[] = { - stdlib_complex128( 1.0, 1.0 ), - stdlib_complex128( 1.0, 1.0 ) -}; -stdlib_complex128_t y[] = { - stdlib_complex128( 0.0, 0.0 ), - stdlib_complex128( 0.0, 0.0 ) -}; - -const stdlib_complex128_t alpha = stdlib_complex128( 1.0, 0.0 ); -const stdlib_complex128_t beta = stdlib_complex128( 0.0, 0.0 ); - -c_zgemv( CblasRowMajor, CblasNoTrans, 2, 2, alpha, (void *)A, 2, (void *)x, 1, beta, (void *)y, 1 ); +TODO ``` -The function accepts the following arguments: - -- **layout**: `[in] CBLAS_LAYOUT` storage layout. -- **trans**: `[in] CBLAS_TRANSPOSE` specifies whether `A` should be transposed, conjugate-transposed, or not transposed. -- **M**: `[in] CBLAS_INT` number of rows in the matrix `A`. -- **N**: `[in] CBLAS_INT` number of columns in the matrix `A`. -- **alpha**: `[in] stdlib_complex128_t` scalar constant. -- **A**: `[in] void*` input matrix. -- **LDA**: `[in] CBLAS_INT` stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`). -- **X**: `[in] void*` first input vector. -- **strideX**: `[in] CBLAS_INT` stride length for `X`. -- **beta**: `[in] stdlib_complex128_t` scalar constant. -- **Y**: `[inout] void*` second input vector. -- **strideY**: `[in] CBLAS_INT` stride length for `Y`. +TODO ```c -void c_zgemv( const CBLAS_LAYOUT layout, const CBLAS_TRANSPOSE trans, const CBLAS_INT M, const CBLAS_INT N, const stdlib_complex128_t alpha, const void *A, const CBLAS_INT LDA, const void *X, const CBLAS_INT strideX, const stdlib_complex128_t beta, void *Y, const CBLAS_INT strideY ) -``` - -#### c_zgemv_ndarray( trans, M, N, alpha, \*A, sa1, sa2, oa, \*X, sx, ox, beta, \*Y, sy, oy ) - -Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, using alternative indexing semantics and where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. - -```c -#include "stdlib/blas/base/shared.h" -#include "stdlib/complex/float64/ctor.h" - -const stdlib_complex128_t A[] = { - stdlib_complex128( 1.0, 2.0 ), stdlib_complex128( 3.0, 4.0 ), - stdlib_complex128( 5.0, 6.0 ), stdlib_complex128( 7.0, 8.0 ) -}; -const stdlib_complex128_t x[] = { - stdlib_complex128( 1.0, 1.0 ), - stdlib_complex128( 1.0, 1.0 ) -}; -stdlib_complex128_t y[] = { - stdlib_complex128( 0.0, 0.0 ), - stdlib_complex128( 0.0, 0.0 ) -}; - -const stdlib_complex128_t alpha = stdlib_complex128( 1.0, 0.0 ); -const stdlib_complex128_t beta = stdlib_complex128( 0.0, 0.0 ); - -c_zgemv_ndarray( CblasNoTrans, 2, 2, alpha, (void *)A, 2, 1, 0, (void *)x, 1, 0, beta, (void *)y, 1, 0 ); -``` - -The function accepts the following arguments: - -- **trans**: `[in] CBLAS_TRANSPOSE` specifies whether `A` should be transposed, conjugate-transposed, or not transposed. -- **M**: `[in] CBLAS_INT` number of rows in the matrix `A`. -- **N**: `[in] CBLAS_INT` number of columns in the matrix `A`. -- **alpha**: `[in] stdlib_complex128_t` scalar constant. -- **A**: `[in] void*` input matrix. -- **sa1**: `[in] CBLAS_INT` stride of the first dimension of `A`. -- **sa2**: `[in] CBLAS_INT` stride of the second dimension of `A`. -- **oa**: `[in] CBLAS_INT` starting index for `A`. -- **X**: `[in] void*` first input vector. -- **sx**: `[in] CBLAS_INT` stride length for `X`. -- **ox**: `[in] CBLAS_INT` starting index for `X`. -- **beta**: `[in] stdlib_complex128_t` scalar constant. -- **Y**: `[inout] void*` second input vector. -- **sy**: `[in] CBLAS_INT` stride length for `Y`. -- **oy**: `[in] CBLAS_INT` starting index for `Y`. - -```c -void c_zgemv_ndarray( const CBLAS_TRANSPOSE trans, const CBLAS_INT M, const CBLAS_INT N, const stdlib_complex128_t alpha, const void *A, const CBLAS_INT strideA1, const CBLAS_INT strideA2, const CBLAS_INT offsetA, const void *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, const stdlib_complex128_t beta, void *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY ) +TODO ``` @@ -359,58 +278,7 @@ void c_zgemv_ndarray( const CBLAS_TRANSPOSE trans, const CBLAS_INT M, const CBLA ### Examples ```c -#include "stdlib/blas/base/zgemv.h" -#include "stdlib/blas/base/shared.h" -#include "stdlib/complex/float64/ctor.h" -#include "stdlib/complex/float64/real.h" -#include "stdlib/complex/float64/imag.h" -#include - -int main( void ) { - // Define a 2x2 matrix stored in row-major order: - const stdlib_complex128_t A[] = { - stdlib_complex128( 1.0, 2.0 ), stdlib_complex128( 3.0, 4.0 ), - stdlib_complex128( 5.0, 6.0 ), stdlib_complex128( 7.0, 8.0 ) - }; - - // Define `x` and `y` vectors: - const stdlib_complex128_t x[] = { - stdlib_complex128( 1.0, 1.0 ), - stdlib_complex128( 1.0, 1.0 ) - }; - stdlib_complex128_t y[] = { - stdlib_complex128( 0.0, 0.0 ), - stdlib_complex128( 0.0, 0.0 ) - }; - - // Specify the number of elements along each dimension of `A`: - const int M = 2; - const int N = 2; - - // Define alpha and beta: - const stdlib_complex128_t alpha = stdlib_complex128( 1.0, 0.0 ); - const stdlib_complex128_t beta = stdlib_complex128( 0.0, 0.0 ); - - // Perform the matrix-vector operation `y = α*A*x + β*y`: - c_zgemv( CblasRowMajor, CblasNoTrans, M, N, alpha, (void *)A, N, (void *)x, 1, beta, (void *)y, 1 ); - - // Print the result: - for ( int i = 0; i < M; i++ ) { - printf( "y[ %i ] = %lf + %lfi\n", i, stdlib_complex128_real( y[ i ] ), stdlib_complex128_imag( y[ i ] ) ); - } - - // Reset `y`: - y[ 0 ] = stdlib_complex128( 0.0, 0.0 ); - y[ 1 ] = stdlib_complex128( 0.0, 0.0 ); - - // Perform the matrix-vector operation `y = α*A*x + β*y` using alternative indexing semantics: - c_zgemv_ndarray( CblasNoTrans, M, N, alpha, (void *)A, N, 1, 0, (void *)x, 1, 0, beta, (void *)y, 1, 0 ); - - // Print the result: - for ( int i = 0; i < M; i++ ) { - printf( "y[ %i ] = %lf + %lfi\n", i, stdlib_complex128_real( y[ i ] ), stdlib_complex128_imag( y[ i ] ) ); - } -} +TODO ``` diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.native.js deleted file mode 100644 index 0a805c16b3fa..000000000000 --- a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.native.js +++ /dev/null @@ -1,129 +0,0 @@ -/** -* @license Apache-2.0 -* -* Copyright (c) 2026 The Stdlib Authors. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ - -'use strict'; - -// MODULES // - -var resolve = require( 'path' ).resolve; -var bench = require( '@stdlib/bench' ); -var uniform = require( '@stdlib/random/array/uniform' ); -var isnan = require( '@stdlib/math/base/assert/is-nan' ); -var pow = require( '@stdlib/math/base/special/pow' ); -var format = require( '@stdlib/string/format' ); -var floor = require( '@stdlib/math/base/special/floor' ); -var Complex128Array = require( '@stdlib/array/complex128' ); -var Complex128 = require( '@stdlib/complex/float64/ctor' ); -var tryRequire = require( '@stdlib/utils/try-require' ); -var pkg = require( './../package.json' ).name; - - -// VARIABLES // - -var zgemv = tryRequire( resolve( __dirname, './../lib/zgemv.native.js' ) ); -var opts = { - 'skip': ( zgemv instanceof Error ) -}; -var options = { - 'dtype': 'float64' -}; - - -// FUNCTIONS // - -/** -* Creates a benchmark function. -* -* @private -* @param {PositiveInteger} N - array length -* @returns {Function} benchmark function -*/ -function createBenchmark( N ) { - var alpha; - var beta; - var xbuf; - var ybuf; - var Abuf; - var x; - var y; - var A; - - xbuf = uniform( N*2, -100.0, 100.0, options ); - x = new Complex128Array( xbuf.buffer ); - ybuf = uniform( N*2, -100.0, 100.0, options ); - y = new Complex128Array( ybuf.buffer ); - Abuf = uniform( (N*N)*2, -100.0, 100.0, options ); - A = new Complex128Array( Abuf.buffer ); - - alpha = new Complex128( 0.5, 0.5 ); - beta = new Complex128( 0.5, -0.5 ); - - return benchmark; - - /** - * Benchmark function. - * - * @private - * @param {Benchmark} b - benchmark instance - */ - function benchmark( b ) { - var i; - var z; - - b.tic(); - for ( i = 0; i < b.iterations; i++ ) { - z = zgemv( 'row-major', 'no-transpose', N, N, alpha, A, N, x, 1, beta, y, 1 ); - if ( isnan( z[ i%z.length ] ) ) { - b.fail( 'should not return NaN' ); - } - } - b.toc(); - if ( isnan( z[ i%z.length ] ) ) { - b.fail( 'should not return NaN' ); - } - b.pass( 'benchmark finished' ); - b.end(); - } -} - - -// MAIN // - -/** -* Main execution sequence. -* -* @private -*/ -function main() { - var min; - var max; - var N; - var f; - var i; - - min = 1; // 10^min - max = 6; // 10^max - - for ( i = min; i <= max; i++ ) { - N = floor( pow( pow( 10, i ), 1.0/2.0 ) ); - f = createBenchmark( N ); - bench( format( '%s::native:size=%d', pkg, N*N ), opts, f ); - } -} - -main(); diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.native.js b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.native.js deleted file mode 100644 index c9121e3b8202..000000000000 --- a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/benchmark.ndarray.native.js +++ /dev/null @@ -1,129 +0,0 @@ -/** -* @license Apache-2.0 -* -* Copyright (c) 2026 The Stdlib Authors. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ - -'use strict'; - -// MODULES // - -var resolve = require( 'path' ).resolve; -var bench = require( '@stdlib/bench' ); -var uniform = require( '@stdlib/random/array/uniform' ); -var isnan = require( '@stdlib/math/base/assert/is-nan' ); -var pow = require( '@stdlib/math/base/special/pow' ); -var format = require( '@stdlib/string/format' ); -var floor = require( '@stdlib/math/base/special/floor' ); -var Complex128Array = require( '@stdlib/array/complex128' ); -var Complex128 = require( '@stdlib/complex/float64/ctor' ); -var tryRequire = require( '@stdlib/utils/try-require' ); -var pkg = require( './../package.json' ).name; - - -// VARIABLES // - -var zgemv = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) ); -var opts = { - 'skip': ( zgemv instanceof Error ) -}; -var options = { - 'dtype': 'float64' -}; - - -// FUNCTIONS // - -/** -* Creates a benchmark function. -* -* @private -* @param {PositiveInteger} N - array length -* @returns {Function} benchmark function -*/ -function createBenchmark( N ) { - var alpha; - var beta; - var xbuf; - var ybuf; - var Abuf; - var x; - var y; - var A; - - xbuf = uniform( N*2, -100.0, 100.0, options ); - x = new Complex128Array( xbuf.buffer ); - ybuf = uniform( N*2, -100.0, 100.0, options ); - y = new Complex128Array( ybuf.buffer ); - Abuf = uniform( (N*N)*2, -100.0, 100.0, options ); - A = new Complex128Array( Abuf.buffer ); - - alpha = new Complex128( 0.5, 0.5 ); - beta = new Complex128( 0.5, -0.5 ); - - return benchmark; - - /** - * Benchmark function. - * - * @private - * @param {Benchmark} b - benchmark instance - */ - function benchmark( b ) { - var i; - var z; - - b.tic(); - for ( i = 0; i < b.iterations; i++ ) { - z = zgemv( 'no-transpose', N, N, alpha, A, N, 1, 0, x, 1, 0, beta, y, 1, 0 ); - if ( isnan( z[ i%z.length ] ) ) { - b.fail( 'should not return NaN' ); - } - } - b.toc(); - if ( isnan( z[ i%z.length ] ) ) { - b.fail( 'should not return NaN' ); - } - b.pass( 'benchmark finished' ); - b.end(); - } -} - - -// MAIN // - -/** -* Main execution sequence. -* -* @private -*/ -function main() { - var min; - var max; - var N; - var f; - var i; - - min = 1; // 10^min - max = 6; // 10^max - - for ( i = min; i <= max; i++ ) { - N = floor( pow( pow( 10, i ), 1.0/2.0 ) ); - f = createBenchmark( N ); - bench( format( '%s::native:ndarray:size=%d', pkg, N*N ), opts, f ); - } -} - -main(); diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/c/Makefile b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/c/Makefile deleted file mode 100644 index 0756dc7da20a..000000000000 --- a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/c/Makefile +++ /dev/null @@ -1,146 +0,0 @@ -#/ -# @license Apache-2.0 -# -# Copyright (c) 2026 The Stdlib Authors. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -#/ - -# VARIABLES # - -ifndef VERBOSE - QUIET := @ -else - QUIET := -endif - -# Determine the OS ([1][1], [2][2]). -# -# [1]: https://en.wikipedia.org/wiki/Uname#Examples -# [2]: http://stackoverflow.com/a/27776822/2225624 -OS ?= $(shell uname) -ifneq (, $(findstring MINGW,$(OS))) - OS := WINNT -else -ifneq (, $(findstring MSYS,$(OS))) - OS := WINNT -else -ifneq (, $(findstring CYGWIN,$(OS))) - OS := WINNT -else -ifneq (, $(findstring Windows_NT,$(OS))) - OS := WINNT -endif -endif -endif -endif - -# Define the program used for compiling C source files: -ifdef C_COMPILER - CC := $(C_COMPILER) -else - CC := gcc -endif - -# Define the command-line options when compiling C files: -CFLAGS ?= \ - -std=c99 \ - -O3 \ - -Wall \ - -pedantic - -# Determine whether to generate position independent code ([1][1], [2][2]). -# -# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options -# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option -ifeq ($(OS), WINNT) - fPIC ?= -else - fPIC ?= -fPIC -endif - -# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`): -INCLUDE ?= - -# List of source files: -SOURCE_FILES ?= - -# List of libraries (e.g., `-lopenblas -lpthread`): -LIBRARIES ?= - -# List of library paths (e.g., `-L /foo/bar -L /beep/boop`): -LIBPATH ?= - -# List of C targets: -c_targets := benchmark.length.out - - -# RULES # - -#/ -# Compiles source files. -# -# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`) -# @param {string} [CFLAGS] - C compiler options -# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) -# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`) -# @param {string} [SOURCE_FILES] - list of source files -# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`) -# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`) -# -# @example -# make -# -# @example -# make all -#/ -all: $(c_targets) - -.PHONY: all - -#/ -# Compiles C source files. -# -# @private -# @param {string} CC - C compiler (e.g., `gcc`) -# @param {string} CFLAGS - C compiler options -# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) -# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`) -# @param {string} SOURCE_FILES - list of source files -# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`) -# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`) -#/ -$(c_targets): %.out: %.c - $(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES) - -#/ -# Runs compiled benchmarks. -# -# @example -# make run -#/ -run: $(c_targets) - $(QUIET) ./$< - -.PHONY: run - -#/ -# Removes generated files. -# -# @example -# make clean -#/ -clean: - $(QUIET) -rm -f *.o *.out - -.PHONY: clean diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/c/benchmark.length.c b/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/c/benchmark.length.c deleted file mode 100644 index 5e2f9087fd10..000000000000 --- a/lib/node_modules/@stdlib/blas/base/zgemv/benchmark/c/benchmark.length.c +++ /dev/null @@ -1,216 +0,0 @@ -/** -* @license Apache-2.0 -* -* Copyright (c) 2026 The Stdlib Authors. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ - -#include "stdlib/blas/base/zgemv.h" -#include "stdlib/complex/float64/ctor.h" -#include "stdlib/complex/float64/real.h" -#include "stdlib/complex/float64/imag.h" -#include -#include -#include -#include -#include - -#define NAME "zgemv" -#define ITERATIONS 1000000 -#define REPEATS 3 -#define MIN 1 -#define MAX 6 - -/** -* Prints the TAP version. -*/ -static void print_version( void ) { - printf( "TAP version 13\n" ); -} - -/** -* Prints the TAP summary. -* -* @param total total number of tests -* @param passing total number of passing tests -*/ -static void print_summary( int total, int passing ) { - printf( "#\n" ); - printf( "1..%d\n", total ); // TAP plan - printf( "# total %d\n", total ); - printf( "# pass %d\n", passing ); - printf( "#\n" ); - printf( "# ok\n" ); -} - -/** -* Prints benchmarks results. -* -* @param iterations number of iterations -* @param elapsed elapsed time in seconds -*/ -static void print_results( int iterations, double elapsed ) { - double rate = (double)iterations / elapsed; - printf( " ---\n" ); - printf( " iterations: %d\n", iterations ); - printf( " elapsed: %0.9f\n", elapsed ); - printf( " rate: %0.9f\n", rate ); - printf( " ...\n" ); -} - -/** -* Returns a clock time. -* -* @return clock time -*/ -static double tic( void ) { - struct timeval now; - gettimeofday( &now, NULL ); - return (double)now.tv_sec + (double)now.tv_usec/1.0e6; -} - -/** -* Generates a random number on the interval [0,1). -* -* @return random number -*/ -static double rand_double( void ) { - int r = rand(); - return (double)r / ( (double)RAND_MAX + 1.0 ); -} - -/** -* Runs a benchmark. -* -* @param iterations number of iterations -* @param N array dimension size -* @return elapsed time in seconds -*/ -static double benchmark1( int iterations, int N ) { - double elapsed; - stdlib_complex128_t *A; - stdlib_complex128_t *x; - stdlib_complex128_t *y; - stdlib_complex128_t alpha = stdlib_complex128( 1.0, 1.0 ); - stdlib_complex128_t beta = stdlib_complex128( 1.0, 1.0 ); - double t; - int i; - int j; - - A = (stdlib_complex128_t *)malloc( N * N * sizeof(stdlib_complex128_t) ); - x = (stdlib_complex128_t *)malloc( N * sizeof(stdlib_complex128_t) ); - y = (stdlib_complex128_t *)malloc( N * sizeof(stdlib_complex128_t) ); - - for ( i = 0; i < N; i++ ) { - x[ i ] = stdlib_complex128( ( rand_double()*20.0 ) - 10.0, ( rand_double()*20.0 ) - 10.0 ); - y[ i ] = stdlib_complex128( ( rand_double()*20.0 ) - 10.0, ( rand_double()*20.0 ) - 10.0 ); - for ( j = 0; j < N; j++ ) { - A[ (i*N)+j ] = stdlib_complex128( ( rand_double()*20.0 ) - 10.0, ( rand_double()*20.0 ) - 10.0 ); - } - } - t = tic(); - for ( i = 0; i < iterations; i++ ) { - c_zgemv( CblasRowMajor, CblasNoTrans, N, N, alpha, (void *)A, N, (void *)x, 1, beta, (void *)y, 1 ); - if ( stdlib_complex128_real( y[ i%N ] ) != stdlib_complex128_real( y[ i%N ] ) ) { - printf( "should not return NaN\n" ); - break; - } - } - elapsed = tic() - t; - free( A ); - free( x ); - free( y ); - return elapsed; -} - -/** -* Runs a benchmark. -* -* @param iterations number of iterations -* @param N array dimension size -* @return elapsed time in seconds -*/ -static double benchmark2( int iterations, int N ) { - double elapsed; - stdlib_complex128_t *A; - stdlib_complex128_t *x; - stdlib_complex128_t *y; - stdlib_complex128_t alpha = stdlib_complex128( 1.0, 1.0 ); - stdlib_complex128_t beta = stdlib_complex128( 1.0, 1.0 ); - double t; - int i; - int j; - - A = (stdlib_complex128_t *)malloc( N * N * sizeof(stdlib_complex128_t) ); - x = (stdlib_complex128_t *)malloc( N * sizeof(stdlib_complex128_t) ); - y = (stdlib_complex128_t *)malloc( N * sizeof(stdlib_complex128_t) ); - - for ( i = 0; i < N; i++ ) { - x[ i ] = stdlib_complex128( ( rand_double()*20.0 ) - 10.0, ( rand_double()*20.0 ) - 10.0 ); - y[ i ] = stdlib_complex128( ( rand_double()*20.0 ) - 10.0, ( rand_double()*20.0 ) - 10.0 ); - for ( j = 0; j < N; j++ ) { - A[ (i*N)+j ] = stdlib_complex128( ( rand_double()*20.0 ) - 10.0, ( rand_double()*20.0 ) - 10.0 ); - } - } - t = tic(); - for ( i = 0; i < iterations; i++ ) { - c_zgemv_ndarray( CblasNoTrans, N, N, alpha, (void *)A, N, 1, 0, (void *)x, 1, 0, beta, (void *)y, 1, 0 ); - if ( stdlib_complex128_real( y[ i%N ] ) != stdlib_complex128_real( y[ i%N ] ) ) { - printf( "should not return NaN\n" ); - break; - } - } - elapsed = tic() - t; - free( A ); - free( x ); - free( y ); - return elapsed; -} - -/** -* Main execution sequence. -*/ -int main( void ) { - double elapsed; - int count; - int iter; - int N; - int i; - int j; - - // Use the current time to seed the random number generator: - srand( time( NULL ) ); - - print_version(); - count = 0; - for ( i = MIN; i <= MAX; i++ ) { - N = floor( pow( pow( 10, i ), 1.0/2.0 ) ); - iter = ITERATIONS / pow( 10, i-1 ); - for ( j = 0; j < REPEATS; j++ ) { - count += 1; - printf( "# c::%s:size=%d\n", NAME, N*N ); - elapsed = benchmark1( iter, N ); - print_results( iter, elapsed ); - printf( "ok %d benchmark finished\n", count ); - } - for ( j = 0; j < REPEATS; j++ ) { - count += 1; - printf( "# c::%s:ndarray:size=%d\n", NAME, N*N ); - elapsed = benchmark2( iter, N ); - print_results( iter, elapsed ); - printf( "ok %d benchmark finished\n", count ); - } - } - print_summary( count, count ); -} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/binding.gyp b/lib/node_modules/@stdlib/blas/base/zgemv/binding.gyp deleted file mode 100644 index 60dce9d0b31a..000000000000 --- a/lib/node_modules/@stdlib/blas/base/zgemv/binding.gyp +++ /dev/null @@ -1,265 +0,0 @@ -# @license Apache-2.0 -# -# Copyright (c) 2026 The Stdlib Authors. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -# A `.gyp` file for building a Node.js native add-on. -# -# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md -# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md -{ - # List of files to include in this file: - 'includes': [ - './include.gypi', - ], - - # Define variables to be used throughout the configuration for all targets: - 'variables': { - # Target name should match the add-on export name: - 'addon_target_name%': 'addon', - - # Fortran compiler (to override -Dfortran_compiler=): - 'fortran_compiler%': 'gfortran', - - # Fortran compiler flags: - 'fflags': [ - # Specify the Fortran standard to which a program is expected to conform: - '-std=f95', - - # Indicate that the layout is free-form source code: - '-ffree-form', - - # Aggressive optimization: - '-O3', - - # Enable commonly used warning options: - '-Wall', - - # Warn if source code contains problematic language features: - '-Wextra', - - # Warn if a procedure is called without an explicit interface: - '-Wimplicit-interface', - - # Do not transform names of entities specified in Fortran source files by appending underscores (i.e., don't mangle names, thus allowing easier usage in C wrappers): - '-fno-underscoring', - - # Warn if source code contains Fortran 95 extensions and C-language constructs: - '-pedantic', - - # Compile but do not link (output is an object file): - '-c', - ], - - # Set variables based on the host OS: - 'conditions': [ - [ - 'OS=="win"', - { - # Define the object file suffix: - 'obj': 'obj', - }, - { - # Define the object file suffix: - 'obj': 'o', - } - ], # end condition (OS=="win") - ], # end conditions - }, # end variables - - # Define compile targets: - 'targets': [ - - # Target to generate an add-on: - { - # The target name should match the add-on export name: - 'target_name': '<(addon_target_name)', - - # Define dependencies: - 'dependencies': [], - - # Define directories which contain relevant include headers: - 'include_dirs': [ - # Local include directory: - '<@(include_dirs)', - ], - - # List of source files: - 'sources': [ - '<@(src_files)', - ], - - # Settings which should be applied when a target's object files are used as linker input: - 'link_settings': { - # Define libraries: - 'libraries': [ - '<@(libraries)', - ], - - # Define library directories: - 'library_dirs': [ - '<@(library_dirs)', - ], - }, - - # C/C++ compiler flags: - 'cflags': [ - # Enable commonly used warning options: - '-Wall', - - # Aggressive optimization: - '-O3', - ], - - # C specific compiler flags: - 'cflags_c': [ - # Specify the C standard to which a program is expected to conform: - '-std=c99', - ], - - # C++ specific compiler flags: - 'cflags_cpp': [ - # Specify the C++ standard to which a program is expected to conform: - '-std=c++11', - ], - - # Linker flags: - 'ldflags': [], - - # Apply conditions based on the host OS: - 'conditions': [ - [ - 'OS=="mac"', - { - # Linker flags: - 'ldflags': [ - '-undefined dynamic_lookup', - '-Wl,-no-pie', - '-Wl,-search_paths_first', - ], - }, - ], # end condition (OS=="mac") - [ - 'OS!="win"', - { - # C/C++ flags: - 'cflags': [ - # Generate platform-independent code: - '-fPIC', - ], - }, - ], # end condition (OS!="win") - ], # end conditions - - # Define custom build actions for particular inputs: - 'rules': [ - { - # Define a rule for processing Fortran files: - 'extension': 'f', - - # Define the pathnames to be used as inputs when performing processing: - 'inputs': [ - # Full path of the current input: - '<(RULE_INPUT_PATH)' - ], - - # Define the outputs produced during processing: - 'outputs': [ - # Store an output object file in a directory for placing intermediate results (only accessible within a single target): - '<(INTERMEDIATE_DIR)/<(RULE_INPUT_ROOT).<(obj)' - ], - - # Define the rule for compiling Fortran based on the host OS: - 'conditions': [ - [ - 'OS=="win"', - - # Rule to compile Fortran on Windows: - { - 'rule_name': 'compile_fortran_windows', - 'message': 'Compiling Fortran file <(RULE_INPUT_PATH) on Windows...', - - 'process_outputs_as_sources': 0, - - # Define the command-line invocation: - 'action': [ - '<(fortran_compiler)', - '<@(fflags)', - '<@(_inputs)', - '-o', - '<@(_outputs)', - ], - }, - - # Rule to compile Fortran on non-Windows: - { - 'rule_name': 'compile_fortran_linux', - 'message': 'Compiling Fortran file <(RULE_INPUT_PATH) on Linux...', - - 'process_outputs_as_sources': 1, - - # Define the command-line invocation: - 'action': [ - '<(fortran_compiler)', - '<@(fflags)', - '-fPIC', # generate platform-independent code - '<@(_inputs)', - '-o', - '<@(_outputs)', - ], - } - ], # end condition (OS=="win") - ], # end conditions - }, # end rule (extension=="f") - ], # end rules - }, # end target <(addon_target_name) - - # Target to copy a generated add-on to a standard location: - { - 'target_name': 'copy_addon', - - # Declare that the output of this target is not linked: - 'type': 'none', - - # Define dependencies: - 'dependencies': [ - # Require that the add-on be generated before building this target: - '<(addon_target_name)', - ], - - # Define a list of actions: - 'actions': [ - { - 'action_name': 'copy_addon', - 'message': 'Copying addon...', - - # Explicitly list the inputs in the command-line invocation below: - 'inputs': [], - - # Declare the expected outputs: - 'outputs': [ - '<(addon_output_dir)/<(addon_target_name).node', - ], - - # Define the command-line invocation: - 'action': [ - 'cp', - '<(PRODUCT_DIR)/<(addon_target_name).node', - '<(addon_output_dir)/<(addon_target_name).node', - ], - }, - ], # end actions - }, # end target copy_addon - ], # end targets -} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/examples/c/Makefile b/lib/node_modules/@stdlib/blas/base/zgemv/examples/c/Makefile deleted file mode 100644 index c8f8e9a1517b..000000000000 --- a/lib/node_modules/@stdlib/blas/base/zgemv/examples/c/Makefile +++ /dev/null @@ -1,146 +0,0 @@ -#/ -# @license Apache-2.0 -# -# Copyright (c) 2026 The Stdlib Authors. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -#/ - -# VARIABLES # - -ifndef VERBOSE - QUIET := @ -else - QUIET := -endif - -# Determine the OS ([1][1], [2][2]). -# -# [1]: https://en.wikipedia.org/wiki/Uname#Examples -# [2]: http://stackoverflow.com/a/27776822/2225624 -OS ?= $(shell uname) -ifneq (, $(findstring MINGW,$(OS))) - OS := WINNT -else -ifneq (, $(findstring MSYS,$(OS))) - OS := WINNT -else -ifneq (, $(findstring CYGWIN,$(OS))) - OS := WINNT -else -ifneq (, $(findstring Windows_NT,$(OS))) - OS := WINNT -endif -endif -endif -endif - -# Define the program used for compiling C source files: -ifdef C_COMPILER - CC := $(C_COMPILER) -else - CC := gcc -endif - -# Define the command-line options when compiling C files: -CFLAGS ?= \ - -std=c99 \ - -O3 \ - -Wall \ - -pedantic - -# Determine whether to generate position independent code ([1][1], [2][2]). -# -# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options -# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option -ifeq ($(OS), WINNT) - fPIC ?= -else - fPIC ?= -fPIC -endif - -# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`): -INCLUDE ?= - -# List of source files: -SOURCE_FILES ?= - -# List of libraries (e.g., `-lopenblas -lpthread`): -LIBRARIES ?= - -# List of library paths (e.g., `-L /foo/bar -L /beep/boop`): -LIBPATH ?= - -# List of C targets: -c_targets := example.out - - -# RULES # - -#/ -# Compiles source files. -# -# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`) -# @param {string} [CFLAGS] - C compiler options -# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) -# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`) -# @param {string} [SOURCE_FILES] - list of source files -# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`) -# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`) -# -# @example -# make -# -# @example -# make all -#/ -all: $(c_targets) - -.PHONY: all - -#/ -# Compiles C source files. -# -# @private -# @param {string} CC - C compiler (e.g., `gcc`) -# @param {string} CFLAGS - C compiler options -# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) -# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`) -# @param {string} SOURCE_FILES - list of source files -# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`) -# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`) -#/ -$(c_targets): %.out: %.c - $(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES) - -#/ -# Runs compiled examples. -# -# @example -# make run -#/ -run: $(c_targets) - $(QUIET) ./$< - -.PHONY: run - -#/ -# Removes generated files. -# -# @example -# make clean -#/ -clean: - $(QUIET) -rm -f *.o *.out - -.PHONY: clean diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/examples/c/example.c b/lib/node_modules/@stdlib/blas/base/zgemv/examples/c/example.c deleted file mode 100644 index e0c5a1cdce29..000000000000 --- a/lib/node_modules/@stdlib/blas/base/zgemv/examples/c/example.c +++ /dev/null @@ -1,70 +0,0 @@ -/** -* @license Apache-2.0 -* -* Copyright (c) 2026 The Stdlib Authors. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ - -#include "stdlib/blas/base/zgemv.h" -#include "stdlib/blas/base/shared.h" -#include "stdlib/complex/float64/ctor.h" -#include "stdlib/complex/float64/real.h" -#include "stdlib/complex/float64/imag.h" -#include - -int main( void ) { - // Define a 2x2 matrix stored in row-major order: - const stdlib_complex128_t A[] = { - stdlib_complex128( 1.0, 2.0 ), stdlib_complex128( 3.0, 4.0 ), - stdlib_complex128( 5.0, 6.0 ), stdlib_complex128( 7.0, 8.0 ) - }; - - // Define `x` and `y` vectors: - const stdlib_complex128_t x[] = { - stdlib_complex128( 1.0, 1.0 ), - stdlib_complex128( 1.0, 1.0 ) - }; - stdlib_complex128_t y[] = { - stdlib_complex128( 0.0, 0.0 ), - stdlib_complex128( 0.0, 0.0 ) - }; - - // Specify the number of elements along each dimension of `A`: - const int M = 2; - const int N = 2; - - // Define alpha and beta: - const stdlib_complex128_t alpha = stdlib_complex128( 1.0, 0.0 ); - const stdlib_complex128_t beta = stdlib_complex128( 0.0, 0.0 ); - - // Perform the matrix-vector operation `y = α*A*x + β*y`: - c_zgemv( CblasRowMajor, CblasNoTrans, M, N, alpha, (void *)A, N, (void *)x, 1, beta, (void *)y, 1 ); - - // Print the result: - for ( int i = 0; i < M; i++ ) { - printf( "y[ %i ] = %lf + %lfi\n", i, stdlib_complex128_real( y[ i ] ), stdlib_complex128_imag( y[ i ] ) ); - } - - // Reset `y`: - y[ 0 ] = stdlib_complex128( 0.0, 0.0 ); - y[ 1 ] = stdlib_complex128( 0.0, 0.0 ); - - // Perform the matrix-vector operation `y = α*A*x + β*y` using alternative indexing semantics: - c_zgemv_ndarray( CblasNoTrans, M, N, alpha, (void *)A, N, 1, 0, (void *)x, 1, 0, beta, (void *)y, 1, 0 ); - - // Print the result: - for ( int i = 0; i < M; i++ ) { - printf( "y[ %i ] = %lf + %lfi\n", i, stdlib_complex128_real( y[ i ] ), stdlib_complex128_imag( y[ i ] ) ); - } -} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/include.gypi b/lib/node_modules/@stdlib/blas/base/zgemv/include.gypi deleted file mode 100644 index dcb556d250e8..000000000000 --- a/lib/node_modules/@stdlib/blas/base/zgemv/include.gypi +++ /dev/null @@ -1,70 +0,0 @@ -# @license Apache-2.0 -# -# Copyright (c) 2026 The Stdlib Authors. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -# A GYP include file for building a Node.js native add-on. -# -# Note that nesting variables is required due to how GYP processes a configuration. Any variables defined within a nested 'variables' section is defined in the outer scope. Thus, conditions in the outer variable scope are free to use these variables without running into "variable undefined" errors. -# -# Main documentation: -# -# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md -# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md -# -# Variable nesting hacks: -# -# [3]: https://chromium.googlesource.com/external/skia/gyp/+/master/common_variables.gypi -# [4]: https://src.chromium.org/viewvc/chrome/trunk/src/build/common.gypi?revision=127004 -{ - # Define variables to be used throughout the configuration for all targets: - 'variables': { - 'variables': { - # Host BLAS library (to override -Dblas=): - 'blas%': '', - - # Path to BLAS library (to override -Dblas_dir=): - 'blas_dir%': '', - }, # end variables - - # Source directory: - 'src_dir': './src', - - # Include directories: - 'include_dirs': [ - '<@(blas_dir)', - ' -*/ -function zgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, offsetX, beta, y, strideY, offsetY ) { // eslint-disable-line max-params, max-len - var viewA; - var viewX; - var viewY; - - if ( M < 0 ) { - throw new RangeError( format( 'invalid argument. Second argument must be a nonnegative integer. Value: `%d`.', M ) ); - } - if ( N < 0 ) { - throw new RangeError( format( 'invalid argument. Third argument must be a nonnegative integer. Value: `%d`.', N ) ); - } - if ( strideX === 0 ) { - throw new RangeError( format( 'invalid argument. Tenth argument must be non-zero. Value: `%d`.', strideX ) ); - } - if ( strideY === 0 ) { - throw new RangeError( format( 'invalid argument. Fourteenth argument must be non-zero. Value: `%d`.', strideY ) ); - } - viewA = reinterpret( A, 0 ); - viewX = reinterpret( x, 0 ); - viewY = reinterpret( y, 0 ); - addon.ndarray( resolveTrans( trans ), M, N, alpha, viewA, strideA1, strideA2, offsetA, viewX, strideX, offsetX, beta, viewY, strideY, offsetY ); // eslint-disable-line max-len - return y; -} - - -// EXPORTS // - -module.exports = zgemv; diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/lib/zgemv.native.js b/lib/node_modules/@stdlib/blas/base/zgemv/lib/zgemv.native.js deleted file mode 100644 index 27f3d11f6e4c..000000000000 --- a/lib/node_modules/@stdlib/blas/base/zgemv/lib/zgemv.native.js +++ /dev/null @@ -1,119 +0,0 @@ -/** -* @license Apache-2.0 -* -* Copyright (c) 2026 The Stdlib Authors. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ - -'use strict'; - -// MODULES // - -var isLayout = require( '@stdlib/blas/base/assert/is-layout' ); -var isMatrixTranspose = require( '@stdlib/blas/base/assert/is-transpose-operation' ); -var isColumnMajor = require( '@stdlib/ndarray/base/assert/is-column-major-string' ); -var max = require( '@stdlib/math/base/special/fast/max' ); -var reinterpret = require( '@stdlib/strided/base/reinterpret-complex128' ); -var resolveOrder = require( '@stdlib/blas/base/layout-resolve-enum' ); -var resolveTrans = require( '@stdlib/blas/base/transpose-operation-resolve-enum' ); -var real = require( '@stdlib/complex/float64/real' ); -var imag = require( '@stdlib/complex/float64/imag' ); -var format = require( '@stdlib/string/format' ); -var addon = require( './../src/addon.node' ); - - -// MAIN // - -/** -* Performs one of the matrix-vector operations `y = α*A*x + β*y`, `y = α*A^T*x + β*y`, or `y = α*A^H*x + β*y`, where `α` and `β` are scalars, `x` and `y` are vectors, and `A` is an `M` by `N` matrix. -* -* @param {string} order - storage layout -* @param {string} trans - specifies whether `A` should be transposed, conjugate-transposed, or not transposed -* @param {NonNegativeInteger} M - number of rows in the matrix `A` -* @param {NonNegativeInteger} N - number of columns in the matrix `A` -* @param {Complex128} alpha - scalar constant -* @param {Complex128Array} A - input matrix -* @param {PositiveInteger} LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) -* @param {Complex128Array} x - first input vector -* @param {integer} strideX - `x` stride length -* @param {Complex128} beta - scalar constant -* @param {Complex128Array} y - second input vector -* @param {integer} strideY - `y` stride length -* @throws {TypeError} first argument must be a valid order -* @throws {TypeError} second argument must be a valid transpose operation -* @throws {RangeError} third argument must be a nonnegative integer -* @throws {RangeError} fourth argument must be a nonnegative integer -* @throws {RangeError} seventh argument must be a valid stride -* @throws {RangeError} ninth argument must be non-zero -* @throws {RangeError} twelfth argument must be non-zero -* @returns {Complex128Array} `y` -* -* @example -* var Complex128Array = require( '@stdlib/array/complex128' ); -* var Complex128 = require( '@stdlib/complex/float64/ctor' ); -* -* var A = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); -* var x = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); -* var y = new Complex128Array( [ 1.0, 2.0, 3.0, 4.0 ] ); -* -* zgemv( 'row-major', 'no-transpose', 2, 3, new Complex128( 1.0, 0.0 ), A, 3, x, 1, new Complex128( 1.0, 0.0 ), y, 1 ); -* // y => -*/ -function zgemv( order, trans, M, N, alpha, A, LDA, x, strideX, beta, y, strideY ) { // eslint-disable-line max-params, max-len - var viewA; - var viewX; - var viewY; - var vala; - - if ( !isLayout( order ) ) { - throw new TypeError( format( 'invalid argument. First argument must be a valid order. Value: `%s`.', order ) ); - } - if ( !isMatrixTranspose( trans ) ) { - throw new TypeError( format( 'invalid argument. Second argument must be a valid transpose operation. Value: `%s`.', trans ) ); - } - if ( M < 0 ) { - throw new RangeError( format( 'invalid argument. Third argument must be a nonnegative integer. Value: `%d`.', M ) ); - } - if ( N < 0 ) { - throw new RangeError( format( 'invalid argument. Fourth argument must be a nonnegative integer. Value: `%d`.', N ) ); - } - if ( strideX === 0 ) { - throw new RangeError( format( 'invalid argument. Ninth argument must be non-zero. Value: `%d`.', strideX ) ); - } - if ( strideY === 0 ) { - throw new RangeError( format( 'invalid argument. Twelfth argument must be non-zero. Value: `%d`.', strideY ) ); - } - if ( isColumnMajor( order ) ) { - vala = M; - } else { - vala = N; - } - if ( LDA < max( 1, vala ) ) { - throw new RangeError( format( 'invalid argument. Seventh argument must be greater than or equal to max(1,%d). Value: `%d`.', vala, LDA ) ); - } - // Check if we can early return... - if ( M === 0 || N === 0 || ( real( alpha ) === 0.0 && imag( alpha ) === 0.0 && real( beta ) === 1.0 && imag( beta ) === 0.0 ) ) { - return y; - } - viewA = reinterpret( A, 0 ); - viewX = reinterpret( x, 0 ); - viewY = reinterpret( y, 0 ); - addon( resolveOrder( order ), resolveTrans( trans ), M, N, alpha, viewA, LDA, viewX, strideX, beta, viewY, strideY ); // eslint-disable-line max-len - return y; -} - - -// EXPORTS // - -module.exports = zgemv; diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/manifest.json b/lib/node_modules/@stdlib/blas/base/zgemv/manifest.json deleted file mode 100644 index 791d7564e73f..000000000000 --- a/lib/node_modules/@stdlib/blas/base/zgemv/manifest.json +++ /dev/null @@ -1,630 +0,0 @@ -{ - "options": { - "task": "build", - "os": "linux", - "blas": "", - "wasm": false - }, - "fields": [ - { - "field": "src", - "resolve": true, - "relative": true - }, - { - "field": "include", - "resolve": true, - "relative": true - }, - { - "field": "libraries", - "resolve": false, - "relative": false - }, - { - "field": "libpath", - "resolve": true, - "relative": false - } - ], - "confs": [ - { - "task": "build", - "os": "linux", - "blas": "", - "wasm": false, - "src": [ - "./src/zgemv.c", - "./src/zgemv_ndarray.c" - ], - "include": [ - "./include" - ], - "libraries": [], - "libpath": [], - "dependencies": [ - "@stdlib/blas/base/shared", - "@stdlib/blas/base/xerbla", - "@stdlib/blas/base/zscal", - "@stdlib/blas/ext/base/zfill", - "@stdlib/strided/base/stride2offset", - "@stdlib/ndarray/base/assert/is-row-major", - "@stdlib/complex/float64/ctor", - "@stdlib/complex/float64/base/mul", - "@stdlib/complex/float64/base/add", - "@stdlib/complex/float64/conj", - "@stdlib/complex/float64/base/assert/is-equal", - "@stdlib/napi/export", - "@stdlib/napi/argv", - "@stdlib/napi/argv-int64", - "@stdlib/napi/argv-int32", - "@stdlib/napi/argv-complex128", - "@stdlib/napi/argv-strided-complex128array", - "@stdlib/napi/argv-strided-complex128array2d" - ] - }, - { - "task": "benchmark", - "os": "linux", - "blas": "", - "wasm": false, - "src": [ - "./src/zgemv.c", - "./src/zgemv_ndarray.c" - ], - "include": [ - "./include" - ], - "libraries": [], - "libpath": [], - "dependencies": [ - "@stdlib/blas/base/shared", - "@stdlib/blas/base/xerbla", - "@stdlib/blas/base/zscal", - "@stdlib/blas/ext/base/zfill", - "@stdlib/strided/base/stride2offset", - "@stdlib/ndarray/base/assert/is-row-major", - "@stdlib/complex/float64/ctor", - "@stdlib/complex/float64/base/mul", - "@stdlib/complex/float64/base/add", - "@stdlib/complex/float64/conj", - "@stdlib/complex/float64/base/assert/is-equal" - ] - }, - { - "task": "examples", - "os": "linux", - "blas": "", - "wasm": false, - "src": [ - "./src/zgemv.c", - "./src/zgemv_ndarray.c" - ], - "include": [ - "./include" - ], - "libraries": [], - "libpath": [], - "dependencies": [ - "@stdlib/blas/base/shared", - "@stdlib/blas/base/xerbla", - "@stdlib/blas/base/zscal", - "@stdlib/blas/ext/base/zfill", - "@stdlib/strided/base/stride2offset", - "@stdlib/ndarray/base/assert/is-row-major", - "@stdlib/complex/float64/ctor", - "@stdlib/complex/float64/base/mul", - "@stdlib/complex/float64/base/add", - "@stdlib/complex/float64/conj", - "@stdlib/complex/float64/base/assert/is-equal" - ] - }, - { - "task": "build", - "os": "linux", - "blas": "openblas", - "wasm": false, - "src": [ - "./src/zgemv_cblas.c", - "./src/zgemv_ndarray.c" - ], - "include": [ - "./include" - ], - "libraries": [ - "-lopenblas", - "-lpthread" - ], - "libpath": [], - "dependencies": [ - "@stdlib/blas/base/shared", - "@stdlib/blas/base/xerbla", - "@stdlib/blas/base/zscal", - "@stdlib/blas/ext/base/zfill", - "@stdlib/strided/base/stride2offset", - "@stdlib/ndarray/base/assert/is-row-major", - "@stdlib/complex/float64/ctor", - "@stdlib/complex/float64/base/mul", - "@stdlib/complex/float64/base/add", - "@stdlib/complex/float64/conj", - "@stdlib/complex/float64/base/assert/is-equal", - "@stdlib/napi/export", - "@stdlib/napi/argv", - "@stdlib/napi/argv-int64", - "@stdlib/napi/argv-int32", - "@stdlib/napi/argv-complex128", - "@stdlib/napi/argv-strided-complex128array", - "@stdlib/napi/argv-strided-complex128array2d" - ] - }, - { - "task": "benchmark", - "os": "linux", - "blas": "openblas", - "wasm": false, - "src": [ - "./src/zgemv_cblas.c", - "./src/zgemv_ndarray.c" - ], - "include": [ - "./include" - ], - "libraries": [ - "-lopenblas", - "-lpthread" - ], - "libpath": [], - "dependencies": [ - "@stdlib/blas/base/shared", - "@stdlib/blas/base/xerbla", - "@stdlib/blas/base/zscal", - "@stdlib/blas/ext/base/zfill", - "@stdlib/strided/base/stride2offset", - "@stdlib/ndarray/base/assert/is-row-major", - "@stdlib/complex/float64/ctor", - "@stdlib/complex/float64/base/mul", - "@stdlib/complex/float64/base/add", - "@stdlib/complex/float64/conj", - "@stdlib/complex/float64/base/assert/is-equal" - ] - }, - { - "task": "examples", - "os": "linux", - "blas": "openblas", - "wasm": false, - "src": [ - "./src/zgemv_cblas.c", - "./src/zgemv_ndarray.c" - ], - "include": [ - "./include" - ], - "libraries": [ - "-lopenblas", - "-lpthread" - ], - "libpath": [], - "dependencies": [ - "@stdlib/blas/base/shared", - "@stdlib/blas/base/xerbla", - "@stdlib/blas/base/zscal", - "@stdlib/blas/ext/base/zfill", - "@stdlib/strided/base/stride2offset", - "@stdlib/ndarray/base/assert/is-row-major", - "@stdlib/complex/float64/ctor", - "@stdlib/complex/float64/base/mul", - "@stdlib/complex/float64/base/add", - "@stdlib/complex/float64/conj", - "@stdlib/complex/float64/base/assert/is-equal" - ] - }, - { - "task": "build", - "os": "mac", - "blas": "", - "wasm": false, - "src": [ - "./src/zgemv.c", - "./src/zgemv_ndarray.c" - ], - "include": [ - "./include" - ], - "libraries": [], - "libpath": [], - "dependencies": [ - "@stdlib/blas/base/shared", - "@stdlib/blas/base/xerbla", - "@stdlib/blas/base/zscal", - "@stdlib/blas/ext/base/zfill", - "@stdlib/strided/base/stride2offset", - "@stdlib/ndarray/base/assert/is-row-major", - "@stdlib/complex/float64/ctor", - "@stdlib/complex/float64/base/mul", - "@stdlib/complex/float64/base/add", - "@stdlib/complex/float64/conj", - "@stdlib/complex/float64/base/assert/is-equal", - "@stdlib/napi/export", - "@stdlib/napi/argv", - "@stdlib/napi/argv-int64", - "@stdlib/napi/argv-int32", - "@stdlib/napi/argv-complex128", - "@stdlib/napi/argv-strided-complex128array", - "@stdlib/napi/argv-strided-complex128array2d" - ] - }, - { - "task": "benchmark", - "os": "mac", - "blas": "", - "wasm": false, - "src": [ - "./src/zgemv.c", - "./src/zgemv_ndarray.c" - ], - "include": [ - "./include" - ], - "libraries": [], - "libpath": [], - "dependencies": [ - "@stdlib/blas/base/shared", - "@stdlib/blas/base/xerbla", - "@stdlib/blas/base/zscal", - "@stdlib/blas/ext/base/zfill", - "@stdlib/strided/base/stride2offset", - "@stdlib/ndarray/base/assert/is-row-major", - "@stdlib/complex/float64/ctor", - "@stdlib/complex/float64/base/mul", - "@stdlib/complex/float64/base/add", - "@stdlib/complex/float64/conj", - "@stdlib/complex/float64/base/assert/is-equal" - ] - }, - { - "task": "examples", - "os": "mac", - "blas": "", - "wasm": false, - "src": [ - "./src/zgemv.c", - "./src/zgemv_ndarray.c" - ], - "include": [ - "./include" - ], - "libraries": [], - "libpath": [], - "dependencies": [ - "@stdlib/blas/base/shared", - "@stdlib/blas/base/xerbla", - "@stdlib/blas/base/zscal", - "@stdlib/blas/ext/base/zfill", - "@stdlib/strided/base/stride2offset", - "@stdlib/ndarray/base/assert/is-row-major", - "@stdlib/complex/float64/ctor", - "@stdlib/complex/float64/base/mul", - "@stdlib/complex/float64/base/add", - "@stdlib/complex/float64/conj", - "@stdlib/complex/float64/base/assert/is-equal" - ] - }, - { - "task": "build", - "os": "mac", - "blas": "apple_accelerate_framework", - "wasm": false, - "src": [ - "./src/zgemv_cblas.c", - "./src/zgemv_ndarray.c" - ], - "include": [ - "./include" - ], - "libraries": [ - "-lblas" - ], - "libpath": [], - "dependencies": [ - "@stdlib/blas/base/shared", - "@stdlib/blas/base/xerbla", - "@stdlib/blas/base/zscal", - "@stdlib/blas/ext/base/zfill", - "@stdlib/strided/base/stride2offset", - "@stdlib/ndarray/base/assert/is-row-major", - "@stdlib/complex/float64/ctor", - "@stdlib/complex/float64/base/mul", - "@stdlib/complex/float64/base/add", - "@stdlib/complex/float64/conj", - "@stdlib/complex/float64/base/assert/is-equal", - "@stdlib/napi/export", - "@stdlib/napi/argv", - "@stdlib/napi/argv-int64", - "@stdlib/napi/argv-int32", - "@stdlib/napi/argv-double", - "@stdlib/napi/argv-strided-float64array", - "@stdlib/napi/argv-strided-float64array2d" - ] - }, - { - "task": "benchmark", - "os": "mac", - "blas": "apple_accelerate_framework", - "wasm": false, - "src": [ - "./src/zgemv_cblas.c", - "./src/zgemv_ndarray.c" - ], - "include": [ - "./include" - ], - "libraries": [ - "-lblas" - ], - "libpath": [], - "dependencies": [ - "@stdlib/blas/base/shared", - "@stdlib/blas/base/xerbla", - "@stdlib/blas/base/zscal", - "@stdlib/blas/ext/base/zfill", - "@stdlib/strided/base/stride2offset", - "@stdlib/ndarray/base/assert/is-row-major", - "@stdlib/complex/float64/ctor", - "@stdlib/complex/float64/base/mul", - "@stdlib/complex/float64/base/add", - "@stdlib/complex/float64/conj", - "@stdlib/complex/float64/base/assert/is-equal" - ] - }, - { - "task": "examples", - "os": "mac", - "blas": "apple_accelerate_framework", - "wasm": false, - "src": [ - "./src/zgemv_cblas.c", - "./src/zgemv_ndarray.c" - ], - "include": [ - "./include" - ], - "libraries": [ - "-lblas" - ], - "libpath": [], - "dependencies": [ - "@stdlib/blas/base/shared", - "@stdlib/blas/base/xerbla", - "@stdlib/blas/base/zscal", - "@stdlib/blas/ext/base/zfill", - "@stdlib/strided/base/stride2offset", - "@stdlib/ndarray/base/assert/is-row-major", - "@stdlib/complex/float64/ctor", - "@stdlib/complex/float64/base/mul", - "@stdlib/complex/float64/base/add", - "@stdlib/complex/float64/conj", - "@stdlib/complex/float64/base/assert/is-equal" - ] - }, - { - "task": "build", - "os": "mac", - "blas": "openblas", - "wasm": false, - "src": [ - "./src/zgemv_cblas.c", - "./src/zgemv_ndarray.c" - ], - "include": [ - "./include" - ], - "libraries": [ - "-lopenblas", - "-lpthread" - ], - "libpath": [], - "dependencies": [ - "@stdlib/blas/base/shared", - "@stdlib/blas/base/xerbla", - "@stdlib/blas/base/zscal", - "@stdlib/blas/ext/base/zfill", - "@stdlib/strided/base/stride2offset", - "@stdlib/ndarray/base/assert/is-row-major", - "@stdlib/complex/float64/ctor", - "@stdlib/complex/float64/base/mul", - "@stdlib/complex/float64/base/add", - "@stdlib/complex/float64/conj", - "@stdlib/complex/float64/base/assert/is-equal", - "@stdlib/napi/export", - "@stdlib/napi/argv", - "@stdlib/napi/argv-int64", - "@stdlib/napi/argv-int32", - "@stdlib/napi/argv-complex128", - "@stdlib/napi/argv-strided-complex128array", - "@stdlib/napi/argv-strided-complex128array2d" - ] - }, - { - "task": "benchmark", - "os": "mac", - "blas": "openblas", - "wasm": false, - "src": [ - "./src/zgemv_cblas.c", - "./src/zgemv_ndarray.c" - ], - "include": [ - "./include" - ], - "libraries": [ - "-lopenblas", - "-lpthread" - ], - "libpath": [], - "dependencies": [ - "@stdlib/blas/base/shared", - "@stdlib/blas/base/xerbla", - "@stdlib/blas/base/zscal", - "@stdlib/blas/ext/base/zfill", - "@stdlib/strided/base/stride2offset", - "@stdlib/ndarray/base/assert/is-row-major", - "@stdlib/complex/float64/ctor", - "@stdlib/complex/float64/base/mul", - "@stdlib/complex/float64/base/add", - "@stdlib/complex/float64/conj", - "@stdlib/complex/float64/base/assert/is-equal" - ] - }, - { - "task": "examples", - "os": "mac", - "blas": "openblas", - "wasm": false, - "src": [ - "./src/zgemv_cblas.c", - "./src/zgemv_ndarray.c" - ], - "include": [ - "./include" - ], - "libraries": [ - "-lopenblas", - "-lpthread" - ], - "libpath": [], - "dependencies": [ - "@stdlib/blas/base/shared", - "@stdlib/blas/base/xerbla", - "@stdlib/blas/base/zscal", - "@stdlib/blas/ext/base/zfill", - "@stdlib/strided/base/stride2offset", - "@stdlib/ndarray/base/assert/is-row-major", - "@stdlib/complex/float64/ctor", - "@stdlib/complex/float64/base/mul", - "@stdlib/complex/float64/base/add", - "@stdlib/complex/float64/conj", - "@stdlib/complex/float64/base/assert/is-equal" - ] - }, - { - "task": "build", - "os": "win", - "blas": "", - "wasm": false, - "src": [ - "./src/zgemv.c", - "./src/zgemv_ndarray.c" - ], - "include": [ - "./include" - ], - "libraries": [], - "libpath": [], - "dependencies": [ - "@stdlib/blas/base/shared", - "@stdlib/blas/base/xerbla", - "@stdlib/blas/base/zscal", - "@stdlib/blas/ext/base/zfill", - "@stdlib/strided/base/stride2offset", - "@stdlib/ndarray/base/assert/is-row-major", - "@stdlib/complex/float64/ctor", - "@stdlib/complex/float64/base/mul", - "@stdlib/complex/float64/base/add", - "@stdlib/complex/float64/conj", - "@stdlib/complex/float64/base/assert/is-equal", - "@stdlib/napi/export", - "@stdlib/napi/argv", - "@stdlib/napi/argv-int64", - "@stdlib/napi/argv-int32", - "@stdlib/napi/argv-complex128", - "@stdlib/napi/argv-strided-complex128array", - "@stdlib/napi/argv-strided-complex128array2d" - ] - }, - { - "task": "benchmark", - "os": "win", - "blas": "", - "wasm": false, - "src": [ - "./src/zgemv.c", - "./src/zgemv_ndarray.c" - ], - "include": [ - "./include" - ], - "libraries": [], - "libpath": [], - "dependencies": [ - "@stdlib/blas/base/shared", - "@stdlib/blas/base/xerbla", - "@stdlib/blas/base/zscal", - "@stdlib/blas/ext/base/zfill", - "@stdlib/strided/base/stride2offset", - "@stdlib/ndarray/base/assert/is-row-major", - "@stdlib/complex/float64/ctor", - "@stdlib/complex/float64/base/mul", - "@stdlib/complex/float64/base/add", - "@stdlib/complex/float64/conj", - "@stdlib/complex/float64/base/assert/is-equal" - ] - }, - { - "task": "examples", - "os": "win", - "blas": "", - "wasm": false, - "src": [ - "./src/zgemv.c", - "./src/zgemv_ndarray.c" - ], - "include": [ - "./include" - ], - "libraries": [], - "libpath": [], - "dependencies": [ - "@stdlib/blas/base/shared", - "@stdlib/blas/base/xerbla", - "@stdlib/blas/base/zscal", - "@stdlib/blas/ext/base/zfill", - "@stdlib/strided/base/stride2offset", - "@stdlib/ndarray/base/assert/is-row-major", - "@stdlib/complex/float64/ctor", - "@stdlib/complex/float64/base/mul", - "@stdlib/complex/float64/base/add", - "@stdlib/complex/float64/conj", - "@stdlib/complex/float64/base/assert/is-equal" - ] - }, - { - "task": "build", - "os": "", - "blas": "", - "wasm": true, - "src": [ - "./src/zgemv.c", - "./src/zgemv_ndarray.c" - ], - "include": [ - "./include" - ], - "libraries": [], - "libpath": [], - "dependencies": [ - "@stdlib/blas/base/shared", - "@stdlib/blas/base/xerbla", - "@stdlib/blas/base/zscal", - "@stdlib/blas/ext/base/zfill", - "@stdlib/strided/base/stride2offset", - "@stdlib/ndarray/base/assert/is-row-major", - "@stdlib/complex/float64/ctor", - "@stdlib/complex/float64/base/mul", - "@stdlib/complex/float64/base/add", - "@stdlib/complex/float64/conj", - "@stdlib/complex/float64/base/assert/is-equal" - ] - } - ] -} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/package.json b/lib/node_modules/@stdlib/blas/base/zgemv/package.json index 1f9b9d85c7e5..fe1aba990892 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/package.json +++ b/lib/node_modules/@stdlib/blas/base/zgemv/package.json @@ -15,14 +15,11 @@ ], "main": "./lib", "browser": "./lib/main.js", - "gypfile": true, "directories": { "benchmark": "./benchmark", "doc": "./docs", "example": "./examples", - "include": "./include", "lib": "./lib", - "src": "./src", "test": "./test" }, "types": "./docs/types", @@ -60,7 +57,6 @@ "blas", "level 2", "zgemv", - "gemv", "linear", "algebra", "subroutines", @@ -68,12 +64,6 @@ "ndarray", "complex", "complex128", - "complex64", - "complex-numbers", - "double", - "dbl", - "float64", - "float64array", "complex128array" ] } diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/src/Makefile b/lib/node_modules/@stdlib/blas/base/zgemv/src/Makefile deleted file mode 100644 index 2caf905cedbe..000000000000 --- a/lib/node_modules/@stdlib/blas/base/zgemv/src/Makefile +++ /dev/null @@ -1,70 +0,0 @@ -#/ -# @license Apache-2.0 -# -# Copyright (c) 2026 The Stdlib Authors. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -#/ - -# VARIABLES # - -ifndef VERBOSE - QUIET := @ -else - QUIET := -endif - -# Determine the OS ([1][1], [2][2]). -# -# [1]: https://en.wikipedia.org/wiki/Uname#Examples -# [2]: http://stackoverflow.com/a/27776822/2225624 -OS ?= $(shell uname) -ifneq (, $(findstring MINGW,$(OS))) - OS := WINNT -else -ifneq (, $(findstring MSYS,$(OS))) - OS := WINNT -else -ifneq (, $(findstring CYGWIN,$(OS))) - OS := WINNT -else -ifneq (, $(findstring Windows_NT,$(OS))) - OS := WINNT -endif -endif -endif -endif - - -# RULES # - -#/ -# Removes generated files for building an add-on. -# -# @example -# make clean-addon -#/ -clean-addon: - $(QUIET) -rm -f *.o *.node - -.PHONY: clean-addon - -#/ -# Removes generated files. -# -# @example -# make clean -#/ -clean: clean-addon - -.PHONY: clean diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/src/addon.c b/lib/node_modules/@stdlib/blas/base/zgemv/src/addon.c deleted file mode 100644 index b6aa741b25d3..000000000000 --- a/lib/node_modules/@stdlib/blas/base/zgemv/src/addon.c +++ /dev/null @@ -1,125 +0,0 @@ -/** -* @license Apache-2.0 -* -* Copyright (c) 2026 The Stdlib Authors. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ - -#include "stdlib/blas/base/zgemv.h" -#include "stdlib/blas/base/shared.h" -#include "stdlib/complex/float64/ctor.h" -#include "stdlib/napi/export.h" -#include "stdlib/napi/argv.h" -#include "stdlib/napi/argv_int64.h" -#include "stdlib/napi/argv_int32.h" -#include "stdlib/napi/argv_complex128.h" -#include "stdlib/napi/argv_strided_complex128array.h" -#include "stdlib/napi/argv_strided_complex128array2d.h" -#include - -/** -* Receives JavaScript callback invocation data. -* -* @param env environment under which the function is invoked -* @param info callback data -* @return Node-API value -*/ -static napi_value addon( napi_env env, napi_callback_info info ) { - CBLAS_INT xlen; - CBLAS_INT ylen; - CBLAS_INT sa1; - CBLAS_INT sa2; - - STDLIB_NAPI_ARGV( env, info, argv, argc, 12 ); - - STDLIB_NAPI_ARGV_INT32( env, layout, argv, 0 ); - STDLIB_NAPI_ARGV_INT32( env, trans, argv, 1 ); - - STDLIB_NAPI_ARGV_INT64( env, M, argv, 2 ); - STDLIB_NAPI_ARGV_INT64( env, N, argv, 3 ); - STDLIB_NAPI_ARGV_INT64( env, strideX, argv, 8 ); - STDLIB_NAPI_ARGV_INT64( env, strideY, argv, 11 ); - STDLIB_NAPI_ARGV_INT64( env, LDA, argv, 6 ); - - STDLIB_NAPI_ARGV_COMPLEX128( env, alpha, argv, 4 ); - STDLIB_NAPI_ARGV_COMPLEX128( env, beta, argv, 9 ); - - if ( trans == CblasNoTrans ) { - xlen = N; - ylen = M; - } else { - xlen = M; - ylen = N; - } - if ( layout == CblasColMajor ) { - sa1 = 1; - sa2 = LDA; - } else { // layout == CblasRowMajor - sa1 = LDA; - sa2 = 1; - } - STDLIB_NAPI_ARGV_STRIDED_COMPLEX128ARRAY( env, X, xlen, strideX, argv, 7 ); - STDLIB_NAPI_ARGV_STRIDED_COMPLEX128ARRAY( env, Y, ylen, strideY, argv, 10 ); - STDLIB_NAPI_ARGV_STRIDED_COMPLEX128ARRAY2D( env, A, M, N, sa1, sa2, argv, 5 ); - - API_SUFFIX(c_zgemv)( layout, trans, M, N, alpha, A, LDA, X, strideX, beta, Y, strideY ); - - return NULL; -} - -/** -* Receives JavaScript callback invocation data. -* -* @param env environment under which the function is invoked -* @param info callback data -* @return Node-API value -*/ -static napi_value addon_method( napi_env env, napi_callback_info info ) { - CBLAS_INT xlen; - CBLAS_INT ylen; - - STDLIB_NAPI_ARGV( env, info, argv, argc, 15 ); - - STDLIB_NAPI_ARGV_INT32( env, trans, argv, 0 ); - - STDLIB_NAPI_ARGV_INT64( env, M, argv, 1 ); - STDLIB_NAPI_ARGV_INT64( env, N, argv, 2 ); - STDLIB_NAPI_ARGV_INT64( env, strideX, argv, 9 ); - STDLIB_NAPI_ARGV_INT64( env, offsetX, argv, 10 ); - STDLIB_NAPI_ARGV_INT64( env, strideY, argv, 13 ); - STDLIB_NAPI_ARGV_INT64( env, offsetY, argv, 14 ); - STDLIB_NAPI_ARGV_INT64( env, strideA1, argv, 5 ); - STDLIB_NAPI_ARGV_INT64( env, strideA2, argv, 6 ); - STDLIB_NAPI_ARGV_INT64( env, offsetA, argv, 7 ); - - STDLIB_NAPI_ARGV_COMPLEX128( env, alpha, argv, 3 ); - STDLIB_NAPI_ARGV_COMPLEX128( env, beta, argv, 11 ); - - if ( trans == CblasNoTrans ) { - xlen = N; - ylen = M; - } else { - xlen = M; - ylen = N; - } - STDLIB_NAPI_ARGV_STRIDED_COMPLEX128ARRAY( env, X, xlen, strideX, argv, 8 ); - STDLIB_NAPI_ARGV_STRIDED_COMPLEX128ARRAY( env, Y, ylen, strideY, argv, 12 ); - STDLIB_NAPI_ARGV_STRIDED_COMPLEX128ARRAY2D( env, A, M, N, strideA1, strideA2, argv, 4 ); - - API_SUFFIX(c_zgemv_ndarray)( trans, M, N, alpha, A, strideA1, strideA2, offsetA, X, strideX, offsetX, beta, Y, strideY, offsetY ); - - return NULL; -} - -STDLIB_NAPI_MODULE_EXPORT_FCN_WITH_METHOD( addon, "ndarray", addon_method ) diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv.c b/lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv.c deleted file mode 100644 index 23ad8213bfd5..000000000000 --- a/lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv.c +++ /dev/null @@ -1,114 +0,0 @@ -/** -* @license Apache-2.0 -* -* Copyright (c) 2026 The Stdlib Authors. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ - -#include "stdlib/blas/base/zgemv.h" -#include "stdlib/blas/base/shared.h" -#include "stdlib/blas/base/xerbla.h" -#include "stdlib/complex/float64/ctor.h" -#include "stdlib/complex/float64/base/assert/is_equal.h" -#include "stdlib/strided/base/stride2offset.h" - -/** -* Performs one of the matrix-vector operations `Y = α*A*X + β*Y`, `Y = α*A^T*X + β*Y`, or `Y = α*A^H*X + β*Y`, where `α` and `β` are scalars, `X` and `Y` are vectors, and `A` is an `M` by `N` matrix. -* -* @param layout storage layout -* @param trans specifies whether `A` should be transposed, conjugate-transposed, or not transposed -* @param M number of rows in the matrix `A` -* @param N number of columns in the matrix `A` -* @param alpha scalar constant -* @param A input matrix -* @param LDA stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) -* @param X first input vector -* @param strideX `X` stride length -* @param beta scalar constant -* @param Y second input vector -* @param strideY `Y` stride length -*/ -void API_SUFFIX(c_zgemv)( const CBLAS_LAYOUT layout, const CBLAS_TRANSPOSE trans, const CBLAS_INT M, const CBLAS_INT N, const stdlib_complex128_t alpha, const void *A, const CBLAS_INT LDA, const void *X, const CBLAS_INT strideX, const stdlib_complex128_t beta, void *Y, const CBLAS_INT strideY ) { - CBLAS_INT vala; - CBLAS_INT xlen; - CBLAS_INT ylen; - CBLAS_INT sa1; - CBLAS_INT sa2; - CBLAS_INT ox; - CBLAS_INT oy; - CBLAS_INT v; - - // Perform input argument validation... - if ( layout != CblasRowMajor && layout != CblasColMajor ) { - c_xerbla( 1, "c_zgemv", "Error: invalid argument. First argument must be a valid storage layout. Value: `%d`.", layout ); - return; - } - if ( trans != CblasTrans && trans != CblasConjTrans && trans != CblasNoTrans ) { - c_xerbla( 2, "c_zgemv", "Error: invalid argument. Second argument must be a valid transpose operation. Value: `%d`.", trans ); - return; - } - if ( M < 0 ) { - c_xerbla( 3, "c_zgemv", "Error: invalid argument. Third argument must be a nonnegative integer. Value: `%d`.", M ); - return; - } - if ( N < 0 ) { - c_xerbla( 4, "c_zgemv", "Error: invalid argument. Fourth argument must be a nonnegative integer. Value: `%d`.", N ); - return; - } - if ( strideX == 0 ) { - c_xerbla( 9, "c_zgemv", "Error: invalid argument. Ninth argument must be nonzero. Value: `%d`.", strideX ); - return; - } - if ( strideY == 0 ) { - c_xerbla( 12, "c_zgemv", "Error: invalid argument. Twelfth argument must be nonzero. Value: `%d`.", strideY ); - return; - } - if ( layout == CblasColMajor ) { - v = M; - } else { - v = N; - } - // max(1, v) - if ( v < 1 ) { - vala = 1; - } else { - vala = v; - } - if ( LDA < v ) { - c_xerbla( 10, "c_zgemv", "Error: invalid argument. Seventh argument must be greater than or equal to max(1,%d). Value: `%d`.", vala, LDA ); - return; - } - // Check if we can early return... - if ( M == 0 || N == 0 || ( stdlib_base_complex128_is_equal( alpha, stdlib_complex128( 0.0, 0.0 ) ) && stdlib_base_complex128_is_equal( beta, stdlib_complex128( 1.0, 0.0 ) ) ) ) { - return; - } - if ( trans == CblasNoTrans ) { - xlen = N; - ylen = M; - } else { - xlen = M; - ylen = N; - } - if ( layout == CblasColMajor ) { - sa1 = 1; - sa2 = LDA; - } else { // layout == CblasRowMajor - sa1 = LDA; - sa2 = 1; - } - ox = stdlib_strided_stride2offset( xlen, strideX ); - oy = stdlib_strided_stride2offset( ylen, strideY ); - API_SUFFIX(c_zgemv_ndarray)( trans, M, N, alpha, A, sa1, sa2, 0, X, strideX, ox, beta, Y, strideY, oy ); - return; -} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv_cblas.c b/lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv_cblas.c deleted file mode 100644 index bb283ad8c444..000000000000 --- a/lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv_cblas.c +++ /dev/null @@ -1,41 +0,0 @@ -/** -* @license Apache-2.0 -* -* Copyright (c) 2026 The Stdlib Authors. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ - -#include "stdlib/blas/base/zgemv.h" -#include "stdlib/blas/base/zgemv_cblas.h" -#include "stdlib/blas/base/shared.h" - -/** -* Performs one of the matrix-vector operations `Y = α*A*X + β*Y`, `Y = α*A^T*X + β*Y`, or `Y = α*A^H*X + β*Y`, where `α` and `β` are scalars, `X` and `Y` are vectors, and `A` is an `M` by `N` matrix. -* -* @param layout storage layout -* @param trans specifies whether `A` should be transposed, conjugate-transposed, or not transposed -* @param M number of rows in the matrix `A` -* @param N number of columns in the matrix `A` -* @param alpha scalar constant -* @param A input matrix -* @param LDA stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`) -* @param X first input vector -* @param strideX `X` stride length -* @param beta scalar constant -* @param Y second input vector -* @param strideY `Y` stride length -*/ -void API_SUFFIX(c_zgemv)( const CBLAS_LAYOUT layout, const CBLAS_TRANSPOSE trans, const CBLAS_INT M, const CBLAS_INT N, const stdlib_complex128_t alpha, const void *A, const CBLAS_INT LDA, const void *X, const CBLAS_INT strideX, const stdlib_complex128_t beta, void *Y, const CBLAS_INT strideY ) { - API_SUFFIX(cblas_zgemv)( layout, trans, M, N, &alpha, A, LDA, X, strideX, &beta, Y, strideY ); -} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv_ndarray.c b/lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv_ndarray.c deleted file mode 100644 index 32503a83c610..000000000000 --- a/lib/node_modules/@stdlib/blas/base/zgemv/src/zgemv_ndarray.c +++ /dev/null @@ -1,189 +0,0 @@ -/** -* @license Apache-2.0 -* -* Copyright (c) 2026 The Stdlib Authors. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ - -#include "stdlib/blas/base/zgemv.h" -#include "stdlib/blas/base/shared.h" -#include "stdlib/blas/base/xerbla.h" -#include "stdlib/blas/base/zscal.h" -#include "stdlib/blas/ext/base/zfill.h" -#include "stdlib/complex/float64/ctor.h" -#include "stdlib/complex/float64/base/mul.h" -#include "stdlib/complex/float64/base/add.h" -#include "stdlib/complex/float64/conj.h" -#include "stdlib/complex/float64/base/assert/is_equal.h" -#include "stdlib/ndarray/base/assert/is_row_major.h" -#include - -/** -* Performs one of the matrix-vector operations `Y = α*A*X + β*Y`, `Y = α*A^T*X + β*Y`, or `Y = α*A^H*X + β*Y`, using alternative indexing semantics and where `α` and `β` are scalars, `X` and `Y` are vectors, and `A` is an `M` by `N` matrix. -* -* @param trans specifies whether `A` should be transposed, conjugate-transposed, or not transposed -* @param M number of rows in the matrix `A` -* @param N number of columns in the matrix `A` -* @param alpha scalar constant -* @param A input matrix -* @param strideA1 stride of the first dimension of `A` -* @param strideA2 stride of the second dimension of `A` -* @param offsetA starting index for `A` -* @param X first input vector -* @param strideX `X` stride length -* @param offsetX starting index for `X` -* @param beta scalar constant -* @param Y second input vector -* @param strideY `Y` stride length -* @param offsetY starting index for `Y` -*/ -void API_SUFFIX(c_zgemv_ndarray)( const CBLAS_TRANSPOSE trans, const CBLAS_INT M, const CBLAS_INT N, const stdlib_complex128_t alpha, const void *A, const CBLAS_INT strideA1, const CBLAS_INT strideA2, const CBLAS_INT offsetA, const void *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, const stdlib_complex128_t beta, void *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY ) { - const stdlib_complex128_t *xp = (stdlib_complex128_t *)X; - stdlib_complex128_t *yp = (stdlib_complex128_t *)Y; - const stdlib_complex128_t *ap = (stdlib_complex128_t *)A; - stdlib_complex128_t zero = stdlib_complex128( 0.0, 0.0 ); - stdlib_complex128_t one = stdlib_complex128( 1.0, 0.0 ); - int64_t sa[ 2 ]; - CBLAS_INT xlen; - CBLAS_INT ylen; - CBLAS_INT da0; - CBLAS_INT da1; - CBLAS_INT ix; - CBLAS_INT iy; - CBLAS_INT ia; - CBLAS_INT i0; - CBLAS_INT i1; - stdlib_complex128_t tmp; - stdlib_complex128_t aval; - bool isrm; - - // Note on variable naming convention: da#, i# where # corresponds to the loop number, with `0` being the innermost loop... - - // Perform input argument validation... - if ( trans != CblasTrans && trans != CblasConjTrans && trans != CblasNoTrans ) { - c_xerbla( 1, "c_zgemv_ndarray", "Error: invalid argument. First argument must be a valid transpose operation. Value: `%d`.", trans ); - return; - } - if ( M < 0 ) { - c_xerbla( 2, "c_zgemv_ndarray", "Error: invalid argument. Second argument must be a nonnegative integer. Value: `%d`.", M ); - return; - } - if ( N < 0 ) { - c_xerbla( 3, "c_zgemv_ndarray", "Error: invalid argument. Third argument must be a nonnegative integer. Value: `%d`.", N ); - return; - } - if ( strideX == 0 ) { - c_xerbla( 10, "c_zgemv_ndarray", "Error: invalid argument. Tenth argument must be nonzero. Value: `%d`.", strideX ); - return; - } - if ( strideY == 0 ) { - c_xerbla( 14, "c_zgemv_ndarray", "Error: invalid argument. Fourteenth argument must be nonzero. Value: `%d`.", strideY ); - return; - } - // Check whether we can avoid computation altogether... - if ( M == 0 || N == 0 || ( stdlib_base_complex128_is_equal( alpha, zero ) && stdlib_base_complex128_is_equal( beta, one ) ) ) { - return; - } - // Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments... - sa[ 0 ] = strideA1; - sa[ 1 ] = strideA2; - isrm = stdlib_ndarray_is_row_major( 2, sa ); - if ( trans == CblasNoTrans ) { - xlen = N; - ylen = M; - } else { - xlen = M; - ylen = N; - } - // Y = beta * Y - if ( stdlib_base_complex128_is_equal( beta, zero ) ) { - API_SUFFIX(stdlib_strided_zfill_ndarray)( ylen, zero, Y, strideY, offsetY ); - } else if ( !stdlib_base_complex128_is_equal( beta, one ) ) { - API_SUFFIX(c_zscal_ndarray)( ylen, beta, Y, strideY, offsetY ); - } - if ( stdlib_base_complex128_is_equal( alpha, zero ) ) { - return; - } - - // Form: Y = α*A*X + Y - if ( - ( !isrm && trans == CblasNoTrans ) || - ( isrm && trans != CblasNoTrans ) - ) { - if ( isrm ) { - // For row-major matrices, the last dimension has the fastest changing index... - da0 = strideA2; // offset increment for innermost loop - da1 = strideA1 - ( ylen*strideA2 ); // offset increment for outermost loop - } else { // isColMajor - // For column-major matrices, the first dimension has the fastest changing index... - da0 = strideA1; // offset increment for innermost loop - da1 = strideA2 - ( ylen*strideA1 ); // offset increment for outermost loop - } - ia = offsetA; - ix = offsetX; - for ( i1 = 0; i1 < xlen; i1++ ) { - tmp = stdlib_base_complex128_mul( alpha, xp[ ix ] ); - if ( !stdlib_base_complex128_is_equal( tmp, zero ) ) { - iy = offsetY; - for ( i0 = 0; i0 < ylen; i0++ ) { - if ( trans == CblasConjTrans ) { - aval = stdlib_complex128_conj( ap[ ia ] ); - } else { - aval = ap[ ia ]; - } - yp[ iy ] = stdlib_base_complex128_add( yp[ iy ], stdlib_base_complex128_mul( aval, tmp ) ); - iy += strideY; - ia += da0; - } - } else { - ia += da0 * ylen; - } - ix += strideX; - ia += da1; - } - return; - } - // Form: Y = α*A^T*X + Y or Y = α*A^H*X + Y - - // ( !isrm && trans != CblasNoTrans ) || ( isrm && trans == CblasNoTrans ) - if ( isrm ) { - // For row-major matrices, the last dimension has the fastest changing index... - da0 = strideA2; // offset increment for innermost loop - da1 = strideA1 - ( xlen*strideA2 ); // offset increment for outermost loop - } else { // isColMajor - // For column-major matrices, the first dimension has the fastest changing index... - da0 = strideA1; // offset increment for innermost loop - da1 = strideA2 - ( xlen*strideA1 ); // offset increment for outermost loop - } - ia = offsetA; - iy = offsetY; - for ( i1 = 0; i1 < ylen; i1++ ) { - tmp = zero; - ix = offsetX; - for ( i0 = 0; i0 < xlen; i0++ ) { - if ( trans == CblasConjTrans ) { - aval = stdlib_complex128_conj( ap[ ia ] ); - } else { - aval = ap[ ia ]; - } - tmp = stdlib_base_complex128_add( tmp, stdlib_base_complex128_mul( aval, xp[ ix ] ) ); - ix += strideX; - ia += da0; - } - yp[ iy ] = stdlib_base_complex128_add( yp[ iy ], stdlib_base_complex128_mul( alpha, tmp ) ); - iy += strideY; - ia += da1; - } - return; -} diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/test.js b/lib/node_modules/@stdlib/blas/base/zgemv/test/test.js index ae878c7d29c2..f1ccea89d1a1 100644 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/test.js +++ b/lib/node_modules/@stdlib/blas/base/zgemv/test/test.js @@ -51,7 +51,7 @@ tape( 'if a native implementation is available, the main export is the native im '@stdlib/utils/try-require': tryRequire }); - t.strictEqual( zgemv, mock, 'returns expected value' ); + t.strictEqual( zgemv, mock, 'returns native implementation' ); t.end(); function tryRequire() { @@ -59,7 +59,7 @@ tape( 'if a native implementation is available, the main export is the native im } function mock() { - // Mock Native Implementation... + // Mock native implementation... } }); @@ -73,7 +73,7 @@ tape( 'if a native implementation is not available, the main export is a JavaScr '@stdlib/utils/try-require': tryRequire }); - t.strictEqual( zgemv, main, 'returns Javascript implementation' ); + t.strictEqual( zgemv, main, 'returns JavaScript implementation' ); t.end(); function tryRequire() { diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/test.ndarray.native.js b/lib/node_modules/@stdlib/blas/base/zgemv/test/test.ndarray.native.js deleted file mode 100644 index b97312c5f79d..000000000000 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/test.ndarray.native.js +++ /dev/null @@ -1,1024 +0,0 @@ -/** -* @license Apache-2.0 -* -* Copyright (c) 2026 The Stdlib Authors. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ - -'use strict'; - -// MODULES // - -var resolve = require( 'path' ).resolve; -var tape = require( 'tape' ); -var isAlmostSameValueComplex128Array = require( '@stdlib/assert/is-almost-same-value-complex128array' ); -var Complex128Array = require( '@stdlib/array/complex128' ); -var Complex128 = require( '@stdlib/complex/float64/ctor' ); -var tryRequire = require( '@stdlib/utils/try-require' ); - - -// VARIABLES // - -var zgemv = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) ); -var opts = { - 'skip': ( zgemv instanceof Error ) -}; - - -// FIXTURES // - -var cap = require( './fixtures/column_major_complex_access_pattern.json' ); -var cnt = require( './fixtures/column_major_nt.json' ); -var ct = require( './fixtures/column_major_t.json' ); -var cct = require( './fixtures/column_major_ct.json' ); -var coa = require( './fixtures/column_major_oa.json' ); -var csa1sa2 = require( './fixtures/column_major_sa1_sa2.json' ); -var csa1nsa2 = require( './fixtures/column_major_sa1n_sa2.json' ); -var csa1sa2n = require( './fixtures/column_major_sa1_sa2n.json' ); -var csa1nsa2n = require( './fixtures/column_major_sa1n_sa2n.json' ); -var cxnyn = require( './fixtures/column_major_xnyn.json' ); -var cxpyn = require( './fixtures/column_major_xpyn.json' ); -var cxnyp = require( './fixtures/column_major_xnyp.json' ); -var cxpyp = require( './fixtures/column_major_xpyp.json' ); -var cx = require( './fixtures/column_major_x_zeros.json' ); -var cxb = require( './fixtures/column_major_x_zeros_beta_one.json' ); -var ca = require( './fixtures/column_major_alpha_zero.json' ); -var rap = require( './fixtures/row_major_complex_access_pattern.json' ); -var rnt = require( './fixtures/row_major_nt.json' ); -var rt = require( './fixtures/row_major_t.json' ); -var rct = require( './fixtures/row_major_ct.json' ); -var roa = require( './fixtures/row_major_oa.json' ); -var rsa1sa2 = require( './fixtures/row_major_sa1_sa2.json' ); -var rsa1nsa2 = require( './fixtures/row_major_sa1n_sa2.json' ); -var rsa1sa2n = require( './fixtures/row_major_sa1_sa2n.json' ); -var rsa1nsa2n = require( './fixtures/row_major_sa1n_sa2n.json' ); -var rxnyn = require( './fixtures/row_major_xnyn.json' ); -var rxpyn = require( './fixtures/row_major_xpyn.json' ); -var rxnyp = require( './fixtures/row_major_xnyp.json' ); -var rxpyp = require( './fixtures/row_major_xpyp.json' ); -var rx = require( './fixtures/row_major_x_zeros.json' ); -var rxb = require( './fixtures/row_major_x_zeros_beta_one.json' ); -var ra = require( './fixtures/row_major_alpha_zero.json' ); - - -// TESTS // - -tape( 'main export is a function', opts, function test( t ) { - t.ok( true, __filename ); - t.strictEqual( typeof zgemv, 'function', 'main export is a function' ); - t.end(); -} ); - -tape( 'the function has an arity of 15', opts, function test( t ) { - t.strictEqual( zgemv.length, 15, 'returns expected value' ); - t.end(); -} ); - -tape( 'the function throws an error if provided an invalid first argument', opts, function test( t ) { - var values; - var data; - var i; - - data = rnt; - - values = [ - 'foo', - 'bar', - 'beep', - 'boop' - ]; - - for ( i = 0; i < values.length; i++ ) { - t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] ); - } - t.end(); - - function badValue( value ) { - return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( value, data.M, data.N, alpha, new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), data.strideX, data.offsetX, beta, new Complex128Array( data.y ), data.strideY, data.offsetY ); - }; - } -} ); - -tape( 'the function throws an error if provided an invalid second argument', opts, function test( t ) { - var values; - var data; - var i; - - data = rnt; - - values = [ - -1, - -2, - -3 - ]; - - for ( i = 0; i < values.length; i++ ) { - t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); - } - t.end(); - - function badValue( value ) { - return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( data.trans, value, data.N, alpha, new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), data.strideX, data.offsetX, beta, new Complex128Array( data.y ), data.strideY, data.offsetY ); - }; - } -} ); - -tape( 'the function throws an error if provided an invalid third argument', opts, function test( t ) { - var values; - var data; - var i; - - data = rnt; - - values = [ - -1, - -2, - -3 - ]; - - for ( i = 0; i < values.length; i++ ) { - t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); - } - t.end(); - - function badValue( value ) { - return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( data.trans, data.M, value, alpha, new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), data.strideX, data.offsetX, beta, new Complex128Array( data.y ), data.strideY, data.offsetY ); - }; - } -} ); - -tape( 'the function throws an error if provided an invalid tenth argument', opts, function test( t ) { - var values; - var data; - var i; - - data = rnt; - - values = [ - 0 - ]; - - for ( i = 0; i < values.length; i++ ) { - t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); - } - t.end(); - - function badValue( value ) { - return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( data.trans, data.M, data.N, alpha, new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), value, data.offsetX, beta, new Complex128Array( data.y ), data.strideY, data.offsetY ); - }; - } -} ); - -tape( 'the function throws an error if provided an invalid fourteenth argument', opts, function test( t ) { - var values; - var data; - var i; - - data = rnt; - - values = [ - 0 - ]; - - for ( i = 0; i < values.length; i++ ) { - t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); - } - t.end(); - - function badValue( value ) { - return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( data.trans, data.M, data.N, alpha, new Complex128Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex128Array( data.x ), data.strideX, data.offsetX, beta, new Complex128Array( data.y ), value, data.offsetY ); - }; - } -} ); - -tape( 'the function performs the matrix-vector operation `y = α*A*x + β*y` (row-major, no-transpose)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rnt; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function performs the matrix-vector operation `y = α*A*x + β*y` (column-major, no-transpose)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = cnt; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function performs the matrix-vector operation `y = α*A^T*x + β*y` (row-major, transpose)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rt; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function performs the matrix-vector operation `y = α*A^T*x + β*y` (column-major, transpose)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = ct; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function performs the matrix-vector operation `y = α*A^H*x + β*y` (row-major, conjugate-transpose)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rct; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function performs the matrix-vector operation `y = α*A^H*x + β*y` (column-major, conjugate-transpose)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = cct; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function returns a reference to the output vector', opts, function test( t ) { - var data; - var out; - var a; - var x; - var y; - - data = rnt; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( out, y, 'same reference' ); - - t.end(); -} ); - -tape( 'if either `M` or `N` is `0`, the function returns the output vector unchanged', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rnt; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y ); - - out = zgemv( data.trans, 0, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - out = zgemv( data.trans, data.M, 0, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'if `α` is `0+0i` and `β` is `1+0i`, the function returns the output vector unchanged (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rnt; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( 0.0, 0.0 ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( 1.0, 0.0 ), y, data.strideY, data.offsetY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'if `α` is `0+0i` and `β` is `1+0i`, the function returns the output vector unchanged (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = cnt; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( 0.0, 0.0 ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( 1.0, 0.0 ), y, data.strideY, data.offsetY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'if `x` contains only zeros and `β` is `1+0i`, the function returns the output vector unchanged (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rxb; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'if `x` contains only zeros and `β` is `1+0i`, the function returns the output vector unchanged (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = cxb; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'if `α` is `0+0i`, the function scales the output vector by `β` (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = ra; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'if `α` is `0+0i`, the function scales the output vector by `β` (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = ca; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'if `x` contains only zeros and `β` is not `1+0i`, the function scales the output vector by `β` (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rx; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'if `x` contains only zeros and `β` is not `1`, the function scales the output vector by `β` (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = cx; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports specifying the strides of the first and second dimensions of `A` (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rsa1sa2; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports specifying the strides of the first and second dimensions of `A` (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = csa1sa2; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports a negative stride for the first dimension of `A` (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rsa1nsa2; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports a negative stride for the first dimension of `A` (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = csa1nsa2; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports a negative stride for the second matrix dimension (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rsa1sa2n; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports a negative stride for the second matrix dimension (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = csa1sa2n; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports negative strides for both matrix dimensions (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rsa1nsa2n; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports negative strides for both matrix dimensions (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = csa1nsa2n; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports specifying an offset for `A` (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = roa; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports specifying an offset for `A` (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = coa; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports specifying `x` and `y` strides (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rxpyp; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports specifying `x` and `y` strides (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = cxpyp; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports specifying a negative `x` stride (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rxnyp; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports specifying a negative `x` stride (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = cxnyp; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports specifying a negative `y` stride (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rxpyn; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports specifying a negative `y` stride (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = cxpyn; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports specifying negative strides for `x` and `y` (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rxnyn; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports specifying negative strides for `x` and `y` (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = cxnyn; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports complex access patterns (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rap; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports complex access patterns (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = cap; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.strideA1, data.strideA2, data.offsetA, x, data.strideX, data.offsetX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY, data.offsetY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 10 ), true, 'returns expected value' ); - - t.end(); -} ); diff --git a/lib/node_modules/@stdlib/blas/base/zgemv/test/test.zgemv.native.js b/lib/node_modules/@stdlib/blas/base/zgemv/test/test.zgemv.native.js deleted file mode 100644 index 5c5dd168a17d..000000000000 --- a/lib/node_modules/@stdlib/blas/base/zgemv/test/test.zgemv.native.js +++ /dev/null @@ -1,784 +0,0 @@ -/** -* @license Apache-2.0 -* -* Copyright (c) 2026 The Stdlib Authors. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ - -'use strict'; - -// MODULES // - -var resolve = require( 'path' ).resolve; -var tape = require( 'tape' ); -var isAlmostSameValueComplex128Array = require( '@stdlib/assert/is-almost-same-value-complex128array' ); -var Complex128Array = require( '@stdlib/array/complex128' ); -var Complex128 = require( '@stdlib/complex/float64/ctor' ); -var tryRequire = require( '@stdlib/utils/try-require' ); - - -// VARIABLES // - -var zgemv = tryRequire( resolve( __dirname, './../lib/zgemv.native.js' ) ); -var opts = { - 'skip': ( zgemv instanceof Error ) -}; - - -// FIXTURES // - -var cnt = require( './fixtures/column_major_nt.json' ); -var ct = require( './fixtures/column_major_t.json' ); -var cct = require( './fixtures/column_major_ct.json' ); -var cxnyn = require( './fixtures/column_major_xnyn.json' ); -var cxpyn = require( './fixtures/column_major_xpyn.json' ); -var cxnyp = require( './fixtures/column_major_xnyp.json' ); -var cxpyp = require( './fixtures/column_major_xpyp.json' ); -var cx = require( './fixtures/column_major_x_zeros.json' ); -var cxb = require( './fixtures/column_major_x_zeros_beta_one.json' ); -var ca = require( './fixtures/column_major_alpha_zero.json' ); -var rnt = require( './fixtures/row_major_nt.json' ); -var rt = require( './fixtures/row_major_t.json' ); -var rct = require( './fixtures/row_major_ct.json' ); -var rxnyn = require( './fixtures/row_major_xnyn.json' ); -var rxpyn = require( './fixtures/row_major_xpyn.json' ); -var rxnyp = require( './fixtures/row_major_xnyp.json' ); -var rxpyp = require( './fixtures/row_major_xpyp.json' ); -var rx = require( './fixtures/row_major_x_zeros.json' ); -var rxb = require( './fixtures/row_major_x_zeros_beta_one.json' ); -var ra = require( './fixtures/row_major_alpha_zero.json' ); - - -// TESTS // - -tape( 'main export is a function', opts, function test( t ) { - t.ok( true, __filename ); - t.strictEqual( typeof zgemv, 'function', 'main export is a function' ); - t.end(); -} ); - -tape( 'the function has an arity of 12', opts, function test( t ) { - t.strictEqual( zgemv.length, 12, 'returns expected value' ); - t.end(); -} ); - -tape( 'the function throws an error if provided an invalid first argument', opts, function test( t ) { - var values; - var data; - var i; - - data = rnt; - - values = [ - 'foo', - 'bar', - 'beep', - 'boop' - ]; - - for ( i = 0; i < values.length; i++ ) { - t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] ); - } - t.end(); - - function badValue( value ) { - return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( value, data.trans, data.M, data.N, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, beta, new Complex128Array( data.y ), data.strideY ); - }; - } -} ); - -tape( 'the function throws an error if provided an invalid second argument', opts, function test( t ) { - var values; - var data; - var i; - - data = rnt; - - values = [ - 'foo', - 'bar', - 'beep', - 'boop' - ]; - - for ( i = 0; i < values.length; i++ ) { - t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] ); - } - t.end(); - - function badValue( value ) { - return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( data.order, value, data.M, data.N, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, beta, new Complex128Array( data.y ), data.strideY ); - }; - } -} ); - -tape( 'the function throws an error if provided an invalid third argument', opts, function test( t ) { - var values; - var data; - var i; - - data = rnt; - - values = [ - -1, - -2, - -3 - ]; - - for ( i = 0; i < values.length; i++ ) { - t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); - } - t.end(); - - function badValue( value ) { - return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( data.order, data.trans, value, data.N, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, beta, new Complex128Array( data.y ), data.strideY ); - }; - } -} ); - -tape( 'the function throws an error if provided an invalid fourth argument', opts, function test( t ) { - var values; - var data; - var i; - - data = rnt; - - values = [ - -1, - -2, - -3 - ]; - - for ( i = 0; i < values.length; i++ ) { - t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); - } - t.end(); - - function badValue( value ) { - return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( data.order, data.trans, data.M, value, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, beta, new Complex128Array( data.y ), data.strideY ); - }; - } -} ); - -tape( 'the function throws an error if provided an invalid ninth argument', opts, function test( t ) { - var values; - var data; - var i; - - data = rnt; - - values = [ - 0 - ]; - - for ( i = 0; i < values.length; i++ ) { - t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); - } - t.end(); - - function badValue( value ) { - return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( data.order, data.trans, data.M, data.N, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), value, beta, new Complex128Array( data.y ), data.strideY ); - }; - } -} ); - -tape( 'the function throws an error if provided an invalid twelfth argument', opts, function test( t ) { - var values; - var data; - var i; - - data = rnt; - - values = [ - 0 - ]; - - for ( i = 0; i < values.length; i++ ) { - t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); - } - t.end(); - - function badValue( value ) { - return function badValue() { - var alpha = new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ); - var beta = new Complex128( data.beta[ 0 ], data.beta[ 1 ] ); - zgemv( data.order, data.trans, data.M, data.N, alpha, new Complex128Array( data.A ), data.lda, new Complex128Array( data.x ), data.strideX, beta, new Complex128Array( data.y ), value ); - }; - } -} ); - -tape( 'the function performs the matrix-vector operation `y = α*A*x + β*y` (row-major, no-transpose)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rnt; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function performs the matrix-vector operation `y = α*A*x + β*y` (column-major, no-transpose)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = cnt; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function performs the matrix-vector operation `y = α*A^T*x + β*y` (row-major, transpose)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rt; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function performs the matrix-vector operation `y = α*A^T*x + β*y` (column-major, transpose)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = ct; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function performs the matrix-vector operation `y = α*A^H*x + β*y` (row-major, conjugate-transpose)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rct; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function performs the matrix-vector operation `y = α*A^H*x + β*y` (column-major, conjugate-transpose)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = cct; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function returns a reference to the output vector', opts, function test( t ) { - var data; - var out; - var a; - var x; - var y; - - data = rnt; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'same reference' ); - - t.end(); -} ); - -tape( 'if either `M` or `N` is `0`, the function returns the output vector unchanged', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rnt; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y ); - - out = zgemv( data.order, data.trans, 0, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - out = zgemv( data.order, data.trans, data.M, 0, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'if `α` is `0+0i` and `β` is `1+0i`, the function returns the output vector unchanged (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rnt; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( 0.0, 0.0 ), a, data.lda, x, data.strideX, new Complex128( 1.0, 0.0 ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'if `α` is `0+0i` and `β` is `1+0i`, the function returns the output vector unchanged (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = ct; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( 0.0, 0.0 ), a, data.lda, x, data.strideX, new Complex128( 1.0, 0.0 ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'if `x` contains only zeros and `β` is `1+0i`, the function returns the output vector unchanged (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rxb; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'if `x` contains only zeros and `β` is `1+0i`, the function returns the output vector unchanged (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = cxb; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'if `α` is `0+0i`, the function scales the output vector by `β` (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = ra; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'if `α` is `0+0i`, the function scales the output vector by `β` (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = ca; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'if `x` contains only zeros and `β` is not `1+0i`, the function scales the output vector by `β` (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rx; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'if `x` contains only zeros and `β` is not `1`, the function scales the output vector by `β` (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = cx; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports specifying `x` and `y` strides (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rxpyp; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports specifying `x` and `y` strides (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = cxpyp; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports specifying a negative `x` stride (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rxnyp; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports specifying a negative `x` stride (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = cxnyp; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports specifying a negative `y` stride (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rxpyn; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports specifying a negative `y` stride (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = cxpyn; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports complex access patterns (row-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = rxnyn; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} ); - -tape( 'the function supports complex access patterns (column-major)', opts, function test( t ) { - var expected; - var data; - var out; - var a; - var x; - var y; - - data = cxnyn; - - a = new Complex128Array( data.A ); - x = new Complex128Array( data.x ); - y = new Complex128Array( data.y ); - - expected = new Complex128Array( data.y_out ); - - out = zgemv( data.order, data.trans, data.M, data.N, new Complex128( data.alpha[ 0 ], data.alpha[ 1 ] ), a, data.lda, x, data.strideX, new Complex128( data.beta[ 0 ], data.beta[ 1 ] ), y, data.strideY ); - t.strictEqual( out, y, 'returns expected value' ); - t.strictEqual( isAlmostSameValueComplex128Array( out, expected, 1 ), true, 'returns expected value' ); - - t.end(); -} );