From c1713877ce6335b1b4a626e2e4b6d46f0eb45081 Mon Sep 17 00:00:00 2001 From: JoyBoy <144602492+0PrashantYadav0@users.noreply.github.com> Date: Tue, 16 Sep 2025 15:16:11 +0530 Subject: [PATCH 01/15] feat: wasm implementation for stats/strided/dnanvariancewd --- .../strided/dnanvariancewd/manifest.json | 2 +- .../strided/wasm/dnanvariancewd/README.md | 329 +++++++++++ .../dnanvariancewd/benchmark/benchmark.js | 121 ++++ .../benchmark/benchmark.module.js | 66 +++ .../benchmark/benchmark.module.main.js | 145 +++++ .../benchmark/benchmark.module.ndarray.js | 145 +++++ .../benchmark/benchmark.ndarray.js | 121 ++++ .../strided/wasm/dnanvariancewd/docs/repl.txt | 552 ++++++++++++++++++ .../wasm/dnanvariancewd/docs/types/index.d.ts | 321 ++++++++++ .../wasm/dnanvariancewd/docs/types/test.ts | 415 +++++++++++++ .../wasm/dnanvariancewd/examples/index.js | 43 ++ .../examples/little_endian_arrays.js | 65 +++ .../wasm/dnanvariancewd/examples/module.js | 63 ++ .../wasm/dnanvariancewd/lib/binary.browser.js | 33 ++ .../strided/wasm/dnanvariancewd/lib/binary.js | 34 ++ .../strided/wasm/dnanvariancewd/lib/index.js | 100 ++++ .../strided/wasm/dnanvariancewd/lib/main.js | 60 ++ .../strided/wasm/dnanvariancewd/lib/module.js | 200 +++++++ .../wasm/dnanvariancewd/lib/routine.js | 168 ++++++ .../strided/wasm/dnanvariancewd/manifest.json | 36 ++ .../strided/wasm/dnanvariancewd/package.json | 86 +++ .../wasm/dnanvariancewd/scripts/build.js | 66 +++ .../wasm/dnanvariancewd/scripts/template.txt | 33 ++ .../strided/wasm/dnanvariancewd/src/Makefile | 243 ++++++++ .../wasm/dnanvariancewd/src/exports.json | 4 + .../strided/wasm/dnanvariancewd/src/main.wasm | Bin 0 -> 406 bytes .../strided/wasm/dnanvariancewd/src/main.wat | 125 ++++ .../strided/wasm/dnanvariancewd/test/test.js | 53 ++ .../wasm/dnanvariancewd/test/test.main.js | 315 ++++++++++ .../wasm/dnanvariancewd/test/test.module.js | 154 +++++ .../dnanvariancewd/test/test.module.main.js | 355 +++++++++++ .../test/test.module.ndarray.js | 307 ++++++++++ .../wasm/dnanvariancewd/test/test.ndarray.js | 311 ++++++++++ .../wasm/dnanvariancewd/test/test.routine.js | 71 +++ test_dmeanvar.js | 0 35 files changed, 5141 insertions(+), 1 deletion(-) create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/README.md create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.js create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.module.js create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.module.main.js create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.module.ndarray.js create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.ndarray.js create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/repl.txt create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/types/index.d.ts create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/types/test.ts create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/examples/index.js create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/examples/little_endian_arrays.js create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/examples/module.js create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/binary.browser.js create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/binary.js create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/index.js create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/main.js create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/module.js create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/routine.js create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/manifest.json create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/package.json create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/scripts/build.js create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/scripts/template.txt create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/src/Makefile create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/src/exports.json create mode 100755 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/src/main.wasm create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/src/main.wat create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.js create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.main.js create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.module.js create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.module.main.js create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.module.ndarray.js create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.ndarray.js create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.routine.js create mode 100644 test_dmeanvar.js diff --git a/lib/node_modules/@stdlib/stats/strided/dnanvariancewd/manifest.json b/lib/node_modules/@stdlib/stats/strided/dnanvariancewd/manifest.json index 86308d31795d..4e48e5cccb38 100644 --- a/lib/node_modules/@stdlib/stats/strided/dnanvariancewd/manifest.json +++ b/lib/node_modules/@stdlib/stats/strided/dnanvariancewd/manifest.json @@ -81,7 +81,7 @@ ] }, { - "task": "", + "task": "build", "wasm": true, "src": [ "./src/main.c" diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/README.md b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/README.md new file mode 100644 index 000000000000..013779ff43df --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/README.md @@ -0,0 +1,329 @@ + + +# dnanvariancewd + +> Compute the [variance][variance] of a double-precision floating-point strided array ignoring `NaN` values and using Welford's algorithm. + +
+ +## Usage + +```javascript +var dnanvariancewd = require( '@stdlib/stats/strided/wasm/dnanvariancewd' ); +``` + +#### dnanvariancewd.main( N, correction, x, strideX ) + +Computes the [variance][variance] of a double-precision floating-point strided array ignoring `NaN` values and using Welford's algorithm. + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); + +var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); + +var v = dnanvariancewd.main( x.length, 1, x, 1 ); +// returns ~4.3333 +``` + +The function has the following parameters: + +- **N**: number of indexed elements. +- **correction**: degrees of freedom adjustment. Setting this parameter to a value other than `0` has the effect of adjusting the divisor during the calculation of the [variance][variance] according to `n-c` where `c` corresponds to the provided degrees of freedom adjustment and `n` corresponds to the number of non-`NaN` indexed elements. When computing the [variance][variance] of a population, setting this parameter to `0` is the standard choice (i.e., the provided array contains data constituting an entire population). When computing the unbiased sample [variance][variance], setting this parameter to `1` is the standard choice (i.e., the provided array contains data sampled from a larger population; this is commonly referred to as Bessel's correction). +- **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' ); + +// eslint-disable-next-line max-len +var x = new Float64Array( [ 1.0, 2.0, 2.0, -7.0, -2.0, 3.0, 4.0, 2.0, NaN, NaN ] ); + +var v = dnanvariancewd.main( 5, 1, x, 2 ); +// returns 6.25 +``` + +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' ); + +// eslint-disable-next-line max-len +var x0 = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN, NaN ] ); +var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element + +var v = dnanvariancewd.main( 5, 1, x1, 2 ); +// returns 6.25 +``` + +#### dnanvariancewd.ndarray( N, correction, x, strideX, offsetX ) + +Computes the [variance][variance] of a double-precision floating-point strided array ignoring `NaN` values and using Welford's algorithm and alternative indexing semantics. + +```javascript +var Float64Array = require( '@stdlib/array/float64' ); + +var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); + +var v = dnanvariancewd.ndarray( x.length, 1, x, 1, 0 ); +// returns ~4.3333 +``` + +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' ); + +// eslint-disable-next-line max-len +var x = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN, NaN ] ); + +var v = dnanvariancewd.ndarray( 5, 1, x, 2, 1 ); +// returns 6.25 +``` + +* * * + +### Module + +#### dnanvariancewd.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 new routine: +var mod = new dnanvariancewd.Module( mem ); +// returns + +// Initialize the routine: +mod.initializeSync(); +``` + +#### dnanvariancewd.Module.prototype.main( N, correction, xp, sx ) + +Computes the [variance][variance] of a double-precision floating-point strided array ignoring `NaN` values and using Welford's 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 new routine: +var mod = new dnanvariancewd.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 v = mod.main( N, 1, xptr, 1 ); +// returns 1.0 +``` + +The function has the following parameters: + +- **N**: number of indexed elements. +- **correction**: degrees of freedom adjustment. +- **xp**: input [`Float64Array`][@stdlib/array/float64] pointer (i.e., byte offset). +- **sx**: stride length for `x`. + +#### dnanvariancewd.Module.prototype.ndarray( N, correction, xp, sx, ox ) + +Computes the [variance][variance] of a double-precision floating-point strided array ignoring `NaN` values and using Welford's 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 new routine: +var mod = new dnanvariancewd.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 v = mod.ndarray( N, 1, xptr, 1, 0 ); +// returns 1.0 +``` + +The function has the following additional parameters: + +- **ox**: starting index for `x`. + +
+ + + +
+ +* * * + +## Notes + +- If `N <= 0`, both `main` and `ndarray` methods return `NaN`. +- If `n - c` is less than or equal to `0` (where `c` corresponds to the provided degrees of freedom adjustment and `n` corresponds to the number of non-`NaN` indexed elements), both `main` and `ndarray` methods return `NaN`. +- This package implements routines using WebAssembly. When provided arrays which are not allocated on a `dnanvariancewd` 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/stats/strided/dnanvariancewd`][@stdlib/stats/strided/dnanvariancewd]. 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/stats/strided/dnanvariancewd`][@stdlib/stats/strided/dnanvariancewd]. 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 randu = require( '@stdlib/random/base/randu' ); +var round = require( '@stdlib/math/base/special/round' ); +var Float64Array = require( '@stdlib/array/float64' ); +var dnanvariancewd = require( '@stdlib/stats/strided/wasm/dnanvariancewd' ); + +var x; +var i; + +x = new Float64Array( 10 ); +for ( i = 0; i < x.length; i++ ) { + if ( randu() < 0.2 ) { + x[ i ] = NaN; + } else { + x[ i ] = round( randu() * 10.0 ); + } +} +console.log( x ); + +var v = dnanvariancewd.ndarray( x.length, 1, x, 1, 0 ); +console.log( v ); +``` + +
+ + + + + +
+ +* * * + +## See Also + +- [`@stdlib/stats/strided/dvariancewd`][@stdlib/stats/strided/dvariancewd]: calculate the variance of a double-precision floating-point strided array using Welford's algorithm. +- [`@stdlib/stats/strided/dnanvariance`][@stdlib/stats/strided/dnanvariance]: calculate the variance of a double-precision floating-point strided array ignoring NaN values. +- [`@stdlib/stats/strided/nanvariancewd`][@stdlib/stats/strided/nanvariancewd]: calculate the variance of a strided array ignoring NaN values and using Welford's algorithm. +- [`@stdlib/stats/base/snanvariancewd`][@stdlib/stats/base/snanvariancewd]: calculate the variance of a single-precision floating-point strided array ignoring NaN values and using Welford's algorithm. + +
+ + + + + +
+ +[variance]: https://en.wikipedia.org/wiki/Variance + +[@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/array/float64]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/float64 + +[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray + + + +[@stdlib/stats/strided/dvariancewd]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/dvariancewd + +[@stdlib/stats/strided/dnanvariance]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/dnanvariance + +[@stdlib/stats/strided/nanvariancewd]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/nanvariancewd + +[@stdlib/stats/base/snanvariancewd]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/base/snanvariancewd + +[@stdlib/stats/strided/dnanvariancewd]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/dnanvariancewd + + + +
+ + diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.js new file mode 100644 index 000000000000..ecaef3c88a37 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.js @@ -0,0 +1,121 @@ +/** +* @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 bench = require( '@stdlib/bench' ); +var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' ); +var uniform = require( '@stdlib/random/base/uniform' ); +var bernoulli = require( '@stdlib/random/base/bernoulli' ); +var filledarrayBy = require( '@stdlib/array/filled-by' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var pkg = require( './../package.json' ).name; +var dnanvariancewd = require( './../lib' ); + + +// VARIABLES // + +var opts = { + 'skip': !hasWebAssemblySupport() +}; +var options = { + 'dtype': 'float64' +}; + + +// FUNCTIONS // + +/** +* Returns a random number. +* +* @private +* @returns {number} random number or `NaN` +*/ +function rand() { + if ( bernoulli( 0.8 ) < 1 ) { + return NaN; + } + return uniform( -10.0, 10.0 ); +} + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + var x = filledarrayBy( len, options.dtype, rand ); + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var v; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = dnanvariancewd.main( x.length, 1, x, 1 ); + if ( isnan( v ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( v ) ) { + 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/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.module.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.module.js new file mode 100644 index 000000000000..1482aff0c351 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.module.js @@ -0,0 +1,66 @@ +/** +* @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 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 dnanvariancewd = 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 dnanvariancewd.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/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.module.main.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.module.main.js new file mode 100644 index 000000000000..e01493449dde --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.module.main.js @@ -0,0 +1,145 @@ +/** +* @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 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/base/uniform' ); +var bernoulli = require( '@stdlib/random/base/bernoulli' ); +var filledarrayBy = require( '@stdlib/array/filled-by' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var pkg = require( './../package.json' ).name; +var dnanvariancewd = require( './../lib' ); + + +// VARIABLES // + +var opts = { + 'skip': !hasWebAssemblySupport() +}; +var options = { + 'dtype': 'float64' +}; + + +// FUNCTIONS // + +/** +* Returns a random number. +* +* @private +* @returns {number} random number or `NaN` +*/ +function rand() { + if ( bernoulli( 0.8 ) < 1 ) { + return NaN; + } + return uniform( -10.0, 10.0 ); +} + +/** +* 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 nb; + var v; + var i; + + // Create a new routine interface: + mem = new Memory({ + 'initial': 0 + }); + mod = new dnanvariancewd.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, filledarrayBy( len, options.dtype, rand ) ); + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = mod.main( len, 1, xptr, 1 ); + if ( isnan( v ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( v ) ) { + 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/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.module.ndarray.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.module.ndarray.js new file mode 100644 index 000000000000..da4246d5a87b --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.module.ndarray.js @@ -0,0 +1,145 @@ +/** +* @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 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/base/uniform' ); +var bernoulli = require( '@stdlib/random/base/bernoulli' ); +var filledarrayBy = require( '@stdlib/array/filled-by' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var pkg = require( './../package.json' ).name; +var dnanvariancewd = require( './../lib' ); + + +// VARIABLES // + +var opts = { + 'skip': !hasWebAssemblySupport() +}; +var options = { + 'dtype': 'float64' +}; + + +// FUNCTIONS // + +/** +* Returns a random number. +* +* @private +* @returns {number} random number or `NaN` +*/ +function rand() { + if ( bernoulli( 0.8 ) < 1 ) { + return NaN; + } + return uniform( -10.0, 10.0 ); +} + +/** +* 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 nb; + var v; + var i; + + // Create a new routine interface: + mem = new Memory({ + 'initial': 0 + }); + mod = new dnanvariancewd.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, 1, filledarrayBy( len, options.dtype, rand ) ); + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = mod.ndarray( len, xptr, 1, 0 ); + if ( isnan( v ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( v ) ) { + 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/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.ndarray.js new file mode 100644 index 000000000000..6f38aa779185 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.ndarray.js @@ -0,0 +1,121 @@ +/** +* @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 bench = require( '@stdlib/bench' ); +var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' ); +var uniform = require( '@stdlib/random/base/uniform' ); +var bernoulli = require( '@stdlib/random/base/bernoulli' ); +var filledarrayBy = require( '@stdlib/array/filled-by' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var pkg = require( './../package.json' ).name; +var dnanvariancewd = require( './../lib' ); + + +// VARIABLES // + +var opts = { + 'skip': !hasWebAssemblySupport() +}; +var options = { + 'dtype': 'float64' +}; + + +// FUNCTIONS // + +/** +* Returns a random number. +* +* @private +* @returns {number} random number or `NaN` +*/ +function rand() { + if ( bernoulli( 0.8 ) < 1 ) { + return NaN; + } + return uniform( -10.0, 10.0 ); +} + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + var x = filledarrayBy( len, options.dtype, rand ); + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var v; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = dnanvariancewd.ndarray( x.length, 1, x, 1, 0 ); + if ( isnan( v ) ) { + b.fail( 'should not return NaN' ); + } + } + b.toc(); + if ( isnan( v ) ) { + 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/stats/strided/wasm/dnanvariancewd/docs/repl.txt b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/repl.txt new file mode 100644 index 000000000000..64cd2d150b15 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/repl.txt @@ -0,0 +1,552 @@ + +{{alias}}.main( N, correction, x, strideX ) + Computes the variance of a double-precision floating-point strided array + ignoring `NaN` values and using Welford's 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. + + correction: number + Degrees of freedom adjustment. Setting this parameter to a value other + than `0` has the effect of adjusting the divisor during the calculation + of the variance according to `n - c` where `c` corresponds to the + provided degrees of freedom adjustment and `n` corresponds to the number + of non-`NaN` indexed elements. When computing the variance of a + population, setting this parameter to `0` is the standard choice (i.e., + the provided array contains data constituting an entire population). + When computing the unbiased sample variance, setting this parameter to + `1` is the standard choice (i.e., the provided array contains data + sampled from a larger population; this is commonly referred to as + Bessel's correction). + + x: Float64Array + Input array. + + strideX: integer + Stride length. + + Returns + ------- + out: number + The variance. + + Examples + -------- + // Standard Usage: + > var x = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, NaN, 2.0 ] ); + > {{alias}}.main( x.length, 1, x, 1 ) + ~4.3333 + + // Using `N` and stride parameters: + > x = new {{alias:@stdlib/array/float64}}( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ] ); + > {{alias}}.main( 4, 1, x, 2 ) + ~4.3333 + + // Using view offsets: + > var x0 = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] ); + > var x1 = new {{alias:@stdlib/array/float64}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); + > {{alias}}.main( 4, 1, x1, 2) + ~4.3333 + + +{{alias}}.ndarray( N, correction, x, strideX, offsetX ) + Computes the variance of a double-precision floating-point strided array + ignoring `NaN` values and using Welford's 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. + + correction: number + Degrees of freedom adjustment. Setting this parameter to a value other + than `0` has the effect of adjusting the divisor during the calculation + of the variance according to `n - c` where `c` corresponds to the + provided degrees of freedom adjustment and `n` corresponds to the number + of non-`NaN` indexed elements. When computing the variance of a + population, setting this parameter to `0` is the standard choice (i.e., + the provided array contains data constituting an entire population). + When computing the unbiased sample variance, setting this parameter to + `1` is the standard choice (i.e., the provided array contains data + sampled from a larger population; this is commonly referred to as + Bessel's correction). + + x: Float64Array + Input array. + + strideX: integer + Stride length. + + offsetX: integer + Starting index. + + Returns + ------- + out: number + The variance. + + Examples + -------- + // Standard Usage: + > var x = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, NaN, 2.0 ] ); + > {{alias}}.ndarray( x.length, 1, x, 1, 0 ) + ~4.3333 + + // Using offset parameter: + > x = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] ); + > {{alias}}.ndarray( 4, 1, x, 2, 1 ) + ~4.3333 + + +{{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, xp, sx ) + Computes the variance of a double-precision floating-point strided array + ignoring `NaN` values and using Welford's algorithm. + + Parameters + ---------- + N: integer + Number of indexed elements. + + correction: number + Degrees of freedom adjustment. Setting this parameter to a value other + than `0` has the effect of adjusting the divisor during the calculation + of the variance according to `n - c` where `c` corresponds to the + provided degrees of freedom adjustment and `n` corresponds to the number + of non-`NaN` indexed elements. When computing the variance of a + population, setting this parameter to `0` is the standard choice (i.e., + the provided array contains data constituting an entire population). + When computing the unbiased sample variance, setting this parameter to + `1` is the standard choice (i.e., the provided array contains data + sampled from a larger population; this is commonly referred to as + Bessel's correction). + + xp: integer + Input array pointer (i.e., byte offset). + + sx: integer + Stride length. + + Returns + ------- + out: number + The variance. + + 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, 1, xptr, 1 ) + 1.0 + + +{{alias}}.Module.prototype.ndarray( N, xp, sx, ox ) + Computes the variance of a double-precision floating-point strided array + ignoring `NaN` values and using Welford's algorithm and alternative + indexing semantics. + + Parameters + ---------- + N: integer + Number of indexed elements. + + correction: number + Degrees of freedom adjustment. Setting this parameter to a value other + than `0` has the effect of adjusting the divisor during the calculation + of the variance according to `n - c` where `c` corresponds to the + provided degrees of freedom adjustment and `n` corresponds to the number + of non-`NaN` indexed elements. When computing the variance of a + population, setting this parameter to `0` is the standard choice (i.e., + the provided array contains data constituting an entire population). + When computing the unbiased sample variance, setting this parameter to + `1` is the standard choice (i.e., the provided array contains data + sampled from a larger population; this is commonly referred to as + Bessel's correction). + + xp: integer + Input array pointer (i.e., byte offset). + + sx: integer + Stride length. + + ox: integer + Starting index. + + Returns + ------- + out: number + The variance. + + 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, 1, xptr, 1, 0 ) + 1.0 + + See Also + -------- + diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/types/index.d.ts new file mode 100644 index 000000000000..4359e824fea0 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/types/index.d.ts @@ -0,0 +1,321 @@ +/* +* @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. +*/ + +// 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 new routine: + * var mod = new dnanvariancewd.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 y = mod.main( N, 1, xptr, 1 ); + * // returns 1.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 new routine: + * var mod = dnanvariancewd.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 y = mod.main( N, 1, xptr, 1 ); + * // returns 1.0 + */ + ( mem: Memory ): Module; // callable +} + +/** +* Interface describing a `dnanvariancewd` WebAssembly module. +*/ +interface Module extends ModuleWrapper { + /** + * Computes the variance of a double-precision floating-point strided array ignoring `NaN` values and using Welford's algorithm. + * + * @param N - number of indexed elements + * @param correction - degrees of freedom adjustment + * @param xptr - input array pointer (i.e., byte offset) + * @param strideX - stride length + * @returns variance + * + * @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 new routine: + * var mod = new dnanvariancewd.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 y = mod.main( N, 1, xptr, 1 ); + * // returns 1.0 + */ + main( N: number, correction: number, xptr: number, strideX: number ): number; + + /** + * Computes the variance of a double-precision floating-point strided array ignoring `NaN` values and using Welford's algorithm and alternative indexing semantics. + * + * @param N - number of indexed elements + * @param correction - degrees of freedom adjustment + * @param xptr - input array pointer (i.e., byte offset) + * @param strideX - stride length + * @param offsetX - starting index + * @returns variance + * + * @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 new routine: + * var mod = new dnanvariancewd.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 y = mod.ndarray( N, 1, xptr, 1, 0 ); + * // returns 1.0 + */ + ndarray( N: number, correction: number, xptr: number, strideX: number, offsetX: number ): number; +} + +/** +* Interface describing `dnanvariancewd`. +*/ +interface Routine extends ModuleWrapper { + /** + * Computes the variance of a double-precision floating-point strided array ignoring `NaN` values and using Welford's algorithm. + * + * @param N - number of indexed elements + * @param correction - degrees of freedom adjustment + * @param x - input array + * @param strideX - stride length + * @returns variance + * + * @example + * var Float64Array = require( '@stdlib/array/float64' ); + * + * var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); + * + * var y = dnanvariancewd.main( 4, 1, x, 1 ); + * // returns ~4.3333 + */ + main( N: number, x: Float64Array, strideX: number ): number; + + /** + * Computes the variance of a double-precision floating-point strided array ignoring `NaN` values and using Welford's algorithm and alternative indexing semantics. + * + * @param N - number of indexed elements + * @param correction - degrees of freedom adjustment + * @param x - input array + * @param strideX - stride length + * @param offsetX - starting index + * @returns variance + * + * @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, NaN, NaN ] ); + * + * var out = dnanvariancewd.ndarray( 5, 1, x, 2, 1 ); + * // returns ~4.7857 + */ + ndarray( N: number, correction: 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 new routine: + * var mod = new dnanvariancewd.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 y = mod.main( N, 1, xptr, 1 ); + * // returns 1.0 + */ + Module: ModuleConstructor; +} + +/** +* Computes the variance of a double-precision floating-point strided array ignoring `NaN` values and using Welford's algorithm. +* +* @param N - number of indexed elements +* @param correction - degrees of freedom adjustment +* @param x - input array +* @param strideX - stride length +* @returns variance +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); +* +* var y = dnanvariancewd.main( 4, 1, x, 1 ); +* // returns ~4.3333 +* +* @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, NaN, NaN ] ); +* +* var y = dnanvariancewd.ndarray( 5, 1, x, 2, 1 ); +* // returns ~4.7857 +*/ +declare var dnanvariancewd: Routine; + + +// EXPORTS // + +export = dnanvariancewd; diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/types/test.ts b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/types/test.ts new file mode 100644 index 000000000000..1b588112f756 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/types/test.ts @@ -0,0 +1,415 @@ +/* +* @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. +*/ + +/* eslint-disable space-in-parens */ + +import Memory = require( '@stdlib/wasm/memory' ); +import dnanvariancewd = require( './index' ); + + +// TESTS // + +// Attached to the main export is a `main` method which returns a number... +{ + const x = new Float64Array( 10 ); + + dnanvariancewd.main( x.length, 1, 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 ); + + dnanvariancewd.main( '10', 1, x, 1 ); // $ExpectError + dnanvariancewd.main( true, 1, x, 1 ); // $ExpectError + dnanvariancewd.main( false, 1, x, 1 ); // $ExpectError + dnanvariancewd.main( null, 1, x, 1 ); // $ExpectError + dnanvariancewd.main( undefined, 1, x, 1 ); // $ExpectError + dnanvariancewd.main( [], 1, x, 1 ); // $ExpectError + dnanvariancewd.main( {}, 1, x, 1 ); // $ExpectError + dnanvariancewd.main( ( x: number ): number => x, 1, x, 1 ); // $ExpectError +} + +// The compiler throws an error if the `main` method is provided a second argument which is not a Float64Array... +{ + const x = new Float64Array( 10 ); + + dnanvariancewd.main( x.length, 10, x, 1 ); // $ExpectError + dnanvariancewd.main( x.length, '10', x, 1 ); // $ExpectError + dnanvariancewd.main( x.length, true, x, 1 ); // $ExpectError + dnanvariancewd.main( x.length, false, x, 1 ); // $ExpectError + dnanvariancewd.main( x.length, null, x, 1 ); // $ExpectError + dnanvariancewd.main( x.length, undefined, x, 1 ); // $ExpectError + dnanvariancewd.main( x.length, [], x, 1 ); // $ExpectError + dnanvariancewd.main( x.length, {}, x, 1 ); // $ExpectError + dnanvariancewd.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 ); + + dnanvariancewd.main( x.length, 1, 10, 1 ); // $ExpectError + dnanvariancewd.main( x.length, 1, '10', 1 ); // $ExpectError + dnanvariancewd.main( x.length, 1, true, 1 ); // $ExpectError + dnanvariancewd.main( x.length, 1, false, 1 ); // $ExpectError + dnanvariancewd.main( x.length, 1, null, 1 ); // $ExpectError + dnanvariancewd.main( x.length, 1, undefined, 1 ); // $ExpectError + dnanvariancewd.main( x.length, 1, [], 1 ); // $ExpectError + dnanvariancewd.main( x.length, 1, {}, 1 ); // $ExpectError + dnanvariancewd.main( x.length, 1, ( 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 ); + + dnanvariancewd.main( x.length, 1, x, '10' ); // $ExpectError + dnanvariancewd.main( x.length, 1, x, true ); // $ExpectError + dnanvariancewd.main( x.length, 1, x, false ); // $ExpectError + dnanvariancewd.main( x.length, 1, x, null ); // $ExpectError + dnanvariancewd.main( x.length, 1, x, undefined ); // $ExpectError + dnanvariancewd.main( x.length, 1, x, [] ); // $ExpectError + dnanvariancewd.main( x.length, 1, x, {} ); // $ExpectError + dnanvariancewd.main( x.length, 1, 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 ); + + dnanvariancewd.main(); // $ExpectError + dnanvariancewd.main( x.length ); // $ExpectError + dnanvariancewd.main( x.length, x ); // $ExpectError + dnanvariancewd.main( x.length, 1, x ); // $ExpectError + dnanvariancewd.main( x.length, 1, x, 1, 10 ); // $ExpectError +} + +// Attached to main export is an `ndarray` method which returns a number... +{ + const x = new Float64Array( 10 ); + + dnanvariancewd.ndarray( x.length, 1, 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 ); + + dnanvariancewd.ndarray( '10', 1, x, 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( true, 1, x, 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( false, 1, x, 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( null, 1, x, 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( undefined, 1, x, 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( [], 1, x, 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( {}, 1, x, 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( ( x: number ): number => x, 1, x, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a first argument which is not a number... +{ + const x = new Float64Array( 10 ); + + dnanvariancewd.ndarray( x.length, 10, x, 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, '10', x, 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, true, x, 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, false, x, 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, null, x, 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, undefined, x, 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, [], x, 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, {}, x, 1, 0 ); // $ExpectError + dnanvariancewd.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 ); + + dnanvariancewd.ndarray( x.length, 1, 10, 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, '10', 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, true, 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, false, 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, null, 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, undefined, 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, [], 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, {}, 1, 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, ( 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 ); + + dnanvariancewd.ndarray( x.length, 1, x, '10', 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, x, true, 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, x, false, 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, x, null, 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, x, undefined, 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, x, [], 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, x, {}, 0 ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, x, ( x: number ): number => x, 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 ); + + dnanvariancewd.ndarray( x.length, 1, x, 1, '10' ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, x, 1, true ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, x, 1, false ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, x, 1, null ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, x, 1, undefined ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, x, 1, [] ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, x, 1, {} ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, 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 ); + + dnanvariancewd.ndarray(); // $ExpectError + dnanvariancewd.ndarray( x.length ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1 ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, x ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, x, 1 ); // $ExpectError + dnanvariancewd.ndarray( x.length, 1, x, 1, 0, 10 ); // $ExpectError +} + +// Attached to the main export is a `Module` constructor which returns a module... +{ + const mem = new Memory({ + 'initial': 0 + }); + + dnanvariancewd.Module( mem ); // $ExpectType Module +} + +// The compiler throws an error if the `Module` constructor is not provided a WebAssembly memory instance... +{ + dnanvariancewd.Module( '10' ); // $ExpectError + dnanvariancewd.Module( true ); // $ExpectError + dnanvariancewd.Module( false ); // $ExpectError + dnanvariancewd.Module( null ); // $ExpectError + dnanvariancewd.Module( undefined ); // $ExpectError + dnanvariancewd.Module( [] ); // $ExpectError + dnanvariancewd.Module( {} ); // $ExpectError + dnanvariancewd.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 = dnanvariancewd.Module( mem ); + + mod.main( 10, 1, 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 = dnanvariancewd.Module( mem ); + + mod.main( '10', 1, 0, 1 ); // $ExpectError + mod.main( true, 1, 0, 1 ); // $ExpectError + mod.main( false, 1, 0, 1 ); // $ExpectError + mod.main( null, 1, 0, 1 ); // $ExpectError + mod.main( undefined, 1, 0, 1 ); // $ExpectError + mod.main( [], 1, 0, 1 ); // $ExpectError + mod.main( {}, 1, 0, 1 ); // $ExpectError + mod.main( ( x: number ): number => x, 1, 0, 1 ); // $ExpectError +} + +// 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 = dnanvariancewd.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 = dnanvariancewd.Module( mem ); + + mod.main( 10, 1, '10', 1 ); // $ExpectError + mod.main( 10, 1, true, 1 ); // $ExpectError + mod.main( 10, 1, false, 1 ); // $ExpectError + mod.main( 10, 1, null, 1 ); // $ExpectError + mod.main( 10, 1, undefined, 1 ); // $ExpectError + mod.main( 10, 1, [], 1 ); // $ExpectError + mod.main( 10, 1, {}, 1 ); // $ExpectError + mod.main( 10, 1, ( 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 = dnanvariancewd.Module( mem ); + + mod.main( 10, 1, 0, '10' ); // $ExpectError + mod.main( 10, 1, 0, true ); // $ExpectError + mod.main( 10, 1, 0, false ); // $ExpectError + mod.main( 10, 1, 0, null ); // $ExpectError + mod.main( 10, 1, 0, undefined ); // $ExpectError + mod.main( 10, 1, 0, [] ); // $ExpectError + mod.main( 10, 1, 0, {} ); // $ExpectError + mod.main( 10, 1, 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 = dnanvariancewd.Module( mem ); + + mod.main(); // $ExpectError + mod.main( 10 ); // $ExpectError + mod.main( 10, 1 ); // $ExpectError + mod.main( 10, 1, 0 ); // $ExpectError + mod.main( 10, 1, 0, 1, 5 ); // $ExpectError +} + +// The `Module` constructor returns a module instance having an `ndarray` method which returns a number... +{ + const mem = new Memory({ + 'initial': 1 + }); + const mod = dnanvariancewd.Module( mem ); + + mod.ndarray( 10, 1, 0, 1, 0 ); // $ExpectType number +} + +// 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 = dnanvariancewd.Module( mem ); + + mod.ndarray( '10', 1, 0, 1, 0 ); // $ExpectError + mod.ndarray( true, 1, 0, 1, 0 ); // $ExpectError + mod.ndarray( false, 1, 0, 1, 0 ); // $ExpectError + mod.ndarray( null, 1, 0, 1, 0 ); // $ExpectError + mod.ndarray( undefined, 1, 0, 1, 0 ); // $ExpectError + mod.ndarray( [], 1, 0, 1, 0 ); // $ExpectError + mod.ndarray( {}, 1, 0, 1, 0 ); // $ExpectError + mod.ndarray( ( x: number ): number => x, 1, 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 = dnanvariancewd.Module( mem ); + + mod.ndarray( 1, '10', 0, 1, 0 ); // $ExpectError + mod.ndarray( 1, true, 0, 1, 0 ); // $ExpectError + mod.ndarray( 1, false, 0, 1, 0 ); // $ExpectError + mod.ndarray( 1, null, 0, 1, 0 ); // $ExpectError + mod.ndarray( 1, undefined, 0, 1, 0 ); // $ExpectError + mod.ndarray( 1, [], 0, 1, 0 ); // $ExpectError + mod.ndarray( 1, {}, 0, 1, 0 ); // $ExpectError + mod.ndarray( 1, ( 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 = dnanvariancewd.Module( mem ); + + mod.ndarray( 10, 1, '10', 1, 0 ); // $ExpectError + mod.ndarray( 10, 1, true, 1, 0 ); // $ExpectError + mod.ndarray( 10, 1, false, 1, 0 ); // $ExpectError + mod.ndarray( 10, 1, null, 1, 0 ); // $ExpectError + mod.ndarray( 10, 1, undefined, 1, 0 ); // $ExpectError + mod.ndarray( 10, 1, [], 1, 0 ); // $ExpectError + mod.ndarray( 10, 1, {}, 1, 0 ); // $ExpectError + mod.ndarray( 10, 1, ( 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 = dnanvariancewd.Module( mem ); + + mod.ndarray( 10, 1, 0, '10', 0 ); // $ExpectError + mod.ndarray( 10, 1, 0, true, 0 ); // $ExpectError + mod.ndarray( 10, 1, 0, false, 0 ); // $ExpectError + mod.ndarray( 10, 1, 0, null, 0 ); // $ExpectError + mod.ndarray( 10, 1, 0, undefined, 0 ); // $ExpectError + mod.ndarray( 10, 1, 0, [], 0 ); // $ExpectError + mod.ndarray( 10, 1, 0, {}, 0 ); // $ExpectError + mod.ndarray( 10, 1, 0, ( x: number ): number => x, 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 = dnanvariancewd.Module( mem ); + + mod.ndarray( 10, 1, 0, 1, '10' ); // $ExpectError + mod.ndarray( 10, 1, 0, 1, true ); // $ExpectError + mod.ndarray( 10, 1, 0, 1, false ); // $ExpectError + mod.ndarray( 10, 1, 0, 1, null ); // $ExpectError + mod.ndarray( 10, 1, 0, 1, undefined ); // $ExpectError + mod.ndarray( 10, 1, 0, 1, [] ); // $ExpectError + mod.ndarray( 10, 1, 0, 1, {} ); // $ExpectError + mod.ndarray( 10, 1, 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 = dnanvariancewd.Module( mem ); + + mod.ndarray(); // $ExpectError + mod.ndarray( 10 ); // $ExpectError + mod.ndarray( 10, 1 ); // $ExpectError + mod.ndarray( 10, 1, 0 ); // $ExpectError + mod.ndarray( 10, 1, 0, 1 ); // $ExpectError + mod.ndarray( 10, 1, 0, 1, 0, 10 ); // $ExpectError +} diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/examples/index.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/examples/index.js new file mode 100644 index 000000000000..5823b3feb7fe --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/examples/index.js @@ -0,0 +1,43 @@ +/** +* @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'; + +var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' ); +var oneTo = require( '@stdlib/array/one-to' ); +var dnanvariancewd = 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 v = dnanvariancewd.ndarray( N, 1, x, 1, 0 ); + + // Print the result: + console.log( v ); +} + +main(); diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/examples/little_endian_arrays.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/examples/little_endian_arrays.js new file mode 100644 index 000000000000..d6f1d14189b2 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/examples/little_endian_arrays.js @@ -0,0 +1,65 @@ +/** +* @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'; + +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 dnanvariancewd = 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 new routine: + var mod = new dnanvariancewd.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 v = mod.ndarray( N, 1, xptr, 1, 0 ); + + // Print the result: + console.log( v ); +} + +main(); diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/examples/module.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/examples/module.js new file mode 100644 index 000000000000..a3e0dace9b67 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/examples/module.js @@ -0,0 +1,63 @@ +/** +* @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'; + +var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' ); +var Memory = require( '@stdlib/wasm/memory' ); +var oneTo = require( '@stdlib/array/one-to' ); +var dnanvariancewd = 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 new routine: + var mod = new dnanvariancewd.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 v = mod.ndarray( N, 1, xptr, 1, 0 ); + + // Print the result: + console.log( v ); +} + +main(); diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/binary.browser.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/binary.browser.js new file mode 100644 index 000000000000..5249fd38aa72 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/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/fwF8Ag8BA2VudgZtZW1vcnkCAAADBAMAAQIHXQMRX193YXNtX2NhbGxfY3RvcnMAAB1zdGRsaWJfc3RyaWRlZF9kbmFudmFyaWFuY2V3ZAABJXN0ZGxpYl9zdHJpZGVkX2RuYW52YXJpYW5jZXdkX25kYXJyYXkAAgrtAQMDAAELHAAgACABIAIgA0EBIABrIANsQQAgA0EATBsQAgvJAQIFfAJ/RAAAAAAAAPh/IQgCQAJAIABBAEwNACADRSAAQQFGcg0BA0AgACALRkUEQCACIARBA3RqKwMAIgcgB2EEQCAHIAahIgkgByAGIAkgCkEBaiIKt6OgIgahoiAFoCEFCyALQQFqIQsgAyAEaiEEDAELCyAKtyABoSIBRAAAAAAAAAAAZQ0AIAUgAaMhCAsgCA8LRAAAAAAAAAAARAAAAAAAAPh/IAEgALhjG0QAAAAAAAD4fyACIARBA3RqKwMAIgEgAWEbCw==' ); + + +// EXPORTS // + +module.exports = wasm; diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/binary.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/binary.js new file mode 100644 index 000000000000..2b83fe651780 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/binary.js @@ -0,0 +1,34 @@ +/** +* @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 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/stats/strided/wasm/dnanvariancewd/lib/index.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/index.js new file mode 100644 index 000000000000..b58f10d807e9 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/index.js @@ -0,0 +1,100 @@ +/** +* @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'; + +/** +* WebAssembly routine to compute the variance of a double-precision floating-point strided array ignoring `NaN` values and using Welford's algorithm. +* +* @module @stdlib/stats/strided/wasm/dnanvariancewd +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* var dnanvariancewd = require( '@stdlib/stats/strided/wasm/dnanvariancewd' ); +* +* // Define a strided array: +* var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); +* +* // Perform operation: +* var v = dnanvariancewd.main( x.length, 1, x, 1 ); +* // returns ~6.3333 +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* var dnanvariancewd = require( '@stdlib/stats/strided/wasm/dnanvariancewd' ); +* +* // Define a strided array: +* var x = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN, NaN ] ); +* +* // Perform operation: +* var v = dnanvariancewd.ndarray( 5, 1, x, 2, 1 ); +* // returns ~4.7857 +* +* @example +* var Memory = require( '@stdlib/wasm/memory' ); +* var oneTo = require( '@stdlib/array/one-to' ); +* var zeros = require( '@stdlib/array/zeros' ); +* var dnanvariancewd = require( '@stdlib/stats/strided/wasm/dnanvariancewd' ); +* +* // 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 new routine: +* var mod = new dnanvariancewd.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 v = mod.main( 3, 1, xptr, 1 ); +* // returns 1.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/stats/strided/wasm/dnanvariancewd/lib/main.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/main.js new file mode 100644 index 000000000000..d53ac9a25838 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/main.js @@ -0,0 +1,60 @@ +/** +* @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 Routine = require( './routine.js' ); + + +// MAIN // + +/** +* WebAssembly routine to compute the variance of a double-precision floating-point strided array ignoring `NaN` values and using Welford's algorithm. +* +* @name dnanvariancewd +* @type {Routine} +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* // Define a strided array: +* var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); +* +* // Perform operation: +* var v = dnanvariancewd.main( 4, 1, x, 1 ); +* // returns ~6.3333 +* +* @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, NaN, NaN ] ); +* +* // Perform operation: +* var v = dnanvariancewd.ndarray( 5, 1, x, 2, 1 ); +* // returns ~4.7857 +*/ +var dnanvariancewd = new Routine(); +dnanvariancewd.initializeSync(); // eslint-disable-line node/no-sync + + +// EXPORTS // + +module.exports = dnanvariancewd; diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/module.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/module.js new file mode 100644 index 000000000000..4ae1d3d6c6bc --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/module.js @@ -0,0 +1,200 @@ +/** +* @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. +*/ + +/* 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 // + +/** +* 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 new routine: +* var dnanvariancewd = new Module( mem ); +* // returns +* +* // Initialize the routine: +* dnanvariancewd.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: +* dnanvariancewd.write( xptr, oneTo( N, dtype ) ); +* +* // Perform computation: +* var v = dnanvariancewd.main( N, 1, xptr, 1 ); +* // returns 1.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 ); + +/** +* Computes the variance of a double-precision floating-point strided array ignoring `NaN` values and using Welford's algorithm. +* +* @name main +* @memberof Module.prototype +* @readonly +* @type {Function} +* @param {PositiveInteger} N - number of indexed elements +* @param {number} correction - degrees of freedom adjustment +* @param {Float64Array} x - input array +* @param {integer} strideX - stride length +* @returns {number} arithmetic mean +* +* @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 new routine: +* var dnanvariancewd = new Module( mem ); +* // returns +* +* // Initialize the routine: +* dnanvariancewd.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: +* dnanvariancewd.write( xptr, oneTo( N, dtype ) ); +* +* // Perform computation: +* var v = dnanvariancewd.main( N, 1, xptr, 1 ); +* // returns 1.0 +*/ +setReadOnly( Module.prototype, 'main', function dnanvariancewd( N, correction, xptr, strideX ) { + return this._instance.exports.stdlib_strided_dnanvariancewd( N, correction, xptr, strideX ); // eslint-disable-line max-len +}); + +/** +* Computes the variance of a double-precision floating-point strided array ignoring `NaN` values and using Welford's algorithm. +* +* @name ndarray +* @memberof Module.prototype +* @readonly +* @type {Function} +* @param {PositiveInteger} N - number of indexed elements +* @param {number} correction - degrees of freedom adjustment +* @param {Float64Array} x - input array +* @param {integer} strideX - stride length +* @param {NonNegativeInteger} offsetX - starting index +* @returns {number} arithmetic mean +* +* @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 new routine: +* var dnanvariancewd = new Module( mem ); +* // returns +* +* // Initialize the routine: +* dnanvariancewd.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: +* dnanvariancewd.write( xptr, oneTo( N, dtype ) ); +* +* // Perform computation: +* var sum = dnanvariancewd.ndarray( N, 1, xptr, 1, 0 ); +* // returns 1.0 +*/ +setReadOnly( Module.prototype, 'ndarray', function dnanvariancewd( N, correction, xptr, strideX, offsetX ) { + return this._instance.exports.stdlib_strided_dnanvariancewd_ndarray( N, correction, xptr, strideX, offsetX ); // eslint-disable-line max-len +}); + + +// EXPORTS // + +module.exports = Module; diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/routine.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/routine.js new file mode 100644 index 000000000000..153bd8aabd12 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/routine.js @@ -0,0 +1,168 @@ +/** +* @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. +*/ + +/* 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 dnanvariancewd = new Routine(); +* +* // Initialize the module: +* dnanvariancewd.initializeSync(); +* +* // Define a strided array: +* var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); +* +* // Perform operation: +* var v = dnanvariancewd.main( 4, 1, x, 1 ); +* // returns ~4.3333 +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* // Create a new routine: +* var dnanvariancewd = new Routine(); +* +* // Initialize the module: +* dnanvariancewd.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, NaN, NaN ] ); +* +* // Perform operation: +* var sum = dnanvariancewd.ndarray( 5, 1, x, 2, 1 ); +* // returns ~4.7857 +*/ +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 ); + +/** +* Computes the variance of a double-precision floating-point strided array ignoring `NaN` values and using Welford's algorithm. +* +* @name main +* @memberof Routine.prototype +* @readonly +* @type {Function} +* @param {PositiveInteger} N - number of indexed elements +* @param {number} correction - degrees of freedom adjustment +* @param {Float64Array} x - input array +* @param {integer} strideX - stride length +* @returns {number} arithmetic mean +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* // Create a new routine: +* var dnanvariancewd = new Routine(); +* +* // Initialize the module: +* dnanvariancewd.initializeSync(); +* +* // Define a strided array: +* var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] ); +* +* // Perform operation: +* var v = dnanvariancewd.main( 4, 1, x, 1 ); +* // returns ~4.3333 +*/ +setReadOnly( Routine.prototype, 'main', function dnanvariancewd( N, correction, x, strideX ) { + return this.ndarray( N, correction, x, strideX, stride2offset( N, strideX ) ); +}); + +/** +* Computes the variance of a double-precision floating-point strided array ignoring `NaN` values and using Welford's algorithm and alternative indexing semantics. +* +* @name ndarray +* @memberof Routine.prototype +* @readonly +* @type {Function} +* @param {PositiveInteger} N - number of indexed elements +* @param {number} correction - degrees of freedom adjustment +* @param {Float64Array} x - input array +* @param {integer} strideX - stride length +* @param {NonNegativeInteger} offsetX - starting index +* @returns {number} arithmetic mean +* +* @example +* var Float64Array = require( '@stdlib/array/float64' ); +* +* // Create a new routine: +* var dnanvariancewd = new Routine(); +* +* // Initialize the module: +* dnanvariancewd.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, NaN, NaN ] ); +* +* // Perform operation: +* var v = dnanvariancewd.ndarray( 5, 1, x, 2, 1 ); +* // returns ~4.7857 +*/ +setReadOnly( Routine.prototype, 'ndarray', function dnanvariancewd( N, correction, 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, correction, p0.ptr, p0.stride, p0.offset ); +}); + + +// EXPORTS // + +module.exports = Routine; diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/manifest.json b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/manifest.json new file mode 100644 index 000000000000..7011de46b7ad --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/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/stats/strided/dnanvariancewd" + ] + } + ] +} diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/package.json b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/package.json new file mode 100644 index 000000000000..42b1c6ea0356 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/package.json @@ -0,0 +1,86 @@ +{ + "name": "@stdlib/stats/strided/wasm/dnanvariancewd", + "version": "0.0.0", + "description": "Calculate the variance of a double-precision floating-point strided array ignoring NaN values and using Welford's 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", + "statistics", + "stats", + "mathematics", + "math", + "variance", + "var", + "deviation", + "dispersion", + "sample variance", + "unbiased", + "stdev", + "std", + "standard deviation", + "welford", + "strided", + "strided array", + "typed", + "array", + "float64", + "double", + "float64array", + "webassembly", + "wasm" + ], + "__stdlib__": { + "wasm": true + } +} diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/scripts/build.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/scripts/build.js new file mode 100644 index 000000000000..66bf9650b6d6 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/scripts/build.js @@ -0,0 +1,66 @@ +#!/usr/bin/env node + +/** +* @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 resolve = require( 'path' ).resolve; +var readFile = require( '@stdlib/fs/read-file' ).sync; +var writeFile = require( '@stdlib/fs/write-file' ).sync; +var replace = require( '@stdlib/string/replace' ); +var currentYear = require( '@stdlib/time/current-year' ); + + +// VARIABLES // + +var wpath = resolve( __dirname, '..', 'src', 'main.wasm' ); +var tpath = resolve( __dirname, 'template.txt' ); +var opath = resolve( __dirname, '..', 'lib', 'binary.browser.js' ); + +var opts = { + 'encoding': 'utf8' +}; + +var PLACEHOLDER = '{{WASM_BASE64}}'; +var YEAR = '{{YEAR}}'; + + +// MAIN // + +/** +* Main execution sequence. +* +* @private +*/ +function main() { + var wasm; + var tmpl; + + wasm = readFile( wpath ); + tmpl = readFile( tpath, opts ); + + tmpl = replace( tmpl, YEAR, currentYear().toString() ); + tmpl = replace( tmpl, PLACEHOLDER, wasm.toString( 'base64' ) ); + + writeFile( opath, tmpl, opts ); +} + +main(); diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/scripts/template.txt b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/scripts/template.txt new file mode 100644 index 000000000000..f66cdb9735b1 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/scripts/template.txt @@ -0,0 +1,33 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) {{YEAR}} The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var base64ToUint8Array = require( '@stdlib/string/base/base64-to-uint8array' ); + + +// MAIN // + +var wasm = base64ToUint8Array( '{{WASM_BASE64}}' ); + + +// EXPORTS // + +module.exports = wasm; diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/src/Makefile b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/src/Makefile new file mode 100644 index 000000000000..1b1f35347760 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/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/stats/strided/wasm/dnanvariancewd/src/exports.json b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/src/exports.json new file mode 100644 index 000000000000..0f3f76c21cd7 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/src/exports.json @@ -0,0 +1,4 @@ +[ + "_stdlib_strided_dnanvariancewd", + "_stdlib_strided_dnanvariancewd_ndarray" +] diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/src/main.wasm b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/src/main.wasm new file mode 100755 index 0000000000000000000000000000000000000000..4721f860dc5cd3cd90623e1958cc2f47e05556a3 GIT binary patch literal 406 zcmaJ*!AiqG5S`iGG-=jSJ$S0ZB;ZL9KcNBJlfNL_HJd})B!x|ADHQT6js1xF3;h`H z9^HymPtN7Nd2e`cK-VRLn_*x!MP4l)9#Ncjyyi22nP|6di`$uZLPyvTc~-4@WmYcj zh5>NF0h#~8uasK5FqP_}P-(NYHNb7%m?D2wbz^gr8D%P6t+dT`m1b)Lc=xZbDx& kVHe|1FF@wnJi>hxND7AXte+nvBzR9pzx$szkWi207cbaU-v9sr literal 0 HcmV?d00001 diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/src/main.wat b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/src/main.wat new file mode 100644 index 000000000000..1100a4e762e0 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/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 i32) + f64.const nan (;=nan;) + local.set 8 + block ;; label = @1 + block ;; label = @2 + local.get 0 + i32.const 0 + i32.le_s + br_if 0 (;@2;) + local.get 3 + i32.eqz + local.get 0 + i32.const 1 + i32.eq + i32.or + br_if 1 (;@1;) + loop ;; label = @3 + local.get 0 + local.get 11 + i32.eq + i32.eqz + if ;; label = @4 + local.get 2 + local.get 4 + i32.const 3 + i32.shl + i32.add + f64.load + local.tee 7 + local.get 7 + f64.eq + if ;; label = @5 + local.get 7 + local.get 6 + f64.sub + local.tee 9 + local.get 7 + local.get 6 + local.get 9 + local.get 10 + i32.const 1 + i32.add + local.tee 10 + f64.convert_i32_s + f64.div + f64.add + local.tee 6 + f64.sub + f64.mul + local.get 5 + f64.add + local.set 5 + end + local.get 11 + i32.const 1 + i32.add + local.set 11 + local.get 3 + local.get 4 + i32.add + local.set 4 + br 1 (;@3;) + end + end + local.get 10 + f64.convert_i32_s + local.get 1 + f64.sub + local.tee 1 + f64.const 0x0p+0 (;=0;) + f64.le + br_if 0 (;@2;) + local.get 5 + local.get 1 + f64.div + local.set 8 + end + local.get 8 + return + end + f64.const 0x0p+0 (;=0;) + f64.const nan (;=nan;) + local.get 1 + local.get 0 + f64.convert_i32_u + f64.lt + select + f64.const nan (;=nan;) + local.get 2 + local.get 4 + i32.const 3 + i32.shl + i32.add + f64.load + local.tee 1 + local.get 1 + f64.eq + select) + (export "__wasm_call_ctors" (func 0)) + (export "stdlib_strided_dnanvariancewd" (func 1)) + (export "stdlib_strided_dnanvariancewd_ndarray" (func 2))) diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.js new file mode 100644 index 000000000000..24dcec089707 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.js @@ -0,0 +1,53 @@ +/** +* @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 tape = require( 'tape' ); +var dnanvariancewd = require( './../lib' ); + + +// TESTS // + +tape( 'main export is an object', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof dnanvariancewd, 'object', 'returns expected value' ); + t.end(); +}); + +tape( 'attached to the main export is a `main` method', function test( t ) { + t.strictEqual( typeof dnanvariancewd.main, 'function', 'returns expected value' ); + t.end(); +}); + +tape( 'attached to the main export is an `ndarray` method', function test( t ) { + t.strictEqual( typeof dnanvariancewd.ndarray, 'function', 'returns expected value' ); + t.end(); +}); + +tape( 'attached to the main export is a `Module` constructor', function test( t ) { + t.strictEqual( typeof dnanvariancewd.Module, 'function', 'returns expected value' ); + t.end(); +}); + +tape( 'the main export is a `Module` instance', function test( t ) { + t.strictEqual( dnanvariancewd instanceof dnanvariancewd.Module, true, 'returns expected value' ); + t.end(); +}); diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.main.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.main.js new file mode 100644 index 000000000000..1a6dc3e23148 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.main.js @@ -0,0 +1,315 @@ +/** +* @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 tape = require( 'tape' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var Float64Array = require( '@stdlib/array/float64' ); +var dnanvariancewd = require( './../lib' ); + + +// TESTS // + +tape( 'main export is an object', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof dnanvariancewd, 'object', 'main export is an object' ); + t.end(); +}); + +tape( 'the `main` method has an arity of 4', function test( t ) { + t.strictEqual( dnanvariancewd.main.length, 4, 'has expected arity' ); + t.end(); +}); + +tape( 'the `main` method calculates the population variance of a strided array (ignoring `NaN` values)', function test( t ) { + var x; + var v; + var i; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, NaN, 0.0, 3.0 ] ); + + v = dnanvariancewd.main( x.length, 0, x, 1 ); + t.strictEqual( v, 53.5/(x.length-1), 'returns expected value' ); + + x = new Float64Array( [ 1.0, NaN, NaN, -2.0, NaN, -4.0, NaN, 5.0, NaN, 0.0, 3.0, NaN ] ); // eslint-disable-line max-len + + v = dnanvariancewd.main( x.length, 0, x, 1 ); + t.strictEqual( v, 53.5/(x.length-6), 'returns expected value' ); + + x = new Float64Array( [ -4.0, NaN ] ); + + v = dnanvariancewd.main( x.length, 0, x, 1 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + x = new Float64Array( [ NaN, NaN ] ); + + v = dnanvariancewd.main( x.length, 0, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( [ NaN ] ); + v = dnanvariancewd.main( x.length, 0, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( [ 4.0 ] ); + v = dnanvariancewd.main( x.length, 0, x, 1 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + x = new Float64Array( 1e3 ); + for ( i = 0; i < 1e3; i++ ) { + x[ i ] = 100.0; + } + v = dnanvariancewd.main( x.length, 0, x, 1 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + x = new Float64Array( [ NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN ] ); // eslint-disable-line max-len + v = dnanvariancewd.main( x.length, 0, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( 1e3 ); + for ( i = 0; i < 1e3; i++ ) { + x[ i ] = NaN; + } + v = dnanvariancewd.main( x.length, 0, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the `main` method calculates the sample variance of a strided array (ignoring `NaN` values)', function test( t ) { + var x; + var v; + var i; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, NaN, 0.0, 3.0 ] ); + + v = dnanvariancewd.main( x.length, 1, x, 1 ); + t.strictEqual( v, 53.5/(x.length-2), 'returns expected value' ); + + x = new Float64Array( [ 1.0, NaN, NaN, -2.0, NaN, -4.0, NaN, 5.0, NaN, 0.0, 3.0, NaN ] ); // eslint-disable-line max-len + + v = dnanvariancewd.main( x.length, 1, x, 1 ); + t.strictEqual( v, 53.5/(x.length-7), 'returns expected value' ); + + x = new Float64Array( [ -4.0, NaN ] ); + + v = dnanvariancewd.main( x.length, 1, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( [ NaN, NaN ] ); + + v = dnanvariancewd.main( x.length, 1, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( [ NaN ] ); + v = dnanvariancewd.main( x.length, 1, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( [ 4.0 ] ); + v = dnanvariancewd.main( x.length, 1, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( 1e3 ); + for ( i = 0; i < 1e3; i++ ) { + x[ i ] = 100.0; + } + v = dnanvariancewd.main( x.length, 1, x, 1 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + x = new Float64Array( [ NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN ] ); // eslint-disable-line max-len + v = dnanvariancewd.main( x.length, 1, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( 1e3 ); + for ( i = 0; i < 1e3; i++ ) { + x[ i ] = NaN; + } + v = dnanvariancewd.main( x.length, 1, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter less than or equal to `0`, the `main` method returns `NaN`', function test( t ) { + var x; + var v; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dnanvariancewd.main( 0, 1, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + v = dnanvariancewd.main( -1, 1, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter equal to `1`, the `main` method returns a population variance of `0` provided the first element is not `NaN`', function test( t ) { + var x; + var v; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dnanvariancewd.main( 1, 0, x, 1 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + x = new Float64Array( [ NaN, 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dnanvariancewd.main( 1, 0, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter equal to `1`, the `main` method returns a sample variance equal to `NaN`', function test( t ) { + var x; + var v; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dnanvariancewd.main( 1, 1, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( [ NaN, 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dnanvariancewd.main( 1, 1, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided a `correction` parameter yielding a correction term less than or equal to `0`, the `main` method returns `NaN`', function test( t ) { + var x; + var v; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dnanvariancewd.main( x.length, x.length, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + v = dnanvariancewd.main( x.length, x.length+1, x, 1 ); + t.strictEqual( isnan( v ), true, '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, + NaN, // 4 + NaN + ]); + + v = dnanvariancewd.main( 5, 1, x, 2 ); + + t.strictEqual( v, 6.25, 'returns expected value' ); + t.end(); +}); + +tape( 'the `main` method supports a negative `stride` parameter', function test( t ) { + var x; + var v; + var i; + + x = new Float64Array([ + NaN, // 4 + NaN, + 1.0, // 3 + 2.0, + 2.0, // 2 + -7.0, + -2.0, // 1 + 3.0, + 4.0, // 0 + 2.0 + ]); + + v = dnanvariancewd.main( 5, 1, x, -2 ); + t.strictEqual( v, 6.25, 'returns expected value' ); + + x = new Float64Array( 1e3 ); + for ( i = 0; i < 1e3; i++ ) { + x[ i ] = 100.0; + } + v = dnanvariancewd.main( x.length, 1, x, -1 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided a `stride` parameter equal to `0`, the `main` method returns `0` provided the correction term is not less than `0` and the first element is not `NaN`', function test( t ) { + var x; + var v; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dnanvariancewd.main( x.length, 1, x, 0 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + x = new Float64Array( [ NaN, 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dnanvariancewd.main( x.length, 1, x, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dnanvariancewd.main( x.length, x.length, x, 0 ); + t.strictEqual( isnan( v ), true, '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, + NaN, // 4 + NaN + ]); + + x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element + + v = dnanvariancewd.main( 5, 1, x1, 2 ); + t.strictEqual( v, 6.25, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.module.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.module.js new file mode 100644 index 000000000000..0cdcd97ef151 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.module.js @@ -0,0 +1,154 @@ +/** +* @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 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/stats/strided/wasm/dnanvariancewd/test/test.module.main.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.module.main.js new file mode 100644 index 000000000000..95e069f77b88 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.module.main.js @@ -0,0 +1,355 @@ +/** +* @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. +*/ + +/* eslint-disable node/no-sync */ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var Memory = require( '@stdlib/wasm/memory' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +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 `main` method calculates the population variance of a strided array (ignoring `NaN` values)', function test( t ) { + var mem; + var mod; + var xp; + var y; + var i; + + 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, NaN, 0.0, 3.0 ] ) ); // eslint-disable-line max-len + y = mod.main( 7, 0, xp, 1 ); + t.strictEqual( y, 53.5/6, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ 1.0, NaN, NaN, -2.0, NaN, -4.0, NaN, 5.0, NaN, 0.0, 3.0, NaN ] ) ); // eslint-disable-line max-len + y = mod.main( 12, 0, xp, 1 ); + // 6 NaNs ignored => N=6 + t.strictEqual( y, 53.5/(12-6), 'returns expected value' ); + + mod.write( xp, new Float64Array( [ -4.0, NaN ] ) ); + y = mod.main( 2, 0, xp, 1 ); + t.strictEqual( y, 0.0, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ NaN, NaN ] ) ); + y = mod.main( 2, 0, xp, 1 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ NaN ] ) ); + y = mod.main( 1, 0, xp, 1 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ 4.0 ] ) ); + y = mod.main( 1, 0, xp, 1 ); + t.strictEqual( y, 0.0, 'returns expected value' ); + + mod.write( xp, new Float64Array( 1e3 ) ); + for ( i = 0; i < 1e3; i++ ) { + mod.write( xp + (i*8), new Float64Array( [ 100.0 ] ) ); + } + y = mod.main( 1000, 0, xp, 1 ); + t.strictEqual( y, 0.0, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN ] ) ); // eslint-disable-line max-len + y = mod.main( 10, 0, xp, 1 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + mod.write( xp, new Float64Array( 1e3 ) ); + for ( i = 0; i < 1e3; i++ ) { + mod.write( xp + (i*8), new Float64Array( [ NaN ] ) ); + } + y = mod.main( 1000, 0, xp, 1 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'a module instance `main` method calculates the sample variance of a strided array (ignoring `NaN` values)', function test( t ) { + var mem; + var mod; + var xp; + var y; + var i; + + 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, NaN, 0.0, 3.0 ] ) ); // eslint-disable-line max-len + y = mod.main( 7, 1, xp, 1 ); + t.strictEqual( y, 53.5/5, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ 1.0, NaN, NaN, -2.0, NaN, -4.0, NaN, 5.0, NaN, 0.0, 3.0, NaN ] ) ); // eslint-disable-line max-len + y = mod.main( 12, 1, xp, 1 ); + // 6 NaNs ignored => N=6, correction=1 => N-c=5 + t.strictEqual( y, 53.5/5, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ -4.0, NaN ] ) ); + y = mod.main( 2, 1, xp, 1 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ NaN, NaN ] ) ); + y = mod.main( 2, 1, xp, 1 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ NaN ] ) ); + y = mod.main( 1, 1, xp, 1 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ 4.0 ] ) ); + y = mod.main( 1, 1, xp, 1 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + mod.write( xp, new Float64Array( 1e3 ) ); + for ( i = 0; i < 1e3; i++ ) { + mod.write( xp + (i*8), new Float64Array( [ 100.0 ] ) ); + } + y = mod.main( 1000, 1, xp, 1 ); + t.strictEqual( y, 0.0, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN ] ) ); // eslint-disable-line max-len + y = mod.main( 10, 1, xp, 1 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + mod.write( xp, new Float64Array( 1e3 ) ); + for ( i = 0; i < 1e3; i++ ) { + mod.write( xp + (i*8), new Float64Array( [ NaN ] ) ); + } + y = mod.main( 1000, 1, xp, 1 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter less than or equal to `0`, a module instance `main` method returns `NaN`', 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, NaN ] ) ); + + y = mod.main( 0, 1, xp, 1 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + y = mod.main( -1, 1, xp, 1 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter equal to `1`, a module instance `main` method returns expected results for population vs sample variance', 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, NaN ] ) ); + + y = mod.main( 1, 0, xp, 1 ); + t.strictEqual( y, 0.0, 'population variance is 0' ); + + y = mod.main( 1, 1, xp, 1 ); + t.strictEqual( isnan( y ), true, 'sample variance is NaN' ); + + mod.write( xp, new Float64Array( [ NaN, 1.0, -2.0, -4.0, 5.0, 3.0 ] ) ); + y = mod.main( 1, 0, xp, 1 ); + t.strictEqual( isnan( y ), true, 'population variance is NaN when first element is NaN' ); + + t.end(); +}); + +tape( 'if provided a `correction` parameter yielding a correction term less than or equal to `0`, a module instance `main` method returns `NaN`', 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, NaN ] ) ); + + y = mod.main( 6, 6, xp, 1 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + y = mod.main( 6, 7, xp, 1 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'a module instance `main` method supports a `stride` parameter', 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, // 0 + 2.0, + 2.0, // 1 + -7.0, + -2.0, // 2 + 3.0, + 4.0, // 3 + 2.0, + NaN, // 4 + NaN + ])); + + y = mod.main( 5, 1, xp, 2 ); + t.strictEqual( y, 6.25, 'returns expected value' ); + + t.end(); +}); + +tape( 'a module instance `main` method supports a negative `stride` parameter', function test( t ) { + var mem; + var mod; + var xp; + var y; + var i; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + xp = 0; + + mod.write( xp, new Float64Array([ + NaN, // 4 + NaN, + 1.0, // 3 + 2.0, + 2.0, // 2 + -7.0, + -2.0, // 1 + 3.0, + 4.0, // 0 + 2.0 + ])); + + y = mod.main( 5, 1, xp, -2 ); + t.strictEqual( y, 6.25, 'returns expected value' ); + + mod.write( xp, new Float64Array( 1e3 ) ); + for ( i = 0; i < 1e3; i++ ) { + mod.write( xp + (i*8), new Float64Array( [ 100.0 ] ) ); + } + y = mod.main( 1000, 1, xp, -1 ); + t.strictEqual( y, 0.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided a `stride` parameter equal to `0`, a module instance `main` method returns `0` provided the correction term is not less than `0` and the first element is not `NaN`', 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, NaN ] ) ); + + y = mod.main( 6, 1, xp, 0 ); + t.strictEqual( y, 0.0, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ NaN, 1.0, -2.0, -4.0, 5.0, 3.0 ] ) ); + y = mod.main( 6, 1, xp, 0 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0, NaN ] ) ); + y = mod.main( 6, 6, xp, 0 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.module.ndarray.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.module.ndarray.js new file mode 100644 index 000000000000..08d94f5c1318 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.module.ndarray.js @@ -0,0 +1,307 @@ +/** +* @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. +*/ + +/* eslint-disable node/no-sync */ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var Memory = require( '@stdlib/wasm/memory' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +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 `ndarray` method calculates the population variance of a strided array (ignoring `NaN` values)', function test( t ) { + var mem; + var mod; + var xp; + var y; + var i; + + 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, NaN, 0.0, 3.0 ] ) ); // eslint-disable-line max-len + y = mod.ndarray( 7, 0, xp, 1, 0 ); + t.strictEqual( y, 53.5/(7-1), 'returns expected value' ); + + mod.write( xp, new Float64Array( [ 1.0, NaN, NaN, -2.0, NaN, -4.0, NaN, 5.0, NaN, 0.0, 3.0, NaN ] ) ); // eslint-disable-line max-len + y = mod.ndarray( 12, 0, xp, 1, 0 ); + t.strictEqual( y, 53.5/(12-6), 'returns expected value' ); + + mod.write( xp, new Float64Array( [ -4.0, NaN ] ) ); + y = mod.ndarray( 2, 0, xp, 1, 0 ); + t.strictEqual( y, 0.0, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ NaN, NaN ] ) ); + y = mod.ndarray( 2, 0, xp, 1, 0 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ NaN ] ) ); + y = mod.ndarray( 1, 0, xp, 1, 0 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ 4.0 ] ) ); + y = mod.ndarray( 1, 0, xp, 1, 0 ); + t.strictEqual( y, 0.0, 'returns expected value' ); + + mod.write( xp, new Float64Array( 1e3 ) ); + for ( i = 0; i < 1e3; i++ ) { + mod.write( xp + (i*8), new Float64Array( [ 100.0 ] ) ); + } + y = mod.ndarray( 1000, 0, xp, 1, 0 ); + t.strictEqual( y, 0.0, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN ] ) ); // eslint-disable-line max-len + y = mod.ndarray( 10, 0, xp, 1, 0 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + mod.write( xp, new Float64Array( 1e3 ) ); + for ( i = 0; i < 1e3; i++ ) { + mod.write( xp + (i*8), new Float64Array( [ NaN ] ) ); + } + y = mod.ndarray( 1000, 0, xp, 1, 0 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'a module instance `ndarray` method calculates the sample variance of a strided array (ignoring `NaN` values)', function test( t ) { + var mem; + var mod; + var xp; + var y; + var i; + + 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, NaN, 0.0, 3.0 ] ) ); // eslint-disable-line max-len + y = mod.ndarray( 7, 1, xp, 1, 0 ); + t.strictEqual( y, 53.5/(7-2), 'returns expected value' ); + + mod.write( xp, new Float64Array( [ 1.0, NaN, NaN, -2.0, NaN, -4.0, NaN, 5.0, NaN, 0.0, 3.0, NaN ] ) ); // eslint-disable-line max-len + y = mod.ndarray( 12, 1, xp, 1, 0 ); + t.strictEqual( y, 53.5/(12-7), 'returns expected value' ); + + mod.write( xp, new Float64Array( [ -4.0, NaN ] ) ); + y = mod.ndarray( 2, 1, xp, 1, 0 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ NaN, NaN ] ) ); + y = mod.ndarray( 2, 1, xp, 1, 0 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ NaN ] ) ); + y = mod.ndarray( 1, 1, xp, 1, 0 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ 4.0 ] ) ); + y = mod.ndarray( 1, 1, xp, 1, 0 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + mod.write( xp, new Float64Array( 1e3 ) ); + for ( i = 0; i < 1e3; i++ ) { + mod.write( xp + (i*8), new Float64Array( [ 100.0 ] ) ); + } + y = mod.ndarray( 1000, 1, xp, 1, 0 ); + t.strictEqual( y, 0.0, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN ] ) ); // eslint-disable-line max-len + y = mod.ndarray( 10, 1, xp, 1, 0 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + mod.write( xp, new Float64Array( 1e3 ) ); + for ( i = 0; i < 1e3; i++ ) { + mod.write( xp + (i*8), new Float64Array( [ NaN ] ) ); + } + y = mod.ndarray( 1000, 1, xp, 1, 0 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'a module instance `ndarray` method supports a `stride` parameter', 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, // 0 + 2.0, + 2.0, // 1 + -7.0, + -2.0, // 2 + 3.0, + 4.0, // 3 + 2.0, + NaN, // 4 + NaN + ])); + + y = mod.ndarray( 5, 1, xp, 2, 0 ); + t.strictEqual( y, 6.25, 'returns expected value' ); + + t.end(); +}); + +tape( 'a module instance `ndarray` method supports a negative `stride` parameter', function test( t ) { + var mem; + var mod; + var xp; + var y; + var i; + + mem = new Memory({ + 'initial': 1 + }); + mod = new Module( mem ); + mod.initializeSync(); + + xp = 0; + + mod.write( xp, new Float64Array([ + NaN, // 4 + NaN, + 1.0, // 3 + 2.0, + 2.0, // 2 + -7.0, + -2.0, // 1 + 3.0, + 4.0, // 0 + 2.0 + ])); + + y = mod.ndarray( 5, 1, xp, -2, 8 ); + t.strictEqual( y, 6.25, 'returns expected value' ); + + mod.write( xp, new Float64Array( 1e3 ) ); + for ( i = 0; i < 1e3; i++ ) { + mod.write( xp + (i*8), new Float64Array( [ 100.0 ] ) ); + } + y = mod.ndarray( 1000, 1, xp, -1, 999 ); + t.strictEqual( y, 0.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided a `stride` parameter equal to `0`, a module instance `ndarray` method returns `0` provided the correction term is not less than `0` and the first element is not `NaN`', 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, NaN ] ) ); + + y = mod.ndarray( 6, 1, xp, 0, 0 ); + t.strictEqual( y, 0.0, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ NaN, 1.0, -2.0, -4.0, 5.0, 3.0 ] ) ); + y = mod.ndarray( 6, 1, xp, 0, 0 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + mod.write( xp, new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0, NaN ] ) ); + y = mod.ndarray( 6, 6, xp, 0, 0 ); + t.strictEqual( isnan( y ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'a module instance `ndarray` method supports an `offset` parameter', 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([ + 2.0, + 1.0, // 0 + 2.0, + -2.0, // 1 + -2.0, + 2.0, // 2 + 3.0, + 4.0, // 3 + NaN, + NaN // 4 + ])); + + y = mod.ndarray( 5, 1, xp, 2, 1 ); + t.strictEqual( y, 6.25, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.ndarray.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.ndarray.js new file mode 100644 index 000000000000..d2675ca99ebe --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.ndarray.js @@ -0,0 +1,311 @@ +/** +* @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 tape = require( 'tape' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var Float64Array = require( '@stdlib/array/float64' ); +var dnanvariancewd = require( './../lib' ); + + +// TESTS // + +tape( 'main export is an object', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof dnanvariancewd, 'object', 'main export is an object' ); + t.end(); +}); + +tape( 'the `ndarray` method has an arity of 5', function test( t ) { + t.strictEqual( dnanvariancewd.ndarray.length, 5, 'has expected arity' ); + t.end(); +}); + +tape( 'the `ndarray` method calculates the population variance of a strided array (ignoring `NaN` values)', function test( t ) { + var x; + var v; + var i; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, NaN, 0.0, 3.0 ] ); + + v = dnanvariancewd.ndarray( x.length, 0, x, 1, 0 ); + t.strictEqual( v, 53.5/(x.length-1), 'returns expected value' ); + + x = new Float64Array( [ 1.0, NaN, NaN, -2.0, NaN, -4.0, NaN, 5.0, NaN, 0.0, 3.0, NaN ] ); // eslint-disable-line max-len + + v = dnanvariancewd.ndarray( x.length, 0, x, 1, 0 ); + t.strictEqual( v, 53.5/(x.length-6), 'returns expected value' ); + + x = new Float64Array( [ -4.0, NaN ] ); + + v = dnanvariancewd.ndarray( x.length, 0, x, 1, 0 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + x = new Float64Array( [ NaN, NaN ] ); + + v = dnanvariancewd.ndarray( x.length, 0, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( [ NaN ] ); + v = dnanvariancewd.ndarray( x.length, 0, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( [ 4.0 ] ); + v = dnanvariancewd.ndarray( x.length, 0, x, 1, 0 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + x = new Float64Array( 1e3 ); + for ( i = 0; i < 1e3; i++ ) { + x[ i ] = 100.0; + } + v = dnanvariancewd.ndarray( x.length, 0, x, 1, 0 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + x = new Float64Array( [ NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN ] ); // eslint-disable-line max-len + v = dnanvariancewd.ndarray( x.length, 0, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( 1e3 ); + for ( i = 0; i < 1e3; i++ ) { + x[ i ] = NaN; + } + v = dnanvariancewd.ndarray( x.length, 0, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the `ndarray` method calculates the sample variance of a strided array (ignoring `NaN` values)', function test( t ) { + var x; + var v; + var i; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, NaN, 0.0, 3.0 ] ); + + v = dnanvariancewd.ndarray( x.length, 1, x, 1, 0 ); + t.strictEqual( v, 53.5/(x.length-2), 'returns expected value' ); + + x = new Float64Array( [ 1.0, NaN, NaN, -2.0, NaN, -4.0, NaN, 5.0, NaN, 0.0, 3.0, NaN ] ); // eslint-disable-line max-len + + v = dnanvariancewd.ndarray( x.length, 1, x, 1, 0 ); + t.strictEqual( v, 53.5/(x.length-7), 'returns expected value' ); + + x = new Float64Array( [ -4.0, NaN ] ); + + v = dnanvariancewd.ndarray( x.length, 1, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( [ NaN, NaN ] ); + + v = dnanvariancewd.ndarray( x.length, 1, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( [ NaN ] ); + v = dnanvariancewd.ndarray( x.length, 1, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( [ 4.0 ] ); + v = dnanvariancewd.ndarray( x.length, 1, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( 1e3 ); + for ( i = 0; i < 1e3; i++ ) { + x[ i ] = 100.0; + } + v = dnanvariancewd.ndarray( x.length, 1, x, 1, 0 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + x = new Float64Array( [ NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN ] ); // eslint-disable-line max-len + v = dnanvariancewd.ndarray( x.length, 1, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( 1e3 ); + for ( i = 0; i < 1e3; i++ ) { + x[ i ] = NaN; + } + v = dnanvariancewd.ndarray( x.length, 1, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter less than or equal to `0`, the `ndarray` method returns `NaN`', function test( t ) { + var x; + var v; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dnanvariancewd.ndarray( 0, 1, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + v = dnanvariancewd.ndarray( -1, 1, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter equal to `1`, the `ndarray` method returns a population variance of `0` provided the first element is not `NaN`', function test( t ) { + var x; + var v; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dnanvariancewd.ndarray( 1, 0, x, 1, 0 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + x = new Float64Array( [ NaN, 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dnanvariancewd.ndarray( 1, 0, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter equal to `1`, the `ndarray` method returns a sample variance equal to `NaN`', function test( t ) { + var x; + var v; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dnanvariancewd.ndarray( 1, 1, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( [ NaN, 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dnanvariancewd.ndarray( 1, 1, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided a `correction` parameter yielding a correction term less than or equal to `0`, the `ndarray` method returns `NaN`', function test( t ) { + var x; + var v; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dnanvariancewd.ndarray( x.length, x.length, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + v = dnanvariancewd.ndarray( x.length, x.length+1, x, 1, 0 ); + t.strictEqual( isnan( v ), true, '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, + NaN, // 4 + NaN + ]); + + v = dnanvariancewd.ndarray( 5, 1, x, 2, 0 ); + + t.strictEqual( v, 6.25, 'returns expected value' ); + t.end(); +}); + +tape( 'the `ndarray` method supports a negative `stride` parameter', function test( t ) { + var x; + var v; + var i; + + x = new Float64Array([ + NaN, // 4 + NaN, + 1.0, // 3 + 2.0, + 2.0, // 2 + -7.0, + -2.0, // 1 + 3.0, + 4.0, // 0 + 2.0 + ]); + + v = dnanvariancewd.ndarray( 5, 1, x, -2, 8 ); + t.strictEqual( v, 6.25, 'returns expected value' ); + + x = new Float64Array( 1e3 ); + for ( i = 0; i < 1e3; i++ ) { + x[ i ] = 100.0; + } + v = dnanvariancewd.ndarray( x.length, 1, x, -1, x.length-1 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided a `stride` parameter equal to `0`, the `ndarray` method returns `0` provided the correction term is not less than `0` and the first element is not `NaN`', function test( t ) { + var x; + var v; + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dnanvariancewd.ndarray( x.length, 1, x, 0, 0 ); + t.strictEqual( v, 0.0, 'returns expected value' ); + + x = new Float64Array( [ NaN, 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dnanvariancewd.ndarray( x.length, 1, x, 0, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = dnanvariancewd.ndarray( x.length, x.length, x, 0, 0 ); + t.strictEqual( isnan( v ), true, '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 + NaN, + NaN // 4 + ]); + + v = dnanvariancewd.ndarray( 5, 1, x, 2, 1 ); + t.strictEqual( v, 6.25, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.routine.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.routine.js new file mode 100644 index 000000000000..806b3de987e3 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.routine.js @@ -0,0 +1,71 @@ +/** +* @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 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 routine module', function test( t ) { + var mod = new Routine(); + t.strictEqual( mod instanceof Module, true, 'returns expected value' ); + t.end(); +}); + +tape( 'attached to a module instance is a `main` method', function test( t ) { + var mod = new Routine(); + t.strictEqual( typeof mod.main, 'function', 'returns expected value' ); + t.end(); +}); + +tape( 'attached to a module instance is an `ndarray` method', function test( t ) { + var mod = new Routine(); + t.strictEqual( typeof mod.ndarray, 'function', 'returns expected value' ); + t.end(); +}); diff --git a/test_dmeanvar.js b/test_dmeanvar.js new file mode 100644 index 000000000000..e69de29bb2d1 From c101ea239fcb91ce99fea81508ccee9e83cb23a2 Mon Sep 17 00:00:00 2001 From: JoyBoy <144602492+0PrashantYadav0@users.noreply.github.com> Date: Tue, 16 Sep 2025 15:30:53 +0530 Subject: [PATCH 02/15] fix: change in params --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: passed - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: passed - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../benchmark/benchmark.module.ndarray.js | 2 +- .../strided/wasm/dnanvariancewd/docs/repl.txt | 4 ++-- .../strided/wasm/dnanvariancewd/lib/index.js | 4 ++-- .../strided/wasm/dnanvariancewd/lib/main.js | 4 ++-- .../strided/wasm/dnanvariancewd/lib/routine.js | 4 ++-- .../strided/wasm/dnanvariancewd/src/main.wat | 16 ++++++++++++++++ 6 files changed, 25 insertions(+), 9 deletions(-) diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.module.ndarray.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.module.ndarray.js index da4246d5a87b..a4d5b53f4ee6 100644 --- a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.module.ndarray.js +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.module.ndarray.js @@ -103,7 +103,7 @@ function createBenchmark( len ) { b.tic(); for ( i = 0; i < b.iterations; i++ ) { - v = mod.ndarray( len, xptr, 1, 0 ); + v = mod.ndarray( len, 1, xptr, 1, 0 ); if ( isnan( v ) ) { b.fail( 'should not return NaN' ); } diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/repl.txt b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/repl.txt index 64cd2d150b15..e4f039a49b64 100644 --- a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/repl.txt +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/repl.txt @@ -444,7 +444,7 @@ [ 1, 2, 3, 4 ] -{{alias}}.Module.prototype.main( N, xp, sx ) +{{alias}}.Module.prototype.main( N, correction, xp, sx ) Computes the variance of a double-precision floating-point strided array ignoring `NaN` values and using Welford's algorithm. @@ -494,7 +494,7 @@ 1.0 -{{alias}}.Module.prototype.ndarray( N, xp, sx, ox ) +{{alias}}.Module.prototype.ndarray( N, correction, xp, sx, ox ) Computes the variance of a double-precision floating-point strided array ignoring `NaN` values and using Welford's algorithm and alternative indexing semantics. diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/index.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/index.js index b58f10d807e9..f6104ffa2cd4 100644 --- a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/index.js +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/index.js @@ -32,7 +32,7 @@ * * // Perform operation: * var v = dnanvariancewd.main( x.length, 1, x, 1 ); -* // returns ~6.3333 +* // returns ~4.3333 * * @example * var Float64Array = require( '@stdlib/array/float64' ); @@ -43,7 +43,7 @@ * * // Perform operation: * var v = dnanvariancewd.ndarray( 5, 1, x, 2, 1 ); -* // returns ~4.7857 +* // returns 6.25 * * @example * var Memory = require( '@stdlib/wasm/memory' ); diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/main.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/main.js index d53ac9a25838..73c17d40f10b 100644 --- a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/main.js +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/main.js @@ -39,7 +39,7 @@ var Routine = require( './routine.js' ); * * // Perform operation: * var v = dnanvariancewd.main( 4, 1, x, 1 ); -* // returns ~6.3333 +* // returns ~4.3333 * * @example * var Float64Array = require( '@stdlib/array/float64' ); @@ -49,7 +49,7 @@ var Routine = require( './routine.js' ); * * // Perform operation: * var v = dnanvariancewd.ndarray( 5, 1, x, 2, 1 ); -* // returns ~4.7857 +* // returns 6.25 */ var dnanvariancewd = new Routine(); dnanvariancewd.initializeSync(); // eslint-disable-line node/no-sync diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/routine.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/routine.js index 153bd8aabd12..7aaca26931d4 100644 --- a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/routine.js +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/routine.js @@ -70,7 +70,7 @@ var Module = require( './module.js' ); * * // Perform operation: * var sum = dnanvariancewd.ndarray( 5, 1, x, 2, 1 ); -* // returns ~4.7857 +* // returns 6.25 */ function Routine() { if ( !( this instanceof Routine ) ) { @@ -146,7 +146,7 @@ setReadOnly( Routine.prototype, 'main', function dnanvariancewd( N, correction, * * // Perform operation: * var v = dnanvariancewd.ndarray( 5, 1, x, 2, 1 ); -* // returns ~4.7857 +* // returns 6.25 */ setReadOnly( Routine.prototype, 'ndarray', function dnanvariancewd( N, correction, x, strideX, offsetX ) { var ptrs; diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/src/main.wat b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/src/main.wat index 1100a4e762e0..8bed58a90b89 100644 --- a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/src/main.wat +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/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 92f0865d110b650490e7797dd4cb60248442fe02 Mon Sep 17 00:00:00 2001 From: JoyBoy <144602492+0PrashantYadav0@users.noreply.github.com> Date: Tue, 16 Sep 2025 15:32:12 +0530 Subject: [PATCH 03/15] fix: changes in input --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: passed - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: na - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../wasm/dnanvariancewd/benchmark/benchmark.module.ndarray.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.module.ndarray.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.module.ndarray.js index a4d5b53f4ee6..a69d84645f30 100644 --- a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.module.ndarray.js +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/benchmark/benchmark.module.ndarray.js @@ -99,7 +99,7 @@ function createBenchmark( len ) { xptr = 0; // Write random values to module memory: - mod.write( xptr, 1, filledarrayBy( len, options.dtype, rand ) ); + mod.write( xptr, filledarrayBy( len, options.dtype, rand ) ); b.tic(); for ( i = 0; i < b.iterations; i++ ) { From a5b6ff8c9c9a63177bf3a128e96c5e64544d5c09 Mon Sep 17 00:00:00 2001 From: JoyBoy <144602492+0PrashantYadav0@users.noreply.github.com> Date: Tue, 16 Sep 2025 17:08:59 +0530 Subject: [PATCH 04/15] fix: remove unwanted 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: 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 --- --- test_dmeanvar.js | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 test_dmeanvar.js diff --git a/test_dmeanvar.js b/test_dmeanvar.js deleted file mode 100644 index e69de29bb2d1..000000000000 From beb2af632a078eee48e4432d15f8f34aa0578fa3 Mon Sep 17 00:00:00 2001 From: Athan Date: Tue, 16 Sep 2025 22:21:39 -0700 Subject: [PATCH 05/15] chore: fix lint disabling Signed-off-by: Athan --- .../strided/wasm/dnanvariancewd/README.md | 31 +++---------------- 1 file changed, 5 insertions(+), 26 deletions(-) diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/README.md b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/README.md index 013779ff43df..2fce5e0186a6 100644 --- a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/README.md +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/README.md @@ -52,10 +52,11 @@ The function has the following parameters: 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' ); -// eslint-disable-next-line max-len var x = new Float64Array( [ 1.0, 2.0, 2.0, -7.0, -2.0, 3.0, 4.0, 2.0, NaN, NaN ] ); var v = dnanvariancewd.main( 5, 1, x, 2 ); @@ -64,12 +65,11 @@ var v = dnanvariancewd.main( 5, 1, x, 2 ); 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' ); -// eslint-disable-next-line max-len var x0 = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN, NaN ] ); var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element @@ -96,6 +96,8 @@ The function has the following additional parameters: While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset 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' ); @@ -283,15 +285,6 @@ console.log( v );
-* * * - -## See Also - -- [`@stdlib/stats/strided/dvariancewd`][@stdlib/stats/strided/dvariancewd]: calculate the variance of a double-precision floating-point strided array using Welford's algorithm. -- [`@stdlib/stats/strided/dnanvariance`][@stdlib/stats/strided/dnanvariance]: calculate the variance of a double-precision floating-point strided array ignoring NaN values. -- [`@stdlib/stats/strided/nanvariancewd`][@stdlib/stats/strided/nanvariancewd]: calculate the variance of a strided array ignoring NaN values and using Welford's algorithm. -- [`@stdlib/stats/base/snanvariancewd`][@stdlib/stats/base/snanvariancewd]: calculate the variance of a single-precision floating-point strided array ignoring NaN values and using Welford's algorithm. -
@@ -310,20 +303,6 @@ console.log( v ); [mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray - - -[@stdlib/stats/strided/dvariancewd]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/dvariancewd - -[@stdlib/stats/strided/dnanvariance]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/dnanvariance - -[@stdlib/stats/strided/nanvariancewd]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/nanvariancewd - -[@stdlib/stats/base/snanvariancewd]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/base/snanvariancewd - -[@stdlib/stats/strided/dnanvariancewd]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/dnanvariancewd - - - From 9de25db2b4ca07b5441f30d2ef19624e9fb1b5ef Mon Sep 17 00:00:00 2001 From: Athan Date: Tue, 16 Sep 2025 22:23:40 -0700 Subject: [PATCH 06/15] docs: remove comment Signed-off-by: Athan --- .../@stdlib/stats/strided/wasm/dnanvariancewd/README.md | 1 - 1 file changed, 1 deletion(-) diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/README.md b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/README.md index 2fce5e0186a6..2c12f683c995 100644 --- a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/README.md +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/README.md @@ -101,7 +101,6 @@ While [`typed array`][mdn-typed-array] views mandate a view offset based on the ```javascript var Float64Array = require( '@stdlib/array/float64' ); -// eslint-disable-next-line max-len var x = new Float64Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN, NaN ] ); var v = dnanvariancewd.ndarray( 5, 1, x, 2, 1 ); From 2cb16b5ff1bb5a1d857701dfba4a082b591ab8c6 Mon Sep 17 00:00:00 2001 From: Athan Date: Tue, 16 Sep 2025 22:29:50 -0700 Subject: [PATCH 07/15] docs: update example Signed-off-by: Athan --- .../strided/wasm/dnanvariancewd/README.md | 21 ++++++++----------- 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/README.md b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/README.md index 2c12f683c995..1649271ee1c6 100644 --- a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/README.md +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/README.md @@ -254,22 +254,19 @@ The function has the following additional parameters: ```javascript -var randu = require( '@stdlib/random/base/randu' ); -var round = require( '@stdlib/math/base/special/round' ); -var Float64Array = require( '@stdlib/array/float64' ); +var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ); +var bernoulli = require( '@stdlib/random/base/bernoulli' ); +var filledarrayBy = require( '@stdlib/array/filled-by' ); var dnanvariancewd = require( '@stdlib/stats/strided/wasm/dnanvariancewd' ); -var x; -var i; - -x = new Float64Array( 10 ); -for ( i = 0; i < x.length; i++ ) { - if ( randu() < 0.2 ) { - x[ i ] = NaN; - } else { - x[ i ] = round( randu() * 10.0 ); +function rand() { + if ( bernoulli( 0.2 ) > 0 ) { + return NaN; } + return discreteUniform( 0, 10 ); } + +var x = filledarrayBy( 10, 'float64', rand ); console.log( x ); var v = dnanvariancewd.ndarray( x.length, 1, x, 1, 0 ); From 601390ca88b5484200bf82ecafea24ae120f273b Mon Sep 17 00:00:00 2001 From: Athan Date: Tue, 16 Sep 2025 22:36:57 -0700 Subject: [PATCH 08/15] docs: fix return value Signed-off-by: Athan --- .../stats/strided/wasm/dnanvariancewd/docs/types/index.d.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/types/index.d.ts index 4359e824fea0..3a78475cece5 100644 --- a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/types/index.d.ts @@ -311,7 +311,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, NaN, NaN ] ); * * var y = dnanvariancewd.ndarray( 5, 1, x, 2, 1 ); -* // returns ~4.7857 +* // returns 6.25 */ declare var dnanvariancewd: Routine; From 17de5042f0d81d24af01edc66f469933609d3da9 Mon Sep 17 00:00:00 2001 From: Athan Date: Tue, 16 Sep 2025 22:39:59 -0700 Subject: [PATCH 09/15] Apply suggestions from code review Signed-off-by: Athan --- .../strided/wasm/dnanvariancewd/docs/types/test.ts | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/types/test.ts b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/types/test.ts index 1b588112f756..caa7b73570b9 100644 --- a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/types/test.ts +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/types/test.ts @@ -45,7 +45,7 @@ import dnanvariancewd = require( './index' ); dnanvariancewd.main( ( x: number ): number => x, 1, x, 1 ); // $ExpectError } -// The compiler throws an error if the `main` method is provided a second argument which is not a Float64Array... +// The compiler throws an error if the `main` method is provided a second argument which is not a number... { const x = new Float64Array( 10 ); @@ -165,7 +165,7 @@ import dnanvariancewd = require( './index' ); dnanvariancewd.ndarray( x.length, 1, x, ( x: number ): number => x, 0 ); // $ExpectError } -// The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number... +// The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a number... { const x = new Float64Array( 10 ); @@ -239,7 +239,7 @@ import dnanvariancewd = require( './index' ); mod.main( ( x: number ): number => x, 1, 0, 1 ); // $ExpectError } -// The compiler throws an error if the `main` method of a module instance is provided a first argument which is not a number... +// 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 @@ -314,7 +314,7 @@ import dnanvariancewd = require( './index' ); mod.ndarray( 10, 1, 0, 1, 0 ); // $ExpectType number } -// The compiler throws an error if the `ndarray` method of a module instance is provided a second argument which is not a 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 @@ -382,7 +382,7 @@ import dnanvariancewd = require( './index' ); mod.ndarray( 10, 1, 0, ( x: number ): number => x, 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... +// 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 From d22a9f4ff7c9eef05ea21093248cad212d427f97 Mon Sep 17 00:00:00 2001 From: Athan Date: Tue, 16 Sep 2025 22:40:46 -0700 Subject: [PATCH 10/15] docs: fix comment Signed-off-by: Athan --- .../stats/strided/wasm/dnanvariancewd/docs/types/test.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/types/test.ts b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/types/test.ts index caa7b73570b9..eeecce7a82fd 100644 --- a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/types/test.ts +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/docs/types/test.ts @@ -121,7 +121,7 @@ import dnanvariancewd = require( './index' ); dnanvariancewd.ndarray( ( x: number ): number => x, 1, x, 1, 0 ); // $ExpectError } -// The compiler throws an error if the `ndarray` method is provided a first argument which is not a number... +// The compiler throws an error if the `ndarray` method is provided a second argument which is not a number... { const x = new Float64Array( 10 ); From ac8534f7645083f379e1f55ff871cd36911dab4e Mon Sep 17 00:00:00 2001 From: Athan Date: Tue, 16 Sep 2025 22:45:06 -0700 Subject: [PATCH 11/15] Apply suggestions from code review Signed-off-by: Athan --- .../@stdlib/stats/strided/wasm/dnanvariancewd/lib/module.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/module.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/module.js index 4ae1d3d6c6bc..fdcca37f40cb 100644 --- a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/module.js +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/module.js @@ -104,7 +104,7 @@ inherits( Module, WasmModule ); * @param {number} correction - degrees of freedom adjustment * @param {Float64Array} x - input array * @param {integer} strideX - stride length -* @returns {number} arithmetic mean +* @returns {number} variance * * @example * var Memory = require( '@stdlib/wasm/memory' ); @@ -155,7 +155,7 @@ setReadOnly( Module.prototype, 'main', function dnanvariancewd( N, correction, x * @param {Float64Array} x - input array * @param {integer} strideX - stride length * @param {NonNegativeInteger} offsetX - starting index -* @returns {number} arithmetic mean +* @returns {number} variance * * @example * var Memory = require( '@stdlib/wasm/memory' ); From 7e0879e9161108b76950dac3e0470b08ed356b07 Mon Sep 17 00:00:00 2001 From: Athan Date: Tue, 16 Sep 2025 22:46:59 -0700 Subject: [PATCH 12/15] Apply suggestions from code review Signed-off-by: Athan --- .../@stdlib/stats/strided/wasm/dnanvariancewd/lib/routine.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/routine.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/routine.js index 7aaca26931d4..e44bbb44a3e6 100644 --- a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/routine.js +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/lib/routine.js @@ -96,7 +96,7 @@ inherits( Routine, Module ); * @param {number} correction - degrees of freedom adjustment * @param {Float64Array} x - input array * @param {integer} strideX - stride length -* @returns {number} arithmetic mean +* @returns {number} variance * * @example * var Float64Array = require( '@stdlib/array/float64' ); @@ -130,7 +130,7 @@ setReadOnly( Routine.prototype, 'main', function dnanvariancewd( N, correction, * @param {Float64Array} x - input array * @param {integer} strideX - stride length * @param {NonNegativeInteger} offsetX - starting index -* @returns {number} arithmetic mean +* @returns {number} variance * * @example * var Float64Array = require( '@stdlib/array/float64' ); From 48779d4187d3931e98b4aefc2e2fe954dd722db6 Mon Sep 17 00:00:00 2001 From: Athan Date: Tue, 16 Sep 2025 22:50:46 -0700 Subject: [PATCH 13/15] style: move comment Signed-off-by: Athan --- .../stats/strided/wasm/dnanvariancewd/test/test.module.main.js | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.module.main.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.module.main.js index 95e069f77b88..1d88e764e191 100644 --- a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.module.main.js +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.module.main.js @@ -131,8 +131,7 @@ tape( 'a module instance `main` method calculates the sample variance of a strid mod.write( xp, new Float64Array( [ 1.0, NaN, NaN, -2.0, NaN, -4.0, NaN, 5.0, NaN, 0.0, 3.0, NaN ] ) ); // eslint-disable-line max-len y = mod.main( 12, 1, xp, 1 ); - // 6 NaNs ignored => N=6, correction=1 => N-c=5 - t.strictEqual( y, 53.5/5, 'returns expected value' ); + t.strictEqual( y, 53.5/5, 'returns expected value' ); // 6 NaNs ignored => N=6, correction=1 => N-c=5 mod.write( xp, new Float64Array( [ -4.0, NaN ] ) ); y = mod.main( 2, 1, xp, 1 ); From 941d64888909142813830d27724dc9cecb4e279b Mon Sep 17 00:00:00 2001 From: Athan Date: Tue, 16 Sep 2025 22:51:42 -0700 Subject: [PATCH 14/15] docs: move comment Signed-off-by: Athan --- .../stats/strided/wasm/dnanvariancewd/test/test.module.main.js | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.module.main.js b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.module.main.js index 1d88e764e191..cea42763df4c 100644 --- a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.module.main.js +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/test/test.module.main.js @@ -70,8 +70,7 @@ tape( 'a module instance `main` method calculates the population variance of a s mod.write( xp, new Float64Array( [ 1.0, NaN, NaN, -2.0, NaN, -4.0, NaN, 5.0, NaN, 0.0, 3.0, NaN ] ) ); // eslint-disable-line max-len y = mod.main( 12, 0, xp, 1 ); - // 6 NaNs ignored => N=6 - t.strictEqual( y, 53.5/(12-6), 'returns expected value' ); + t.strictEqual( y, 53.5/(12-6), 'returns expected value' ); // 6 NaNs ignored => N=6 mod.write( xp, new Float64Array( [ -4.0, NaN ] ) ); y = mod.main( 2, 0, xp, 1 ); From eee176a698283da67896bfee7394e41bf52d9eff Mon Sep 17 00:00:00 2001 From: Athan Date: Tue, 16 Sep 2025 22:56:02 -0700 Subject: [PATCH 15/15] docs: fix missing link definition Signed-off-by: Athan --- .../@stdlib/stats/strided/wasm/dnanvariancewd/README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/README.md b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/README.md index 1649271ee1c6..24878b11f57e 100644 --- a/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/README.md +++ b/lib/node_modules/@stdlib/stats/strided/wasm/dnanvariancewd/README.md @@ -299,6 +299,8 @@ console.log( v ); [mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray +[@stdlib/stats/strided/dnanvariancewd]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/dnanvariancewd +