From e91fe503d69ea04eb8619282ec5b04a5114517ed Mon Sep 17 00:00:00 2001 From: Arjan Date: Thu, 6 Aug 2026 11:04:14 +0530 Subject: [PATCH 01/16] chore: package setup --- 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_pkg_readmes status: na - task: lint_markdown_docs status: na - task: lint_markdown status: na - task: lint_package_json status: passed - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../stats/strided/snanmeanpw/lib/index.js | 68 +++++++++++++++ .../stats/strided/snanmeanpw/lib/main.js | 35 ++++++++ .../stats/strided/snanmeanpw/lib/ndarray.js | 83 +++++++++++++++++++ .../strided/snanmeanpw/lib/snanmeanpw.js | 52 ++++++++++++ .../stats/strided/snanmeanpw/package.json | 78 +++++++++++++++++ 5 files changed, 316 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/lib/index.js create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/lib/main.js create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/lib/ndarray.js create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/lib/snanmeanpw.js create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/package.json diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/lib/index.js b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/lib/index.js new file mode 100644 index 000000000000..1ec9ef0d5bbe --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/lib/index.js @@ -0,0 +1,68 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +/** +* Compute the arithmetic mean of a single-precision floating-point strided array, ignoring `NaN` values and using pairwise summation. +* +* @module @stdlib/stats/strided/snanmeanpw +* +* @example +* var Float32Array = require( '@stdlib/array/float32' ); +* var snanmeanpw = require( '@stdlib/stats/strided/snanmeanpw' ); +* +* var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] ); +* +* var v = snanmeanpw( x.length, x, 1 ); +* // returns ~0.3333 +* +* @example +* var Float32Array = require( '@stdlib/array/float32' ); +* var snanmeanpw = require( '@stdlib/stats/strided/snanmeanpw' ); +* +* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN, NaN ] ); +* +* var v = snanmeanpw.ndarray( 5, x, 2, 1 ); +* // returns 1.25 +*/ + +// MODULES // + +var join = require( 'path' ).join; +var tryRequire = require( '@stdlib/utils/try-require' ); +var isError = require( '@stdlib/assert/is-error' ); +var main = require( './main.js' ); + + +// MAIN // + +var snanmeanpw; +var tmp = tryRequire( join( __dirname, './native.js' ) ); +if ( isError( tmp ) ) { + snanmeanpw = main; +} else { + snanmeanpw = tmp; +} + + +// EXPORTS // + +module.exports = snanmeanpw; + +// exports: { "ndarray": "snanmeanpw.ndarray" } diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/lib/main.js b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/lib/main.js new file mode 100644 index 000000000000..036879ef707f --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/lib/main.js @@ -0,0 +1,35 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' ); +var snanmeanpw = require( './snanmeanpw.js' ); +var ndarray = require( './ndarray.js' ); + + +// MAIN // + +setReadOnly( snanmeanpw, 'ndarray', ndarray ); + + +// EXPORTS // + +module.exports = snanmeanpw; diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/lib/ndarray.js b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/lib/ndarray.js new file mode 100644 index 000000000000..8df4d58dca69 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/lib/ndarray.js @@ -0,0 +1,83 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var isnan = require( '@stdlib/assert/is-nan' ); +var float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' ); +var snansumpw = require( '@stdlib/blas/ext/base/snansumpw' ).ndarray; + + +// MAIN // + +/** +* Computes the arithmetic mean of a single-precision floating-point strided array, ignoring `NaN` values and using pairwise summation. +* +* @param {PositiveInteger} N - number of indexed elements +* @param {Float32Array} x - input array +* @param {integer} strideX - stride length +* @param {NonNegativeInteger} offsetX - starting index +* @returns {number} arithmetic mean +* +* @example +* var Float32Array = require( '@stdlib/array/float32' ); +* +* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN, NaN ] ); +* +* var v = snanmeanpw( 5, x, 2, 1 ); +* // returns 1.25 +*/ +function snanmeanpw( N, x, strideX, offsetX ) { + var ix; + var n; + var i; + var v; + + if ( N <= 0 ) { + return NaN; + } + + if ( N === 1 || strideX === 0 ) { + return x[ offsetX ]; + } + + ix = offsetX; + n = 0; + + // Count non-NaN elements + for ( i = 0; i < N; i++ ) { + v = x[ ix ]; + if ( !isnan( v ) ) { + n += 1; + } + ix += strideX; + } + + if ( n === 0 ) { + return NaN; + } + + return float64ToFloat32( snansumpw( N, x, strideX, offsetX ) / n ); +} + + +// EXPORTS // + +module.exports = snanmeanpw; diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/lib/snanmeanpw.js b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/lib/snanmeanpw.js new file mode 100644 index 000000000000..9f173e4b01e1 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/lib/snanmeanpw.js @@ -0,0 +1,52 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var stride2offset = require( '@stdlib/strided/base/stride2offset' ); +var ndarray = require( './ndarray.js' ); + + +// MAIN // + +/** +* Computes the arithmetic mean of a single-precision floating-point strided array, ignoring `NaN` values and using pairwise summation. +* +* @param {PositiveInteger} N - number of indexed elements +* @param {Float32Array} x - input array +* @param {integer} strideX - stride length +* @returns {number} arithmetic mean +* +* @example +* var Float32Array = require( '@stdlib/array/float32' ); +* +* var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] ); +* +* var v = snanmeanpw( x.length, x, 1 ); +* // returns ~0.3333 +*/ +function snanmeanpw( N, x, strideX ) { + return ndarray( N, x, strideX, stride2offset( N, strideX ) ); +} + + +// EXPORTS // + +module.exports = snanmeanpw; diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/package.json b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/package.json new file mode 100644 index 000000000000..07fa4a073317 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/package.json @@ -0,0 +1,78 @@ +{ + "name": "@stdlib/stats/strided/snanmeanpw", + "version": "0.0.0", + "description": "Calculate the arithmetic mean of a single-precision floating-point strided array ignoring NaN values and using pairwise summation.", + "license": "Apache-2.0", + "author": { + "name": "The Stdlib Authors", + "url": "https://github.com/stdlib-js/stdlib/graphs/contributors" + }, + "contributors": [ + { + "name": "The Stdlib Authors", + "url": "https://github.com/stdlib-js/stdlib/graphs/contributors" + } + ], + "main": "./lib", + "browser": "./lib/main.js", + "gypfile": true, + "directories": { + "benchmark": "./benchmark", + "doc": "./docs", + "example": "./examples", + "include": "./include", + "lib": "./lib", + "src": "./src", + "test": "./test" + }, + "types": "./docs/types", + "scripts": {}, + "homepage": "https://github.com/stdlib-js/stdlib", + "repository": { + "type": "git", + "url": "git://github.com/stdlib-js/stdlib.git" + }, + "bugs": { + "url": "https://github.com/stdlib-js/stdlib/issues" + }, + "dependencies": {}, + "devDependencies": {}, + "engines": { + "node": ">=0.10.0", + "npm": ">2.7.0" + }, + "os": [ + "aix", + "darwin", + "freebsd", + "linux", + "macos", + "openbsd", + "sunos", + "win32", + "windows" + ], + "keywords": [ + "stdlib", + "stdmath", + "statistics", + "stats", + "mathematics", + "math", + "average", + "avg", + "mean", + "arithmetic mean", + "central tendency", + "pairwise", + "pw", + "strided", + "strided array", + "typed", + "array", + "float32", + "float", + "float32array" + ], + "__stdlib__": {} +} From 0b3a45dbe065b376fb9b3fd1cc38a2f8a3c2307b Mon Sep 17 00:00:00 2001 From: Arjan Date: Thu, 6 Aug 2026 13:13:41 +0530 Subject: [PATCH 02/16] docs: add package README.md --- 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_pkg_readmes status: passed - task: lint_markdown_docs status: na - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../stats/strided/snanmeanpw/README.md | 333 ++++++++++++++++++ 1 file changed, 333 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/README.md diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/README.md b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/README.md new file mode 100644 index 000000000000..e13e23f2f02b --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/README.md @@ -0,0 +1,333 @@ + + +# snanmeanpw + +> Calculate the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array, ignoring `NaN` values and using pairwise summation. + +
+ +The [arithmetic mean][arithmetic-mean] is defined as + + + +```math +\mu = \frac{1}{n} \sum_{i=0}^{n-1} x_i +``` + + + + + +
+ + + +
+ +## Usage + +```javascript +var snanmeanpw = require( '@stdlib/stats/strided/snanmeanpw' ); +``` + +#### snanmeanpw( N, x, strideX ) + +Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array using pairwise summation. + +```javascript +var Float32Array = require( '@stdlib/array/float32' ); + +var x = new Float32Array( [ 1.0, -2.0, 2.0 ] ); + +var v = snanmeanpw( x.length, x, 1 ); +// returns ~0.3333 +``` + +The function has the following parameters: + +- **N**: number of indexed elements. +- **x**: input [`Float32Array`][@stdlib/array/float32]. +- **strideX**: stride length for `x`. + +The `N` and stride parameters determine which elements in the strided array are accessed at runtime. For example, to compute the [arithmetic mean][arithmetic-mean] of every other element in `x`, + +```javascript +var Float32Array = require( '@stdlib/array/float32' ); + +var x = new Float32Array( [ 1.0, 2.0, 2.0, -7.0, -2.0, 3.0, 4.0, 2.0 ] ); + +var v = snanmeanpw( 4, x, 2 ); +// returns 1.25 +``` + +Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views. + + + +```javascript +var Float32Array = require( '@stdlib/array/float32' ); + +var x0 = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] ); +var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element + +var v = snanmeanpw( 4, x1, 2 ); +// returns 1.25 +``` + +#### snanmeanpw.ndarray( N, x, strideX, offsetX ) + +Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array using pairwise summation and alternative indexing semantics. + +```javascript +var Float32Array = require( '@stdlib/array/float32' ); + +var x = new Float32Array( [ 1.0, -2.0, 2.0 ] ); + +var v = snanmeanpw.ndarray( x.length, x, 1, 0 ); +// returns ~0.33333 +``` + +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 calculate the [arithmetic mean][arithmetic-mean] for every other element in `x` starting from the second element + +```javascript +var Float32Array = require( '@stdlib/array/float32' ); + +var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] ); + +var v = snanmeanpw.ndarray( 4, x, 2, 1 ); +// returns 1.25 +``` + +
+ + + +
+ +## Notes + +- If `N <= 0`, both functions return `NaN`. +- In general, pairwise summation is more numerically stable than ordinary recursive summation (i.e., "simple" summation), with slightly worse performance. While not the most numerically stable summation technique (e.g., compensated summation techniques such as the Kahan–Babuška-Neumaier algorithm are generally more numerically stable), pairwise summation strikes a reasonable balance between numerical stability and performance. If either numerical stability or performance is more desirable for your use case, consider alternative summation techniques. + +
+ + + +
+ +## Examples + + + +```javascript +var discreteUniform = require( '@stdlib/random/array/discrete-uniform' ); +var snanmeanpw = require( '@stdlib/stats/strided/snanmeanpw' ); + +var x = discreteUniform( 10, -50, 50, { + 'dtype': 'float32' +}); +console.log( x ); + +var v = snanmeanpw( x.length, x, 1 ); +console.log( v ); +``` + +
+ + + + + +* * * + +
+ +## C APIs + + + +
+ +
+ + + + + +
+ +### Usage + +```c +#include "stdlib/stats/strided/snanmeanpw.h" +``` + +#### stdlib_strided_snanmeanpw( N, \*X, strideX ) + +Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array using pairwise summation. + +```c +const float x[] = { 1.0f, 2.0f, 3.0f }; + +float v = stdlib_strided_snanmeanpw( 3, x, 1 ); +// returns 2.0f +``` + +The function accepts the following arguments: + +- **N**: `[in] CBLAS_INT` number of indexed elements. +- **X**: `[in] float*` input array. +- **strideX**: `[in] CBLAS_INT` stride length for `X`. + +```c +float stdlib_strided_snanmeanpw( const CBLAS_INT N, const float *X, const CBLAS_INT strideX ); +``` + +#### stdlib_strided_snanmeanpw_ndarray( N, \*X, strideX, offsetX ) + +Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array using pairwise summation and alternative indexing semantics. + +```c +const float x[] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f }; + +float v = stdlib_strided_snanmeanpw_ndarray( 4, x, 2, 0 ); +// returns 4.0f +``` + +The function accepts the following arguments: + +- **N**: `[in] CBLAS_INT` number of indexed elements. +- **X**: `[in] float*` input array. +- **strideX**: `[in] CBLAS_INT` stride length for `X`. +- **offsetX**: `[in] CBLAS_INT` starting index for `X`. + +```c +float stdlib_strided_snanmeanpw_ndarray( const CBLAS_INT N, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX ); +``` + +
+ + + + + +
+ +
+ + + + + +
+ +### Examples + +```c +#include "stdlib/stats/strided/snanmeanpw.h" +#include + +int main( void ) { + // Create a strided array: + const float x[] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f }; + + // Specify the number of elements: + const int N = 4; + + // Specify the stride length: + const int strideX = 2; + + // Compute the arithmetic mean: + float v = stdlib_strided_snanmeanpw( N, x, strideX ); + + // Print the result: + printf( "mean: %f\n", v ); +} +``` + +
+ + + +
+ + + +* * * + +
+ +## References + +- Higham, Nicholas J. 1993. "The Accuracy of Floating Point Summation." _SIAM Journal on Scientific Computing_ 14 (4): 783–99. doi:[10.1137/0914050][@higham:1993a]. + +
+ + + + + +
+ +* * * + +## See Also + +- [`@stdlib/stats/strided/dmeanpw`][@stdlib/stats/strided/dmeanpw]: calculate the arithmetic mean of a double-precision floating-point strided array using pairwise summation. +- [`@stdlib/stats/strided/meanpw`][@stdlib/stats/strided/meanpw]: calculate the arithmetic mean of a strided array using pairwise summation. +- [`@stdlib/stats/strided/smean`][@stdlib/stats/strided/smean]: calculate the arithmetic mean of a single-precision floating-point strided array. + +
+ + + + + +
+ +[arithmetic-mean]: https://en.wikipedia.org/wiki/Arithmetic_mean + +[@stdlib/array/float32]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/float32 + +[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray + +[@higham:1993a]: https://doi.org/10.1137/0914050 + + + +[@stdlib/stats/strided/dmeanpw]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/dmeanpw + +[@stdlib/stats/strided/meanpw]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/meanpw + +[@stdlib/stats/strided/smean]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/smean + + + +
+ + From 029ebd357877714a939f96fecf87bb38f477c14d Mon Sep 17 00:00:00 2001 From: Arjan Date: Thu, 6 Aug 2026 13:20:41 +0530 Subject: [PATCH 03/16] docs: add repl.txt --- 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_pkg_readmes status: na - task: lint_markdown_docs status: na - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: passed - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../stats/strided/snanmeanpw/docs/repl.txt | 90 +++++++++++++++++++ 1 file changed, 90 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/docs/repl.txt diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/docs/repl.txt b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/docs/repl.txt new file mode 100644 index 000000000000..d571ba9d8dd8 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/docs/repl.txt @@ -0,0 +1,90 @@ + +{{alias}}( N, x, strideX ) + Computes the arithmetic mean of a single-precision floating-point strided + array ignoring `NaN` values and using pairwise summation. + + 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 `NaN`. + + Parameters + ---------- + N: integer + Number of indexed elements. + + x: Float32Array + Input array. + + strideX: integer + Stride length. + + Returns + ------- + out: float + The arithmetic mean. + + Examples + -------- + // Standard Usage: + > var x = new {{alias:@stdlib/array/float32}}( [ 1.0, -2.0, 2.0, NaN ] ); + > {{alias}}( x.length, x, 1 ) + ~0.3333 + + // Using `N` and stride parameters: + > x = new {{alias:@stdlib/array/float32}}( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ] ); + > {{alias}}( 3, x, 2 ) + ~0.3333 + + // Using view offsets: + > var x0 = new {{alias:@stdlib/array/float32}}( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] ); + > var x1 = new {{alias:@stdlib/array/float32}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); + > {{alias}}( 3, x1, 2 ) + ~-0.3333 + + +{{alias}}.ndarray( N, x, strideX, offsetX ) + Computes the arithmetic mean of a single-precision floating-point strided + array using pairwise summation 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. + + x: Float32Array + Input array. + + strideX: integer + Stride length. + + offsetX: integer + Starting index. + + Returns + ------- + out: float + The arithmetic mean. + + Examples + -------- + // Standard Usage: + > var x = new {{alias:@stdlib/array/float32}}( [ 1.0, -2.0, NaN, 2.0 ] ); + > {{alias}}.ndarray( x.length, x, 1, 0 ) + ~0.3333 + + // Using offset parameter: + > var x = new {{alias:@stdlib/array/float32}}( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] ); + > {{alias}}.ndarray( 3, x, 2, 1 ) + ~-0.3333 + + See Also + -------- + From f50a2a6bace9440b197d5bc0ee82085a124aa03e Mon Sep 17 00:00:00 2001 From: Arjan Date: Thu, 6 Aug 2026 13:37:10 +0530 Subject: [PATCH 04/16] docs: add `docs/types` --- 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_pkg_readmes status: na - task: lint_markdown_docs status: na - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: passed - task: lint_license_headers status: passed --- --- .../strided/snanmeanpw/docs/types/index.d.ts | 92 ++++++++++ .../strided/snanmeanpw/docs/types/test.ts | 157 ++++++++++++++++++ 2 files changed, 249 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/docs/types/index.d.ts create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/docs/types/test.ts diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/docs/types/index.d.ts new file mode 100644 index 000000000000..f697eb92f814 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/docs/types/index.d.ts @@ -0,0 +1,92 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +// TypeScript Version: 4.1 + +/** +* Interface describing `snanmeanpw`. +*/ +interface Routine { + /** + * Computes the arithmetic mean of a single-precision floating-point strided array, ignoring `NaN` values using pairwise summation. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length + * @returns arithmetic mean + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, -2.0, 2.0 ] ); + * + * var v = snanmeanpw( x.length, x, 1 ); + * // returns ~0.3333 + */ + ( N: number, x: Float32Array, strideX: number ): number; + + /** + * Computes the arithmetic mean of a single-precision floating-point strided array ignoring `NaN` values and using pairwise summation and alternative indexing semantics. + * + * @param N - number of indexed elements + * @param x - input array + * @param strideX - stride length + * @param offsetX - starting index + * @returns arithmetic mean + * + * @example + * var Float32Array = require( '@stdlib/array/float32' ); + * + * var x = new Float32Array( [ 1.0, -2.0, 2.0 ] ); + * + * var v = snanmeanpw.ndarray( x.length, x, 1, 0 ); + * // returns ~0.3333 + */ + ndarray( N: number, x: Float32Array, strideX: number, offsetX: number ): number; +} + +/** +* Computes the arithmetic mean of a single-precision floating-point strided array, ignoring `NaN` values and using pairwise summation. +* +* @param N - number of indexed elements +* @param x - input array +* @param strideX - stride length +* @returns arithmetic mean +* +* @example +* var Float32Array = require( '@stdlib/array/float32' ); +* +* var x = new Float32Array( [ 1.0, -2.0, 2.0 ] ); +* +* var v = snanmeanpw( x.length, x, 1 ); +* // returns ~0.3333 +* +* @example +* var Float32Array = require( '@stdlib/array/float32' ); +* +* var x = new Float32Array( [ 1.0, -2.0, 2.0 ] ); +* +* var v = snanmeanpw.ndarray( x.length, x, 1, 0 ); +* // returns ~0.3333 +*/ +declare var snanmeanpw: Routine; + + +// EXPORTS // + +export = snanmeanpw; diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/docs/types/test.ts b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/docs/types/test.ts new file mode 100644 index 000000000000..bdbaad7d7ca1 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/docs/types/test.ts @@ -0,0 +1,157 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2020 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +import snanmeanpw = require( './index' ); + + +// TESTS // + +// The function returns a number... +{ + const x = new Float32Array( 10 ); + + snanmeanpw( x.length, x, 1 ); // $ExpectType number +} + +// The compiler throws an error if the function is provided a first argument which is not a number... +{ + const x = new Float32Array( 10 ); + + snanmeanpw( '10', x, 1 ); // $ExpectError + snanmeanpw( true, x, 1 ); // $ExpectError + snanmeanpw( false, x, 1 ); // $ExpectError + snanmeanpw( null, x, 1 ); // $ExpectError + snanmeanpw( undefined, x, 1 ); // $ExpectError + snanmeanpw( [], x, 1 ); // $ExpectError + snanmeanpw( {}, x, 1 ); // $ExpectError + snanmeanpw( ( x: number ): number => x, x, 1 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a second argument which is not a Float32Array... +{ + const x = new Float32Array( 10 ); + + snanmeanpw( x.length, 10, 1 ); // $ExpectError + snanmeanpw( x.length, '10', 1 ); // $ExpectError + snanmeanpw( x.length, true, 1 ); // $ExpectError + snanmeanpw( x.length, false, 1 ); // $ExpectError + snanmeanpw( x.length, null, 1 ); // $ExpectError + snanmeanpw( x.length, undefined, 1 ); // $ExpectError + snanmeanpw( x.length, [], 1 ); // $ExpectError + snanmeanpw( x.length, {}, 1 ); // $ExpectError + snanmeanpw( x.length, ( x: number ): number => x, 1 ); // $ExpectError +} + +// The compiler throws an error if the function is provided a third argument which is not a number... +{ + const x = new Float32Array( 10 ); + + snanmeanpw( x.length, x, '10' ); // $ExpectError + snanmeanpw( x.length, x, true ); // $ExpectError + snanmeanpw( x.length, x, false ); // $ExpectError + snanmeanpw( x.length, x, null ); // $ExpectError + snanmeanpw( x.length, x, undefined ); // $ExpectError + snanmeanpw( x.length, x, [] ); // $ExpectError + snanmeanpw( x.length, x, {} ); // $ExpectError + snanmeanpw( x.length, x, ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the function is provided an unsupported number of arguments... +{ + const x = new Float32Array( 10 ); + + snanmeanpw(); // $ExpectError + snanmeanpw( x.length ); // $ExpectError + snanmeanpw( x.length, x ); // $ExpectError + snanmeanpw( x.length, x, 1, 10 ); // $ExpectError +} + +// Attached to main export is an `ndarray` method which returns a number... +{ + const x = new Float32Array( 10 ); + + snanmeanpw.ndarray( x.length, 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 Float32Array( 10 ); + + snanmeanpw.ndarray( '10', x, 1, 0 ); // $ExpectError + snanmeanpw.ndarray( true, x, 1, 0 ); // $ExpectError + snanmeanpw.ndarray( false, x, 1, 0 ); // $ExpectError + snanmeanpw.ndarray( null, x, 1, 0 ); // $ExpectError + snanmeanpw.ndarray( undefined, x, 1, 0 ); // $ExpectError + snanmeanpw.ndarray( [], x, 1, 0 ); // $ExpectError + snanmeanpw.ndarray( {}, x, 1, 0 ); // $ExpectError + snanmeanpw.ndarray( ( x: number ): number => x, x, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a second argument which is not a Float32Array... +{ + const x = new Float32Array( 10 ); + + snanmeanpw.ndarray( x.length, 10, 1, 0 ); // $ExpectError + snanmeanpw.ndarray( x.length, '10', 1, 0 ); // $ExpectError + snanmeanpw.ndarray( x.length, true, 1, 0 ); // $ExpectError + snanmeanpw.ndarray( x.length, false, 1, 0 ); // $ExpectError + snanmeanpw.ndarray( x.length, null, 1, 0 ); // $ExpectError + snanmeanpw.ndarray( x.length, undefined, 1, 0 ); // $ExpectError + snanmeanpw.ndarray( x.length, [], 1, 0 ); // $ExpectError + snanmeanpw.ndarray( x.length, {}, 1, 0 ); // $ExpectError + snanmeanpw.ndarray( x.length, ( x: number ): number => x, 1, 0 ); // $ExpectError +} + +// The compiler throws an error if the `ndarray` method is provided a third argument which is not a number... +{ + const x = new Float32Array( 10 ); + + snanmeanpw.ndarray( x.length, x, '10', 0 ); // $ExpectError + snanmeanpw.ndarray( x.length, x, true, 0 ); // $ExpectError + snanmeanpw.ndarray( x.length, x, false, 0 ); // $ExpectError + snanmeanpw.ndarray( x.length, x, null, 0 ); // $ExpectError + snanmeanpw.ndarray( x.length, x, undefined, 0 ); // $ExpectError + snanmeanpw.ndarray( x.length, x, [], 0 ); // $ExpectError + snanmeanpw.ndarray( x.length, x, {}, 0 ); // $ExpectError + snanmeanpw.ndarray( x.length, 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 Float32Array( 10 ); + + snanmeanpw.ndarray( x.length, x, 1, '10' ); // $ExpectError + snanmeanpw.ndarray( x.length, x, 1, true ); // $ExpectError + snanmeanpw.ndarray( x.length, x, 1, false ); // $ExpectError + snanmeanpw.ndarray( x.length, x, 1, null ); // $ExpectError + snanmeanpw.ndarray( x.length, x, 1, undefined ); // $ExpectError + snanmeanpw.ndarray( x.length, x, 1, [] ); // $ExpectError + snanmeanpw.ndarray( x.length, x, 1, {} ); // $ExpectError + snanmeanpw.ndarray( x.length, 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 Float32Array( 10 ); + + snanmeanpw.ndarray(); // $ExpectError + snanmeanpw.ndarray( x.length ); // $ExpectError + snanmeanpw.ndarray( x.length, x ); // $ExpectError + snanmeanpw.ndarray( x.length, x, 1 ); // $ExpectError + snanmeanpw.ndarray( x.length, x, 1, 0, 10 ); // $ExpectError +} From fdad3b63890a89da277eba5317ed58df13a0d990 Mon Sep 17 00:00:00 2001 From: Arjan Date: Thu, 6 Aug 2026 14:13:30 +0530 Subject: [PATCH 05/16] test: setup js tests --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown_pkg_readmes status: na - task: lint_markdown_docs status: na - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../stats/strided/snanmeanpw/test/test.js | 82 +++++++++ .../strided/snanmeanpw/test/test.ndarray.js | 161 +++++++++++++++++ .../snanmeanpw/test/test.snanmeanpw.js | 165 ++++++++++++++++++ 3 files changed, 408 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.js create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.ndarray.js create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.snanmeanpw.js diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.js b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.js new file mode 100644 index 000000000000..c8da3b0b03e2 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.js @@ -0,0 +1,82 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var proxyquire = require( 'proxyquire' ); +var IS_BROWSER = require( '@stdlib/assert/is-browser' ); +var snanmeanpw = require( './../lib' ); + + +// VARIABLES // + +var opts = { + 'skip': IS_BROWSER +}; + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof snanmeanpw, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'attached to the main export is a method providing an ndarray interface', function test( t ) { + t.strictEqual( typeof snanmeanpw.ndarray, 'function', 'method is a function' ); + t.end(); +}); + +tape( 'if a native implementation is available, the main export is the native implementation', opts, function test( t ) { + var snanmeanpw = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire + }); + + t.strictEqual( snanmeanpw, mock, 'returns expected value' ); + t.end(); + + function tryRequire() { + return mock; + } + + function mock() { + // Mock... + } +}); + +tape( 'if a native implementation is not available, the main export is a JavaScript implementation', opts, function test( t ) { + var snanmeanpw; + var main; + + main = require( './../lib/snanmeanpw.js' ); + + snanmeanpw = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire + }); + + t.strictEqual( snanmeanpw, main, 'returns expected value' ); + t.end(); + + function tryRequire() { + return new Error( 'Cannot find module' ); + } +}); diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.ndarray.js b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.ndarray.js new file mode 100644 index 000000000000..33db79be9df9 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.ndarray.js @@ -0,0 +1,161 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var Float32Array = require( '@stdlib/array/float32' ); +var snanmeanpw = require( './../lib/ndarray.js' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof snanmeanpw, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 4', function test( t ) { + t.strictEqual( snanmeanpw.length, 4, 'has expected arity' ); + t.end(); +}); + +tape( 'the function calculates the arithmetic mean of a strided array', function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ] ); + v = snanmeanpw( x.length, x, 1, 0 ); + t.strictEqual( v, 0.5, 'returns expected value' ); + + x = new Float32Array( [ -4.0, -4.0 ] ); + v = snanmeanpw( x.length, x, 1, 0 ); + t.strictEqual( v, -4.0, 'returns expected value' ); + + x = new Float32Array( [ -4.0, NaN ] ); + v = snanmeanpw( x.length, x, 1, 0 ); + t.strictEqual( v, -4.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `NaN`', function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = snanmeanpw( 0, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + v = snanmeanpw( -1, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter equal to `1`, the function returns the first indexed element', function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = snanmeanpw( 1, x, 1, 0 ); + t.strictEqual( v, 1.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports a `stride` parameter', function test( t ) { + var x; + var v; + + x = new Float32Array([ + 1.0, // 0 + 2.0, + 2.0, // 1 + -7.0, + -2.0, // 2 + 3.0, + 4.0, // 3 + 2.0 + ]); + + v = snanmeanpw( 4, x, 2, 0 ); + + t.strictEqual( v, 1.25, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports a negative `stride` parameter', function test( t ) { + var x; + var v; + + x = new Float32Array([ + 1.0, // 3 + 2.0, + 2.0, // 2 + -7.0, + -2.0, // 1 + 3.0, + 4.0, // 0 + 2.0 + ]); + + v = snanmeanpw( 4, x, -2, 6 ); + + t.strictEqual( v, 1.25, 'returns expected value' ); + t.end(); +}); + +tape( 'if provided a `stride` parameter equal to `0`, the function returns the first indexed element', function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = snanmeanpw( x.length, x, 0, 0 ); + t.strictEqual( v, 1.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports an `offset` parameter', function test( t ) { + var x; + var v; + + x = new Float32Array([ + 2.0, + 1.0, // 0 + 2.0, + -2.0, // 1 + -2.0, + 2.0, // 2 + 3.0, + 4.0 // 3 + ]); + + v = snanmeanpw( 4, x, 2, 1 ); + t.strictEqual( v, 1.25, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.snanmeanpw.js b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.snanmeanpw.js new file mode 100644 index 000000000000..e80baadb0241 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.snanmeanpw.js @@ -0,0 +1,165 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var Float32Array = require( '@stdlib/array/float32' ); +var snanmeanpw = require( './../lib/snanmeanpw' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof snanmeanpw, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 3', function test( t ) { + t.strictEqual( snanmeanpw.length, 3, 'has expected arity' ); + t.end(); +}); + +tape( 'the function calculates the arithmetic mean of a strided array', function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ] ); + v = snanmeanpw( x.length, x, 1 ); + t.strictEqual( v, 0.5, 'returns expected value' ); + + x = new Float32Array( [ -4.0, -4.0 ] ); + v = snanmeanpw( x.length, x, 1 ); + t.strictEqual( v, -4.0, 'returns expected value' ); + + x = new Float32Array( [ -4.0, NaN ] ); + v = snanmeanpw( x.length, x, 1 ); + t.strictEqual( v, -4.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `NaN`', function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = snanmeanpw( 0, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + v = snanmeanpw( -1, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter equal to `1`, the function returns the first element', function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = snanmeanpw( 1, x, 1 ); + t.strictEqual( v, 1.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports a `stride` parameter', function test( t ) { + var x; + var v; + + x = new Float32Array([ + 1.0, // 0 + 2.0, + 2.0, // 1 + -7.0, + -2.0, // 2 + 3.0, + 4.0, // 3 + 2.0 + ]); + + v = snanmeanpw( 4, x, 2 ); + + t.strictEqual( v, 1.25, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports a negative `stride` parameter', function test( t ) { + var x; + var v; + + x = new Float32Array([ + 1.0, // 3 + 2.0, + 2.0, // 2 + -7.0, + -2.0, // 1 + 3.0, + 4.0, // 0 + 2.0 + ]); + + v = snanmeanpw( 4, x, -2 ); + + t.strictEqual( v, 1.25, 'returns expected value' ); + t.end(); +}); + +tape( 'if provided a `stride` parameter equal to `0`, the function returns the first element', function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = snanmeanpw( x.length, x, 0 ); + t.strictEqual( v, 1.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports view offsets', function test( t ) { + var x0; + var x1; + var v; + + x0 = new Float32Array([ + 2.0, + 1.0, // 0 + 2.0, + -2.0, // 1 + -2.0, + 2.0, // 2 + 3.0, + 4.0, // 3 + 6.0 + ]); + + x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element + + v = snanmeanpw( 4, x1, 2 ); + t.strictEqual( v, 1.25, 'returns expected value' ); + + t.end(); +}); From 175cb824ac331e2d9f9514aee8b1c633c55d12f3 Mon Sep 17 00:00:00 2001 From: Arjan Date: Thu, 6 Aug 2026 14:15:36 +0530 Subject: [PATCH 06/16] chore: add js examples --- 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_pkg_readmes status: na - task: lint_markdown_docs status: na - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: passed - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../strided/snanmeanpw/examples/index.js | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/examples/index.js diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/examples/index.js b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/examples/index.js new file mode 100644 index 000000000000..3c16cc7cb54f --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/examples/index.js @@ -0,0 +1,36 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +var randu = require( '@stdlib/random/base/randu' ); +var round = require( '@stdlib/math/base/special/round' ); +var Float32Array = require( '@stdlib/array/float32' ); +var snanmeanpw = require( './../lib' ); + +var x; +var i; + +x = new Float32Array( 10 ); +for ( i = 0; i < x.length; i++ ) { + x[ i ] = round( (randu()*100.0) - 50.0 ); +} +console.log( x ); + +var v = snanmeanpw( x.length, x, 1 ); +console.log( v ); From 3129c0ddb84f62a62f471a88a7291ddbb2ab32fe Mon Sep 17 00:00:00 2001 From: Arjan Date: Thu, 6 Aug 2026 16:49:41 +0530 Subject: [PATCH 07/16] bench: add js benchmarks --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown_pkg_readmes status: na - task: lint_markdown_docs status: na - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: passed - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../strided/snanmeanpw/benchmark/benchmark.js | 103 ++++++++++++++++++ .../snanmeanpw/benchmark/benchmark.ndarray.js | 103 ++++++++++++++++++ 2 files changed, 206 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/benchmark.js create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/benchmark.ndarray.js diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/benchmark.js new file mode 100644 index 000000000000..46a549ee60e8 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/benchmark.js @@ -0,0 +1,103 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var bench = require( '@stdlib/bench' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var format = require( '@stdlib/string/format' ); +var pkg = require( './../package.json' ).name; +var snanmeanpw = require( './../lib/snanmeanpw.js' ); + + +// VARIABLES // + +var options = { + 'dtype': 'float32' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + var x = uniform( len, -10.0, 10.0, options ); + 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 = snanmeanpw( x.length, 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( format( '%s:len=%d', pkg, len ), f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/benchmark.ndarray.js new file mode 100644 index 000000000000..ff107296114f --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/benchmark.ndarray.js @@ -0,0 +1,103 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var bench = require( '@stdlib/bench' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var format = require( '@stdlib/string/format' ); +var pkg = require( './../package.json' ).name; +var snanmeanpw = require( './../lib/ndarray.js' ); + + +// VARIABLES // + +var options = { + 'dtype': 'float32' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + var x = uniform( len, -10.0, 10.0, options ); + 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 = snanmeanpw( x.length, 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( format( '%s:ndarray:len=%d', pkg, len ), f ); + } +} + +main(); From fbb629a9c3a72588dea4587b7887fda1faffc95d Mon Sep 17 00:00:00 2001 From: Arjan Date: Thu, 6 Aug 2026 17:49:09 +0530 Subject: [PATCH 08/16] feat: add C implementation --- 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_pkg_readmes status: na - task: lint_markdown_docs status: na - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: passed - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: missing_dependencies - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../stats/strided/snanmeanpw/binding.gyp | 170 ++++++++++++++++++ .../stats/strided/snanmeanpw/include.gypi | 53 ++++++ .../include/stdlib/stats/strided/snanmeanpw.h | 45 +++++ .../stats/strided/snanmeanpw/lib/native.js | 35 ++++ .../strided/snanmeanpw/lib/ndarray.native.js | 52 ++++++ .../snanmeanpw/lib/snanmeanpw.native.js | 51 ++++++ .../stats/strided/snanmeanpw/manifest.json | 103 +++++++++++ .../stats/strided/snanmeanpw/src/Makefile | 70 ++++++++ .../stats/strided/snanmeanpw/src/addon.c | 61 +++++++ .../stats/strided/snanmeanpw/src/main.c | 76 ++++++++ 10 files changed, 716 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/binding.gyp create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/include.gypi create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/include/stdlib/stats/strided/snanmeanpw.h create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/lib/native.js create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/lib/ndarray.native.js create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/lib/snanmeanpw.native.js create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/manifest.json create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/src/Makefile create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/src/addon.c create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/src/main.c diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/binding.gyp b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/binding.gyp new file mode 100644 index 000000000000..0d6508a12e99 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/binding.gyp @@ -0,0 +1,170 @@ +# @license Apache-2.0 +# +# Copyright (c) 2026 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# A `.gyp` file for building a Node.js native add-on. +# +# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md +# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md +{ + # List of files to include in this file: + 'includes': [ + './include.gypi', + ], + + # Define variables to be used throughout the configuration for all targets: + 'variables': { + # Target name should match the add-on export name: + 'addon_target_name%': 'addon', + + # Set variables based on the host OS: + 'conditions': [ + [ + 'OS=="win"', + { + # Define the object file suffix: + 'obj': 'obj', + }, + { + # Define the object file suffix: + 'obj': 'o', + } + ], # end condition (OS=="win") + ], # end conditions + }, # end variables + + # Define compile targets: + 'targets': [ + + # Target to generate an add-on: + { + # The target name should match the add-on export name: + 'target_name': '<(addon_target_name)', + + # Define dependencies: + 'dependencies': [], + + # Define directories which contain relevant include headers: + 'include_dirs': [ + # Local include directory: + '<@(include_dirs)', + ], + + # List of source files: + 'sources': [ + '<@(src_files)', + ], + + # Settings which should be applied when a target's object files are used as linker input: + 'link_settings': { + # Define libraries: + 'libraries': [ + '<@(libraries)', + ], + + # Define library directories: + 'library_dirs': [ + '<@(library_dirs)', + ], + }, + + # C/C++ compiler flags: + 'cflags': [ + # Enable commonly used warning options: + '-Wall', + + # Aggressive optimization: + '-O3', + ], + + # C specific compiler flags: + 'cflags_c': [ + # Specify the C standard to which a program is expected to conform: + '-std=c99', + ], + + # C++ specific compiler flags: + 'cflags_cpp': [ + # Specify the C++ standard to which a program is expected to conform: + '-std=c++11', + ], + + # Linker flags: + 'ldflags': [], + + # Apply conditions based on the host OS: + 'conditions': [ + [ + 'OS=="mac"', + { + # Linker flags: + 'ldflags': [ + '-undefined dynamic_lookup', + '-Wl,-no-pie', + '-Wl,-search_paths_first', + ], + }, + ], # end condition (OS=="mac") + [ + 'OS!="win"', + { + # C/C++ flags: + 'cflags': [ + # Generate platform-independent code: + '-fPIC', + ], + }, + ], # end condition (OS!="win") + ], # end conditions + }, # end target <(addon_target_name) + + # Target to copy a generated add-on to a standard location: + { + 'target_name': 'copy_addon', + + # Declare that the output of this target is not linked: + 'type': 'none', + + # Define dependencies: + 'dependencies': [ + # Require that the add-on be generated before building this target: + '<(addon_target_name)', + ], + + # Define a list of actions: + 'actions': [ + { + 'action_name': 'copy_addon', + 'message': 'Copying addon...', + + # Explicitly list the inputs in the command-line invocation below: + 'inputs': [], + + # Declare the expected outputs: + 'outputs': [ + '<(addon_output_dir)/<(addon_target_name).node', + ], + + # Define the command-line invocation: + 'action': [ + 'cp', + '<(PRODUCT_DIR)/<(addon_target_name).node', + '<(addon_output_dir)/<(addon_target_name).node', + ], + }, + ], # end actions + }, # end target copy_addon + ], # end targets +} diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/include.gypi b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/include.gypi new file mode 100644 index 000000000000..bee8d41a2caf --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/include.gypi @@ -0,0 +1,53 @@ +# @license Apache-2.0 +# +# Copyright (c) 2026 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# A GYP include file for building a Node.js native add-on. +# +# Main documentation: +# +# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md +# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md +{ + # Define variables to be used throughout the configuration for all targets: + 'variables': { + # Source directory: + 'src_dir': './src', + + # Include directories: + 'include_dirs': [ + ' + +/** +* Receives JavaScript callback invocation data. +* +* @param env environment under which the function is invoked +* @param info callback data +* @return Node-API value +*/ +static napi_value addon( napi_env env, napi_callback_info info ) { + STDLIB_NAPI_ARGV( env, info, argv, argc, 3 ); + STDLIB_NAPI_ARGV_INT64( env, N, argv, 0 ); + STDLIB_NAPI_ARGV_INT64( env, strideX, argv, 2 ); + STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, X, N, strideX, argv, 1 ); + STDLIB_NAPI_CREATE_DOUBLE( env, (double)API_SUFFIX(stdlib_strided_snanmeanpw)( N, X, strideX ), v ); + return v; +} + +/** +* Receives JavaScript callback invocation data. +* +* @param env environment under which the function is invoked +* @param info callback data +* @return Node-API value +*/ +static napi_value addon_method( napi_env env, napi_callback_info info ) { + STDLIB_NAPI_ARGV( env, info, argv, argc, 4 ); + STDLIB_NAPI_ARGV_INT64( env, N, argv, 0 ); + STDLIB_NAPI_ARGV_INT64( env, strideX, argv, 2 ); + STDLIB_NAPI_ARGV_INT64( env, offsetX, argv, 3 ); + STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, X, N, strideX, argv, 1 ); + STDLIB_NAPI_CREATE_DOUBLE( env, (double)API_SUFFIX(stdlib_strided_snanmeanpw_ndarray)( N, X, strideX, offsetX ), v ); + return v; +} + +STDLIB_NAPI_MODULE_EXPORT_FCN_WITH_METHOD( addon, "ndarray", addon_method ) diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/src/main.c b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/src/main.c new file mode 100644 index 000000000000..a1d4e389ae2b --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/src/main.c @@ -0,0 +1,76 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "stdlib/blas/base/shared/cblas.h" +#include "stdlib/stats/strided/snanmeanpw.h" +#include "stdlib/blas/ext/base/snansumpw.h" +#include "stdlib/blas/base/shared.h" +#include "stdlib/strided/base/stride2offset.h" + +/** +* Computes the arithmetic mean of a single-precision floating-point strided array, ignoring 'NaN' values and using pairwise summation. +* +* @param N number of indexed elements +* @param X input array +* @param strideX stride length +* @return output value +*/ +float API_SUFFIX(stdlib_strided_snanmeanpw)( const CBLAS_INT N, const float *X, const CBLAS_INT strideX ) { + const CBLAS_INT ox = stdlib_strided_stride2offset( N, strideX ); + return API_SUFFIX(stdlib_strided_snanmeanpw_ndarray)( N, X, strideX, ox ); +} + +/** +* Computes the arithmetic mean of a single-precision floating-point strided array using pairwise summation and alternative indexing semantics, ignoring `NaN` values. +* +* @param N number of indexed elements +* @param X input array +* @param strideX stride length +* @param offsetX starting index for X +* @return output value +*/ +float API_SUFFIX(stdlib_strided_snanmeanpw_ndarray)( const CBLAS_INT N, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX ) { + CBLAS_INT ix; + CBLAS_INT i; + CBLAS_INT n; + float v; + if ( N <= 0 ) { + return 0.0f / 0.0f; // NaN + } + if ( N == 1 || strideX == 0 ) { + return X[ 0 ]; + } + + ix = offsetX; + n = 0; + + // Compute non-NaN terms + for( i = 0; i < N; i++ ) { + v = X[ix]; + if ( v == v ) { + n += 1; + } + ix += strideX; + } + + if ( n == 0 ) { + return 0.0f / 0.0f; // NaN + } + + return (double)API_SUFFIX(stdlib_strided_snansumpw_ndarray)( N, X, strideX, offsetX ) / (double)n; +} From 58de4fcaeefc6090f67eadf52fcc3080b0e7d475 Mon Sep 17 00:00:00 2001 From: Arjan Date: Thu, 6 Aug 2026 18:09:06 +0530 Subject: [PATCH 09/16] bench: add native addon benchmarks --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown_pkg_readmes status: na - task: lint_markdown_docs status: na - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: passed - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../snanmeanpw/benchmark/benchmark.native.js | 108 ++++++++++++++++++ .../benchmark/benchmark.ndarray.native.js | 108 ++++++++++++++++++ 2 files changed, 216 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/benchmark.native.js create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/benchmark.ndarray.native.js diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/benchmark.native.js new file mode 100644 index 000000000000..a4833af14a18 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/benchmark.native.js @@ -0,0 +1,108 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var resolve = require( 'path' ).resolve; +var bench = require( '@stdlib/bench' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var tryRequire = require( '@stdlib/utils/try-require' ); +var format = require( '@stdlib/string/format' ); +var pkg = require( './../package.json' ).name; + + +// VARIABLES // + +var snanmeanpw = tryRequire( resolve( __dirname, './../lib/snanmeanpw.native.js' ) ); +var opts = { + 'skip': ( snanmeanpw instanceof Error ) +}; +var options = { + 'dtype': 'float32' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + var x = uniform( len, -10.0, 10.0, options ); + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var v; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = snanmeanpw( x.length, 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( format( '%s::native:len=%d', pkg, len ), opts, f ); + } +} + +main(); diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/benchmark.ndarray.native.js b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/benchmark.ndarray.native.js new file mode 100644 index 000000000000..79cca8ea2d6f --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/benchmark.ndarray.native.js @@ -0,0 +1,108 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var resolve = require( 'path' ).resolve; +var bench = require( '@stdlib/bench' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var tryRequire = require( '@stdlib/utils/try-require' ); +var format = require( '@stdlib/string/format' ); +var pkg = require( './../package.json' ).name; + + +// VARIABLES // + +var snanmeanpw = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) ); +var opts = { + 'skip': ( snanmeanpw instanceof Error ) +}; +var options = { + 'dtype': 'float32' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + var x = uniform( len, -10.0, 10.0, options ); + return benchmark; + + /** + * Benchmark function. + * + * @private + * @param {Benchmark} b - benchmark instance + */ + function benchmark( b ) { + var v; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = snanmeanpw( x.length, 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( format( '%s::native:ndarray:len=%d', pkg, len ), opts, f ); + } +} + +main(); From ae19c7f74dde2feb4932a9ef494d8eb4406e287b Mon Sep 17 00:00:00 2001 From: Arjan Date: Thu, 6 Aug 2026 21:05:22 +0530 Subject: [PATCH 10/16] bench: add benchmark/c --- 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_pkg_readmes status: na - task: lint_markdown_docs status: na - 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: missing_dependencies - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../strided/snanmeanpw/benchmark/c/Makefile | 146 +++++++++++++ .../snanmeanpw/benchmark/c/benchmark.length.c | 200 ++++++++++++++++++ 2 files changed, 346 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/c/Makefile create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/c/benchmark.length.c diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/c/Makefile b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/c/Makefile new file mode 100644 index 000000000000..0756dc7da20a --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/c/Makefile @@ -0,0 +1,146 @@ +#/ +# @license Apache-2.0 +# +# Copyright (c) 2026 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#/ + +# VARIABLES # + +ifndef VERBOSE + QUIET := @ +else + QUIET := +endif + +# Determine the OS ([1][1], [2][2]). +# +# [1]: https://en.wikipedia.org/wiki/Uname#Examples +# [2]: http://stackoverflow.com/a/27776822/2225624 +OS ?= $(shell uname) +ifneq (, $(findstring MINGW,$(OS))) + OS := WINNT +else +ifneq (, $(findstring MSYS,$(OS))) + OS := WINNT +else +ifneq (, $(findstring CYGWIN,$(OS))) + OS := WINNT +else +ifneq (, $(findstring Windows_NT,$(OS))) + OS := WINNT +endif +endif +endif +endif + +# Define the program used for compiling C source files: +ifdef C_COMPILER + CC := $(C_COMPILER) +else + CC := gcc +endif + +# Define the command-line options when compiling C files: +CFLAGS ?= \ + -std=c99 \ + -O3 \ + -Wall \ + -pedantic + +# Determine whether to generate position independent code ([1][1], [2][2]). +# +# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options +# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option +ifeq ($(OS), WINNT) + fPIC ?= +else + fPIC ?= -fPIC +endif + +# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`): +INCLUDE ?= + +# List of source files: +SOURCE_FILES ?= + +# List of libraries (e.g., `-lopenblas -lpthread`): +LIBRARIES ?= + +# List of library paths (e.g., `-L /foo/bar -L /beep/boop`): +LIBPATH ?= + +# List of C targets: +c_targets := benchmark.length.out + + +# RULES # + +#/ +# Compiles source files. +# +# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`) +# @param {string} [CFLAGS] - C compiler options +# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`) +# @param {string} [SOURCE_FILES] - list of source files +# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`) +# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`) +# +# @example +# make +# +# @example +# make all +#/ +all: $(c_targets) + +.PHONY: all + +#/ +# Compiles C source files. +# +# @private +# @param {string} CC - C compiler (e.g., `gcc`) +# @param {string} CFLAGS - C compiler options +# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`) +# @param {string} SOURCE_FILES - list of source files +# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`) +# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`) +#/ +$(c_targets): %.out: %.c + $(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES) + +#/ +# Runs compiled benchmarks. +# +# @example +# make run +#/ +run: $(c_targets) + $(QUIET) ./$< + +.PHONY: run + +#/ +# Removes generated files. +# +# @example +# make clean +#/ +clean: + $(QUIET) -rm -f *.o *.out + +.PHONY: clean diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/c/benchmark.length.c b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/c/benchmark.length.c new file mode 100644 index 000000000000..51d43c20030c --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/benchmark/c/benchmark.length.c @@ -0,0 +1,200 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "stdlib/stats/strided/snanmeanpw.h" +#include +#include +#include +#include +#include + +#define NAME "snanmeanpw" +#define ITERATIONS 1000000 +#define REPEATS 3 +#define MIN 1 +#define MAX 6 + +/** +* Prints the TAP version. +*/ +static void print_version( void ) { + printf( "TAP version 13\n" ); +} + +/** +* Prints the TAP summary. +* +* @param total total number of tests +* @param passing total number of passing tests +*/ +static void print_summary( int total, int passing ) { + printf( "#\n" ); + printf( "1..%d\n", total ); // TAP plan + printf( "# total %d\n", total ); + printf( "# pass %d\n", passing ); + printf( "#\n" ); + printf( "# ok\n" ); +} + +/** +* Prints benchmarks results. +* +* @param iterations number of iterations +* @param elapsed elapsed time in seconds +*/ +static void print_results( int iterations, double elapsed ) { + double rate = (double)iterations / elapsed; + printf( " ---\n" ); + printf( " iterations: %d\n", iterations ); + printf( " elapsed: %0.9f\n", elapsed ); + printf( " rate: %0.9f\n", rate ); + printf( " ...\n" ); +} + +/** +* Returns a clock time. +* +* @return clock time +*/ +static double tic( void ) { + struct timeval now; + gettimeofday( &now, NULL ); + return (double)now.tv_sec + (double)now.tv_usec/1.0e6; +} + +/** +* Generates a random number on the interval [0,1). +* +* @return random number +*/ +static float rand_float( void ) { + int r = rand(); + return (float)r / ( (float)RAND_MAX + 1.0f ); +} + +/** +* Runs a benchmark. +* +* @param iterations number of iterations +* @param len array length +* @return elapsed time in seconds +*/ +static double benchmark1( int iterations, int len ) { + double elapsed; + float* x; + float v; + double t; + int i; + + x = (float *)malloc( len * sizeof( float ) ); + for ( i = 0; i < len; i++ ) { + x[ i ] = ( rand_float()*20000.0f ) - 10000.0f; + } + v = 0.0f; + t = tic(); + for ( i = 0; i < iterations; i++ ) { + // cppcheck-suppress uninitvar + v = stdlib_strided_snanmeanpw( len, x, 1 ); + if ( v != v ) { + printf( "should not return NaN\n" ); + break; + } + } + elapsed = tic() - t; + if ( v != v ) { + printf( "should not return NaN\n" ); + } + free( x ); + return elapsed; +} + +/** +* Runs a benchmark. +* +* @param iterations number of iterations +* @param len array length +* @return elapsed time in seconds +*/ +static double benchmark2( int iterations, int len ) { + double elapsed; + float* x; + float v; + double t; + int i; + + x = (float *)malloc( len * sizeof( float) ); + for ( i = 0; i < len; i++ ) { + x[ i ] = ( rand_float()*20000.0f ) - 10000.0f; + } + v = 0.0f; + t = tic(); + for ( i = 0; i < iterations; i++ ) { + // cppcheck-suppress uninitvar + v = stdlib_strided_snanmeanpw_ndarray( len, x, 1, 0 ); + if ( v != v ) { + printf( "should not return NaN\n" ); + break; + } + } + elapsed = tic() - t; + if ( v != v ) { + printf( "should not return NaN\n" ); + } + return elapsed; +} + +/** +* Main execution sequence. +*/ +int main( void ) { + double elapsed; + int count; + int iter; + int len; + int i; + int j; + + // Use the current time to seed the random number generator: + srand( time( NULL ) ); + + print_version(); + count = 0; + for ( i = MIN; i <= MAX; i++ ) { + len = pow( 10, i ); + iter = ITERATIONS / pow( 10, i-1 ); + for ( j = 0; j < REPEATS; j++ ) { + count += 1; + printf( "# c::%s:len=%d\n", NAME, len ); + elapsed = benchmark1( iter, len ); + print_results( iter, elapsed ); + printf( "ok %d benchmark finished\n", count ); + } + } + for ( i = MIN; i <= MAX; i++ ) { + len = pow( 10, i ); + iter = ITERATIONS / pow( 10, i-1 ); + for ( j = 0; j < REPEATS; j++ ) { + count += 1; + printf( "# c::%s:ndarray:len=%d\n", NAME, len ); + elapsed = benchmark2( iter, len ); + print_results( iter, elapsed ); + printf( "ok %d benchmark finished\n", count ); + } + } + print_summary( count, count ); +} From 3ff536cb4d87cb9e46d027623c974214a7158261 Mon Sep 17 00:00:00 2001 From: Arjan Date: Thu, 6 Aug 2026 21:12:44 +0530 Subject: [PATCH 11/16] chore: add examples/c --- 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_pkg_readmes status: na - task: lint_markdown_docs status: na - 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: missing_dependencies - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../strided/snanmeanpw/examples/c/Makefile | 146 ++++++++++++++++++ .../strided/snanmeanpw/examples/c/example.c | 37 +++++ 2 files changed, 183 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/examples/c/Makefile create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/examples/c/example.c diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/examples/c/Makefile b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/examples/c/Makefile new file mode 100644 index 000000000000..c8f8e9a1517b --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/examples/c/Makefile @@ -0,0 +1,146 @@ +#/ +# @license Apache-2.0 +# +# Copyright (c) 2026 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +#/ + +# VARIABLES # + +ifndef VERBOSE + QUIET := @ +else + QUIET := +endif + +# Determine the OS ([1][1], [2][2]). +# +# [1]: https://en.wikipedia.org/wiki/Uname#Examples +# [2]: http://stackoverflow.com/a/27776822/2225624 +OS ?= $(shell uname) +ifneq (, $(findstring MINGW,$(OS))) + OS := WINNT +else +ifneq (, $(findstring MSYS,$(OS))) + OS := WINNT +else +ifneq (, $(findstring CYGWIN,$(OS))) + OS := WINNT +else +ifneq (, $(findstring Windows_NT,$(OS))) + OS := WINNT +endif +endif +endif +endif + +# Define the program used for compiling C source files: +ifdef C_COMPILER + CC := $(C_COMPILER) +else + CC := gcc +endif + +# Define the command-line options when compiling C files: +CFLAGS ?= \ + -std=c99 \ + -O3 \ + -Wall \ + -pedantic + +# Determine whether to generate position independent code ([1][1], [2][2]). +# +# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options +# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option +ifeq ($(OS), WINNT) + fPIC ?= +else + fPIC ?= -fPIC +endif + +# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`): +INCLUDE ?= + +# List of source files: +SOURCE_FILES ?= + +# List of libraries (e.g., `-lopenblas -lpthread`): +LIBRARIES ?= + +# List of library paths (e.g., `-L /foo/bar -L /beep/boop`): +LIBPATH ?= + +# List of C targets: +c_targets := example.out + + +# RULES # + +#/ +# Compiles source files. +# +# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`) +# @param {string} [CFLAGS] - C compiler options +# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`) +# @param {string} [SOURCE_FILES] - list of source files +# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`) +# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`) +# +# @example +# make +# +# @example +# make all +#/ +all: $(c_targets) + +.PHONY: all + +#/ +# Compiles C source files. +# +# @private +# @param {string} CC - C compiler (e.g., `gcc`) +# @param {string} CFLAGS - C compiler options +# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`) +# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`) +# @param {string} SOURCE_FILES - list of source files +# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`) +# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`) +#/ +$(c_targets): %.out: %.c + $(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES) + +#/ +# Runs compiled examples. +# +# @example +# make run +#/ +run: $(c_targets) + $(QUIET) ./$< + +.PHONY: run + +#/ +# Removes generated files. +# +# @example +# make clean +#/ +clean: + $(QUIET) -rm -f *.o *.out + +.PHONY: clean diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/examples/c/example.c b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/examples/c/example.c new file mode 100644 index 000000000000..f2c6676da493 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/examples/c/example.c @@ -0,0 +1,37 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2020 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "stdlib/stats/strided/snanmeanpw.h" +#include + +int main( void ) { + // Create a strided array: + const float x[] = { 1.0f, 2.0f, 0.0f/0.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 0.0f/0.0f, 8.0f }; + + // Specify the number of elements: + const int N = 5; + + // Specify the stride length: + const int strideX = 2; + + // Compute the arithmetic mean: + float v = stdlib_strided_snanmeanpw( N, x, strideX ); + + // Print the result: + printf( "mean: %f\n", v ); +} From b82c9ce0560c99e66253cd813c12cdaea933ef8b Mon Sep 17 00:00:00 2001 From: Arjan Date: Thu, 6 Aug 2026 22:35:22 +0530 Subject: [PATCH 12/16] chore: add examples to show `NaN` handling behaviour --- 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_pkg_readmes status: passed - task: lint_markdown_docs status: na - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../stats/strided/snanmeanpw/README.md | 58 +++++++++++-------- 1 file changed, 35 insertions(+), 23 deletions(-) diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/README.md b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/README.md index e13e23f2f02b..b0e2f4ad13e8 100644 --- a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/README.md +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/README.md @@ -2,7 +2,7 @@ @license Apache-2.0 -Copyright (c) 2020 The Stdlib Authors. +Copyright (c) 2026 The Stdlib Authors. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. @@ -58,7 +58,7 @@ Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-p ```javascript var Float32Array = require( '@stdlib/array/float32' ); -var x = new Float32Array( [ 1.0, -2.0, 2.0 ] ); +var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] ); var v = snanmeanpw( x.length, x, 1 ); // returns ~0.3333 @@ -72,26 +72,28 @@ 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 compute the [arithmetic mean][arithmetic-mean] of every other element in `x`, + + ```javascript var Float32Array = require( '@stdlib/array/float32' ); -var x = new Float32Array( [ 1.0, 2.0, 2.0, -7.0, -2.0, 3.0, 4.0, 2.0 ] ); +var x = new Float32Array( [ 1.0, 2.0, 2.0, -7.0, -2.0, 3.0, 4.0, 2.0, NaN, NaN ] ); -var v = snanmeanpw( 4, x, 2 ); +var v = snanmeanpw( 5, x, 2 ); // returns 1.25 ``` Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views. - + ```javascript var Float32Array = require( '@stdlib/array/float32' ); -var x0 = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] ); +var x0 = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN, NaN ] ); var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element -var v = snanmeanpw( 4, x1, 2 ); +var v = snanmeanpw( 5, x1, 2 ); // returns 1.25 ``` @@ -102,7 +104,7 @@ Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-p ```javascript var Float32Array = require( '@stdlib/array/float32' ); -var x = new Float32Array( [ 1.0, -2.0, 2.0 ] ); +var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] ); var v = snanmeanpw.ndarray( x.length, x, 1, 0 ); // returns ~0.33333 @@ -114,12 +116,14 @@ 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 calculate the [arithmetic mean][arithmetic-mean] for every other element in `x` starting from the second element + + ```javascript var Float32Array = require( '@stdlib/array/float32' ); -var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] ); +var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN, NaN ] ); -var v = snanmeanpw.ndarray( 4, x, 2, 1 ); +var v = snanmeanpw.ndarray( 5, x, 2, 1 ); // returns 1.25 ``` @@ -132,6 +136,7 @@ var v = snanmeanpw.ndarray( 4, x, 2, 1 ); ## Notes - If `N <= 0`, both functions return `NaN`. +- If every indexed element is `NaN`, both functions return `NaN`. - In general, pairwise summation is more numerically stable than ordinary recursive summation (i.e., "simple" summation), with slightly worse performance. While not the most numerically stable summation technique (e.g., compensated summation techniques such as the Kahan–Babuška-Neumaier algorithm are generally more numerically stable), pairwise summation strikes a reasonable balance between numerical stability and performance. If either numerical stability or performance is more desirable for your use case, consider alternative summation techniques. @@ -145,12 +150,19 @@ var v = snanmeanpw.ndarray( 4, x, 2, 1 ); ```javascript -var discreteUniform = require( '@stdlib/random/array/discrete-uniform' ); +var uniform = require( '@stdlib/random/base/uniform' ); +var filledarrayBy = require( '@stdlib/array/filled-by' ); +var bernoulli = require( '@stdlib/random/base/bernoulli' ); var snanmeanpw = require( '@stdlib/stats/strided/snanmeanpw' ); -var x = discreteUniform( 10, -50, 50, { - 'dtype': 'float32' -}); +function rand() { + if ( bernoulli( 0.8 ) < 1 ) { + return NaN; + } + return uniform( -50.0, 50.0 ); +} + +var x = filledarrayBy( 10, 'float32', rand ); console.log( x ); var v = snanmeanpw( x.length, x, 1 ); @@ -189,12 +201,12 @@ console.log( v ); #### stdlib_strided_snanmeanpw( N, \*X, strideX ) -Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array using pairwise summation. +Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array, ignoring `NaN` values and using pairwise summation. ```c -const float x[] = { 1.0f, 2.0f, 3.0f }; +const float x[] = { 1.0f, 2.0f, 0.0f/0.0f, 3.0f }; -float v = stdlib_strided_snanmeanpw( 3, x, 1 ); +float v = stdlib_strided_snanmeanpw( 4, x, 1 ); // returns 2.0f ``` @@ -210,13 +222,13 @@ float stdlib_strided_snanmeanpw( const CBLAS_INT N, const float *X, const CBLAS_ #### stdlib_strided_snanmeanpw_ndarray( N, \*X, strideX, offsetX ) -Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array using pairwise summation and alternative indexing semantics. +Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array, ignoring `NaN` values and using pairwise summation and alternative indexing semantics. ```c -const float x[] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f }; +const float x[] = { 1.0f, -2.0f, 0.0f/0.0f, 2.0f }; -float v = stdlib_strided_snanmeanpw_ndarray( 4, x, 2, 0 ); -// returns 4.0f +float v = stdlib_strided_snanmeanpw_ndarray( 4, x, 1, 0 ); +// returns ~0.33333f ``` The function accepts the following arguments: @@ -254,10 +266,10 @@ float stdlib_strided_snanmeanpw_ndarray( const CBLAS_INT N, const float *X, cons int main( void ) { // Create a strided array: - const float x[] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f }; + const float x[] = { 1.0f, 2.0f, 0.0f/0.0f, 3.0f, 0.0f/0.0f, 4.0f, 5.0f, 6.0f, 0.0f/0.0f, 7.0f, 8.0f, 0.0f/0.0f }; // Specify the number of elements: - const int N = 4; + const int N = 6; // Specify the stride length: const int strideX = 2; From 95cdc4f4bad2f09f95ced572430b21c57416882a Mon Sep 17 00:00:00 2001 From: Arjan Date: Thu, 6 Aug 2026 22:40:13 +0530 Subject: [PATCH 13/16] chore: update examples to show `NaN` handling behaviour --- 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_pkg_readmes status: na - task: lint_markdown_docs status: na - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: passed - task: lint_javascript_tests status: na - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../strided/snanmeanpw/examples/index.js | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/examples/index.js b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/examples/index.js index 3c16cc7cb54f..0680a30af498 100644 --- a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/examples/index.js +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/examples/index.js @@ -18,18 +18,19 @@ 'use strict'; -var randu = require( '@stdlib/random/base/randu' ); -var round = require( '@stdlib/math/base/special/round' ); -var Float32Array = require( '@stdlib/array/float32' ); +var uniform = require( '@stdlib/random/base/uniform' ); +var filledarrayBy = require( '@stdlib/array/filled-by' ); +var bernoulli = require( '@stdlib/random/base/bernoulli' ); var snanmeanpw = require( './../lib' ); -var x; -var i; - -x = new Float32Array( 10 ); -for ( i = 0; i < x.length; i++ ) { - x[ i ] = round( (randu()*100.0) - 50.0 ); +function rand() { + if ( bernoulli( 0.8 ) < 1 ) { + return NaN; + } + return uniform( -50.0, 50.0 ); } + +var x = filledarrayBy( 10, 'float32', rand ); console.log( x ); var v = snanmeanpw( x.length, x, 1 ); From 17eca51dbc72846d600d5253cb7c98b5be6294d7 Mon Sep 17 00:00:00 2001 From: Arjan Date: Thu, 6 Aug 2026 22:53:33 +0530 Subject: [PATCH 14/16] test: update js tests to test NaN handling behaviour --- 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_pkg_readmes status: na - task: lint_markdown_docs status: na - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../strided/snanmeanpw/test/test.ndarray.js | 37 +++++++++++-------- .../snanmeanpw/test/test.snanmeanpw.js | 18 +++++---- 2 files changed, 33 insertions(+), 22 deletions(-) diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.ndarray.js b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.ndarray.js index 33db79be9df9..cd7645dcbc41 100644 --- a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.ndarray.js @@ -39,21 +39,24 @@ tape( 'the function has an arity of 4', function test( t ) { t.end(); }); -tape( 'the function calculates the arithmetic mean of a strided array', function test( t ) { +tape( 'the function calculates the arithmetic mean of a strided array, ignoring `NaN` values', function test( t ) { var x; var v; - x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ] ); + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, NaN, 0.0, 3.0 ] ); + v = snanmeanpw( x.length, x, 1, 0 ); t.strictEqual( v, 0.5, 'returns expected value' ); - x = new Float32Array( [ -4.0, -4.0 ] ); + x = new Float32Array( [ -4.0, NaN ] ); + v = snanmeanpw( x.length, x, 1, 0 ); t.strictEqual( v, -4.0, 'returns expected value' ); - x = new Float32Array( [ -4.0, NaN ] ); + x = new Float32Array( [ NaN, NaN ] ); + v = snanmeanpw( x.length, x, 1, 0 ); - t.strictEqual( v, -4.0, 'returns expected value' ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); t.end(); }); @@ -97,10 +100,11 @@ tape( 'the function supports a `stride` parameter', function test( t ) { -2.0, // 2 3.0, 4.0, // 3 - 2.0 + 2.0, + NaN // 4 ]); - v = snanmeanpw( 4, x, 2, 0 ); + v = snanmeanpw( 5, x, 2, 0 ); t.strictEqual( v, 1.25, 'returns expected value' ); t.end(); @@ -111,17 +115,18 @@ tape( 'the function supports a negative `stride` parameter', function test( t ) var v; x = new Float32Array([ - 1.0, // 3 + 1.0, // 4 2.0, - 2.0, // 2 + 2.0, // 3 -7.0, - -2.0, // 1 + -2.0, // 2 3.0, - 4.0, // 0 - 2.0 + 4.0, // 1 + 2.0, + NaN // 0 ]); - v = snanmeanpw( 4, x, -2, 6 ); + v = snanmeanpw( 5, x, -2, 8 ); t.strictEqual( v, 1.25, 'returns expected value' ); t.end(); @@ -151,10 +156,12 @@ tape( 'the function supports an `offset` parameter', function test( t ) { -2.0, 2.0, // 2 3.0, - 4.0 // 3 + 4.0, // 3 + NaN, + NaN // 4 ]); - v = snanmeanpw( 4, x, 2, 1 ); + v = snanmeanpw( 5, x, 2, 1 ); t.strictEqual( v, 1.25, 'returns expected value' ); t.end(); diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.snanmeanpw.js b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.snanmeanpw.js index e80baadb0241..9c80c6d0d8c7 100644 --- a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.snanmeanpw.js +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.snanmeanpw.js @@ -39,21 +39,24 @@ tape( 'the function has an arity of 3', function test( t ) { t.end(); }); -tape( 'the function calculates the arithmetic mean of a strided array', function test( t ) { +tape( 'the function calculates the arithmetic mean of a strided array, ignoring `NaN` values', function test( t ) { var x; var v; - x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ] ); + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, NaN, 0.0, 3.0 ] ); + v = snanmeanpw( x.length, x, 1 ); t.strictEqual( v, 0.5, 'returns expected value' ); - x = new Float32Array( [ -4.0, -4.0 ] ); + x = new Float32Array( [ -4.0, NaN ] ); + v = snanmeanpw( x.length, x, 1 ); t.strictEqual( v, -4.0, 'returns expected value' ); - x = new Float32Array( [ -4.0, NaN ] ); + x = new Float32Array( [ NaN, NaN ] ); + v = snanmeanpw( x.length, x, 1 ); - t.strictEqual( v, -4.0, 'returns expected value' ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); t.end(); }); @@ -153,12 +156,13 @@ tape( 'the function supports view offsets', function test( t ) { 2.0, // 2 3.0, 4.0, // 3 - 6.0 + 6.0, + NaN // 4 ]); x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element - v = snanmeanpw( 4, x1, 2 ); + v = snanmeanpw( 5, x1, 2 ); t.strictEqual( v, 1.25, 'returns expected value' ); t.end(); From 2a106af3c5fe6b4d3c903235a1c5111f2419ac72 Mon Sep 17 00:00:00 2001 From: Arjan Date: Thu, 6 Aug 2026 22:55:45 +0530 Subject: [PATCH 15/16] chore: update copyright years --- 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_pkg_readmes status: na - task: lint_markdown_docs status: na - 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: missing_dependencies - task: lint_c_examples status: missing_dependencies - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: passed - task: lint_license_headers status: passed --- --- .../@stdlib/stats/strided/snanmeanpw/docs/types/test.ts | 2 +- .../@stdlib/stats/strided/snanmeanpw/examples/c/example.c | 2 +- lib/node_modules/@stdlib/stats/strided/snanmeanpw/src/addon.c | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/docs/types/test.ts b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/docs/types/test.ts index bdbaad7d7ca1..fb9f3a61272a 100644 --- a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/docs/types/test.ts +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/docs/types/test.ts @@ -1,7 +1,7 @@ /* * @license Apache-2.0 * -* Copyright (c) 2020 The Stdlib Authors. +* Copyright (c) 2026 The Stdlib Authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/examples/c/example.c b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/examples/c/example.c index f2c6676da493..4b84625be702 100644 --- a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/examples/c/example.c +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/examples/c/example.c @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2020 The Stdlib Authors. +* Copyright (c) 2026 The Stdlib Authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/src/addon.c b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/src/addon.c index 383c72443e21..6cf55710301c 100644 --- a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/src/addon.c +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/src/addon.c @@ -1,7 +1,7 @@ /** * @license Apache-2.0 * -* Copyright (c) 2025 The Stdlib Authors. +* Copyright (c) 2026 The Stdlib Authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. From b0c6b710f8515b513cf8b341fd5f315cff4102bf Mon Sep 17 00:00:00 2001 From: Arjan Date: Thu, 6 Aug 2026 23:08:26 +0530 Subject: [PATCH 16/16] test: add native addon tests --- type: pre_commit_static_analysis_report description: Results of running static analysis checks when committing changes. report: - task: lint_filenames status: passed - task: lint_editorconfig status: passed - task: lint_markdown_pkg_readmes status: na - task: lint_markdown_docs status: na - task: lint_markdown status: na - task: lint_package_json status: na - task: lint_repl_help status: na - task: lint_javascript_src status: na - task: lint_javascript_cli status: na - task: lint_javascript_examples status: na - task: lint_javascript_tests status: passed - task: lint_javascript_benchmarks status: na - task: lint_python status: na - task: lint_r status: na - task: lint_c_src status: na - task: lint_c_examples status: na - task: lint_c_benchmarks status: na - task: lint_c_tests_fixtures status: na - task: lint_shell status: na - task: lint_typescript_declarations status: passed - task: lint_typescript_tests status: na - task: lint_license_headers status: passed --- --- .../snanmeanpw/test/test.ndarray.native.js | 177 +++++++++++++++++ .../snanmeanpw/test/test.snanmeanpw.native.js | 178 ++++++++++++++++++ 2 files changed, 355 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.ndarray.native.js create mode 100644 lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.snanmeanpw.native.js diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.ndarray.native.js b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.ndarray.native.js new file mode 100644 index 000000000000..6f9a2c2cf0d6 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.ndarray.native.js @@ -0,0 +1,177 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var resolve = require( 'path' ).resolve; +var tape = require( 'tape' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var Float32Array = require( '@stdlib/array/float32' ); +var tryRequire = require( '@stdlib/utils/try-require' ); + + +// VARIABLES // + +var snanmeanpw = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) ); +var opts = { + 'skip': ( snanmeanpw instanceof Error ) +}; + + +// TESTS // + +tape( 'main export is a function', opts, function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof snanmeanpw, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 4', opts, function test( t ) { + t.strictEqual( snanmeanpw.length, 4, 'has expected arity' ); + t.end(); +}); + +tape( 'the function calculates the arithmetic mean of a strided array, ignoring `NaN` values', opts, function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, NaN, 0.0, 3.0 ] ); + + v = snanmeanpw( x.length, x, 1, 0 ); + t.strictEqual( v, 0.5, 'returns expected value' ); + + x = new Float32Array( [ -4.0, NaN ] ); + + v = snanmeanpw( x.length, x, 1, 0 ); + t.strictEqual( v, -4.0, 'returns expected value' ); + + x = new Float32Array( [ NaN, NaN ] ); + + v = snanmeanpw( x.length, 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 function returns `NaN`', opts, function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = snanmeanpw( 0, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + v = snanmeanpw( -1, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter equal to `1`, the function returns the first indexed element', opts, function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = snanmeanpw( 1, x, 1, 0 ); + t.strictEqual( v, 1.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports a `stride` parameter', opts, function test( t ) { + var x; + var v; + + x = new Float32Array([ + 1.0, // 0 + 2.0, + 2.0, // 1 + -7.0, + -2.0, // 2 + 3.0, + 4.0, // 3 + 2.0, + NaN // 4 + ]); + + v = snanmeanpw( 5, x, 2, 0 ); + + t.strictEqual( v, 1.25, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports a negative `stride` parameter', opts, function test( t ) { + var x; + var v; + + x = new Float32Array([ + 1.0, // 4 + 2.0, + 2.0, // 3 + -7.0, + -2.0, // 2 + 3.0, + 4.0, // 1 + 2.0, + NaN // 0 + ]); + + v = snanmeanpw( 5, x, -2, 8 ); + + t.strictEqual( v, 1.25, 'returns expected value' ); + t.end(); +}); + +tape( 'if provided a `stride` parameter equal to `0`, the function returns the first indexed element', opts, function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = snanmeanpw( x.length, x, 0, 0 ); + t.strictEqual( v, 1.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports an `offset` parameter', opts, function test( t ) { + var x; + var v; + + x = new Float32Array([ + 2.0, + 1.0, // 0 + 2.0, + -2.0, // 1 + -2.0, + 2.0, // 2 + 3.0, + 4.0, // 3 + NaN, + NaN // 4 + ]); + + v = snanmeanpw( 5, x, 2, 1 ); + t.strictEqual( v, 1.25, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.snanmeanpw.native.js b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.snanmeanpw.native.js new file mode 100644 index 000000000000..e077470a3f54 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/snanmeanpw/test/test.snanmeanpw.native.js @@ -0,0 +1,178 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var resolve = require( 'path' ).resolve; +var tape = require( 'tape' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var Float32Array = require( '@stdlib/array/float32' ); +var tryRequire = require( '@stdlib/utils/try-require' ); + + +// VARIABLES // + +var snanmeanpw = tryRequire( resolve( __dirname, './../lib/snanmeanpw.native.js' ) ); +var opts = { + 'skip': ( snanmeanpw instanceof Error ) +}; + + +// TESTS // + +tape( 'main export is a function', opts, function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof snanmeanpw, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 3', opts, function test( t ) { + t.strictEqual( snanmeanpw.length, 3, 'has expected arity' ); + t.end(); +}); + +tape( 'the function calculates the arithmetic mean of a strided array, ignoring `NaN` values', opts, function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, NaN, 0.0, 3.0 ] ); + + v = snanmeanpw( x.length, x, 1 ); + t.strictEqual( v, 0.5, 'returns expected value' ); + + x = new Float32Array( [ -4.0, NaN ] ); + + v = snanmeanpw( x.length, x, 1 ); + t.strictEqual( v, -4.0, 'returns expected value' ); + + x = new Float32Array( [ NaN, NaN ] ); + + v = snanmeanpw( x.length, 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 function returns `NaN`', opts, function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = snanmeanpw( 0, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + v = snanmeanpw( -1, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an `N` parameter equal to `1`, the function returns the first element', opts, function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = snanmeanpw( 1, x, 1 ); + t.strictEqual( v, 1.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports a `stride` parameter', opts, function test( t ) { + var x; + var v; + + x = new Float32Array([ + 1.0, // 0 + 2.0, + 2.0, // 1 + -7.0, + -2.0, // 2 + 3.0, + 4.0, // 3 + 2.0 + ]); + + v = snanmeanpw( 4, x, 2 ); + + t.strictEqual( v, 1.25, 'returns expected value' ); + t.end(); +}); + +tape( 'the function supports a negative `stride` parameter', opts, function test( t ) { + var x; + var v; + + x = new Float32Array([ + 1.0, // 3 + 2.0, + 2.0, // 2 + -7.0, + -2.0, // 1 + 3.0, + 4.0, // 0 + 2.0 + ]); + + v = snanmeanpw( 4, x, -2 ); + + t.strictEqual( v, 1.25, 'returns expected value' ); + t.end(); +}); + +tape( 'if provided a `stride` parameter equal to `0`, the function returns the first element', opts, function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = snanmeanpw( x.length, x, 0 ); + t.strictEqual( v, 1.0, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports view offsets', opts, function test( t ) { + var x0; + var x1; + var v; + + x0 = new Float32Array([ + 2.0, + 1.0, // 0 + 2.0, + -2.0, // 1 + -2.0, + 2.0, // 2 + 3.0, + 4.0, // 3 + 6.0, + NaN // 4 + ]); + + x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element + + v = snanmeanpw( 5, x1, 2 ); + t.strictEqual( v, 1.25, 'returns expected value' ); + + t.end(); +});