From 3acdf1617a14f554f979ff6449fe4acf7e3aa99a Mon Sep 17 00:00:00 2001 From: JoyBoy <144602492+0PrashantYadav0@users.noreply.github.com> Date: Sat, 1 Mar 2025 17:23:29 +0530 Subject: [PATCH 01/10] feat: initials files requied for wasm implementation --- type: pre_push_report description: Results of running various checks prior to pushing changes. report: - task: run_javascript_examples status: na - task: run_c_examples status: na - task: run_cpp_examples status: na - task: run_javascript_readme_examples status: na - task: run_c_benchmarks status: na - task: run_cpp_benchmarks status: na - task: run_fortran_benchmarks status: na - task: run_javascript_benchmarks status: na - task: run_julia_benchmarks status: na - task: run_python_benchmarks status: na - task: run_r_benchmarks status: na - task: run_javascript_tests status: na --- --- .../ext/base/wasm/dapxsumkbn/src/main.wasm | Bin 330 -> 0 bytes .../ext/base/wasm/dapxsumkbn/src/main.wat | 118 ---- .../blas/ext/base/wasm/dapxsumkbn2/README.md | 293 ++++++++++ .../wasm/dapxsumkbn2/benchmark/benchmark.js | 106 ++++ .../dapxsumkbn2/benchmark/benchmark.module.js | 66 +++ .../benchmark/benchmark.module.main.js | 130 +++++ .../benchmark/benchmark.module.ndarray.js | 130 +++++ .../benchmark/benchmark.ndarray.js | 106 ++++ .../ext/base/wasm/dapxsumkbn2/docs/repl.txt | 514 ++++++++++++++++++ .../wasm/dapxsumkbn2/docs/types/index.d.ts | 321 +++++++++++ .../base/wasm/dapxsumkbn2/docs/types/test.ts | 413 ++++++++++++++ .../base/wasm/dapxsumkbn2/examples/index.js | 43 ++ .../examples/little_endian_arrays.js | 65 +++ .../base/wasm/dapxsumkbn2/examples/module.js | 63 +++ .../ext/base/wasm/dapxsumkbn2/lib/binary.js | 34 ++ .../ext/base/wasm/dapxsumkbn2/lib/index.js | 100 ++++ .../ext/base/wasm/dapxsumkbn2/lib/main.js | 60 ++ .../ext/base/wasm/dapxsumkbn2/lib/module.js | 200 +++++++ .../ext/base/wasm/dapxsumkbn2/lib/routine.js | 168 ++++++ .../ext/base/wasm/dapxsumkbn2/manifest.json | 36 ++ .../ext/base/wasm/dapxsumkbn2/package.json | 80 +++ .../base/wasm/dapxsumkbn2/scripts/build.js | 63 +++ .../scripts/template.txt} | 2 +- .../ext/base/wasm/dapxsumkbn2/src/Makefile | 243 +++++++++ .../base/wasm/dapxsumkbn2/src/exports.json | 4 + .../ext/base/wasm/dapxsumkbn2/test/test.js | 53 ++ .../base/wasm/dapxsumkbn2/test/test.main.js | 172 ++++++ .../base/wasm/dapxsumkbn2/test/test.module.js | 154 ++++++ .../wasm/dapxsumkbn2/test/test.module.main.js | 208 +++++++ .../dapxsumkbn2/test/test.module.ndarray.js | 241 ++++++++ .../wasm/dapxsumkbn2/test/test.ndarray.js | 169 ++++++ .../wasm/dapxsumkbn2/test/test.routine.js | 71 +++ 32 files changed, 4307 insertions(+), 119 deletions(-) delete mode 100755 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn/src/main.wasm delete mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn/src/main.wat create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/README.md create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.main.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.ndarray.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.ndarray.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/repl.txt create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/index.d.ts create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/test.ts create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/index.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/little_endian_arrays.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/module.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/binary.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/index.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/main.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/module.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/routine.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/manifest.json create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/package.json create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/build.js rename lib/node_modules/@stdlib/blas/ext/base/wasm/{dapxsumkbn/lib/binary.browser.js => dapxsumkbn2/scripts/template.txt} (62%) create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/src/Makefile create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/src/exports.json create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.main.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.main.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.ndarray.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.ndarray.js create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.routine.js diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn/src/main.wasm b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn/src/main.wasm deleted file mode 100755 index a8ad820a853c22ea072eec06b1c185d49f09874c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 330 zcmZ{ey-LJT5QS&%+-!nZh!z&I7L#oS@evYGD_iTE?A{3ZT}k3kAdt$3*e=@n20orQ zLF}9<&N&R{V<2fO1UtTG`ZBAFt80{V#xsfmVmS`uh(qkmYK`!b()wjprPaRa1pr9` z6z&6^YW-?qdY6=?-gWz?1vqazQ)XM;c1>ndqfPSk);?FowgwFTz3JK{O_TH>j=qpA zUR?kKBMYVo849K{0_)*^eInF53L0=^uvvyT@H@U@k|Bk*>D}GRke!7fBkJ-?f@$OM v%C0kQ+>dECyy$_Q!{d4i9QGp21CNPi9!PeB)iElyG%R|4<`2d2{i%Kck3vWf diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn/src/main.wat b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn/src/main.wat deleted file mode 100644 index 8deb825dec00..000000000000 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn/src/main.wat +++ /dev/null @@ -1,118 +0,0 @@ -;; @license Apache-2.0 -;; -;; Copyright (c) 2024 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 f64 i32 i32) (result f64))) - (type (;2;) (func (param i32 f64 i32 i32 i32) (result f64))) - (import "env" "memory" (memory (;0;) 0)) - (func (;0;) (type 0) - nop) - (func (;1;) (type 1) (param i32 f64 i32 i32) (result f64) - local.get 0 - local.get 1 - local.get 2 - local.get 3 - i32.const 1 - local.get 0 - i32.sub - local.get 3 - i32.mul - i32.const 0 - local.get 3 - i32.const 0 - i32.le_s - select - call 2) - (func (;2;) (type 2) (param i32 f64 i32 i32 i32) (result f64) - (local f64 f64 f64 i32) - local.get 0 - i32.const 0 - i32.le_s - if ;; label = @1 - f64.const 0x0p+0 (;=0;) - return - end - local.get 3 - if ;; label = @1 - loop ;; label = @2 - local.get 0 - local.get 8 - i32.eq - i32.eqz - if ;; label = @3 - local.get 5 - local.get 1 - local.get 2 - local.get 4 - i32.const 3 - i32.shl - i32.add - f64.load - f64.add - local.tee 5 - local.get 6 - local.get 6 - local.get 5 - f64.add - local.tee 7 - f64.sub - f64.add - local.get 6 - local.get 5 - local.get 7 - f64.sub - f64.add - local.get 6 - f64.abs - local.get 5 - f64.abs - f64.ge - select - f64.add - local.set 5 - local.get 8 - i32.const 1 - i32.add - local.set 8 - local.get 3 - local.get 4 - i32.add - local.set 4 - local.get 7 - local.set 6 - br 1 (;@2;) - end - end - local.get 6 - local.get 5 - f64.add - return - end - local.get 1 - local.get 2 - local.get 4 - i32.const 3 - i32.shl - i32.add - f64.load - f64.add - local.get 0 - f64.convert_i32_u - f64.mul) - (export "__wasm_call_ctors" (func 0)) - (export "stdlib_strided_dapxsumkbn" (func 1)) - (export "stdlib_strided_dapxsumkbn_ndarray" (func 2))) diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/README.md b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/README.md new file mode 100644 index 000000000000..d978bebad3aa --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/README.md @@ -0,0 +1,293 @@ + + +# dapxsumkbn2 + +> Add a scalar constant to each double-precision floating-point strided array element and compute the sum using an improved Kahan–Babuška algorithm. + +
+ +## Usage + +```javascript +var dapxsumkbn2 = require( '@stdlib/blas/ext/base/wasm/dapxsumkbn2' ); +``` + +#### dapxsumkbn2.main( N, alpha, x, strideX ) + +Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm. + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); + +var x = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + +var sum = dapxsumkbn2.main( x.length, 5.0, x, 1 ); +// returns 16.0 +``` + +The function has the following parameters: + +- **N**: number of indexed elements. +- **alpha**: scalar constant. +- **x**: input [`Float64Array`][@stdlib/array/float64]. +- **strideX**: stride length for `x`. + +The `N` and stride parameters determine which elements in the strided array are accessed at runtime. For example, to access every other element in `x`, + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); + +var x = new Float64Array( [ 1.0, 2.0, 2.0, -7.0, -2.0, 3.0, 4.0, 2.0 ] ); + +var sum = dapxsumkbn2.main( 4, 5.0, x, 2 ); +// returns 25.0 +``` + +Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views. + + + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); + +var x0 = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] ); +var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element + +var sum = dapxsumkbn2.main( 4, 5.0, x1, 2 ); +// returns 25.0 +``` + +#### dapxsumkbn2.ndarray( N, alpha, x, strideX, offsetX ) + +Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm and alternative indexing semantics. + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); + +var x = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + +var sum = dapxsumkbn2.ndarray( x.length, 5.0, x, 1, 0 ); +// returns 16.0 +``` + +The function has the following additional parameters: + +- **offsetX**: starting index for `x`. + +While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameter supports indexing semantics based on a starting index. For example, to access every other element starting from the second element: + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); + +var x = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] ); + +var v = dapxsumkbn2.ndarray( 4, 5.0, x, 2, 1 ); +// returns 25.0 +``` + +* * * + +### Module + +#### dapxsumkbn2.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 dapxsumkbn2.Module( mem ); +// returns + +// Initialize the routine: +mod.initializeSync(); +``` + +#### dapxsumkbn2.Module.prototype.main( N, alpha, xp, sx ) + +Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm. + + + +```javascript +var Memory = require( '@stdlib/wasm/memory' ); +var oneTo = require( '@stdlib/array/one-to' ); +var zeros = require( '@stdlib/array/zeros' ); + +// 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 dapxsumkbn2.Module( mem ); +// returns + +// Initialize the routine: +mod.initializeSync(); + +// Define a vector data type: +var dtype = 'float64'; + +// Specify a vector length: +var N = 3; + +// Define a pointer (i.e., byte offset) for storing the input vector: +var xptr = 0; + +// Write vector values to module memory: +mod.write( xptr, oneTo( N, dtype ) ); + +// Perform computation: +var sum = mod.main( N, 5.0, xptr, 1 ); +// returns 21.0 +``` + +The function has the following parameters: + +- **N**: number of indexed elements. +- **alpha**: scalar constant. +- **xp**: input [`Float64Array`][@stdlib/array/float64] pointer (i.e., byte offset). +- **sx**: stride length for `x`. + +#### dapxsumkbn2.Module.prototype.ndarray( N, alpha, xp, sx, ox ) + +Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm and alternative indexing semantics. + + + +```javascript +var Memory = require( '@stdlib/wasm/memory' ); +var oneTo = require( '@stdlib/array/one-to' ); +var zeros = require( '@stdlib/array/zeros' ); + +// 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 dapxsumkbn2.Module( mem ); +// returns + +// Initialize the routine: +mod.initializeSync(); + +// Define a vector data type: +var dtype = 'float64'; + +// Specify a vector length: +var N = 3; + +// Define a pointer (i.e., byte offset) for storing the input vector: +var xptr = 0; + +// Write vector values to module memory: +mod.write( xptr, oneTo( N, dtype ) ); + +// Perform computation: +var sum = mod.ndarray( N, 5.0, xptr, 1, 0 ); +// returns 21.0 +``` + +The function has the following additional parameters: + +- **ox**: starting index for `x`. + +
+ + + +
+ +* * * + +## Notes + +- If `N <= 0`, both `main` and `ndarray` methods return `0.0`. +- This package implements routines using WebAssembly. When provided arrays which are not allocated on a `dapxsumkbn2` 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/dapxsumkbn2`][@stdlib/blas/ext/base/dapxsumkbn2]. 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/dapxsumkbn2`][@stdlib/blas/ext/base/dapxsumkbn2]. 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. + +
+ + + +
+ +* * * + +## Examples + + + +```javascript +var discreteUniform = require( '@stdlib/random/array/discrete-uniform' ); +var dapxsumkbn2 = require( '@stdlib/blas/ext/base/wasm/dapxsumkbn2' ); + +var opts = { + 'dtype': 'float64' +}; +var x = discreteUniform( 10, 0, 100, opts ); +console.log( x ); + +var sum = dapxsumkbn2.ndarray( x.length, 5.0, x, 1, 0 ); +console.log( sum ); +``` + +
+ + + + + +
+ +
+ + + + + +
+ +[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray + +[@stdlib/array/float64]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/float64 + +[@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/ext/base/dapxsumkbn2]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/ext/base/dapxsumkbn2 + +
+ + diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.js new file mode 100644 index 000000000000..b10ac5d3b102 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.js @@ -0,0 +1,106 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var pkg = require( './../package.json' ).name; +var dapxsumkbn = require( './../lib' ); + + +// VARIABLES // + +var opts = { + 'skip': !hasWebAssemblySupport() +}; +var options = { + 'dtype': 'float64' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + var x = uniform( len, -10.0, 10.0, options ); + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var sum; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + sum = dapxsumkbn.main( x.length, 5.0, x, 1 ); + if ( isnan( sum ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( sum ) ) { + 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( pkg+':len='+len, opts, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.js new file mode 100644 index 000000000000..1110f8893ccd --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.js @@ -0,0 +1,66 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 pkg = require( './../package.json' ).name; +var dapxsumkbn = require( './../lib' ); + + +// VARIABLES // + +var opts = { + 'skip': !hasWebAssemblySupport() +}; + + +// MAIN // + +bench( pkg+':Module:constructor', 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 dapxsumkbn.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/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.main.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.main.js new file mode 100644 index 000000000000..7463536cf3fa --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.main.js @@ -0,0 +1,130 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var pkg = require( './../package.json' ).name; +var dapxsumkbn = require( './../lib' ); + + +// VARIABLES // + +var opts = { + 'skip': !hasWebAssemblySupport() +}; +var options = { + 'dtype': 'float64' +}; + + +// 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 xptr; + var mod; + var mem; + var sum; + var nb; + var i; + + // Create a new BLAS routine interface: + mem = new Memory({ + 'initial': 0 + }); + mod = new dapxsumkbn.Module( mem ); + + // Initialize the module: + mod.initializeSync(); // eslint-disable-line node/no-sync + + // Reallocate the underlying memory to allow storing a vector: + nb = bytesPerElement( options.dtype ); + mod.realloc( len*nb ); + + // Define a pointer (i.e., byte offset) to the first vector element: + xptr = 0; + + // Write random values to module memory: + mod.write( xptr, uniform( len, -10.0, 10.0, options ) ); + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + sum = mod.main( len, 5.0, xptr, 1 ); + if ( isnan( sum ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( sum ) ) { + 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( pkg+'::module,pointers:len='+len, opts, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.ndarray.js new file mode 100644 index 000000000000..1530dc8217fc --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.ndarray.js @@ -0,0 +1,130 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var pkg = require( './../package.json' ).name; +var dapxsumkbn = require( './../lib' ); + + +// VARIABLES // + +var opts = { + 'skip': !hasWebAssemblySupport() +}; +var options = { + 'dtype': 'float64' +}; + + +// 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 xptr; + var mod; + var mem; + var sum; + var nb; + var i; + + // Create a new BLAS routine interface: + mem = new Memory({ + 'initial': 0 + }); + mod = new dapxsumkbn.Module( mem ); + + // Initialize the module: + mod.initializeSync(); // eslint-disable-line node/no-sync + + // Reallocate the underlying memory to allow storing a vector: + nb = bytesPerElement( options.dtype ); + mod.realloc( len*nb ); + + // Define a pointer (i.e., byte offset) to the first vector element: + xptr = 0; + + // Write random values to module memory: + mod.write( xptr, uniform( len, -10.0, 10.0, options ) ); + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + sum = mod.ndarray( len, 5.0, xptr, 1, 0 ); + if ( isnan( sum ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( sum ) ) { + 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( pkg+'::module,pointers:ndarray:len='+len, opts, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.ndarray.js new file mode 100644 index 000000000000..32ccd8d59bbf --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.ndarray.js @@ -0,0 +1,106 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var pkg = require( './../package.json' ).name; +var dapxsumkbn = require( './../lib' ); + + +// VARIABLES // + +var opts = { + 'skip': !hasWebAssemblySupport() +}; +var options = { + 'dtype': 'float64' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + var x = uniform( len, -10.0, 10.0, options ); + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var sum; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + sum = dapxsumkbn.ndarray( x.length, 5.0, x, 1, 0 ); + if ( isnan( sum ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( sum ) ) { + 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( pkg+':ndarray:len='+len, opts, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/repl.txt b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/repl.txt new file mode 100644 index 000000000000..92a6b5e7098d --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/repl.txt @@ -0,0 +1,514 @@ + +{{alias}}.main( N, alpha, x, strideX ) + Adds a scalar constant to each double-precision floating-point strided + array element and computes the sum using an improved Kahan–Babuška + algorithm. + + The `N` and stride parameters determine which elements in the strided array + are accessed at runtime. + + Indexing is relative to the first index. To introduce an offset, use a typed + array view. + + If `N <= 0`, the function returns `0.0`. + + Parameters + ---------- + N: integer + Number of indexed elements. + + alpha: number + Scalar constant. + + x: Float64Array + Input array. + + strideX: integer + Stride length. + + Returns + ------- + out: number + Sum. + + Examples + -------- + // Standard Usage: + > var x = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, 2.0 ] ); + > {{alias}}.main( x.length, 5.0, x, 1 ) + 16.0 + + // Using `N` and stride parameters: + > x = new {{alias:@stdlib/array/float64}}( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0 ] ); + > {{alias}}.main( 3, 5.0, x, 2 ) + 16.0 + + // Using view offsets: + > var x0 = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] ); + > var x1 = new {{alias:@stdlib/array/float64}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); + > {{alias}}.main( 3, 5.0, x1, 2) + 14.0 + + +{{alias}}.ndarray( N, alpha, x, strideX, offsetX ) + Adds a scalar constant to each double-precision floating-point strided array + element and computes the sum using an improved Kahan–Babuška algorithm and + alternative indexing semantics. + + While typed array views mandate a view offset based on the underlying + buffer, the offset parameter supports indexing semantics based on a starting + index. + + Parameters + ---------- + N: integer + Number of indexed elements. + + alpha: number + Scalar constant. + + x: Float64Array + Input array. + + strideX: integer + Stride length. + + offsetX: integer + Starting index. + + Returns + ------- + out: number + Sum. + + Examples + -------- + // Standard Usage: + > var x = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, 2.0 ] ); + > {{alias}}.ndarray( x.length, 5.0, x, 1, 0 ) + 16.0 + + // Using offset parameter: + > var x = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] ); + > {{alias}}.ndarray( 3, 5.0, x, 2, 1 ) + 14.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 WebAsssembly 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, alpha, xp, sx ) + Adds a scalar constant to each double-precision floating-point strided + array element and computes the sum using an improved Kahan–Babuška + algorithm. + + Parameters + ---------- + N: integer + Number of indexed elements. + + alpha: number + Scalar constant. + + xp: integer + Input array pointer (i.e., byte offset). + + sx: integer + Stride length. + + Returns + ------- + sum: number + Sum. + + Examples + -------- + > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 1 } ); + > var mod = new {{alias}}.Module( mem ); + > mod.initializeSync(); + + // Define a "pointer" (i.e., byte offset) into module memory: + > var xptr = 0; + + // Write data to module memory: + > mod.write( xptr, {{alias:@stdlib/array/one-to}}( 3, 'float64' ) ); + + // Perform computation: + > var s = mod.main( 3, 5.0, xptr, 1 ) + 21.0 + + +{{alias}}.Module.prototype.ndarray( N, alpha, xp, sx, ox ) + Adds a scalar constant to each double-precision floating-point strided + array element and computes the sum using an improved Kahan–Babuška algorithm + and alternative indexing semantics. + + Parameters + ---------- + N: integer + Number of indexed elements. + + alpha: number + Scalar constant. + + xp: integer + Input array pointer (i.e., byte offset). + + sx: integer + Stride length. + + ox: integer + Starting index. + + Returns + ------- + sum: number + Sum. + + Examples + -------- + > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 1 } ); + > var mod = new {{alias}}.Module( mem ); + > mod.initializeSync(); + + // Define a "pointer" (i.e., byte offset) into module memory: + > var xptr = 0; + + // Write data to module memory: + > mod.write( xptr, {{alias:@stdlib/array/one-to}}( 3, 'float64' ) ); + + // Perform computation: + > var s = mod.ndarray( 3, 5.0, xptr, 1, 0 ) + 21.0 + + See Also + -------- + diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/index.d.ts new file mode 100644 index 000000000000..5f59f38e9248 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/index.d.ts @@ -0,0 +1,321 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2024 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'; + +/** +* 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 oneTo = require( '@stdlib/array/one-to' ); + * + * // 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 dapxsumkbn.Module( mem ); + * // returns + * + * // Initialize the routine: + * mod.initializeSync(); + * + * // Define a vector data type: + * var dtype = 'float64'; + * + * // Specify a vector length: + * var N = 3; + * + * // Define a pointer (i.e., byte offset) to the first vector element: + * var xptr = 0; + * + * // Write vector values to module memory: + * mod.write( xptr, oneTo( N, dtype ) ); + * + * // Perform computation: + * var out = mod.main( N, 5.0, xptr, 1 ); + * // returns 21.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 oneTo = require( '@stdlib/array/one-to' ); + * + * // 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 = dapxsumkbn.Module( mem ); + * // returns + * + * // Initialize the routine: + * mod.initializeSync(); + * + * // Define a vector data type: + * var dtype = 'float64'; + * + * // Specify a vector length: + * var N = 3; + * + * // Define a pointer (i.e., byte offset) to the first vector element: + * var xptr = 0; + * + * // Write vector values to module memory: + * mod.write( xptr, oneTo( N, dtype ) ); + * + * // Perform computation: + * var out = mod.main( N, 5.0, xptr, 1 ); + * // returns 21.0 + */ + ( mem: Memory ): Module; // callable +} + +/** +* Interface describing a `dapxsumkbn` WebAssembly module. +*/ +interface Module extends ModuleWrapper { + /** + * Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm. + * + * @param N - number of indexed elements + * @param alpha - scalar constant + * @param xptr - input array pointer (i.e., byte offset) + * @param strideX - stride length + * @returns sum + * + * @example + * var Memory = require( '@stdlib/wasm/memory' ); + * var oneTo = require( '@stdlib/array/one-to' ); + * + * // 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 dapxsumkbn.Module( mem ); + * // returns + * + * // Initialize the routine: + * mod.initializeSync(); + * + * // Define a vector data type: + * var dtype = 'float64'; + * + * // Specify a vector length: + * var N = 3; + * + * // Define a pointer (i.e., byte offset) to the first vector element: + * var xptr = 0; + * + * // Write vector values to module memory: + * mod.write( xptr, oneTo( N, dtype ) ); + * + * // Perform computation: + * var out = mod.main( N, 5.0, xptr, 1 ); + * // returns 21.0 + */ + main( N: number, alpha: number, xptr: number, strideX: number ): number; + + /** + * Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm and alternative indexing semantics. + * + * @param N - number of indexed elements + * @param alpha - scalar constant + * @param xptr - input array pointer (i.e., byte offset) + * @param strideX - stride length + * @param offsetX - starting index + * @returns sum + * + * @example + * var Memory = require( '@stdlib/wasm/memory' ); + * var oneTo = require( '@stdlib/array/one-to' ); + * + * // 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 dapxsumkbn.Module( mem ); + * // returns + * + * // Initialize the routine: + * mod.initializeSync(); + * + * // Define a vector data type: + * var dtype = 'float64'; + * + * // Specify a vector length: + * var N = 3; + * + * // Define a pointer (i.e., byte offset) to the first vector element: + * var xptr = 0; + * + * // Write vector values to module memory: + * mod.write( xptr, oneTo( N, dtype ) ); + * + * // Perform computation: + * var out = mod.ndarray( N, 5.0, xptr, 1, 0 ); + * // returns 21.0 + */ + ndarray( N: number, alpha: number, xptr: number, strideX: number, offsetX: number ): number; +} + +/** +* Interface describing `dapxsumkbn`. +*/ +interface Routine extends ModuleWrapper { + /** + * Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm. + * + * @param N - number of indexed elements + * @param alpha - scalar constant + * @param x - input array + * @param strideX - stride length + * @returns sum + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, -2.0, 2.0 ] ); + * + * var out = dapxsumkbn.main( 3, 5.0, x, 1 ); + * // returns 16.0 + */ + main( N: number, alpha: number, x: Float64Array, strideX: number ): number; + + /** + * Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm and alternative indexing semantics. + * + * @param N - number of indexed elements + * @param alpha - scalar constant + * @param x - input array + * @param strideX - stride length + * @param offsetX - starting index + * @returns sum + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] ); + * + * var out = dapxsumkbn.ndarray( 4, 5.0, x, 2, 1 ); + * // returns 25.0 + */ + ndarray( N: number, alpha: number, x: Float64Array, strideX: number, offsetX: number ): number; + + /** + * 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 oneTo = require( '@stdlib/array/one-to' ); + * + * // 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 dapxsumkbn.Module( mem ); + * // returns + * + * // Initialize the routine: + * mod.initializeSync(); + * + * // Define a vector data type: + * var dtype = 'float64'; + * + * // Specify a vector length: + * var N = 3; + * + * // Define a pointer (i.e., byte offset) to the first vector element: + * var xptr = 0; + * + * // Write vector values to module memory: + * mod.write( xptr, oneTo( N, dtype ) ); + * + * // Perform computation: + * var out = mod.main( N, 5.0, xptr, 1 ); + * // returns 21.0 + */ + Module: ModuleConstructor; +} + +/** +* Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm. +* +* @param N - number of indexed elements +* @param alpha - scalar constant +* @param x - input array +* @param strideX - stride length +* @returns sum +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var x = new Float64Array( [ 1.0, -2.0, 2.0 ] ); +* +* var out = dapxsumkbn.main( 3, 5.0, x, 1 ); +* // returns 16.0 +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var x = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] ); +* +* var out = dapxsumkbn.ndarray( 4, 5.0, x, 2, 1 ); +* // returns 25.0 +*/ +declare var dapxsumkbn: Routine; + + +// EXPORTS // + +export = dapxsumkbn; diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/test.ts b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/test.ts new file mode 100644 index 000000000000..f103259c71e9 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/test.ts @@ -0,0 +1,413 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2024 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 Memory = require( '@stdlib/wasm/memory' ); +import dapxsumkbn = require( './index' ); + + +// TESTS // + +// Attached to the main export is a `main` method which returns a number... +{ + const x = new Float64Array( 10 ); + + dapxsumkbn.main( x.length, 5.0, x, 1 ); // $ExpectType number +} + +// The compiler throws an error if the `main` method is provided a first argument which is not a number... +{ + const x = new Float64Array( 10 ); + + dapxsumkbn.main( '10', 5.0, x, 1 ); // $ExpectError + dapxsumkbn.main( true, 5.0, x, 1 ); // $ExpectError + dapxsumkbn.main( false, 5.0, x, 1 ); // $ExpectError + dapxsumkbn.main( null, 5.0, x, 1 ); // $ExpectError + dapxsumkbn.main( undefined, 5.0, x, 1 ); // $ExpectError + dapxsumkbn.main( [], 5.0, x, 1 ); // $ExpectError + dapxsumkbn.main( {}, 5.0, x, 1 ); // $ExpectError + dapxsumkbn.main( ( x: number ): number => x, 5.0, x, 1 ); // $ExpectError +} + +// The compiler throws an error if the `main` method is provided a second argument which is not a number... +{ + const x = new Float64Array( 10 ); + + dapxsumkbn.main( x.length, '10', x, 1 ); // $ExpectError + dapxsumkbn.main( x.length, true, x, 1 ); // $ExpectError + dapxsumkbn.main( x.length, false, x, 1 ); // $ExpectError + dapxsumkbn.main( x.length, null, x, 1 ); // $ExpectError + dapxsumkbn.main( x.length, undefined, x, 1 ); // $ExpectError + dapxsumkbn.main( x.length, [], x, 1 ); // $ExpectError + dapxsumkbn.main( x.length, {}, x, 1 ); // $ExpectError + dapxsumkbn.main( x.length, ( x: number ): number => x, x, 1 ); // $ExpectError +} + +// The compiler throws an error if the `main` method is provided a third argument which is not a Float64Array... +{ + const x = new Float64Array( 10 ); + + dapxsumkbn.main( x.length, 5.0, 10, 1 ); // $ExpectError + dapxsumkbn.main( x.length, 5.0, '10', 1 ); // $ExpectError + dapxsumkbn.main( x.length, 5.0, true, 1 ); // $ExpectError + dapxsumkbn.main( x.length, 5.0, false, 1 ); // $ExpectError + dapxsumkbn.main( x.length, 5.0, null, 1 ); // $ExpectError + dapxsumkbn.main( x.length, 5.0, undefined, 1 ); // $ExpectError + dapxsumkbn.main( x.length, 5.0, [], 1 ); // $ExpectError + dapxsumkbn.main( x.length, 5.0, {}, 1 ); // $ExpectError + dapxsumkbn.main( x.length, 5.0, ( x: number ): number => x, 1 ); // $ExpectError +} + +// The compiler throws an error if the `main` method is provided a fourth argument which is not a number... +{ + const x = new Float64Array( 10 ); + + dapxsumkbn.main( x.length, 5.0, x, '10' ); // $ExpectError + dapxsumkbn.main( x.length, 5.0, x, true ); // $ExpectError + dapxsumkbn.main( x.length, 5.0, x, false ); // $ExpectError + dapxsumkbn.main( x.length, 5.0, x, null ); // $ExpectError + dapxsumkbn.main( x.length, 5.0, x, undefined ); // $ExpectError + dapxsumkbn.main( x.length, 5.0, x, [] ); // $ExpectError + dapxsumkbn.main( x.length, 5.0, x, {} ); // $ExpectError + dapxsumkbn.main( x.length, 5.0, x, ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the `main` method is provided an unsupported number of arguments... +{ + const x = new Float64Array( 10 ); + + dapxsumkbn.main(); // $ExpectError + dapxsumkbn.main( x.length ); // $ExpectError + dapxsumkbn.main( x.length, x ); // $ExpectError + dapxsumkbn.main( x.length, x, 1 ); // $ExpectError + dapxsumkbn.main( x.length, x, 1, 10, 2 ); // $ExpectError +} + +// Attached to main export is an `ndarray` method which returns a number... +{ + const x = new Float64Array( 10 ); + + dapxsumkbn.ndarray( x.length, 5.0, x, 1, 0 ); // $ExpectType number +} + +// The compiler throws an error if the `ndarray` method is provided a first argument which is not a number... +{ + const x = new Float64Array( 10 ); + + dapxsumkbn.ndarray( '10', 5.0, x, 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( true, 5.0, x, 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( false, 5.0, x, 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( null, 5.0, x, 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( undefined, 5.0, x, 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( [], 5.0, x, 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( {}, 5.0, x, 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( ( x: number ): number => x, 5.0, x, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a second argument which is not a number... +{ + const x = new Float64Array( 10 ); + + dapxsumkbn.ndarray( x.length, '10', x, 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, true, x, 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, false, x, 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, null, x, 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, undefined, x, 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, [], x, 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, {}, x, 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, ( x: number ): number => x, x, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a third argument which is not a Float64Array... +{ + const x = new Float64Array( 10 ); + + dapxsumkbn.ndarray( x.length, 5.0, 10, 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, '10', 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, true, 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, false, 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, null, 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, undefined, 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, [], 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, {}, 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, ( x: number ): number => x, 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 Float64Array( 10 ); + + dapxsumkbn.ndarray( x.length, 5.0, x, '10', 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, x, true, 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, x, false, 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, x, null, 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, x, undefined, 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, x, [], 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, x, {}, 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, x, ( x: number ): number => x, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a number... +{ + const x = new Float64Array( 10 ); + + dapxsumkbn.ndarray( x.length, 5.0, x, 1, '10' ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, x, 1, true ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, x, 1, false ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, x, 1, null ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, x, 1, undefined ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, x, 1, [] ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, x, 1, {} ); // $ExpectError + dapxsumkbn.ndarray( x.length, 5.0, x, 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 Float64Array( 10 ); + + dapxsumkbn.ndarray(); // $ExpectError + dapxsumkbn.ndarray( x.length ); // $ExpectError + dapxsumkbn.ndarray( x.length, x ); // $ExpectError + dapxsumkbn.ndarray( x.length, x, 1 ); // $ExpectError + dapxsumkbn.ndarray( x.length, x, 1, 0 ); // $ExpectError + dapxsumkbn.ndarray( x.length, x, 1, 0, 10, 2 ); // $ExpectError +} + +// Attached to the main export is a `Module` constructor which returns a module... +{ + const mem = new Memory({ + 'initial': 0 + }); + + dapxsumkbn.Module( mem ); // $ExpectType Module +} + +// The compiler throws an error if the `Module` constructor is not provided a WebAssembly memory instance... +{ + dapxsumkbn.Module( '10' ); // $ExpectError + dapxsumkbn.Module( true ); // $ExpectError + dapxsumkbn.Module( false ); // $ExpectError + dapxsumkbn.Module( null ); // $ExpectError + dapxsumkbn.Module( undefined ); // $ExpectError + dapxsumkbn.Module( [] ); // $ExpectError + dapxsumkbn.Module( {} ); // $ExpectError + dapxsumkbn.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 = dapxsumkbn.Module( mem ); + + mod.main( 10, 5.0, 0, 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 = dapxsumkbn.Module( mem ); + + mod.main( '10', 5.0, 0, 1 ); // $ExpectError + mod.main( true, 5.0, 0, 1 ); // $ExpectError + mod.main( false, 5.0, 0, 1 ); // $ExpectError + mod.main( null, 5.0, 0, 1 ); // $ExpectError + mod.main( undefined, 5.0, 0, 1 ); // $ExpectError + mod.main( [], 5.0, 0, 1 ); // $ExpectError + mod.main( {}, 5.0, 0, 1 ); // $ExpectError + mod.main( ( x: number ): number => x, 5.0, 0, 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 = dapxsumkbn.Module( mem ); + + mod.main( 10, '10', 0, 1 ); // $ExpectError + mod.main( 10, true, 0, 1 ); // $ExpectError + mod.main( 10, false, 0, 1 ); // $ExpectError + mod.main( 10, null, 0, 1 ); // $ExpectError + mod.main( 10, undefined, 0, 1 ); // $ExpectError + mod.main( 10, [], 0, 1 ); // $ExpectError + mod.main( 10, {}, 0, 1 ); // $ExpectError + mod.main( 10, ( x: number ): number => x, 0, 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 = dapxsumkbn.Module( mem ); + + mod.main( 10, 5.0, '10', 1 ); // $ExpectError + mod.main( 10, 5.0, true, 1 ); // $ExpectError + mod.main( 10, 5.0, false, 1 ); // $ExpectError + mod.main( 10, 5.0, null, 1 ); // $ExpectError + mod.main( 10, 5.0, undefined, 1 ); // $ExpectError + mod.main( 10, 5.0, [], 1 ); // $ExpectError + mod.main( 10, 5.0, {}, 1 ); // $ExpectError + mod.main( 10, 5.0, ( x: number ): number => x, 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 = dapxsumkbn.Module( mem ); + + mod.main( 10, 5.0, 0, '10' ); // $ExpectError + mod.main( 10, 5.0, 0, true ); // $ExpectError + mod.main( 10, 5.0, 0, false ); // $ExpectError + mod.main( 10, 5.0, 0, null ); // $ExpectError + mod.main( 10, 5.0, 0, undefined ); // $ExpectError + mod.main( 10, 5.0, 0, [] ); // $ExpectError + mod.main( 10, 5.0, 0, {} ); // $ExpectError + mod.main( 10, 5.0, 0, ( 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 = dapxsumkbn.Module( mem ); + + mod.main(); // $ExpectError + mod.main( 10 ); // $ExpectError + mod.main( 10, 0 ); // $ExpectError + mod.main( 10, 0, 1 ); // $ExpectError + mod.main( 10, 0, 1, 5, 2 ); // $ExpectError +} + +// The `Module` constructor returns a module instance having an `ndarray` method which returns a number... +{ + const mem = new Memory({ + 'initial': 1 + }); + const mod = dapxsumkbn.Module( mem ); + + mod.ndarray( 10, 5.0, 0, 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 = dapxsumkbn.Module( mem ); + + mod.ndarray( '10', 5.0, 0, 1, 0 ); // $ExpectError + mod.ndarray( true, 5.0, 0, 1, 0 ); // $ExpectError + mod.ndarray( false, 5.0, 0, 1, 0 ); // $ExpectError + mod.ndarray( null, 5.0, 0, 1, 0 ); // $ExpectError + mod.ndarray( undefined, 5.0, 0, 1, 0 ); // $ExpectError + mod.ndarray( [], 5.0, 0, 1, 0 ); // $ExpectError + mod.ndarray( {}, 5.0, 0, 1, 0 ); // $ExpectError + mod.ndarray( ( x: number ): number => x, 5.0, 0, 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 = dapxsumkbn.Module( mem ); + + mod.ndarray( 5.0, '10', 0, 1, 0 ); // $ExpectError + mod.ndarray( 5.0, true, 0, 1, 0 ); // $ExpectError + mod.ndarray( 5.0, false, 0, 1, 0 ); // $ExpectError + mod.ndarray( 5.0, null, 0, 1, 0 ); // $ExpectError + mod.ndarray( 5.0, undefined, 0, 1, 0 ); // $ExpectError + mod.ndarray( 5.0, [], 0, 1, 0 ); // $ExpectError + mod.ndarray( 5.0, {}, 0, 1, 0 ); // $ExpectError + mod.ndarray( 5.0, ( x: number ): number => x, 0, 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 = dapxsumkbn.Module( mem ); + + mod.ndarray( 10, 5.0, '10', 1, 0 ); // $ExpectError + mod.ndarray( 10, 5.0, true, 1, 0 ); // $ExpectError + mod.ndarray( 10, 5.0, false, 1, 0 ); // $ExpectError + mod.ndarray( 10, 5.0, null, 1, 0 ); // $ExpectError + mod.ndarray( 10, 5.0, undefined, 1, 0 ); // $ExpectError + mod.ndarray( 10, 5.0, [], 1, 0 ); // $ExpectError + mod.ndarray( 10, 5.0, {}, 1, 0 ); // $ExpectError + mod.ndarray( 10, 5.0, ( x: number ): number => x, 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 = dapxsumkbn.Module( mem ); + + mod.ndarray( 10, 5.0, 0, '10', 0 ); // $ExpectError + mod.ndarray( 10, 5.0, 0, true, 0 ); // $ExpectError + mod.ndarray( 10, 5.0, 0, false, 0 ); // $ExpectError + mod.ndarray( 10, 5.0, 0, null, 0 ); // $ExpectError + mod.ndarray( 10, 5.0, 0, undefined, 0 ); // $ExpectError + mod.ndarray( 10, 5.0, 0, [], 0 ); // $ExpectError + mod.ndarray( 10, 5.0, 0, {}, 0 ); // $ExpectError + mod.ndarray( 10, 5.0, 0, ( x: number ): number => x, 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 = dapxsumkbn.Module( mem ); + + mod.ndarray( 10, 5.0, 0, 1, '10' ); // $ExpectError + mod.ndarray( 10, 5.0, 0, 1, true ); // $ExpectError + mod.ndarray( 10, 5.0, 0, 1, false ); // $ExpectError + mod.ndarray( 10, 5.0, 0, 1, null ); // $ExpectError + mod.ndarray( 10, 5.0, 0, 1, undefined ); // $ExpectError + mod.ndarray( 10, 5.0, 0, 1, [] ); // $ExpectError + mod.ndarray( 10, 5.0, 0, 1, {} ); // $ExpectError + mod.ndarray( 10, 5.0, 0, 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 = dapxsumkbn.Module( mem ); + + mod.ndarray(); // $ExpectError + mod.ndarray( 10 ); // $ExpectError + mod.ndarray( 10, 0 ); // $ExpectError + mod.ndarray( 10, 0, 1 ); // $ExpectError + mod.ndarray( 10, 0, 1, 0 ); // $ExpectError + mod.ndarray( 10, 0, 1, 0, 10, 2 ); // $ExpectError +} diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/index.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/index.js new file mode 100644 index 000000000000..7c6e0b408530 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/index.js @@ -0,0 +1,43 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 dapxsumkbn = require( './../lib' ); + +function main() { + if ( !hasWebAssemblySupport() ) { + console.error( 'Environment does not support WebAssembly.' ); + return; + } + // Specify a vector length: + var N = 3; + + // Create an input array: + var x = oneTo( N, 'float64' ); + + // Perform computation: + var sum = dapxsumkbn.ndarray( N, 5.0, x, 1, 0 ); + + // Print the result: + console.log( sum ); +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/little_endian_arrays.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/little_endian_arrays.js new file mode 100644 index 000000000000..65fd33c1b48c --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/little_endian_arrays.js @@ -0,0 +1,65 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 Float64ArrayLE = require( '@stdlib/array/little-endian-float64' ); +var dapxsumkbn = 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 dapxsumkbn.Module( mem ); + // returns + + // Initialize the routine: + mod.initializeSync(); // eslint-disable-line node/no-sync + + // Specify a vector length: + var N = 3; + + // Define a pointer (i.e., byte offset) for storing the input vector: + var xptr = 0; + + // Create a typed array view over module memory: + var x = new Float64ArrayLE( mod.memory.buffer, xptr, N ); + + // Write values to module memory: + gfillBy( N, x, 1, discreteUniform( -10.0, 10.0 ) ); + + // Perform computation: + var sum = mod.ndarray( N, 5.0, xptr, 1, 0 ); + + // Print the result: + console.log( sum ); +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/module.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/module.js new file mode 100644 index 000000000000..3e473635fab9 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/module.js @@ -0,0 +1,63 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 oneTo = require( '@stdlib/array/one-to' ); +var dapxsumkbn = 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 dapxsumkbn.Module( mem ); + // returns + + // Initialize the routine: + mod.initializeSync(); // eslint-disable-line node/no-sync + + // Define a vector data type: + var dtype = 'float64'; + + // Specify a vector length: + var N = 3; + + // Define a pointer (i.e., byte offset) for storing the input vector: + var xptr = 0; + + // Write vector values to module memory: + mod.write( xptr, oneTo( N, dtype ) ); + + // Perform computation: + var sum = mod.ndarray( N, 5.0, xptr, 1, 0 ); + + // Print the result: + console.log( sum ); +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/binary.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/binary.js new file mode 100644 index 000000000000..6f02393f96e5 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/binary.js @@ -0,0 +1,34 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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/ext/base/wasm/dapxsumkbn2/lib/index.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/index.js new file mode 100644 index 000000000000..d565b0a839fc --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/index.js @@ -0,0 +1,100 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 add a scalar constant to each double-precision floating-point strided array element and compute the sum using a second-order iterative Kahan–Babuška algorithm. +* +* @module @stdlib/blas/ext/base/wasm/dapxsumkbn2 +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* var dapxsumkbn2 = require( '@stdlib/blas/ext/base/wasm/dapxsumkbn2' ); +* +* // Define a strided array: +* var x = new Float64Array( [ 1.0, -2.0, 2.0 ] ); +* +* // Perform operation: +* var v = dapxsumkbn2.main( 3, 5.0, x, 1 ); +* // returns 16.0 +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* var dapxsumkbn2 = require( '@stdlib/blas/ext/base/wasm/dapxsumkbn2' ); +* +* // Define a strided array: +* var x = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] ); +* +* // Perform operation: +* var v = dapxsumkbn2.ndarray( 4, 5.0, x, 2, 1 ); +* // returns 25.0 +* +* @example +* var Memory = require( '@stdlib/wasm/memory' ); +* var oneTo = require( '@stdlib/array/one-to' ); +* var zeros = require( '@stdlib/array/zeros' ); +* var dapxsumkbn2 = require( '@stdlib/blas/ext/base/wasm/dapxsumkbn2' ); +* +* // 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 dapxsumkbn2.Module( mem ); +* // returns +* +* // Initialize the routine: +* mod.initializeSync(); +* +* // Define a vector data type: +* var dtype = 'float64'; +* +* // Specify a vector length: +* var N = 3; +* +* // Define a pointer (i.e., byte offset) for storing the input vector: +* var xptr = 0; +* +* // Write vector values to module memory: +* mod.write( xptr, oneTo( N, dtype ) ); +* +* // Perform computation: +* var sum = mod.main( N, 5.0, xptr, 1 ); +* // returns 21.0 +*/ + +// MODULES // + +var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' ); +var main = require( './main.js' ); +var Module = require( './module.js' ); + + +// MAIN // + +setReadOnly( main, 'Module', Module ); + + +// EXPORTS // + +module.exports = main; + +// exports: { "Module": "main.Module" } diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/main.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/main.js new file mode 100644 index 000000000000..77ab51bacd4d --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/main.js @@ -0,0 +1,60 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 Routine = require( './routine.js' ); + + +// MAIN // + +/** +* WebAssembly routine to add a scalar constant to each double-precision floating-point strided array element and compute the sum using a second-order iterative Kahan–Babuška algorithm. +* +* @name dapxsumkbn2 +* @type {Routine} +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* // Define a strided array: +* var x = new Float64Array( [ 1.0, -2.0, 2.0 ] ); +* +* // Perform operation: +* var v = dapxsumkbn2.main( 3, 5.0, x, 1 ); +* // returns 16.0 +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* // Define a strided array: +* var x = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] ); +* +* // Perform operation: +* var v = dapxsumkbn2.ndarray( 4, 5.0, x, 2, 1 ); +* // returns 25.0 +*/ +var dapxsumkbn2 = new Routine(); +dapxsumkbn2.initializeSync(); // eslint-disable-line node/no-sync + + +// EXPORTS // + +module.exports = dapxsumkbn2; diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/module.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/module.js new file mode 100644 index 000000000000..453831ce7728 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/module.js @@ -0,0 +1,200 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 oneTo = require( '@stdlib/array/one-to' ); +* +* // 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 dapxsumkbn2 = new Module( mem ); +* // returns +* +* // Initialize the routine: +* dapxsumkbn2.initializeSync(); +* +* // Define a vector data type: +* var dtype = 'float64'; +* +* // Specify a vector length: +* var N = 3; +* +* // Define a pointer (i.e., byte offset) for storing the input vector: +* var xptr = 0; +* +* // Write vector values to module memory: +* dapxsumkbn2.write( xptr, oneTo( N, dtype ) ); +* +* // Perform computation: +* var sum = dapxsumkbn2.main( N, 5.0, xptr, 1 ); +* // returns 21.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 + } + }); + + return this; +} + +// Inherit from the parent constructor: +inherits( Module, WasmModule ); + +/** +* Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm. +* +* @name main +* @memberof Module.prototype +* @readonly +* @type {Function} +* @param {PositiveInteger} N - number of indexed elements +* @param {number} alpha - scalar constant +* @param {NonNegativeInteger} xptr - input array pointer (i.e., byte offset) +* @param {integer} strideX - stride length +* @returns {number} sum +* +* @example +* var Memory = require( '@stdlib/wasm/memory' ); +* var oneTo = require( '@stdlib/array/one-to' ); +* +* // 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 dapxsumkbn2 = new Module( mem ); +* // returns +* +* // Initialize the routine: +* dapxsumkbn2.initializeSync(); +* +* // Define a vector data type: +* var dtype = 'float64'; +* +* // Specify a vector length: +* var N = 3; +* +* // Define a pointer (i.e., byte offset) for storing the input vector: +* var xptr = 0; +* +* // Write vector values to module memory: +* dapxsumkbn2.write( xptr, oneTo( N, dtype ) ); +* +* // Perform computation: +* var sum = dapxsumkbn2.main( N, 5.0, xptr, 1 ); +* // returns 21.0 +*/ +setReadOnly( Module.prototype, 'main', function dapxsumkbn2( N, alpha, xptr, strideX ) { + return this._instance.exports.stdlib_strided_dapxsumkbn2( N, alpha, xptr, strideX ); // eslint-disable-line max-len +}); + +/** +* Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm and alternative indexing semantics. +* +* @name ndarray +* @memberof Module.prototype +* @readonly +* @type {Function} +* @param {PositiveInteger} N - number of indexed elements +* @param {number} alpha - scalar constant +* @param {NonNegativeInteger} xptr - input array pointer (i.e., byte offset) +* @param {integer} strideX - stride length +* @param {NonNegativeInteger} offsetX - starting index +* @returns {number} sum +* +* @example +* var Memory = require( '@stdlib/wasm/memory' ); +* var oneTo = require( '@stdlib/array/one-to' ); +* +* // 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 dapxsumkbn2 = new Module( mem ); +* // returns +* +* // Initialize the routine: +* dapxsumkbn2.initializeSync(); +* +* // Define a vector data type: +* var dtype = 'float64'; +* +* // Specify a vector length: +* var N = 3; +* +* // Define a pointer (i.e., byte offset) for storing the input vector: +* var xptr = 0; +* +* // Write vector values to module memory: +* dapxsumkbn2.write( xptr, oneTo( N, dtype ) ); +* +* // Perform computation: +* var sum = dapxsumkbn2.ndarray( N, 5.0, xptr, 1, 0 ); +* // returns 21.0 +*/ +setReadOnly( Module.prototype, 'ndarray', function dapxsumkbn2( N, alpha, xptr, strideX, offsetX ) { + return this._instance.exports.stdlib_strided_dapxsumkbn2_ndarray( N, alpha, xptr, strideX, offsetX ); // eslint-disable-line max-len +}); + + +// EXPORTS // + +module.exports = Module; diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/routine.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/routine.js new file mode 100644 index 000000000000..626d4235e8a1 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/routine.js @@ -0,0 +1,168 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +/* eslint-disable max-len, 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 Memory = require( '@stdlib/wasm/memory' ); +var arrays2ptrs = require( '@stdlib/wasm/base/arrays2ptrs' ); +var strided2object = require( '@stdlib/wasm/base/strided2object' ); +var Module = require( './module.js' ); + + +// MAIN // + +/** +* Routine constructor. +* +* @private +* @constructor +* @returns {Routine} routine instance +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* // Create a new routine: +* var dapxsumkbn2 = new Routine(); +* +* // Initialize the module: +* dapxsumkbn2.initializeSync(); +* +* // Define a strided array: +* var x = new Float64Array( [ 1.0, -2.0, 2.0 ] ); +* +* // Perform operation: +* var sum = dapxsumkbn2.main( 3, 5.0, x, 1 ); +* // returns 16.0 +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* // Create a new routine: +* var dapxsumkbn2 = new Routine(); +* +* // Initialize the module: +* dapxsumkbn2.initializeSync(); +* +* // Define a strided array: +* var x = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] ); +* +* // Perform operation: +* var sum = dapxsumkbn2.ndarray( 4, 5.0, x, 2, 1 ); +* // returns 25.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 ); + +/** +* Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm. +* +* @name main +* @memberof Routine.prototype +* @readonly +* @type {Function} +* @param {PositiveInteger} N - number of indexed elements +* @param {number} alpha - scalar constant +* @param {Float64Array} x - input array +* @param {integer} strideX - stride length +* @returns {number} sum +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* // Create a new routine: +* var dapxsumkbn2 = new Routine(); +* +* // Initialize the module: +* dapxsumkbn2.initializeSync(); +* +* // Define a strided array: +* var x = new Float64Array( [ 1.0, -2.0, 2.0 ] ); +* +* // Perform operation: +* var sum = dapxsumkbn2.main( 3, 5.0, x, 1 ); +* // returns 16.0 +*/ +setReadOnly( Routine.prototype, 'main', function dapxsumkbn2( N, alpha, x, strideX ) { + return this.ndarray( N, alpha, x, strideX, stride2offset( N, strideX ) ); +}); + +/** +* Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm and alternative indexing semantics. +* +* @name ndarray +* @memberof Routine.prototype +* @readonly +* @type {Function} +* @param {PositiveInteger} N - number of indexed elements +* @param {number} alpha - scalar constant +* @param {Float64Array} x - input array +* @param {integer} strideX - stride length +* @param {NonNegativeInteger} offsetX - starting index +* @returns {number} sum +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* // Create a new routine: +* var dapxsumkbn2 = new Routine(); +* +* // Initialize the module: +* dapxsumkbn2.initializeSync(); +* +* // Define a strided array: +* var x = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] ); +* +* // Perform operation: +* var sum = dapxsumkbn2.ndarray( 4, 5.0, x, 2, 1 ); +* // returns 25.0 +*/ +setReadOnly( Routine.prototype, 'ndarray', function dapxsumkbn2( N, alpha, x, strideX, offsetX ) { + var ptrs; + var p0; + + // Convert the input arrays to "pointers" in the module's memory: + ptrs = arrays2ptrs( this, [ + strided2object( N, x, strideX, offsetX ) + ]); + p0 = ptrs[ 0 ]; + + // Perform computation by calling the corresponding parent method: + return Module.prototype.ndarray.call( this, N, alpha, p0.ptr, p0.stride, p0.offset ); +}); + + +// EXPORTS // + +module.exports = Routine; diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/manifest.json b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/manifest.json new file mode 100644 index 000000000000..69ca119c4329 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/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/ext/base/dapxsumkbn2" + ] + } + ] +} diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/package.json b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/package.json new file mode 100644 index 000000000000..4f2bda42d5d7 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/package.json @@ -0,0 +1,80 @@ +{ + "name": "@stdlib/blas/base/ext/wasm/dapxsumkbn2", + "version": "0.0.0", + "description": "Add a constant to each double-precision floating-point strided array element and compute the sum using an improved Kahan–Babuška algorithm.", + "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", + "dasum", + "linear", + "algebra", + "subroutines", + "sum", + "vector", + "array", + "ndarray", + "float64", + "double", + "float64array", + "webassembly", + "wasm" + ], + "__stdlib__": { + "wasm": true + } +} diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/build.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/build.js new file mode 100644 index 000000000000..348354d7029c --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/build.js @@ -0,0 +1,63 @@ +#!/usr/bin/env node + +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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' ); + + +// 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}}'; + + +// MAIN // + +/** +* Main execution sequence. +* +* @private +*/ +function main() { + var wasm; + var tmpl; + + wasm = readFile( wpath ); + tmpl = readFile( tpath, opts ); + + tmpl = replace( tmpl, PLACEHOLDER, wasm.toString( 'base64' ) ); + + writeFile( opath, tmpl, opts ); +} + +main(); diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn/lib/binary.browser.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/template.txt similarity index 62% rename from lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn/lib/binary.browser.js rename to lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/template.txt index dd71bedc1dd6..12996dd89e3b 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn/lib/binary.browser.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/template.txt @@ -25,7 +25,7 @@ var base64ToUint8Array = require( '@stdlib/string/base/base64-to-uint8array' ); // MAIN // -var wasm = base64ToUint8Array( 'AGFzbQEAAAAADwhkeWxpbmsuMAEEAAAAAAEVA2AAAGAEf3x/fwF8YAV/fH9/fwF8Ag8BA2VudgZtZW1vcnkCAAADBAMAAQIHVQMRX193YXNtX2NhbGxfY3RvcnMAABlzdGRsaWJfc3RyaWRlZF9kYXB4c3Vta2JuAAEhc3RkbGliX3N0cmlkZWRfZGFweHN1bWtibl9uZGFycmF5AAIKqQEDAwABCxwAIAAgASACIANBASAAayADbEEAIANBAEwbEAILhQECA3wBfyAAQQBMBEBEAAAAAAAAAAAPCyADBEADQCAAIAhGRQRAIAUgASACIARBA3RqKwMAoCIFIAYgBiAFoCIHoaAgBiAFIAehoCAGmSAFmWYboCEFIAhBAWohCCADIARqIQQgByEGDAELCyAGIAWgDwsgASACIARBA3RqKwMAoCAAuKIL' ); +var wasm = base64ToUint8Array( '{{WASM_BASE64}}' ); // EXPORTS // diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/src/Makefile b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/src/Makefile new file mode 100644 index 000000000000..1b1f35347760 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/src/Makefile @@ -0,0 +1,243 @@ +#/ +# @license Apache-2.0 +# +# Copyright (c) 2025 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) + +#/ +# 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/ext/base/wasm/dapxsumkbn2/src/exports.json b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/src/exports.json new file mode 100644 index 000000000000..33e62e68a389 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/src/exports.json @@ -0,0 +1,4 @@ +[ + "_stdlib_strided_dapxsumkbn2", + "_stdlib_strided_dapxsumkbn2_ndarray" +] diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.js new file mode 100644 index 000000000000..a50020a09b11 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.js @@ -0,0 +1,53 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 dapxsumkbn2 = require( './../lib' ); + + +// TESTS // + +tape( 'main export is an object', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof dapxsumkbn2, 'object', 'returns expected value' ); + t.end(); +}); + +tape( 'attached to the main export is a `main` method', function test( t ) { + t.strictEqual( typeof dapxsumkbn2.main, 'function', 'returns expected value' ); + t.end(); +}); + +tape( 'attached to the main export is an `ndarray` method', function test( t ) { + t.strictEqual( typeof dapxsumkbn2.ndarray, 'function', 'returns expected value' ); + t.end(); +}); + +tape( 'attached to the main export is a `Module` constructor', function test( t ) { + t.strictEqual( typeof dapxsumkbn2.Module, 'function', 'returns expected value' ); + t.end(); +}); + +tape( 'the main export is a `Module` instance', function test( t ) { + t.strictEqual( dapxsumkbn2 instanceof dapxsumkbn2.Module, true, 'returns expected value' ); + t.end(); +}); diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.main.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.main.js new file mode 100644 index 000000000000..d6440f85d3c7 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.main.js @@ -0,0 +1,172 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 isnan = require( '@stdlib/math/base/assert/is-nan' ); +var Float64Array = require( '@stdlib/array/float64' ); +var dapxsumkbn2 = require( './../lib' ); + + +// TESTS // + +tape( 'main export is an object', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof dapxsumkbn2, 'object', 'main export is an object' ); + t.end(); +}); + +tape( 'the `main` method has an arity of 4', function test( t ) { + t.strictEqual( dapxsumkbn2.main.length, 4, 'returns expected value' ); + t.end(); +}); + +tape( 'the `main` method adds a constant and calculates the sum of all strided array elements', function test( t ) { + var x; + var v; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0, 0.0, -3.0, 3.0 ] ); + v = dapxsumkbn2.main( x.length, 5.0, x, 1 ); + t.strictEqual( v, 48.0, 'returns expected value' ); + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ] ); + v = dapxsumkbn2.main( x.length, 5.0, x, 1 ); + t.strictEqual( v, 33.0, 'returns expected value' ); + + x = new Float64Array( [ -4.0, -4.0 ] ); + v = dapxsumkbn2.main( x.length, 5.0, x, 1 ); + t.strictEqual( v, 2.0, 'returns expected value' ); + + x = new Float64Array( [ NaN, 4.0 ] ); + v = dapxsumkbn2.main( x.length, 5.0, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( [ 1.0, 1e100, 1.0, -1.0e100 ] ); + v = dapxsumkbn2.main( x.length, 5.0, x, 1 ); + t.strictEqual( v, 12.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter less than or equal to `0`, the `main` method returns `0.0`', function test( t ) { + var x; + var v; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dapxsumkbn2.main( 0, 5.0, x, 1 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + v = dapxsumkbn2.main( -1, 5.0, x, 1 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter equal to `1`, the `main` method returns the first element plus a constant', function test( t ) { + var x; + var v; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dapxsumkbn2.main( 1, 5.0, x, 1 ); + t.strictEqual( v, 6.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the `main` method supports a `stride` parameter', function test( t ) { + var x; + var v; + + x = new Float64Array([ + 1.0, // 0 + 2.0, + 2.0, // 1 + -7.0, + -2.0, // 2 + 3.0, + 4.0, // 3 + 2.0 + ]); + + v = dapxsumkbn2.main( 4, 5.0, x, 2 ); + + t.strictEqual( v, 25.0, 'returns expected value' ); + t.end(); +}); + +tape( 'the `main` method supports a negative `stride` parameter', function test( t ) { + var x; + var v; + + x = new Float64Array([ + 1.0, // 3 + 2.0, + 2.0, // 2 + -7.0, + -2.0, // 1 + 3.0, + 4.0, // 0 + 2.0 + ]); + + v = dapxsumkbn2.main( 4, 5.0, x, -2 ); + + t.strictEqual( v, 25.0, 'returns expected value' ); + t.end(); +}); + +tape( 'if provided a `stride` parameter equal to `0`, the `main` method returns the first element plus a constant repeated N times', function test( t ) { + var x; + var v; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dapxsumkbn2.main( x.length, 5.0, x, 0 ); + + t.strictEqual( v, x.length * (x[0]+5.0), 'returns expected value' ); + t.end(); +}); + +tape( 'the `main` method supports view offsets', function test( t ) { + var x0; + var x1; + var v; + + x0 = new Float64Array([ + 2.0, + 1.0, // 0 + 2.0, + -2.0, // 1 + -2.0, + 2.0, // 2 + 3.0, + 4.0, // 3 + 6.0 + ]); + + x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element + v = dapxsumkbn2.main( 4, 5.0, x1, 2 ); + t.strictEqual( v, 25.0, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.js new file mode 100644 index 000000000000..9adcb07e22fa --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.js @@ -0,0 +1,154 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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/ext/base/wasm/dapxsumkbn2/test/test.module.main.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.main.js new file mode 100644 index 000000000000..a1e7af7e8363 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.main.js @@ -0,0 +1,208 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 node/no-sync */ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var Memory = require( '@stdlib/wasm/memory' ); +var Float64Array = require( '@stdlib/array/float64' ); +var Module = require( './../lib' ).Module; + + +// 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 4', function test( t ) { + var mem; + var mod; + + mem = new Memory({ + 'initial': 0 + }); + mod = new Module( mem ); + t.strictEqual( mod.main.length, 4, 'returns expected value' ); + t.end(); +}); + +tape( 'a module instance has a `main` method adds a constant and calculates the sum of all strided array elements', function test( t ) { + var mem; + var mod; + var xp; + var y; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + xp = 0; + + mod.write( xp, new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ] ) ); + + y = mod.main( 6, 5.0, xp, 1 ); + t.strictEqual( y, 33.0, '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 returns `0.0`', function test( t ) { + var mem; + var mod; + var xp; + var y; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + xp = 0; + + mod.write( xp, new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ) ); + + y = mod.main( 0, 5.0, xp, 1 ); + t.strictEqual( y, 0.0, 'returns expected value' ); + + y = mod.main( -1, 5.0, xp, 1 ); + t.strictEqual( y, 0.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter equal to `1`, a module instance has a `main` method which returns the first element plus a constant', function test( t ) { + var mem; + var mod; + var xp; + var y; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + xp = 0; + + mod.write( xp, new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ) ); + + y = mod.main( 1, 5.0, xp, 1 ); + t.strictEqual( y, 6.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'a module instance has a `main` method which supports a `stride` parameter', function test( t ) { + var mem; + var mod; + var xp; + var y; + var N; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + xp = 0; + + mod.write( xp, new Float64Array([ + 1.0, // 0 + 2.0, + 2.0, // 1 + -7.0, + -2.0, // 2 + 3.0, + 4.0, // 3 + 2.0 + ])); + N = 4; + + y = mod.main( N, 5.0, xp, 2 ); + t.strictEqual( y, 25.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'a module instance has a `main` method which supports a negative `stride` parameter', function test( t ) { + var mem; + var mod; + var xp; + var y; + var N; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + xp = 0; + + mod.write( xp, new Float64Array([ + 1.0, // 3 + 2.0, + 2.0, // 2 + -7.0, + -2.0, // 1 + 3.0, + 4.0, // 0 + 2.0 + ])); + N = 4; + + y = mod.main( N, 5.0, xp, -2 ); + t.strictEqual( y, 25.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided a `stride` parameter equal to `0`, a module instance has a `main` method returns the first element plus a constant repeated N times', function test( t ) { + var mem; + var mod; + var xp; + var y; + var N; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + xp = 0; + + mod.write( xp, new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ) ); + N = 5; + + y = mod.main( N, 5.0, xp, 0 ); + t.strictEqual( y, 30.0, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.ndarray.js new file mode 100644 index 000000000000..59cd4204a5f9 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.ndarray.js @@ -0,0 +1,241 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 node/no-sync */ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var Memory = require( '@stdlib/wasm/memory' ); +var Float64Array = require( '@stdlib/array/float64' ); +var Module = require( './../lib' ).Module; + + +// 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 5', function test( t ) { + var mem; + var mod; + + mem = new Memory({ + 'initial': 0 + }); + mod = new Module( mem ); + t.strictEqual( mod.ndarray.length, 5, 'returns expected value' ); + t.end(); +}); + +tape( 'a module instance has an `ndarray` method which adds a constant and calculates the sum of all strided array elements', function test( t ) { + var mem; + var mod; + var xp; + var y; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + xp = 0; + + mod.write( xp, new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ] ) ); + + y = mod.ndarray( 6, 5.0, xp, 1, 0 ); + t.strictEqual( y, 33.0, '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 returns `0.0`', function test( t ) { + var mem; + var mod; + var xp; + var y; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + xp = 0; + + mod.write( xp, new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ) ); + + y = mod.ndarray( 0, 5.0, xp, 1, 0 ); + t.strictEqual( y, 0.0, 'returns expected value' ); + + y = mod.ndarray( -1, 5.0, xp, 1, 0 ); + t.strictEqual( y, 0.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter equal to `1`, a module instance has an `ndarray` method which returns the first indexed element plus a constant', function test( t ) { + var mem; + var mod; + var xp; + var y; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + xp = 0; + + mod.write( xp, new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ) ); + + y = mod.ndarray( 1, 5.0, xp, 1, 0 ); + t.strictEqual( y, 6.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'a module instance has an `ndarray` method which supports a `stride` parameter', function test( t ) { + var mem; + var mod; + var xp; + var y; + var N; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + xp = 0; + + mod.write( xp, new Float64Array([ + 1.0, // 0 + 2.0, + 2.0, // 1 + -7.0, + -2.0, // 2 + 3.0, + 4.0, // 3 + 2.0 + ])); + N = 4; + + y = mod.ndarray( N, 5.0, xp, 2, 0 ); + t.strictEqual( y, 25.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'a module instance has an `ndarray` method which supports a negative `stride` parameter', function test( t ) { + var mem; + var mod; + var xp; + var y; + var N; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + xp = 0; + + mod.write( xp, new Float64Array([ + 1.0, // 3 + 2.0, + 2.0, // 2 + -7.0, + -2.0, // 1 + 3.0, + 4.0, // 0 + 2.0 + ])); + N = 4; + + y = mod.ndarray( N, 5.0, xp, -2, 6 ); + t.strictEqual( y, 25.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided a `stride` parameter equal to `0`, a module instance has an `ndarray` method which returns the first element plus a constant repeated N times', function test( t ) { + var mem; + var mod; + var xp; + var y; + var N; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + xp = 0; + + mod.write( xp, new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ) ); + N = 5; + + y = mod.ndarray( N, 5.0, xp, 0, 0 ); + t.strictEqual( y, 30.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'a module instance has an `ndarray` method which supports an `offset` parameter', function test( t ) { + var mem; + var mod; + var xp; + var y; + var N; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + xp = 0; + + mod.write( xp, new Float64Array([ + 2.0, + 1.0, // 0 + 2.0, + -2.0, // 1 + -2.0, + 2.0, // 2 + 3.0, + 4.0 // 3 + ])); + N = 4; + + y = mod.ndarray( N, 5.0, xp, 2, 1 ); + t.strictEqual( y, 25.0, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.ndarray.js new file mode 100644 index 000000000000..2e90adbb75f1 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.ndarray.js @@ -0,0 +1,169 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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 isnan = require( '@stdlib/math/base/assert/is-nan' ); +var Float64Array = require( '@stdlib/array/float64' ); +var dapxsumkbn2 = require( './../lib' ); + + +// TESTS // + +tape( 'main export is an object', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof dapxsumkbn2, 'object', 'main export is an object' ); + t.end(); +}); + +tape( 'the `ndarray` method has an arity of 5', function test( t ) { + t.strictEqual( dapxsumkbn2.ndarray.length, 5, 'returns expected value' ); + t.end(); +}); + +tape( 'the `ndarray` method adds a constant and calculates the sum of all strided array elements', function test( t ) { + var x; + var v; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0, 0.0, -3.0, 3.0 ] ); + v = dapxsumkbn2.ndarray( x.length, 5.0, x, 1, 0 ); + t.strictEqual( v, 48.0, 'returns expected value' ); + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ] ); + v = dapxsumkbn2.ndarray( x.length, 5.0, x, 1, 0 ); + t.strictEqual( v, 33.0, 'returns expected value' ); + + x = new Float64Array( [ -4.0, -4.0 ] ); + v = dapxsumkbn2.ndarray( x.length, 5.0, x, 1, 0 ); + t.strictEqual( v, 2.0, 'returns expected value' ); + + x = new Float64Array( [ NaN, 4.0 ] ); + v = dapxsumkbn2.ndarray( x.length, 5.0, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( [ 1.0, 1.0e100, 1.0, -1.0e100 ] ); + v = dapxsumkbn2.ndarray( x.length, 5.0, x, 1, 0 ); + t.strictEqual( v, 12.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter less than or equal to `0`, the `ndarray` method returns `0.0`', function test( t ) { + var x; + var v; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dapxsumkbn2.ndarray( 0, 5.0, x, 1, 0 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + v = dapxsumkbn2.ndarray( -1, 5.0, x, 1, 0 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter equal to `1`, the `ndarray` method returns the first indexed element plus a constant', function test( t ) { + var x; + var v; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dapxsumkbn2.ndarray( 1, 5.0, x, 1, 0 ); + t.strictEqual( v, 6.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the `ndarray` method supports a `stride` parameter', function test( t ) { + var x; + var v; + + x = new Float64Array([ + 1.0, // 0 + 2.0, + 2.0, // 1 + -7.0, + -2.0, // 2 + 3.0, + 4.0, // 3 + 2.0 + ]); + + v = dapxsumkbn2.ndarray( 4, 5.0, x, 2, 0 ); + + t.strictEqual( v, 25.0, 'returns expected value' ); + t.end(); +}); + +tape( 'the `ndarray` method supports a negative `stride` parameter', function test( t ) { + var x; + var v; + + x = new Float64Array([ + 1.0, // 3 + 2.0, + 2.0, // 2 + -7.0, + -2.0, // 1 + 3.0, + 4.0, // 0 + 2.0 + ]); + + v = dapxsumkbn2.ndarray( 4, 5.0, x, -2, 6 ); + + t.strictEqual( v, 25.0, 'returns expected value' ); + t.end(); +}); + +tape( 'if provided a `stride` parameter equal to `0`, the `ndarray` method returns the first element plus a constant repeated N times', function test( t ) { + var x; + var v; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dapxsumkbn2.ndarray( x.length, 5.0, x, 0, 0 ); + t.strictEqual( v, x.length * (x[0]+5.0), 'returns expected value' ); + + t.end(); +}); + +tape( 'the `ndarray` method supports an `offset` parameter', function test( t ) { + var x; + var v; + + x = new Float64Array([ + 2.0, + 1.0, // 0 + 2.0, + -2.0, // 1 + -2.0, + 2.0, // 2 + 3.0, + 4.0 // 3 + ]); + + v = dapxsumkbn2.ndarray( 4, 5.0, x, 2, 1 ); + t.strictEqual( v, 25.0, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.routine.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.routine.js new file mode 100644 index 000000000000..56a4b67daaf0 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.routine.js @@ -0,0 +1,71 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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(); +}); From 464504b4fce54ce253cd9d4564d9bf397ced7029 Mon Sep 17 00:00:00 2001 From: JoyBoy <144602492+0PrashantYadav0@users.noreply.github.com> Date: Sat, 1 Mar 2025 17:29:58 +0530 Subject: [PATCH 02/10] feat: reverted unwanted changes --- type: pre_push_report description: Results of running various checks prior to pushing changes. report: - task: run_javascript_examples status: na - task: run_c_examples status: na - task: run_cpp_examples status: na - task: run_javascript_readme_examples status: na - task: run_c_benchmarks status: na - task: run_cpp_benchmarks status: na - task: run_fortran_benchmarks status: na - task: run_javascript_benchmarks status: na - task: run_julia_benchmarks status: na - task: run_python_benchmarks status: na - task: run_r_benchmarks status: na - task: run_javascript_tests status: na --- --- .../wasm/dapxsumkbn/lib/binary.browser.js | 33 +++++ .../ext/base/wasm/dapxsumkbn/src/main.wasm | Bin 0 -> 330 bytes .../ext/base/wasm/dapxsumkbn/src/main.wat | 118 ++++++++++++++++++ 3 files changed, 151 insertions(+) create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn/lib/binary.browser.js create mode 100755 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn/src/main.wasm create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn/src/main.wat diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn/lib/binary.browser.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn/lib/binary.browser.js new file mode 100644 index 000000000000..dd71bedc1dd6 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn/lib/binary.browser.js @@ -0,0 +1,33 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 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( 'AGFzbQEAAAAADwhkeWxpbmsuMAEEAAAAAAEVA2AAAGAEf3x/fwF8YAV/fH9/fwF8Ag8BA2VudgZtZW1vcnkCAAADBAMAAQIHVQMRX193YXNtX2NhbGxfY3RvcnMAABlzdGRsaWJfc3RyaWRlZF9kYXB4c3Vta2JuAAEhc3RkbGliX3N0cmlkZWRfZGFweHN1bWtibl9uZGFycmF5AAIKqQEDAwABCxwAIAAgASACIANBASAAayADbEEAIANBAEwbEAILhQECA3wBfyAAQQBMBEBEAAAAAAAAAAAPCyADBEADQCAAIAhGRQRAIAUgASACIARBA3RqKwMAoCIFIAYgBiAFoCIHoaAgBiAFIAehoCAGmSAFmWYboCEFIAhBAWohCCADIARqIQQgByEGDAELCyAGIAWgDwsgASACIARBA3RqKwMAoCAAuKIL' ); + + +// EXPORTS // + +module.exports = wasm; diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn/src/main.wasm b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn/src/main.wasm new file mode 100755 index 0000000000000000000000000000000000000000..a8ad820a853c22ea072eec06b1c185d49f09874c GIT binary patch literal 330 zcmZ{ey-LJT5QS&%+-!nZh!z&I7L#oS@evYGD_iTE?A{3ZT}k3kAdt$3*e=@n20orQ zLF}9<&N&R{V<2fO1UtTG`ZBAFt80{V#xsfmVmS`uh(qkmYK`!b()wjprPaRa1pr9` z6z&6^YW-?qdY6=?-gWz?1vqazQ)XM;c1>ndqfPSk);?FowgwFTz3JK{O_TH>j=qpA zUR?kKBMYVo849K{0_)*^eInF53L0=^uvvyT@H@U@k|Bk*>D}GRke!7fBkJ-?f@$OM v%C0kQ+>dECyy$_Q!{d4i9QGp21CNPi9!PeB)iElyG%R|4<`2d2{i%Kck3vWf literal 0 HcmV?d00001 diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn/src/main.wat b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn/src/main.wat new file mode 100644 index 000000000000..8deb825dec00 --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn/src/main.wat @@ -0,0 +1,118 @@ +;; @license Apache-2.0 +;; +;; Copyright (c) 2024 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 f64 i32 i32) (result f64))) + (type (;2;) (func (param i32 f64 i32 i32 i32) (result f64))) + (import "env" "memory" (memory (;0;) 0)) + (func (;0;) (type 0) + nop) + (func (;1;) (type 1) (param i32 f64 i32 i32) (result f64) + local.get 0 + local.get 1 + local.get 2 + local.get 3 + i32.const 1 + local.get 0 + i32.sub + local.get 3 + i32.mul + i32.const 0 + local.get 3 + i32.const 0 + i32.le_s + select + call 2) + (func (;2;) (type 2) (param i32 f64 i32 i32 i32) (result f64) + (local f64 f64 f64 i32) + local.get 0 + i32.const 0 + i32.le_s + if ;; label = @1 + f64.const 0x0p+0 (;=0;) + return + end + local.get 3 + if ;; label = @1 + loop ;; label = @2 + local.get 0 + local.get 8 + i32.eq + i32.eqz + if ;; label = @3 + local.get 5 + local.get 1 + local.get 2 + local.get 4 + i32.const 3 + i32.shl + i32.add + f64.load + f64.add + local.tee 5 + local.get 6 + local.get 6 + local.get 5 + f64.add + local.tee 7 + f64.sub + f64.add + local.get 6 + local.get 5 + local.get 7 + f64.sub + f64.add + local.get 6 + f64.abs + local.get 5 + f64.abs + f64.ge + select + f64.add + local.set 5 + local.get 8 + i32.const 1 + i32.add + local.set 8 + local.get 3 + local.get 4 + i32.add + local.set 4 + local.get 7 + local.set 6 + br 1 (;@2;) + end + end + local.get 6 + local.get 5 + f64.add + return + end + local.get 1 + local.get 2 + local.get 4 + i32.const 3 + i32.shl + i32.add + f64.load + f64.add + local.get 0 + f64.convert_i32_u + f64.mul) + (export "__wasm_call_ctors" (func 0)) + (export "stdlib_strided_dapxsumkbn" (func 1)) + (export "stdlib_strided_dapxsumkbn_ndarray" (func 2))) From 99c613456c389053c59949da76ad4cfcddb7638b Mon Sep 17 00:00:00 2001 From: JoyBoy <144602492+0PrashantYadav0@users.noreply.github.com> Date: Sat, 1 Mar 2025 17:33:26 +0530 Subject: [PATCH 03/10] chore: add package.json --- .../blas/ext/base/wasm/dapxsumkbn2/package.json | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/package.json b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/package.json index 4f2bda42d5d7..675ebf9dc60d 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/package.json +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/package.json @@ -1,7 +1,7 @@ { "name": "@stdlib/blas/base/ext/wasm/dapxsumkbn2", "version": "0.0.0", - "description": "Add a constant to each double-precision floating-point strided array element and compute the sum using an improved Kahan–Babuška algorithm.", + "description": "Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm.", "license": "Apache-2.0", "author": { "name": "The Stdlib Authors", @@ -56,18 +56,19 @@ "keywords": [ "stdlib", "stdmath", + "statistics", + "stats", "mathematics", "math", "blas", - "level 1", - "dasum", - "linear", - "algebra", - "subroutines", + "extended", "sum", - "vector", + "total", + "summation", + "strided", + "strided array", + "typed", "array", - "ndarray", "float64", "double", "float64array", From cee7aedb23cc3207b9b1e8f86f5272882d01c9e9 Mon Sep 17 00:00:00 2001 From: JoyBoy <144602492+0PrashantYadav0@users.noreply.github.com> Date: Sat, 1 Mar 2025 19:19:15 +0530 Subject: [PATCH 04/10] chore: add benchmark and docs --- .../blas/ext/base/dnansumkbn2/manifest.json | 23 +- .../blas/ext/base/wasm/dapxsumkbn2/README.md | 10 +- .../wasm/dapxsumkbn2/benchmark/benchmark.js | 4 +- .../dapxsumkbn2/benchmark/benchmark.module.js | 4 +- .../benchmark/benchmark.module.main.js | 4 +- .../benchmark/benchmark.module.ndarray.js | 4 +- .../benchmark/benchmark.ndarray.js | 4 +- .../ext/base/wasm/dapxsumkbn2/docs/repl.txt | 10 +- .../wasm/dapxsumkbn2/docs/types/index.d.ts | 36 +-- .../base/wasm/dapxsumkbn2/docs/types/test.ts | 220 +++++++++--------- .../base/wasm/dapxsumkbn2/examples/index.js | 4 +- .../examples/little_endian_arrays.js | 4 +- .../base/wasm/dapxsumkbn2/examples/module.js | 4 +- 13 files changed, 176 insertions(+), 155 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/manifest.json b/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/manifest.json index 57e9af5c51e3..d4a221b0f283 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/manifest.json +++ b/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/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" ], @@ -49,6 +51,7 @@ }, { "task": "benchmark", + "wasm": false, "src": [ "./src/main.c" ], @@ -66,6 +69,24 @@ }, { "task": "examples", + "wasm": false, + "src": [ + "./src/main.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/math/base/special/abs", + "@stdlib/blas/base/shared", + "@stdlib/strided/base/stride2offset" + ] + }, + { + "task": "build", + "wasm": true, "src": [ "./src/main.c" ], diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/README.md b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/README.md index d978bebad3aa..f3449ef74196 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/README.md +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/README.md @@ -20,7 +20,7 @@ limitations under the License. # dapxsumkbn2 -> Add a scalar constant to each double-precision floating-point strided array element and compute the sum using an improved Kahan–Babuška algorithm. +> Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm.
@@ -32,7 +32,7 @@ var dapxsumkbn2 = require( '@stdlib/blas/ext/base/wasm/dapxsumkbn2' ); #### dapxsumkbn2.main( N, alpha, x, strideX ) -Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm. +Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm. ```javascript var Float64Array = require( '@stdlib/array/float64' ); @@ -77,7 +77,7 @@ var sum = dapxsumkbn2.main( 4, 5.0, x1, 2 ); #### dapxsumkbn2.ndarray( N, alpha, x, strideX, offsetX ) -Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm and alternative indexing semantics. +Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm and alternative indexing semantics. ```javascript var Float64Array = require( '@stdlib/array/float64' ); @@ -132,7 +132,7 @@ mod.initializeSync(); #### dapxsumkbn2.Module.prototype.main( N, alpha, xp, sx ) -Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm. +Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm. @@ -180,7 +180,7 @@ The function has the following parameters: #### dapxsumkbn2.Module.prototype.ndarray( N, alpha, xp, sx, ox ) -Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm and alternative indexing semantics. +Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm and alternative indexing semantics. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.js index b10ac5d3b102..3bdec8939cdc 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.js @@ -26,7 +26,7 @@ var uniform = require( '@stdlib/random/array/uniform' ); var isnan = require( '@stdlib/math/base/assert/is-nan' ); var pow = require( '@stdlib/math/base/special/pow' ); var pkg = require( './../package.json' ).name; -var dapxsumkbn = require( './../lib' ); +var dapxsumkbn2 = require( './../lib' ); // VARIABLES // @@ -64,7 +64,7 @@ function createBenchmark( len ) { b.tic(); for ( i = 0; i < b.iterations; i++ ) { - sum = dapxsumkbn.main( x.length, 5.0, x, 1 ); + sum = dapxsumkbn2.main( x.length, 5.0, x, 1 ); if ( isnan( sum ) ) { b.fail( 'should not return NaN' ); } diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.js index 1110f8893ccd..298c635d1e6b 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.js @@ -24,7 +24,7 @@ var bench = require( '@stdlib/bench' ); var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' ); var Memory = require( '@stdlib/wasm/memory' ); var pkg = require( './../package.json' ).name; -var dapxsumkbn = require( './../lib' ); +var dapxsumkbn2 = require( './../lib' ); // VARIABLES // @@ -52,7 +52,7 @@ bench( pkg+':Module:constructor', opts, function benchmark( b ) { b.tic(); for ( i = 0; i < b.iterations; i++ ) { - v = new dapxsumkbn.Module( values[ i%values.length ] ); + v = new dapxsumkbn2.Module( values[ i%values.length ] ); if ( typeof v !== 'object' ) { b.fail( 'should return an object' ); } diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.main.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.main.js index 7463536cf3fa..3fb098f42e76 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.main.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.main.js @@ -28,7 +28,7 @@ var uniform = require( '@stdlib/random/array/uniform' ); var isnan = require( '@stdlib/math/base/assert/is-nan' ); var pow = require( '@stdlib/math/base/special/pow' ); var pkg = require( './../package.json' ).name; -var dapxsumkbn = require( './../lib' ); +var dapxsumkbn2 = require( './../lib' ); // VARIABLES // @@ -71,7 +71,7 @@ function createBenchmark( len ) { mem = new Memory({ 'initial': 0 }); - mod = new dapxsumkbn.Module( mem ); + mod = new dapxsumkbn2.Module( mem ); // Initialize the module: mod.initializeSync(); // eslint-disable-line node/no-sync diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.ndarray.js index 1530dc8217fc..efab5db62bb3 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.ndarray.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.ndarray.js @@ -28,7 +28,7 @@ var uniform = require( '@stdlib/random/array/uniform' ); var isnan = require( '@stdlib/math/base/assert/is-nan' ); var pow = require( '@stdlib/math/base/special/pow' ); var pkg = require( './../package.json' ).name; -var dapxsumkbn = require( './../lib' ); +var dapxsumkbn2 = require( './../lib' ); // VARIABLES // @@ -71,7 +71,7 @@ function createBenchmark( len ) { mem = new Memory({ 'initial': 0 }); - mod = new dapxsumkbn.Module( mem ); + mod = new dapxsumkbn2.Module( mem ); // Initialize the module: mod.initializeSync(); // eslint-disable-line node/no-sync diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.ndarray.js index 32ccd8d59bbf..52bc3c54775c 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.ndarray.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.ndarray.js @@ -26,7 +26,7 @@ var uniform = require( '@stdlib/random/array/uniform' ); var isnan = require( '@stdlib/math/base/assert/is-nan' ); var pow = require( '@stdlib/math/base/special/pow' ); var pkg = require( './../package.json' ).name; -var dapxsumkbn = require( './../lib' ); +var dapxsumkbn2 = require( './../lib' ); // VARIABLES // @@ -64,7 +64,7 @@ function createBenchmark( len ) { b.tic(); for ( i = 0; i < b.iterations; i++ ) { - sum = dapxsumkbn.ndarray( x.length, 5.0, x, 1, 0 ); + sum = dapxsumkbn2.ndarray( x.length, 5.0, x, 1, 0 ); if ( isnan( sum ) ) { b.fail( 'should not return NaN' ); } diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/repl.txt b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/repl.txt index 92a6b5e7098d..c2260a15a6cc 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/repl.txt +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/repl.txt @@ -1,8 +1,8 @@ {{alias}}.main( N, alpha, x, strideX ) Adds a scalar constant to each double-precision floating-point strided - array element and computes the sum using an improved Kahan–Babuška - algorithm. + array element and computes the sum using a second-order iterative + Kahan–Babuška algorithm. The `N` and stride parameters determine which elements in the strided array are accessed at runtime. @@ -51,9 +51,9 @@ {{alias}}.ndarray( N, alpha, x, strideX, offsetX ) - Adds a scalar constant to each double-precision floating-point strided array - element and computes the sum using an improved Kahan–Babuška algorithm and - alternative indexing semantics. + Adds a scalar constant to each double-precision floating-point strided + array element and computes the sum using a second-order iterative + Kahan–Babuška algorithm and alternative indexing semantics. While typed array views mandate a view offset based on the underlying buffer, the offset parameter supports indexing semantics based on a starting diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/index.d.ts index 5f59f38e9248..bb782515ac57 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/index.d.ts @@ -43,7 +43,7 @@ interface ModuleConstructor { * }); * * // Create a BLAS routine: - * var mod = new dapxsumkbn.Module( mem ); + * var mod = new dapxsumkbn2.Module( mem ); * // returns * * // Initialize the routine: @@ -84,7 +84,7 @@ interface ModuleConstructor { * }); * * // Create a BLAS routine: - * var mod = dapxsumkbn.Module( mem ); + * var mod = dapxsumkbn2.Module( mem ); * // returns * * // Initialize the routine: @@ -110,11 +110,11 @@ interface ModuleConstructor { } /** -* Interface describing a `dapxsumkbn` WebAssembly module. +* Interface describing a `dapxsumkbn2` WebAssembly module. */ interface Module extends ModuleWrapper { /** - * Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm. + * Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm. * * @param N - number of indexed elements * @param alpha - scalar constant @@ -133,7 +133,7 @@ interface Module extends ModuleWrapper { * }); * * // Create a BLAS routine: - * var mod = new dapxsumkbn.Module( mem ); + * var mod = new dapxsumkbn2.Module( mem ); * // returns * * // Initialize the routine: @@ -158,7 +158,7 @@ interface Module extends ModuleWrapper { main( N: number, alpha: number, xptr: number, strideX: number ): number; /** - * Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm and alternative indexing semantics. + * Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm and alternative indexing semantics. * * @param N - number of indexed elements * @param alpha - scalar constant @@ -178,7 +178,7 @@ interface Module extends ModuleWrapper { * }); * * // Create a BLAS routine: - * var mod = new dapxsumkbn.Module( mem ); + * var mod = new dapxsumkbn2.Module( mem ); * // returns * * // Initialize the routine: @@ -204,11 +204,11 @@ interface Module extends ModuleWrapper { } /** -* Interface describing `dapxsumkbn`. +* Interface describing `dapxsumkbn2`. */ interface Routine extends ModuleWrapper { /** - * Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm. + * Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm. * * @param N - number of indexed elements * @param alpha - scalar constant @@ -221,13 +221,13 @@ interface Routine extends ModuleWrapper { * * var x = new Float64Array( [ 1.0, -2.0, 2.0 ] ); * - * var out = dapxsumkbn.main( 3, 5.0, x, 1 ); + * var out = dapxsumkbn2.main( 3, 5.0, x, 1 ); * // returns 16.0 */ main( N: number, alpha: number, x: Float64Array, strideX: number ): number; /** - * Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm and alternative indexing semantics. + * Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm and alternative indexing semantics. * * @param N - number of indexed elements * @param alpha - scalar constant @@ -241,7 +241,7 @@ interface Routine extends ModuleWrapper { * * var x = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] ); * - * var out = dapxsumkbn.ndarray( 4, 5.0, x, 2, 1 ); + * var out = dapxsumkbn2.ndarray( 4, 5.0, x, 2, 1 ); * // returns 25.0 */ ndarray( N: number, alpha: number, x: Float64Array, strideX: number, offsetX: number ): number; @@ -263,7 +263,7 @@ interface Routine extends ModuleWrapper { * }); * * // Create a BLAS routine: - * var mod = new dapxsumkbn.Module( mem ); + * var mod = new dapxsumkbn2.Module( mem ); * // returns * * // Initialize the routine: @@ -289,7 +289,7 @@ interface Routine extends ModuleWrapper { } /** -* Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using an improved Kahan–Babuška algorithm. +* Adds a scalar constant to each double-precision floating-point strided array element and computes the sum using a second-order iterative Kahan–Babuška algorithm. * * @param N - number of indexed elements * @param alpha - scalar constant @@ -302,7 +302,7 @@ interface Routine extends ModuleWrapper { * * var x = new Float64Array( [ 1.0, -2.0, 2.0 ] ); * -* var out = dapxsumkbn.main( 3, 5.0, x, 1 ); +* var out = dapxsumkbn2.main( 3, 5.0, x, 1 ); * // returns 16.0 * * @example @@ -310,12 +310,12 @@ interface Routine extends ModuleWrapper { * * var x = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] ); * -* var out = dapxsumkbn.ndarray( 4, 5.0, x, 2, 1 ); +* var out = dapxsumkbn2.ndarray( 4, 5.0, x, 2, 1 ); * // returns 25.0 */ -declare var dapxsumkbn: Routine; +declare var dapxsumkbn2: Routine; // EXPORTS // -export = dapxsumkbn; +export = dapxsumkbn2; diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/test.ts b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/test.ts index f103259c71e9..ef3ea2786e68 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/test.ts +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/test.ts @@ -19,7 +19,7 @@ /* eslint-disable space-in-parens */ import Memory = require( '@stdlib/wasm/memory' ); -import dapxsumkbn = require( './index' ); +import dapxsumkbn2 = require( './index' ); // TESTS // @@ -28,165 +28,165 @@ import dapxsumkbn = require( './index' ); { const x = new Float64Array( 10 ); - dapxsumkbn.main( x.length, 5.0, x, 1 ); // $ExpectType number + dapxsumkbn2.main( x.length, 5.0, x, 1 ); // $ExpectType number } // The compiler throws an error if the `main` method is provided a first argument which is not a number... { const x = new Float64Array( 10 ); - dapxsumkbn.main( '10', 5.0, x, 1 ); // $ExpectError - dapxsumkbn.main( true, 5.0, x, 1 ); // $ExpectError - dapxsumkbn.main( false, 5.0, x, 1 ); // $ExpectError - dapxsumkbn.main( null, 5.0, x, 1 ); // $ExpectError - dapxsumkbn.main( undefined, 5.0, x, 1 ); // $ExpectError - dapxsumkbn.main( [], 5.0, x, 1 ); // $ExpectError - dapxsumkbn.main( {}, 5.0, x, 1 ); // $ExpectError - dapxsumkbn.main( ( x: number ): number => x, 5.0, x, 1 ); // $ExpectError + dapxsumkbn2.main( '10', 5.0, x, 1 ); // $ExpectError + dapxsumkbn2.main( true, 5.0, x, 1 ); // $ExpectError + dapxsumkbn2.main( false, 5.0, x, 1 ); // $ExpectError + dapxsumkbn2.main( null, 5.0, x, 1 ); // $ExpectError + dapxsumkbn2.main( undefined, 5.0, x, 1 ); // $ExpectError + dapxsumkbn2.main( [], 5.0, x, 1 ); // $ExpectError + dapxsumkbn2.main( {}, 5.0, x, 1 ); // $ExpectError + dapxsumkbn2.main( ( x: number ): number => x, 5.0, x, 1 ); // $ExpectError } // The compiler throws an error if the `main` method is provided a second argument which is not a number... { const x = new Float64Array( 10 ); - dapxsumkbn.main( x.length, '10', x, 1 ); // $ExpectError - dapxsumkbn.main( x.length, true, x, 1 ); // $ExpectError - dapxsumkbn.main( x.length, false, x, 1 ); // $ExpectError - dapxsumkbn.main( x.length, null, x, 1 ); // $ExpectError - dapxsumkbn.main( x.length, undefined, x, 1 ); // $ExpectError - dapxsumkbn.main( x.length, [], x, 1 ); // $ExpectError - dapxsumkbn.main( x.length, {}, x, 1 ); // $ExpectError - dapxsumkbn.main( x.length, ( x: number ): number => x, x, 1 ); // $ExpectError + dapxsumkbn2.main( x.length, '10', x, 1 ); // $ExpectError + dapxsumkbn2.main( x.length, true, x, 1 ); // $ExpectError + dapxsumkbn2.main( x.length, false, x, 1 ); // $ExpectError + dapxsumkbn2.main( x.length, null, x, 1 ); // $ExpectError + dapxsumkbn2.main( x.length, undefined, x, 1 ); // $ExpectError + dapxsumkbn2.main( x.length, [], x, 1 ); // $ExpectError + dapxsumkbn2.main( x.length, {}, x, 1 ); // $ExpectError + dapxsumkbn2.main( x.length, ( x: number ): number => x, x, 1 ); // $ExpectError } // The compiler throws an error if the `main` method is provided a third argument which is not a Float64Array... { const x = new Float64Array( 10 ); - dapxsumkbn.main( x.length, 5.0, 10, 1 ); // $ExpectError - dapxsumkbn.main( x.length, 5.0, '10', 1 ); // $ExpectError - dapxsumkbn.main( x.length, 5.0, true, 1 ); // $ExpectError - dapxsumkbn.main( x.length, 5.0, false, 1 ); // $ExpectError - dapxsumkbn.main( x.length, 5.0, null, 1 ); // $ExpectError - dapxsumkbn.main( x.length, 5.0, undefined, 1 ); // $ExpectError - dapxsumkbn.main( x.length, 5.0, [], 1 ); // $ExpectError - dapxsumkbn.main( x.length, 5.0, {}, 1 ); // $ExpectError - dapxsumkbn.main( x.length, 5.0, ( x: number ): number => x, 1 ); // $ExpectError + dapxsumkbn2.main( x.length, 5.0, 10, 1 ); // $ExpectError + dapxsumkbn2.main( x.length, 5.0, '10', 1 ); // $ExpectError + dapxsumkbn2.main( x.length, 5.0, true, 1 ); // $ExpectError + dapxsumkbn2.main( x.length, 5.0, false, 1 ); // $ExpectError + dapxsumkbn2.main( x.length, 5.0, null, 1 ); // $ExpectError + dapxsumkbn2.main( x.length, 5.0, undefined, 1 ); // $ExpectError + dapxsumkbn2.main( x.length, 5.0, [], 1 ); // $ExpectError + dapxsumkbn2.main( x.length, 5.0, {}, 1 ); // $ExpectError + dapxsumkbn2.main( x.length, 5.0, ( x: number ): number => x, 1 ); // $ExpectError } // The compiler throws an error if the `main` method is provided a fourth argument which is not a number... { const x = new Float64Array( 10 ); - dapxsumkbn.main( x.length, 5.0, x, '10' ); // $ExpectError - dapxsumkbn.main( x.length, 5.0, x, true ); // $ExpectError - dapxsumkbn.main( x.length, 5.0, x, false ); // $ExpectError - dapxsumkbn.main( x.length, 5.0, x, null ); // $ExpectError - dapxsumkbn.main( x.length, 5.0, x, undefined ); // $ExpectError - dapxsumkbn.main( x.length, 5.0, x, [] ); // $ExpectError - dapxsumkbn.main( x.length, 5.0, x, {} ); // $ExpectError - dapxsumkbn.main( x.length, 5.0, x, ( x: number ): number => x ); // $ExpectError + dapxsumkbn2.main( x.length, 5.0, x, '10' ); // $ExpectError + dapxsumkbn2.main( x.length, 5.0, x, true ); // $ExpectError + dapxsumkbn2.main( x.length, 5.0, x, false ); // $ExpectError + dapxsumkbn2.main( x.length, 5.0, x, null ); // $ExpectError + dapxsumkbn2.main( x.length, 5.0, x, undefined ); // $ExpectError + dapxsumkbn2.main( x.length, 5.0, x, [] ); // $ExpectError + dapxsumkbn2.main( x.length, 5.0, x, {} ); // $ExpectError + dapxsumkbn2.main( x.length, 5.0, x, ( x: number ): number => x ); // $ExpectError } // The compiler throws an error if the `main` method is provided an unsupported number of arguments... { const x = new Float64Array( 10 ); - dapxsumkbn.main(); // $ExpectError - dapxsumkbn.main( x.length ); // $ExpectError - dapxsumkbn.main( x.length, x ); // $ExpectError - dapxsumkbn.main( x.length, x, 1 ); // $ExpectError - dapxsumkbn.main( x.length, x, 1, 10, 2 ); // $ExpectError + dapxsumkbn2.main(); // $ExpectError + dapxsumkbn2.main( x.length ); // $ExpectError + dapxsumkbn2.main( x.length, x ); // $ExpectError + dapxsumkbn2.main( x.length, x, 1 ); // $ExpectError + dapxsumkbn2.main( x.length, x, 1, 10, 2 ); // $ExpectError } // Attached to main export is an `ndarray` method which returns a number... { const x = new Float64Array( 10 ); - dapxsumkbn.ndarray( x.length, 5.0, x, 1, 0 ); // $ExpectType number + dapxsumkbn2.ndarray( x.length, 5.0, x, 1, 0 ); // $ExpectType number } // The compiler throws an error if the `ndarray` method is provided a first argument which is not a number... { const x = new Float64Array( 10 ); - dapxsumkbn.ndarray( '10', 5.0, x, 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( true, 5.0, x, 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( false, 5.0, x, 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( null, 5.0, x, 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( undefined, 5.0, x, 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( [], 5.0, x, 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( {}, 5.0, x, 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( ( x: number ): number => x, 5.0, x, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( '10', 5.0, x, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( true, 5.0, x, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( false, 5.0, x, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( null, 5.0, x, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( undefined, 5.0, x, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( [], 5.0, x, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( {}, 5.0, x, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( ( x: number ): number => x, 5.0, x, 1, 0 ); // $ExpectError } // The compiler throws an error if the `ndarray` method is provided a second argument which is not a number... { const x = new Float64Array( 10 ); - dapxsumkbn.ndarray( x.length, '10', x, 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, true, x, 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, false, x, 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, null, x, 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, undefined, x, 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, [], x, 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, {}, x, 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, ( x: number ): number => x, x, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, '10', x, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, true, x, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, false, x, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, null, x, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, undefined, x, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, [], x, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, {}, x, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, ( x: number ): number => x, x, 1, 0 ); // $ExpectError } // The compiler throws an error if the `ndarray` method is provided a third argument which is not a Float64Array... { const x = new Float64Array( 10 ); - dapxsumkbn.ndarray( x.length, 5.0, 10, 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, '10', 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, true, 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, false, 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, null, 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, undefined, 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, [], 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, {}, 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, ( x: number ): number => x, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, 10, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, '10', 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, true, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, false, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, null, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, undefined, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, [], 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, {}, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, ( x: number ): number => x, 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 Float64Array( 10 ); - dapxsumkbn.ndarray( x.length, 5.0, x, '10', 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, x, true, 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, x, false, 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, x, null, 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, x, undefined, 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, x, [], 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, x, {}, 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, x, ( x: number ): number => x, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, x, '10', 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, x, true, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, x, false, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, x, null, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, x, undefined, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, x, [], 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, x, {}, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, x, ( x: number ): number => x, 0 ); // $ExpectError } // The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a number... { const x = new Float64Array( 10 ); - dapxsumkbn.ndarray( x.length, 5.0, x, 1, '10' ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, x, 1, true ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, x, 1, false ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, x, 1, null ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, x, 1, undefined ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, x, 1, [] ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, x, 1, {} ); // $ExpectError - dapxsumkbn.ndarray( x.length, 5.0, x, 1, ( x: number ): number => x ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, x, 1, '10' ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, x, 1, true ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, x, 1, false ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, x, 1, null ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, x, 1, undefined ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, x, 1, [] ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, x, 1, {} ); // $ExpectError + dapxsumkbn2.ndarray( x.length, 5.0, x, 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 Float64Array( 10 ); - dapxsumkbn.ndarray(); // $ExpectError - dapxsumkbn.ndarray( x.length ); // $ExpectError - dapxsumkbn.ndarray( x.length, x ); // $ExpectError - dapxsumkbn.ndarray( x.length, x, 1 ); // $ExpectError - dapxsumkbn.ndarray( x.length, x, 1, 0 ); // $ExpectError - dapxsumkbn.ndarray( x.length, x, 1, 0, 10, 2 ); // $ExpectError + dapxsumkbn2.ndarray(); // $ExpectError + dapxsumkbn2.ndarray( x.length ); // $ExpectError + dapxsumkbn2.ndarray( x.length, x ); // $ExpectError + dapxsumkbn2.ndarray( x.length, x, 1 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, x, 1, 0 ); // $ExpectError + dapxsumkbn2.ndarray( x.length, x, 1, 0, 10, 2 ); // $ExpectError } // Attached to the main export is a `Module` constructor which returns a module... @@ -195,19 +195,19 @@ import dapxsumkbn = require( './index' ); 'initial': 0 }); - dapxsumkbn.Module( mem ); // $ExpectType Module + dapxsumkbn2.Module( mem ); // $ExpectType Module } // The compiler throws an error if the `Module` constructor is not provided a WebAssembly memory instance... { - dapxsumkbn.Module( '10' ); // $ExpectError - dapxsumkbn.Module( true ); // $ExpectError - dapxsumkbn.Module( false ); // $ExpectError - dapxsumkbn.Module( null ); // $ExpectError - dapxsumkbn.Module( undefined ); // $ExpectError - dapxsumkbn.Module( [] ); // $ExpectError - dapxsumkbn.Module( {} ); // $ExpectError - dapxsumkbn.Module( ( x: number ): number => x ); // $ExpectError + dapxsumkbn2.Module( '10' ); // $ExpectError + dapxsumkbn2.Module( true ); // $ExpectError + dapxsumkbn2.Module( false ); // $ExpectError + dapxsumkbn2.Module( null ); // $ExpectError + dapxsumkbn2.Module( undefined ); // $ExpectError + dapxsumkbn2.Module( [] ); // $ExpectError + dapxsumkbn2.Module( {} ); // $ExpectError + dapxsumkbn2.Module( ( x: number ): number => x ); // $ExpectError } // The `Module` constructor returns a module instance having a `main` method which returns a number... @@ -215,7 +215,7 @@ import dapxsumkbn = require( './index' ); const mem = new Memory({ 'initial': 1 }); - const mod = dapxsumkbn.Module( mem ); + const mod = dapxsumkbn2.Module( mem ); mod.main( 10, 5.0, 0, 1 ); // $ExpectType number } @@ -225,7 +225,7 @@ import dapxsumkbn = require( './index' ); const mem = new Memory({ 'initial': 1 }); - const mod = dapxsumkbn.Module( mem ); + const mod = dapxsumkbn2.Module( mem ); mod.main( '10', 5.0, 0, 1 ); // $ExpectError mod.main( true, 5.0, 0, 1 ); // $ExpectError @@ -242,7 +242,7 @@ import dapxsumkbn = require( './index' ); const mem = new Memory({ 'initial': 1 }); - const mod = dapxsumkbn.Module( mem ); + const mod = dapxsumkbn2.Module( mem ); mod.main( 10, '10', 0, 1 ); // $ExpectError mod.main( 10, true, 0, 1 ); // $ExpectError @@ -259,7 +259,7 @@ import dapxsumkbn = require( './index' ); const mem = new Memory({ 'initial': 1 }); - const mod = dapxsumkbn.Module( mem ); + const mod = dapxsumkbn2.Module( mem ); mod.main( 10, 5.0, '10', 1 ); // $ExpectError mod.main( 10, 5.0, true, 1 ); // $ExpectError @@ -276,7 +276,7 @@ import dapxsumkbn = require( './index' ); const mem = new Memory({ 'initial': 1 }); - const mod = dapxsumkbn.Module( mem ); + const mod = dapxsumkbn2.Module( mem ); mod.main( 10, 5.0, 0, '10' ); // $ExpectError mod.main( 10, 5.0, 0, true ); // $ExpectError @@ -293,7 +293,7 @@ import dapxsumkbn = require( './index' ); const mem = new Memory({ 'initial': 1 }); - const mod = dapxsumkbn.Module( mem ); + const mod = dapxsumkbn2.Module( mem ); mod.main(); // $ExpectError mod.main( 10 ); // $ExpectError @@ -307,7 +307,7 @@ import dapxsumkbn = require( './index' ); const mem = new Memory({ 'initial': 1 }); - const mod = dapxsumkbn.Module( mem ); + const mod = dapxsumkbn2.Module( mem ); mod.ndarray( 10, 5.0, 0, 1, 0 ); // $ExpectType number } @@ -317,7 +317,7 @@ import dapxsumkbn = require( './index' ); const mem = new Memory({ 'initial': 1 }); - const mod = dapxsumkbn.Module( mem ); + const mod = dapxsumkbn2.Module( mem ); mod.ndarray( '10', 5.0, 0, 1, 0 ); // $ExpectError mod.ndarray( true, 5.0, 0, 1, 0 ); // $ExpectError @@ -334,7 +334,7 @@ import dapxsumkbn = require( './index' ); const mem = new Memory({ 'initial': 1 }); - const mod = dapxsumkbn.Module( mem ); + const mod = dapxsumkbn2.Module( mem ); mod.ndarray( 5.0, '10', 0, 1, 0 ); // $ExpectError mod.ndarray( 5.0, true, 0, 1, 0 ); // $ExpectError @@ -351,7 +351,7 @@ import dapxsumkbn = require( './index' ); const mem = new Memory({ 'initial': 1 }); - const mod = dapxsumkbn.Module( mem ); + const mod = dapxsumkbn2.Module( mem ); mod.ndarray( 10, 5.0, '10', 1, 0 ); // $ExpectError mod.ndarray( 10, 5.0, true, 1, 0 ); // $ExpectError @@ -368,7 +368,7 @@ import dapxsumkbn = require( './index' ); const mem = new Memory({ 'initial': 1 }); - const mod = dapxsumkbn.Module( mem ); + const mod = dapxsumkbn2.Module( mem ); mod.ndarray( 10, 5.0, 0, '10', 0 ); // $ExpectError mod.ndarray( 10, 5.0, 0, true, 0 ); // $ExpectError @@ -385,7 +385,7 @@ import dapxsumkbn = require( './index' ); const mem = new Memory({ 'initial': 1 }); - const mod = dapxsumkbn.Module( mem ); + const mod = dapxsumkbn2.Module( mem ); mod.ndarray( 10, 5.0, 0, 1, '10' ); // $ExpectError mod.ndarray( 10, 5.0, 0, 1, true ); // $ExpectError @@ -402,7 +402,7 @@ import dapxsumkbn = require( './index' ); const mem = new Memory({ 'initial': 1 }); - const mod = dapxsumkbn.Module( mem ); + const mod = dapxsumkbn2.Module( mem ); mod.ndarray(); // $ExpectError mod.ndarray( 10 ); // $ExpectError diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/index.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/index.js index 7c6e0b408530..f9df74f7274b 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/index.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/index.js @@ -20,7 +20,7 @@ var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' ); var oneTo = require( '@stdlib/array/one-to' ); -var dapxsumkbn = require( './../lib' ); +var dapxsumkbn2 = require( './../lib' ); function main() { if ( !hasWebAssemblySupport() ) { @@ -34,7 +34,7 @@ function main() { var x = oneTo( N, 'float64' ); // Perform computation: - var sum = dapxsumkbn.ndarray( N, 5.0, x, 1, 0 ); + var sum = dapxsumkbn2.ndarray( N, 5.0, x, 1, 0 ); // Print the result: console.log( sum ); diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/little_endian_arrays.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/little_endian_arrays.js index 65fd33c1b48c..b92e8cf6db8b 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/little_endian_arrays.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/little_endian_arrays.js @@ -23,7 +23,7 @@ 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 Float64ArrayLE = require( '@stdlib/array/little-endian-float64' ); -var dapxsumkbn = require( './../lib' ); +var dapxsumkbn2 = require( './../lib' ); function main() { if ( !hasWebAssemblySupport() ) { @@ -37,7 +37,7 @@ function main() { }); // Create a BLAS routine: - var mod = new dapxsumkbn.Module( mem ); + var mod = new dapxsumkbn2.Module( mem ); // returns // Initialize the routine: diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/module.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/module.js index 3e473635fab9..ca62a000d102 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/module.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/module.js @@ -21,7 +21,7 @@ var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' ); var Memory = require( '@stdlib/wasm/memory' ); var oneTo = require( '@stdlib/array/one-to' ); -var dapxsumkbn = require( './../lib' ); +var dapxsumkbn2 = require( './../lib' ); function main() { if ( !hasWebAssemblySupport() ) { @@ -35,7 +35,7 @@ function main() { }); // Create a BLAS routine: - var mod = new dapxsumkbn.Module( mem ); + var mod = new dapxsumkbn2.Module( mem ); // returns // Initialize the routine: From 5705b0c54282c4e5aac1dfb1ea878265b43536d2 Mon Sep 17 00:00:00 2001 From: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com> Date: Sat, 1 Mar 2025 13:50:41 +0000 Subject: [PATCH 05/10] chore: update copyright years --- .../@stdlib/blas/ext/base/wasm/dapxsumkbn2/README.md | 2 +- .../blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.js | 2 +- .../ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.js | 2 +- .../base/wasm/dapxsumkbn2/benchmark/benchmark.module.main.js | 2 +- .../base/wasm/dapxsumkbn2/benchmark/benchmark.module.ndarray.js | 2 +- .../ext/base/wasm/dapxsumkbn2/benchmark/benchmark.ndarray.js | 2 +- .../blas/ext/base/wasm/dapxsumkbn2/docs/types/index.d.ts | 2 +- .../@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/test.ts | 2 +- .../@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/index.js | 2 +- .../ext/base/wasm/dapxsumkbn2/examples/little_endian_arrays.js | 2 +- .../@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/module.js | 2 +- .../@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/binary.js | 2 +- .../@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/index.js | 2 +- .../@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/main.js | 2 +- .../@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/module.js | 2 +- .../@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/routine.js | 2 +- .../@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/build.js | 2 +- .../@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/template.txt | 2 +- .../@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.js | 2 +- .../@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.main.js | 2 +- .../@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.js | 2 +- .../blas/ext/base/wasm/dapxsumkbn2/test/test.module.main.js | 2 +- .../blas/ext/base/wasm/dapxsumkbn2/test/test.module.ndarray.js | 2 +- .../@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.ndarray.js | 2 +- .../@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.routine.js | 2 +- 25 files changed, 25 insertions(+), 25 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/README.md b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/README.md index f3449ef74196..66fa6ff08835 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/README.md +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/README.md @@ -2,7 +2,7 @@ @license Apache-2.0 -Copyright (c) 2024 The Stdlib Authors. +Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.js index 3bdec8939cdc..6363490bdb79 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.js index 298c635d1e6b..b8ee93210b66 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.main.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.main.js index 3fb098f42e76..cc12d6d8e9ec 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.main.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.main.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.ndarray.js index efab5db62bb3..0bcea18f33b7 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.ndarray.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.module.ndarray.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.ndarray.js index 52bc3c54775c..7e105f787615 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.ndarray.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/benchmark/benchmark.ndarray.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/index.d.ts index bb782515ac57..1a1dbe5dfb39 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/index.d.ts @@ -1,7 +1,7 @@ /* * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/test.ts b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/test.ts index ef3ea2786e68..7a7014734ecb 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/test.ts +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/docs/types/test.ts @@ -1,7 +1,7 @@ /* * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/index.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/index.js index f9df74f7274b..63fb0a49d3f9 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/index.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/index.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/little_endian_arrays.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/little_endian_arrays.js index b92e8cf6db8b..a53bced39638 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/little_endian_arrays.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/little_endian_arrays.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/module.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/module.js index ca62a000d102..173d6fcb567f 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/module.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/examples/module.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/binary.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/binary.js index 6f02393f96e5..2b83fe651780 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/binary.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/binary.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/index.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/index.js index d565b0a839fc..449ac01c6f56 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/index.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/index.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/main.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/main.js index 77ab51bacd4d..abe20b36857a 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/main.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/main.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/module.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/module.js index 453831ce7728..82d2b136f0c8 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/module.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/module.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/routine.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/routine.js index 626d4235e8a1..d672344e497c 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/routine.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/routine.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/build.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/build.js index 348354d7029c..9a7b4afb94bd 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/build.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/build.js @@ -3,7 +3,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/template.txt b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/template.txt index 12996dd89e3b..554d4b2abe02 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/template.txt +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/template.txt @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.js index a50020a09b11..f7172500a116 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.main.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.main.js index d6440f85d3c7..ab3c0d1c1103 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.main.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.main.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.js index 9adcb07e22fa..0cdcd97ef151 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.main.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.main.js index a1e7af7e8363..42fa4c4abde4 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.main.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.main.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.ndarray.js index 59cd4204a5f9..6dd5dca035ac 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.ndarray.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.module.ndarray.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.ndarray.js index 2e90adbb75f1..1314cc731ee2 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.ndarray.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.routine.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.routine.js index 56a4b67daaf0..d90a5804a8e1 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.routine.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/test/test.routine.js @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2024 The Stdlib Authors. +* Copyright (c) 2025 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. From 7d885de29794bfc6952a5f7cd6023401262dc440 Mon Sep 17 00:00:00 2001 From: JoyBoy <144602492+0PrashantYadav0@users.noreply.github.com> Date: Sat, 1 Mar 2025 21:46:07 +0530 Subject: [PATCH 06/10] fix: fix bugs --- .../blas/ext/base/dnansumkbn2/manifest.json | 23 +------------------ 1 file changed, 1 insertion(+), 22 deletions(-) diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/manifest.json b/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/manifest.json index d4a221b0f283..57e9af5c51e3 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/manifest.json +++ b/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/manifest.json @@ -1,7 +1,6 @@ { "options": { - "task": "build", - "wasm": false + "task": "build" }, "fields": [ { @@ -28,7 +27,6 @@ "confs": [ { "task": "build", - "wasm": false, "src": [ "./src/main.c" ], @@ -51,7 +49,6 @@ }, { "task": "benchmark", - "wasm": false, "src": [ "./src/main.c" ], @@ -69,24 +66,6 @@ }, { "task": "examples", - "wasm": false, - "src": [ - "./src/main.c" - ], - "include": [ - "./include" - ], - "libraries": [], - "libpath": [], - "dependencies": [ - "@stdlib/math/base/special/abs", - "@stdlib/blas/base/shared", - "@stdlib/strided/base/stride2offset" - ] - }, - { - "task": "build", - "wasm": true, "src": [ "./src/main.c" ], From 6c07fad8a9a7a67befdcce3ebbf94646138d206d Mon Sep 17 00:00:00 2001 From: JoyBoy <144602492+0PrashantYadav0@users.noreply.github.com> Date: Sat, 1 Mar 2025 23:12:54 +0530 Subject: [PATCH 07/10] chore: update package.json --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../blas/ext/base/dnansumkbn2/manifest.json | 24 ++++++++++++++++++- 1 file changed, 23 insertions(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/manifest.json b/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/manifest.json index 57e9af5c51e3..8f502b747310 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/manifest.json +++ b/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/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" ], @@ -49,6 +51,7 @@ }, { "task": "benchmark", + "wasm": false, "src": [ "./src/main.c" ], @@ -66,6 +69,25 @@ }, { "task": "examples", + "wasm": false, + "src": [ + "./src/main.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/math/base/assert/is-nan", + "@stdlib/math/base/special/abs", + "@stdlib/blas/base/shared", + "@stdlib/strided/base/stride2offset" + ] + }, + { + "task": "build", + "wasm": true, "src": [ "./src/main.c" ], From cf939ede29b6a8fd95ef131be21a4f10804ed2f9 Mon Sep 17 00:00:00 2001 From: JoyBoy <144602492+0PrashantYadav0@users.noreply.github.com> Date: Sun, 2 Mar 2025 00:00:37 +0530 Subject: [PATCH 08/10] chore: add web assembly files --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- type: pre_push_report description: Results of running various checks prior to pushing changes. report: - task: run_javascript_examples status: na - task: run_c_examples status: na - task: run_cpp_examples status: na - task: run_javascript_readme_examples status: na - task: run_c_benchmarks status: na - task: run_cpp_benchmarks status: na - task: run_fortran_benchmarks status: na - task: run_javascript_benchmarks status: na - task: run_julia_benchmarks status: na - task: run_python_benchmarks status: na - task: run_r_benchmarks status: na - task: run_javascript_tests status: na --- --- .../blas/ext/base/dapxsumkbn2/manifest.json | 24 +++- .../blas/ext/base/dnansumkbn2/manifest.json | 24 +--- .../wasm/dapxsumkbn2/lib/binary.browser.js | 33 +++++ .../ext/base/wasm/dapxsumkbn2/src/main.wasm | Bin 0 -> 368 bytes .../ext/base/wasm/dapxsumkbn2/src/main.wat | 125 ++++++++++++++++++ 5 files changed, 182 insertions(+), 24 deletions(-) create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/binary.browser.js create mode 100755 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/src/main.wasm create mode 100644 lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/src/main.wat diff --git a/lib/node_modules/@stdlib/blas/ext/base/dapxsumkbn2/manifest.json b/lib/node_modules/@stdlib/blas/ext/base/dapxsumkbn2/manifest.json index 81c9d3af44e5..7043ec46b7e5 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dapxsumkbn2/manifest.json +++ b/lib/node_modules/@stdlib/blas/ext/base/dapxsumkbn2/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" ], @@ -49,6 +51,7 @@ }, { "task": "benchmark", + "wasm": false, "src": [ "./src/main.c" ], @@ -65,6 +68,25 @@ }, { "task": "examples", + "wasm": false, + "src": [ + "./src/main.c" + ], + "include": [ + "./include" + ], + "libraries": [], + "libpath": [], + "dependencies": [ + "@stdlib/math/base/assert/is-nan", + "@stdlib/math/base/special/abs", + "@stdlib/blas/base/shared", + "@stdlib/strided/base/stride2offset" + ] + }, + { + "task": "build", + "wasm": true, "src": [ "./src/main.c" ], diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/manifest.json b/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/manifest.json index 8f502b747310..57e9af5c51e3 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/manifest.json +++ b/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/manifest.json @@ -1,7 +1,6 @@ { "options": { - "task": "build", - "wasm": false + "task": "build" }, "fields": [ { @@ -28,7 +27,6 @@ "confs": [ { "task": "build", - "wasm": false, "src": [ "./src/main.c" ], @@ -51,7 +49,6 @@ }, { "task": "benchmark", - "wasm": false, "src": [ "./src/main.c" ], @@ -69,25 +66,6 @@ }, { "task": "examples", - "wasm": false, - "src": [ - "./src/main.c" - ], - "include": [ - "./include" - ], - "libraries": [], - "libpath": [], - "dependencies": [ - "@stdlib/math/base/assert/is-nan", - "@stdlib/math/base/special/abs", - "@stdlib/blas/base/shared", - "@stdlib/strided/base/stride2offset" - ] - }, - { - "task": "build", - "wasm": true, "src": [ "./src/main.c" ], diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/binary.browser.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/binary.browser.js new file mode 100644 index 000000000000..dfd90de0d5df --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/lib/binary.browser.js @@ -0,0 +1,33 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 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( 'AGFzbQEAAAAADwhkeWxpbmsuMAEEAAAAAAEVA2AAAGAEf3x/fwF8YAV/fH9/fwF8Ag8BA2VudgZtZW1vcnkCAAADBAMAAQIHVwMRX193YXNtX2NhbGxfY3RvcnMAABpzdGRsaWJfc3RyaWRlZF9kYXB4c3Vta2JuMgABInN0ZGxpYl9zdHJpZGVkX2RhcHhzdW1rYm4yX25kYXJyYXkAAgrNAQMDAAELHAAgACABIAIgA0EBIABrIANsQQAgA0EATBsQAgupAQIFfAF/IABBAEwEQEQAAAAAAAAAAA8LIAMEQANAIAAgCkZFBEAgCCABIAIgBEEDdGorAwCgIgcgBSAFIAegIgmhoCAFIAcgCaGgIAWZIAeZZhsiBSAGIAYgBaAiB6GgIAYgBSAHoaAgBpkgBZlmG6AhCCAKQQFqIQogAyAEaiEEIAkhBSAHIQYMAQsLIAggBSAGoKAPCyABIAIgBEEDdGorAwCgIAC4ogs=' ); + + +// EXPORTS // + +module.exports = wasm; diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/src/main.wasm b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/src/main.wasm new file mode 100755 index 0000000000000000000000000000000000000000..2d3bf51c2c257c9788d420e6a6d9e419ed5641a0 GIT binary patch literal 368 zcmZ`zyH3MU47IOsnl?cy3@ntv$%=#!Uyw+^#Ljq=HbqLBq$mlGN|Ev%-7akW0YAY% z;Z%qXdpO5BK0b!Dtq`Q<(`;Af_2%*l^*G}xB>;&Y`eDF6aYhuP=1A-MWm2uHZL?DV zqzO>D4|HP8s~j_{v@Ff4+cqu0S=(i0zBFyuniS^D(WK3AJ%eGM4?FPb__n6m@54dMXL>o-mi?IkiCe}ruc^1e*FgZfs Sml*L{EAivQe{l?7AN~(;TTnj$ literal 0 HcmV?d00001 diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/src/main.wat b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/src/main.wat new file mode 100644 index 000000000000..a9bb98cf5e4a --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/src/main.wat @@ -0,0 +1,125 @@ +(module + (type (;0;) (func)) + (type (;1;) (func (param i32 f64 i32 i32) (result f64))) + (type (;2;) (func (param i32 f64 i32 i32 i32) (result f64))) + (import "env" "memory" (memory (;0;) 0)) + (func (;0;) (type 0) + nop) + (func (;1;) (type 1) (param i32 f64 i32 i32) (result f64) + local.get 0 + local.get 1 + local.get 2 + local.get 3 + i32.const 1 + local.get 0 + i32.sub + local.get 3 + i32.mul + i32.const 0 + local.get 3 + i32.const 0 + i32.le_s + select + call 2) + (func (;2;) (type 2) (param i32 f64 i32 i32 i32) (result f64) + (local f64 f64 f64 f64 f64 i32) + local.get 0 + i32.const 0 + i32.le_s + if ;; label = @1 + f64.const 0x0p+0 (;=0;) + return + end + local.get 3 + if ;; label = @1 + loop ;; label = @2 + local.get 0 + local.get 10 + i32.eq + i32.eqz + if ;; label = @3 + local.get 8 + local.get 1 + local.get 2 + local.get 4 + i32.const 3 + i32.shl + i32.add + f64.load + f64.add + local.tee 7 + local.get 5 + local.get 5 + local.get 7 + f64.add + local.tee 9 + f64.sub + f64.add + local.get 5 + local.get 7 + local.get 9 + f64.sub + f64.add + local.get 5 + f64.abs + local.get 7 + f64.abs + f64.ge + select + local.tee 5 + local.get 6 + local.get 6 + local.get 5 + f64.add + local.tee 7 + f64.sub + f64.add + local.get 6 + local.get 5 + local.get 7 + f64.sub + f64.add + local.get 6 + f64.abs + local.get 5 + f64.abs + f64.ge + select + f64.add + local.set 8 + local.get 10 + i32.const 1 + i32.add + local.set 10 + local.get 3 + local.get 4 + i32.add + local.set 4 + local.get 9 + local.set 5 + local.get 7 + local.set 6 + br 1 (;@2;) + end + end + local.get 8 + local.get 5 + local.get 6 + f64.add + f64.add + return + end + local.get 1 + local.get 2 + local.get 4 + i32.const 3 + i32.shl + i32.add + f64.load + f64.add + local.get 0 + f64.convert_i32_u + f64.mul) + (export "__wasm_call_ctors" (func 0)) + (export "stdlib_strided_dapxsumkbn2" (func 1)) + (export "stdlib_strided_dapxsumkbn2_ndarray" (func 2))) From 9d90026a2bbaf59099b8aef23e9427a19d9c66e9 Mon Sep 17 00:00:00 2001 From: JoyBoy <144602492+0PrashantYadav0@users.noreply.github.com> Date: Sun, 2 Mar 2025 01:11:44 +0530 Subject: [PATCH 09/10] chore: add license in main.wat Signed-off-by: JoyBoy <144602492+0PrashantYadav0@users.noreply.github.com> --- .../blas/ext/base/wasm/dapxsumkbn2/src/main.wat | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/src/main.wat b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/src/main.wat index a9bb98cf5e4a..0ffffcb720d3 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/src/main.wat +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/src/main.wat @@ -1,3 +1,19 @@ +;; @license Apache-2.0 +;; +;; Copyright (c) 2025 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 f64 i32 i32) (result f64))) From e28264f63290afec7dc871062735a2826ec8b5fd Mon Sep 17 00:00:00 2001 From: JoyBoy <144602492+0PrashantYadav0@users.noreply.github.com> Date: Wed, 5 Mar 2025 13:52:59 +0530 Subject: [PATCH 10/10] fix: changes in scripts --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- type: pre_push_report description: Results of running various checks prior to pushing changes. report: - task: run_javascript_examples status: na - task: run_c_examples status: na - task: run_cpp_examples status: na - task: run_javascript_readme_examples status: na - task: run_c_benchmarks status: na - task: run_cpp_benchmarks status: na - task: run_fortran_benchmarks status: na - task: run_javascript_benchmarks status: na - task: run_julia_benchmarks status: na - task: run_python_benchmarks status: na - task: run_r_benchmarks status: na - task: run_javascript_tests status: na --- --- .../@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/build.js | 3 +++ .../blas/ext/base/wasm/dapxsumkbn2/scripts/template.txt | 2 +- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/build.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/build.js index 9a7b4afb94bd..5f54efd4e40f 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/build.js +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/build.js @@ -33,12 +33,14 @@ var replace = require( '@stdlib/string/replace' ); var wpath = resolve( __dirname, '..', 'src', 'main.wasm' ); var tpath = resolve( __dirname, 'template.txt' ); var opath = resolve( __dirname, '..', 'lib', 'binary.browser.js' ); +var currentYear = require( '@stdlib/time/current-year' ); var opts = { 'encoding': 'utf8' }; var PLACEHOLDER = '{{WASM_BASE64}}'; +var YEAR = '{{YEAR}}'; // MAIN // @@ -55,6 +57,7 @@ function main() { wasm = readFile( wpath ); tmpl = readFile( tpath, opts ); + tmpl = replace( tmpl, YEAR, currentYear().toString() ); tmpl = replace( tmpl, PLACEHOLDER, wasm.toString( 'base64' ) ); writeFile( opath, tmpl, opts ); diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/template.txt b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/template.txt index 554d4b2abe02..f66cdb9735b1 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/template.txt +++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dapxsumkbn2/scripts/template.txt @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2025 The Stdlib Authors. +* 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.