diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/README.md b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/README.md new file mode 100644 index 000000000000..ab68e55d6e74 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/README.md @@ -0,0 +1,372 @@ + + +# caxpy + +> Scale a single-precision complex floating-point vector by a single-precision complex floating-point constant and add the result to a single-precision complex floating-point vector. + +
+ +## Usage + +```javascript +var caxpy = require( '@stdlib/blas/base/wasm/caxpy' ); +``` + +#### caxpy.main( N, alpha, x, strideX, y, strideY ) + +Scales values from `x` by `alpha` and adds the result to `y`. + +```javascript +var Complex64Array = require( '@stdlib/array/complex64' ); +var Complex64 = require( '@stdlib/complex/float32/ctor' ); + +var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); +var y = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); +var alpha = new Complex64( 2.0, 2.0 ); + +caxpy.main( 3, alpha, x, 1, y, 1 ); +// y => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] +``` + +The function has the following parameters: + +- **N**: number of indexed elements. +- **alpha**: scalar [`Complex64`][@stdlib/complex/float32/ctor] constant. +- **x**: first input [`Complex64Array`][@stdlib/array/complex64]. +- **strideX**: index increment for `x`. +- **y**: second input [`Complex64Array`][@stdlib/array/complex64]. +- **strideY**: index increment for `y`. + +The `N` and stride parameters determine how values from `x` are scaled by `alpha` and added to `y`. For example, to scale every other value in `x` by `alpha` and add the result to every other value of `y`, + +```javascript +var Complex64Array = require( '@stdlib/array/complex64' ); +var Complex64 = require( '@stdlib/complex/float32/ctor' ); + +var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); +var y = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); +var alpha = new Complex64( 2.0, 2.0 ); + +caxpy.main( 2, alpha, x, 2, y, 2 ); +// y => [ -1.0, 7.0, 1.0, 1.0, -1.0, 23.0, 1.0, 1.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( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); +var y0 = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + +// Define a scalar constant: +var alpha = new Complex64( 2.0, 2.0 ); + +// Create offset views... +var x1 = new Complex64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element +var y1 = new Complex64Array( y0.buffer, y0.BYTES_PER_ELEMENT*2 ); // start at 3rd element + +// Scales values of `x0` by `alpha` starting from second index and add the result to `y0` starting from third index... +caxpy.main( 2, alpha, x1, 1, y1, 1 ); +// y0 => [ 1.0, 1.0, 1.0, 1.0, -1.0, 15.0, -1.0, 23.0 ] +``` + +#### caxpy.ndarray( N, alpha, x, strideX, offsetX, y, strideY, offsetY ) + +Scales values from `x` by `alpha` and adds the result to `y` using alternative indexing semantics. + +```javascript +var Complex64Array = require( '@stdlib/array/complex64' ); +var Complex64 = require( '@stdlib/complex/float32/ctor' ); + +var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); +var y = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); +var alpha = new Complex64( 2.0, 2.0 ); + +caxpy.ndarray( 3, alpha, x, 1, 0, y, 1, 0 ); +// y => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] +``` + +The function has the following additional parameters: + +- **offsetX**: starting index for `x`. +- **offsetY**: 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, to scale values in the first input strided array starting from the second element and add the result to the second input array starting from the second element, + +```javascript +var Complex64Array = require( '@stdlib/array/complex64' ); +var Complex64 = require( '@stdlib/complex/float32/ctor' ); + +var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); +var y = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); +var alpha = new Complex64( 2.0, 2.0 ); + +caxpy.ndarray( 3, alpha, x, 1, 1, y, 1, 1 ); +// y => [ 1.0, 1.0, -1.0, 15.0, -1.0, 23.0, -1.0, 31.0 ] +``` + +* * * + +### Module + +#### caxpy.Module( memory ) + +Returns a new WebAssembly [module wrapper][@stdlib/wasm/module-wrapper] instance which uses the provided WebAssembly [memory][@stdlib/wasm/memory] instance as its underlying memory. + + + +```javascript +var Memory = require( '@stdlib/wasm/memory' ); + +// Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB): +var mem = new Memory({ + 'initial': 10, + 'maximum': 100 +}); + +// Create a BLAS routine: +var mod = new caxpy.Module( mem ); +// returns + +// Initialize the routine: +mod.initializeSync(); +``` + +#### caxpy.Module.prototype.main( N, ap, xp, sx, yp, sy ) + +Scales values from `x` by `alpha` and adds the result to `y`. + + + +```javascript +var Memory = require( '@stdlib/wasm/memory' ); +var zeros = require( '@stdlib/array/zeros' ); +var bytesPerElement = require( '@stdlib/ndarray/base/bytes-per-element' ); +var Float32Array = require( '@stdlib/array/float32' ); +var Complex64Array = require( '@stdlib/array/complex64' ); +var reinterpretComplex64 = require( '@stdlib/strided/base/reinterpret-complex64' ); +var caxpy = require( '@stdlib/blas/base/wasm/caxpy' ); + +// Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB): +var mem = new Memory({ + 'initial': 10, + 'maximum': 100 +}); + +// Create a BLAS routine: +var mod = new caxpy.Module( mem ); +// returns + +// Initialize the routine: +mod.initializeSync(); + +// Define a vector data type: +var dtype = 'complex64'; + +// Specify a vector length: +var N = 3; + +// Define pointers (i.e., byte offsets) for storing two vectors and a complex number: +var xptr = 0; +var yptr = N * bytesPerElement( dtype ); +var aptr = 2 * N * bytesPerElement( dtype ); + +// Write vector values to module memory: +mod.write( xptr, new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ) ); +mod.write( yptr, new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ) ); + +// Write a complex number to module memory: +mod.write( aptr, new Float32Array( [ 2.0, 2.0 ] ) ); + +// Perform computation: +mod.main( N, aptr, xptr, 1, yptr, 1 ); + +// Read out the results: +var view = zeros( N, dtype ); +mod.read( yptr, view ); + +console.log( reinterpretComplex64( view, 0 ) ); +// => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] +``` + +The function has the following parameters: + +- **N**: number of indexed elements. +- **ap**: pointer (i.e., byte offset) to a scalar [`Complex64`][@stdlib/complex/float32/ctor] constant. +- **xp**: first input [`Complex64Array`][@stdlib/array/complex64] pointer (i.e., byte offset). +- **sx**: index increment for `x`. +- **yp**: second input [`Complex64Array`][@stdlib/array/complex64] pointer (i.e., byte offset). +- **sy**: index increment for `y`. + +#### caxpy.Module.prototype.ndarray( N, ap, xp, sx, ox, yp, sy, oy ) + +Scales values from `x` by `alpha` and adds the result to `y` using alternative indexing semantics. + + + +```javascript +var Memory = require( '@stdlib/wasm/memory' ); +var zeros = require( '@stdlib/array/zeros' ); +var bytesPerElement = require( '@stdlib/ndarray/base/bytes-per-element' ); +var Float32Array = require( '@stdlib/array/float32' ); +var Complex64Array = require( '@stdlib/array/complex64' ); +var reinterpretComplex64 = require( '@stdlib/strided/base/reinterpret-complex64' ); +var caxpy = require( '@stdlib/blas/base/wasm/caxpy' ); + +// Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB): +var mem = new Memory({ + 'initial': 10, + 'maximum': 100 +}); + +// Create a BLAS routine: +var mod = new caxpy.Module( mem ); +// returns + +// Initialize the routine: +mod.initializeSync(); + +// Define a vector data type: +var dtype = 'complex64'; + +// Specify a vector length: +var N = 3; + +// Define pointers (i.e., byte offsets) for storing two vectors and a complex number: +var xptr = 0; +var yptr = N * bytesPerElement( dtype ); +var aptr = 2 * N * bytesPerElement( dtype ); + +// Write vector values to module memory: +mod.write( xptr, new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ) ); +mod.write( yptr, new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ) ); + +// Write a complex number to module memory: +mod.write( aptr, new Float32Array( [ 2.0, 2.0 ] ) ); + +// Perform computation: +mod.ndarray( N, aptr, xptr, 1, 0, yptr, 1, 0 ); + +// Read out the results: +var view = zeros( N, dtype ); +mod.read( yptr, view ); + +console.log( reinterpretComplex64( view, 0 ) ); +// => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] +``` + +The function has the following additional parameters: + +- **ox**: starting index for `x`. +- **oy**: starting index for `y`. + +
+ + + +
+ +* * * + +## Notes + +- If `N <= 0`, `y` is left unchanged. +- This package implements routines using WebAssembly. When provided arrays which are not allocated on a `caxpy` module memory instance, data must be explicitly copied to module memory prior to computation. Data movement may entail a performance cost, and, thus, if you are using arrays external to module memory, you should prefer using [`@stdlib/blas/base/caxpy`][@stdlib/blas/base/caxpy]. However, if working with arrays which are allocated and explicitly managed on module memory, you can achieve better performance when compared to the pure JavaScript implementations found in [`@stdlib/blas/base/caxpy`][@stdlib/blas/base/caxpy]. Beware that such performance gains may come at the cost of additional complexity when having to perform manual memory management. Choosing between implementations depends heavily on the particular needs and constraints of your application, with no one choice universally better than the other. +- `caxpy()` corresponds to the [BLAS][blas] level 1 function [`caxpy`][caxpy]. + +
+ + + +
+ +* * * + +## Examples + + + +```javascript +var oneTo = require( '@stdlib/array/one-to' ); +var ones = require( '@stdlib/array/ones' ); +var Complex64 = require( '@stdlib/complex/float32/ctor' ); +var Complex64Array = require( '@stdlib/array/complex64' ); +var reinterpretComplex64 = require( '@stdlib/strided/base/reinterpret-complex64' ); +var caxpy = require( '@stdlib/blas/base/wasm/caxpy' ); + +// Specify a vector length: +var N = 5; + +// Create the input arrays: +var x = new Complex64Array( oneTo( N*2, 'float32' ).buffer ); +var y = new Complex64Array( ones( N*2, 'float32' ).buffer ); + +// Create a complex number: +var alpha = new Complex64( 2.0, 2.0 ); + +// Perform computation: +caxpy.ndarray( N, alpha, x, 1, 0, y, 1, 0 ); + +// Print the results: +console.log( reinterpretComplex64( y, 0 ) ); +// => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0, -1.0, 31.0, -1.0, 39.0 ] +``` + +
+ + + + + +
+ +
+ + + + + +
+ +[blas]: http://www.netlib.org/blas + +[caxpy]: https://www.netlib.org/lapack/explore-html/d5/d4b/group__axpy_ga0b7bac1f4d42514074a48f14f5f9caa0.html#ga0b7bac1f4d42514074a48f14f5f9caa0 + +[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 + +[@stdlib/complex/float32/ctor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/complex/float32/ctor + +[@stdlib/wasm/memory]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/wasm/memory + +[@stdlib/wasm/module-wrapper]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/wasm/module-wrapper + +[@stdlib/blas/base/caxpy]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/base/caxpy + +
+ + diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/benchmark/benchmark.js new file mode 100644 index 000000000000..ba1c362c1f6b --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/benchmark/benchmark.js @@ -0,0 +1,121 @@ +/** +* @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 hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' ); +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 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 caxpy = require( './../lib' ); + + +// VARIABLES // + +var opts = { + 'skip': !hasWebAssemblySupport() +}; +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 xbuf; + var ybuf; + var x; + var y; + + 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 ); + + alpha = new Complex64( 1.0, 0.0 ); + + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + caxpy.main( x.length, alpha, x, 1, y, 1 ); + if ( isnanf( ybuf[ i%(len*2) ] ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnanf( ybuf[ 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 = pow( 10, i ); + f = createBenchmark( len ); + bench( format( '%s:len=%d', pkg, len ), opts, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/benchmark/benchmark.module.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/benchmark/benchmark.module.js new file mode 100644 index 000000000000..0f6c43a3d126 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/benchmark/benchmark.module.js @@ -0,0 +1,67 @@ +/** +* @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 hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' ); +var Memory = require( '@stdlib/wasm/memory' ); +var format = require( '@stdlib/string/format' ); +var pkg = require( './../package.json' ).name; +var caxpy = require( './../lib' ); + + +// VARIABLES // + +var opts = { + 'skip': !hasWebAssemblySupport() +}; + + +// MAIN // + +bench( format( '%s:Module:constructor', pkg ), opts, function benchmark( b ) { + var values; + var o; + var v; + var i; + + o = { + 'initial': 0 + }; + values = [ + new Memory( o ), + new Memory( o ) + ]; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = new caxpy.Module( values[ i%values.length ] ); + if ( typeof v !== 'object' ) { + b.fail( 'should return an object' ); + } + } + b.toc(); + if ( typeof v !== 'object' ) { + b.fail( 'should return an object' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/benchmark/benchmark.module.main.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/benchmark/benchmark.module.main.js new file mode 100644 index 000000000000..300c3fba8d66 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/benchmark/benchmark.module.main.js @@ -0,0 +1,143 @@ +/** +* @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 hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' ); +var Memory = require( '@stdlib/wasm/memory' ); +var bytesPerElement = require( '@stdlib/ndarray/base/bytes-per-element' ); +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 Float32Array = require( '@stdlib/array/float32' ); +var format = require( '@stdlib/string/format' ); +var pkg = require( './../package.json' ).name; +var caxpy = require( './../lib' ); + + +// VARIABLES // + +var opts = { + 'skip': !hasWebAssemblySupport() +}; +var options = { + 'dtype': 'float32' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var byteOffset; + var view; + var xptr; + var yptr; + var aptr; + var mod; + var mem; + var nb; + var i; + + // Create a new BLAS routine interface: + mem = new Memory({ + 'initial': 0 + }); + mod = new caxpy.Module( mem ); + + // Initialize the module: + mod.initializeSync(); // eslint-disable-line n/no-sync + + // Reallocate the underlying memory to allow storing two vectors and a complex number: + nb = bytesPerElement( 'complex64' ); + mod.realloc( (2*len*nb)+nb ); + + // Define pointers (i.e., byte offsets) for storing two vectors and a complex number: + xptr = 0; + yptr = len * nb; + aptr = 2 * len * nb; + + // Write random values to module memory: + mod.write( xptr, uniform( len*2, -100.0, 100.0, options ) ); + mod.write( yptr, uniform( len*2, -100.0, 100.0, options ) ); + mod.write( aptr, new Float32Array( [ 1.0, 0.0 ] ) ); + + // Retrieve a DataView of module memory: + view = mod.view; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + mod.main( len, aptr, xptr, 1, yptr, 1 ); + byteOffset = yptr + ( (i%len)*nb ); + if ( isnanf( view.getFloat32( byteOffset, true ) ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnanf( view.getFloat32( byteOffset, true ) ) ) { + 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 = pow( 10, i ); + f = createBenchmark( len ); + bench( format( '%s::module,pointers:len=%d', pkg, len ), opts, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/benchmark/benchmark.module.ndarray.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/benchmark/benchmark.module.ndarray.js new file mode 100644 index 000000000000..c0015c3f8156 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/benchmark/benchmark.module.ndarray.js @@ -0,0 +1,143 @@ +/** +* @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 hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' ); +var Memory = require( '@stdlib/wasm/memory' ); +var bytesPerElement = require( '@stdlib/ndarray/base/bytes-per-element' ); +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 Float32Array = require( '@stdlib/array/float32' ); +var format = require( '@stdlib/string/format' ); +var pkg = require( './../package.json' ).name; +var caxpy = require( './../lib' ); + + +// VARIABLES // + +var opts = { + 'skip': !hasWebAssemblySupport() +}; +var options = { + 'dtype': 'float32' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var byteOffset; + var view; + var xptr; + var yptr; + var aptr; + var mod; + var mem; + var nb; + var i; + + // Create a new BLAS routine interface: + mem = new Memory({ + 'initial': 0 + }); + mod = new caxpy.Module( mem ); + + // Initialize the module: + mod.initializeSync(); // eslint-disable-line n/no-sync + + // Reallocate the underlying memory to allow storing two vectors and a complex number: + nb = bytesPerElement( 'complex64' ); + mod.realloc( (2*len*nb)+nb ); + + // Define pointers (i.e., byte offsets) for storing two vectors and a complex number: + xptr = 0; + yptr = len * nb; + aptr = 2 * len * nb; + + // Write random values to module memory: + mod.write( xptr, uniform( len*2, -100.0, 100.0, options ) ); + mod.write( yptr, uniform( len*2, -100.0, 100.0, options ) ); + mod.write( aptr, new Float32Array( [ 1.0, 0.0 ] ) ); + + // Retrieve a DataView of module memory: + view = mod.view; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + mod.ndarray( len, aptr, xptr, 1, 0, yptr, 1, 0 ); + byteOffset = yptr + ( (i%len)*nb ); + if ( isnanf( view.getFloat32( byteOffset, true ) ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnanf( view.getFloat32( byteOffset, true ) ) ) { + 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 = pow( 10, i ); + f = createBenchmark( len ); + bench( format( '%s::module,pointers:ndarray:len=%d', pkg, len ), opts, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/benchmark/benchmark.ndarray.js new file mode 100644 index 000000000000..f95888c113d6 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/benchmark/benchmark.ndarray.js @@ -0,0 +1,121 @@ +/** +* @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 hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' ); +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 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 caxpy = require( './../lib' ); + + +// VARIABLES // + +var opts = { + 'skip': !hasWebAssemblySupport() +}; +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 xbuf; + var ybuf; + var x; + var y; + + 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 ); + + alpha = new Complex64( 1.0, 0.0 ); + + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + caxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, 0 ); + if ( isnanf( ybuf[ i%(len*2) ] ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnanf( ybuf[ 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 = pow( 10, i ); + f = createBenchmark( len ); + bench( format( '%s:ndarray:len=%d', pkg, len ), opts, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/docs/repl.txt b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/docs/repl.txt new file mode 100644 index 000000000000..a0059d2f210a --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/docs/repl.txt @@ -0,0 +1,583 @@ + +{{alias}}.main( N, alpha, x, strideX, y, strideY ) + Scales a single-precision complex floating-point vector by a single- + precision complex floating-point constant and adds the result to a single- + precision complex floating-point vector. + + The `N` and stride parameters determine how values from `x` are scaled by + `alpha` and added to `y`. + + Indexing is relative to the first index. To introduce an offset, use typed + array views. + + If `N <= 0`, the function returns `y` unchanged. + + Parameters + ---------- + N: integer + Number of indexed elements. + + alpha: Complex64 + Complex constant. + + x: Complex64Array + First input array. + + strideX: integer + Index increment for `x`. + + y: Complex64Array + Second input array. + + strideY: integer + Index increment for `y`. + + Returns + ------- + y: Complex64Array + Second input array. + + Examples + -------- + // Standard usage: + > var x = new {{alias:@stdlib/array/complex64}}( [ 1.0, 2.0, 3.0, 4.0 ] ); + > var y = new {{alias:@stdlib/array/complex64}}( [ 1.0, 1.0, 1.0, 1.0 ] ); + > var alpha = new {{alias:@stdlib/complex/float32/ctor}}( 2.0, 2.0 ); + > {{alias}}.main( 2, alpha, x, 1, y, 1 ) + [ -1.0, 7.0, -1.0, 15.0 ] + + // Advanced indexing: + > x = new {{alias:@stdlib/array/complex64}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + > y = new {{alias:@stdlib/array/complex64}}( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + > alpha = new {{alias:@stdlib/complex/float32/ctor}}( 1.0, 1.0 ); + > {{alias}}.main( 2, alpha, x, 2, y, 2 ) + [ 0.0, 4.0, 1.0, 1.0, 0.0, 12.0 ] + + // Using typed array views: + > var x0 = new {{alias:@stdlib/array/complex64}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + > var y0 = new {{alias:@stdlib/array/complex64}}( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + > var x1 = new {{alias:@stdlib/array/complex64}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); + > var y1 = new {{alias:@stdlib/array/complex64}}( y0.buffer, y0.BYTES_PER_ELEMENT*1 ); + > alpha = new {{alias:@stdlib/complex/float32/ctor}}( 2.0, 2.0 ); + > {{alias}}.main( 2, alpha, x1, 1, y1, 1 ) + [ -1.0, 15.0, -1.0, 23.0 ] + > y0 + [ 1.0, 1.0, -1.0, 15.0, -1.0, 23.0 ] + + +{{alias}}.ndarray( N, alpha, x, strideX, offsetX, y, strideY, offsetY ) + Scales a single-precision complex floating-point vector by a single- + precision complex floating-point constant and adds the result to a single- + precision complex floating-point vector using alternative indexing + semantics. + + While typed array views mandate a view offset based on the underlying + buffer, the offset parameters support indexing semantics based on starting + indices. + + Parameters + ---------- + N: integer + Number of indexed elements. + + alpha: Complex64 + Complex constant. + + x: Complex64Array + First input array. + + strideX: integer + Index increment for `x`. + + offsetX: integer + Starting index for `x`. + + y: Complex64Array + Second input array. + + strideY: integer + Index increment for `y`. + + offsetY: integer + Starting index for `y`. + + Returns + ------- + y: Complex64Array + Second input array. + + Examples + -------- + // Standard usage: + > var x = new {{alias:@stdlib/array/complex64}}( [ 1.0, 2.0, 3.0, 4.0 ] ); + > var y = new {{alias:@stdlib/array/complex64}}( [ 1.0, 1.0, 1.0, 1.0 ] ); + > var alpha = new {{alias:@stdlib/complex/float32/ctor}}( 2.0, 2.0 ); + > {{alias}}.ndarray( 2, alpha, x, 1, 0, y, 1, 0 ) + [ -1.0, 7.0, -1.0, 15.0 ] + + // Advanced indexing: + > x = new {{alias:@stdlib/array/complex64}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + > y = new {{alias:@stdlib/array/complex64}}( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + > alpha = new {{alias:@stdlib/complex/float32/ctor}}( 1.0, 2.0 ); + > {{alias}}.ndarray( 2, alpha, x, 1, 2, y, 1, 2 ) + [ 1.0, 1.0, 1.0, 1.0, -6.0, 17.0, -8.0, 23.0 ] + + +{{alias}}.Module( memory ) + Returns a new WebAssembly module wrapper which uses the provided WebAssembly + memory instance as its underlying memory. + + Parameters + ---------- + memory: Memory + WebAssembly memory instance. + + Returns + ------- + mod: Module + WebAssembly module wrapper. + + Examples + -------- + // Create a new memory instance: + > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } ); + + // Create a new routine: + > var mod = new {{alias}}.Module( mem ); + + // Initialize the routine: + > mod.initializeSync(); + + +{{alias}}.Module.prototype.binary + Read-only property which returns WebAssembly binary code. + + Returns + ------- + out: Uint8Array + WebAssembly binary code. + + Examples + -------- + > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } ); + > var mod = new {{alias}}.Module( mem ); + > mod.initializeSync(); + > mod.binary + + + +{{alias}}.Module.prototype.memory + Read-only property which returns WebAssembly memory. + + Returns + ------- + mem: Memory|null + WebAssembly memory. + + Examples + -------- + > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } ); + > var mod = new {{alias}}.Module( mem ); + > mod.initializeSync(); + > mod.memory + + + +{{alias}}.Module.prototype.buffer + Read-only property which returns a WebAssembly memory buffer as a + Uint8Array. + + Returns + ------- + buf: Uint8Array|null + WebAssembly memory buffer. + + Examples + -------- + > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } ); + > var mod = new {{alias}}.Module( mem ); + > mod.initializeSync(); + > mod.buffer + + + +{{alias}}.Module.prototype.view + Read-only property which returns a WebAssembly memory buffer as a DataView. + + Returns + ------- + view: DataView|null + WebAssembly memory view. + + Examples + -------- + > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } ); + > var mod = new {{alias}}.Module( mem ); + > mod.initializeSync(); + > mod.view + + + +{{alias}}.Module.prototype.exports + Read-only property which returns "raw" WebAssembly module exports. + + Returns + ------- + out: Object|null + WebAssembly module exports. + + Examples + -------- + > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } ); + > var mod = new {{alias}}.Module( mem ); + > mod.initializeSync(); + > mod.exports + {...} + + +{{alias}}.Module.prototype.initialize() + Asynchronously initializes a WebAssembly module instance. + + Returns + ------- + p: Promise + Promise which resolves upon initializing a WebAssembly module instance. + + Examples + -------- + > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } ); + > var mod = new {{alias}}.Module( mem ); + > mod.initialize(); + + +{{alias}}.Module.prototype.initializeAsync( clbk ) + Asynchronously initializes a WebAssembly module instance. + + Parameters + ---------- + clbk: Function + Callback to invoke upon initializing a WebAssembly module instance. + + Examples + -------- + > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } ); + > var mod = new {{alias}}.Module( mem ); + > function clbk() { console.log( 'done' ) }; + > mod.initializeAsync( clbk ); + + +{{alias}}.Module.prototype.initializeSync() + Synchronously initializes a WebAssembly module instance. + + In web browsers, JavaScript engines may raise an exception when attempting + to synchronously compile large WebAssembly binaries due to concerns about + blocking the main thread. Hence, to initialize WebAssembly modules having + large binaries (e.g., >4KiB), consider using asynchronous initialization + methods in browser contexts. + + Returns + ------- + mod: Module + Module wrapper instance. + + Examples + -------- + > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } ); + > var mod = new {{alias}}.Module( mem ); + > mod.initializeSync(); + + +{{alias}}.Module.prototype.realloc( nbytes ) + Reallocates the underlying WebAssembly memory instance to a specified number + of bytes. + + WebAssembly memory can only *grow*, not shrink. Hence, if provided a number + of bytes which is less than or equal to the size of the current memory, the + function does nothing. + + When non-shared memory is resized, the underlying the `ArrayBuffer` is + detached, consequently invalidating any associated typed array views. Before + resizing non-shared memory, ensure that associated typed array views no + longer need byte access and can be garbage collected. + + Parameters + ---------- + nbytes: integer + Memory size (in bytes). + + Returns + ------- + bool: boolean + Boolean indicating whether the resize operation was successful. + + Examples + -------- + > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } ); + > var mod = new {{alias}}.Module( mem ); + > mod.initializeSync(); + > mod.realloc( 100 ) + + + +{{alias}}.Module.prototype.hasCapacity( byteOffset, values ) + Returns a boolean indicating whether the underlying WebAssembly memory + instance has the capacity to store a provided list of values starting from a + specified byte offset. + + Parameters + ---------- + byteOffset: integer + Byte offset at which to start writing values. + + values: ArrayLikeObject + Input array containing values to write. + + Returns + ------- + bool: boolean + Boolean indicating whether the underlying WebAssembly memory instance + has enough capacity. + + Examples + -------- + > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } ); + > var mod = new {{alias}}.Module( mem ); + > mod.initializeSync(); + > mod.realloc( 100 ); + > mod.hasCapacity( 0, [ 1, 2, 3, 4 ] ) + true + + +{{alias}}.Module.prototype.isView( values ) + Returns a boolean indicating whether a provided list of values is a view of + the underlying memory of the WebAssembly module. + + Parameters + ---------- + values: ArrayLikeObject + Input array. + + Returns + ------- + bool: boolean + Boolean indicating whether the list is a memory view. + + Examples + -------- + > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } ); + > var mod = new {{alias}}.Module( mem ); + > mod.initializeSync(); + > mod.realloc( 100 ); + > mod.isView( [ 1, 2, 3, 4 ] ) + false + + +{{alias}}.Module.prototype.write( byteOffset, values ) + Writes values to the underlying WebAssembly memory instance. + + The function infers element size (i.e., number of bytes per element) from + the data type of the input array. For example, if provided a Float32Array, + the function writes each element as a single-precision floating-point number + to the underlying WebAssembly memory instance. + + In order to write elements as a different data type, you need to perform an + explicit cast *before* calling this method. For example, in order to write + single-precision floating-point numbers contained in a Float32Array as + signed 32-bit integers, you must first convert the Float32Array to an + Int32Array before passing the values to this method. + + If provided an array having an unknown or "generic" data type, elements are + written as double-precision floating-point numbers. + + Parameters + ---------- + byteOffset: integer + Byte offset at which to start writing values. + + values: ArrayLikeObject + Input array containing values to write. + + Returns + ------- + mod: Module + Module wrapper instance. + + Examples + -------- + > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } ); + > var mod = new {{alias}}.Module( mem ); + > mod.initializeSync(); + > mod.realloc( 100 ); + > mod.write( 0, [ 1, 2, 3, 4 ] ); + + +{{alias}}.Module.prototype.read( byteOffset, out ) + Reads values from the underlying WebAssembly memory instance. + + The function infers element size (i.e., number of bytes per element) from + the data type of the output array. For example, if provided a Float32Array, + the function reads each element as a single-precision floating-point number + from the underlying WebAssembly memory instance. + + In order to read elements as a different data type, you need to perform an + explicit cast *after* calling this method. For example, in order to read + single-precision floating-point numbers contained in a Float32Array as + signed 32-bit integers, you must convert the Float32Array to an Int32Array + after reading memory values using this method. + + If provided an output array having an unknown or "generic" data type, + elements are read as double-precision floating-point numbers. + + Parameters + ---------- + byteOffset: integer + Byte offset at which to start reading values. + + out: ArrayLikeObject + Output array for storing read values. + + Returns + ------- + mod: Module + Module wrapper instance. + + Examples + -------- + > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } ); + > var mod = new {{alias}}.Module( mem ); + > mod.initializeSync(); + > mod.realloc( 100 ); + > mod.write( 0, [ 1, 2, 3, 4 ] ); + > var out = [ 0, 0, 0, 0 ]; + > mod.read( 0, out ); + > out + [ 1, 2, 3, 4 ] + + +{{alias}}.Module.prototype.main( N, ap, xp, sx, yp, sy ) + Scales a single-precision complex floating-point vector by a single- + precision complex floating-point constant and adds the result to a single- + precision complex floating-point vector. + + Parameters + ---------- + N: integer + Number of indexed elements. + + ap: integer + Pointer (i.e., byte offset) to a scalar complex constant. + + xp: integer + First input array pointer (i.e., byte offset). + + sx: integer + Index increment for `x`. + + yp: integer + Second input array pointer (i.e., byte offset). + + sy: integer + Index increment for `y`. + + Returns + ------- + yp: integer + Second input array pointer (i.e., byte offset). + + Examples + -------- + > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 1 } ); + > var mod = new {{alias}}.Module( mem ); + > mod.initializeSync(); + + // Define "pointers" (i.e., byte offsets) into module memory: + > var xptr = 0; + > var yptr = 24; + > var aptr = 48; + + // Write data to module memory: + > mod.write( xptr, new {{alias:@stdlib/array/complex64}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ) ); + > mod.write( yptr, new {{alias:@stdlib/array/complex64}}( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ) ); + + // Write a complex number to module memory: + > mod.write( aptr, new {{alias:@stdlib/array/float32}}( [ 2.0, 2.0 ] ) ); + + // Perform computation: + > mod.main( 3, aptr, xptr, 1, yptr, 1 ); + + // Extract results from module memory: + > var view = {{alias:@stdlib/array/zeros}}( 3, 'complex64' ); + > mod.read( yptr, view ); + + > view + [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] + + +{{alias}}.Module.prototype.ndarray( N, ap, xp, sx, ox, yp, sy, oy ) + Scales a single-precision complex floating-point vector by a single- + precision complex floating-point constant and adds the result to a single- + precision complex floating-point vector using alternative indexing + semantics. + + Parameters + ---------- + N: integer + Number of indexed elements. + + ap: integer + Pointer (i.e., byte offset) to a scalar complex constant. + + xp: integer + First input array pointer (i.e., byte offset). + + sx: integer + Index increment for `x`. + + ox: integer + Starting index for `x`. + + yp: integer + Second input array pointer (i.e., byte offset). + + sy: integer + Index increment for `y`. + + oy: integer + Starting index for `y`. + + Returns + ------- + yp: integer + Second input array pointer (i.e., byte offset). + + Examples + -------- + > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 1 } ); + > var mod = new {{alias}}.Module( mem ); + > mod.initializeSync(); + + // Define "pointers" (i.e., byte offsets) into module memory: + > var xptr = 0; + > var yptr = 24; + > var aptr = 48; + + // Write data to module memory: + > mod.write( xptr, new {{alias:@stdlib/array/complex64}}( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ) ); + > mod.write( yptr, new {{alias:@stdlib/array/complex64}}( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ) ); + + // Write a complex number to module memory: + > mod.write( aptr, new {{alias:@stdlib/array/float32}}( [ 2.0, 2.0 ] ) ); + + // Perform computation: + > mod.ndarray( 3, aptr, xptr, 1, 0, yptr, 1, 0 ); + + // Extract results from module memory: + > var view = {{alias:@stdlib/array/zeros}}( 3, 'complex64' ); + > mod.read( yptr, view ); + + > view + [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] + + See Also + -------- + diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/docs/types/index.d.ts new file mode 100644 index 000000000000..e3b8f5f16b90 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/docs/types/index.d.ts @@ -0,0 +1,463 @@ +/* +* @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 { ModuleWrapper, Memory } from '@stdlib/types/wasm'; +import { Complex64Array } from '@stdlib/types/array'; +import { Complex64 } from '@stdlib/types/complex'; + +/** +* Interface defining a module constructor which is both "newable" and "callable". +*/ +interface ModuleConstructor { + /** + * Returns a new WebAssembly module wrapper instance which uses the provided WebAssembly memory instance as its underlying memory. + * + * @param mem - WebAssembly memory instance + * @returns module wrapper instance + * + * @example + * var Memory = require( '@stdlib/wasm/memory' ); + * var zeros = require( '@stdlib/array/zeros' ); + * var bytesPerElement = require( '@stdlib/ndarray/base/bytes-per-element' ); + * var Float32Array = require( '@stdlib/array/float32' ); + * var Complex64Array = require( '@stdlib/array/complex64' ); + * var reinterpretComplex64 = require( '@stdlib/strided/base/reinterpret-complex64' ); + * + * // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB): + * var mem = new Memory({ + * 'initial': 10, + * 'maximum': 100 + * }); + * + * // Create a BLAS routine: + * var mod = new caxpy.Module( mem ); + * // returns + * + * // Initialize the routine: + * mod.initializeSync(); + * + * // Define a vector data type: + * var dtype = 'complex64'; + * + * // Specify a vector length: + * var N = 3; + * + * // Define pointers (i.e., byte offsets) for storing two vectors and a complex number: + * var xptr = 0; + * var yptr = N * bytesPerElement( dtype ); + * var aptr = 2 * N * bytesPerElement( dtype ); + * + * // Write vector values to module memory: + * mod.write( xptr, new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ) ); + * mod.write( yptr, new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ) ); + * + * // Write a complex number to module memory: + * mod.write( aptr, new Float32Array( [ 2.0, 2.0 ] ) ); + * + * // Perform computation: + * var ptr = mod.main( N, aptr, xptr, 1, yptr, 1 ); + * // returns + * + * var bool = ( ptr === yptr ); + * // returns true + * + * // Read out the results: + * var view = zeros( N, dtype ); + * mod.read( yptr, view ); + * + * console.log( reinterpretComplex64( view, 0 ) ); + * // => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] + */ + new( mem: Memory ): Module; // newable + + /** + * Returns a new WebAssembly module wrapper instance which uses the provided WebAssembly memory instance as its underlying memory. + * + * @param mem - WebAssembly memory instance + * @returns module wrapper instance + * + * @example + * var Memory = require( '@stdlib/wasm/memory' ); + * var zeros = require( '@stdlib/array/zeros' ); + * var bytesPerElement = require( '@stdlib/ndarray/base/bytes-per-element' ); + * var Float32Array = require( '@stdlib/array/float32' ); + * var Complex64Array = require( '@stdlib/array/complex64' ); + * var reinterpretComplex64 = require( '@stdlib/strided/base/reinterpret-complex64' ); + * + * // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB): + * var mem = new Memory({ + * 'initial': 10, + * 'maximum': 100 + * }); + * + * // Create a BLAS routine: + * var mod = caxpy.Module( mem ); + * // returns + * + * // Initialize the routine: + * mod.initializeSync(); + * + * // Define a vector data type: + * var dtype = 'complex64'; + * + * // Specify a vector length: + * var N = 3; + * + * // Define pointers (i.e., byte offsets) for storing two vectors and a complex number: + * var xptr = 0; + * var yptr = N * bytesPerElement( dtype ); + * var aptr = 2 * N * bytesPerElement( dtype ); + * + * // Write vector values to module memory: + * mod.write( xptr, new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ) ); + * mod.write( yptr, new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ) ); + * + * // Write a complex number to module memory: + * mod.write( aptr, new Float32Array( [ 2.0, 2.0 ] ) ); + * + * // Perform computation: + * var ptr = mod.main( N, aptr, xptr, 1, yptr, 1 ); + * // returns + * + * var bool = ( ptr === yptr ); + * // returns true + * + * // Read out the results: + * var view = zeros( N, dtype ); + * mod.read( yptr, view ); + * + * console.log( reinterpretComplex64( view, 0 ) ); + * // => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] + */ + ( mem: Memory ): Module; // callable +} + +/** +* Interface describing a `caxpy` WebAssembly module. +*/ +interface Module extends ModuleWrapper { + /** + * Scales a single-precision complex floating-point vector by a single-precision complex floating-point constant and adds the result to a single-precision complex floating-point vector. + * + * @param N - number of indexed elements + * @param aptr - scalar constant pointer (i.e., byte offset) + * @param xptr - first input array pointer (i.e., byte offset) + * @param strideX - `x` stride length + * @param yptr - second input array pointer (i.e., byte offset) + * @param strideY - `y` stride length + * @returns second input array pointer (i.e., byte offset) + * + * @example + * var Memory = require( '@stdlib/wasm/memory' ); + * var zeros = require( '@stdlib/array/zeros' ); + * var bytesPerElement = require( '@stdlib/ndarray/base/bytes-per-element' ); + * var Float32Array = require( '@stdlib/array/float32' ); + * var Complex64Array = require( '@stdlib/array/complex64' ); + * var reinterpretComplex64 = require( '@stdlib/strided/base/reinterpret-complex64' ); + * + * // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB): + * var mem = new Memory({ + * 'initial': 10, + * 'maximum': 100 + * }); + * + * // Create a BLAS routine: + * var mod = new caxpy.Module( mem ); + * // returns + * + * // Initialize the routine: + * mod.initializeSync(); + * + * // Define a vector data type: + * var dtype = 'complex64'; + * + * // Specify a vector length: + * var N = 3; + * + * // Define pointers (i.e., byte offsets) for storing two vectors and a complex number: + * var xptr = 0; + * var yptr = N * bytesPerElement( dtype ); + * var aptr = 2 * N * bytesPerElement( dtype ); + * + * // Write vector values to module memory: + * mod.write( xptr, new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ) ); + * mod.write( yptr, new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ) ); + * + * // Write a complex number to module memory: + * mod.write( aptr, new Float32Array( [ 2.0, 2.0 ] ) ); + * + * // Perform computation: + * var ptr = mod.main( N, aptr, xptr, 1, yptr, 1 ); + * // returns + * + * var bool = ( ptr === yptr ); + * // returns true + * + * // Read out the results: + * var view = zeros( N, dtype ); + * mod.read( yptr, view ); + * + * console.log( reinterpretComplex64( view, 0 ) ); + * // => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] + */ + main( N: number, aptr: number, xptr: number, strideX: number, yptr: number, strideY: number ): number; + + /** + * Scales a single-precision complex floating-point vector by a single-precision complex floating-point constant and adds the result to a single-precision complex floating-point vector using alternative indexing semantics. + * + * @param N - number of indexed elements + * @param aptr - scalar constant pointer (i.e., byte offset) + * @param xptr - first input array pointer (i.e., byte offset) + * @param strideX - `x` stride length + * @param offsetX - starting index for `x` + * @param yptr - second input array pointer (i.e., byte offset) + * @param strideY - `y` stride length + * @param offsetY - starting index for `y` + * @returns second input array pointer (i.e., byte offset) + * + * @example + * var Memory = require( '@stdlib/wasm/memory' ); + * var zeros = require( '@stdlib/array/zeros' ); + * var bytesPerElement = require( '@stdlib/ndarray/base/bytes-per-element' ); + * var Float32Array = require( '@stdlib/array/float32' ); + * var Complex64Array = require( '@stdlib/array/complex64' ); + * var reinterpretComplex64 = require( '@stdlib/strided/base/reinterpret-complex64' ); + * + * // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB): + * var mem = new Memory({ + * 'initial': 10, + * 'maximum': 100 + * }); + * + * // Create a BLAS routine: + * var mod = new caxpy.Module( mem ); + * // returns + * + * // Initialize the routine: + * mod.initializeSync(); + * + * // Define a vector data type: + * var dtype = 'complex64'; + * + * // Specify a vector length: + * var N = 3; + * + * // Define pointers (i.e., byte offsets) for storing two vectors and a complex number: + * var xptr = 0; + * var yptr = N * bytesPerElement( dtype ); + * var aptr = 2 * N * bytesPerElement( dtype ); + * + * // Write vector values to module memory: + * mod.write( xptr, new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ) ); + * mod.write( yptr, new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ) ); + * + * // Write a complex number to module memory: + * mod.write( aptr, new Float32Array( [ 2.0, 2.0 ] ) ); + * + * // Perform computation: + * var ptr = mod.ndarray( N, aptr, xptr, 1, 0, yptr, 1, 0 ); + * // returns + * + * var bool = ( ptr === yptr ); + * // returns true + * + * // Read out the results: + * var view = zeros( N, dtype ); + * mod.read( yptr, view ); + * + * console.log( reinterpretComplex64( view, 0 ) ); + * // => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] + */ + ndarray( N: number, aptr: number, xptr: number, strideX: number, offsetX: number, yptr: number, strideY: number, offsetY: number ): number; +} + +/** +* Interface describing `caxpy`. +*/ +interface Routine extends ModuleWrapper { + /** + * Scales a single-precision complex floating-point vector by a single-precision complex floating-point constant and adds the result to a single-precision complex floating-point vector. + * + * @param N - number of indexed elements + * @param alpha - scalar constant + * @param x - first input array + * @param strideX - `x` stride length + * @param y - second input array + * @param strideY - `y` stride length + * @returns second input array + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * var Complex64 = require( '@stdlib/complex/float32/ctor' ); + * + * // Define strided arrays: + * var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var y = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + * + * // Define a scalar constant: + * var alpha = new Complex64( 2.0, 2.0 ); + * + * // Perform operation: + * caxpy.main( x.length, alpha, x, 1, y, 1 ); + * // y => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] + */ + main( N: number, alpha: Complex64, x: Complex64Array, strideX: number, y: Complex64Array, strideY: number ): Complex64Array; + + /** + * Scales a single-precision complex floating-point vector by a single-precision complex floating-point constant and adds the result to a single-precision complex floating-point vector using alternative indexing semantics. + * + * @param N - number of indexed elements + * @param alpha - scalar constant + * @param x - first input array + * @param strideX - `x` stride length + * @param offsetX - starting index for `x` + * @param y - second input array + * @param strideY - `y` stride length + * @param offsetY - starting index for `y` + * @returns second input array + * + * @example + * var Complex64Array = require( '@stdlib/array/complex64' ); + * var Complex64 = require( '@stdlib/complex/float32/ctor' ); + * + * // Define strided arrays: + * var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); + * var y = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + * + * // Define a scalar constant: + * var alpha = new Complex64( 2.0, 2.0 ); + * + * // Perform operation: + * caxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, 0 ); + * // y => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] + */ + ndarray( N: number, alpha: Complex64, x: Complex64Array, strideX: number, offsetX: number, y: Complex64Array, strideY: number, offsetY: number ): Complex64Array; + + /** + * Returns a new WebAssembly module wrapper instance which uses the provided WebAssembly memory instance as its underlying memory. + * + * @param mem - WebAssembly memory instance + * @returns module wrapper instance + * + * @example + * var Memory = require( '@stdlib/wasm/memory' ); + * var zeros = require( '@stdlib/array/zeros' ); + * var bytesPerElement = require( '@stdlib/ndarray/base/bytes-per-element' ); + * var Float32Array = require( '@stdlib/array/float32' ); + * var Complex64Array = require( '@stdlib/array/complex64' ); + * var reinterpretComplex64 = require( '@stdlib/strided/base/reinterpret-complex64' ); + * + * // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB): + * var mem = new Memory({ + * 'initial': 10, + * 'maximum': 100 + * }); + * + * // Create a BLAS routine: + * var mod = new caxpy.Module( mem ); + * // returns + * + * // Initialize the routine: + * mod.initializeSync(); + * + * // Define a vector data type: + * var dtype = 'complex64'; + * + * // Specify a vector length: + * var N = 3; + * + * // Define pointers (i.e., byte offsets) for storing two vectors and a complex number: + * var xptr = 0; + * var yptr = N * bytesPerElement( dtype ); + * var aptr = 2 * N * bytesPerElement( dtype ); + * + * // Write vector values to module memory: + * mod.write( xptr, new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ) ); + * mod.write( yptr, new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ) ); + * + * // Write a complex number to module memory: + * mod.write( aptr, new Float32Array( [ 2.0, 2.0 ] ) ); + * + * // Perform computation: + * var ptr = mod.main( N, aptr, xptr, 1, yptr, 1 ); + * // returns + * + * var bool = ( ptr === yptr ); + * // returns true + * + * // Read out the results: + * var view = zeros( N, dtype ); + * mod.read( yptr, view ); + * + * console.log( reinterpretComplex64( view, 0 ) ); + * // => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] + */ + Module: ModuleConstructor; +} + +/** +* Scales a single-precision complex floating-point vector by a single-precision complex floating-point constant and adds the result to a single-precision complex floating-point vector. +* +* @param N - number of indexed elements +* @param alpha - scalar constant +* @param x - first input array +* @param strideX - `x` stride length +* @param y - second input array +* @param strideY - `y` stride length +* @returns second input array +* +* @example +* var Complex64Array = require( '@stdlib/array/complex64' ); +* var Complex64 = require( '@stdlib/complex/float32/ctor' ); +* +* // Define strided arrays: +* var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); +* var y = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); +* +* // Define a scalar constant: +* var alpha = new Complex64( 2.0, 2.0 ); +* +* // Perform operation: +* caxpy.main( x.length, alpha, x, 1, y, 1 ); +* // y => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] +* +* @example +* var Complex64Array = require( '@stdlib/array/complex64' ); +* var Complex64 = require( '@stdlib/complex/float32/ctor' ); +* +* // Define strided arrays: +* var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); +* var y = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); +* +* // Define a scalar constant: +* var alpha = new Complex64( 2.0, 2.0 ); +* +* // Perform operation: +* caxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, 0 ); +* // y => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] +*/ +declare var caxpy: Routine; + + +// EXPORTS // + +export = caxpy; diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/docs/types/test.ts b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/docs/types/test.ts new file mode 100644 index 000000000000..7e2e7c01099a --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/docs/types/test.ts @@ -0,0 +1,612 @@ +/* +* @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 space-in-parens */ + +import Complex64Array = require( '@stdlib/array/complex64' ); +import Complex64 = require( '@stdlib/complex/float32/ctor' ); +import Memory = require( '@stdlib/wasm/memory' ); +import caxpy = require( './index' ); + + +// TESTS // + +// Attached to the main export is a `main` method which returns a Complex64Array... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const alpha = new Complex64( 2.0, 2.0 ); + + caxpy.main( x.length, alpha, x, 1, y, 1 ); // $ExpectType Complex64Array +} + +// The compiler throws an error if the `main` method is provided a first argument which is not a number... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const alpha = new Complex64( 2.0, 2.0 ); + + caxpy.main( '10', alpha, x, 1, y, 1 ); // $ExpectError + caxpy.main( true, alpha, x, 1, y, 1 ); // $ExpectError + caxpy.main( false, alpha, x, 1, y, 1 ); // $ExpectError + caxpy.main( null, alpha, x, 1, y, 1 ); // $ExpectError + caxpy.main( undefined, alpha, x, 1, y, 1 ); // $ExpectError + caxpy.main( [], alpha, x, 1, y, 1 ); // $ExpectError + caxpy.main( {}, alpha, x, 1, y, 1 ); // $ExpectError + caxpy.main( ( x: number ): number => x, alpha, x, 1, y, 1 ); // $ExpectError +} + +// The compiler throws an error if the `main` method is provided a second argument which is not a complex number... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + + caxpy.main( x.length, '10', x, 1, y, 1 ); // $ExpectError + caxpy.main( x.length, true, x, 1, y, 1 ); // $ExpectError + caxpy.main( x.length, false, x, 1, y, 1 ); // $ExpectError + caxpy.main( x.length, null, x, 1, y, 1 ); // $ExpectError + caxpy.main( x.length, undefined, x, 1, y, 1 ); // $ExpectError + caxpy.main( x.length, [], x, 1, y, 1 ); // $ExpectError + caxpy.main( x.length, {}, x, 1, y, 1 ); // $ExpectError + caxpy.main( x.length, ( x: number ): number => x, x, 1, y, 1 ); // $ExpectError +} + +// The compiler throws an error if the `main` method is provided a third argument which is not a Complex64Array... +{ + const y = new Complex64Array( 10 ); + const alpha = new Complex64( 2.0, 2.0 ); + + caxpy.main( y.length, alpha, 10, 1, y, 1 ); // $ExpectError + caxpy.main( y.length, alpha, '10', 1, y, 1 ); // $ExpectError + caxpy.main( y.length, alpha, true, 1, y, 1 ); // $ExpectError + caxpy.main( y.length, alpha, false, 1, y, 1 ); // $ExpectError + caxpy.main( y.length, alpha, null, 1, y, 1 ); // $ExpectError + caxpy.main( y.length, alpha, undefined, 1, y, 1 ); // $ExpectError + caxpy.main( y.length, alpha, [], 1, y, 1 ); // $ExpectError + caxpy.main( y.length, alpha, {}, 1, y, 1 ); // $ExpectError + caxpy.main( y.length, alpha, ( x: number ): number => x, 1, y, 1 ); // $ExpectError +} + +// The compiler throws an error if the `main` method is provided a fourth argument which is not a number... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const alpha = new Complex64( 2.0, 2.0 ); + + caxpy.main( x.length, alpha, x, '10', y, 1 ); // $ExpectError + caxpy.main( x.length, alpha, x, true, y, 1 ); // $ExpectError + caxpy.main( x.length, alpha, x, false, y, 1 ); // $ExpectError + caxpy.main( x.length, alpha, x, null, y, 1 ); // $ExpectError + caxpy.main( x.length, alpha, x, undefined, y, 1 ); // $ExpectError + caxpy.main( x.length, alpha, x, [], y, 1 ); // $ExpectError + caxpy.main( x.length, alpha, x, {}, y, 1 ); // $ExpectError + caxpy.main( x.length, alpha, x, ( x: number ): number => x, y, 1 ); // $ExpectError +} + +// The compiler throws an error if the `main` method is provided a fifth argument which is not a Complex64Array... +{ + const x = new Complex64Array( 10 ); + const alpha = new Complex64( 2.0, 2.0 ); + + caxpy.main( x.length, alpha, x, 1, 10, 1 ); // $ExpectError + caxpy.main( x.length, alpha, x, 1, '10', 1 ); // $ExpectError + caxpy.main( x.length, alpha, x, 1, true, 1 ); // $ExpectError + caxpy.main( x.length, alpha, x, 1, false, 1 ); // $ExpectError + caxpy.main( x.length, alpha, x, 1, null, 1 ); // $ExpectError + caxpy.main( x.length, alpha, x, 1, undefined, 1 ); // $ExpectError + caxpy.main( x.length, alpha, x, 1, [], 1 ); // $ExpectError + caxpy.main( x.length, alpha, x, 1, {}, 1 ); // $ExpectError + caxpy.main( x.length, alpha, x, 1, ( x: number ): number => x, 1 ); // $ExpectError +} + +// The compiler throws an error if the `main` method is provided a sixth argument which is not a number... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const alpha = new Complex64( 2.0, 2.0 ); + + caxpy.main( x.length, alpha, x, 1, y, '10' ); // $ExpectError + caxpy.main( x.length, alpha, x, 1, y, true ); // $ExpectError + caxpy.main( x.length, alpha, x, 1, y, false ); // $ExpectError + caxpy.main( x.length, alpha, x, 1, y, null ); // $ExpectError + caxpy.main( x.length, alpha, x, 1, y, undefined ); // $ExpectError + caxpy.main( x.length, alpha, x, 1, y, [] ); // $ExpectError + caxpy.main( x.length, alpha, x, 1, y, {} ); // $ExpectError + caxpy.main( x.length, alpha, x, 1, y, ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the `main` method is provided an unsupported number of arguments... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const alpha = new Complex64( 2.0, 2.0 ); + + caxpy.main(); // $ExpectError + caxpy.main( x.length ); // $ExpectError + caxpy.main( x.length, alpha ); // $ExpectError + caxpy.main( x.length, alpha, x ); // $ExpectError + caxpy.main( x.length, alpha, x, 1 ); // $ExpectError + caxpy.main( x.length, alpha, x, 1, y ); // $ExpectError + caxpy.main( x.length, alpha, x, 1, 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 alpha = new Complex64( 2.0, 2.0 ); + + caxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, 0 ); // $ExpectType Complex64Array +} + +// The compiler throws an error if the `ndarray` method is provided a first argument which is not a number... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const alpha = new Complex64( 2.0, 2.0 ); + + caxpy.ndarray( '10', alpha, x, 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( true, alpha, x, 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( false, alpha, x, 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( null, alpha, x, 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( undefined, alpha, x, 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( [], alpha, x, 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( {}, alpha, x, 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( ( x: number ): number => x, alpha, x, 1, 0, y, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a second argument which is not a complex number... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + + caxpy.ndarray( x.length, '10', x, 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, true, x, 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, false, x, 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, null, x, 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, undefined, x, 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, [], x, 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, {}, x, 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, ( x: number ): number => x, x, 1, 0, y, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a third argument which is not a Complex64Array... +{ + const y = new Complex64Array( 10 ); + const alpha = new Complex64( 2.0, 2.0 ); + + caxpy.ndarray( y.length, alpha, 10, 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( y.length, alpha, '10', 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( y.length, alpha, true, 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( y.length, alpha, false, 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( y.length, alpha, null, 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( y.length, alpha, undefined, 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( y.length, alpha, [], 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( y.length, alpha, {}, 1, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( y.length, alpha, ( x: number ): number => x, 1, 0, y, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const alpha = new Complex64( 2.0, 2.0 ); + + caxpy.ndarray( x.length, alpha, x, '10', 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, true, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, false, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, null, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, undefined, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, [], 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, {}, 0, y, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, ( x: number ): number => x, 0, y, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a number... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const alpha = new Complex64( 2.0, 2.0 ); + + caxpy.ndarray( x.length, alpha, x, 1, '10', y, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, true, y, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, false, y, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, null, y, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, undefined, y, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, [], y, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, {}, y, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, ( x: number ): number => x, y, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a sixth argument which is not a Complex64Array... +{ + const x = new Complex64Array( 10 ); + const alpha = new Complex64( 2.0, 2.0 ); + + caxpy.ndarray( x.length, alpha, x, 1, 0, 10, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, '10', 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, true, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, false, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, null, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, undefined, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, [], 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, {}, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, ( x: number ): number => x, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a seventh argument which is not a number... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const alpha = new Complex64( 2.0, 2.0 ); + + caxpy.ndarray( x.length, alpha, x, 1, 0, y, '10', 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, y, true, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, y, false, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, y, null, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, y, undefined, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, y, [], 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, y, {}, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, y, ( x: number ): number => x, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided an eighth argument which is not a number... +{ + const x = new Complex64Array( 10 ); + const y = new Complex64Array( 10 ); + const alpha = new Complex64( 2.0, 2.0 ); + + caxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, '10' ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, true ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, false ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, null ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, undefined ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, [] ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, {} ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, 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 alpha = new Complex64( 2.0, 2.0 ); + + caxpy.ndarray(); // $ExpectError + caxpy.ndarray( x.length ); // $ExpectError + caxpy.ndarray( x.length, alpha ); // $ExpectError + caxpy.ndarray( x.length, alpha, x ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, y ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, y, 1 ); // $ExpectError + caxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, 0, 10 ); // $ExpectError +} + +// Attached to the main export is a `Module` constructor which returns a module... +{ + const mem = new Memory({ + 'initial': 0 + }); + + caxpy.Module( mem ); // $ExpectType Module +} + +// The compiler throws an error if the `Module` constructor is not provided a WebAssembly memory instance... +{ + caxpy.Module( '10' ); // $ExpectError + caxpy.Module( true ); // $ExpectError + caxpy.Module( false ); // $ExpectError + caxpy.Module( null ); // $ExpectError + caxpy.Module( undefined ); // $ExpectError + caxpy.Module( [] ); // $ExpectError + caxpy.Module( {} ); // $ExpectError + caxpy.Module( ( x: number ): number => x ); // $ExpectError +} + +// The `Module` constructor returns a module instance having a `main` method which returns a number... +{ + const mem = new Memory({ + 'initial': 1 + }); + const mod = caxpy.Module( mem ); + + mod.main( 10, 160, 0, 1, 80, 1 ); // $ExpectType number +} + +// The compiler throws an error if the `main` method of a module instance is provided a first argument which is not a number... +{ + const mem = new Memory({ + 'initial': 1 + }); + const mod = caxpy.Module( mem ); + + mod.main( '10', 160, 0, 1, 80, 1 ); // $ExpectError + mod.main( true, 160, 0, 1, 80, 1 ); // $ExpectError + mod.main( false, 160, 0, 1, 80, 1 ); // $ExpectError + mod.main( null, 160, 0, 1, 80, 1 ); // $ExpectError + mod.main( undefined, 160, 0, 1, 80, 1 ); // $ExpectError + mod.main( [], 160, 0, 1, 80, 1 ); // $ExpectError + mod.main( {}, 160, 0, 1, 80, 1 ); // $ExpectError + mod.main( ( x: number ): number => x, 160, 0, 1, 80, 1 ); // $ExpectError +} + +// The compiler throws an error if the `main` method of a module instance is provided a second argument which is not a number... +{ + const mem = new Memory({ + 'initial': 1 + }); + const mod = caxpy.Module( mem ); + + mod.main( 10, '10', 0, 1, 80, 1 ); // $ExpectError + mod.main( 10, true, 0, 1, 80, 1 ); // $ExpectError + mod.main( 10, false, 0, 1, 80, 1 ); // $ExpectError + mod.main( 10, null, 0, 1, 80, 1 ); // $ExpectError + mod.main( 10, undefined, 0, 1, 80, 1 ); // $ExpectError + mod.main( 10, [], 0, 1, 80, 1 ); // $ExpectError + mod.main( 10, {}, 0, 1, 80, 1 ); // $ExpectError + mod.main( 10, ( x: number ): number => x, 0, 1, 80, 1 ); // $ExpectError +} + +// The compiler throws an error if the `main` method of a module instance is provided a third argument which is not a number... +{ + const mem = new Memory({ + 'initial': 1 + }); + const mod = caxpy.Module( mem ); + + mod.main( 10, 160, '10', 1, 80, 1 ); // $ExpectError + mod.main( 10, 160, true, 1, 80, 1 ); // $ExpectError + mod.main( 10, 160, false, 1, 80, 1 ); // $ExpectError + mod.main( 10, 160, null, 1, 80, 1 ); // $ExpectError + mod.main( 10, 160, undefined, 1, 80, 1 ); // $ExpectError + mod.main( 10, 160, [], 1, 80, 1 ); // $ExpectError + mod.main( 10, 160, {}, 1, 80, 1 ); // $ExpectError + mod.main( 10, 160, ( x: number ): number => x, 1, 80, 1 ); // $ExpectError +} + +// The compiler throws an error if the `main` method of a module instance is provided a fourth argument which is not a number... +{ + const mem = new Memory({ + 'initial': 1 + }); + const mod = caxpy.Module( mem ); + + mod.main( 10, 160, 0, '10', 80, 1 ); // $ExpectError + mod.main( 10, 160, 0, true, 80, 1 ); // $ExpectError + mod.main( 10, 160, 0, false, 80, 1 ); // $ExpectError + mod.main( 10, 160, 0, null, 80, 1 ); // $ExpectError + mod.main( 10, 160, 0, undefined, 80, 1 ); // $ExpectError + mod.main( 10, 160, 0, [], 80, 1 ); // $ExpectError + mod.main( 10, 160, 0, {}, 80, 1 ); // $ExpectError + mod.main( 10, 160, 0, ( x: number ): number => x, 80, 1 ); // $ExpectError +} + +// The compiler throws an error if the `main` method of a module instance is provided a fifth argument which is not a number... +{ + const mem = new Memory({ + 'initial': 1 + }); + const mod = caxpy.Module( mem ); + + mod.main( 10, 160, 0, 1, '10', 1 ); // $ExpectError + mod.main( 10, 160, 0, 1, true, 1 ); // $ExpectError + mod.main( 10, 160, 0, 1, false, 1 ); // $ExpectError + mod.main( 10, 160, 0, 1, null, 1 ); // $ExpectError + mod.main( 10, 160, 0, 1, undefined, 1 ); // $ExpectError + mod.main( 10, 160, 0, 1, [], 1 ); // $ExpectError + mod.main( 10, 160, 0, 1, {}, 1 ); // $ExpectError + mod.main( 10, 160, 0, 1, ( x: number ): number => x, 1 ); // $ExpectError +} + +// The compiler throws an error if the `main` method of a module instance is provided a sixth argument which is not a number... +{ + const mem = new Memory({ + 'initial': 1 + }); + const mod = caxpy.Module( mem ); + + mod.main( 10, 160, 0, 1, 80, '10' ); // $ExpectError + mod.main( 10, 160, 0, 1, 80, true ); // $ExpectError + mod.main( 10, 160, 0, 1, 80, false ); // $ExpectError + mod.main( 10, 160, 0, 1, 80, null ); // $ExpectError + mod.main( 10, 160, 0, 1, 80, undefined ); // $ExpectError + mod.main( 10, 160, 0, 1, 80, [] ); // $ExpectError + mod.main( 10, 160, 0, 1, 80, {} ); // $ExpectError + mod.main( 10, 160, 0, 1, 80, ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the `main` method of a module instance is provided an unsupported number of arguments... +{ + const mem = new Memory({ + 'initial': 1 + }); + const mod = caxpy.Module( mem ); + + mod.main(); // $ExpectError + mod.main( 10 ); // $ExpectError + mod.main( 10, 160 ); // $ExpectError + mod.main( 10, 160, 0 ); // $ExpectError + mod.main( 10, 160, 0, 1 ); // $ExpectError + mod.main( 10, 160, 0, 1, 80 ); // $ExpectError + mod.main( 10, 160, 0, 1, 80, 1, 10 ); // $ExpectError +} + +// The `Module` constructor returns a module instance having an `ndarray` method which returns a number... +{ + const mem = new Memory({ + 'initial': 1 + }); + const mod = caxpy.Module( mem ); + + mod.ndarray( 10, 160, 0, 1, 0, 80, 1, 0 ); // $ExpectType number +} + +// The compiler throws an error if the `ndarray` method of a module instance is provided a first argument which is not a number... +{ + const mem = new Memory({ + 'initial': 1 + }); + const mod = caxpy.Module( mem ); + + mod.ndarray( '10', 160, 0, 1, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( true, 160, 0, 1, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( false, 160, 0, 1, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( null, 160, 0, 1, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( undefined, 160, 0, 1, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( [], 160, 0, 1, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( {}, 160, 0, 1, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( ( x: number ): number => x, 160, 0, 1, 0, 80, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method of a module instance is provided a second argument which is not a number... +{ + const mem = new Memory({ + 'initial': 1 + }); + const mod = caxpy.Module( mem ); + + mod.ndarray( 10, '10', 0, 1, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, true, 0, 1, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, false, 0, 1, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, null, 0, 1, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, undefined, 0, 1, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, [], 0, 1, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, {}, 0, 1, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, ( x: number ): number => x, 0, 1, 0, 80, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method of a module instance is provided a third argument which is not a number... +{ + const mem = new Memory({ + 'initial': 1 + }); + const mod = caxpy.Module( mem ); + + mod.ndarray( 10, 160, '10', 1, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, true, 1, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, false, 1, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, null, 1, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, undefined, 1, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, [], 1, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, {}, 1, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, ( x: number ): number => x, 1, 0, 80, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method of a module instance is provided a fourth argument which is not a number... +{ + const mem = new Memory({ + 'initial': 1 + }); + const mod = caxpy.Module( mem ); + + mod.ndarray( 10, 160, 0, '10', 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, true, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, false, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, null, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, undefined, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, [], 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, {}, 0, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, ( x: number ): number => x, 0, 80, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method of a module instance is provided a fifth argument which is not a number... +{ + const mem = new Memory({ + 'initial': 1 + }); + const mod = caxpy.Module( mem ); + + mod.ndarray( 10, 160, 0, 1, '10', 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, true, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, false, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, null, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, undefined, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, [], 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, {}, 80, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, ( x: number ): number => x, 80, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method of a module instance is provided a sixth argument which is not a number... +{ + const mem = new Memory({ + 'initial': 1 + }); + const mod = caxpy.Module( mem ); + + mod.ndarray( 10, 160, 0, 1, 0, '10', 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, true, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, false, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, null, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, undefined, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, [], 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, {}, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, ( x: number ): number => x, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method of a module instance is provided a seventh argument which is not a number... +{ + const mem = new Memory({ + 'initial': 1 + }); + const mod = caxpy.Module( mem ); + + mod.ndarray( 10, 160, 0, 1, 0, 80, '10', 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, 80, true, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, 80, false, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, 80, null, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, 80, undefined, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, 80, [], 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, 80, {}, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, 80, ( x: number ): number => x, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method of a module instance is provided an eighth argument which is not a number... +{ + const mem = new Memory({ + 'initial': 1 + }); + const mod = caxpy.Module( mem ); + + mod.ndarray( 10, 160, 0, 1, 0, 80, 1, '10' ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, 80, 1, true ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, 80, 1, false ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, 80, 1, null ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, 80, 1, undefined ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, 80, 1, [] ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, 80, 1, {} ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, 80, 1, ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method of a module instance is provided an unsupported number of arguments... +{ + const mem = new Memory({ + 'initial': 1 + }); + const mod = caxpy.Module( mem ); + + mod.ndarray(); // $ExpectError + mod.ndarray( 10 ); // $ExpectError + mod.ndarray( 10, 160 ); // $ExpectError + mod.ndarray( 10, 160, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, 80 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, 80, 1 ); // $ExpectError + mod.ndarray( 10, 160, 0, 1, 0, 80, 1, 0, 10 ); // $ExpectError +} diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/examples/index.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/examples/index.js new file mode 100644 index 000000000000..67d5f19170e2 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/examples/index.js @@ -0,0 +1,53 @@ +/** +* @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 hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' ); +var oneTo = require( '@stdlib/array/one-to' ); +var ones = require( '@stdlib/array/ones' ); +var Complex64 = require( '@stdlib/complex/float32/ctor' ); +var Complex64Array = require( '@stdlib/array/complex64' ); +var reinterpretComplex64 = require( '@stdlib/strided/base/reinterpret-complex64' ); +var caxpy = require( './../lib' ); + +function main() { + if ( !hasWebAssemblySupport() ) { + console.error( 'Environment does not support WebAssembly.' ); + return; + } + // Specify a vector length: + var N = 5; + + // Create the input arrays: + var xbuf = oneTo( N*2, 'float32' ); + var x = new Complex64Array( xbuf.buffer ); + var y = new Complex64Array( ones( N*2, 'float32' ).buffer ); + + // Create a complex number: + var alpha = new Complex64( 2.0, 2.0 ); + + // Perform computation: + caxpy.ndarray( N, alpha, x, 1, 0, y, 1, 0 ); + + // Print the results: + console.log( reinterpretComplex64( y, 0 ) ); + // => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0, -1.0, 31.0, -1.0, 39.0 ] +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/examples/little_endian_arrays.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/examples/little_endian_arrays.js new file mode 100644 index 000000000000..3fe663c2d287 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/examples/little_endian_arrays.js @@ -0,0 +1,73 @@ +/** +* @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 hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' ); +var Memory = require( '@stdlib/wasm/memory' ); +var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ).factory; +var gfillBy = require( '@stdlib/blas/ext/base/gfill-by' ); +var bytesPerElement = require( '@stdlib/ndarray/base/bytes-per-element' ); +var Float32ArrayLE = require( '@stdlib/array/little-endian-float32' ); +var caxpy = require( './../lib' ); + +function main() { + if ( !hasWebAssemblySupport() ) { + console.error( 'Environment does not support WebAssembly.' ); + return; + } + // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB): + var mem = new Memory({ + 'initial': 10, + 'maximum': 100 + }); + + // Create a BLAS routine: + var mod = new caxpy.Module( mem ); + // returns + + // Initialize the routine: + mod.initializeSync(); // eslint-disable-line n/no-sync + + // Specify a vector length: + var N = 5; + + // Define pointers (i.e., byte offsets) for storing two vectors and a complex number: + var xptr = 0; + var yptr = N * bytesPerElement( 'complex64' ); + var aptr = 2 * N * bytesPerElement( 'complex64' ); + + // Create typed array views over module memory: + var x = new Float32ArrayLE( mod.memory.buffer, xptr, N*2 ); + var y = new Float32ArrayLE( mod.memory.buffer, yptr, N*2 ); + var a = new Float32ArrayLE( mod.memory.buffer, aptr, 2 ); + + // Write values to module memory: + gfillBy( N*2, x, 1, discreteUniform( -10.0, 10.0 ) ); + gfillBy( N*2, y, 1, discreteUniform( -10.0, 10.0 ) ); + gfillBy( 2, a, 1, discreteUniform( -10.0, 10.0 ) ); + + // Perform computation: + mod.ndarray( N, aptr, xptr, 1, 0, yptr, 1, 0 ); + + // Print the results: + console.log( 'x[:] = [%s]', x.toString() ); + console.log( 'y[:] = [%s]', y.toString() ); +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/examples/module.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/examples/module.js new file mode 100644 index 000000000000..8dcead8d62cb --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/examples/module.js @@ -0,0 +1,84 @@ +/** +* @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 hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' ); +var Memory = require( '@stdlib/wasm/memory' ); +var bytesPerElement = require( '@stdlib/ndarray/base/bytes-per-element' ); +var oneTo = require( '@stdlib/array/one-to' ); +var ones = require( '@stdlib/array/ones' ); +var zeros = require( '@stdlib/array/zeros' ); +var Complex64Array = require( '@stdlib/array/complex64' ); +var Float32Array = require( '@stdlib/array/float32' ); +var reinterpretComplex64 = require( '@stdlib/strided/base/reinterpret-complex64' ); +var caxpy = require( './../lib' ); + +function main() { + if ( !hasWebAssemblySupport() ) { + console.error( 'Environment does not support WebAssembly.' ); + return; + } + // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB): + var mem = new Memory({ + 'initial': 10, + 'maximum': 100 + }); + + // Create a BLAS routine: + var mod = new caxpy.Module( mem ); + // returns + + // Initialize the routine: + mod.initializeSync(); // eslint-disable-line n/no-sync + + // Define a vector data type for interleaved real and imaginary components: + var dtype = 'complex64'; + + // Specify a vector length: + var N = 5; + + // Define pointers (i.e., byte offsets) for storing two vectors and a complex number: + var xptr = 0; + var yptr = N * bytesPerElement( dtype ); + var aptr = 2 * N * bytesPerElement( dtype ); + + // Write vector values to module memory: + var xbuf = oneTo( N*2, 'float32' ); + var x = new Complex64Array( xbuf.buffer ); + mod.write( xptr, x ); + + var ybuf = ones( N*2, 'float32' ); + var y = new Complex64Array( ybuf.buffer ); + mod.write( yptr, y ); + + // Write complex number components to module memory: + mod.write( aptr, new Float32Array( [ 2.0, 2.0 ] ) ); + + // Perform computation: + mod.ndarray( N, aptr, xptr, 1, 0, yptr, 1, 0 ); + + // Read out the results: + var view = zeros( N, dtype ); + mod.read( yptr, view ); + + console.log( reinterpretComplex64( view, 0 ) ); + // => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0, -1.0, 31.0, -1.0, 39.0 ] +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/lib/binary.browser.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/lib/binary.browser.js new file mode 100644 index 000000000000..38a445493109 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/lib/binary.browser.js @@ -0,0 +1,33 @@ +/** +* @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 base64ToUint8Array = require( '@stdlib/string/base/base64-to-uint8array' ); + + +// MAIN // + +var wasm = base64ToUint8Array( 'AGFzbQEAAAAADwhkeWxpbmsuMAEEAAAAAAEYA2AAAGAGf39/f39/AGAIf39/f39/f38AAiYCA2VudgZtZW1vcnkCAAADZW52D19fc3RhY2tfcG9pbnRlcgN/AQMEAwABAgcxAxFfX3dhc21fY2FsbF9jdG9ycwAAB2NfY2F4cHkAAQ9jX2NheHB5X25kYXJyYXkAAgr+AQMDAAELTgEBfyMAQRBrIgYkACAGIAEpAgA3AwggACAGQQhqIAIgA0EBIABrIgAgA2xBACADQQBMGyAEIAUgACAFbEEAIAVBAEwbEAIgBkEQaiQAC6gBAgJ+BH0CQCAAQQBMDQAgASoCACIKiyABKgIEIguLkkMAAAAAWw0AIAUgB0EDdGohASACIARBA3RqIQcgAK0hCSAGQQN0IQAgA0EDdCECA0AgCCAJUQ0BIAEgCiAHKgIEIgyUIAcqAgAiDSALlJIgASoCBJI4AgQgASAKIA2UIAsgDJSTIAEqAgCSOAIAIAhCAXwhCCAAIAFqIQEgAiAHaiEHDAALAAsL' ); + + +// EXPORTS // + +module.exports = wasm; diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/lib/binary.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/lib/binary.js new file mode 100644 index 000000000000..b2cc0a347ff9 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/lib/binary.js @@ -0,0 +1,34 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var resolve = require( 'path' ).resolve; +var readWASM = require( '@stdlib/fs/read-wasm' ).sync; + + +// MAIN // + +var wasm = readWASM( resolve( __dirname, '..', 'src', 'main.wasm' ) ); + + +// EXPORTS // + +module.exports = wasm; diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/lib/index.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/lib/index.js new file mode 100644 index 000000000000..a2940a97e1db --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/lib/index.js @@ -0,0 +1,118 @@ +/** +* @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'; + +/** +* WebAssembly routine to scale a single-precision complex floating-point vector by a single-precision complex floating-point constant and add the result to a single-precision complex floating-point vector. +* +* @module @stdlib/blas/base/wasm/caxpy +* +* @example +* var Complex64Array = require( '@stdlib/array/complex64' ); +* var Complex64 = require( '@stdlib/complex/float32/ctor' ); +* var caxpy = require( '@stdlib/blas/base/wasm/caxpy' ); +* +* // Define strided arrays: +* var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); +* var y = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); +* +* // Define a scalar constant: +* var alpha = new Complex64( 2.0, 2.0 ); +* +* // Perform operation: +* caxpy.main( x.length, alpha, x, 1, y, 1 ); +* // y => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] +* +* @example +* var Complex64Array = require( '@stdlib/array/complex64' ); +* var Complex64 = require( '@stdlib/complex/float32/ctor' ); +* var caxpy = require( '@stdlib/blas/base/wasm/caxpy' ); +* +* // Define strided arrays: +* var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); +* var y = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); +* +* // Define a scalar constant: +* var alpha = new Complex64( 2.0, 2.0 ); +* +* // Perform operation: +* caxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, 0 ); +* // y => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] +* +* @example +* var Memory = require( '@stdlib/wasm/memory' ); +* var zeros = require( '@stdlib/array/zeros' ); +* var bytesPerElement = require( '@stdlib/ndarray/base/bytes-per-element' ); +* var Float32Array = require( '@stdlib/array/float32' ); +* var Complex64Array = require( '@stdlib/array/complex64' ); +* var reinterpretComplex64 = require( '@stdlib/strided/base/reinterpret-complex64' ); +* var caxpy = require( '@stdlib/blas/base/wasm/caxpy' ); +* +* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB): +* var mem = new Memory({ +* 'initial': 10, +* 'maximum': 100 +* }); +* +* // Create a BLAS routine: +* var mod = new caxpy.Module( mem ); +* // returns +* +* // Initialize the routine: +* mod.initializeSync(); +* +* // Define a vector data type: +* var dtype = 'complex64'; +* +* // Specify a vector length: +* var N = 3; +* +* // Define pointers (i.e., byte offsets) for storing two vectors and a complex number: +* var xptr = 0; +* var yptr = N * bytesPerElement( dtype ); +* var aptr = 2 * N * bytesPerElement( dtype ); +* +* // Write vector values to module memory: +* mod.write( xptr, new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ) ); +* mod.write( yptr, new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ) ); +* +* // Write a complex number to module memory: +* mod.write( aptr, new Float32Array( [ 2.0, 2.0 ] ) ); +* +* // Perform computation: +* mod.main( N, aptr, xptr, 1, yptr, 1 ); +* +* // Read out the results: +* var view = zeros( N, dtype ); +* mod.read( yptr, view ); +* +* console.log( reinterpretComplex64( view, 0 ) ); +* // => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] +*/ + +// MODULES // + +var main = require( './main.js' ); + + +// EXPORTS // + +module.exports = main; + +// exports: { "Module": "main.Module" } diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/lib/main.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/lib/main.js new file mode 100644 index 000000000000..613fc2c0dac1 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/lib/main.js @@ -0,0 +1,73 @@ +/** +* @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 Routine = require( './routine.js' ); +var Module = require( './module.js' ); + + +// MAIN // + +/** +* WebAssembly module to scale a single-precision complex floating-point vector by a single-precision complex floating-point constant and add the result to a single-precision complex floating-point vector. +* +* @name caxpy +* @type {Routine} +* +* @example +* var Complex64Array = require( '@stdlib/array/complex64' ); +* var Complex64 = require( '@stdlib/complex/float32/ctor' ); +* +* // Define strided arrays: +* var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); +* var y = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); +* +* // Define a scalar constant: +* var alpha = new Complex64( 2.0, 2.0 ); +* +* // Perform operation: +* caxpy.main( x.length, alpha, x, 1, y, 1 ); +* // y => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] +* +* @example +* var Complex64Array = require( '@stdlib/array/complex64' ); +* var Complex64 = require( '@stdlib/complex/float32/ctor' ); +* +* // Define strided arrays: +* var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); +* var y = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); +* +* // Define a scalar constant: +* var alpha = new Complex64( 2.0, 2.0 ); +* +* // Perform operation: +* caxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, 0 ); +* // y => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] +*/ +var caxpy = new Routine(); +caxpy.initializeSync(); // eslint-disable-line n/no-sync +setReadOnly( caxpy, 'Module', Module.bind( null ) ); + + +// EXPORTS // + +module.exports = caxpy; diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/lib/module.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/lib/module.js new file mode 100644 index 000000000000..c0fe065281d9 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/lib/module.js @@ -0,0 +1,273 @@ +/** +* @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 no-restricted-syntax, no-invalid-this */ + +'use strict'; + +// MODULES // + +var isWebAssemblyMemory = require( '@stdlib/assert/is-wasm-memory' ); +var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' ); +var inherits = require( '@stdlib/utils/inherit' ); +var WasmModule = require( '@stdlib/wasm/module-wrapper' ); +var format = require( '@stdlib/string/format' ); +var wasmBinary = require( './binary.js' ); + + +// MAIN // + +/** +* BLAS routine WebAssembly module wrapper constructor. +* +* @constructor +* @param {Object} memory - WebAssembly memory instance +* @throws {TypeError} must provide a WebAssembly memory instance +* @returns {Module} module instance +* +* @example +* var Memory = require( '@stdlib/wasm/memory' ); +* var zeros = require( '@stdlib/array/zeros' ); +* var bytesPerElement = require( '@stdlib/ndarray/base/bytes-per-element' ); +* var Float32Array = require( '@stdlib/array/float32' ); +* var Complex64Array = require( '@stdlib/array/complex64' ); +* var reinterpretComplex64 = require( '@stdlib/strided/base/reinterpret-complex64' ); +* +* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB): +* var mem = new Memory({ +* 'initial': 10, +* 'maximum': 100 +* }); +* +* // Create a BLAS routine: +* var caxpy = new Module( mem ); +* // returns +* +* // Initialize the routine: +* caxpy.initializeSync(); +* +* // Define a vector data type: +* var dtype = 'complex64'; +* +* // Specify a vector length: +* var N = 3; +* +* // Define pointers (i.e., byte offsets) for storing two vectors and a complex number: +* var xptr = 0; +* var yptr = N * bytesPerElement( dtype ); +* var aptr = 2 * N * bytesPerElement( dtype ); +* +* // Write vector values to module memory: +* caxpy.write( xptr, new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ) ); +* caxpy.write( yptr, new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ) ); +* +* // Write a complex number to module memory: +* caxpy.write( aptr, new Float32Array( [ 2.0, 2.0 ] ) ); +* +* // Perform computation: +* var ptr = caxpy.main( N, aptr, xptr, 1, yptr, 1 ); +* // returns +* +* var bool = ( ptr === yptr ); +* // returns true +* +* // Read out the results: +* var view = zeros( N, dtype ); +* caxpy.read( yptr, view ); +* +* console.log( reinterpretComplex64( view, 0 ) ); +* // => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] +*/ +function Module( memory ) { + if ( !( this instanceof Module ) ) { + return new Module( memory ); + } + if ( !isWebAssemblyMemory( memory ) ) { + throw new TypeError( format( 'invalid argument. Must provide a WebAssembly memory instance. Value: `%s`.', memory ) ); + } + // Call the parent constructor: + WasmModule.call( this, wasmBinary, memory, { + 'env': { + 'memory': memory, + + // NOTE: required by Emscripten `SIDE_MODULE` builds which use the stack (e.g., to pass complex values by value between routines): + '__stack_pointer': new WebAssembly.Global({ // eslint-disable-line n/no-unsupported-features/node-builtins + 'value': 'i32', + 'mutable': true + }, 65536 ) + } + }); + + return this; +} + +// Inherit from the parent constructor: +inherits( Module, WasmModule ); + +/** +* Scales a single-precision complex floating-point vector by a single-precision complex floating-point constant and adds the result to a single-precision complex floating-point vector. +* +* @name main +* @memberof Module.prototype +* @readonly +* @type {Function} +* @param {PositiveInteger} N - number of indexed elements +* @param {NonNegativeInteger} aptr - scalar constant pointer (i.e., byte offset) +* @param {NonNegativeInteger} xptr - first input array pointer (i.e., byte offset) +* @param {integer} strideX - `x` stride length +* @param {NonNegativeInteger} yptr - second input array pointer (i.e., byte offset) +* @param {integer} strideY - `y` stride length +* @returns {NonNegativeInteger} second input array pointer (i.e., byte offset) +* +* @example +* var Memory = require( '@stdlib/wasm/memory' ); +* var zeros = require( '@stdlib/array/zeros' ); +* var bytesPerElement = require( '@stdlib/ndarray/base/bytes-per-element' ); +* var Float32Array = require( '@stdlib/array/float32' ); +* var Complex64Array = require( '@stdlib/array/complex64' ); +* var reinterpretComplex64 = require( '@stdlib/strided/base/reinterpret-complex64' ); +* +* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB): +* var mem = new Memory({ +* 'initial': 10, +* 'maximum': 100 +* }); +* +* // Create a BLAS routine: +* var caxpy = new Module( mem ); +* // returns +* +* // Initialize the routine: +* caxpy.initializeSync(); +* +* // Define a vector data type: +* var dtype = 'complex64'; +* +* // Specify a vector length: +* var N = 3; +* +* // Define pointers (i.e., byte offsets) for storing two vectors and a complex number: +* var xptr = 0; +* var yptr = N * bytesPerElement( dtype ); +* var aptr = 2 * N * bytesPerElement( dtype ); +* +* // Write vector values to module memory: +* caxpy.write( xptr, new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ) ); +* caxpy.write( yptr, new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ) ); +* +* // Write a complex number to module memory: +* caxpy.write( aptr, new Float32Array( [ 2.0, 2.0 ] ) ); +* +* // Perform computation: +* var ptr = caxpy.main( N, aptr, xptr, 1, yptr, 1 ); +* // returns +* +* var bool = ( ptr === yptr ); +* // returns true +* +* // Read out the results: +* var view = zeros( N, dtype ); +* caxpy.read( yptr, view ); +* +* console.log( reinterpretComplex64( view, 0 ) ); +* // => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] +*/ +setReadOnly( Module.prototype, 'main', function caxpy( N, aptr, xptr, strideX, yptr, strideY ) { // eslint-disable-line stdlib/jsdoc-doctest-decimal-point + this._instance.exports.c_caxpy( N, aptr, xptr, strideX, yptr, strideY ); + return yptr; +}); + +/** +* Scales a single-precision complex floating-point vector by a single-precision complex floating-point constant and adds the result to a single-precision complex floating-point vector using alternative indexing semantics. +* +* @name ndarray +* @memberof Module.prototype +* @readonly +* @type {Function} +* @param {PositiveInteger} N - number of indexed elements +* @param {NonNegativeInteger} aptr - scalar constant pointer (i.e., byte offset) +* @param {NonNegativeInteger} xptr - first input array pointer (i.e., byte offset) +* @param {integer} strideX - `x` stride length +* @param {NonNegativeInteger} offsetX - starting `x` index +* @param {NonNegativeInteger} yptr - second input array pointer (i.e., byte offset) +* @param {integer} strideY - `y` stride length +* @param {NonNegativeInteger} offsetY - starting `y` index +* @returns {NonNegativeInteger} second input array pointer (i.e., byte offset) +* +* @example +* var Memory = require( '@stdlib/wasm/memory' ); +* var zeros = require( '@stdlib/array/zeros' ); +* var bytesPerElement = require( '@stdlib/ndarray/base/bytes-per-element' ); +* var Float32Array = require( '@stdlib/array/float32' ); +* var Complex64Array = require( '@stdlib/array/complex64' ); +* var reinterpretComplex64 = require( '@stdlib/strided/base/reinterpret-complex64' ); +* +* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB): +* var mem = new Memory({ +* 'initial': 10, +* 'maximum': 100 +* }); +* +* // Create a BLAS routine: +* var caxpy = new Module( mem ); +* // returns +* +* // Initialize the routine: +* caxpy.initializeSync(); +* +* // Define a vector data type: +* var dtype = 'complex64'; +* +* // Specify a vector length: +* var N = 3; +* +* // Define pointers (i.e., byte offsets) for storing two vectors and a complex number: +* var xptr = 0; +* var yptr = N * bytesPerElement( dtype ); +* var aptr = 2 * N * bytesPerElement( dtype ); +* +* // Write vector values to module memory: +* caxpy.write( xptr, new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ) ); +* caxpy.write( yptr, new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ) ); +* +* // Write a complex number to module memory: +* caxpy.write( aptr, new Float32Array( [ 2.0, 2.0 ] ) ); +* +* // Perform computation: +* var ptr = caxpy.ndarray( N, aptr, xptr, 1, 0, yptr, 1, 0 ); +* // returns +* +* var bool = ( ptr === yptr ); +* // returns true +* +* // Read out the results: +* var view = zeros( N, dtype ); +* caxpy.read( yptr, view ); +* +* console.log( reinterpretComplex64( view, 0 ) ); +* // => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] +*/ +setReadOnly( Module.prototype, 'ndarray', function caxpy( N, aptr, xptr, strideX, offsetX, yptr, strideY, offsetY ) { // eslint-disable-line stdlib/jsdoc-doctest-decimal-point + this._instance.exports.c_caxpy_ndarray( N, aptr, xptr, strideX, offsetX, yptr, strideY, offsetY ); // eslint-disable-line max-len + return yptr; +}); + + +// EXPORTS // + +module.exports = Module; diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/lib/routine.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/lib/routine.js new file mode 100644 index 000000000000..aba7dae7ff31 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/lib/routine.js @@ -0,0 +1,207 @@ +/** +* @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 no-restricted-syntax, no-invalid-this */ + +'use strict'; + +// MODULES // + +var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' ); +var inherits = require( '@stdlib/utils/inherit' ); +var stride2offset = require( '@stdlib/strided/base/stride2offset' ); +var readDataView = require( '@stdlib/strided/base/read-dataview' ).ndarray; +var Memory = require( '@stdlib/wasm/memory' ); +var arrays2ptrs = require( '@stdlib/wasm/base/arrays2ptrs' ); +var reimf = require( '@stdlib/complex/float32/reim' ); +var strided2object = require( '@stdlib/wasm/base/strided2object' ); +var Module = require( './module.js' ); + + +// MAIN // + +/** +* Routine constructor. +* +* @private +* @constructor +* @returns {Routine} routine instance +* +* @example +* var Complex64Array = require( '@stdlib/array/complex64' ); +* var Complex64 = require( '@stdlib/complex/float32/ctor' ); +* +* // Create a new routine: +* var caxpy = new Routine(); +* +* // Initialize the module: +* caxpy.initializeSync(); +* +* // Define strided arrays: +* var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); +* var y = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); +* +* // Create a complex number: +* var alpha = new Complex64( 2.0, 2.0 ); +* +* // Perform operation: +* caxpy.main( x.length, alpha, x, 1, y, 1 ); +* // y => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] +* +* @example +* var Complex64Array = require( '@stdlib/array/complex64' ); +* var Complex64 = require( '@stdlib/complex/float32/ctor' ); +* +* // Create a new routine: +* var caxpy = new Routine(); +* +* // Initialize the module: +* caxpy.initializeSync(); +* +* // Define strided arrays: +* var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); +* var y = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); +* +* // Create a complex number: +* var alpha = new Complex64( 2.0, 2.0 ); +* +* // Perform operation: +* caxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, 0 ); +* // y => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] +*/ +function Routine() { + if ( !( this instanceof Routine ) ) { + return new Routine(); + } + Module.call( this, new Memory({ + 'initial': 0 + })); + return this; +} + +// Inherit from the parent constructor: +inherits( Routine, Module ); + +/** +* Scales a single-precision complex floating-point vector by a single-precision complex floating-point constant and adds the result to a single-precision complex floating-point vector. +* +* @name main +* @memberof Routine.prototype +* @readonly +* @type {Function} +* @param {PositiveInteger} N - number of indexed elements +* @param {Complex64} alpha - scalar constant +* @param {Complex64Array} x - first input array +* @param {integer} strideX - `x` stride length +* @param {Complex64Array} y - second input array +* @param {integer} strideY - `y` stride length +* @returns {Complex64Array} second input array +* +* @example +* var Complex64Array = require( '@stdlib/array/complex64' ); +* var Complex64 = require( '@stdlib/complex/float32/ctor' ); +* +* // Create a new routine: +* var caxpy = new Routine(); +* +* // Initialize the module: +* caxpy.initializeSync(); +* +* // Define strided arrays: +* var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); +* var y = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); +* +* // Create a complex number: +* var alpha = new Complex64( 2.0, 2.0 ); +* +* // Perform operation: +* caxpy.main( x.length, alpha, x, 1, y, 1 ); +* // y => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] +*/ +setReadOnly( Routine.prototype, 'main', function caxpy( N, alpha, x, strideX, y, strideY ) { + return this.ndarray( N, alpha, x, strideX, stride2offset( N, strideX ), y, strideY, stride2offset( N, strideY ) ); // eslint-disable-line max-len +}); + +/** +* Scales a single-precision complex floating-point vector by a single-precision complex floating-point constant and adds the result to a single-precision complex floating-point vector using alternative indexing semantics. +* +* @name ndarray +* @memberof Routine.prototype +* @readonly +* @type {Function} +* @param {PositiveInteger} N - number of indexed elements +* @param {Complex64} alpha - scalar constant +* @param {Complex64Array} x - first input array +* @param {integer} strideX - `x` stride length +* @param {NonNegativeInteger} offsetX - starting `x` index +* @param {Complex64Array} y - second input array +* @param {integer} strideY - `y` stride length +* @param {NonNegativeInteger} offsetY - starting `y` index +* @returns {Complex64Array} second input array +* +* @example +* var Complex64Array = require( '@stdlib/array/complex64' ); +* var Complex64 = require( '@stdlib/complex/float32/ctor' ); +* +* // Create a new routine: +* var caxpy = new Routine(); +* +* // Initialize the module: +* caxpy.initializeSync(); +* +* // Define strided arrays: +* var x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] ); +* var y = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); +* +* // Create a complex number: +* var alpha = new Complex64( 2.0, 2.0 ); +* +* // Perform operation: +* caxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, 0 ); +* // y => [ -1.0, 7.0, -1.0, 15.0, -1.0, 23.0 ] +*/ +setReadOnly( Routine.prototype, 'ndarray', function caxpy( N, alpha, x, strideX, offsetX, y, strideY, offsetY ) { + var ptrs; + var p0; + var p1; + var p2; + + // Convert the input arrays to "pointers" in the module's memory: + ptrs = arrays2ptrs( this, [ + strided2object( N, x, strideX, offsetX ), + strided2object( N, y, strideY, offsetY ), + strided2object( 2, reimf( alpha ), 1, 0 ) + ]); + p0 = ptrs[ 0 ]; + p1 = ptrs[ 1 ]; + p2 = ptrs[ 2 ]; + + // Perform computation by calling the corresponding parent method: + Module.prototype.ndarray.call( this, N, p2.ptr, p0.ptr, p0.stride, p0.offset, p1.ptr, p1.stride, p1.offset ); // eslint-disable-line max-len + + // If the output array data had to be copied to module memory, copy the results to the provided output array... + if ( p1.copy ) { + readDataView( N, this.view, p1.stride*p1.BYTES_PER_ELEMENT, p1.ptr, y, strideY, offsetY, true ); // eslint-disable-line max-len + } + return y; +}); + + +// EXPORTS // + +module.exports = Routine; diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/manifest.json b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/manifest.json new file mode 100644 index 000000000000..4605f9f053f8 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/manifest.json @@ -0,0 +1,36 @@ +{ + "options": {}, + "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": [ + { + "src": [], + "include": [], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/blas/base/caxpy" + ] + } + ] +} diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/package.json b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/package.json new file mode 100644 index 000000000000..e1712bf2aa7c --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/package.json @@ -0,0 +1,87 @@ +{ + "name": "@stdlib/blas/base/wasm/caxpy", + "version": "0.0.0", + "description": "Scale a single-precision complex floating-point vector by a single-precision complex floating-point constant and add the result to a single-precision complex floating-point vector.", + "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/binary.js": "./lib/binary.browser.js" + }, + "directories": { + "benchmark": "./benchmark", + "doc": "./docs", + "example": "./examples", + "lib": "./lib", + "scripts": "./scripts", + "src": "./src", + "test": "./test" + }, + "types": "./docs/types", + "scripts": {}, + "homepage": "https://github.com/stdlib-js/stdlib", + "repository": { + "type": "git", + "url": "git://github.com/stdlib-js/stdlib.git" + }, + "bugs": { + "url": "https://github.com/stdlib-js/stdlib/issues" + }, + "dependencies": {}, + "devDependencies": {}, + "engines": { + "node": ">=0.10.0", + "npm": ">2.7.0" + }, + "os": [ + "aix", + "darwin", + "freebsd", + "linux", + "macos", + "openbsd", + "sunos", + "win32", + "windows" + ], + "keywords": [ + "stdlib", + "stdmath", + "mathematics", + "math", + "blas", + "level 1", + "caxpy", + "linear", + "algebra", + "subroutines", + "scale", + "add", + "alpha", + "cp", + "vector", + "typed", + "array", + "ndarray", + "complex", + "complex64", + "float", + "float32", + "single", + "float32array", + "webassembly", + "wasm" + ], + "__stdlib__": { + "wasm": true + } +} diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/scripts/build.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/scripts/build.js new file mode 100644 index 000000000000..0e05b3ad6a39 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/scripts/build.js @@ -0,0 +1,66 @@ +#!/usr/bin/env node + +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var resolve = require( 'path' ).resolve; +var readFile = require( '@stdlib/fs/read-file' ).sync; +var writeFile = require( '@stdlib/fs/write-file' ).sync; +var replace = require( '@stdlib/string/replace' ); +var currentYear = require( '@stdlib/time/current-year' ); + + +// VARIABLES // + +var wpath = resolve( __dirname, '..', 'src', 'main.wasm' ); +var tpath = resolve( __dirname, 'template.txt' ); +var opath = resolve( __dirname, '..', 'lib', 'binary.browser.js' ); + +var opts = { + 'encoding': 'utf8' +}; + +var PLACEHOLDER = '{{WASM_BASE64}}'; +var YEAR = '{{YEAR}}'; + + +// MAIN // + +/** +* Main execution sequence. +* +* @private +*/ +function main() { + var wasm; + var tmpl; + + wasm = readFile( wpath ); + tmpl = readFile( tpath, opts ); + + tmpl = replace( tmpl, YEAR, currentYear().toString() ); + tmpl = replace( tmpl, PLACEHOLDER, wasm.toString( 'base64' ) ); + + writeFile( opath, tmpl, opts ); +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/scripts/postbuild.wat.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/scripts/postbuild.wat.js new file mode 100644 index 000000000000..0d8edabe98d0 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/scripts/postbuild.wat.js @@ -0,0 +1,64 @@ +#!/usr/bin/env node + +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var resolve = require( 'path' ).resolve; +var licenseHeader = require( '@stdlib/_tools/licenses/header' ); +var insertHeader = require( '@stdlib/_tools/licenses/insert-header-file-list' ).sync; +var currentYear = require( '@stdlib/time/current-year' ); + + +// VARIABLES // + +var wpath = resolve( __dirname, '..', 'src', 'main.wat' ); + + +// MAIN // + +/** +* Main execution sequence. +* +* @private +* @throws {Error} unexpected error +*/ +function main() { + var headers; + var files; + var err; + + files = [ + wpath + ]; + headers = { + 'wat': licenseHeader( 'Apache-2.0', 'wat', { + 'year': currentYear(), + 'copyright': 'The Stdlib Authors' + }) + }; + err = insertHeader( files, headers ); + if ( err ) { + throw err; + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/scripts/template.txt b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/scripts/template.txt new file mode 100644 index 000000000000..f66cdb9735b1 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/scripts/template.txt @@ -0,0 +1,33 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) {{YEAR}} 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 base64ToUint8Array = require( '@stdlib/string/base/base64-to-uint8array' ); + + +// MAIN // + +var wasm = base64ToUint8Array( '{{WASM_BASE64}}' ); + + +// EXPORTS // + +module.exports = wasm; diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/src/Makefile b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/src/Makefile new file mode 100644 index 000000000000..fcc028115b77 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/src/Makefile @@ -0,0 +1,244 @@ +#/ +# @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. +#/ + +#/ +# To compile targets listed in this Makefile, use top-level project `make` +# commands rather than commands listed in this Makefile. The top-level project +# `make` commands will ensure that various environment variables and flags are +# appropriately set. +#/ + +# VARIABLES # + +ifndef VERBOSE + QUIET := @ +else + QUIET := +endif + +# Determine the OS ([1][1], [2][2]). +# +# [1]: https://en.wikipedia.org/wiki/Uname#Examples +# [2]: http://stackoverflow.com/a/27776822/2225624 +OS ?= $(shell uname) +ifneq (, $(findstring MINGW,$(OS))) + OS := WINNT +else +ifneq (, $(findstring MSYS,$(OS))) + OS := WINNT +else +ifneq (, $(findstring CYGWIN,$(OS))) + OS := WINNT +else +ifneq (, $(findstring Windows_NT,$(OS))) + OS := WINNT +endif +endif +endif +endif + +# Define the program used for compiling C source files to WebAssembly: +ifdef EMCC_COMPILER + EMCC := $(EMCC_COMPILER) +else + EMCC := emcc +endif + +# Define the program used for compiling WebAssembly files to the WebAssembly text format: +ifdef WASM2WAT + WASM_TO_WAT := $(WASM2WAT) +else + WASM_TO_WAT := wasm2wat +endif + +# Define the program used for compiling WebAssembly files to JavaScript: +ifdef WASM2JS + WASM_TO_JS := $(WASM2JS) +else + WASM_TO_JS := wasm2js +endif + +# Define the path to the Node.js executable: +ifdef NODE + NODEJS := $(NODE) +else + NODEJS := node +endif + +# Define the integer size: +ifdef CBLAS_INT + INT_TYPE := $(CBLAS_INT) +else + INT_TYPE := int32_t +endif + +# Define the command-line options when compiling C files: +CFLAGS ?= \ + -std=c99 \ + -O3 \ + -flto \ + -Wall \ + -pedantic \ + -D CBLAS_INT=$(INT_TYPE) + +# Define the command-line options when compiling C files to WebAssembly and asm.js: +EMCCFLAGS ?= $(CFLAGS) + +# Define shared `emcc` flags: +EMCC_SHARED_FLAGS := \ + -Oz \ + -fwasm-exceptions \ + -s SUPPORT_LONGJMP=1 \ + -s SIDE_MODULE=2 \ + -s EXPORTED_FUNCTIONS="$(shell cat exports.json | tr -d ' \t\n' | sed s/\"/\'/g)" + +# Define WebAssembly `emcc` flags: +EMCC_WASM_FLAGS := $(EMCC_SHARED_FLAGS) \ + -s WASM=1 \ + -s WASM_BIGINT=0 + +# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`): +INCLUDE ?= + +# List of source files: +SOURCE_FILES ?= + +# List of libraries (e.g., `-lopenblas -lpthread`): +LIBRARIES ?= + +# List of library paths (e.g., `-L /foo/bar -L /beep/boop`): +LIBPATH ?= + +# List of WebAssembly targets: +wasm_targets := main.wasm + +# List of WebAssembly WAT targets: +wat_targets := main.wat + +# List of WebAssembly JavaScript targets: +wasm_js_targets := main.wasm.js + +# List of other JavaScript targets: +browser_js_targets := ./../lib/binary.browser.js + + +# RULES # + +#/ +# Compiles source files. +# +# @param {string} [EMCC_COMPILER] - EMCC compiler (e.g., `emcc`) +# @param {string} [EMCCFLAGS] - EMCC compiler options +# @param {string} [WASM2WAT] - WebAssembly text format compiler (e.g., `wasm2wat`) +# @param {string} [WASM2JS] - WebAssembly JavaScript compiler (e.g., `wasm2js`) +# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`) +# @param {string} [SOURCE_FILES] - list of source files +# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`) +# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`) +# +# @example +# make +# +# @example +# make all +#/ +all: wasm + +.PHONY: all + +#/ +# Compiles source files to WebAssembly. +# +# @param {string} [EMCC_COMPILER] - EMCC compiler (e.g., `emcc`) +# @param {string} [EMCCFLAGS] - EMCC compiler options +# @param {string} [WASM2WAT] - WebAssembly text format compiler (e.g., `wasm2wat`) +# @param {string} [WASM2JS] - WebAssembly JavaScript compiler (e.g., `wasm2js`) +# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`) +# @param {string} [SOURCE_FILES] - list of source files +# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`) +# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`) +# +# @example +# make wasm +#/ +wasm: $(wasm_targets) $(wat_targets) $(browser_js_targets) + +.PHONY: wasm + +#/ +# Compiles C source files to WebAssembly binaries. +# +# @private +# @param {string} EMCC - EMCC compiler (e.g., `emcc`) +# @param {string} EMCCFLAGS - EMCC compiler options +# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`) +# @param {string} SOURCE_FILES - list of source files +# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`) +# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`) +#/ +$(wasm_targets): + $(QUIET) $(EMCC) $(EMCCFLAGS) $(EMCC_WASM_FLAGS) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) $(LIBRARIES) + +#/ +# Compiles WebAssembly binary files to the WebAssembly text format. +# +# @private +# @param {string} WASM2WAT - WAT compiler (e.g., `wasm2wat`) +#/ +$(wat_targets): %.wat: %.wasm + $(QUIET) $(WASM_TO_WAT) -o $@ $(wasm_targets) + $(QUIET) $(NODEJS) ./../scripts/postbuild.wat.js + +#/ +# Compiles WebAssembly binary files to JavaScript. +# +# @private +# @param {string} WASM2JS - JavaScript compiler (e.g., `wasm2js`) +#/ +$(wasm_js_targets): %.wasm.js: %.wasm + $(QUIET) $(WASM_TO_JS) -o $@ $(wasm_targets) + +#/ +# Generates an inline WebAssembly build for use in bundlers. +# +# @private +# @param {string} NODE - Node.js executable +#/ +$(browser_js_targets): $(wasm_targets) + $(QUIET) $(NODEJS) ./../scripts/build.js + +#/ +# Removes generated WebAssembly files. +# +# @example +# make clean-wasm +#/ +clean-wasm: + $(QUIET) -rm -f *.wasm *.wat *.wasm.js $(browser_js_targets) + +.PHONY: clean-wasm + +#/ +# Removes generated files. +# +# @example +# make clean +#/ +clean: clean-wasm + +.PHONY: clean diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/src/exports.json b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/src/exports.json new file mode 100644 index 000000000000..223a8af03f12 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/src/exports.json @@ -0,0 +1,4 @@ +[ + "_c_caxpy", + "_c_caxpy_ndarray" +] diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/src/main.wasm b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/src/main.wasm new file mode 100755 index 000000000000..1fdc94af0404 Binary files /dev/null and b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/src/main.wasm differ diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/src/main.wat b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/src/main.wat new file mode 100644 index 000000000000..83a2b51dd65d --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/src/main.wat @@ -0,0 +1,161 @@ +;; @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. + +(module + (type (;0;) (func)) + (type (;1;) (func (param i32 i32 i32 i32 i32 i32))) + (type (;2;) (func (param i32 i32 i32 i32 i32 i32 i32 i32))) + (import "env" "memory" (memory (;0;) 0)) + (import "env" "__stack_pointer" (global (;0;) (mut i32))) + (func (;0;) (type 0) + nop) + (func (;1;) (type 1) (param i32 i32 i32 i32 i32 i32) + (local i32) + global.get 0 + i32.const 16 + i32.sub + local.tee 6 + global.set 0 + local.get 6 + local.get 1 + i64.load align=4 + i64.store offset=8 + local.get 0 + local.get 6 + i32.const 8 + i32.add + local.get 2 + local.get 3 + i32.const 1 + local.get 0 + i32.sub + local.tee 0 + local.get 3 + i32.mul + i32.const 0 + local.get 3 + i32.const 0 + i32.le_s + select + local.get 4 + local.get 5 + local.get 0 + local.get 5 + i32.mul + i32.const 0 + local.get 5 + i32.const 0 + i32.le_s + select + call 2 + local.get 6 + i32.const 16 + i32.add + global.set 0) + (func (;2;) (type 2) (param i32 i32 i32 i32 i32 i32 i32 i32) + (local i64 i64 f32 f32 f32 f32) + block ;; label = @1 + local.get 0 + i32.const 0 + i32.le_s + br_if 0 (;@1;) + local.get 1 + f32.load + local.tee 10 + f32.abs + local.get 1 + f32.load offset=4 + local.tee 11 + f32.abs + f32.add + f32.const 0x0p+0 (;=0;) + f32.eq + br_if 0 (;@1;) + local.get 5 + local.get 7 + i32.const 3 + i32.shl + i32.add + local.set 1 + local.get 2 + local.get 4 + i32.const 3 + i32.shl + i32.add + local.set 7 + local.get 0 + i64.extend_i32_u + local.set 9 + local.get 6 + i32.const 3 + i32.shl + local.set 0 + local.get 3 + i32.const 3 + i32.shl + local.set 2 + loop ;; label = @2 + local.get 8 + local.get 9 + i64.eq + br_if 1 (;@1;) + local.get 1 + local.get 10 + local.get 7 + f32.load offset=4 + local.tee 12 + f32.mul + local.get 7 + f32.load + local.tee 13 + local.get 11 + f32.mul + f32.add + local.get 1 + f32.load offset=4 + f32.add + f32.store offset=4 + local.get 1 + local.get 10 + local.get 13 + f32.mul + local.get 11 + local.get 12 + f32.mul + f32.sub + local.get 1 + f32.load + f32.add + f32.store + local.get 8 + i64.const 1 + i64.add + local.set 8 + local.get 0 + local.get 1 + i32.add + local.set 1 + local.get 2 + local.get 7 + i32.add + local.set 7 + br 0 (;@2;) + end + unreachable + end) + (export "__wasm_call_ctors" (func 0)) + (export "c_caxpy" (func 1)) + (export "c_caxpy_ndarray" (func 2))) diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/test/test.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/test/test.js new file mode 100644 index 000000000000..f32a16a3a9bb --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/test/test.js @@ -0,0 +1,53 @@ +/** +* @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 caxpy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is an object', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof caxpy, 'object', 'returns expected value' ); + t.end(); +}); + +tape( 'attached to the main export is a `main` method', function test( t ) { + t.strictEqual( typeof caxpy.main, 'function', 'returns expected value' ); + t.end(); +}); + +tape( 'attached to the main export is an `ndarray` method', function test( t ) { + t.strictEqual( typeof caxpy.ndarray, 'function', 'returns expected value' ); + t.end(); +}); + +tape( 'attached to the main export is a `Module` constructor', function test( t ) { + t.strictEqual( typeof caxpy.Module, 'function', 'returns expected value' ); + t.end(); +}); + +tape( 'the main export is a `Module` instance', function test( t ) { + t.strictEqual( caxpy instanceof caxpy.Module, true, 'returns expected value' ); + t.end(); +}); diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/test/test.main.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/test/test.main.js new file mode 100644 index 000000000000..d5c8858806df --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/test/test.main.js @@ -0,0 +1,561 @@ +/** +* @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 Complex64Array = require( '@stdlib/array/complex64' ); +var Complex64 = require( '@stdlib/complex/float32/ctor' ); +var Float32Array = require( '@stdlib/array/float32' ); +var EPS = require( '@stdlib/constants/float32/eps' ); +var abs = require( '@stdlib/math/base/special/abs' ); +var caxpy = require( './../lib' ); + + +// FUNCTIONS // + +/** +* Tests for element-wise approximate equality. +* +* @private +* @param {Object} t - test object +* @param {Collection} actual - actual values +* @param {Collection} expected - expected values +* @param {number} rtol - relative tolerance +*/ +function isApprox( t, actual, expected, rtol ) { + var delta; + var tol; + var i; + + t.strictEqual( actual.length, expected.length, 'returns expected value' ); + for ( i = 0; i < expected.length; i++ ) { + if ( actual[ i ] === expected[ i ] ) { + t.strictEqual( actual[ i ], expected[ i ], 'returns expected value' ); + } else { + delta = abs( actual[ i ] - expected[ i ] ); + tol = rtol * EPS * abs( expected[ i ] ); + t.ok( delta <= tol, 'within tolerance. actual: '+actual[ i ]+'. expected: '+expected[ i ]+'. delta: '+delta+'. tol: '+tol+'.' ); + } + } +} + + +// TESTS // + +tape( 'main export is an object', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof caxpy, 'object', 'main export is an object' ); + t.end(); +}); + +tape( 'the `main` method has an arity of 6', function test( t ) { + t.strictEqual( caxpy.main.length, 6, 'arity of 6' ); + t.end(); +}); + +tape( 'the `main` method scales elements from `x` by `alpha` and adds the result to `y`', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex64Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, // 2 + -0.7, // 2 + -0.1, // 3 + -0.9, // 3 + 0.2, // 4 + -0.8, // 4 + -0.9, + -0.4, + 0.1, + 0.4, + -0.6, + 0.6 + ]); + y = new Complex64Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, // 4 + -0.5, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ]); + alpha = new Complex64( 0.4, -0.7 ); + + caxpy.main( 4, alpha, x, 1, y, 1 ); + + viewY = new Float32Array( y.buffer ); + expected = new Float32Array([ + 0.32, // 1 + -1.41, // 1 + -1.55, // 2 + 0.5, // 2 + 0.03, // 3 + -0.89, // 3 + -0.38, // 4 + -0.96, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ]); + isApprox( t, viewY, expected, 10.0 ); + t.end(); +}); + +tape( 'the `main` method supports an `x` stride', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex64Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, + -0.7, + -0.1, // 2 + -0.9, // 2 + 0.2, + -0.8, + -0.9, // 3 + -0.4, // 3 + 0.1, + 0.4, + -0.6, // 4 + 0.6 // 4 + ]); + y = new Complex64Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, // 4 + -0.5, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ]); + alpha = new Complex64( 0.4, -0.7 ); + + caxpy.main( 4, alpha, x, 2, y, 1 ); + + viewY = new Float32Array( y.buffer ); + expected = new Float32Array([ + 0.32, // 1 + -1.41, // 1 + -1.57, // 2 + 0.21, // 2 + 0.06, // 3 + -0.13, // 3 + 0.28, // 4 + 0.16, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ]); + isApprox( t, viewY, expected, 10.0 ); + t.end(); +}); + +tape( 'the `main` method supports a `y` stride', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex64Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, // 2 + -0.7, // 2 + -0.1, // 3 + -0.9, // 3 + 0.2, // 4 + -0.8, // 4 + -0.9, + -0.4, + 0.1, + 0.4, + -0.6, + 0.6 + ]); + y = new Complex64Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, + 0.5, + 0.7, // 2 + -0.6, // 2 + 0.1, + -0.5, + -0.1, // 3 + -0.2, // 3 + -0.5, + -0.3, + 0.8, // 4 + -0.7 // 4 + ]); + alpha = new Complex64( 0.4, -0.7 ); + + caxpy.main( 4, alpha, x, 1, y, 2 ); + + viewY = new Float32Array( y.buffer ); + expected = new Float32Array([ + 0.32, // 1 + -1.41, // 1 + -0.9, + 0.5, + 0.05, // 2 + -0.6, // 2 + 0.1, + -0.5, + -0.77, // 3 + -0.49, // 3 + -0.5, + -0.3, + 0.32, // 4 + -1.16 // 4 + ]); + isApprox( t, viewY, expected, 10.0 ); + t.end(); +}); + +tape( 'the `main` method returns a reference to the output array', function test( t ) { + var alpha; + var out; + var x; + var y; + + x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + y = new Complex64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + alpha = new Complex64( 2.0, 2.0 ); + + out = caxpy.main( x.length, alpha, x, 1, y, 1 ); + + t.strictEqual( out, y, 'same reference' ); + t.end(); +}); + +tape( 'if provided `alpha` parameter equal to `0`, the `main` method returns the second input array unchanged', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + y = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + alpha = new Complex64( 0.0, 0.0 ); + + viewY = new Float32Array( y.buffer ); + expected = new Float32Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + + caxpy.main( -1, alpha, x, 1, y, 1 ); + t.deepEqual( viewY, expected, 'returns expected value' ); + + caxpy.main( 0, alpha, x, 1, y, 1 ); + t.deepEqual( viewY, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter less than or equal to `0`, the `main` method returns the second input array unchanged', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + y = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + alpha = new Complex64( 2.0, 2.0 ); + + viewY = new Float32Array( y.buffer ); + expected = new Float32Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + + caxpy.main( -1, alpha, x, 1, y, 1 ); + t.deepEqual( viewY, expected, 'returns expected value' ); + + caxpy.main( 0, alpha, x, 1, y, 1 ); + t.deepEqual( viewY, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the `main` method supports negative `x` strides', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex64Array([ + 0.7, // 4 + -0.8, // 4 + -0.4, + -0.7, + -0.1, // 3 + -0.9, // 3 + 0.2, + -0.8, + -0.9, // 2 + -0.4, // 2 + 0.1, + 0.4, + -0.6, // 1 + 0.6 // 1 + ]); + y = new Complex64Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, // 4 + -0.5, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ]); + alpha = new Complex64( 0.4, -0.7 ); + + caxpy.main( 4, alpha, x, -2, y, 1 ); + + viewY = new Float32Array( y.buffer ); + expected = new Float32Array([ + 0.78, // 1 + 0.06, // 1 + -1.54, // 2 + 0.97, // 2 + 0.03, // 3 + -0.89, // 3 + -0.18, // 4 + -1.31, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ]); + isApprox( t, viewY, expected, 10.0 ); + t.end(); +}); + +tape( 'the `main` method supports negative `y` strides', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex64Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, + -0.7, + -0.1, // 2 + -0.9, // 2 + 0.2, + -0.8, + -0.9, // 3 + -0.4, // 3 + 0.1, + 0.4, + -0.6, // 4 + 0.6 // 4 + ]); + y = new Complex64Array([ + 0.6, // 4 + -0.6, // 4 + -0.9, + 0.5, + 0.7, // 3 + -0.6, // 3 + 0.1, + -0.5, + -0.1, // 2 + -0.2, // 2 + -0.5, + -0.3, + 0.8, // 1 + -0.7 // 1 + ]); + alpha = new Complex64( 0.4, -0.7 ); + + caxpy.main( 4, alpha, x, 2, y, -2 ); + + viewY = new Float32Array( y.buffer ); + expected = new Float32Array([ + 0.78, // 4 + 0.06, // 4 + -0.9, + 0.5, + 0.06, // 3 + -0.13, // 3 + 0.1, + -0.5, + -0.77, // 2 + -0.49, // 2 + -0.5, + -0.3, + 0.52, // 1 + -1.51 // 1 + ]); + isApprox( t, viewY, expected, 10.0 ); + t.end(); +}); + +tape( 'the `main` method supports complex access patterns', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex64Array([ + 0.7, // 4 + -0.8, // 4 + -0.4, // 3 + -0.7, // 3 + -0.1, // 2 + -0.9, // 2 + 0.2, // 1 + -0.8, // 1 + -0.9, + -0.4, + 0.1, + 0.4, + -0.6, + 0.6 + ]); + y = new Complex64Array([ + 0.6, // 4 + -0.6, // 4 + -0.9, + 0.5, + 0.7, // 3 + -0.6, // 3 + 0.1, + -0.5, + -0.1, // 2 + -0.2, // 2 + -0.5, + -0.3, + 0.8, // 1 + -0.7 // 1 + ]); + alpha = new Complex64( 0.4, -0.7 ); + + caxpy.main( 4, alpha, x, -1, y, -2 ); + + viewY = new Float32Array( y.buffer ); + expected = new Float32Array([ + 0.32, // 4 + -1.41, // 4 + -0.9, + 0.5, + 0.05, // 3 + -0.6, // 3 + 0.1, + -0.5, + -0.77, // 2 + -0.49, // 2 + -0.5, + -0.3, + 0.32, // 1 + -1.16 // 1 + ]); + isApprox( t, viewY, expected, 10.0 ); + t.end(); +}); + +tape( 'the `main` method supports view offsets', function test( t ) { + var expected; + var viewY; + var alpha; + var cx0; + var cy0; + var cx1; + var cy1; + + // Initial arrays... + cx0 = new Complex64Array([ + 1.0, + 2.0, + 3.0, // 1 + 4.0, // 1 + 5.0, + 6.0 + ]); + cy0 = new Complex64Array([ + 1.0, + 1.0, + 1.0, + 1.0, + 1.0, // 1 + 1.0 // 1 + ]); + + // Define a scalar constant: + alpha = new Complex64( 2.0, 2.0 ); + + // Create offset views... + cx1 = new Complex64Array( cx0.buffer, cx0.BYTES_PER_ELEMENT*1 ); // begin at the 2nd element + cy1 = new Complex64Array( cy0.buffer, cy0.BYTES_PER_ELEMENT*2 ); // begin at the 3rd element + + caxpy.main( 1, alpha, cx1, 1, cy1, 1 ); + + viewY = new Float32Array( cy0.buffer ); + expected = new Float32Array( [ 1.0, 1.0, 1.0, 1.0, -1.0, 15.0 ] ); + + isApprox( t, viewY, expected, 10.0 ); + t.end(); +}); diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/test/test.module.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/test/test.module.js new file mode 100644 index 000000000000..b03f8cd3d8d0 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/test/test.module.js @@ -0,0 +1,154 @@ +/** +* @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 Memory = require( '@stdlib/wasm/memory' ); +var ModuleWrapper = require( '@stdlib/wasm/module-wrapper' ); +var Module = require( './../lib' ).Module; + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof Module, 'function', 'returns expected value' ); + t.end(); +}); + +tape( 'the function is a constructor', function test( t ) { + var mem; + var mod; + + mem = new Memory({ + 'initial': 0 + }); + mod = new Module( mem ); + t.strictEqual( mod instanceof Module, true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function is a constructor which does not require `new`', function test( t ) { + var mem; + var mod; + + mem = new Memory({ + 'initial': 0 + }); + mod = Module( mem ); // eslint-disable-line new-cap + t.strictEqual( mod instanceof Module, true, 'returns expected value' ); + t.end(); +}); + +tape( 'the module constructor throws an error if provided a first argument which is not a WebAssembly memory instance (new)', function test( t ) { + var values; + var i; + + values = [ + '5', + 5, + NaN, + true, + false, + null, + void 0, + [], + {}, + function noop() {} + ]; + 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() { + return new Module( value ); + }; + } +}); + +tape( 'the module constructor throws an error if provided a first argument which is not a WebAssembly memory instance (no new)', function test( t ) { + var values; + var i; + + values = [ + '5', + 5, + NaN, + true, + false, + null, + void 0, + [], + {}, + function noop() {} + ]; + 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() { + return Module( value ); // eslint-disable-line new-cap + }; + } +}); + +tape( 'the module instance returned by the module constructor inherits from a module wrapper', function test( t ) { + var mem; + var mod; + + mem = new Memory({ + 'initial': 0 + }); + mod = new Module( mem ); + + t.strictEqual( mod instanceof ModuleWrapper, true, 'returns expected value' ); + t.end(); +}); + +tape( 'attached to a module instance is a `main` method', function test( t ) { + var mem; + var mod; + + mem = new Memory({ + 'initial': 0 + }); + mod = new Module( mem ); + + t.strictEqual( typeof mod.main, 'function', 'returns expected value' ); + t.end(); +}); + +tape( 'attached to a module instance is an `ndarray` method', function test( t ) { + var mem; + var mod; + + mem = new Memory({ + 'initial': 0 + }); + mod = new Module( mem ); + + t.strictEqual( typeof mod.ndarray, 'function', 'returns expected value' ); + t.end(); +}); diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/test/test.module.main.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/test/test.module.main.js new file mode 100644 index 000000000000..6a6bec67c86f --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/test/test.module.main.js @@ -0,0 +1,256 @@ +/** +* @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 n/no-sync */ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var Memory = require( '@stdlib/wasm/memory' ); +var Complex64Array = require( '@stdlib/array/complex64' ); +var Float32Array = require( '@stdlib/array/float32' ); +var EPS = require( '@stdlib/constants/float32/eps' ); +var abs = require( '@stdlib/math/base/special/abs' ); +var Module = require( './../lib' ).Module; + + +// VARIABLES // + +// Pointers (i.e., byte offsets) for storing two vectors and a complex number (using generous gaps to avoid overlap): +var XPTR = 0; +var YPTR = 128; +var APTR = 256; + + +// FUNCTIONS // + +/** +* Tests for element-wise approximate equality. +* +* @private +* @param {Object} t - test object +* @param {Collection} actual - actual values +* @param {Collection} expected - expected values +* @param {number} rtol - relative tolerance +*/ +function isApprox( t, actual, expected, rtol ) { + var delta; + var tol; + var i; + + t.strictEqual( actual.length, expected.length, 'returns expected value' ); + for ( i = 0; i < expected.length; i++ ) { + if ( actual[ i ] === expected[ i ] ) { + t.strictEqual( actual[ i ], expected[ i ], 'returns expected value' ); + } else { + delta = abs( actual[ i ] - expected[ i ] ); + tol = rtol * EPS * abs( expected[ i ] ); + t.ok( delta <= tol, 'within tolerance. actual: '+actual[ i ]+'. expected: '+expected[ i ]+'. delta: '+delta+'. tol: '+tol+'.' ); + } + } +} + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof Module, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'a module instance has a `main` method which has an arity of 6', function test( t ) { + var mem; + var mod; + + mem = new Memory({ + 'initial': 0 + }); + mod = new Module( mem ); + t.strictEqual( mod.main.length, 6, 'returns expected value' ); + t.end(); +}); + +tape( 'a module instance has a `main` method which scales elements from `x` by `alpha` and adds the result to `y`', function test( t ) { + var actualY; + var viewY; + var mem; + var mod; + var ye; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + mod.write( XPTR, new Complex64Array( [ 0.7, -0.8, -0.4, -0.7, -0.1, -0.9, 0.2, -0.8 ] ) ); + mod.write( YPTR, new Complex64Array( [ 0.6, -0.6, -0.9, 0.5, 0.7, -0.6, 0.1, -0.5 ] ) ); + mod.write( APTR, new Float32Array( [ 0.4, -0.7 ] ) ); + + ye = new Float32Array( [ 0.32, -1.41, -1.55, 0.5, 0.03, -0.89, -0.38, -0.96 ] ); + + mod.main( 4, APTR, XPTR, 1, YPTR, 1 ); + + actualY = new Complex64Array( 4 ); + mod.read( YPTR, actualY ); + viewY = new Float32Array( actualY.buffer ); + isApprox( t, viewY, ye, 10.0 ); + + t.end(); +}); + +tape( 'a module instance has a `main` method which supports an `x` stride', function test( t ) { + var actualY; + var viewY; + var mem; + var mod; + var ye; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + mod.write( XPTR, new Complex64Array( [ 0.7, -0.8, -0.4, -0.7, -0.1, -0.9, 0.2, -0.8, -0.9, -0.4, 0.1, 0.4, -0.6, 0.6 ] ) ); + mod.write( YPTR, new Complex64Array( [ 0.6, -0.6, -0.9, 0.5, 0.7, -0.6, 0.1, -0.5, -0.1, -0.2, -0.5, -0.3, 0.8, -0.7 ] ) ); + mod.write( APTR, new Float32Array( [ 0.4, -0.7 ] ) ); + + ye = new Float32Array([ + 0.32, -1.41, -1.57, 0.21, 0.06, -0.13, 0.28, 0.16, -0.1, -0.2, -0.5, -0.3, 0.8, -0.7 + ]); + + mod.main( 4, APTR, XPTR, 2, YPTR, 1 ); + + actualY = new Complex64Array( 7 ); + mod.read( YPTR, actualY ); + viewY = new Float32Array( actualY.buffer ); + isApprox( t, viewY, ye, 10.0 ); + + t.end(); +}); + +tape( 'a module instance has a `main` method which supports a `y` stride', function test( t ) { + var actualY; + var viewY; + var mem; + var mod; + var ye; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + mod.write( XPTR, new Complex64Array( [ 0.7, -0.8, -0.4, -0.7, -0.1, -0.9, 0.2, -0.8, -0.9, -0.4, 0.1, 0.4, -0.6, 0.6 ] ) ); + mod.write( YPTR, new Complex64Array( [ 0.6, -0.6, -0.9, 0.5, 0.7, -0.6, 0.1, -0.5, -0.1, -0.2, -0.5, -0.3, 0.8, -0.7 ] ) ); + mod.write( APTR, new Float32Array( [ 0.4, -0.7 ] ) ); + + ye = new Float32Array([ + 0.32, -1.41, -0.9, 0.5, 0.05, -0.6, 0.1, -0.5, -0.77, -0.49, -0.5, -0.3, 0.32, -1.16 + ]); + + mod.main( 4, APTR, XPTR, 1, YPTR, 2 ); + + actualY = new Complex64Array( 7 ); + mod.read( YPTR, actualY ); + viewY = new Float32Array( actualY.buffer ); + isApprox( t, viewY, ye, 10.0 ); + + t.end(); +}); + +tape( 'a module instance has a `main` method which supports a negative `x` stride', function test( t ) { + var actualY; + var viewY; + var mem; + var mod; + var ye; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + mod.write( XPTR, new Complex64Array( [ 0.7, -0.8, -0.4, -0.7, -0.1, -0.9, 0.2, -0.8, -0.9, -0.4, 0.1, 0.4, -0.6, 0.6 ] ) ); + mod.write( YPTR, new Complex64Array( [ 0.6, -0.6, -0.9, 0.5, 0.7, -0.6, 0.1, -0.5, -0.1, -0.2, -0.5, -0.3, 0.8, -0.7 ] ) ); + mod.write( APTR, new Float32Array( [ 0.4, -0.7 ] ) ); + + ye = new Float32Array([ + 0.78, 0.06, -1.54, 0.97, 0.03, -0.89, -0.18, -1.31, -0.1, -0.2, -0.5, -0.3, 0.8, -0.7 + ]); + + mod.main( 4, APTR, XPTR, -2, YPTR, 1 ); + + actualY = new Complex64Array( 7 ); + mod.read( YPTR, actualY ); + viewY = new Float32Array( actualY.buffer ); + isApprox( t, viewY, ye, 10.0 ); + + t.end(); +}); + +tape( 'a module instance has a `main` method which returns a reference to the output array', function test( t ) { + var mem; + var mod; + var out; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + mod.write( XPTR, new Complex64Array( [ 0.3, 0.1, 0.5, 0.0, 0.0, 0.5 ] ) ); + mod.write( YPTR, new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ) ); + mod.write( APTR, new Float32Array( [ 0.4, -0.7 ] ) ); + + out = mod.main( 3, APTR, XPTR, 1, YPTR, 1 ); + t.strictEqual( out, YPTR, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter less than or equal to `0`, a module instance has a `main` method which leaves the output array unchanged', function test( t ) { + var mem; + var mod; + var out; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + mod.write( XPTR, new Complex64Array( [ 0.3, 0.1, 0.5, 0.0, 0.0, 0.5 ] ) ); + mod.write( YPTR, new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ) ); + mod.write( APTR, new Float32Array( [ 0.4, -0.7 ] ) ); + + out = mod.main( 0, APTR, XPTR, 1, YPTR, 1 ); + t.strictEqual( out, YPTR, 'returns expected value' ); + + out = mod.main( -1, APTR, XPTR, 1, YPTR, 1 ); + t.strictEqual( out, YPTR, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/test/test.module.ndarray.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/test/test.module.ndarray.js new file mode 100644 index 000000000000..0c630b3af6a0 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/test/test.module.ndarray.js @@ -0,0 +1,256 @@ +/** +* @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 n/no-sync */ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var Memory = require( '@stdlib/wasm/memory' ); +var Complex64Array = require( '@stdlib/array/complex64' ); +var Float32Array = require( '@stdlib/array/float32' ); +var EPS = require( '@stdlib/constants/float32/eps' ); +var abs = require( '@stdlib/math/base/special/abs' ); +var Module = require( './../lib' ).Module; + + +// VARIABLES // + +// Pointers (i.e., byte offsets) for storing two vectors and a complex number (using generous gaps to avoid overlap): +var XPTR = 0; +var YPTR = 128; +var APTR = 256; + + +// FUNCTIONS // + +/** +* Tests for element-wise approximate equality. +* +* @private +* @param {Object} t - test object +* @param {Collection} actual - actual values +* @param {Collection} expected - expected values +* @param {number} rtol - relative tolerance +*/ +function isApprox( t, actual, expected, rtol ) { + var delta; + var tol; + var i; + + t.strictEqual( actual.length, expected.length, 'returns expected value' ); + for ( i = 0; i < expected.length; i++ ) { + if ( actual[ i ] === expected[ i ] ) { + t.strictEqual( actual[ i ], expected[ i ], 'returns expected value' ); + } else { + delta = abs( actual[ i ] - expected[ i ] ); + tol = rtol * EPS * abs( expected[ i ] ); + t.ok( delta <= tol, 'within tolerance. actual: '+actual[ i ]+'. expected: '+expected[ i ]+'. delta: '+delta+'. tol: '+tol+'.' ); + } + } +} + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof Module, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'a module instance has an `ndarray` method which has an arity of 8', function test( t ) { + var mem; + var mod; + + mem = new Memory({ + 'initial': 0 + }); + mod = new Module( mem ); + t.strictEqual( mod.ndarray.length, 8, 'returns expected value' ); + t.end(); +}); + +tape( 'a module instance has an `ndarray` method which scales elements from `x` by `alpha` and adds the result to `y`', function test( t ) { + var actualY; + var viewY; + var mem; + var mod; + var ye; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + mod.write( XPTR, new Complex64Array( [ 0.7, -0.8, -0.4, -0.7, -0.1, -0.9, 0.2, -0.8 ] ) ); + mod.write( YPTR, new Complex64Array( [ 0.6, -0.6, -0.9, 0.5, 0.7, -0.6, 0.1, -0.5 ] ) ); + mod.write( APTR, new Float32Array( [ 0.4, -0.7 ] ) ); + + ye = new Float32Array( [ 0.32, -1.41, -1.55, 0.5, 0.03, -0.89, -0.38, -0.96 ] ); + + mod.ndarray( 4, APTR, XPTR, 1, 0, YPTR, 1, 0 ); + + actualY = new Complex64Array( 4 ); + mod.read( YPTR, actualY ); + viewY = new Float32Array( actualY.buffer ); + isApprox( t, viewY, ye, 10.0 ); + + t.end(); +}); + +tape( 'a module instance has an `ndarray` method which supports an `x` offset', function test( t ) { + var actualY; + var viewY; + var mem; + var mod; + var ye; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + mod.write( XPTR, new Complex64Array( [ 0.7, -0.8, -0.4, -0.7, -0.1, -0.9, 0.2, -0.8, -0.9, -0.4, 0.1, 0.4, -0.6, 0.6 ] ) ); + mod.write( YPTR, new Complex64Array( [ 0.6, -0.6, -0.9, 0.5, 0.7, -0.6, 0.1, -0.5, -0.1, -0.2, -0.5, -0.3, 0.8, -0.7 ] ) ); + mod.write( APTR, new Float32Array( [ 0.4, -0.7 ] ) ); + + ye = new Float32Array([ + -0.05, -0.6, -1.38, 0.04, 1.02, -0.51, 0.1, -0.5, -0.1, -0.2, -0.5, -0.3, 0.8, -0.7 + ]); + + mod.ndarray( 3, APTR, XPTR, 2, 1, YPTR, 1, 0 ); + + actualY = new Complex64Array( 7 ); + mod.read( YPTR, actualY ); + viewY = new Float32Array( actualY.buffer ); + isApprox( t, viewY, ye, 10.0 ); + + t.end(); +}); + +tape( 'a module instance has an `ndarray` method which supports a `y` offset', function test( t ) { + var actualY; + var viewY; + var mem; + var mod; + var ye; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + mod.write( XPTR, new Complex64Array( [ 0.7, -0.8, -0.4, -0.7, -0.1, -0.9, 0.2, -0.8, -0.9, -0.4, 0.1, 0.4, -0.6, 0.6 ] ) ); + mod.write( YPTR, new Complex64Array( [ 0.6, -0.6, -0.9, 0.5, 0.7, -0.6, 0.1, -0.5, -0.1, -0.2, -0.5, -0.3, 0.8, -0.7 ] ) ); + mod.write( APTR, new Float32Array( [ 0.4, -0.7 ] ) ); + + ye = new Float32Array([ + 0.6, -0.6, -1.18, -0.31, 0.7, -0.6, -0.55, -0.5, -0.1, -0.2, -1.17, -0.59, 0.8, -0.7 + ]); + + mod.ndarray( 3, APTR, XPTR, 1, 0, YPTR, 2, 1 ); + + actualY = new Complex64Array( 7 ); + mod.read( YPTR, actualY ); + viewY = new Float32Array( actualY.buffer ); + isApprox( t, viewY, ye, 10.0 ); + + t.end(); +}); + +tape( 'a module instance has an `ndarray` method which supports a negative `x` stride', function test( t ) { + var actualY; + var viewY; + var mem; + var mod; + var ye; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + mod.write( XPTR, new Complex64Array( [ 0.7, -0.8, -0.4, -0.7, -0.1, -0.9, 0.2, -0.8, -0.9, -0.4, 0.1, 0.4, -0.6, 0.6 ] ) ); + mod.write( YPTR, new Complex64Array( [ 0.6, -0.6, -0.9, 0.5, 0.7, -0.6, 0.1, -0.5, -0.1, -0.2, -0.5, -0.3, 0.8, -0.7 ] ) ); + mod.write( APTR, new Float32Array( [ 0.4, -0.7 ] ) ); + + ye = new Float32Array([ + 0.78, 0.06, -1.54, 0.97, 0.03, -0.89, -0.18, -1.31, -0.1, -0.2, -0.5, -0.3, 0.8, -0.7 + ]); + + mod.ndarray( 4, APTR, XPTR, -2, 6, YPTR, 1, 0 ); + + actualY = new Complex64Array( 7 ); + mod.read( YPTR, actualY ); + viewY = new Float32Array( actualY.buffer ); + isApprox( t, viewY, ye, 10.0 ); + + t.end(); +}); + +tape( 'a module instance has an `ndarray` method which returns a reference to the output array', function test( t ) { + var mem; + var mod; + var out; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + mod.write( XPTR, new Complex64Array( [ 0.3, 0.1, 0.5, 0.0, 0.0, 0.5 ] ) ); + mod.write( YPTR, new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ) ); + mod.write( APTR, new Float32Array( [ 0.4, -0.7 ] ) ); + + out = mod.ndarray( 3, APTR, XPTR, 1, 0, YPTR, 1, 0 ); + t.strictEqual( out, YPTR, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter less than or equal to `0`, a module instance has an `ndarray` method which leaves the output array unchanged', function test( t ) { + var mem; + var mod; + var out; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + mod.write( XPTR, new Complex64Array( [ 0.3, 0.1, 0.5, 0.0, 0.0, 0.5 ] ) ); + mod.write( YPTR, new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ) ); + mod.write( APTR, new Float32Array( [ 0.4, -0.7 ] ) ); + + out = mod.ndarray( 0, APTR, XPTR, 1, 0, YPTR, 1, 0 ); + t.strictEqual( out, YPTR, 'returns expected value' ); + + out = mod.ndarray( -1, APTR, XPTR, 1, 0, YPTR, 1, 0 ); + t.strictEqual( out, YPTR, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/test/test.ndarray.js new file mode 100644 index 000000000000..5c0afe1fe1b8 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/test/test.ndarray.js @@ -0,0 +1,646 @@ +/** +* @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 Complex64Array = require( '@stdlib/array/complex64' ); +var Complex64 = require( '@stdlib/complex/float32/ctor' ); +var Float32Array = require( '@stdlib/array/float32' ); +var EPS = require( '@stdlib/constants/float32/eps' ); +var abs = require( '@stdlib/math/base/special/abs' ); +var caxpy = require( './../lib' ); + + +// FUNCTIONS // + +/** +* Tests for element-wise approximate equality. +* +* @private +* @param {Object} t - test object +* @param {Collection} actual - actual values +* @param {Collection} expected - expected values +* @param {number} rtol - relative tolerance +*/ +function isApprox( t, actual, expected, rtol ) { + var delta; + var tol; + var i; + + t.strictEqual( actual.length, expected.length, 'returns expected value' ); + for ( i = 0; i < expected.length; i++ ) { + if ( actual[ i ] === expected[ i ] ) { + t.strictEqual( actual[ i ], expected[ i ], 'returns expected value' ); + } else { + delta = abs( actual[ i ] - expected[ i ] ); + tol = rtol * EPS * abs( expected[ i ] ); + t.ok( delta <= tol, 'within tolerance. actual: '+actual[ i ]+'. expected: '+expected[ i ]+'. delta: '+delta+'. tol: '+tol+'.' ); + } + } +} + + +// TESTS // + +tape( 'main export is an object', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof caxpy, 'object', 'main export is an object' ); + t.end(); +}); + +tape( 'the `ndarray` method has an arity of 8', function test( t ) { + t.strictEqual( caxpy.ndarray.length, 8, 'arity of 8' ); + t.end(); +}); + +tape( 'the `ndarray` method scales elements from `x` by `alpha` and adds the result to `y`', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex64Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, // 2 + -0.7, // 2 + -0.1, // 3 + -0.9, // 3 + 0.2, // 4 + -0.8, // 4 + -0.9, + -0.4, + 0.1, + 0.4, + -0.6, + 0.6 + ]); + y = new Complex64Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, // 4 + -0.5, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ]); + alpha = new Complex64( 0.4, -0.7 ); + + caxpy.ndarray( 4, alpha, x, 1, 0, y, 1, 0 ); + + viewY = new Float32Array( y.buffer ); + expected = new Float32Array([ + 0.32, // 1 + -1.41, // 1 + -1.55, // 2 + 0.5, // 2 + 0.03, // 3 + -0.89, // 3 + -0.38, // 4 + -0.96, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ]); + isApprox( t, viewY, expected, 10.0 ); + t.end(); +}); + +tape( 'the `ndarray` method supports an `x` stride', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex64Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, + -0.7, + -0.1, // 2 + -0.9, // 2 + 0.2, + -0.8, + -0.9, // 3 + -0.4, // 3 + 0.1, + 0.4, + -0.6, // 4 + 0.6 // 4 + ]); + y = new Complex64Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, // 4 + -0.5, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ]); + alpha = new Complex64( 0.4, -0.7 ); + + caxpy.ndarray( 4, alpha, x, 2, 0, y, 1, 0 ); + + viewY = new Float32Array( y.buffer ); + expected = new Float32Array([ + 0.32, // 1 + -1.41, // 1 + -1.57, // 2 + 0.21, // 2 + 0.06, // 3 + -0.13, // 3 + 0.28, // 4 + 0.16, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ]); + isApprox( t, viewY, expected, 10.0 ); + t.end(); +}); + +tape( 'the `ndarray` method supports an `x` offset', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex64Array([ + 0.7, + -0.8, + -0.4, // 1 + -0.7, // 1 + -0.1, + -0.9, + 0.2, // 2 + -0.8, // 2 + -0.9, + -0.4, + 0.1, // 3 + 0.4, // 3 + -0.6, + 0.6 + ]); + y = new Complex64Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, + -0.5, + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ]); + alpha = new Complex64( 0.4, -0.7 ); + + caxpy.ndarray( 3, alpha, x, 2, 1, y, 1, 0 ); + + viewY = new Float32Array( y.buffer ); + expected = new Float32Array([ + -0.05, // 1 + -0.6, // 1 + -1.38, // 2 + 0.04, // 2 + 1.02, // 3 + -0.51, // 3 + 0.1, + -0.5, + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ]); + isApprox( t, viewY, expected, 10.0 ); + t.end(); +}); + +tape( 'the `ndarray` method supports a `y` stride', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex64Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, // 2 + -0.7, // 2 + -0.1, // 3 + -0.9, // 3 + 0.2, // 4 + -0.8, // 4 + -0.9, + -0.4, + 0.1, + 0.4, + -0.6, + 0.6 + ]); + y = new Complex64Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, + 0.5, + 0.7, // 2 + -0.6, // 2 + 0.1, + -0.5, + -0.1, // 3 + -0.2, // 3 + -0.5, + -0.3, + 0.8, // 4 + -0.7 // 4 + ]); + alpha = new Complex64( 0.4, -0.7 ); + + caxpy.ndarray( 4, alpha, x, 1, 0, y, 2, 0 ); + + viewY = new Float32Array( y.buffer ); + expected = new Float32Array([ + 0.32, // 1 + -1.41, // 1 + -0.9, + 0.5, + 0.05, // 2 + -0.6, // 2 + 0.1, + -0.5, + -0.77, // 3 + -0.49, // 3 + -0.5, + -0.3, + 0.32, // 4 + -1.16 // 4 + ]); + isApprox( t, viewY, expected, 10.0 ); + t.end(); +}); + +tape( 'the `ndarray` method supports a `y` offset', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex64Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, // 2 + -0.7, // 2 + -0.1, // 3 + -0.9, // 3 + 0.2, + -0.8, + -0.9, + -0.4, + 0.1, + 0.4, + -0.6, + 0.6 + ]); + y = new Complex64Array([ + 0.6, + -0.6, + -0.9, // 1 + 0.5, // 1 + 0.7, + -0.6, + 0.1, // 2 + -0.5, // 2 + -0.1, + -0.2, + -0.5, // 3 + -0.3, // 3 + 0.8, + -0.7 + ]); + alpha = new Complex64( 0.4, -0.7 ); + + caxpy.ndarray( 3, alpha, x, 1, 0, y, 2, 1 ); + + viewY = new Float32Array( y.buffer ); + expected = new Float32Array([ + 0.6, + -0.6, + -1.18, // 1 + -0.31, // 1 + 0.7, + -0.6, + -0.55, // 2 + -0.5, // 2 + -0.1, + -0.2, + -1.17, // 3 + -0.59, // 3 + 0.8, + -0.7 + ]); + isApprox( t, viewY, expected, 10.0 ); + t.end(); +}); + +tape( 'the `ndarray` method returns a reference to the output array', function test( t ) { + var alpha; + var out; + var x; + var y; + + x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + y = new Complex64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); + alpha = new Complex64( 2.0, 2.0 ); + + out = caxpy.ndarray( x.length, alpha, x, 1, 0, y, 1, 0 ); + + t.strictEqual( out, y, 'same reference' ); + t.end(); +}); + +tape( 'if provided `alpha` parameter equal to `0`, the `ndarray` method returns the second input array unchanged', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + y = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + alpha = new Complex64( 0.0, 0.0 ); + + viewY = new Float32Array( y.buffer ); + expected = new Float32Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + + caxpy.ndarray( -1, alpha, x, 1, 0, y, 1, 0 ); + t.deepEqual( viewY, expected, 'returns expected value' ); + + caxpy.ndarray( 0, alpha, x, 1, 0, y, 1, 0 ); + t.deepEqual( viewY, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter less than or equal to `0`, the `ndarray` method returns the second input array unchanged', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] ); + y = new Complex64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + alpha = new Complex64( 2.0, 2.0 ); + + viewY = new Float32Array( y.buffer ); + expected = new Float32Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] ); + + caxpy.ndarray( -1, alpha, x, 1, 0, y, 1, 0 ); + t.deepEqual( viewY, expected, 'returns expected value' ); + + caxpy.ndarray( 0, alpha, x, 1, 0, y, 1, 0 ); + t.deepEqual( viewY, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the `ndarray` method supports a negative `x` stride', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex64Array([ + 0.7, // 4 + -0.8, // 4 + -0.4, + -0.7, + -0.1, // 3 + -0.9, // 3 + 0.2, + -0.8, + -0.9, // 2 + -0.4, // 2 + 0.1, + 0.4, + -0.6, // 1 + 0.6 // 1 + ]); + y = new Complex64Array([ + 0.6, // 1 + -0.6, // 1 + -0.9, // 2 + 0.5, // 2 + 0.7, // 3 + -0.6, // 3 + 0.1, // 4 + -0.5, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ]); + alpha = new Complex64( 0.4, -0.7 ); + + caxpy.ndarray( 4, alpha, x, -2, 6, y, 1, 0 ); + + viewY = new Float32Array( y.buffer ); + expected = new Float32Array([ + 0.78, // 1 + 0.06, // 1 + -1.54, // 2 + 0.97, // 2 + 0.03, // 3 + -0.89, // 3 + -0.18, // 4 + -1.31, // 4 + -0.1, + -0.2, + -0.5, + -0.3, + 0.8, + -0.7 + ]); + isApprox( t, viewY, expected, 10.0 ); + t.end(); +}); + +tape( 'the `ndarray` method supports a negative `y` stride', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex64Array([ + 0.7, // 1 + -0.8, // 1 + -0.4, + -0.7, + -0.1, // 2 + -0.9, // 2 + 0.2, + -0.8, + -0.9, // 3 + -0.4, // 3 + 0.1, + 0.4, + -0.6, // 4 + 0.6 // 4 + ]); + y = new Complex64Array([ + 0.6, // 4 + -0.6, // 4 + -0.9, + 0.5, + 0.7, // 3 + -0.6, // 3 + 0.1, + -0.5, + -0.1, // 2 + -0.2, // 2 + -0.5, + -0.3, + 0.8, // 1 + -0.7 // 1 + ]); + alpha = new Complex64( 0.4, -0.7 ); + + caxpy.ndarray( 4, alpha, x, 2, 0, y, -2, 6 ); + + viewY = new Float32Array( y.buffer ); + expected = new Float32Array([ + 0.78, // 4 + 0.06, // 4 + -0.9, + 0.5, + 0.06, // 3 + -0.13, // 3 + 0.1, + -0.5, + -0.77, // 2 + -0.49, // 2 + -0.5, + -0.3, + 0.52, // 1 + -1.51 // 1 + ]); + isApprox( t, viewY, expected, 10.0 ); + t.end(); +}); + +tape( 'the `ndarray` method supports complex access patterns', function test( t ) { + var expected; + var viewY; + var alpha; + var x; + var y; + + x = new Complex64Array([ + 0.7, // 4 + -0.8, // 4 + -0.4, // 3 + -0.7, // 3 + -0.1, // 2 + -0.9, // 2 + 0.2, // 1 + -0.8, // 1 + -0.9, + -0.4, + 0.1, + 0.4, + -0.6, + 0.6 + ]); + y = new Complex64Array([ + 0.6, // 4 + -0.6, // 4 + -0.9, + 0.5, + 0.7, // 3 + -0.6, // 3 + 0.1, + -0.5, + -0.1, // 2 + -0.2, // 2 + -0.5, + -0.3, + 0.8, // 1 + -0.7 // 1 + ]); + alpha = new Complex64( 0.4, -0.7 ); + + caxpy.ndarray( 4, alpha, x, -1, 3, y, -2, 6 ); + + viewY = new Float32Array( y.buffer ); + expected = new Float32Array([ + 0.32, // 4 + -1.41, // 4 + -0.9, + 0.5, + 0.05, // 3 + -0.6, // 3 + 0.1, + -0.5, + -0.77, // 2 + -0.49, // 2 + -0.5, + -0.3, + 0.32, // 1 + -1.16 // 1 + ]); + isApprox( t, viewY, expected, 10.0 ); + t.end(); +}); diff --git a/lib/node_modules/@stdlib/blas/base/wasm/caxpy/test/test.routine.js b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/test/test.routine.js new file mode 100644 index 000000000000..957b387076ca --- /dev/null +++ b/lib/node_modules/@stdlib/blas/base/wasm/caxpy/test/test.routine.js @@ -0,0 +1,71 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var ModuleWrapper = require( '@stdlib/wasm/module-wrapper' ); +var Module = require( './../lib/module.js' ); +var Routine = require( './../lib/routine.js' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof Routine, 'function', 'returns expected value' ); + t.end(); +}); + +tape( 'the function is a constructor', function test( t ) { + var mod = new Routine(); + t.strictEqual( mod instanceof Routine, true, 'returns expected value' ); + t.end(); +}); + +tape( 'the function is a constructor which does not require `new`', function test( t ) { + var mod = Routine(); // eslint-disable-line new-cap + t.strictEqual( mod instanceof Routine, true, 'returns expected value' ); + t.end(); +}); + +tape( 'the module instance returned by the constructor inherits from a module wrapper', function test( t ) { + var mod = new Routine(); + t.strictEqual( mod instanceof ModuleWrapper, true, 'returns expected value' ); + t.end(); +}); + +tape( 'the module instance returned by the constructor inherits from a BLAS routine module', function test( t ) { + var mod = new Routine(); + t.strictEqual( mod instanceof Module, true, 'returns expected value' ); + t.end(); +}); + +tape( 'attached to a module instance is a `main` method', function test( t ) { + var mod = new Routine(); + t.strictEqual( typeof mod.main, 'function', 'returns expected value' ); + t.end(); +}); + +tape( 'attached to a module instance is an `ndarray` method', function test( t ) { + var mod = new Routine(); + t.strictEqual( typeof mod.ndarray, 'function', 'returns expected value' ); + t.end(); +}); diff --git a/lib/node_modules/@stdlib/complex/float32/base/add/manifest.json b/lib/node_modules/@stdlib/complex/float32/base/add/manifest.json index c55113261d87..fab472548dc0 100644 --- a/lib/node_modules/@stdlib/complex/float32/base/add/manifest.json +++ b/lib/node_modules/@stdlib/complex/float32/base/add/manifest.json @@ -1,6 +1,7 @@ { "options": { - "task": "build" + "task": "build", + "wasm": false }, "fields": [ { @@ -27,6 +28,7 @@ "confs": [ { "task": "build", + "wasm": false, "src": [ "./src/main.c" ], @@ -43,6 +45,7 @@ }, { "task": "benchmark", + "wasm": false, "src": [ "./src/main.c" ], @@ -58,6 +61,23 @@ }, { "task": "examples", + "wasm": false, + "src": [ + "./src/main.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/complex/float32/ctor", + "@stdlib/complex/float32/reim" + ] + }, + { + "task": "build", + "wasm": true, "src": [ "./src/main.c" ],