From add28fb9b89dffe9e1a1a7650f9642a66fd626c4 Mon Sep 17 00:00:00 2001 From: Arjan Date: Sat, 15 Aug 2026 14:43:38 +0530 Subject: [PATCH 01/11] 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/sdsmeanpw/lib/index.js | 68 ++++++++++++++++ .../stats/strided/sdsmeanpw/lib/main.js | 35 +++++++++ .../stats/strided/sdsmeanpw/lib/ndarray.js | 59 ++++++++++++++ .../stats/strided/sdsmeanpw/lib/sdsmeanpw.js | 52 +++++++++++++ .../stats/strided/sdsmeanpw/package.json | 78 +++++++++++++++++++ 5 files changed, 292 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/index.js create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/main.js create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/ndarray.js create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/sdsmeanpw.js create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/package.json diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/index.js b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/index.js new file mode 100644 index 000000000000..0bb1b7d90d1b --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/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 using pairwise summation with extended accumulation. +* +* @module @stdlib/stats/strided/sdsmeanpw +* +* @example +* var Float32Array = require( '@stdlib/array/float32' ); +* var sdsmeanpw = require( '@stdlib/stats/strided/sdsmeanpw' ); +* +* var x = new Float32Array( [ 1.0, -2.0, 2.0 ] ); +* +* var v = sdsmeanpw( x.length, x, 1 ); +* // returns ~0.3333 +* +* @example +* var Float32Array = require( '@stdlib/array/float32' ); +* var sdsmeanpw = require( '@stdlib/stats/strided/sdsmeanpw' ); +* +* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] ); +* +* var v = sdsmeanpw.ndarray( 4, 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 sdsmeanpw; +var tmp = tryRequire( join( __dirname, './native.js' ) ); +if ( isError( tmp ) ) { + sdsmeanpw = main; +} else { + sdsmeanpw = tmp; +} + + +// EXPORTS // + +module.exports = sdsmeanpw; + +// exports: { "ndarray": "sdsmeanpw.ndarray" } diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/main.js b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/main.js new file mode 100644 index 000000000000..d243ae6fd0e5 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/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 sdsmeanpw = require( './sdsmeanpw.js' ); +var ndarray = require( './ndarray.js' ); + + +// MAIN // + +setReadOnly( sdsmeanpw, 'ndarray', ndarray ); + + +// EXPORTS // + +module.exports = sdsmeanpw; diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/ndarray.js b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/ndarray.js new file mode 100644 index 000000000000..81507bfb56a6 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/ndarray.js @@ -0,0 +1,59 @@ +/** +* @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 sdssumpw = require( '@stdlib/blas/ext/base/sdssumpw' ).ndarray; +var float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' ); + + +// MAIN // + +/** +* Computes the arithmetic mean of a single-precision floating-point strided array using pairwise summation with extended accumulation. +* +* @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 ] ); +* +* var v = sdsmeanpw( 4, x, 2, 1 ); +* // returns 1.25 +*/ +function sdsmeanpw( N, x, strideX, offsetX ) { + if ( N <= 0 ) { + return NaN; + } + if ( N === 1 || strideX === 0 ) { + return x[ offsetX ]; + } + return float64ToFloat32( sdssumpw( N, x, strideX, offsetX ) / N ); +} + + +// EXPORTS // + +module.exports = sdsmeanpw; diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/sdsmeanpw.js b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/sdsmeanpw.js new file mode 100644 index 000000000000..d4affda4b54e --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/sdsmeanpw.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 using pairwise summation with extended accumulation. +* +* @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, 2.0 ] ); +* +* var v = sdsmeanpw( x.length, x, 1 ); +* // returns ~0.3333 +*/ +function sdsmeanpw( N, x, strideX ) { + return ndarray( N, x, strideX, stride2offset( N, strideX ) ); +} + + +// EXPORTS // + +module.exports = sdsmeanpw; diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/package.json b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/package.json new file mode 100644 index 000000000000..d9e1bd48d09f --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/package.json @@ -0,0 +1,78 @@ +{ + "name": "@stdlib/stats/strided/dsmeanpw", + "version": "0.0.0", + "description": "Calculate the arithmetic mean of a single-precision floating-point strided array using pairwise summation with extended accumulation.", + "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 ad7bdf377e38b144a2fbc7492aea64d2dd41d28e Mon Sep 17 00:00:00 2001 From: Arjan Date: Sat, 15 Aug 2026 15:02:25 +0530 Subject: [PATCH 02/11] fix: update package name, JSDocs --- 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 --- --- lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/index.js | 2 +- .../@stdlib/stats/strided/sdsmeanpw/lib/ndarray.js | 2 +- .../@stdlib/stats/strided/sdsmeanpw/lib/sdsmeanpw.js | 2 +- lib/node_modules/@stdlib/stats/strided/sdsmeanpw/package.json | 4 ++-- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/index.js b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/index.js index 0bb1b7d90d1b..7382e8d43c40 100644 --- a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/index.js +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/index.js @@ -19,7 +19,7 @@ 'use strict'; /** -* Compute the arithmetic mean of a single-precision floating-point strided array using pairwise summation with extended accumulation. +* Compute the arithmetic mean of a single-precision floating-point strided array using pairwise summation with extended accumulation and returns a single-precision result. * * @module @stdlib/stats/strided/sdsmeanpw * diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/ndarray.js b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/ndarray.js index 81507bfb56a6..cd6ae470d2a3 100644 --- a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/ndarray.js +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/ndarray.js @@ -27,7 +27,7 @@ var float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' ); // MAIN // /** -* Computes the arithmetic mean of a single-precision floating-point strided array using pairwise summation with extended accumulation. +* Computes the arithmetic mean of a single-precision floating-point strided array using pairwise summation with extended accumulation and returns a single-precision result. * * @param {PositiveInteger} N - number of indexed elements * @param {Float32Array} x - input array diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/sdsmeanpw.js b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/sdsmeanpw.js index d4affda4b54e..5a3217b34973 100644 --- a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/sdsmeanpw.js +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/sdsmeanpw.js @@ -27,7 +27,7 @@ var ndarray = require( './ndarray.js' ); // MAIN // /** -* Computes the arithmetic mean of a single-precision floating-point strided array using pairwise summation with extended accumulation. +* Computes the arithmetic mean of a single-precision floating-point strided array using pairwise summation with extended accumulation and returns a single-precision result. * * @param {PositiveInteger} N - number of indexed elements * @param {Float32Array} x - input array diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/package.json b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/package.json index d9e1bd48d09f..a06cffa9068c 100644 --- a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/package.json +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/package.json @@ -1,7 +1,7 @@ { - "name": "@stdlib/stats/strided/dsmeanpw", + "name": "@stdlib/stats/strided/sdsmeanpw", "version": "0.0.0", - "description": "Calculate the arithmetic mean of a single-precision floating-point strided array using pairwise summation with extended accumulation.", + "description": "Calculate the arithmetic mean of a single-precision floating-point strided array using pairwise summation with extended accumulation and returns a single-precision result.", "license": "Apache-2.0", "author": { "name": "The Stdlib Authors", From c241f28c9ee9b635ea5a0aab8acb00face303c65 Mon Sep 17 00:00:00 2001 From: Arjan Date: Sat, 15 Aug 2026 15:18:29 +0530 Subject: [PATCH 03/11] chore: native addon 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: 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: 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/sdsmeanpw/binding.gyp | 170 ++++++++++++++++++ .../stats/strided/sdsmeanpw/include.gypi | 53 ++++++ .../include/stdlib/stats/strided/sdsmeanpw.h | 45 +++++ .../stats/strided/sdsmeanpw/manifest.json | 103 +++++++++++ .../stats/strided/sdsmeanpw/src/Makefile | 70 ++++++++ .../stats/strided/sdsmeanpw/src/addon.c | 60 +++++++ .../stats/strided/sdsmeanpw/src/main.c | 54 ++++++ 7 files changed, 555 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/binding.gyp create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/include.gypi create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/include/stdlib/stats/strided/sdsmeanpw.h create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/manifest.json create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/src/Makefile create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/src/addon.c create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/src/main.c diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/binding.gyp b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/binding.gyp new file mode 100644 index 000000000000..0d6508a12e99 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/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/sdsmeanpw/include.gypi b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/include.gypi new file mode 100644 index 000000000000..bee8d41a2caf --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/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': [ + ' Date: Sat, 15 Aug 2026 15:35:21 +0530 Subject: [PATCH 04/11] chore: add JS wrappers to native addon --- 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: 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/sdsmeanpw/lib/native.js | 35 +++++++++++++ .../strided/sdsmeanpw/lib/ndarray.native.js | 52 +++++++++++++++++++ .../strided/sdsmeanpw/lib/sdsmeanpw.native.js | 51 ++++++++++++++++++ 3 files changed, 138 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/native.js create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/ndarray.native.js create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/sdsmeanpw.native.js diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/native.js b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/native.js new file mode 100644 index 000000000000..7c2a28d793e7 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/native.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 sdsmeanpw = require( './sdsmeanpw.native.js' ); +var ndarray = require( './ndarray.native.js' ); + + +// MAIN // + +setReadOnly( sdsmeanpw, 'ndarray', ndarray ); + + +// EXPORTS // + +module.exports = sdsmeanpw; diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/ndarray.native.js b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/ndarray.native.js new file mode 100644 index 000000000000..7d7d064d8483 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/ndarray.native.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 addon = require( './../src/addon.node' ); + + +// MAIN // + +/** +* Computes the arithmetic mean of a single-precision floating-point strided array using pairwise summation with extended accumulation and returns a single-precision result. +* +* @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 ] ); +* +* var v = sdsmeanpw( 4, x, 2, 1 ); +* // returns 1.25 +*/ +function sdsmeanpw( N, x, strideX, offsetX ) { + return addon.ndarray( N, x, strideX, offsetX ); +} + + +// EXPORTS // + +module.exports = sdsmeanpw; diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/sdsmeanpw.native.js b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/sdsmeanpw.native.js new file mode 100644 index 000000000000..788a94ebe622 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/lib/sdsmeanpw.native.js @@ -0,0 +1,51 @@ +/** +* @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 addon = require( './../src/addon.node' ); + + +// MAIN // + +/** +* Computes the arithmetic mean of a single-precision floating-point strided array using pairwise summation with extended accumulation and returns a single-precision result. +* +* @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, 2.0 ] ); +* +* var v = sdsmeanpw( x.length, x, 1 ); +* // returns ~0.3333 +*/ +function sdsmeanpw( N, x, strideX ) { + return addon( N, x, strideX ); +} + + +// EXPORTS // + +module.exports = sdsmeanpw; From 1d4ebd1d8345bccfd533cd1a286b56f3367659f7 Mon Sep 17 00:00:00 2001 From: Arjan Date: Sat, 15 Aug 2026 15:37:15 +0530 Subject: [PATCH 05/11] 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/sdsmeanpw/docs/types/index.d.ts | 92 ++++++++++ .../strided/sdsmeanpw/docs/types/test.ts | 157 ++++++++++++++++++ 2 files changed, 249 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/docs/types/index.d.ts create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/docs/types/test.ts diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/docs/types/index.d.ts new file mode 100644 index 000000000000..fdddd70b0812 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/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 `sdsmeanpw`. +*/ +interface Routine { + /** + * Computes the arithmetic mean of a single-precision floating-point strided array using pairwise summation with extended accumulation and returns a single-precision result. + * + * @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 = sdsmeanpw( 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 using pairwise summation with extended accumulation and alternative indexing semantics and returns a single-precision result. + * + * @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 = sdsmeanpw.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 using pairwise summation with extended accumulation and returns a single-precision result. +* +* @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 = sdsmeanpw( 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 = sdsmeanpw.ndarray( x.length, x, 1, 0 ); +* // returns ~0.3333 +*/ +declare var sdsmeanpw: Routine; + + +// EXPORTS // + +export = sdsmeanpw; diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/docs/types/test.ts b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/docs/types/test.ts new file mode 100644 index 000000000000..3c104130eabf --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/docs/types/test.ts @@ -0,0 +1,157 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +import sdsmeanpw = require( './index' ); + + +// TESTS // + +// The function returns a number... +{ + const x = new Float32Array( 10 ); + + sdsmeanpw( 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 ); + + sdsmeanpw( '10', x, 1 ); // $ExpectError + sdsmeanpw( true, x, 1 ); // $ExpectError + sdsmeanpw( false, x, 1 ); // $ExpectError + sdsmeanpw( null, x, 1 ); // $ExpectError + sdsmeanpw( undefined, x, 1 ); // $ExpectError + sdsmeanpw( [], x, 1 ); // $ExpectError + sdsmeanpw( {}, x, 1 ); // $ExpectError + sdsmeanpw( ( 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 ); + + sdsmeanpw( x.length, 10, 1 ); // $ExpectError + sdsmeanpw( x.length, '10', 1 ); // $ExpectError + sdsmeanpw( x.length, true, 1 ); // $ExpectError + sdsmeanpw( x.length, false, 1 ); // $ExpectError + sdsmeanpw( x.length, null, 1 ); // $ExpectError + sdsmeanpw( x.length, undefined, 1 ); // $ExpectError + sdsmeanpw( x.length, [], 1 ); // $ExpectError + sdsmeanpw( x.length, {}, 1 ); // $ExpectError + sdsmeanpw( 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 ); + + sdsmeanpw( x.length, x, '10' ); // $ExpectError + sdsmeanpw( x.length, x, true ); // $ExpectError + sdsmeanpw( x.length, x, false ); // $ExpectError + sdsmeanpw( x.length, x, null ); // $ExpectError + sdsmeanpw( x.length, x, undefined ); // $ExpectError + sdsmeanpw( x.length, x, [] ); // $ExpectError + sdsmeanpw( x.length, x, {} ); // $ExpectError + sdsmeanpw( 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 ); + + sdsmeanpw(); // $ExpectError + sdsmeanpw( x.length ); // $ExpectError + sdsmeanpw( x.length, x ); // $ExpectError + sdsmeanpw( x.length, x, 1, 10 ); // $ExpectError +} + +// Attached to main export is an `ndarray` method which returns a number... +{ + const x = new Float32Array( 10 ); + + sdsmeanpw.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 ); + + sdsmeanpw.ndarray( '10', x, 1, 0 ); // $ExpectError + sdsmeanpw.ndarray( true, x, 1, 0 ); // $ExpectError + sdsmeanpw.ndarray( false, x, 1, 0 ); // $ExpectError + sdsmeanpw.ndarray( null, x, 1, 0 ); // $ExpectError + sdsmeanpw.ndarray( undefined, x, 1, 0 ); // $ExpectError + sdsmeanpw.ndarray( [], x, 1, 0 ); // $ExpectError + sdsmeanpw.ndarray( {}, x, 1, 0 ); // $ExpectError + sdsmeanpw.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 ); + + sdsmeanpw.ndarray( x.length, 10, 1, 0 ); // $ExpectError + sdsmeanpw.ndarray( x.length, '10', 1, 0 ); // $ExpectError + sdsmeanpw.ndarray( x.length, true, 1, 0 ); // $ExpectError + sdsmeanpw.ndarray( x.length, false, 1, 0 ); // $ExpectError + sdsmeanpw.ndarray( x.length, null, 1, 0 ); // $ExpectError + sdsmeanpw.ndarray( x.length, undefined, 1, 0 ); // $ExpectError + sdsmeanpw.ndarray( x.length, [], 1, 0 ); // $ExpectError + sdsmeanpw.ndarray( x.length, {}, 1, 0 ); // $ExpectError + sdsmeanpw.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 ); + + sdsmeanpw.ndarray( x.length, x, '10', 0 ); // $ExpectError + sdsmeanpw.ndarray( x.length, x, true, 0 ); // $ExpectError + sdsmeanpw.ndarray( x.length, x, false, 0 ); // $ExpectError + sdsmeanpw.ndarray( x.length, x, null, 0 ); // $ExpectError + sdsmeanpw.ndarray( x.length, x, undefined, 0 ); // $ExpectError + sdsmeanpw.ndarray( x.length, x, [], 0 ); // $ExpectError + sdsmeanpw.ndarray( x.length, x, {}, 0 ); // $ExpectError + sdsmeanpw.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 ); + + sdsmeanpw.ndarray( x.length, x, 1, '10' ); // $ExpectError + sdsmeanpw.ndarray( x.length, x, 1, true ); // $ExpectError + sdsmeanpw.ndarray( x.length, x, 1, false ); // $ExpectError + sdsmeanpw.ndarray( x.length, x, 1, null ); // $ExpectError + sdsmeanpw.ndarray( x.length, x, 1, undefined ); // $ExpectError + sdsmeanpw.ndarray( x.length, x, 1, [] ); // $ExpectError + sdsmeanpw.ndarray( x.length, x, 1, {} ); // $ExpectError + sdsmeanpw.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 ); + + sdsmeanpw.ndarray(); // $ExpectError + sdsmeanpw.ndarray( x.length ); // $ExpectError + sdsmeanpw.ndarray( x.length, x ); // $ExpectError + sdsmeanpw.ndarray( x.length, x, 1 ); // $ExpectError + sdsmeanpw.ndarray( x.length, x, 1, 0, 10 ); // $ExpectError +} From 9c7054dd1f6ac505b58f13478c6e68954fe11b58 Mon Sep 17 00:00:00 2001 From: Arjan Date: Sat, 15 Aug 2026 15:39:36 +0530 Subject: [PATCH 06/11] bench: add benchmarks for JS and native --- 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/sdsmeanpw/benchmark/benchmark.js | 103 +++++++++++++++++ .../sdsmeanpw/benchmark/benchmark.native.js | 108 ++++++++++++++++++ .../sdsmeanpw/benchmark/benchmark.ndarray.js | 103 +++++++++++++++++ .../benchmark/benchmark.ndarray.native.js | 108 ++++++++++++++++++ 4 files changed, 422 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/benchmark/benchmark.js create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/benchmark/benchmark.native.js create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/benchmark/benchmark.ndarray.js create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/benchmark/benchmark.ndarray.native.js diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/benchmark/benchmark.js new file mode 100644 index 000000000000..f50cbdbea5ed --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/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 sdsmeanpw = require( './../lib/sdsmeanpw.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 = sdsmeanpw( 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/sdsmeanpw/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/benchmark/benchmark.native.js new file mode 100644 index 000000000000..64dcfc32c999 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/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 sdsmeanpw = tryRequire( resolve( __dirname, './../lib/sdsmeanpw.native.js' ) ); +var opts = { + 'skip': ( sdsmeanpw 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 = sdsmeanpw( 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/sdsmeanpw/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/benchmark/benchmark.ndarray.js new file mode 100644 index 000000000000..5e832045b0a0 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/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 sdsmeanpw = 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 = sdsmeanpw( 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(); diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/benchmark/benchmark.ndarray.native.js b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/benchmark/benchmark.ndarray.native.js new file mode 100644 index 000000000000..c3d43ffcd175 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/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 sdsmeanpw = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) ); +var opts = { + 'skip': ( sdsmeanpw 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 = sdsmeanpw( 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 e9d7646112770647d36969ca946d50e196a42177 Mon Sep 17 00:00:00 2001 From: Arjan Date: Sat, 15 Aug 2026 15:56:17 +0530 Subject: [PATCH 07/11] bench: add C api benchmark --- 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/sdsmeanpw/benchmark/c/Makefile | 146 +++++++++++++ .../sdsmeanpw/benchmark/c/benchmark.length.c | 200 ++++++++++++++++++ 2 files changed, 346 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/benchmark/c/Makefile create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/benchmark/c/benchmark.length.c diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/benchmark/c/Makefile b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/benchmark/c/Makefile new file mode 100644 index 000000000000..0756dc7da20a --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/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/sdsmeanpw/benchmark/c/benchmark.length.c b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/benchmark/c/benchmark.length.c new file mode 100644 index 000000000000..273c9ffce620 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/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/sdsmeanpw.h" +#include +#include +#include +#include +#include + +#define NAME "sdsmeanpw" +#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_sdsmeanpw( 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_sdsmeanpw_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" ); + } + free( x ); + 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 df8af5d40471480ac954a2d442044a04c9079bd2 Mon Sep 17 00:00:00 2001 From: Arjan Date: Sat, 15 Aug 2026 15:56:53 +0530 Subject: [PATCH 08/11] chore: add /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: 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/sdsmeanpw/examples/c/Makefile | 146 ++++++++++++++++++ .../strided/sdsmeanpw/examples/c/example.c | 37 +++++ .../stats/strided/sdsmeanpw/examples/index.js | 30 ++++ 3 files changed, 213 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/examples/c/Makefile create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/examples/c/example.c create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/examples/index.js diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/examples/c/Makefile b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/examples/c/Makefile new file mode 100644 index 000000000000..c8f8e9a1517b --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/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/sdsmeanpw/examples/c/example.c b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/examples/c/example.c new file mode 100644 index 000000000000..e17d5dcae02d --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/examples/c/example.c @@ -0,0 +1,37 @@ +/** +* @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/sdsmeanpw.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: + double v = stdlib_strided_sdsmeanpw( N, x, strideX ); + + // Print the result: + printf( "mean: %lf\n", v ); +} diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/examples/index.js b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/examples/index.js new file mode 100644 index 000000000000..0957b67e584c --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/examples/index.js @@ -0,0 +1,30 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2026 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +var discreteUniform = require( '@stdlib/random/array/discrete-uniform' ); +var sdsmeanpw = require( './../lib' ); + +var x = discreteUniform( 10, -50, 50, { + 'dtype': 'float32' +}); +console.log( x ); + +var v = sdsmeanpw( x.length, x, 1 ); +console.log( v ); From f5be658a8a25308f9efb38561324eca46bb78d60 Mon Sep 17 00:00:00 2001 From: Arjan Date: Sat, 15 Aug 2026 23:33:41 +0530 Subject: [PATCH 09/11] test: add base 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/sdsmeanpw/test/test.js | 82 ++++++ .../strided/sdsmeanpw/test/test.ndarray.js | 173 +++++++++++ .../sdsmeanpw/test/test.ndarray.native.js | 182 ++++++++++++ .../strided/sdsmeanpw/test/test.sdsmeanpw.js | 177 ++++++++++++ .../sdsmeanpw/test/test.sdsmeanpw.native.js | 268 ++++++++++++++++++ 5 files changed, 882 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/test/test.js create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/test/test.ndarray.js create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/test/test.ndarray.native.js create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/test/test.sdsmeanpw.js create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/test/test.sdsmeanpw.native.js diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/test/test.js b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/test/test.js new file mode 100644 index 000000000000..a69db2e84f40 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/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 sdsmeanpw = 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 sdsmeanpw, '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 sdsmeanpw.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 sdsmeanpw = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire + }); + + t.strictEqual( sdsmeanpw, 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 sdsmeanpw; + var main; + + main = require( './../lib/sdsmeanpw.js' ); + + sdsmeanpw = proxyquire( './../lib', { + '@stdlib/utils/try-require': tryRequire + }); + + t.strictEqual( sdsmeanpw, main, 'returns expected value' ); + t.end(); + + function tryRequire() { + return new Error( 'Cannot find module' ); + } +}); diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/test/test.ndarray.js b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/test/test.ndarray.js new file mode 100644 index 000000000000..b65b3a05c54e --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/test/test.ndarray.js @@ -0,0 +1,173 @@ +/** +* @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 float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' ); +var Float32Array = require( '@stdlib/array/float32' ); +var sdsmeanpw = require( './../lib/ndarray.js' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof sdsmeanpw, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 4', function test( t ) { + t.strictEqual( sdsmeanpw.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 = sdsmeanpw( x.length, x, 1, 0 ); + t.strictEqual( v, 0.5, 'returns expected value' ); + + x = new Float32Array( [ -4.0, -4.0 ] ); + v = sdsmeanpw( x.length, x, 1, 0 ); + t.strictEqual( v, -4.0, 'returns expected value' ); + + x = new Float32Array( [ -4.0, NaN ] ); + v = sdsmeanpw( x.length, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns a single-precision result', function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, 2.0, 2.0 ] ); + v = sdsmeanpw( x.length, x, 1, 0 ); + t.strictEqual( v, float64ToFloat32( 5 / 3 ), '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 = sdsmeanpw( 0, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + v = sdsmeanpw( -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 = sdsmeanpw( 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 = sdsmeanpw( 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 = sdsmeanpw( 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 = sdsmeanpw( 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 = sdsmeanpw( 4, x, 2, 1 ); + t.strictEqual( v, 1.25, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/test/test.ndarray.native.js b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/test/test.ndarray.native.js new file mode 100644 index 000000000000..19837fd66ec6 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/test/test.ndarray.native.js @@ -0,0 +1,182 @@ +/** +* @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 float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' ); +var Float32Array = require( '@stdlib/array/float32' ); +var tryRequire = require( '@stdlib/utils/try-require' ); + + +// VARIABLES // + +var sdsmeanpw = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) ); +var opts = { + 'skip': ( sdsmeanpw instanceof Error ) +}; + + +// TESTS // + +tape( 'main export is a function', opts, function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof sdsmeanpw, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 4', opts, function test( t ) { + t.strictEqual( sdsmeanpw.length, 4, 'has expected arity' ); + t.end(); +}); + +tape( 'the function calculates the arithmetic mean of a strided array', opts, function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ] ); + v = sdsmeanpw( x.length, x, 1, 0 ); + t.strictEqual( v, 0.5, 'returns expected value' ); + + x = new Float32Array( [ -4.0, -4.0 ] ); + v = sdsmeanpw( x.length, x, 1, 0 ); + t.strictEqual( v, -4.0, 'returns expected value' ); + + x = new Float32Array( [ -4.0, NaN ] ); + v = sdsmeanpw( x.length, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns a single-precision result', function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, 2.0, 2.0 ] ); + v = sdsmeanpw( x.length, x, 1, 0 ); + t.strictEqual( v, float64ToFloat32( 5 / 3 ), '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 = sdsmeanpw( 0, x, 1, 0 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + v = sdsmeanpw( -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 = sdsmeanpw( 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 + ]); + + v = sdsmeanpw( 4, 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, // 3 + 2.0, + 2.0, // 2 + -7.0, + -2.0, // 1 + 3.0, + 4.0, // 0 + 2.0 + ]); + + v = sdsmeanpw( 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', opts, function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ); + + v = sdsmeanpw( 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 + ]); + + v = sdsmeanpw( 4, x, 2, 1 ); + t.strictEqual( v, 1.25, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/test/test.sdsmeanpw.js b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/test/test.sdsmeanpw.js new file mode 100644 index 000000000000..d5052bf88199 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/test/test.sdsmeanpw.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 tape = require( 'tape' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' ); +var Float32Array = require( '@stdlib/array/float32' ); +var sdsmeanpw = require( './../lib/sdsmeanpw.js' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof sdsmeanpw, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 3', function test( t ) { + t.strictEqual( sdsmeanpw.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 = sdsmeanpw( x.length, x, 1 ); + t.strictEqual( v, 0.5, 'returns expected value' ); + + x = new Float32Array( [ -4.0, -4.0 ] ); + v = sdsmeanpw( x.length, x, 1 ); + t.strictEqual( v, -4.0, 'returns expected value' ); + + x = new Float32Array( [ -4.0, NaN ] ); + v = sdsmeanpw( x.length, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns a single-precision result', function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, 2.0, 2.0 ] ); + v = sdsmeanpw( x.length, x, 1 ); + t.strictEqual( v, float64ToFloat32( 5 / 3 ), '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 = sdsmeanpw( 0, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + v = sdsmeanpw( -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 = sdsmeanpw( 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 = sdsmeanpw( 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 = sdsmeanpw( 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 = sdsmeanpw( 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 = sdsmeanpw( 4, x1, 2 ); + t.strictEqual( v, 1.25, 'returns expected value' ); + + t.end(); +}); diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/test/test.sdsmeanpw.native.js b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/test/test.sdsmeanpw.native.js new file mode 100644 index 000000000000..2d3dfad8d1f5 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/test/test.sdsmeanpw.native.js @@ -0,0 +1,268 @@ +/** +* @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 float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' ); +var Float32Array = require( '@stdlib/array/float32' ); +var tryRequire = require( '@stdlib/utils/try-require' ); + + +// VARIABLES // + +var sdsmeanpw = tryRequire( resolve( __dirname, './../lib/sdsmeanpw.native.js' ) ); +var opts = { + 'skip': ( sdsmeanpw instanceof Error ) +}; + + +// TESTS // + +tape( 'main export is a function', opts, function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof sdsmeanpw, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 3', opts, function test( t ) { + t.strictEqual( sdsmeanpw.length, 3, 'has expected arity' ); + t.end(); +}); + +tape( 'the function throws an error if provided a first argument which is not a number', opts, function test( t ) { + var values; + var i; + + values = [ + '5', + true, + false, + null, + void 0, + [], + {}, + function noop() {} + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + sdsmeanpw( value, new Float32Array( 10 ), 1 ); + }; + } +}); + +tape( 'the function throws an error if provided a second argument which is not a Float32Array', opts, function test( t ) { + var values; + var i; + + values = [ + '5', + 5, + true, + false, + null, + void 0, + [], + {}, + function noop() {} + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + sdsmeanpw( 10, value, 1 ); + }; + } +}); + +tape( 'the function throws an error if provided a third argument which is not a number', opts, function test( t ) { + var values; + var i; + + values = [ + '5', + true, + false, + null, + void 0, + [], + {}, + function noop() {} + ]; + + for ( i = 0; i < values.length; i++ ) { + t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + sdsmeanpw( 10, new Float32Array( 10 ), value ); + }; + } +}); + +tape( 'the function calculates the arithmetic mean of a strided array', opts, function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ] ); + v = sdsmeanpw( x.length, x, 1 ); + t.strictEqual( v, 0.5, 'returns expected value' ); + + x = new Float32Array( [ -4.0, -4.0 ] ); + v = sdsmeanpw( x.length, x, 1 ); + t.strictEqual( v, -4.0, 'returns expected value' ); + + x = new Float32Array( [ -4.0, NaN ] ); + v = sdsmeanpw( x.length, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function returns a single-precision result', function test( t ) { + var x; + var v; + + x = new Float32Array( [ 1.0, 2.0, 2.0 ] ); + v = sdsmeanpw( x.length, x, 1 ); + t.strictEqual( v, float64ToFloat32( 5 / 3 ), '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 = sdsmeanpw( 0, x, 1 ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + v = sdsmeanpw( -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 = sdsmeanpw( 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 = sdsmeanpw( 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 = sdsmeanpw( 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 = sdsmeanpw( 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 + ]); + + x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element + + v = sdsmeanpw( 4, x1, 2 ); + t.strictEqual( v, 1.25, 'returns expected value' ); + + t.end(); +}); From 76c84276551a9d19105fd06eee5da46b86518bc3 Mon Sep 17 00:00:00 2001 From: Arjan Date: Sun, 16 Aug 2026 08:57:22 +0530 Subject: [PATCH 10/11] docs: add README.md and 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: passed - 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 --- --- .../@stdlib/stats/strided/sdsmeanpw/README.md | 337 ++++++++++++++++++ .../docs/img/equation_arithmetic_mean.svg | 42 +++ .../stats/strided/sdsmeanpw/docs/repl.txt | 93 +++++ 3 files changed, 472 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/README.md create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/docs/img/equation_arithmetic_mean.svg create mode 100644 lib/node_modules/@stdlib/stats/strided/sdsmeanpw/docs/repl.txt diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/README.md b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/README.md new file mode 100644 index 000000000000..7ae70b25924a --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/README.md @@ -0,0 +1,337 @@ + + +# sdsmeanpw + +> Calculate the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array using pairwise summation with extended accumulation and returns a single-precision result. + +
+ +The [arithmetic mean][arithmetic-mean] is defined as + + + +```math +\mu = \frac{1}{n} \sum_{i=0}^{n-1} x_i +``` + + + + + +
+ + + +
+ +## Usage + +```javascript +var sdsmeanpw = require( '@stdlib/stats/strided/sdsmeanpw' ); +``` + +#### sdsmeanpw( N, x, strideX ) + +Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array `x` using pairwise summation with extended accumulation and returns single-precision result. + +```javascript +var Float32Array = require( '@stdlib/array/float32' ); + +var x = new Float32Array( [ 1.0, -2.0, 2.0 ] ); + +var v = sdsmeanpw( 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 `x` 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 = sdsmeanpw( 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 = sdsmeanpw( 4, x1, 2 ); +// returns 1.25 +``` + +#### sdsmeanpw.ndarray( N, x, strideX, offsetX ) + +Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array using pairwise summation with extended accumulation and alternative indexing semantics and returns a single-precision result. + +```javascript +var Float32Array = require( '@stdlib/array/float32' ); + +var x = new Float32Array( [ 1.0, -2.0, 2.0 ] ); + +var v = sdsmeanpw.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 = sdsmeanpw.ndarray( 4, x, 2, 1 ); +// returns 1.25 +``` + +
+ + + +
+ +## Notes + +- If `N <= 0`, both functions return `NaN`. +- Accumulated intermediate values are stored as double-precision floating-point numbers. +- 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 sdsmeanpw = require( '@stdlib/stats/strided/sdsmeanpw' ); + +var x = discreteUniform( 10, -50, 50, { + 'dtype': 'float32' +}); +console.log( x ); + +var v = sdsmeanpw( x.length, x, 1 ); +console.log( v ); +``` + +
+ + + + + +* * * + +
+ +## C APIs + + + +
+ +
+ + + + + +
+ +### Usage + +```c +#include "stdlib/stats/strided/sdsmeanpw.h" +``` + +#### stdlib_strided_sdsmeanpw( N, \*X, strideX ) + +Computes the arithmetic mean of a single-precision floating-point strided array using pairwise summation with extended accumulation and returns a single-precision result. + +```c +const float x[] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f }; + +float v = stdlib_strided_sdsmeanpw( 4, x, 2 ); +// returns 4.0 +``` + +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_sdsmeanpw( const CBLAS_INT N, const float *X, const CBLAS_INT strideX ); +``` + +#### stdlib_strided_sdsmeanpw_ndarray( N, \*X, strideX, offsetX ) + +Computes the arithmetic mean of a single-precision floating-point strided array using pairwise summation with extended accumulation and alternative indexing semantics and returns a single-precision result. + +```c +const float x[] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f }; + +float v = stdlib_strided_sdsmeanpw_ndarray( 4, x, 2, 0 ); +// returns 4.0 +``` + +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_sdsmeanpw_ndarray( const CBLAS_INT N, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX ); +``` + +
+ + + + + +
+ +
+ + + + + +
+ +### Examples + +```c +#include "stdlib/stats/strided/sdsmeanpw.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: + double v = stdlib_strided_sdsmeanpw( N, x, strideX ); + + // Print the result: + printf( "mean: %lf\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/dsmean`][@stdlib/stats/strided/dsmean]: calculate the arithmetic mean of a single-precision floating-point strided array using extended accumulation and returning an extended precision result. +- [`@stdlib/stats/strided/meanpw`][@stdlib/stats/strided/meanpw]: calculate the arithmetic mean of a strided array using pairwise summation. +- [`@stdlib/stats/strided/smeanpw`][@stdlib/stats/strided/smeanpw]: calculate the arithmetic mean of a single-precision floating-point strided array using pairwise summation. + +
+ + + + + +
+ +[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/dsmean]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/dsmean + +[@stdlib/stats/strided/meanpw]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/meanpw + +[@stdlib/stats/strided/smeanpw]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/smeanpw + + + +
+ + diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/docs/img/equation_arithmetic_mean.svg b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/docs/img/equation_arithmetic_mean.svg new file mode 100644 index 000000000000..c31439606fb6 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/docs/img/equation_arithmetic_mean.svg @@ -0,0 +1,42 @@ + +mu equals StartFraction 1 Over n EndFraction sigma-summation Underscript i equals 0 Overscript n minus 1 Endscripts x Subscript i + + + \ No newline at end of file diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/docs/repl.txt b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/docs/repl.txt new file mode 100644 index 000000000000..c9941c05973d --- /dev/null +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/docs/repl.txt @@ -0,0 +1,93 @@ + +{{alias}}( N, x, strideX ) + Computes the arithmetic mean of a single-precision floating-point strided + array using pairwise summation with extended accumulation and returns a + single-precision result. + + 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: number + The arithmetic mean. + + Examples + -------- + // Standard Usage: + > var x = new {{alias:@stdlib/array/float32}}( [ 1.0, -2.0, 2.0 ] ); + > {{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 ] ); + > {{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 with extended accumulation and alternative + indexing semantics and returns a single-precision result. + + 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: number + The arithmetic mean. + + Examples + -------- + // Standard Usage: + > var x = new {{alias:@stdlib/array/float32}}( [ 1.0, -2.0, 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 ] ); + > {{alias}}.ndarray( 3, x, 2, 1 ) + ~-0.3333 + + See Also + -------- + + From 989e865662f66abd972d08b0f06103538ec98040 Mon Sep 17 00:00:00 2001 From: Arjan Date: Sun, 16 Aug 2026 09:01:37 +0530 Subject: [PATCH 11/11] chore: update copyright year --- 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 --- --- lib/node_modules/@stdlib/stats/strided/sdsmeanpw/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/README.md b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/README.md index 7ae70b25924a..4ca332ed4083 100644 --- a/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/README.md +++ b/lib/node_modules/@stdlib/stats/strided/sdsmeanpw/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.