From c88a75e1454364905190c296d593a248e9419600 Mon Sep 17 00:00:00 2001 From: kaustubh Date: Wed, 24 Dec 2025 13:30:41 +0530 Subject: [PATCH 1/5] feat: add stats/base/ndarray/sstdev --- .../stats/base/ndarray/sstdev/README.md | 190 +++++++++++++++ .../ndarray/sstdev/benchmark/benchmark.js | 106 ++++++++ .../sstdev/docs/img/equation_sample_mean.svg | 43 ++++ .../stats/base/ndarray/sstdev/docs/repl.txt | 55 +++++ .../base/ndarray/sstdev/docs/types/index.d.ts | 52 ++++ .../base/ndarray/sstdev/docs/types/test.ts | 61 +++++ .../base/ndarray/sstdev/examples/index.js | 37 +++ .../stats/base/ndarray/sstdev/lib/index.js | 54 +++++ .../stats/base/ndarray/sstdev/lib/main.js | 69 ++++++ .../stats/base/ndarray/sstdev/package.json | 77 ++++++ .../stats/base/ndarray/sstdev/test/test.js | 229 ++++++++++++++++++ 11 files changed, 973 insertions(+) create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/sstdev/README.md create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/sstdev/benchmark/benchmark.js create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/img/equation_sample_mean.svg create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/repl.txt create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/types/index.d.ts create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/types/test.ts create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/sstdev/examples/index.js create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/sstdev/lib/index.js create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/sstdev/lib/main.js create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/sstdev/package.json create mode 100644 lib/node_modules/@stdlib/stats/base/ndarray/sstdev/test/test.js diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/README.md b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/README.md new file mode 100644 index 000000000000..9abd2a71ca55 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/README.md @@ -0,0 +1,190 @@ + + +# sstdev + +> Calculate the [standard deviation][standard-deviation] of a one-dimensional +single-precision floating-point ndarray. + +
+ +The population [standard deviation][standard-deviation] of a finite size population of size `N` is given by + + + +```math +\sigma = \sqrt{\frac{1}{N} \sum_{i=0}^{N-1} (x_i - \mu)^2} +``` + + + + + +where the population mean is given by + + + +```math +\mu = \frac{1}{N} \sum_{i=0}^{N-1} x_i +``` + + + + + +Often in the analysis of data, the true population [standard deviation][standard-deviation] is not known _a priori_ and must be estimated from a sample drawn from the population distribution. If one attempts to use the formula for the population [standard deviation][standard-deviation], the result is biased and yields an **uncorrected sample standard deviation**. To compute a **corrected sample standard deviation** for a sample of size `n`, + + + +```math +s = \sqrt{\frac{1}{n-1} \sum_{i=0}^{n-1} (x_i - \bar{x})^2} +``` + + + + + +where the sample mean is given by + + + +```math +\bar{x} = \frac{1}{n} \sum_{i=0}^{n-1} x_i +``` + + + + + +The use of the term `n-1` is commonly referred to as Bessel's correction. Note, however, that applying Bessel's correction can increase the mean squared error between the sample standard deviation and population standard deviation. Depending on the characteristics of the population distribution, other correction factors (e.g., `n-1.5`, `n+1`, etc) can yield better estimators. + +
+ + + +
+ +## Usage + +```javascript +var sstdev = require( '@stdlib/stats/base/ndarray/sstdev' ); +``` + +#### sstdev( arrays ) + +Computes the [standard deviation][standard-deviation] of a one-dimensional +single-precision floating-point ndarray. + +```javascript +var Float32Array = require( '@stdlib/array/float32' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); + +var opts = { + 'dtype': 'float32' +}; + +var xbuf = new Float32Array( [ 1.0, -2.0, 2.0 ] ); +var x = new ndarray( opts.dtype, xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); +var correction = scalar2ndarray( 1.0, opts ); + +var v = sstdev( [ x, correction ] ); +// returns ~2.0817 +``` + +The function has the following parameters: + +- **arrays**: array-like object containing two elements: a one-dimensional input ndarray and a zero-dimensional ndarray specifying the degrees of freedom adjustment. Providing a non-zero degrees of freedom adjustment has the effect of adjusting the divisor during the calculation of the [standard deviation][standard-deviation] according to `N-c` where `N` is the number of elements in the input ndarray and `c` corresponds to the provided degrees of freedom adjustment. When computing the [standard deviation][standard-deviation] of a population, setting this parameter to `0` is the standard choice (i.e., the provided array contains data constituting an entire population). When computing the corrected sample [standard deviation][standard-deviation], setting this parameter to `1` is the standard choice (i.e., the provided array contains data sampled from a larger population; this is commonly referred to as Bessel's correction). + +
+ + + +
+ +## Notes + +- If provided an empty one-dimensional ndarray, the function returns `NaN`. +- If `N - c` is less than or equal to `0` (where `N` corresponds to the number of elements in the input ndarray and `c` corresponds to the provided degrees of freedom adjustment), the function returns `NaN`. + +
+ + + +
+ +## Examples + + + +```javascript +var discreteUniform = require( '@stdlib/random/array/discrete-uniform' ); +var Float32Array = require( '@stdlib/array/float32' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var ndarray2array = require( '@stdlib/ndarray/to-array' ); +var sstdev = require( '@stdlib/stats/base/ndarray/sstdev' ); + +var opts = { + 'dtype': 'float32' +}; + +var xbuf = discreteUniform( 10, -50, 50, opts ); +var x = new ndarray( opts.dtype, xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' ); +console.log( ndarray2array( x ) ); + +var correction = scalar2ndarray( 1.0, opts ); +var v = sstdev( [ x, correction ] ); +console.log( v ); +``` + +
+ + + + + +
+ +
+ + + + + +
+ +[standard-deviation]: https://en.wikipedia.org/wiki/Standard_deviation + +
+ + diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/benchmark/benchmark.js new file mode 100644 index 000000000000..3413458bf6b2 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/benchmark/benchmark.js @@ -0,0 +1,106 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var bench = require( '@stdlib/bench' ); +var uniform = require( '@stdlib/random/array/uniform' ); +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pow = require( '@stdlib/math/base/special/pow' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var format = require( '@stdlib/string/format' ); +var pkg = require( './../package.json' ).name; +var sstdev = require( './../lib' ); + + +// VARIABLES // + +var options = { + 'dtype': 'float32' +}; + + +// FUNCTIONS // + +/** +* Creates a benchmark function. +* +* @private +* @param {PositiveInteger} len - array length +* @returns {Function} benchmark function +*/ +function createBenchmark( len ) { + var correction; + var xbuf; + var x; + + xbuf = uniform( len, -10.0, 10.0, options ); + x = new ndarray( options.dtype, xbuf, [ len ], [ 1 ], 0, 'row-major' ); + correction = scalar2ndarray( 1.0, options ); + + return benchmark; + + function benchmark( b ) { + var v; + var i; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + v = sstdev( [ x, correction ] ); + 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/base/ndarray/sstdev/docs/img/equation_sample_mean.svg b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/img/equation_sample_mean.svg new file mode 100644 index 000000000000..aea7a5f6687a --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/img/equation_sample_mean.svg @@ -0,0 +1,43 @@ + +x overbar 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/base/ndarray/sstdev/docs/repl.txt b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/repl.txt new file mode 100644 index 000000000000..7817771c10d8 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/repl.txt @@ -0,0 +1,55 @@ + +{{alias}}( arrays ) + Computes the standard deviation of a one-dimensional single-precision + floating-point ndarray. + + If provided an empty one-dimensional ndarray, the function returns `NaN`. + + If `N - c` is less than or equal to `0` (where `N` corresponds to the number + of elements in the input ndarray and `c` corresponds to the provided degrees + of freedom adjustment), the function returns `NaN`. + + Parameters + ---------- + arrays: ArrayLikeObject + Array-like object containing two elements: a one-dimensional input + ndarray and a zero-dimensional ndarray specifying the degrees of freedom + adjustment. Providing a non-zero degrees of freedom adjustment has the + effect of adjusting the divisor during the calculation of the standard + deviation according to `N-c` where `N` is the number of elements in the + input ndarray and `c` corresponds to the provided degrees of freedom + adjustment. When computing the standard deviation of a population, + setting this parameter to `0` is the standard choice (i.e., the provided + array contains data constituting an entire population). When computing + the corrected sample standard deviation, setting this parameter to `1` + is the standard choice (i.e., the provided array contains data sampled + from a larger population; this is commonly referred to as Bessel's + correction). + + Returns + ------- + out: number + The standard deviation. + + Examples + -------- + // Create input ndarray: + > var xbuf = [ 1.0, -2.0, 2.0 ]; + > var dt = 'generic'; + > var sh = [ xbuf.length ]; + > var st = [ 1 ]; + > var oo = 0; + > var ord = 'row-major'; + > var x = new {{alias:@stdlib/ndarray/ctor}}( dt, xbuf, sh, st, oo, ord ); + + // Create correction ndarray: + > var opts = { 'dtype': dt }; + > var correction = {{alias:@stdlib/ndarray/from-scalar}}( 1.0, opts ); + + // Compute the standard deviation: + > {{alias}}( [ x, correction ] ) + ~2.0817 + + See Also + -------- + diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/types/index.d.ts new file mode 100644 index 000000000000..278e7d5426c1 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/types/index.d.ts @@ -0,0 +1,52 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +// TypeScript Version: 4.1 + +/// + +import { typedndarray } from '@stdlib/types/ndarray'; + +/** +* Computes the standard deviation of a one-dimensional ndarray. +* +* @param arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying a degrees of freedom adjustment +* @returns standard deviation +* +* @example +* var ndarray = require( '@stdlib/ndarray/base/ctor' ); +* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +* var Float32Array = require( '@stdlib/array/float32' ); +* +* var opts = { +* 'dtype': 'float32' +* }; +* +* var xbuf = new Float32Array( [ 1.0, -2.0, 2.0 ] ); +* var x = new ndarray( opts.dtype, xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); +* var correction = scalar2ndarray( 1.0, opts ); +* +* var v = sstdev( [ x, correction ] ); +* // returns ~2.0817 +*/ +declare function sstdev( arrays: [ T, T ] ): number; + + +// EXPORTS // + +export = sstdev; diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/types/test.ts b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/types/test.ts new file mode 100644 index 000000000000..127495dd5707 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/types/test.ts @@ -0,0 +1,61 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +/* eslint-disable space-in-parens */ + +import zeros = require( '@stdlib/ndarray/zeros' ); +import scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +import sstdev = require( './index' ); + + +// TESTS // + +// The function returns a number... +{ + const x = zeros( [ 10 ], { + 'dtype': 'float32' + }); + const correction = scalar2ndarray( 1.0, { 'dtype': 'float32' } ); + + sstdev( [ x, correction ] ); // $ExpectType number +} + +// The compiler throws an error if the function is provided a first argument which is not an array of ndarrays... +{ + sstdev( '10' ); // $ExpectError + sstdev( 10 ); // $ExpectError + sstdev( true ); // $ExpectError + sstdev( false ); // $ExpectError + sstdev( null ); // $ExpectError + sstdev( undefined ); // $ExpectError + sstdev( [] ); // $ExpectError + sstdev( {} ); // $ExpectError + sstdev( ( x: number ): number => x ); // $ExpectError +} + +// The compiler throws an error if the function is provided an unsupported number of arguments... +{ + const x = zeros( [ 10 ], { + 'dtype': 'float32' + }); + const correction = scalar2ndarray( 1.0, { 'dtype': 'float32' } ); + + sstdev(); // $ExpectError + sstdev( [ x, correction ], 10 ); // $ExpectError +} + diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/examples/index.js b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/examples/index.js new file mode 100644 index 000000000000..28d34c671e1d --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/examples/index.js @@ -0,0 +1,37 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +var discreteUniform = require( '@stdlib/random/array/discrete-uniform' ); +var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); +var ndarray2array = require( '@stdlib/ndarray/to-array' ); +var sstdev = require( './../lib' ); + +var opts = { + 'dtype': 'float32' +}; + +var xbuf = discreteUniform( 10, -50, 50, opts ); +var x = new ndarray( opts.dtype, xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' ); +console.log( ndarray2array( x ) ); + +var correction = scalar2ndarray( 1.0, opts ); +var v = sstdev( [ x, correction ] ); +console.log( v ); diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/lib/index.js b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/lib/index.js new file mode 100644 index 000000000000..8f657e4bf65e --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/lib/index.js @@ -0,0 +1,54 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +/** +* Compute the standard deviation of a one-dimensional single-precision floating-point ndarray. +* +* @module @stdlib/stats/base/ndarray/sstdev +* +* @example +* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +* var ndarray = require( '@stdlib/ndarray/ctor' ); +* var sstdev = require( '@stdlib/stats/base/ndarray/sstdev' ); +* +* var opts = { +* 'dtype': 'generic' +* }; +* +* // Define a one-dimensional input ndarray: +* var xbuf = [ 1.0, -2.0, 2.0 ]; +* var x = new ndarray( opts.dtype, xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); +* +* // Specify the degrees of freedom adjustment: +* var correction = scalar2ndarray( 1.0, opts ); +* +* // Compute the standard deviation: +* var v = sstdev( [ x, correction ] ); +* // returns ~2.0817 +*/ + +// MODULES // + +var main = require( './main.js' ); + + +// EXPORTS // + +module.exports = main; diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/lib/main.js b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/lib/main.js new file mode 100644 index 000000000000..fcace7b54a8d --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/lib/main.js @@ -0,0 +1,69 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var numelDimension = require( '@stdlib/ndarray/base/numel-dimension' ); +var getStride = require( '@stdlib/ndarray/base/stride' ); +var getOffset = require( '@stdlib/ndarray/base/offset' ); +var getData = require( '@stdlib/ndarray/base/data-buffer' ); +var ndarraylike2scalar = require( '@stdlib/ndarray/base/ndarraylike2scalar' ); +var strided = require( '@stdlib/stats/strided/sstdev' ).ndarray; + + +// MAIN // + +/** +* Computes the standard deviation of a one-dimensional single-precision floating-point ndarray. +* +* @param {ArrayLikeObject} arrays - array-like object containing a one-dimensional input ndarray and a zero-dimensional ndarray specifying a degrees of freedom adjustment +* @returns {number} standard deviation +* +* @example +* var Float32Array = require( '@stdlib/array/float32' ); +* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +* var ndarray = require( '@stdlib/ndarray/base/ctor' ); +* +* var opts = { +* 'dtype': 'float32' +* }; +* +* var xbuf = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] ); +* var x = new ndarray( opts.dtype, xbuf, [ 4 ], [ 2 ], 1, 'row-major' ); +* +* var correction = scalar2ndarray( 1.0, opts ); +* +* var v = sstdev( [ x, correction ] ); +* // returns 2.5 +*/ +function sstdev( arrays ) { + var correction; + var x; + + x = arrays[ 0 ]; + correction = ndarraylike2scalar( arrays[ 1 ] ); + + return strided( numelDimension( x, 0 ), correction, getData( x ), getStride( x, 0 ), getOffset( x ) ); // eslint-disable-line max-len +} + + +// EXPORTS // + +module.exports = sstdev; diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/package.json b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/package.json new file mode 100644 index 000000000000..68160dc8a6f9 --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/package.json @@ -0,0 +1,77 @@ +{ + "name": "@stdlib/stats/base/ndarray/sstdev", + "version": "0.0.0", + "description": "Compute the standard deviation of a one-dimensional single-precision floating-point ndarray.", + "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", + "directories": { + "benchmark": "./benchmark", + "doc": "./docs", + "example": "./examples", + "lib": "./lib", + "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", + "standard deviation", + "variance", + "var", + "deviation", + "dispersion", + "spread", + "sample standard deviation", + "unbiased", + "sstdev", + "std", + "ndarray", + "float32", + "float", + "single", + "single-precision", + "typed", + "float32array" + ], + "__stdlib__": {} +} diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/test/test.js b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/test/test.js new file mode 100644 index 000000000000..da9a350a3aeb --- /dev/null +++ b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/test/test.js @@ -0,0 +1,229 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2025 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var sqrt = require( '@stdlib/math/base/special/sqrt' ); +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 scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); +var ndarray = require( '@stdlib/ndarray/base/ctor' ); +var sstdev = require( './../lib' ); + + +// FUNCTIONS // + +/** +* Returns a one-dimensional ndarray. +* +* @private +* @param {Collection} buffer - underlying data buffer +* @param {NonNegativeInteger} length - number of indexed elements +* @param {integer} stride - stride length +* @param {NonNegativeInteger} offset - index offset +* @returns {ndarray} one-dimensional ndarray +*/ +function vector( buffer, length, stride, offset ) { + return new ndarray( 'float32', buffer, [ length ], [ stride ], offset, 'row-major' ); +} + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof sstdev, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function has an arity of 1', function test( t ) { + t.strictEqual( sstdev.length, 1, 'has expected arity' ); + t.end(); +}); + +tape( 'the function calculates the standard deviation of a one-dimensional ndarray', function test( t ) { + var correction; + var expected; + var opts; + var x; + var v; + + opts = { + 'dtype': 'float32' + }; + + x = new Float32Array( [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ] ); + correction = scalar2ndarray( 1.0, opts ); + + v = sstdev( [ vector( x, x.length, 1, 0 ), correction ] ); + expected = float64ToFloat32( sqrt( 53.5/(x.length-1) ) ); + t.strictEqual( v, expected, 'returns expected value' ); + + x = new Float32Array( [ -4.0, -5.0 ] ); + correction = scalar2ndarray( 1.0, opts ); + + v = sstdev( [ vector( x, x.length, 1, 0 ), correction ] ); + expected = float64ToFloat32( sqrt( 0.5 ) ); + t.strictEqual( v, expected, 'returns expected value' ); + + x = new Float32Array( [ NaN ] ); + correction = scalar2ndarray( 1.0, opts ); + + v = sstdev( [ vector( x, x.length, 1, 0 ), correction ] ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + x = new Float32Array( [ NaN, NaN ] ); + correction = scalar2ndarray( 1.0, opts ); + + v = sstdev( [ vector( x, x.length, 1, 0 ), correction ] ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided an empty ndarray, the function returns `NaN`', function test( t ) { + var correction; + var opts; + var x; + var v; + + opts = { + 'dtype': 'float32' + }; + + x = new Float32Array( [] ); + correction = scalar2ndarray( 1.0, opts ); + + v = sstdev( [ vector( x, 0, 1, 0 ), correction ] ); + t.strictEqual( isnan( v ), true, 'returns expected value' ); + + t.end(); +}); + +tape( 'if provided a correction argument yielding `N-correction` less than or equal to `0`, the function returns `NaN`', function test( t ) { + var correction; + var opts; + var x; + var v; + + opts = { + 'dtype': 'float32' + }; + + x = new Float32Array( [ 1.0 ] ); + correction = scalar2ndarray( 1.0, opts ); + + v = sstdev( [ vector( x, 1, 1, 0 ), correction ] ); + t.strictEqual( isnan( v ), true, 'returns NaN' ); + + t.end(); +}); + +tape( 'the function supports one-dimensional ndarrays having non-unit strides', function test( t ) { + var correction; + var expected; + var opts; + var x; + var v; + + opts = { + 'dtype': 'float32' + }; + + x = new Float32Array([ + 1.0, // 0 + 2.0, + 2.0, // 1 + -7.0, + -2.0, // 2 + 3.0, + 4.0, // 3 + 2.0 + ]); + correction = scalar2ndarray( 1.0, opts ); + + v = sstdev( [ vector( x, 4, 2, 0 ), correction ] ); + expected = 2.5; + t.strictEqual( v, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports one-dimensional ndarrays having negative strides', function test( t ) { + var correction; + var expected; + var opts; + var x; + var v; + + opts = { + 'dtype': 'float32' + }; + + x = new Float32Array([ + 1.0, // 3 + 2.0, + 2.0, // 2 + -7.0, + -2.0, // 1 + 3.0, + 4.0, // 0 + 2.0 + ]); + correction = scalar2ndarray( 1.0, opts ); + + v = sstdev( [ vector( x, 4, -2, 6 ), correction ] ); + expected = 2.5; + t.strictEqual( v, expected, 'returns expected value' ); + + t.end(); +}); + +tape( 'the function supports one-dimensional ndarrays having non-zero offsets', function test( t ) { + var correction; + var expected; + var opts; + var x; + var v; + + opts = { + 'dtype': 'float32' + }; + + x = new Float32Array([ + 2.0, + 1.0, // 0 + 2.0, + -2.0, // 1 + -2.0, + 2.0, // 2 + 3.0, + 4.0 // 3 + ]); + correction = scalar2ndarray( 1.0, opts ); + + v = sstdev( [ vector( x, 4, 2, 1 ), correction ] ); + expected = 2.5; + t.strictEqual( v, expected, 'returns expected value' ); + + t.end(); +}); From cd470f755a6a3ebd3a038a8037b1afce7918df78 Mon Sep 17 00:00:00 2001 From: kaustubh Date: Wed, 24 Dec 2025 13:37:48 +0530 Subject: [PATCH 2/5] lint --- .../@stdlib/stats/base/ndarray/sstdev/README.md | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/README.md b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/README.md index 9abd2a71ca55..588b1c2a8598 100644 --- a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/README.md +++ b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/README.md @@ -20,8 +20,7 @@ limitations under the License. # sstdev -> Calculate the [standard deviation][standard-deviation] of a one-dimensional -single-precision floating-point ndarray. +> Calculate the [standard deviation][standard-deviation] of a one-dimensional single-precision floating-point ndarray.
@@ -101,8 +100,7 @@ var sstdev = require( '@stdlib/stats/base/ndarray/sstdev' ); #### sstdev( arrays ) -Computes the [standard deviation][standard-deviation] of a one-dimensional -single-precision floating-point ndarray. +Computes the [standard deviation][standard-deviation] of a one-dimensional single-precision floating-point ndarray. ```javascript var Float32Array = require( '@stdlib/array/float32' ); From 49adba04e38bdcafac8877d1dbf9aed0e63ce21b Mon Sep 17 00:00:00 2001 From: kaustubh Date: Wed, 24 Dec 2025 16:38:12 +0530 Subject: [PATCH 3/5] Done Reviewed Changes --- .../stats/base/ndarray/sstdev/benchmark/benchmark.js | 6 +++--- .../@stdlib/stats/base/ndarray/sstdev/docs/repl.txt | 4 ++-- .../stats/base/ndarray/sstdev/docs/types/index.d.ts | 5 ++--- .../stats/base/ndarray/sstdev/docs/types/test.ts | 8 ++++++-- .../@stdlib/stats/base/ndarray/sstdev/lib/index.js | 5 +++-- .../@stdlib/stats/base/ndarray/sstdev/test/test.js | 10 +++++----- 6 files changed, 21 insertions(+), 17 deletions(-) diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/benchmark/benchmark.js index 3413458bf6b2..7ba2e1ada3f0 100644 --- a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/benchmark/benchmark.js +++ b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/benchmark/benchmark.js @@ -22,7 +22,7 @@ var bench = require( '@stdlib/bench' ); var uniform = require( '@stdlib/random/array/uniform' ); -var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var isnanf = require( '@stdlib/math/base/assert/is-nanf' ); var pow = require( '@stdlib/math/base/special/pow' ); var ndarray = require( '@stdlib/ndarray/base/ctor' ); var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); @@ -65,12 +65,12 @@ function createBenchmark( len ) { b.tic(); for ( i = 0; i < b.iterations; i++ ) { v = sstdev( [ x, correction ] ); - if ( isnan( v ) ) { + if ( isnanf( v ) ) { b.fail( 'should not return NaN' ); } } b.toc(); - if ( isnan( v ) ) { + if ( isnanf( v ) ) { b.fail( 'should not return NaN' ); } b.pass( 'benchmark finished' ); diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/repl.txt b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/repl.txt index 7817771c10d8..2d031b05f4f2 100644 --- a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/repl.txt +++ b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/repl.txt @@ -34,8 +34,8 @@ Examples -------- // Create input ndarray: - > var xbuf = [ 1.0, -2.0, 2.0 ]; - > var dt = 'generic'; + > var xbuf = new {{alias:@stdlib/array/float32}}( [ 1.0, -2.0, 2.0 ] ); + > var dt = 'float32'; > var sh = [ xbuf.length ]; > var st = [ 1 ]; > var oo = 0; diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/types/index.d.ts index 278e7d5426c1..29cef2dc18d0 100644 --- a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/types/index.d.ts @@ -20,7 +20,7 @@ /// -import { typedndarray } from '@stdlib/types/ndarray'; +import { float32ndarray, typedndarray } from '@stdlib/types/ndarray'; /** * Computes the standard deviation of a one-dimensional ndarray. @@ -44,8 +44,7 @@ import { typedndarray } from '@stdlib/types/ndarray'; * var v = sstdev( [ x, correction ] ); * // returns ~2.0817 */ -declare function sstdev( arrays: [ T, T ] ): number; - +declare function sstdev = typedndarray>( arrays: [ float32ndarray, T ] ): number; // EXPORTS // diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/types/test.ts b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/types/test.ts index 127495dd5707..5b5111b1263f 100644 --- a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/types/test.ts +++ b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/types/test.ts @@ -30,7 +30,9 @@ import sstdev = require( './index' ); const x = zeros( [ 10 ], { 'dtype': 'float32' }); - const correction = scalar2ndarray( 1.0, { 'dtype': 'float32' } ); + const correction = scalar2ndarray( 1.0, { + 'dtype': 'float32' + }); sstdev( [ x, correction ] ); // $ExpectType number } @@ -53,7 +55,9 @@ import sstdev = require( './index' ); const x = zeros( [ 10 ], { 'dtype': 'float32' }); - const correction = scalar2ndarray( 1.0, { 'dtype': 'float32' } ); + const correction = scalar2ndarray( 1.0, { + 'dtype': 'float32' + }); sstdev(); // $ExpectError sstdev( [ x, correction ], 10 ); // $ExpectError diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/lib/index.js b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/lib/index.js index 8f657e4bf65e..e00fb1d9f41c 100644 --- a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/lib/index.js +++ b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/lib/index.js @@ -24,16 +24,17 @@ * @module @stdlib/stats/base/ndarray/sstdev * * @example +* var Float32Array = require( '@stdlib/array/float32' ); * var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); * var ndarray = require( '@stdlib/ndarray/ctor' ); * var sstdev = require( '@stdlib/stats/base/ndarray/sstdev' ); * * var opts = { -* 'dtype': 'generic' +* 'dtype': 'float32' * }; * * // Define a one-dimensional input ndarray: -* var xbuf = [ 1.0, -2.0, 2.0 ]; +* var xbuf = new Float32Array( [ 1.0, -2.0, 2.0 ] ); * var x = new ndarray( opts.dtype, xbuf, [ 3 ], [ 1 ], 0, 'row-major' ); * * // Specify the degrees of freedom adjustment: diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/test/test.js b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/test/test.js index da9a350a3aeb..d33b6540944b 100644 --- a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/test/test.js +++ b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/test/test.js @@ -22,7 +22,7 @@ var tape = require( 'tape' ); var sqrt = require( '@stdlib/math/base/special/sqrt' ); -var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var isnanf = require( '@stdlib/math/base/assert/is-nanf' ); var float64ToFloat32 = require( '@stdlib/number/float64/base/to-float32' ); var Float32Array = require( '@stdlib/array/float32' ); var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' ); @@ -89,13 +89,13 @@ tape( 'the function calculates the standard deviation of a one-dimensional ndarr correction = scalar2ndarray( 1.0, opts ); v = sstdev( [ vector( x, x.length, 1, 0 ), correction ] ); - t.strictEqual( isnan( v ), true, 'returns expected value' ); + t.strictEqual( isnanf( v ), true, 'returns expected value' ); x = new Float32Array( [ NaN, NaN ] ); correction = scalar2ndarray( 1.0, opts ); v = sstdev( [ vector( x, x.length, 1, 0 ), correction ] ); - t.strictEqual( isnan( v ), true, 'returns expected value' ); + t.strictEqual( isnanf( v ), true, 'returns expected value' ); t.end(); }); @@ -114,7 +114,7 @@ tape( 'if provided an empty ndarray, the function returns `NaN`', function test( correction = scalar2ndarray( 1.0, opts ); v = sstdev( [ vector( x, 0, 1, 0 ), correction ] ); - t.strictEqual( isnan( v ), true, 'returns expected value' ); + t.strictEqual( isnanf( v ), true, 'returns expected value' ); t.end(); }); @@ -133,7 +133,7 @@ tape( 'if provided a correction argument yielding `N-correction` less than or eq correction = scalar2ndarray( 1.0, opts ); v = sstdev( [ vector( x, 1, 1, 0 ), correction ] ); - t.strictEqual( isnan( v ), true, 'returns NaN' ); + t.strictEqual( isnanf( v ), true, 'returns NaN' ); t.end(); }); From b64473df0e1bd89667ec26767defe108a22e430d Mon Sep 17 00:00:00 2001 From: Athan Date: Wed, 24 Dec 2025 13:58:06 -0800 Subject: [PATCH 4/5] style: add blank line Signed-off-by: Athan --- .../@stdlib/stats/base/ndarray/sstdev/docs/types/index.d.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/types/index.d.ts index 29cef2dc18d0..f663c08427b3 100644 --- a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/types/index.d.ts +++ b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/docs/types/index.d.ts @@ -46,6 +46,7 @@ import { float32ndarray, typedndarray } from '@stdlib/types/ndarray'; */ declare function sstdev = typedndarray>( arrays: [ float32ndarray, T ] ): number; + // EXPORTS // export = sstdev; From 5b257d7fc2f496fd0adbed865256339d6aa73626 Mon Sep 17 00:00:00 2001 From: Athan Date: Wed, 24 Dec 2025 14:08:23 -0800 Subject: [PATCH 5/5] test: fix message Signed-off-by: Athan --- lib/node_modules/@stdlib/stats/base/ndarray/sstdev/test/test.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/test/test.js b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/test/test.js index d33b6540944b..02db83675f35 100644 --- a/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/test/test.js +++ b/lib/node_modules/@stdlib/stats/base/ndarray/sstdev/test/test.js @@ -133,7 +133,7 @@ tape( 'if provided a correction argument yielding `N-correction` less than or eq correction = scalar2ndarray( 1.0, opts ); v = sstdev( [ vector( x, 1, 1, 0 ), correction ] ); - t.strictEqual( isnanf( v ), true, 'returns NaN' ); + t.strictEqual( isnanf( v ), true, 'returns expected value' ); t.end(); });