From 3220a2abadef704af11932717a4457239ee76036 Mon Sep 17 00:00:00 2001 From: Divit Jain Date: Wed, 25 Feb 2026 17:17:20 +0530 Subject: [PATCH 01/29] docs: repl file updated --- 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: 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: passed - task: lint_license_headers status: passed --- --- .../@stdlib/blas/base/cgemv/README.md | 302 +++++ .../blas/base/cgemv/benchmark/benchmark.js | 123 ++ .../base/cgemv/benchmark/benchmark.ndarray.js | 123 ++ .../@stdlib/blas/base/cgemv/docs/repl.txt | 184 +++ .../blas/base/cgemv/docs/types/index.d.ts | 147 ++ .../blas/base/cgemv/docs/types/test.ts | 582 ++++++++ .../@stdlib/blas/base/cgemv/examples/index.js | 57 + .../@stdlib/blas/base/cgemv/lib/base.js | 238 ++++ .../@stdlib/blas/base/cgemv/lib/cgemv.js | 145 ++ .../@stdlib/blas/base/cgemv/lib/index.js | 79 ++ .../@stdlib/blas/base/cgemv/lib/main.js | 35 + .../@stdlib/blas/base/cgemv/lib/ndarray.js | 92 ++ .../@stdlib/blas/base/cgemv/manifest.json | 43 + .../@stdlib/blas/base/cgemv/package.json | 72 + .../fixtures/column_major_alpha_zero.json | 26 + .../column_major_complex_access_pattern.json | 23 + .../cgemv/test/fixtures/column_major_nt.json | 26 + .../cgemv/test/fixtures/column_major_oa.json | 23 + .../test/fixtures/column_major_sa1_sa2.json | 23 + .../test/fixtures/column_major_sa1_sa2n.json | 23 + .../test/fixtures/column_major_sa1n_sa2.json | 23 + .../test/fixtures/column_major_sa1n_sa2n.json | 23 + .../cgemv/test/fixtures/column_major_t.json | 26 + .../test/fixtures/column_major_x_zeros.json | 26 + .../column_major_x_zeros_beta_one.json | 26 + .../test/fixtures/column_major_xnyn.json | 26 + .../test/fixtures/column_major_xnyp.json | 26 + .../test/fixtures/column_major_xpyn.json | 26 + .../test/fixtures/column_major_xpyp.json | 26 + .../test/fixtures/row_major_alpha_zero.json | 26 + .../row_major_complex_access_pattern.json | 23 + .../cgemv/test/fixtures/row_major_nt.json | 26 + .../cgemv/test/fixtures/row_major_oa.json | 23 + .../test/fixtures/row_major_sa1_sa2.json | 23 + .../test/fixtures/row_major_sa1_sa2n.json | 23 + .../test/fixtures/row_major_sa1n_sa2.json | 23 + .../test/fixtures/row_major_sa1n_sa2n.json | 23 + .../base/cgemv/test/fixtures/row_major_t.json | 26 + .../test/fixtures/row_major_x_zeros.json | 26 + .../fixtures/row_major_x_zeros_beta_one.json | 26 + .../cgemv/test/fixtures/row_major_xnyn.json | 26 + .../cgemv/test/fixtures/row_major_xnyp.json | 26 + .../cgemv/test/fixtures/row_major_xpyn.json | 26 + .../cgemv/test/fixtures/row_major_xpyp.json | 26 + .../blas/base/cgemv/test/test.cgemv.js | 886 ++++++++++++ .../@stdlib/blas/base/cgemv/test/test.js | 82 ++ .../blas/base/cgemv/test/test.ndarray.js | 1207 +++++++++++++++++ 47 files changed, 5141 insertions(+) create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/README.md create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.js create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.ndarray.js create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/docs/repl.txt create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/docs/types/index.d.ts create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/docs/types/test.ts create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/examples/index.js create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/lib/cgemv.js create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/lib/index.js create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/lib/main.js create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/manifest.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/package.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_alpha_zero.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_complex_access_pattern.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_nt.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_oa.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_sa1_sa2.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_sa1_sa2n.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_sa1n_sa2.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_sa1n_sa2n.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_t.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_x_zeros.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_x_zeros_beta_one.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_xnyn.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_xnyp.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_xpyn.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_xpyp.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_alpha_zero.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_complex_access_pattern.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_nt.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_oa.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_sa1_sa2.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_sa1_sa2n.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_sa1n_sa2.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_sa1n_sa2n.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_t.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_x_zeros.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_x_zeros_beta_one.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_xnyn.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_xnyp.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_xpyn.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_xpyp.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/test.cgemv.js create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/test.js create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/README.md b/lib/node_modules/@stdlib/blas/base/cgemv/README.md new file mode 100644 index 000000000000..fe591ef09cc3 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/README.md @@ -0,0 +1,302 @@ + + +# cgemv + +> Perform one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` for complex-valued data. + +
+ +## Usage + +```javascript +var cgemv = require( '@stdlib/blas/base/cgemv' ); +``` + +#### cgemv( order, trans, M, N, α, A, LDA, x, sx, β, y, sy ) + +Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` where `α` and `β` are complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex matrix. + +```javascript +var Complex64Array = require( '@stdlib/array/complex64' ); +var Complex64 = require( '@stdlib/complex/float32/ctor' ); + +var A = new Complex64Array( [ 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 ] ); // eslint-disable-line max-params, max-len +var x = new Complex64Array( [ 1.0, 1.0, 2.0, 2.0 ] ); +var y = new Complex64Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); + +var alpha = new Complex64( 0.5, 0.5 ); +var beta = new Complex64( 0.5, -0.5 ); + +cgemv( '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. +- **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`. +- **α**: complex scalar constant. +- **A**: input matrix stored in linear memory as a [`Complex64Array`][@stdlib/array/complex64]. +- **LDA**: stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`). +- **x**: input [`Complex64Array`][@stdlib/array/complex64]. +- **sx**: stride length for `x`. +- **β**: complex scalar constant. +- **y**: output [`Complex64Array`][@stdlib/array/complex64]. +- **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 Complex64Array = require( '@stdlib/array/complex64' ); +var Complex64 = require( '@stdlib/complex/float32/ctor' ); + +var A = new Complex64Array( [ 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 ] ); // eslint-disable-line max-params, max-len +var x = new Complex64Array( [ 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 2.0, 2.0 ] ); +var y = new Complex64Array( [ 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 ] ); // eslint-disable-line max-params, max-len + +var alpha = new Complex64( 0.5, 0.5 ); +var beta = new Complex64( 0.5, -0.5 ); + +cgemv( 'column-major', 'no-transpose', 4, 2, alpha, A, 4, x, 3, 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. + + + +```javascript +var Complex64Array = require( '@stdlib/array/complex64' ); +var Complex64 = require( '@stdlib/complex/float32/ctor' ); + +// Initial arrays... +var x0 = new Complex64Array( [ 0.0, 0.0, 1.0, 1.0, 2.0, 2.0 ] ); +var y0 = new Complex64Array( [ 0.0, 0.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); // eslint-disable-line max-params, max-len +var A = new Complex64Array( [ 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 ] ); // eslint-disable-line max-params, max-len + +var alpha = new Complex64( 0.5, 0.5 ); +var beta = new Complex64( 0.5, -0.5 ); + +// Create offset views... +var x1 = new Complex64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd complex element +var y1 = new Complex64Array( y0.buffer, y0.BYTES_PER_ELEMENT*1 ); // start at 2nd complex element + +cgemv( '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 ] +``` + + + +#### cgemv.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` or `y = α*A^T*x + β*y` using alternative indexing semantics and where `α` and `β` are complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex matrix. + +```javascript +var Complex64Array = require( '@stdlib/array/complex64' ); +var Complex64 = require( '@stdlib/complex/float32/ctor' ); + +var A = new Complex64Array( [ 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 Complex64Array( [ 1.0, 1.0, 2.0, 2.0 ] ); +var y = new Complex64Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); + +var alpha = new Complex64( 0.5, 0.5 ); +var beta = new Complex64( 0.5, -0.5 ); + +cgemv.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: + +- **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`. + +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 Complex64Array = require( '@stdlib/array/complex64' ); +var Complex64 = require( '@stdlib/complex/float32/ctor' ); + +var A = new Complex64Array( [ 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 Complex64Array( [ 0.0, 0.0, 1.0, 1.0, 2.0, 2.0 ] ); +var y = new Complex64Array( [ 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 Complex64( 0.5, 0.5 ); +var beta = new Complex64( 0.5, -0.5 ); + +cgemv.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 ] +``` + +
+ + + +
+ +## Notes + +- `cgemv()` corresponds to the [BLAS][blas] level 2 function [`cgemv`][cgemv]. + +
+ + + +
+ +## Examples + + + +```javascript +var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ); +var Complex64 = require( '@stdlib/complex/float32/ctor' ); +var filledarrayBy = require( '@stdlib/array/filled-by' ); +var logEach = require( '@stdlib/console/log-each' ); +var cgemv = require( '@stdlib/blas/base/cgemv' ); + +function rand() { + return new Complex64( discreteUniform( 0, 255 ), discreteUniform( -128, 127 ) ); +} + +var M = 3; +var N = 3; + +var A = filledarrayBy( M*N, 'complex64', rand ); +var x = filledarrayBy( N, 'complex64', rand ); +var y = filledarrayBy( M, 'complex64', rand ); + +var alpha = new Complex64( 0.5, 0.5 ); +var beta = new Complex64( 0.5, -0.5 ); + +cgemv( 'column-major', 'no-transpose', M, N, alpha, A, 4, x, 1, beta, y, 1 ); + +// Print the results: +logEach( '(%s)', x ); + +cgemv.ndarray( 'no-transpose', M, N, alpha, A, 1, 4, 0, x, 1, 0, beta, y, 1, 0 ); + +// Print the results: +logEach( '(%s)', x ); +``` + +
+ + + + + +* * * + +
+ +## C APIs + + + +
+ +
+ + + + + +
+ +### Usage + +```c +TODO +``` + +#### TODO + +TODO. + +```c +TODO +``` + +TODO + +```c +TODO +``` + +
+ + + + + +
+ +
+ + + + + +
+ +### Examples + +```c +TODO +``` + +
+ + + +
+ + + + + +
+ +
+ + + + + +
+ +[blas]: http://www.netlib.org/blas + +[cgemv]: https://www.netlib.org/lapack/explore-html/d7/dda/group__gemv_ga44c85a0d7ecd60a6bc8ca27b222d7792.html#ga44c85a0d7ecd60a6bc8ca27b222d7792 + +[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray + +[@stdlib/array/complex64]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/complex64 + +
+ + diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.js new file mode 100644 index 000000000000..bba69084144f --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.js @@ -0,0 +1,123 @@ +/** +* @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 isnanf = require( '@stdlib/math/base/assert/is-nanf' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var floor = require( '@stdlib/math/base/special/floor' ); +var Complex64Array = require( '@stdlib/array/complex64' ); +var Complex64 = require( '@stdlib/complex/float32/ctor' ); +var format = require( '@stdlib/string/format' ); +var pkg = require( './../package.json' ).name; +var cgemv = require( './../lib/cgemv.js' ); + + +// VARIABLES // + +var options = { + 'dtype': 'float32' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + var alpha; + var beta; + var xbuf; + var ybuf; + var Abuf; + var x; + var y; + var A; + + xbuf = uniform( len*2, -100.0, 100.0, options ); + x = new Complex64Array( xbuf.buffer ); + ybuf = uniform( len*2, -100.0, 100.0, options ); + y = new Complex64Array( ybuf.buffer ); + Abuf = uniform( (len*len)*2, -100.0, 100.0, options ); + A = new Complex64Array( Abuf.buffer ); + + alpha = new Complex64( 0.5, 0.5 ); + beta = new Complex64( 0.5, -0.5 ); + + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + cgemv( 'row-major', 'no-transpose', len, len, alpha, A, len, x, 1, beta, y, 1 ); + if ( isnanf( Abuf[ i%(len*2) ] ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnanf( Abuf[ i%(len*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 len; + var f; + var i; + + min = 1; // 10^min + max = 6; // 10^max + + for ( i = min; i <= max; i++ ) { + len = floor( pow( pow( 10, i ), 1.0/2.0 ) ); + f = createBenchmark( len ); + bench( format( '%s:len=%d', pkg, len ), f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.ndarray.js new file mode 100644 index 000000000000..08ad6f6399d5 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.ndarray.js @@ -0,0 +1,123 @@ +/** +* @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 isnanf = require( '@stdlib/math/base/assert/is-nanf' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var floor = require( '@stdlib/math/base/special/floor' ); +var Complex64Array = require( '@stdlib/array/complex64' ); +var Complex64 = require( '@stdlib/complex/float32/ctor' ); +var format = require( '@stdlib/string/format' ); +var pkg = require( './../package.json' ).name; +var cgemv = require( './../lib/ndarray.js' ); + + +// VARIABLES // + +var options = { + 'dtype': 'float32' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + var alpha; + var beta; + var xbuf; + var ybuf; + var Abuf; + var x; + var y; + var A; + + xbuf = uniform( len*2, -100.0, 100.0, options ); + x = new Complex64Array( xbuf.buffer ); + ybuf = uniform( len*2, -100.0, 100.0, options ); + y = new Complex64Array( ybuf.buffer ); + Abuf = uniform( (len*len)*2, -100.0, 100.0, options ); + A = new Complex64Array( Abuf.buffer ); + + alpha = new Complex64( 0.5, 0.5 ); + beta = new Complex64( 0.5, -0.5 ); + + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + cgemv( 'no-transpose', len, len, alpha, A, 1, len, 0, x, 1, 0, beta, y, 1, 0 ); + if ( isnanf( Abuf[ i%(len*2) ] ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnanf( Abuf[ i%(len*2) ] ) ) { + b.fail( 'should not return NaN' ); + } + b.pass( 'benchmark finished' ); + b.end(); + } +} + + +// MAIN // + +/** +* Main execution sequence. +* +* @private +*/ +function main() { + var len; + var min; + var max; + var f; + var i; + + min = 1; // 10^min + max = 6; // 10^max + + for ( i = min; i <= max; i++ ) { + len = floor( pow( pow( 10, i ), 1.0/2.0 ) ); + f = createBenchmark( len ); + bench( format( '%s:ndarray:len=%d', pkg, len ), f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/docs/repl.txt b/lib/node_modules/@stdlib/blas/base/cgemv/docs/repl.txt new file mode 100644 index 000000000000..5d392eb1984b --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/docs/repl.txt @@ -0,0 +1,184 @@ + +{{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 complex + scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex + 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. Accepted values typically include: 'no-transpose', + 'transpose', 'conjugate-transpose'. + + M: integer + Number of rows in `A`. + + N: integer + Number of columns in `A`. + + α: Complex64 + Complex scalar constant. + + A: Complex64Array + Input matrix. + + lda: integer + Stride of the first dimension of `A` (a.k.a., leading dimension of the + matrix `A`). + + x: Complex64Array + First input vector. + + sx: integer + Index increment for `x`. + + β: Complex64 + Complex scalar constant. + + y: Complex64Array + Second input vector. + + sy: integer + Index increment for `y`. + + Returns + ------- + y: Complex64Array + Second input vector. + + Examples + -------- + // Standard usage: + > var x = new {{alias:@stdlib/array/complex64}}([ 1.0, 1.0, 2.0, 2.0 ]); + > var y = new {{alias:@stdlib/array/complex64}}([ 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/complex64}}( buf ); + > var alpha = new {{alias:@stdlib/complex/float32/ctor}}( 0.5, 0.5 ); + > var beta = new {{alias:@stdlib/complex/float32/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 ) + [ -6.0, 7.0, -8.0, 10.0 ] + + // Advanced indexing: + > x = new {{alias:@stdlib/array/complex64}}([ 2.0, 2.0, 1.0, 1.0 ]); + > y = new {{alias:@stdlib/array/complex64}}([ 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/complex64}}( buf ); + > alpha = new {{alias:@stdlib/complex/float32/ctor}}( 0.5, 0.5 ); + > beta = new {{alias:@stdlib/complex/float32/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/complex64}}( x0buf ); + > var y0buf = [ 0.0, 0.0, 1.0, 1.0, 2.0, 2.0 ]; + > var y0 = new {{alias:@stdlib/array/complex64}}( y0buf ); + > var x0bytes = x0.BYTES_PER_ELEMENT*1; + > var x1 = new {{alias:@stdlib/array/complex64}}( x0.buffer, x0bytes ); + > var y0bytes = y0.BYTES_PER_ELEMENT*1; + > var y1 = new {{alias:@stdlib/array/complex64}}( 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/complex64}}( buf ); + > alpha = new {{alias:@stdlib/complex/float32/ctor}}( 0.5, 0.5 ); + > beta = new {{alias:@stdlib/complex/float32/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 + semantics and where `α` and `β` are complex scalars, `x` and `y` are complex + vectors, and `A` is an `M` by `N` complex 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`. + + α: Complex64 + Complex scalar constant. + + A: Complex64Array + Input matrix. + + sa1: integer + Stride of the first dimension of `A`. + + sa2: integer + Stride of the second dimension of `A`. + + oa: integer + Starting index (offset) for `A`. + + x: Complex64Array + First input vector. + + sx: integer + Index increment for `x`. + + ox: integer + Starting index (offset) for `x`. + + β: Complex64 + Complex scalar constant. + + y: Complex64Array + Second input vector. + + sy: integer + Index increment for `y`. + + oy: integer + Starting index (offset) for `y`. + + Returns + ------- + y: Complex64Array + Second input vector. + + Examples + -------- + > x = new {{alias:@stdlib/array/complex64}}([ 1.0, 1.0, 2.0, 2.0 ]); + > y = new {{alias:@stdlib/array/complex64}}([ 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/complex64}}( buf ); + > alpha = new {{alias:@stdlib/complex/float32/ctor}}( 0.5, 0.5 ); + > beta = new {{alias:@stdlib/complex/float32/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/cgemv/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/index.d.ts new file mode 100644 index 000000000000..21171c55dea7 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/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 { Complex64Array } from '@stdlib/types/array'; +import { Layout, TransposeOperation } from '@stdlib/types/blas'; +import { Complex64 } from '@stdlib/types/complex'; + +/** +* Interface describing `cgemv`. +*/ +interface Routine { + /** + * Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y`, where `α` and `β` are complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex 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` + * @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 Complex64Array = require( '@stdlib/array/complex64' ); + * var Complex64 = require( '@stdlib/complex/float32/ctor' ); + * + * var A = new Complex64Array( [ 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 Complex64Array( [ 1.0, 1.0, 2.0, 2.0 ] ); + * var y = new Complex64Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); + * var alpha = new Complex64( 0.5, 0.5 ); + * var beta = new Complex64( 0.5, -0.5 ); + * + * cgemv( '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: Complex64, A: Complex64Array, LDA: number, x: Complex64Array, strideX: number, beta: Complex64, y: Complex64Array, strideY: number ): Complex64Array; + + /** + * Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y`, using alternative indexing semantics. + * + * @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 Complex64Array = require( '@stdlib/array/complex64' ); + * var Complex64 = require( '@stdlib/complex/float32/ctor' ); + * + * var A = new Complex64Array( [ 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 Complex64Array( [ 1.0, 1.0, 2.0, 2.0 ] ); + * var y = new Complex64Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); + * var alpha = new Complex64( 0.5, 0.5 ); + * var beta = new Complex64( 0.5, -0.5 ); + * + * cgemv.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: Complex64, A: Complex64Array, strideA1: number, strideA2: number, offsetA: number, x: Complex64Array, strideX: number, offsetX: number, beta: Complex64, y: Complex64Array, strideY: number, offsetY: number ): Complex64Array; +} + +/** +* Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y`, where `α` and `β` are complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex 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 Complex64Array = require( '@stdlib/array/complex64' ); +* var Complex64 = require( '@stdlib/complex/float32/ctor' ); +* +* var A = new Complex64Array( [ 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 Complex64Array( [ 1.0, 1.0, 2.0, 2.0 ] ); +* var y = new Complex64Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); +* var alpha = new Complex64( 0.5, 0.5 ); +* var beta = new Complex64( 0.5, -0.5 ); +* +* cgemv( '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 Complex64Array = require( '@stdlib/array/complex64' ); +* var Complex64 = require( '@stdlib/complex/float32/ctor' ); +* +* var A = new Complex64Array( [ 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 Complex64Array( [ 1.0, 1.0, 2.0, 2.0 ] ); +* var y = new Complex64Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); +* var alpha = new Complex64( 0.5, 0.5 ); +* var beta = new Complex64( 0.5, -0.5 ); +* +* cgemv.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 cgemv: Routine; + + +// EXPORTS // + +export = cgemv; diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/test.ts b/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/test.ts new file mode 100644 index 000000000000..8ffcfdad36c7 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/test.ts @@ -0,0 +1,582 @@ +/* +* @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 Complex64Array = require( '@stdlib/array/complex64' ); +import Complex64 = require( '@stdlib/complex/float32/ctor' ); +import cgemv = require( './index' ); + + +// TESTS // + +// The function returns a Complex64Array... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 1.0, 0.0 ); + const beta = new Complex64( 1.0, 0.0 ); + + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectType Complex64Array +} + +// The compiler throws an error if the function is provided a first argument which is not a string... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv( 10, 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( true, 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( false, 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( null, 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( undefined, 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( [], 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( {}, 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( ( 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 Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv( 'row-major', 10, 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', true, 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', false, 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', null, 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', undefined, 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', [], 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', {}, 10, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( '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 Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv( 'row-major', 'no-transpose', '10', 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', true, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', false, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', null, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', undefined, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', [], 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', {}, 10, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( '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 Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv( 'row-major', 'no-transpose', 10, '10', alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, true, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, false, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, null, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, undefined, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, [], alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, {}, alpha, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( '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 Complex64... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv( 'row-major', 'no-transpose', 10, 10, '10', A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, true, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, flase, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, null, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, undefined, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, [], A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, {}, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( '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 Complex64Array... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, 10, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, '10', 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, true, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, false, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, null, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, undefined, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, [ '1' ], 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, {}, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( '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 Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, '10', x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, true, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, false, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, null, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, undefined, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, [], x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, {}, x, 1, beta, y, 1 ); // $ExpectError + cgemv( '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 Complex64Array... +{ + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, 10, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, '10', 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, true, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, false, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, null, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, undefined, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, [ '1' ], 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, {}, 1, beta, y, 1 ); // $ExpectError + cgemv( '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 Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, '10', beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, true, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, false, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, null, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, undefined, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, [], beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, {}, beta, y, 1 ); // $ExpectError + cgemv( '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 Complex64... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, '10', y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, 1.0, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, true, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, false, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, null, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, undefined, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, [], y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, {}, y, 1 ); // $ExpectError + cgemv( '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 Complex64Array... +{ + const x = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, 10, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, '10', 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, true, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, false, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, null, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, undefined, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, [], 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, {}, 1 ); // $ExpectError + cgemv( '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 Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, '10' ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, true ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, false ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, null ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, undefined ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, [] ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y, {} ); // $ExpectError + cgemv( '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 Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv(); // $ExpectError + cgemv( 'row-major' ); // $ExpectError + cgemv( 'row-major', 'no-transpose' ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, y ); // $ExpectError + cgemv( '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 Complex64Array... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectType Complex64Array +} + +// The compiler throws an error if the function is provided a first argument which is not a string... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv.ndarray( 10, 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( true, 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( false, 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( null, 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( undefined, 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( [ '1' ], 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( {}, 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.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 Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv.ndarray( 'no-transpose', '10', 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', true, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', false, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', null, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', undefined, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', [], 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', {}, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.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 Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv.ndarray( 'no-transpose', 10, '10', alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, true, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, false, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, null, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, undefined, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, [], alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, {}, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.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 Complex64... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv.ndarray( 'no-transpose', 10, 10, '10', A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, 10, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, true, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, false, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, null, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, undefined, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, [], A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, {}, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.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 Complex64Array... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv.ndarray( 'no-transpose', 10, 10, alpha, 10, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, '10', 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, true, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, false, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, null, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, undefined, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, [], 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, {}, 10, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.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 Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, '10', 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, true, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, false, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, null, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, undefined, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, [], 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, {}, 1, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.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 Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, '10', 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, true, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, false, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, null, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, undefined, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, [], 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, {}, 0, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.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 Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, '10', x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, true, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, false, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, null, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, undefined, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, [], x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, {}, x, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.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 Complex64Array... +{ + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, 10, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, '10', 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, true, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, false, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, null, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, undefined, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, [], 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, {}, 1, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.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 Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, '10', 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, true, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, false, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, null, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, undefined, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, [], 0, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, {}, 0, beta, y, 1, 0 ); // $ExpectError + cgemv.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 Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, '10', beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, true, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, false, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, null, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, undefined, beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, [], beta, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, {}, beta, y, 1, 0 ); // $ExpectError + cgemv.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 Complex64... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, '10', y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, 10, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, true, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, false, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, null, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, undefined, y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, [], y, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, {}, y, 1, 0 ); // $ExpectError + cgemv.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 Complex64Array... +{ + const x = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, 10, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, '10', 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, true, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, false, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, null, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, undefined, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, [], 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, {}, 1, 0 ); // $ExpectError + cgemv.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 Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, '10', 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, true, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, false, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, null, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, undefined, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, [], 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, {}, 0 ); // $ExpectError + cgemv.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 Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, '10' ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, true ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, false ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, null ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, undefined ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, [] ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, {} ); // $ExpectError + cgemv.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 Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const A = new Complex64Array( 20 ); + const alpha = new Complex64( 0.5, 0.5 ); + const beta = new Complex64( 0.5, -0.5 ); + + cgemv.ndarray(); // $ExpectError + cgemv.ndarray( 'no-transpose' ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1 ); // $ExpectError + cgemv.ndarray( 'no-transpose', 10, 10, alpha, A, 10, 1, 0, x, 1, 0, beta, y, 1, 0, 10 ); // $ExpectError +} diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/examples/index.js b/lib/node_modules/@stdlib/blas/base/cgemv/examples/index.js new file mode 100644 index 000000000000..eb0a6e6389b6 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/examples/index.js @@ -0,0 +1,57 @@ +/** +* @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'; + +var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ); +var filledarrayBy = require( '@stdlib/array/filled-by' ); +var Complex64 = require( '@stdlib/complex/float32/ctor' ); +var logEach = require( '@stdlib/console/log-each' ); +var cgemv = require( './../lib' ); + +function rand() { + return new Complex64( discreteUniform( 0, 10 ), discreteUniform( -5, 5 ) ); +} + +var M = 3; +var N = 3; + +var x = filledarrayBy( N, 'complex64', rand ); +console.log( x.get( 0 ).toString() ); + +var y = filledarrayBy( M, 'complex64', rand ); +console.log( y.get( 0 ).toString() ); + +var A = filledarrayBy( M*N, 'complex64', rand ); +console.log( A.get( 0 ).toString() ); + +var alpha = new Complex64( 2.0, 3.0 ); +console.log( alpha.toString() ); + +var beta = new Complex64( 3.0, -2.0 ); +console.log( beta.toString() ); + +cgemv( 'row-major', 'no-transpose', M, N, alpha, A, M, x, 1, beta, y, 1 ); + +// Print the results: +logEach( '(%s)', y ); + +cgemv.ndarray( 'no-transpose', M, N, alpha, A, 1, M, 0, x, 1, 0, beta, y, 1, 0 ); + +// Print the results: +logEach( '(%s)', y ); diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js new file mode 100644 index 000000000000..e5ee4b134e8c --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js @@ -0,0 +1,238 @@ +/** +* @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 isRowMajor = require( '@stdlib/ndarray/base/assert/is-row-major' ); +var cfill = require( '@stdlib/blas/ext/base/cfill' ).ndarray; +var cscal = require( '@stdlib/blas/base/cscal' ).ndarray; +var realf = require( '@stdlib/complex/float32/real' ); +var imagf = require( '@stdlib/complex/float32/imag' ); +var f32 = require( '@stdlib/number/float64/base/to-float32' ); +var reinterpret = require( '@stdlib/strided/base/reinterpret-complex64' ); +var muladd = require( '@stdlib/complex/float32/base/mul-add' ).assign; + + +// FUNCTIONS // + +/** +* Tests whether a provided string indicates to transpose a matrix. +* +* @private +* @param {string} str - input string +* @returns {boolean} boolean indicating whether to transpose a matrix +* +* @example +* var bool = isTransposed( 'transpose' ); +* // returns true +* +* @example +* var bool = isTransposed( 'conjugate-transpose' ); +* // returns true +* +* @example +* var bool = isTransposed( 'no-transpose' ); +* // returns false +*/ +function isTransposed( str ) { // NOTE: consider moving to a separate helper utility package + return ( str !== 'no-transpose' ); +} + + +// MAIN // + +/** +* Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y`, where `α` and `β` are complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex matrix. +* +* @private +* @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 {Complex64} alpha - scalar constant +* @param {Complex64Array} 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 {Complex64Array} x - first input vector +* @param {integer} strideX - `x` stride length +* @param {NonNegativeInteger} offsetX - starting index for `x` +* @param {Complex64} beta - scalar constant +* @param {Complex64Array} y - second input vector +* @param {integer} strideY - `y` stride length +* @param {NonNegativeInteger} offsetY - starting index for `y` +* @returns {Complex64Array} `y` +* +* @example +* var Complex64Array = require( '@stdlib/array/complex64' ); +* var Complex64 = require( '@stdlib/complex/float32/ctor' ); +* +* var A = new Complex64Array( [ 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 Complex64Array( [ 1.0, 1.0, 2.0, 2.0 ] ); +* var y = new Complex64Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); +* var alpha = new Complex64( 0.5, 0.5 ); +* var beta = new Complex64( 0.5, -0.5 ); +* +* cgemv( '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 cgemv( 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 sign; + var sa0; + var sa1; + var oa2; + var ix0; + var ix1; + var iy0; + var iy1; + var rea; + var ima; + var rex; + var imx; + var oa; + var ox; + var oy; + var sx; + var sy; + var i0; + var i1; + var ia; + + // layout + isrm = isRowMajor( [ strideA1, strideA2 ] ); + + // lengths + if ( isTransposed( trans ) ) { + xlen = M; + ylen = N; + } else { + xlen = N; + ylen = M; + } + + // decompose scalars + rebeta = realf( beta ); + imbeta = imagf( beta ); + realpha = realf( alpha ); + imalpha = imagf( alpha ); + + // y = beta*y + if ( rebeta === 0.0 && imbeta === 0.0 ) { + cfill( ylen, 0.0, y, strideY, offsetY ); + } else if ( rebeta !== 1.0 || imbeta !== 0.0 ) { + cscal( ylen, beta, y, strideY, offsetY ); + } + + // if alpha is zero, early return y + if ( realpha === 0.0 && imalpha === 0.0 ) { + return y; + } + + // reinterpret arrays to raw numeric views + viewA = reinterpret( A, 0 ); + viewX = reinterpret( x, 0 ); + viewY = reinterpret( y, 0 ); + + // Set sign to handle conjugation: flip the imaginary part for conjugate-transpose + if ( trans === 'conjugate-transpose' ) { + sign = -1; + } else { + sign = 1; + } + + if ( isrm ) { + // For row-major matrices, the last dimension has the fastest changing index... + sa0 = strideA2 * 2; // offset increment for innermost loop + sa1 = strideA1 * 2; // offset increment for outermost loop + } else { // isColMajor + // For column-major matrices, the first dimension has the fastest changing index... + sa0 = strideA1 * 2; // offset increment for innermost loop + sa1 = strideA2 * 2; // offset increment for outermost loop + } + + // Vector indexing base + oa = offsetA * 2; + ox = offsetX * 2; + oy = offsetY * 2; + + // Vector strides + sx = strideX * 2; + sy = strideY * 2; + + // Form: y = α*A*x + y + if ( + ( !isrm && !isTransposed( trans ) ) || + ( isrm && isTransposed( trans ) ) + ) { + for ( i1 = 0; i1 < xlen; i1++ ) { + ix1 = ox + ( i1 * sx ); + oa2 = oa + ( i1 * sa1 ); + rex = viewX[ ix1 ]; + imx = viewX[ ix1 + 1 ]; + retmp = f32( ( realpha * rex ) - ( imalpha * imx ) ); + imtmp = f32( ( realpha * imx ) + ( imalpha * rex ) ); + for ( i0 = 0; i0 < ylen; i0++ ) { + ia = oa2 + ( i0 * sa0 ); + iy0 = oy + ( i0 * sy ); + rea = viewA[ ia ]; + ima = sign * viewA[ ia + 1 ]; + muladd( rea, ima, retmp, imtmp, viewY[ iy0 ], viewY[ iy0 + 1 ], viewY, 1, iy0 ); // eslint-disable-line max-len + } + } + return y; + } + + // Form: y = α*A^T*x + y + // ( !isrm && isTransposed( trans ) ) || ( isrm && !isTransposed( trans ) ) + for ( i1 = 0; i1 < ylen; i1++ ) { + oa2 = oa + ( i1 * sa1 ); + iy1 = oy + ( i1 * sy ); + retmp = 0.0; + imtmp = 0.0; + for ( i0 = 0; i0 < xlen; i0++ ) { + ia = oa2 + ( i0 * sa0 ); + ix0 = ox + ( i0 * sx ); + rea = viewA[ ia ]; + ima = sign * viewA[ ia + 1 ]; + rex = viewX[ ix0 ]; + imx = viewX[ ix0 + 1 ]; + retmp = f32( retmp + f32( ( rea * rex ) - ( ima * imx ) ) ); + imtmp = f32( imtmp + f32( ( rea * imx ) + ( ima * rex ) ) ); + } + muladd( realpha, imalpha, retmp, imtmp, viewY[ iy1 ], viewY[ iy1 + 1 ], viewY, 1, iy1 ); // eslint-disable-line max-len + } + return y; +} + + +// EXPORTS // + +module.exports = cgemv; diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/cgemv.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/cgemv.js new file mode 100644 index 000000000000..5b0893010b7c --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/cgemv.js @@ -0,0 +1,145 @@ +/** +* @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 realf = require( '@stdlib/complex/float32/real' ); +var imagf = require( '@stdlib/complex/float32/imag' ); +var format = require( '@stdlib/string/format' ); +var base = require( './base.js' ); + + +// MAIN // + +/** +* Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y`, where `α` and `β` are complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex 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 {Complex64} alpha - scalar constant +* @param {Complex64Array} A - input matrix +* @param {PositiveInteger} LDA - stride of the first dimension of `A` +* @param {Complex64Array} x - first input vector +* @param {integer} strideX - `x` stride length +* @param {Complex64} beta - scalar constant +* @param {Complex64Array} 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 {Complex64Array} `y` +* +* @example +* var Complex64Array = require( '@stdlib/array/complex64' ); +* var Complex64 = require( '@stdlib/complex/float32/ctor' ); +* +* var A = new Complex64Array( [ 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 Complex64Array( [ 1.0, 1.0, 2.0, 2.0 ] ); +* var y = new Complex64Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); +* var alpha = new Complex64( 0.5, 0.5 ); +* var beta = new Complex64( 0.5, -0.5 ); +* +* cgemv( '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 cgemv( order, trans, M, N, alpha, A, LDA, x, strideX, beta, y, strideY ) { // eslint-disable-line max-params, max-len + var realpha; + var imalpha; + var rebeta; + var imbeta; + 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 ) ); + } + rebeta = realf( beta ); + imbeta = imagf( beta ); + realpha = realf( alpha ); + imalpha = imagf( alpha ); + + // Check if we can early return... + if ( M === 0 || N === 0 || ( realpha === 0.0 && imalpha === 0.0 && rebeta === 1.0 && imbeta === 0.0 ) ) { // eslint-disable-line max-len + 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 = cgemv; diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/index.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/index.js new file mode 100644 index 000000000000..424edb273fb0 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/index.js @@ -0,0 +1,79 @@ +/** +* @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'; + +/** +* BLAS level 2 routine to perform one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y`, where `α` and `β` are complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex matrix. +* +* @module @stdlib/blas/base/cgemv +* +* @example +* var Complex64Array = require( '@stdlib/array/complex64' ); +* var Complex64 = require( '@stdlib/complex/float32/ctor' ); +* var cgemv = require( '@stdlib/blas/base/cgemv' ); +* +* var A = new Complex64Array( [ 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 Complex64Array( [ 1.0, 1.0, 2.0, 2.0 ] ); +* var y = new Complex64Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); +* var alpha = new Complex64( 0.5, 0.5 ); +* var beta = new Complex64( 0.5, -0.5 ); +* +* cgemv( '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 Complex64Array = require( '@stdlib/array/complex64' ); +* var Complex64 = require( '@stdlib/complex/float32/ctor' ); +* var cgemv = require( '@stdlib/blas/base/cgemv' ); +* +* var A = new Complex64Array( [ 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 Complex64Array( [ 1.0, 1.0, 2.0, 2.0 ] ); +* var y = new Complex64Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); +* var alpha = new Complex64( 0.5, 0.5 ); +* var beta = new Complex64( 0.5, -0.5 ); +* +* cgemv.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 // + +var join = require( 'path' ).join; +var tryRequire = require( '@stdlib/utils/try-require' ); +var isError = require( '@stdlib/assert/is-error' ); +var main = require( './main.js' ); + + +// MAIN // + +var cgemv; +var tmp = tryRequire( join( __dirname, './native.js' ) ); + +if ( isError( tmp ) ) { + cgemv = main; +} else { + cgemv = tmp; +} + + +// EXPORTS // + +module.exports = cgemv; + +// exports: { "ndarray": "cgemv.ndarray" } diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/main.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/main.js new file mode 100644 index 000000000000..dd5e4c2bccea --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/main.js @@ -0,0 +1,35 @@ +/** +* @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 setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' ); +var cgemv = require( './cgemv.js' ); +var ndarray = require( './ndarray.js' ); + + +// MAIN // + +setReadOnly( cgemv, 'ndarray', ndarray ); + + +// EXPORTS // + +module.exports = cgemv; diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js new file mode 100644 index 000000000000..19498a820d21 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js @@ -0,0 +1,92 @@ +/** +* @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 isMatrixTranspose = require( '@stdlib/blas/base/assert/is-transpose-operation' ); +var format = require( '@stdlib/string/format' ); +var base = require( './base.js' ); + +/** +* Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y`, where `α` and `β` are complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex 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 {Complex64} alpha - scalar constant +* @param {Complex64Array} 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 {Complex64Array} x - first input vector +* @param {integer} strideX - `x` stride length +* @param {NonNegativeInteger} offsetX - starting index for `x` +* @param {Complex64} beta - scalar constant +* @param {Complex64Array} y - second input vector +* @param {integer} strideY - `y` stride length +* @param {NonNegativeInteger} offsetY - starting index for `y` +* @throws {TypeError} first argument must be a valid transpose operation +* @throws {RangeError} second argument must be a nonnegative integer +* @throws {RangeError} third argument must be a nonnegative integer +* @throws {RangeError} tenth argument must be non-zero +* @throws {RangeError} fourteenth argument must be non-zero +* @returns {Complex64Array} `y` +* +* @example +* var Complex64Array = require( '@stdlib/array/complex64' ); +* var Complex64 = require( '@stdlib/complex/float32/ctor' ); +* +* var A = new Complex64Array( [ 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 Complex64Array( [ 1.0, 1.0, 2.0, 2.0 ] ); +* var y = new Complex64Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); +* var alpha = new Complex64( 0.5, 0.5 ); +* var beta = new Complex64( 0.5, -0.5 ); +* +* cgemv( '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 cgemv( 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 ) { + 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 = cgemv; diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/manifest.json b/lib/node_modules/@stdlib/blas/base/cgemv/manifest.json new file mode 100644 index 000000000000..1dc10c0fab64 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/manifest.json @@ -0,0 +1,43 @@ +{ + "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": [], + "include": [], + "libraries": [], + "libpath": [], + "dependencies": [] + } + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/package.json b/lib/node_modules/@stdlib/blas/base/cgemv/package.json new file mode 100644 index 000000000000..d6d69f31b4f5 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/package.json @@ -0,0 +1,72 @@ +{ + "name": "@stdlib/blas/base/cgemv", + "version": "0.0.0", + "description": "Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` where `α` and `β` are complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex matrix.", + "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", + "directories": { + "benchmark": "./benchmark", + "doc": "./docs", + "example": "./examples", + "lib": "./lib", + "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", + "cgemv", + "linear", + "algebra", + "subroutines", + "array", + "ndarray", + "complex", + "complex64", + "complex64array" + ], + "__stdlib__": { + "wasm": false + } +} diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_alpha_zero.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_alpha_zero.json new file mode 100644 index 000000000000..62aec9742f6d --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_alpha_zero.json @@ -0,0 +1,26 @@ +{ + "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/cgemv/test/fixtures/column_major_complex_access_pattern.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_complex_access_pattern.json new file mode 100644 index 000000000000..6406f1728712 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_complex_access_pattern.json @@ -0,0 +1,23 @@ +{ + "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/cgemv/test/fixtures/column_major_nt.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_nt.json new file mode 100644 index 000000000000..994e05f83b84 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_nt.json @@ -0,0 +1,26 @@ +{ + "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/cgemv/test/fixtures/column_major_oa.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_oa.json new file mode 100644 index 000000000000..3c778c62ed8c --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_oa.json @@ -0,0 +1,23 @@ +{ + "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/cgemv/test/fixtures/column_major_sa1_sa2.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_sa1_sa2.json new file mode 100644 index 000000000000..807af427ed00 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_sa1_sa2.json @@ -0,0 +1,23 @@ +{ + "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/cgemv/test/fixtures/column_major_sa1_sa2n.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_sa1_sa2n.json new file mode 100644 index 000000000000..6e749b464198 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_sa1_sa2n.json @@ -0,0 +1,23 @@ +{ + "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/cgemv/test/fixtures/column_major_sa1n_sa2.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_sa1n_sa2.json new file mode 100644 index 000000000000..2eadf7172502 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_sa1n_sa2.json @@ -0,0 +1,23 @@ +{ + "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/cgemv/test/fixtures/column_major_sa1n_sa2n.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_sa1n_sa2n.json new file mode 100644 index 000000000000..ec811967e285 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_sa1n_sa2n.json @@ -0,0 +1,23 @@ +{ + "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/cgemv/test/fixtures/column_major_t.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_t.json new file mode 100644 index 000000000000..8c4b2b2fa2b8 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_t.json @@ -0,0 +1,26 @@ +{ + "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/cgemv/test/fixtures/column_major_x_zeros.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_x_zeros.json new file mode 100644 index 000000000000..e96e0ec25727 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_x_zeros.json @@ -0,0 +1,26 @@ +{ + "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/cgemv/test/fixtures/column_major_x_zeros_beta_one.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_x_zeros_beta_one.json new file mode 100644 index 000000000000..831993bb51f1 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_x_zeros_beta_one.json @@ -0,0 +1,26 @@ +{ + "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/cgemv/test/fixtures/column_major_xnyn.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_xnyn.json new file mode 100644 index 000000000000..55d37dd07f8e --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_xnyn.json @@ -0,0 +1,26 @@ +{ + "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/cgemv/test/fixtures/column_major_xnyp.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_xnyp.json new file mode 100644 index 000000000000..25d87bb2258a --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_xnyp.json @@ -0,0 +1,26 @@ +{ + "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/cgemv/test/fixtures/column_major_xpyn.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_xpyn.json new file mode 100644 index 000000000000..3b39aa86c196 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_xpyn.json @@ -0,0 +1,26 @@ +{ + "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/cgemv/test/fixtures/column_major_xpyp.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_xpyp.json new file mode 100644 index 000000000000..994e05f83b84 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_xpyp.json @@ -0,0 +1,26 @@ +{ + "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/cgemv/test/fixtures/row_major_alpha_zero.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_alpha_zero.json new file mode 100644 index 000000000000..80a3da689b9d --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_alpha_zero.json @@ -0,0 +1,26 @@ +{ + "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/cgemv/test/fixtures/row_major_complex_access_pattern.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_complex_access_pattern.json new file mode 100644 index 000000000000..c1755fb65807 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_complex_access_pattern.json @@ -0,0 +1,23 @@ +{ + "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/cgemv/test/fixtures/row_major_nt.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_nt.json new file mode 100644 index 000000000000..acc5cb255fd5 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_nt.json @@ -0,0 +1,26 @@ +{ + "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/cgemv/test/fixtures/row_major_oa.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_oa.json new file mode 100644 index 000000000000..cd0e233f10d2 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_oa.json @@ -0,0 +1,23 @@ +{ + "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/cgemv/test/fixtures/row_major_sa1_sa2.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_sa1_sa2.json new file mode 100644 index 000000000000..a61467b5d4b6 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_sa1_sa2.json @@ -0,0 +1,23 @@ +{ + "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/cgemv/test/fixtures/row_major_sa1_sa2n.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_sa1_sa2n.json new file mode 100644 index 000000000000..ad7954a998b0 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_sa1_sa2n.json @@ -0,0 +1,23 @@ +{ + "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/cgemv/test/fixtures/row_major_sa1n_sa2.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_sa1n_sa2.json new file mode 100644 index 000000000000..706215a47ae9 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_sa1n_sa2.json @@ -0,0 +1,23 @@ +{ + "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/cgemv/test/fixtures/row_major_sa1n_sa2n.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_sa1n_sa2n.json new file mode 100644 index 000000000000..435660e4a45e --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_sa1n_sa2n.json @@ -0,0 +1,23 @@ +{ + "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/cgemv/test/fixtures/row_major_t.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_t.json new file mode 100644 index 000000000000..46308ee6bd0f --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_t.json @@ -0,0 +1,26 @@ +{ + "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/cgemv/test/fixtures/row_major_x_zeros.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_x_zeros.json new file mode 100644 index 000000000000..9659ac5fcb3d --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_x_zeros.json @@ -0,0 +1,26 @@ +{ + "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/cgemv/test/fixtures/row_major_x_zeros_beta_one.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_x_zeros_beta_one.json new file mode 100644 index 000000000000..1ba1c7827ba8 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_x_zeros_beta_one.json @@ -0,0 +1,26 @@ +{ + "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/cgemv/test/fixtures/row_major_xnyn.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_xnyn.json new file mode 100644 index 000000000000..70ab1be836b1 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_xnyn.json @@ -0,0 +1,26 @@ +{ + "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/cgemv/test/fixtures/row_major_xnyp.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_xnyp.json new file mode 100644 index 000000000000..31c5851bf84b --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_xnyp.json @@ -0,0 +1,26 @@ +{ + "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/cgemv/test/fixtures/row_major_xpyn.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_xpyn.json new file mode 100644 index 000000000000..e1869ba5cac8 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_xpyn.json @@ -0,0 +1,26 @@ +{ + "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/cgemv/test/fixtures/row_major_xpyp.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_xpyp.json new file mode 100644 index 000000000000..acc5cb255fd5 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_xpyp.json @@ -0,0 +1,26 @@ +{ + "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/cgemv/test/test.cgemv.js b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.cgemv.js new file mode 100644 index 000000000000..9c4a54fa5ab4 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.cgemv.js @@ -0,0 +1,886 @@ +/** +* @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 isSameComplex64Array = require( '@stdlib/assert/is-same-complex64array' ); +var Complex64Array = require( '@stdlib/array/complex64' ); +var Complex64 = require( '@stdlib/complex/float32/ctor' ); +var cgemv = require( './../lib/cgemv.js' ); + + +// FIXTURES // + +var cnt = require( './fixtures/column_major_nt.json' ); +var ct = require( './fixtures/column_major_t.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 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 cgemv, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 12', function test( t ) { + t.strictEqual( cgemv.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() { + cgemv( value, data.trans, data.M, data.N, new Complex64( data.alpha[0], data.alpha[1] ), new Complex64Array( data.A ), data.lda, new Complex64Array( data.x ), data.strideX, new Complex64( data.beta[0], data.beta[1] ), new Complex64Array( 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() { + cgemv( data.order, value, data.M, data.N, new Complex64( data.alpha[0], data.alpha[1] ), new Complex64Array( data.A ), data.lda, new Complex64Array( data.x ), data.strideX, new Complex64( data.beta[0], data.beta[1] ), new Complex64Array( 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() { + cgemv( data.order, data.trans, value, data.N, new Complex64( data.alpha[0], data.alpha[1] ), new Complex64Array( data.A ), data.lda, new Complex64Array( data.x ), data.strideX, new Complex64( data.beta[0], data.beta[1] ), new Complex64Array( 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() { + cgemv( data.order, data.trans, data.M, value, new Complex64( data.alpha[0], data.alpha[1] ), new Complex64Array( data.A ), data.lda, new Complex64Array( data.x ), data.strideX, new Complex64( data.beta[0], data.beta[1] ), new Complex64Array( 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() { + cgemv( data.order, data.trans, data.M, data.N, new Complex64( data.alpha[0], data.alpha[1] ), new Complex64Array( data.A ), value, new Complex64Array( data.x ), data.strideX, new Complex64( data.beta[0], data.beta[1] ), new Complex64Array( 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() { + cgemv( data.order, data.trans, data.M, data.N, new Complex64( data.alpha[0], data.alpha[1] ), new Complex64Array( data.A ), data.lda, new Complex64Array( data.x ), value, new Complex64( data.beta[0], data.beta[1] ), new Complex64Array( 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() { + cgemv( data.order, data.trans, data.M, data.N, new Complex64( data.alpha[0], data.alpha[1] ), new Complex64Array( data.A ), data.lda, new Complex64Array( data.x ), data.strideX, new Complex64( data.beta[0], data.beta[1] ), new Complex64Array( data.y ), value ); + }; + } +}); + +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` (row-major, no-transpose)', function test( t ) { + var expected; + var alpha; + var data; + var beta; + var out; + var a; + var x; + var y; + + data = rnt; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` (column-major, no-transpose)', function test( t ) { + var expected; + var alpha; + var data; + var beta; + var out; + var a; + var x; + var y; + + data = cnt; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` (row-major, transpose)', function test( t ) { + var expected; + var alpha; + var data; + var beta; + var out; + var a; + var x; + var y; + + data = rt; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` (column-major, transpose)', function test( t ) { + var expected; + var alpha; + var data; + var beta; + var out; + var a; + var x; + var y; + + data = ct; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + 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 Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.end(); +}); + +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 = rt; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y ); + + out = cgemv( data.order, data.trans, 0, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + + out = cgemv( data.order, data.trans, data.M, 0, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + + t.end(); +}); + +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 = ct; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y ); + + out = cgemv( data.order, data.trans, 0, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + + out = cgemv( data.order, data.trans, data.M, 0, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + + t.end(); +}); + +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 = rt; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( 0.0, 0.0 ); + beta = new Complex64( 1.0, 0.0 ); + + expected = new Complex64Array( data.y ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + + t.end(); +}); + +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 = ct; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( 0.0, 0.0 ); + beta = new Complex64( 1.0, 0.0 ); + + expected = new Complex64Array( data.y ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + + t.end(); +}); + +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 = rxb; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + + t.end(); +}); + +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 = cxb; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + + t.end(); +}); + +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 = ra; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( 0.0, 0.0 ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + + t.end(); +}); + +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 = ca; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( 0.0, 0.0 ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( 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; + var y; + + data = rx; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( 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 `β` (column-major)', function test( t ) { + var expected; + var alpha; + var data; + var beta; + var out; + var a; + var x; + var y; + + data = cx; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( 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; + var y; + + data = rxpyp; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( 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; + var y; + + data = cxpyp; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( 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; + var y; + + data = rxnyp; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( 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; + var y; + + data = cxnyp; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( 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; + var y; + + data = rxpyn; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( 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; + var y; + + data = cxpyn; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( 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; + var y; + + data = rxnyn; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( 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; + var y; + + data = cxnyn; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.js b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.js new file mode 100644 index 000000000000..2803bc7eef84 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/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 cgemv = 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 cgemv, '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 cgemv.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 cgemv = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire + }); + + t.strictEqual( cgemv, mock, 'returns native implementation' ); + t.end(); + + function tryRequire() { + return mock; + } + + function mock() { + // Mock native implementation... + } +}); + +tape( 'if a native implementation is not available, the main export is a JavaScript implementation', opts, function test( t ) { + var cgemv; + var main; + + main = require( './../lib/cgemv.js' ); + + cgemv = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire + }); + + t.strictEqual( cgemv, main, 'returns JavaScript implementation' ); + t.end(); + + function tryRequire() { + return new Error( 'Cannot find module' ); + } +}); diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js new file mode 100644 index 000000000000..a084d0580f18 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js @@ -0,0 +1,1207 @@ +/** +* @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 isSameComplex64Array = require( '@stdlib/assert/is-same-complex64array' ); +var Complex64Array = require( '@stdlib/array/complex64' ); +var Complex64 = require( '@stdlib/complex/float32/ctor' ); +var cgemv = 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 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 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 cgemv, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 15', function test( t ) { + t.strictEqual( cgemv.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() { + cgemv( value, data.M, data.N, new Complex64( data.alpha[0], data.alpha[1] ), new Complex64Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex64Array( data.x ), data.strideX, data.offsetX, new Complex64( data.beta[0], data.beta[1] ), new Complex64Array( 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() { + cgemv( data.trans, value, data.N, new Complex64( data.alpha[0], data.alpha[1] ), new Complex64Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex64Array( data.x ), data.strideX, data.offsetX, new Complex64( data.beta[0], data.beta[1] ), new Complex64Array( 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() { + cgemv( data.trans, data.M, value, new Complex64( data.alpha[0], data.alpha[1] ), new Complex64Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex64Array( data.x ), data.strideX, data.offsetX, new Complex64( data.beta[0], data.beta[1] ), new Complex64Array( 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() { + cgemv( data.trans, data.M, data.N, new Complex64( data.alpha[0], data.alpha[1] ), new Complex64Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex64Array( data.x ), value, data.offsetX, new Complex64( data.beta[0], data.beta[1] ), new Complex64Array( 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() { + cgemv( data.trans, data.M, data.N, new Complex64( data.alpha[0], data.alpha[1] ), new Complex64Array( data.A ), data.strideA1, data.strideA2, data.offsetA, new Complex64Array( data.x ), data.strideX, data.offsetX, new Complex64( data.beta[0], data.beta[1] ), new Complex64Array( data.y ), value, data.offsetY ); + }; + } +}); + +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` (row-major, no-transpose)', function test( t ) { + var expected; + var alpha; + var data; + var beta; + var out; + var a; + var x; + var y; + + data = rnt; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` (column-major, no-transpose)', function test( t ) { + var expected; + var alpha; + var data; + var beta; + var out; + var a; + var x; + var y; + + data = cnt; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` (row-major, transpose)', function test( t ) { + var expected; + var alpha; + var data; + var beta; + var out; + var a; + var x; + var y; + + data = rt; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` (column-major, transpose)', function test( t ) { + var expected; + var alpha; + var data; + var beta; + var out; + var a; + var x; + var y; + + data = ct; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +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 = rt; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + + 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 Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + + t.end(); +}); + +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 = rt; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +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 = ct; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +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 = rt; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( 0.0, 0.0 ); + beta = new Complex64( 1.0, 0.0 ); + + expected = new Complex64Array( data.y ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +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 = ct; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( 0.0, 0.0 ); + beta = new Complex64( 1.0, 0.0 ); + + expected = new Complex64Array( data.y ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +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 = rxb; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +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 = cxb; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +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 = ra; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +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 = ca; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + 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; + var y; + + data = rx; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +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; + var y; + + data = cx; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + 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; + var y; + + data = rsa1sa2; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + 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; + var y; + + data = csa1sa2; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + 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; + var y; + + data = rsa1nsa2; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + 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; + var y; + + data = csa1nsa2; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +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; + var y; + + data = rsa1sa2n; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +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; + var y; + + data = csa1sa2n; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +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; + var y; + + data = rsa1nsa2n; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +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; + var y; + + data = csa1nsa2n; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +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; + var y; + + data = roa; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +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; + var y; + + data = coa; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + 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; + var y; + + data = rxpyp; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + 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; + var y; + + data = cxpyp; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + 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; + var y; + + data = rxnyp; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + 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; + var y; + + data = cxnyp; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + 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; + var y; + + data = rxpyn; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + 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; + var y; + + data = cxpyn; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + 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; + var y; + + data = rxnyn; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + 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; + var y; + + data = cxnyn; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + 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; + var y; + + data = rap; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + 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; + var y; + + data = cap; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); From 33b2fe73c2331e6752f987e42d224653a0e2f6ac Mon Sep 17 00:00:00 2001 From: Divit Jain Date: Wed, 25 Feb 2026 17:34:04 +0530 Subject: [PATCH 02/29] docs: package.json updated --- 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: passed - 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: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- lib/node_modules/@stdlib/blas/base/cgemv/package.json | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/package.json b/lib/node_modules/@stdlib/blas/base/cgemv/package.json index d6d69f31b4f5..4da9236bf4d8 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/package.json +++ b/lib/node_modules/@stdlib/blas/base/cgemv/package.json @@ -65,8 +65,5 @@ "complex", "complex64", "complex64array" - ], - "__stdlib__": { - "wasm": false - } + ] } From f70680cdea6c53528ff1091e33c4f4928a2d448d Mon Sep 17 00:00:00 2001 From: Divit Date: Sat, 28 Feb 2026 14:39:23 +0000 Subject: [PATCH 03/29] chores: clean up in base.js --- lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js index e5ee4b134e8c..466e2d6a689a 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js @@ -51,7 +51,7 @@ var muladd = require( '@stdlib/complex/float32/base/mul-add' ).assign; * var bool = isTransposed( 'no-transpose' ); * // returns false */ -function isTransposed( str ) { // NOTE: consider moving to a separate helper utility package +function isTransposed( str ) { // NOTE: consider moving to a separate helper utility packages return ( str !== 'no-transpose' ); } From c38fd950905f19d0caf9d185aa5198c13d08c5ac Mon Sep 17 00:00:00 2001 From: Divit Date: Sat, 28 Feb 2026 14:42:19 +0000 Subject: [PATCH 04/29] chore: clean up in base.js --- 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: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js index 466e2d6a689a..e5ee4b134e8c 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js @@ -51,7 +51,7 @@ var muladd = require( '@stdlib/complex/float32/base/mul-add' ).assign; * var bool = isTransposed( 'no-transpose' ); * // returns false */ -function isTransposed( str ) { // NOTE: consider moving to a separate helper utility packages +function isTransposed( str ) { // NOTE: consider moving to a separate helper utility package return ( str !== 'no-transpose' ); } From f73c3f591d37a32021f9f0eac2597e23556fa31b Mon Sep 17 00:00:00 2001 From: Divit Date: Tue, 10 Mar 2026 10:09:40 +0000 Subject: [PATCH 05/29] docs: description updated --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: passed - task: lint_package_json status: na - task: lint_repl_help status: passed - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/blas/base/cgemv/README.md | 8 ++-- .../@stdlib/blas/base/cgemv/docs/repl.txt | 16 +++---- .../@stdlib/blas/base/cgemv/lib/base.js | 38 ++++++++-------- .../@stdlib/blas/base/cgemv/lib/cgemv.js | 10 ++--- .../@stdlib/blas/base/cgemv/lib/index.js | 2 +- .../@stdlib/blas/base/cgemv/lib/ndarray.js | 12 +++--- .../@stdlib/blas/base/cgemv/manifest.json | 43 ------------------- 7 files changed, 42 insertions(+), 87 deletions(-) delete mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/manifest.json diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/README.md b/lib/node_modules/@stdlib/blas/base/cgemv/README.md index fe591ef09cc3..f98743996863 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/README.md +++ b/lib/node_modules/@stdlib/blas/base/cgemv/README.md @@ -20,7 +20,7 @@ limitations under the License. # cgemv -> Perform one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` for complex-valued data. +> Perform one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y` for complex-valued data.
@@ -32,7 +32,7 @@ var cgemv = require( '@stdlib/blas/base/cgemv' ); #### cgemv( order, trans, M, N, α, A, LDA, x, sx, β, y, sy ) -Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` where `α` and `β` are complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex 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 complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex matrix. ```javascript var Complex64Array = require( '@stdlib/array/complex64' ); @@ -56,7 +56,7 @@ The function has the following parameters: - **M**: number of rows in the matrix `A`. - **N**: number of columns in the matrix `A`. - **α**: complex scalar constant. -- **A**: input matrix stored in linear memory as a [`Complex64Array`][@stdlib/array/complex64]. +- **A**: complex input matrix stored in linear memory as a [`Complex64Array`][@stdlib/array/complex64]. - **LDA**: stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`). - **x**: input [`Complex64Array`][@stdlib/array/complex64]. - **sx**: stride length for `x`. @@ -109,7 +109,7 @@ cgemv( 'column-major', 'no-transpose', 4, 2, alpha, A, 4, x1, 1, beta, y1, 1 ); #### cgemv.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` or `y = α*A^T*x + β*y` using alternative indexing semantics and where `α` and `β` are complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex 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 complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex matrix. ```javascript var Complex64Array = require( '@stdlib/array/complex64' ); diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/docs/repl.txt b/lib/node_modules/@stdlib/blas/base/cgemv/docs/repl.txt index 5d392eb1984b..f6536d75c35c 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/docs/repl.txt +++ b/lib/node_modules/@stdlib/blas/base/cgemv/docs/repl.txt @@ -33,14 +33,14 @@ Complex scalar constant. A: Complex64Array - Input matrix. + Complex input matrix. lda: integer Stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`). x: Complex64Array - First input vector. + First complex input vector. sx: integer Index increment for `x`. @@ -49,7 +49,7 @@ Complex scalar constant. y: Complex64Array - Second input vector. + Second complex input vector. sy: integer Index increment for `y`. @@ -57,7 +57,7 @@ Returns ------- y: Complex64Array - Second input vector. + Second complex input vector. Examples -------- @@ -130,7 +130,7 @@ Complex scalar constant. A: Complex64Array - Input matrix. + Complex input matrix. sa1: integer Stride of the first dimension of `A`. @@ -142,7 +142,7 @@ Starting index (offset) for `A`. x: Complex64Array - First input vector. + First complex input vector. sx: integer Index increment for `x`. @@ -154,7 +154,7 @@ Complex scalar constant. y: Complex64Array - Second input vector. + Second complex input vector. sy: integer Index increment for `y`. @@ -165,7 +165,7 @@ Returns ------- y: Complex64Array - Second input vector. + Second complex input vector. Examples -------- diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js index e5ee4b134e8c..169c1acd1f2e 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js @@ -59,22 +59,22 @@ function isTransposed( str ) { // NOTE: consider moving to a separate helper uti // MAIN // /** -* Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y`, where `α` and `β` are complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex 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 complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex matrix. * * @private * @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 {Complex64} alpha - scalar constant -* @param {Complex64Array} A - input matrix +* @param {Complex64} alpha - complex scalar constant +* @param {Complex64Array} A - complex 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 {Complex64Array} x - first input vector +* @param {Complex64Array} x - first complex input vector * @param {integer} strideX - `x` stride length * @param {NonNegativeInteger} offsetX - starting index for `x` -* @param {Complex64} beta - scalar constant -* @param {Complex64Array} y - second input vector +* @param {Complex64} beta - complex scalar constant +* @param {Complex64Array} y - second complex input vector * @param {integer} strideY - `y` stride length * @param {NonNegativeInteger} offsetY - starting index for `y` * @returns {Complex64Array} `y` @@ -109,14 +109,12 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, var sa0; var sa1; var oa2; - var ix0; - var ix1; - var iy0; - var iy1; var rea; var ima; var rex; var imx; + var ix; + var iy; var oa; var ox; var oy; @@ -193,18 +191,18 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, ( isrm && isTransposed( trans ) ) ) { for ( i1 = 0; i1 < xlen; i1++ ) { - ix1 = ox + ( i1 * sx ); + ix = ox + ( i1 * sx ); oa2 = oa + ( i1 * sa1 ); - rex = viewX[ ix1 ]; - imx = viewX[ ix1 + 1 ]; + rex = viewX[ ix ]; + imx = viewX[ ix + 1 ]; retmp = f32( ( realpha * rex ) - ( imalpha * imx ) ); imtmp = f32( ( realpha * imx ) + ( imalpha * rex ) ); for ( i0 = 0; i0 < ylen; i0++ ) { ia = oa2 + ( i0 * sa0 ); - iy0 = oy + ( i0 * sy ); rea = viewA[ ia ]; ima = sign * viewA[ ia + 1 ]; - muladd( rea, ima, retmp, imtmp, viewY[ iy0 ], viewY[ iy0 + 1 ], viewY, 1, iy0 ); // eslint-disable-line max-len + iy = oy + ( i0 * sy ); + muladd( rea, ima, retmp, imtmp, viewY[ iy ], viewY[ iy + 1 ], viewY, 1, iy ); // eslint-disable-line max-len } } return y; @@ -214,20 +212,20 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, // ( !isrm && isTransposed( trans ) ) || ( isrm && !isTransposed( trans ) ) for ( i1 = 0; i1 < ylen; i1++ ) { oa2 = oa + ( i1 * sa1 ); - iy1 = oy + ( i1 * sy ); retmp = 0.0; imtmp = 0.0; for ( i0 = 0; i0 < xlen; i0++ ) { ia = oa2 + ( i0 * sa0 ); - ix0 = ox + ( i0 * sx ); + ix = ox + ( i0 * sx ); rea = viewA[ ia ]; ima = sign * viewA[ ia + 1 ]; - rex = viewX[ ix0 ]; - imx = viewX[ ix0 + 1 ]; + rex = viewX[ ix ]; + imx = viewX[ ix + 1 ]; retmp = f32( retmp + f32( ( rea * rex ) - ( ima * imx ) ) ); imtmp = f32( imtmp + f32( ( rea * imx ) + ( ima * rex ) ) ); } - muladd( realpha, imalpha, retmp, imtmp, viewY[ iy1 ], viewY[ iy1 + 1 ], viewY, 1, iy1 ); // eslint-disable-line max-len + iy = oy + ( i1 * sy ); + muladd( realpha, imalpha, retmp, imtmp, viewY[ iy ], viewY[ iy + 1 ], viewY, 1, iy ); // eslint-disable-line max-len } return y; } diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/cgemv.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/cgemv.js index 5b0893010b7c..1a5f37ba6f38 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/lib/cgemv.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/cgemv.js @@ -34,18 +34,18 @@ var base = require( './base.js' ); // MAIN // /** -* Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y`, where `α` and `β` are complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex 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 complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex 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 {Complex64} alpha - scalar constant -* @param {Complex64Array} A - input matrix +* @param {Complex64} alpha - complex scalar constant +* @param {Complex64Array} A - complex input matrix * @param {PositiveInteger} LDA - stride of the first dimension of `A` -* @param {Complex64Array} x - first input vector +* @param {Complex64Array} x - first complex input vector * @param {integer} strideX - `x` stride length -* @param {Complex64} beta - scalar constant +* @param {Complex64} beta - complex scalar constant * @param {Complex64Array} y - second input vector * @param {integer} strideY - `y` stride length * @throws {TypeError} first argument must be a valid order diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/index.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/index.js index 424edb273fb0..9b542876e752 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/lib/index.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/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` or `y = α*A^T*x + β*y`, where `α` and `β` are complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex 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 complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex matrix. * * @module @stdlib/blas/base/cgemv * diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js index 19498a820d21..2fd03deae30c 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js @@ -25,21 +25,21 @@ var format = require( '@stdlib/string/format' ); var base = require( './base.js' ); /** -* Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y`, where `α` and `β` are complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex 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 complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex 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 {Complex64} alpha - scalar constant -* @param {Complex64Array} A - input matrix +* @param {Complex64} alpha - complex scalar constant +* @param {Complex64Array} A - complex 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 {Complex64Array} x - first input vector +* @param {Complex64Array} x - first complex input vector * @param {integer} strideX - `x` stride length * @param {NonNegativeInteger} offsetX - starting index for `x` -* @param {Complex64} beta - scalar constant -* @param {Complex64Array} y - second input vector +* @param {Complex64} beta - complex scalar constant +* @param {Complex64Array} y - second complex input vector * @param {integer} strideY - `y` stride length * @param {NonNegativeInteger} offsetY - starting index for `y` * @throws {TypeError} first argument must be a valid transpose operation diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/manifest.json b/lib/node_modules/@stdlib/blas/base/cgemv/manifest.json deleted file mode 100644 index 1dc10c0fab64..000000000000 --- a/lib/node_modules/@stdlib/blas/base/cgemv/manifest.json +++ /dev/null @@ -1,43 +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": [], - "include": [], - "libraries": [], - "libpath": [], - "dependencies": [] - } - ] -} From 486945a393bec71cc4c0fd52d473f5b4a6796fba Mon Sep 17 00:00:00 2001 From: Divit Date: Tue, 10 Mar 2026 10:10:54 +0000 Subject: [PATCH 06/29] docs: comments updated --- 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: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js index 169c1acd1f2e..c8eb8eee1477 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js @@ -124,10 +124,10 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, var i1; var ia; - // layout + // Layout isrm = isRowMajor( [ strideA1, strideA2 ] ); - // lengths + // Lengths if ( isTransposed( trans ) ) { xlen = M; ylen = N; @@ -136,7 +136,7 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, ylen = M; } - // decompose scalars + // Decompose scalars rebeta = realf( beta ); imbeta = imagf( beta ); realpha = realf( alpha ); @@ -149,12 +149,12 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, cscal( ylen, beta, y, strideY, offsetY ); } - // if alpha is zero, early return y + // If alpha is zero, early return y if ( realpha === 0.0 && imalpha === 0.0 ) { return y; } - // reinterpret arrays to raw numeric views + // Reinterpret arrays to raw numeric views viewA = reinterpret( A, 0 ); viewX = reinterpret( x, 0 ); viewY = reinterpret( y, 0 ); From 59d803718efee7ce699ccd019d4c2a19814febf1 Mon Sep 17 00:00:00 2001 From: Divit Date: Tue, 10 Mar 2026 10:24:33 +0000 Subject: [PATCH 07/29] docs: typo corrected --- 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: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: passed - task: lint_license_headers status: passed --- --- .../@stdlib/blas/base/cgemv/docs/types/index.d.ts | 2 +- lib/node_modules/@stdlib/blas/base/cgemv/docs/types/test.ts | 4 +--- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/index.d.ts index 21171c55dea7..f6210808184b 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/index.d.ts @@ -18,7 +18,7 @@ // TypeScript Version: 4.1 -// +/// import { Complex64Array } from '@stdlib/types/array'; import { Layout, TransposeOperation } from '@stdlib/types/blas'; diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/test.ts b/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/test.ts index 8ffcfdad36c7..54c7ff65d54a 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/test.ts +++ b/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/test.ts @@ -115,7 +115,7 @@ import cgemv = require( './index' ); cgemv( 'row-major', 'no-transpose', 10, 10, '10', A, 10, x, 1, beta, y, 1 ); // $ExpectError cgemv( 'row-major', 'no-transpose', 10, 10, true, A, 10, x, 1, beta, y, 1 ); // $ExpectError - cgemv( 'row-major', 'no-transpose', 10, 10, flase, A, 10, x, 1, beta, y, 1 ); // $ExpectError + cgemv( 'row-major', 'no-transpose', 10, 10, false, A, 10, x, 1, beta, y, 1 ); // $ExpectError cgemv( 'row-major', 'no-transpose', 10, 10, null, A, 10, x, 1, beta, y, 1 ); // $ExpectError cgemv( 'row-major', 'no-transpose', 10, 10, undefined, A, 10, x, 1, beta, y, 1 ); // $ExpectError cgemv( 'row-major', 'no-transpose', 10, 10, [], A, 10, x, 1, beta, y, 1 ); // $ExpectError @@ -220,7 +220,6 @@ import cgemv = require( './index' ); const alpha = new Complex64( 0.5, 0.5 ); const beta = new Complex64( 0.5, -0.5 ); - cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, 10, 1 ); // $ExpectError cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, '10', 1 ); // $ExpectError cgemv( 'row-major', 'no-transpose', 10, 10, alpha, A, 10, x, 1, beta, true, 1 ); // $ExpectError @@ -250,7 +249,6 @@ import cgemv = require( './index' ); cgemv( '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 Complex64Array( 10 ); From d7deb468b24bb94e3628c553d5c365c902e1d0ed Mon Sep 17 00:00:00 2001 From: Divit Date: Tue, 10 Mar 2026 10:25:11 +0000 Subject: [PATCH 08/29] test: benchmark updated --- 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 --- --- .../blas/base/cgemv/benchmark/benchmark.js | 25 ++++++++++--------- .../base/cgemv/benchmark/benchmark.ndarray.js | 25 ++++++++++--------- 2 files changed, 26 insertions(+), 24 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.js index bba69084144f..37b530aa3d31 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.js @@ -45,10 +45,10 @@ var options = { * Creates a benchmark function. * * @private -* @param {PositiveInteger} len - array length +* @param {PositiveInteger} N - array dimension size * @returns {Function} benchmark function */ -function createBenchmark( len ) { +function createBenchmark( N ) { var alpha; var beta; var xbuf; @@ -58,11 +58,11 @@ function createBenchmark( len ) { var y; var A; - xbuf = uniform( len*2, -100.0, 100.0, options ); + xbuf = uniform( N*2, -100.0, 100.0, options ); x = new Complex64Array( xbuf.buffer ); - ybuf = uniform( len*2, -100.0, 100.0, options ); + ybuf = uniform( N*2, -100.0, 100.0, options ); y = new Complex64Array( ybuf.buffer ); - Abuf = uniform( (len*len)*2, -100.0, 100.0, options ); + Abuf = uniform( (N*N)*2, -100.0, 100.0, options ); A = new Complex64Array( Abuf.buffer ); alpha = new Complex64( 0.5, 0.5 ); @@ -78,16 +78,17 @@ function createBenchmark( len ) { */ function benchmark( b ) { var i; + var z; b.tic(); for ( i = 0; i < b.iterations; i++ ) { - cgemv( 'row-major', 'no-transpose', len, len, alpha, A, len, x, 1, beta, y, 1 ); - if ( isnanf( Abuf[ i%(len*2) ] ) ) { + z = cgemv( 'row-major', 'no-transpose', N, N, alpha, A, N, x, 1, beta, y, 1 ); + if ( isnanf( z[ i% ( z.length ) ] ) ) { b.fail( 'should not return NaN' ); } } b.toc(); - if ( isnanf( Abuf[ i%(len*2) ] ) ) { + if ( isnanf( z[ i % ( z.length ) ] ) ) { b.fail( 'should not return NaN' ); } b.pass( 'benchmark finished' ); @@ -106,7 +107,7 @@ function createBenchmark( len ) { function main() { var min; var max; - var len; + var N; var f; var i; @@ -114,9 +115,9 @@ function main() { max = 6; // 10^max for ( i = min; i <= max; i++ ) { - len = floor( pow( pow( 10, i ), 1.0/2.0 ) ); - f = createBenchmark( len ); - bench( format( '%s:len=%d', pkg, len ), f ); + N = floor( pow( pow( 10, i ), 1.0/2.0 ) ); + f = createBenchmark( N ); + bench( format( '%s:size=%d', pkg, N*N ), f ); } } diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.ndarray.js index 08ad6f6399d5..ef7ab3d7df5d 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.ndarray.js @@ -45,10 +45,10 @@ var options = { * Creates a benchmark function. * * @private -* @param {PositiveInteger} len - array length +* @param {PositiveInteger} N - array dimension size * @returns {Function} benchmark function */ -function createBenchmark( len ) { +function createBenchmark( N ) { var alpha; var beta; var xbuf; @@ -58,11 +58,11 @@ function createBenchmark( len ) { var y; var A; - xbuf = uniform( len*2, -100.0, 100.0, options ); + xbuf = uniform( N*2, -100.0, 100.0, options ); x = new Complex64Array( xbuf.buffer ); - ybuf = uniform( len*2, -100.0, 100.0, options ); + ybuf = uniform( N*2, -100.0, 100.0, options ); y = new Complex64Array( ybuf.buffer ); - Abuf = uniform( (len*len)*2, -100.0, 100.0, options ); + Abuf = uniform( (N*N)*2, -100.0, 100.0, options ); A = new Complex64Array( Abuf.buffer ); alpha = new Complex64( 0.5, 0.5 ); @@ -78,16 +78,17 @@ function createBenchmark( len ) { */ function benchmark( b ) { var i; + var z; b.tic(); for ( i = 0; i < b.iterations; i++ ) { - cgemv( 'no-transpose', len, len, alpha, A, 1, len, 0, x, 1, 0, beta, y, 1, 0 ); - if ( isnanf( Abuf[ i%(len*2) ] ) ) { + z = cgemv( 'no-transpose', N, N, alpha, A, 1, N, 0, x, 1, 0, beta, y, 1, 0 ); + if ( isnanf( z[ i % ( z.length ) ] ) ) { b.fail( 'should not return NaN' ); } } b.toc(); - if ( isnanf( Abuf[ i%(len*2) ] ) ) { + if ( isnanf( z[ i % ( z.length ) ] ) ) { b.fail( 'should not return NaN' ); } b.pass( 'benchmark finished' ); @@ -104,9 +105,9 @@ function createBenchmark( len ) { * @private */ function main() { - var len; var min; var max; + var N; var f; var i; @@ -114,9 +115,9 @@ function main() { max = 6; // 10^max for ( i = min; i <= max; i++ ) { - len = floor( pow( pow( 10, i ), 1.0/2.0 ) ); - f = createBenchmark( len ); - bench( format( '%s:ndarray:len=%d', pkg, len ), f ); + N = floor( pow( pow( 10, i ), 1.0/2.0 ) ); + f = createBenchmark( N ); + bench( format( '%s:ndarray:size=%d', pkg, N*N ), f ); } } From f8b34d8ea4ffd2bbd42e6f79664a4c283c4e0668 Mon Sep 17 00:00:00 2001 From: Divit Date: Tue, 10 Mar 2026 10:46:46 +0000 Subject: [PATCH 09/29] test: fixtures and tests added of conjugate-transpose --- 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: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../cgemv/test/fixtures/column_major_ct.json | 26 +++++++++ .../cgemv/test/fixtures/row_major_ct.json | 26 +++++++++ .../base/cgemv/test/fixtures/row_major_t.json | 2 +- .../blas/base/cgemv/test/test.cgemv.js | 58 +++++++++++++++++++ .../blas/base/cgemv/test/test.ndarray.js | 58 +++++++++++++++++++ 5 files changed, 169 insertions(+), 1 deletion(-) create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_ct.json create mode 100644 lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_ct.json diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_ct.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_ct.json new file mode 100644 index 000000000000..8e34d636b595 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/column_major_ct.json @@ -0,0 +1,26 @@ +{ + "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/cgemv/test/fixtures/row_major_ct.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_ct.json new file mode 100644 index 000000000000..1a533b9d5a74 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_ct.json @@ -0,0 +1,26 @@ +{ + "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/cgemv/test/fixtures/row_major_t.json b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_t.json index 46308ee6bd0f..f6a46ba3560c 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_t.json +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/fixtures/row_major_t.json @@ -13,7 +13,7 @@ [ 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], + "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, diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.cgemv.js b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.cgemv.js index 9c4a54fa5ab4..664c3b3d711d 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.cgemv.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.cgemv.js @@ -33,6 +33,7 @@ var cgemv = require( './../lib/cgemv.js' ); 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' ); @@ -42,6 +43,7 @@ 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' ); @@ -350,6 +352,62 @@ tape( 'the function performs one of the matrix-vector operations `y = α*A*x + t.end(); }); +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` (row-major, conjugate-transpose)', function test( t ) { + var expected; + var alpha; + var data; + var beta; + var out; + var a; + var x; + var y; + + data = rct; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` (column-major, conjugate-transpose)', function test( t ) { + var expected; + var alpha; + var data; + var beta; + var out; + var a; + var x; + var y; + + data = cct; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + tape( 'the function returns a reference to the second input vector (column-major)', function test( t ) { var alpha; var data; diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js index a084d0580f18..5c67dc9a2f32 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js @@ -34,6 +34,7 @@ var cgemv = require( './../lib/ndarray.js' ); 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' ); @@ -49,6 +50,7 @@ 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' ); @@ -310,6 +312,62 @@ tape( 'the function performs one of the matrix-vector operations `y = α*A*x + t.end(); }); +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` (row-major, conjugate-transpose)', function test( t ) { + var expected; + var alpha; + var data; + var beta; + var out; + var a; + var x; + var y; + + data = rct; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + +tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` (column-major, conjugate-transpose)', function test( t ) { + var expected; + var alpha; + var data; + var beta; + var out; + var a; + var x; + var y; + + data = cct; + + a = new Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( data.alpha[0], data.alpha[1] ); + beta = new Complex64( data.beta[0], data.beta[1] ); + + expected = new Complex64Array( data.y_out ); + + out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + + t.end(); +}); + tape( 'the function returns a reference to the second input vector (row-major)', function test( t ) { var alpha; var data; From 6a579e18814e0fe5eb670475306cafa1f0771efe Mon Sep 17 00:00:00 2001 From: Divit Date: Fri, 20 Mar 2026 18:45:00 +0000 Subject: [PATCH 10/29] chore: clean up --- 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: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js index 2fd03deae30c..e6abb567807e 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js @@ -45,6 +45,8 @@ var base = require( './base.js' ); * @throws {TypeError} first argument must be a valid transpose operation * @throws {RangeError} second argument must be a nonnegative integer * @throws {RangeError} third argument must be a nonnegative integer +* @throws {RangeError} sixth argument must be a nonnegative integer +* @throws {RangeError} seventh argument must be a nonnegative integer * @throws {RangeError} tenth argument must be non-zero * @throws {RangeError} fourteenth argument must be non-zero * @returns {Complex64Array} `y` @@ -72,6 +74,12 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, if ( N < 0 ) { throw new RangeError( format( 'invalid argument. Third argument must be a nonnegative integer. Value: `%d`.', N ) ); } + if ( strideA1 === 0 ) { + throw new RangeError( format( 'invalid argument. Sixth argument must be non-zero. Value: `%d`.', strideX ) ); + } + if ( strideA2 === 0 ) { + throw new RangeError( format( 'invalid argument. Seventh argument must be non-zero. Value: `%d`.', strideX ) ); + } if ( strideX === 0 ) { throw new RangeError( format( 'invalid argument. Tenth argument must be non-zero. Value: `%d`.', strideX ) ); } From 17e309cb812eafd73b9f5d8f903825c3e32e12f0 Mon Sep 17 00:00:00 2001 From: Divit Date: Fri, 20 Mar 2026 18:45:19 +0000 Subject: [PATCH 11/29] chore: clean up --- 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: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js index e6abb567807e..e0ad1365747f 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js @@ -75,10 +75,10 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, throw new RangeError( format( 'invalid argument. Third argument must be a nonnegative integer. Value: `%d`.', N ) ); } if ( strideA1 === 0 ) { - throw new RangeError( format( 'invalid argument. Sixth argument must be non-zero. Value: `%d`.', strideX ) ); + throw new RangeError( format( 'invalid argument. Sixth argument must be non-zero. Value: `%d`.', strideA1 ) ); } if ( strideA2 === 0 ) { - throw new RangeError( format( 'invalid argument. Seventh argument must be non-zero. Value: `%d`.', strideX ) ); + throw new RangeError( format( 'invalid argument. Seventh argument must be non-zero. Value: `%d`.', strideA2 ) ); } if ( strideX === 0 ) { throw new RangeError( format( 'invalid argument. Tenth argument must be non-zero. Value: `%d`.', strideX ) ); From 14544517f542c220365762d077bde62b4f6433e3 Mon Sep 17 00:00:00 2001 From: Divit Date: Thu, 9 Apr 2026 11:44:56 +0000 Subject: [PATCH 12/29] test: cover zero-beta branch --- 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: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/blas/base/cgemv/lib/ndarray.js | 4 +- .../blas/base/cgemv/test/test.cgemv.js | 54 +++++++++++++++++++ .../blas/base/cgemv/test/test.ndarray.js | 46 ++++++++++++++++ 3 files changed, 102 insertions(+), 2 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js index e0ad1365747f..6e6ece3515d0 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js @@ -45,8 +45,8 @@ var base = require( './base.js' ); * @throws {TypeError} first argument must be a valid transpose operation * @throws {RangeError} second argument must be a nonnegative integer * @throws {RangeError} third argument must be a nonnegative integer -* @throws {RangeError} sixth argument must be a nonnegative integer -* @throws {RangeError} seventh argument must be a nonnegative integer +* @throws {RangeError} sixth argument must be non-zero +* @throws {RangeError} seventh argument must be non-zero * @throws {RangeError} tenth argument must be non-zero * @throws {RangeError} fourteenth argument must be non-zero * @returns {Complex64Array} `y` diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.cgemv.js b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.cgemv.js index 664c3b3d711d..45dc58100fef 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.cgemv.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.cgemv.js @@ -663,6 +663,60 @@ tape( 'if `α` is `0`, the function scales the second input vector by `β` (colu 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 Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( 0.0, 0.0 ); + beta = new Complex64( 0.0, 0.0 ); + + expected = new Complex64Array( data.y.length ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.deepEqual( out, expected, true, 'returns expected value' ); + + t.end(); +}); + +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 Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( 0.0, 0.0 ); + beta = new Complex64( 0.0, 0.0 ); + + expected = new Complex64Array( data.y.length ); + + out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); + t.deepEqual( 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; diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js index 5c67dc9a2f32..447f88809d29 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js @@ -154,6 +154,52 @@ tape( 'the function throws an error if provided an invalid third argument', func } }); +tape( 'the function throws an error if provided an invalid sixth 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() { + cgemv( data.trans, data.M, data.N, new Complex64( data.alpha[0], data.alpha[1] ), new Complex64Array( data.A ), value, data.strideA2, data.offsetA, new Complex64Array( data.x ), data.strideX, data.offsetX, new Complex64( data.beta[0], data.beta[1] ), new Complex64Array( data.y ), data.strideY, data.offsetY ); + }; + } +}); + +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 + ]; + + 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() { + cgemv( data.trans, data.M, data.N, new Complex64( data.alpha[0], data.alpha[1] ), new Complex64Array( data.A ), data.strideA1, value, data.offsetA, new Complex64Array( data.x ), data.strideX, data.offsetX, new Complex64( data.beta[0], data.beta[1] ), new Complex64Array( 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; From 7fe33f1c101ba7f812dfaae3e87bc7ddb04bc142 Mon Sep 17 00:00:00 2001 From: Divit Date: Thu, 9 Apr 2026 13:46:09 +0000 Subject: [PATCH 13/29] test: cover zero-beta branch in ndarray --- 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: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../blas/base/cgemv/test/test.ndarray.js | 54 +++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js index 447f88809d29..5ad27927ee8f 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js @@ -694,6 +694,60 @@ tape( 'if `α` is `0`, the function scales the second input vector by `β` (colu 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 Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( 0.0, 0.0 ); + beta = new Complex64( 0.0, 0.0 ); + + expected = new Complex64Array( data.y.length ); + + out = cgemv( 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.deepEqual( out, expected, true, 'returns expected value' ); + + t.end(); +}); + +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 Complex64Array( data.A ); + x = new Complex64Array( data.x ); + y = new Complex64Array( data.y ); + + alpha = new Complex64( 0.0, 0.0 ); + beta = new Complex64( 0.0, 0.0 ); + + expected = new Complex64Array( data.y.length ); + + out = cgemv( 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.deepEqual( 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; From 264ecd49e30339a34b87975050a4f2c6959630c2 Mon Sep 17 00:00:00 2001 From: Divit Date: Wed, 15 Apr 2026 05:59:17 +0000 Subject: [PATCH 14/29] test: remove strideA1 and strideA2 validations and tests --- 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: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/blas/base/cgemv/lib/ndarray.js | 8 ---- .../blas/base/cgemv/test/test.ndarray.js | 46 ------------------- 2 files changed, 54 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js index 6e6ece3515d0..2fd03deae30c 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js @@ -45,8 +45,6 @@ var base = require( './base.js' ); * @throws {TypeError} first argument must be a valid transpose operation * @throws {RangeError} second argument must be a nonnegative integer * @throws {RangeError} third argument must be a nonnegative integer -* @throws {RangeError} sixth argument must be non-zero -* @throws {RangeError} seventh argument must be non-zero * @throws {RangeError} tenth argument must be non-zero * @throws {RangeError} fourteenth argument must be non-zero * @returns {Complex64Array} `y` @@ -74,12 +72,6 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, if ( N < 0 ) { throw new RangeError( format( 'invalid argument. Third argument must be a nonnegative integer. Value: `%d`.', N ) ); } - if ( strideA1 === 0 ) { - throw new RangeError( format( 'invalid argument. Sixth argument must be non-zero. Value: `%d`.', strideA1 ) ); - } - if ( strideA2 === 0 ) { - throw new RangeError( format( 'invalid argument. Seventh argument must be non-zero. Value: `%d`.', strideA2 ) ); - } if ( strideX === 0 ) { throw new RangeError( format( 'invalid argument. Tenth argument must be non-zero. Value: `%d`.', strideX ) ); } diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js index 5ad27927ee8f..6b65b41f6360 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js @@ -154,52 +154,6 @@ tape( 'the function throws an error if provided an invalid third argument', func } }); -tape( 'the function throws an error if provided an invalid sixth 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() { - cgemv( data.trans, data.M, data.N, new Complex64( data.alpha[0], data.alpha[1] ), new Complex64Array( data.A ), value, data.strideA2, data.offsetA, new Complex64Array( data.x ), data.strideX, data.offsetX, new Complex64( data.beta[0], data.beta[1] ), new Complex64Array( data.y ), data.strideY, data.offsetY ); - }; - } -}); - -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 - ]; - - 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() { - cgemv( data.trans, data.M, data.N, new Complex64( data.alpha[0], data.alpha[1] ), new Complex64Array( data.A ), data.strideA1, value, data.offsetA, new Complex64Array( data.x ), data.strideX, data.offsetX, new Complex64( data.beta[0], data.beta[1] ), new Complex64Array( 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; From 29e0eda2f4f86fab83c837660a276379efe33bd9 Mon Sep 17 00:00:00 2001 From: Divit Date: Wed, 15 Apr 2026 08:38:03 +0000 Subject: [PATCH 15/29] refactor: update index increment to stride addition --- 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: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/blas/base/cgemv/lib/base.js | 63 +++++++++++-------- 1 file changed, 38 insertions(+), 25 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js index c8eb8eee1477..14a077c16531 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js @@ -106,9 +106,8 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, var xlen; var ylen; var sign; - var sa0; - var sa1; - var oa2; + var da0; + var da1; var rea; var ima; var rex; @@ -166,16 +165,6 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, sign = 1; } - if ( isrm ) { - // For row-major matrices, the last dimension has the fastest changing index... - sa0 = strideA2 * 2; // offset increment for innermost loop - sa1 = strideA1 * 2; // offset increment for outermost loop - } else { // isColMajor - // For column-major matrices, the first dimension has the fastest changing index... - sa0 = strideA1 * 2; // offset increment for innermost loop - sa1 = strideA2 * 2; // offset increment for outermost loop - } - // Vector indexing base oa = offsetA * 2; ox = offsetX * 2; @@ -190,42 +179,66 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, ( !isrm && !isTransposed( trans ) ) || ( isrm && isTransposed( trans ) ) ) { + if ( isrm ) { + da0 = strideA2 * 2; + da1 = ( strideA1 * 2 ) - ( ylen * strideA2 * 2 ); + } else { + da0 = strideA1 * 2; + da1 = ( strideA2 * 2 ) - ( ylen * strideA1 * 2 ); + } + ia = oa; + ix = ox; for ( i1 = 0; i1 < xlen; i1++ ) { - ix = ox + ( i1 * sx ); - oa2 = oa + ( i1 * sa1 ); rex = viewX[ ix ]; imx = viewX[ ix + 1 ]; retmp = f32( ( realpha * rex ) - ( imalpha * imx ) ); imtmp = f32( ( realpha * imx ) + ( imalpha * rex ) ); - for ( i0 = 0; i0 < ylen; i0++ ) { - ia = oa2 + ( i0 * sa0 ); - rea = viewA[ ia ]; - ima = sign * viewA[ ia + 1 ]; - iy = oy + ( i0 * sy ); - muladd( rea, ima, retmp, imtmp, viewY[ iy ], viewY[ iy + 1 ], viewY, 1, iy ); // eslint-disable-line max-len + if ( retmp === 0.0 && imtmp === 0.0 ) { + ia += da0 * ylen; + } else { + iy = oy; + for ( i0 = 0; i0 < ylen; i0++ ) { + 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; + } } + ix += sx; + ia += da1; } return y; } // Form: y = α*A^T*x + y // ( !isrm && isTransposed( trans ) ) || ( isrm && !isTransposed( trans ) ) + if ( isrm ) { + da0 = strideA2 * 2; + da1 = ( strideA1 * 2 ) - ( xlen * strideA2 * 2 ); + } else { + da0 = strideA1 * 2; + da1 = ( strideA2 * 2 ) - ( xlen * strideA1 * 2 ); + } + ia = oa; + iy = oy; for ( i1 = 0; i1 < ylen; i1++ ) { - oa2 = oa + ( i1 * sa1 ); retmp = 0.0; imtmp = 0.0; + ix = ox; for ( i0 = 0; i0 < xlen; i0++ ) { - ia = oa2 + ( i0 * sa0 ); - ix = ox + ( i0 * sx ); rea = viewA[ ia ]; ima = sign * viewA[ ia + 1 ]; rex = viewX[ ix ]; imx = viewX[ ix + 1 ]; retmp = f32( retmp + f32( ( rea * rex ) - ( ima * imx ) ) ); imtmp = f32( imtmp + f32( ( rea * imx ) + ( ima * rex ) ) ); + ix += sx; + ia += da0; } - iy = oy + ( i1 * sy ); 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 4bb7daf2a1b0e44a4b0128bad795418ab73145a7 Mon Sep 17 00:00:00 2001 From: Divit Date: Sat, 18 Apr 2026 14:11:09 +0000 Subject: [PATCH 16/29] chore: clean up in benchmarks --- 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/cgemv/benchmark/benchmark.js | 4 ++-- .../@stdlib/blas/base/cgemv/benchmark/benchmark.ndarray.js | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.js index 37b530aa3d31..cd2c38863493 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.js @@ -83,12 +83,12 @@ function createBenchmark( N ) { b.tic(); for ( i = 0; i < b.iterations; i++ ) { z = cgemv( 'row-major', 'no-transpose', N, N, alpha, A, N, x, 1, beta, y, 1 ); - if ( isnanf( z[ i% ( z.length ) ] ) ) { + if ( isnanf( z[ i%z.length ] ) ) { b.fail( 'should not return NaN' ); } } b.toc(); - if ( isnanf( z[ i % ( z.length ) ] ) ) { + if ( isnanf( z[ i%z.length ] ) ) { b.fail( 'should not return NaN' ); } b.pass( 'benchmark finished' ); diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.ndarray.js index ef7ab3d7df5d..3ea977458728 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/benchmark/benchmark.ndarray.js @@ -83,12 +83,12 @@ function createBenchmark( N ) { b.tic(); for ( i = 0; i < b.iterations; i++ ) { z = cgemv( 'no-transpose', N, N, alpha, A, 1, N, 0, x, 1, 0, beta, y, 1, 0 ); - if ( isnanf( z[ i % ( z.length ) ] ) ) { + if ( isnanf( z[ i%z.length ] ) ) { b.fail( 'should not return NaN' ); } } b.toc(); - if ( isnanf( z[ i % ( z.length ) ] ) ) { + if ( isnanf( z[ i%z.length ] ) ) { b.fail( 'should not return NaN' ); } b.pass( 'benchmark finished' ); From 3db65c87ecdcee4c4d0ab3d0b7ef883a17517398 Mon Sep 17 00:00:00 2001 From: Divit Date: Sat, 18 Apr 2026 14:18:04 +0000 Subject: [PATCH 17/29] chore: clean up in index.d.ts --- 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: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: passed - task: lint_license_headers status: passed --- --- lib/node_modules/@stdlib/blas/base/cgemv/docs/types/index.d.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/index.d.ts index f6210808184b..f0a259bd1050 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/index.d.ts @@ -29,7 +29,7 @@ import { Complex64 } from '@stdlib/types/complex'; */ interface Routine { /** - * Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y`, where `α` and `β` are complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex matrix. + * Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y`, where `α` and `β` are scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex matrix. * * @param order - storage layout * @param trans - specifies whether `A` should be transposed, conjugate-transposed, or not transposed From dcd87a543b8d565d8cc110cd9b674d357e1ac496 Mon Sep 17 00:00:00 2001 From: Divit Date: Sat, 18 Apr 2026 14:33:57 +0000 Subject: [PATCH 18/29] chore: clean up in docs --- 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: passed - 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: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: passed - task: lint_license_headers status: passed --- --- .../@stdlib/blas/base/cgemv/docs/repl.txt | 50 +++++++++---------- .../blas/base/cgemv/docs/types/index.d.ts | 6 +-- 2 files changed, 27 insertions(+), 29 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/docs/repl.txt b/lib/node_modules/@stdlib/blas/base/cgemv/docs/repl.txt index f6536d75c35c..230506c7af81 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/docs/repl.txt +++ b/lib/node_modules/@stdlib/blas/base/cgemv/docs/repl.txt @@ -1,16 +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 complex - scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex - 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 `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 @@ -20,8 +19,7 @@ trans: string Specifies whether `A` should be transposed, conjugate-transposed, or not - transposed. Accepted values typically include: 'no-transpose', - 'transpose', 'conjugate-transpose'. + transposed. M: integer Number of rows in `A`. @@ -30,26 +28,26 @@ Number of columns in `A`. α: Complex64 - Complex scalar constant. + Scalar constant. A: Complex64Array - Complex input matrix. + Input matrix. lda: integer Stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`). x: Complex64Array - First complex input vector. + First input vector. sx: integer Index increment for `x`. β: Complex64 - Complex scalar constant. + Scalar constant. y: Complex64Array - Second complex input vector. + Second input vector. sy: integer Index increment for `y`. @@ -57,7 +55,7 @@ Returns ------- y: Complex64Array - Second complex input vector. + Second input vector. Examples -------- @@ -107,18 +105,18 @@ {{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 complex scalars, `x` and `y` are complex - vectors, and `A` is an `M` by `N` complex matrix. + 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 + 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`. + Specifies whether `A` should be transposed, conjugate-transposed, or not + transposed. M: integer Number of rows in `A`. @@ -127,10 +125,10 @@ Number of columns in `A`. α: Complex64 - Complex scalar constant. + Scalar constant. A: Complex64Array - Complex input matrix. + Input matrix. sa1: integer Stride of the first dimension of `A`. @@ -142,7 +140,7 @@ Starting index (offset) for `A`. x: Complex64Array - First complex input vector. + First input vector. sx: integer Index increment for `x`. @@ -151,10 +149,10 @@ Starting index (offset) for `x`. β: Complex64 - Complex scalar constant. + Scalar constant. y: Complex64Array - Second complex input vector. + Second input vector. sy: integer Index increment for `y`. @@ -165,7 +163,7 @@ Returns ------- y: Complex64Array - Second complex input vector. + Second input vector. Examples -------- diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/index.d.ts index f0a259bd1050..f4d2e01e78eb 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/index.d.ts @@ -29,7 +29,7 @@ import { Complex64 } from '@stdlib/types/complex'; */ interface Routine { /** - * Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y`, where `α` and `β` are scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex matrix. + * Performs one of the matrix-vector operations `y = α*A*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. * * @param order - storage layout * @param trans - specifies whether `A` should be transposed, conjugate-transposed, or not transposed @@ -61,7 +61,7 @@ interface Routine { ( order: Layout, trans: TransposeOperation, M: number, N: number, alpha: Complex64, A: Complex64Array, LDA: number, x: Complex64Array, strideX: number, beta: Complex64, y: Complex64Array, strideY: number ): Complex64Array; /** - * Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y`, using alternative indexing semantics. + * 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` @@ -97,7 +97,7 @@ interface Routine { } /** -* Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y`, where `α` and `β` are complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex 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 From 7d40bfd831e1effe0d38223d07b2c9c1ba15956f Mon Sep 17 00:00:00 2001 From: Divit Date: Sat, 18 Apr 2026 14:35:47 +0000 Subject: [PATCH 19/29] chore: clean up in example --- 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: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/blas/base/cgemv/examples/index.js | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/examples/index.js b/lib/node_modules/@stdlib/blas/base/cgemv/examples/index.js index eb0a6e6389b6..39c490d62493 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/examples/index.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/examples/index.js @@ -32,26 +32,18 @@ var M = 3; var N = 3; var x = filledarrayBy( N, 'complex64', rand ); -console.log( x.get( 0 ).toString() ); - var y = filledarrayBy( M, 'complex64', rand ); -console.log( y.get( 0 ).toString() ); - var A = filledarrayBy( M*N, 'complex64', rand ); -console.log( A.get( 0 ).toString() ); var alpha = new Complex64( 2.0, 3.0 ); -console.log( alpha.toString() ); - var beta = new Complex64( 3.0, -2.0 ); -console.log( beta.toString() ); cgemv( 'row-major', 'no-transpose', M, N, alpha, A, M, x, 1, beta, y, 1 ); // Print the results: -logEach( '(%s)', y ); +logEach( '%s', y ); cgemv.ndarray( 'no-transpose', M, N, alpha, A, 1, M, 0, x, 1, 0, beta, y, 1, 0 ); // Print the results: -logEach( '(%s)', y ); +logEach( '%s', y ); From 5c44017ec86fe8ae95c2a2e7c4b15776e6f1f2c7 Mon Sep 17 00:00:00 2001 From: Divit Date: Sat, 18 Apr 2026 15:55:11 +0000 Subject: [PATCH 20/29] chore: clean up in lib --- 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: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/blas/base/cgemv/lib/base.js | 77 +++++++++---------- .../@stdlib/blas/base/cgemv/lib/cgemv.js | 23 ++---- .../@stdlib/blas/base/cgemv/lib/index.js | 3 +- .../@stdlib/blas/base/cgemv/lib/ndarray.js | 13 ++-- 4 files changed, 50 insertions(+), 66 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js index 14a077c16531..e62b1b7e8c81 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js @@ -59,22 +59,22 @@ function isTransposed( str ) { // NOTE: consider moving to a separate helper uti // MAIN // /** -* 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 complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex 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 * @param {NonNegativeInteger} M - number of rows in the matrix `A` * @param {NonNegativeInteger} N - number of columns in the matrix `A` -* @param {Complex64} alpha - complex scalar constant -* @param {Complex64Array} A - complex input matrix +* @param {Complex64} alpha - scalar constant +* @param {Complex64Array} 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 {Complex64Array} x - first complex input vector +* @param {Complex64Array} x - first input vector * @param {integer} strideX - `x` stride length * @param {NonNegativeInteger} offsetX - starting index for `x` -* @param {Complex64} beta - complex scalar constant -* @param {Complex64Array} y - second complex input vector +* @param {Complex64} beta - scalar constant +* @param {Complex64Array} y - second input vector * @param {integer} strideY - `y` stride length * @param {NonNegativeInteger} offsetY - starting index for `y` * @returns {Complex64Array} `y` @@ -106,6 +106,8 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, var xlen; var ylen; var sign; + var sa1; + var sa2; var da0; var da1; var rea; @@ -123,10 +125,9 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, var i1; var ia; - // Layout - isrm = isRowMajor( [ strideA1, strideA2 ] ); + // Note on variable naming convention: sa#, ix#, i# where # corresponds to the loop number, with `0` being the innermost loop... - // Lengths + isrm = isRowMajor( [ strideA1, strideA2 ] ); if ( isTransposed( trans ) ) { xlen = M; ylen = N; @@ -134,7 +135,6 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, xlen = N; ylen = M; } - // Decompose scalars rebeta = realf( beta ); imbeta = imagf( beta ); @@ -147,30 +147,23 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, } else if ( rebeta !== 1.0 || imbeta !== 0.0 ) { cscal( ylen, beta, y, strideY, offsetY ); } - - // If alpha is zero, early return y if ( realpha === 0.0 && imalpha === 0.0 ) { return y; } - - // Reinterpret arrays to raw numeric views + // Reinterpret arrays to real-valued views viewA = reinterpret( A, 0 ); viewX = reinterpret( x, 0 ); viewY = reinterpret( y, 0 ); - - // Set sign to handle conjugation: flip the imaginary part for conjugate-transpose if ( trans === 'conjugate-transpose' ) { sign = -1; } else { sign = 1; } - - // Vector indexing base oa = offsetA * 2; + sa1 = strideA1 *2; + sa2 = strideA2 *2; ox = offsetX * 2; oy = offsetY * 2; - - // Vector strides sx = strideX * 2; sy = strideY * 2; @@ -180,27 +173,29 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, ( isrm && isTransposed( trans ) ) ) { if ( isrm ) { - da0 = strideA2 * 2; - da1 = ( strideA1 * 2 ) - ( ylen * strideA2 * 2 ); - } else { - da0 = strideA1 * 2; - da1 = ( strideA2 * 2 ) - ( ylen * strideA1 * 2 ); + // For row-major matrices, the last dimension has the fastest changing index... + 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 = sa1; // stride for innermost loop + da1 = sa2 - (ylen*sa1); // stride for outermost loop } ia = oa; ix = ox; for ( i1 = 0; i1 < xlen; i1++ ) { rex = viewX[ ix ]; - imx = viewX[ ix + 1 ]; - retmp = f32( ( realpha * rex ) - ( imalpha * imx ) ); - imtmp = f32( ( realpha * imx ) + ( imalpha * rex ) ); + imx = viewX[ ix+1 ]; + retmp = f32(f32(realpha*rex) - f32(imalpha*imx)); + imtmp = f32(f32(realpha*imx) + f32(imalpha*rex)); if ( retmp === 0.0 && imtmp === 0.0 ) { ia += da0 * ylen; } else { iy = oy; for ( i0 = 0; i0 < ylen; i0++ ) { 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 + 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; } @@ -210,15 +205,17 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, } return y; } - // Form: y = α*A^T*x + y + // ( !isrm && isTransposed( trans ) ) || ( isrm && !isTransposed( trans ) ) if ( isrm ) { - da0 = strideA2 * 2; - da1 = ( strideA1 * 2 ) - ( xlen * strideA2 * 2 ); + // For row-major matrices, the last dimension has the fastest changing index... + da0 = sa2; // stride for innermost loop + da1 = sa1 - (xlen*sa2); // stride for outermost loop } else { - da0 = strideA1 * 2; - da1 = ( strideA2 * 2 ) - ( xlen * strideA1 * 2 ); + // For column-major matrices, the first dimension has the fastest changing index... + da0 = sa1; // stride for innermost loop + da1 = sa2 - (xlen*sa1); // stride for outermost loop } ia = oa; iy = oy; @@ -228,15 +225,15 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, ix = ox; for ( i0 = 0; i0 < xlen; i0++ ) { rea = viewA[ ia ]; - ima = sign * viewA[ ia + 1 ]; + ima = sign * viewA[ ia+1 ]; rex = viewX[ ix ]; - imx = viewX[ ix + 1 ]; - retmp = f32( retmp + f32( ( rea * rex ) - ( ima * imx ) ) ); - imtmp = f32( imtmp + f32( ( rea * imx ) + ( ima * rex ) ) ); + imx = viewX[ ix+1 ]; + retmp = f32(retmp + f32(rea*rex) - f32(ima*imx)); + imtmp = f32(imtmp + f32(rea*imx) + f32(ima*rex)); ix += sx; ia += da0; } - muladd( realpha, imalpha, retmp, imtmp, viewY[ iy ], viewY[ iy + 1 ], viewY, 1, iy ); // eslint-disable-line max-len + muladd( realpha, imalpha, retmp, imtmp, viewY[ iy ], viewY[ iy+1 ], viewY, 1, iy ); // eslint-disable-line max-len iy += sy; ia += da1; } diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/cgemv.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/cgemv.js index 1a5f37ba6f38..59d71a870b62 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/lib/cgemv.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/cgemv.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 realf = require( '@stdlib/complex/float32/real' ); -var imagf = require( '@stdlib/complex/float32/imag' ); var format = require( '@stdlib/string/format' ); var base = require( './base.js' ); @@ -34,18 +32,18 @@ var base = require( './base.js' ); // MAIN // /** -* 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 complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex 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 * @param {NonNegativeInteger} M - number of rows in the matrix `A` * @param {NonNegativeInteger} N - number of columns in the matrix `A` -* @param {Complex64} alpha - complex scalar constant -* @param {Complex64Array} A - complex input matrix +* @param {Complex64} alpha - scalar constant +* @param {Complex64Array} A - input matrix * @param {PositiveInteger} LDA - stride of the first dimension of `A` -* @param {Complex64Array} x - first complex input vector +* @param {Complex64Array} x - first input vector * @param {integer} strideX - `x` stride length -* @param {Complex64} beta - complex scalar constant +* @param {Complex64} beta - scalar constant * @param {Complex64Array} y - second input vector * @param {integer} strideY - `y` stride length * @throws {TypeError} first argument must be a valid order @@ -71,10 +69,6 @@ var base = require( './base.js' ); * // y => [ -10.0, 11.0, -12.0, 14.0, -14.0, 17.0, -16.0, 20.0 ] */ function cgemv( order, trans, M, N, alpha, A, LDA, x, strideX, beta, y, strideY ) { // eslint-disable-line max-params, max-len - var realpha; - var imalpha; - var rebeta; - var imbeta; var iscm; var vala; var xlen; @@ -111,13 +105,8 @@ function cgemv( order, trans, M, N, alpha, A, LDA, x, strideX, beta, y, strideY if ( strideY === 0 ) { throw new RangeError( format( 'invalid argument. Twelfth argument must be non-zero. Value: `%d`.', strideY ) ); } - rebeta = realf( beta ); - imbeta = imagf( beta ); - realpha = realf( alpha ); - imalpha = imagf( alpha ); - // Check if we can early return... - if ( M === 0 || N === 0 || ( realpha === 0.0 && imalpha === 0.0 && rebeta === 1.0 && imbeta === 0.0 ) ) { // eslint-disable-line max-len + if ( M === 0 || N === 0 ) { return y; } if ( trans === 'no-transpose' ) { diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/index.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/index.js index 9b542876e752..83b8c036dca5 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/lib/index.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/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` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y`, where `α` and `β` are complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex 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/cgemv * @@ -64,7 +64,6 @@ var main = require( './main.js' ); var cgemv; var tmp = tryRequire( join( __dirname, './native.js' ) ); - if ( isError( tmp ) ) { cgemv = main; } else { diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js index 2fd03deae30c..35ea6e68a66e 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/ndarray.js @@ -25,21 +25,21 @@ var format = require( '@stdlib/string/format' ); var base = require( './base.js' ); /** -* 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 complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex 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` * @param {NonNegativeInteger} N - number of columns in the matrix `A` -* @param {Complex64} alpha - complex scalar constant -* @param {Complex64Array} A - complex input matrix +* @param {Complex64} alpha - scalar constant +* @param {Complex64Array} 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 {Complex64Array} x - first complex input vector +* @param {Complex64Array} x - first input vector * @param {integer} strideX - `x` stride length * @param {NonNegativeInteger} offsetX - starting index for `x` -* @param {Complex64} beta - complex scalar constant -* @param {Complex64Array} y - second complex input vector +* @param {Complex64} beta - scalar constant +* @param {Complex64Array} y - second input vector * @param {integer} strideY - `y` stride length * @param {NonNegativeInteger} offsetY - starting index for `y` * @throws {TypeError} first argument must be a valid transpose operation @@ -82,7 +82,6 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, 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 } From ea482273348b4f704bda66fca46e0437e3325c67 Mon Sep 17 00:00:00 2001 From: Divit Date: Sat, 18 Apr 2026 16:03:53 +0000 Subject: [PATCH 21/29] chore: clean up in readme --- 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: 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: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../@stdlib/blas/base/cgemv/README.md | 36 ++++++++++++------- .../@stdlib/blas/base/cgemv/package.json | 2 +- 2 files changed, 25 insertions(+), 13 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/README.md b/lib/node_modules/@stdlib/blas/base/cgemv/README.md index f98743996863..85987410e396 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/README.md +++ b/lib/node_modules/@stdlib/blas/base/cgemv/README.md @@ -32,13 +32,15 @@ var cgemv = require( '@stdlib/blas/base/cgemv' ); #### cgemv( order, trans, M, N, α, A, LDA, x, sx, β, y, sy ) -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 complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex 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 Complex64Array = require( '@stdlib/array/complex64' ); var Complex64 = require( '@stdlib/complex/float32/ctor' ); -var A = new Complex64Array( [ 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 ] ); // eslint-disable-line max-params, max-len +var A = new Complex64Array( [ 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 Complex64Array( [ 1.0, 1.0, 2.0, 2.0 ] ); var y = new Complex64Array( [ 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); @@ -55,24 +57,26 @@ The function has the following parameters: - **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`. -- **α**: complex scalar constant. -- **A**: complex input matrix stored in linear memory as a [`Complex64Array`][@stdlib/array/complex64]. +- **α**: scalar constant. +- **A**: input matrix stored in linear memory as a [`Complex64Array`][@stdlib/array/complex64]. - **LDA**: stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`). - **x**: input [`Complex64Array`][@stdlib/array/complex64]. - **sx**: stride length for `x`. -- **β**: complex scalar constant. +- **β**: scalar constant. - **y**: output [`Complex64Array`][@stdlib/array/complex64]. - **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 Complex64Array = require( '@stdlib/array/complex64' ); var Complex64 = require( '@stdlib/complex/float32/ctor' ); -var A = new Complex64Array( [ 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 ] ); // eslint-disable-line max-params, max-len +var A = new Complex64Array( [ 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 Complex64Array( [ 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 2.0, 2.0 ] ); -var y = new Complex64Array( [ 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 ] ); // eslint-disable-line max-params, max-len +var y = new Complex64Array( [ 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 Complex64( 0.5, 0.5 ); var beta = new Complex64( 0.5, -0.5 ); @@ -85,14 +89,16 @@ Note that indexing is relative to the first index. To introduce an offset, use [ + + ```javascript var Complex64Array = require( '@stdlib/array/complex64' ); var Complex64 = require( '@stdlib/complex/float32/ctor' ); // Initial arrays... var x0 = new Complex64Array( [ 0.0, 0.0, 1.0, 1.0, 2.0, 2.0 ] ); -var y0 = new Complex64Array( [ 0.0, 0.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); // eslint-disable-line max-params, max-len -var A = new Complex64Array( [ 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 ] ); // eslint-disable-line max-params, max-len +var y0 = new Complex64Array( [ 0.0, 0.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0 ] ); +var A = new Complex64Array( [ 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 Complex64( 0.5, 0.5 ); var beta = new Complex64( 0.5, -0.5 ); @@ -109,7 +115,9 @@ cgemv( 'column-major', 'no-transpose', 4, 2, alpha, A, 4, x1, 1, beta, y1, 1 ); #### cgemv.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` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y` using alternative indexing semantics and where `α` and `β` are complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex 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. + + ```javascript var Complex64Array = require( '@stdlib/array/complex64' ); @@ -136,6 +144,8 @@ The function has the following additional parameters: While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameters support indexing semantics based on starting indices. For example, + + ```javascript var Complex64Array = require( '@stdlib/array/complex64' ); var Complex64 = require( '@stdlib/complex/float32/ctor' ); @@ -171,6 +181,8 @@ cgemv.ndarray( 'no-transpose', 4, 2, alpha, A, 1, 4, 0, x, 1, 1, beta, y, -2, 6 + + ```javascript var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ); var Complex64 = require( '@stdlib/complex/float32/ctor' ); @@ -195,12 +207,12 @@ var beta = new Complex64( 0.5, -0.5 ); cgemv( 'column-major', 'no-transpose', M, N, alpha, A, 4, x, 1, beta, y, 1 ); // Print the results: -logEach( '(%s)', x ); +logEach( '%s', x ); cgemv.ndarray( 'no-transpose', M, N, alpha, A, 1, 4, 0, x, 1, 0, beta, y, 1, 0 ); // Print the results: -logEach( '(%s)', x ); +logEach( '%s', x ); ```
diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/package.json b/lib/node_modules/@stdlib/blas/base/cgemv/package.json index 4da9236bf4d8..9a2fa7093968 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/package.json +++ b/lib/node_modules/@stdlib/blas/base/cgemv/package.json @@ -1,7 +1,7 @@ { "name": "@stdlib/blas/base/cgemv", "version": "0.0.0", - "description": "Performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` where `α` and `β` are complex scalars, `x` and `y` are complex vectors, and `A` is an `M` by `N` complex matrix.", + "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 5203da820f843b2a795cd48f1b3e4e9dac521b4f Mon Sep 17 00:00:00 2001 From: Athan Date: Mon, 20 Apr 2026 17:33:41 -0700 Subject: [PATCH 22/29] Apply suggestions from code review Co-authored-by: Athan Signed-off-by: Athan --- lib/node_modules/@stdlib/blas/base/cgemv/docs/types/index.d.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/index.d.ts index f4d2e01e78eb..980cf5c96c47 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/blas/base/cgemv/docs/types/index.d.ts @@ -29,7 +29,7 @@ import { Complex64 } from '@stdlib/types/complex'; */ interface Routine { /** - * Performs one of the matrix-vector operations `y = α*A*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. + * 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 From 6a7426522233aa0563ced871bd454ae4324e9be1 Mon Sep 17 00:00:00 2001 From: Athan Date: Mon, 20 Apr 2026 17:36:57 -0700 Subject: [PATCH 23/29] docs: fix comment Signed-off-by: Athan --- lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js index e62b1b7e8c81..4f1e6fe13804 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js @@ -51,7 +51,7 @@ var muladd = require( '@stdlib/complex/float32/base/mul-add' ).assign; * var bool = isTransposed( 'no-transpose' ); * // returns false */ -function isTransposed( str ) { // NOTE: consider moving to a separate helper utility package +function isTransposed( str ) { // TODO: consider moving to a separate helper utility package return ( str !== 'no-transpose' ); } From 1921795bae85665dc17347e242c1db082b7caaad Mon Sep 17 00:00:00 2001 From: Athan Date: Mon, 20 Apr 2026 17:39:45 -0700 Subject: [PATCH 24/29] Apply suggestions from code review Co-authored-by: Athan Signed-off-by: Athan --- lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js index 4f1e6fe13804..86bf9c9f9484 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js @@ -135,7 +135,7 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, xlen = N; ylen = M; } - // Decompose scalars + // Decompose scalars into real and imaginary components: rebeta = realf( beta ); imbeta = imagf( beta ); realpha = realf( alpha ); @@ -150,7 +150,7 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, if ( realpha === 0.0 && imalpha === 0.0 ) { return y; } - // Reinterpret arrays to real-valued views + // Reinterpret arrays to real-valued views: viewA = reinterpret( A, 0 ); viewX = reinterpret( x, 0 ); viewY = reinterpret( y, 0 ); From e0854994f01c87e128def152be9ba33ee7f59c45 Mon Sep 17 00:00:00 2001 From: Athan Date: Mon, 20 Apr 2026 17:45:01 -0700 Subject: [PATCH 25/29] Apply suggestions from code review Co-authored-by: Athan Signed-off-by: Athan --- lib/node_modules/@stdlib/blas/base/cgemv/README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/README.md b/lib/node_modules/@stdlib/blas/base/cgemv/README.md index 85987410e396..f4baba5c0d7c 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/README.md +++ b/lib/node_modules/@stdlib/blas/base/cgemv/README.md @@ -20,7 +20,7 @@ limitations under the License. # cgemv -> Perform one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y` for complex-valued data. +> Perform one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*x + β*y` or `y = α*A^H*x + β*y`.
@@ -75,13 +75,13 @@ var Complex64Array = require( '@stdlib/array/complex64' ); var Complex64 = require( '@stdlib/complex/float32/ctor' ); var A = new Complex64Array( [ 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 Complex64Array( [ 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 2.0, 2.0 ] ); +var x = new Complex64Array( [ 1.0, 1.0, 0.0, 0.0, 2.0, 2.0, 0.0, 0.0 ] ); var y = new Complex64Array( [ 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 Complex64( 0.5, 0.5 ); var beta = new Complex64( 0.5, -0.5 ); -cgemv( 'column-major', 'no-transpose', 4, 2, alpha, A, 4, x, 3, beta, y, 2 ); +cgemv( '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 ] ``` From c9692c32dd1174b2c02ba37d9bf6250d2a66476a Mon Sep 17 00:00:00 2001 From: Athan Date: Mon, 20 Apr 2026 17:46:55 -0700 Subject: [PATCH 26/29] Apply suggestions from code review Co-authored-by: Athan Signed-off-by: Athan --- lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js index 86bf9c9f9484..3e4a05f57d14 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js @@ -150,7 +150,7 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, if ( realpha === 0.0 && imalpha === 0.0 ) { return y; } - // Reinterpret arrays to real-valued views: + // Reinterpret arrays as real-valued views of interleaved real and imaginary components: viewA = reinterpret( A, 0 ); viewX = reinterpret( x, 0 ); viewY = reinterpret( y, 0 ); From f7f5a83a987907ee4a3f854522a12fa2f7892efa Mon Sep 17 00:00:00 2001 From: Athan Date: Mon, 20 Apr 2026 18:14:13 -0700 Subject: [PATCH 27/29] test: clean-up --- 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: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../blas/base/cgemv/test/test.cgemv.js | 122 ++++++------- .../blas/base/cgemv/test/test.ndarray.js | 172 +++++++++--------- 2 files changed, 147 insertions(+), 147 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.cgemv.js b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.cgemv.js index 45dc58100fef..b6129d1a03de 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.cgemv.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.cgemv.js @@ -240,7 +240,7 @@ tape( 'the function throws an error if provided an invalid twelfth argument', fu } }); -tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*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; @@ -262,13 +262,13 @@ tape( 'the function performs one of the matrix-vector operations `y = α*A*x + expected = new Complex64Array( data.y_out ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); -tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*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; @@ -290,13 +290,13 @@ tape( 'the function performs one of the matrix-vector operations `y = α*A*x + expected = new Complex64Array( data.y_out ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); -tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `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; @@ -318,13 +318,13 @@ tape( 'the function performs one of the matrix-vector operations `y = α*A*x + expected = new Complex64Array( data.y_out ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); -tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `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; @@ -346,13 +346,13 @@ tape( 'the function performs one of the matrix-vector operations `y = α*A*x + expected = new Complex64Array( data.y_out ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); -tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*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; @@ -374,13 +374,13 @@ tape( 'the function performs one of the matrix-vector operations `y = α*A*x + expected = new Complex64Array( data.y_out ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); -tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*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; @@ -402,8 +402,8 @@ tape( 'the function performs one of the matrix-vector operations `y = α*A*x + expected = new Complex64Array( data.y_out ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -427,7 +427,7 @@ tape( 'the function returns a reference to the second input vector (column-major beta = new Complex64( data.beta[0], data.beta[1] ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); t.end(); }); @@ -453,12 +453,12 @@ tape( 'if either `M` or `N` is `0`, the function returns the second input vector expected = new Complex64Array( data.y ); out = cgemv( data.order, data.trans, 0, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); out = cgemv( data.order, data.trans, data.M, 0, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -485,12 +485,12 @@ tape( 'if either `M` or `N` is `0`, the function returns the second input vector expected = new Complex64Array( data.y ); out = cgemv( data.order, data.trans, 0, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); out = cgemv( data.order, data.trans, data.M, 0, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -517,8 +517,8 @@ tape( 'if `α` is `0` and `β` is `1`, the function returns the second input vec expected = new Complex64Array( data.y ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -545,8 +545,8 @@ tape( 'if `α` is `0` and `β` is `1`, the function returns the second input vec expected = new Complex64Array( data.y ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -573,8 +573,8 @@ tape( 'if `x` contains only zeros and `β` is `1`, the function returns the seco expected = new Complex64Array( data.y_out ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -601,8 +601,8 @@ tape( 'if `x` contains only zeros and `β` is `1`, the function returns the seco expected = new Complex64Array( data.y_out ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -629,8 +629,8 @@ tape( 'if `α` is `0`, the function scales the second input vector by `β` (row- expected = new Complex64Array( data.y_out ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -657,8 +657,8 @@ tape( 'if `α` is `0`, the function scales the second input vector by `β` (colu expected = new Complex64Array( data.y_out ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -685,7 +685,7 @@ tape( 'if `α` is `0` and `β` is `0`, the function zeros the second input vecto expected = new Complex64Array( data.y.length ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.deepEqual( out, expected, true, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -712,7 +712,7 @@ tape( 'if `α` is `0` and `β` is `0`, the function zeros the second input vecto expected = new Complex64Array( data.y.length ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.deepEqual( out, expected, true, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -739,8 +739,8 @@ tape( 'if `x` contains only zeros and `β` is not `1`, the function scales the s expected = new Complex64Array( data.y_out ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -767,8 +767,8 @@ tape( 'if `x` contains only zeros and `β` is not `1`, the function scales the s expected = new Complex64Array( data.y_out ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -795,8 +795,8 @@ tape( 'the function supports specifying `x` and `y` strides (row-major)', functi expected = new Complex64Array( data.y_out ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -823,8 +823,8 @@ tape( 'the function supports specifying `x` and `y` strides (column-major)', fun expected = new Complex64Array( data.y_out ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -851,8 +851,8 @@ tape( 'the function supports specifying a negative `x` stride (row-major)', func expected = new Complex64Array( data.y_out ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -879,8 +879,8 @@ tape( 'the function supports specifying a negative `x` stride (column-major)', f expected = new Complex64Array( data.y_out ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -907,8 +907,8 @@ tape( 'the function supports specifying a negative `y` stride (row-major)', func expected = new Complex64Array( data.y_out ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -935,8 +935,8 @@ tape( 'the function supports specifying a negative `y` stride (column-major)', f expected = new Complex64Array( data.y_out ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -963,8 +963,8 @@ tape( 'the function supports complex access patterns (row-major)', function test expected = new Complex64Array( data.y_out ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -991,8 +991,8 @@ tape( 'the function supports complex access patterns (column-major)', function t expected = new Complex64Array( data.y_out ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); - t.strictEqual( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js index 6b65b41f6360..fc2e5ad6d84d 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js @@ -200,7 +200,7 @@ tape( 'the function throws an error if provided an invalid fourteenth argument', } }); -tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*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; @@ -222,13 +222,13 @@ tape( 'the function performs one of the matrix-vector operations `y = α*A*x + expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); -tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*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; @@ -250,13 +250,13 @@ tape( 'the function performs one of the matrix-vector operations `y = α*A*x + expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); -tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `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; @@ -278,13 +278,13 @@ tape( 'the function performs one of the matrix-vector operations `y = α*A*x + expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); -tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `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; @@ -306,13 +306,13 @@ tape( 'the function performs one of the matrix-vector operations `y = α*A*x + expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); -tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*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; @@ -334,13 +334,13 @@ tape( 'the function performs one of the matrix-vector operations `y = α*A*x + expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); -tape( 'the function performs one of the matrix-vector operations `y = α*A*x + β*y` or `y = α*A^T*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; @@ -362,8 +362,8 @@ tape( 'the function performs one of the matrix-vector operations `y = α*A*x + expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -387,7 +387,7 @@ tape( 'the function returns a reference to the second input vector (row-major)', beta = new Complex64( data.beta[0], data.beta[1] ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); t.end(); }); @@ -411,7 +411,7 @@ tape( 'the function returns a reference to the second input vector (column-major beta = new Complex64( data.beta[0], data.beta[1] ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); t.end(); }); @@ -438,12 +438,12 @@ tape( 'if either `M` or `N` is `0`, the function returns the second input vector expected = new Complex64Array( data.y ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -470,12 +470,12 @@ tape( 'if either `M` or `N` is `0`, the function returns the second input vector expected = new Complex64Array( data.y ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -502,8 +502,8 @@ tape( 'if `α` is `0` and `β` is `1`, the function returns the second input vec expected = new Complex64Array( data.y ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -530,8 +530,8 @@ tape( 'if `α` is `0` and `β` is `1`, the function returns the second input vec expected = new Complex64Array( data.y ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -558,8 +558,8 @@ tape( 'if `x` contains only zeros and `β` is `1`, the function returns the seco expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -586,8 +586,8 @@ tape( 'if `x` contains only zeros and `β` is `1`, the function returns the seco expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -614,8 +614,8 @@ tape( 'if `α` is `0`, the function scales the second input vector by `β` (row- expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -642,8 +642,8 @@ tape( 'if `α` is `0`, the function scales the second input vector by `β` (colu expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -670,7 +670,7 @@ tape( 'if `α` is `0` and `β` is `0`, the function zeros the second input vecto expected = new Complex64Array( data.y.length ); out = cgemv( 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.deepEqual( out, expected, true, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -697,7 +697,7 @@ tape( 'if `α` is `0` and `β` is `0`, the function zeros the second input vecto expected = new Complex64Array( data.y.length ); out = cgemv( 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.deepEqual( out, expected, true, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -724,8 +724,8 @@ tape( 'if `x` contains only zeros and `β` is not `1`, the function scales the s expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -752,8 +752,8 @@ tape( 'if `x` contains only zeros and `β` is not `1`, the function scales the s expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -780,8 +780,8 @@ tape( 'the function supports specifying the strides of the first and second dime expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -808,8 +808,8 @@ tape( 'the function supports specifying the strides of the first and second dime expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -836,8 +836,8 @@ tape( 'the function supports a negative stride for the first dimension of `A` (r expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -864,8 +864,8 @@ tape( 'the function supports a negative stride for the first dimension of `A` (c expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -892,8 +892,8 @@ tape( 'the function supports a negative stride for the second dimension of `A` ( expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -920,8 +920,8 @@ tape( 'the function supports a negative stride for the second dimension of `A` ( expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -948,8 +948,8 @@ tape( 'the function supports negative strides for `A` (row-major)', function tes expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -976,8 +976,8 @@ tape( 'the function supports negative strides for `A` (column-major)', function expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -1004,8 +1004,8 @@ tape( 'the function supports specifying an offset parameter for `A` (row-major)' expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -1032,8 +1032,8 @@ tape( 'the function supports specifying an offset parameter for `A` (column-majo expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -1060,8 +1060,8 @@ tape( 'the function supports specifying `x` and `y` strides (row-major)', functi expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -1088,8 +1088,8 @@ tape( 'the function supports specifying `x` and `y` strides (column-major)', fun expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -1116,8 +1116,8 @@ tape( 'the function supports specifying a negative `x` stride (row-major)', func expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -1144,8 +1144,8 @@ tape( 'the function supports specifying a negative `x` stride (column-major)', f expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -1172,8 +1172,8 @@ tape( 'the function supports specifying a negative `y` stride (row-major)', func expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -1200,8 +1200,8 @@ tape( 'the function supports specifying a negative `y` stride (column-major)', f expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -1228,8 +1228,8 @@ tape( 'the function supports specifying negative strides for `x` and `y` (row-ma expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -1256,8 +1256,8 @@ tape( 'the function supports specifying negative strides for `x` and `y` (column expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -1284,8 +1284,8 @@ tape( 'the function supports complex access patterns (row-major)', function test expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); @@ -1312,8 +1312,8 @@ tape( 'the function supports complex access patterns (column-major)', function t expected = new Complex64Array( data.y_out ); out = cgemv( 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( isSameComplex64Array( out, y ), true, 'returns expected values' ); - t.deepEqual( isSameComplex64Array( out, expected ), true, 'returns expected values' ); + t.strictEqual( out, y, 'returns expected value' ); + t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); t.end(); }); From c20d54c55f2fda938db73aa023f496d9669e2f98 Mon Sep 17 00:00:00 2001 From: Athan Date: Mon, 20 Apr 2026 18:42:10 -0700 Subject: [PATCH 28/29] fix: pass correct argument --- 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: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js index 3e4a05f57d14..e59ab4b6287c 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/lib/base.js @@ -143,7 +143,7 @@ function cgemv( trans, M, N, alpha, A, strideA1, strideA2, offsetA, x, strideX, // y = beta*y if ( rebeta === 0.0 && imbeta === 0.0 ) { - cfill( ylen, 0.0, y, strideY, offsetY ); + cfill( ylen, alpha, y, strideY, offsetY ); } else if ( rebeta !== 1.0 || imbeta !== 0.0 ) { cscal( ylen, beta, y, strideY, offsetY ); } From 58d7af6dbc5982ada716c36e4aec23c489257d67 Mon Sep 17 00:00:00 2001 From: Athan Date: Mon, 20 Apr 2026 18:46:25 -0700 Subject: [PATCH 29/29] test: fix failing tests --- 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: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- lib/node_modules/@stdlib/blas/base/cgemv/test/test.cgemv.js | 4 ++-- lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.cgemv.js b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.cgemv.js index b6129d1a03de..cb0b69c9227f 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.cgemv.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.cgemv.js @@ -682,7 +682,7 @@ tape( 'if `α` is `0` and `β` is `0`, the function zeros the second input vecto alpha = new Complex64( 0.0, 0.0 ); beta = new Complex64( 0.0, 0.0 ); - expected = new Complex64Array( data.y.length ); + expected = new Complex64Array( y.length ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); @@ -709,7 +709,7 @@ tape( 'if `α` is `0` and `β` is `0`, the function zeros the second input vecto alpha = new Complex64( 0.0, 0.0 ); beta = new Complex64( 0.0, 0.0 ); - expected = new Complex64Array( data.y.length ); + expected = new Complex64Array( y.length ); out = cgemv( data.order, data.trans, data.M, data.N, alpha, a, data.lda, x, data.strideX, beta, y, data.strideY ); t.strictEqual( isSameComplex64Array( out, expected ), true, 'returns expected value' ); diff --git a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js index fc2e5ad6d84d..a97876c0fa0a 100644 --- a/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/blas/base/cgemv/test/test.ndarray.js @@ -667,7 +667,7 @@ tape( 'if `α` is `0` and `β` is `0`, the function zeros the second input vecto alpha = new Complex64( 0.0, 0.0 ); beta = new Complex64( 0.0, 0.0 ); - expected = new Complex64Array( data.y.length ); + expected = new Complex64Array( y.length ); out = cgemv( 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( isSameComplex64Array( out, expected ), true, 'returns expected value' ); @@ -694,7 +694,7 @@ tape( 'if `α` is `0` and `β` is `0`, the function zeros the second input vecto alpha = new Complex64( 0.0, 0.0 ); beta = new Complex64( 0.0, 0.0 ); - expected = new Complex64Array( data.y.length ); + expected = new Complex64Array( y.length ); out = cgemv( 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( isSameComplex64Array( out, expected ), true, 'returns expected value' );