diff --git a/lib/node_modules/@stdlib/stats/base/sdsmeanors/README.md b/lib/node_modules/@stdlib/stats/base/sdsmeanors/README.md index b6735cf153ed..6deff1aff6f0 100644 --- a/lib/node_modules/@stdlib/stats/base/sdsmeanors/README.md +++ b/lib/node_modules/@stdlib/stats/base/sdsmeanors/README.md @@ -51,7 +51,7 @@ The [arithmetic mean][arithmetic-mean] is defined as var sdsmeanors = require( '@stdlib/stats/base/sdsmeanors' ); ``` -#### sdsmeanors( N, x, stride ) +#### sdsmeanors( N, x, strideX ) Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array `x` using ordinary recursive summation with extended accumulation. @@ -59,9 +59,8 @@ Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-p var Float32Array = require( '@stdlib/array/float32' ); var x = new Float32Array( [ 1.0, -2.0, 2.0 ] ); -var N = x.length; -var v = sdsmeanors( N, x, 1 ); +var v = sdsmeanors( x.length, x, 1 ); // returns ~0.3333 ``` @@ -69,18 +68,16 @@ The function has the following parameters: - **N**: number of indexed elements. - **x**: input [`Float32Array`][@stdlib/array/float32]. -- **stride**: index increment for `x`. +- **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`, +The `N` and stride parameters determine which elements in the strided array are accessed at runtime. For example, to compute the [arithmetic mean][arithmetic-mean] of every other element in `x`, ```javascript var Float32Array = require( '@stdlib/array/float32' ); -var floor = require( '@stdlib/math/base/special/floor' ); var x = new Float32Array( [ 1.0, 2.0, 2.0, -7.0, -2.0, 3.0, 4.0, 2.0 ] ); -var N = floor( x.length / 2 ); -var v = sdsmeanors( N, x, 2 ); +var v = sdsmeanors( 4, x, 2 ); // returns 1.25 ``` @@ -90,18 +87,15 @@ Note that indexing is relative to the first index. To introduce an offset, use [ ```javascript var Float32Array = require( '@stdlib/array/float32' ); -var floor = require( '@stdlib/math/base/special/floor' ); 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 N = floor( x0.length / 2 ); - -var v = sdsmeanors( N, x1, 2 ); +var v = sdsmeanors( 4, x1, 2 ); // returns 1.25 ``` -#### sdsmeanors.ndarray( N, x, stride, offset ) +#### sdsmeanors.ndarray( N, x, strideX, offsetX ) Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array using ordinary recursive summation with extended accumulation and alternative indexing semantics. @@ -109,26 +103,23 @@ Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-p var Float32Array = require( '@stdlib/array/float32' ); var x = new Float32Array( [ 1.0, -2.0, 2.0 ] ); -var N = x.length; -var v = sdsmeanors.ndarray( N, x, 1, 0 ); +var v = sdsmeanors.ndarray( x.length, x, 1, 0 ); // returns ~0.33333 ``` The function has the following additional parameters: -- **offset**: starting index for `x`. +- **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 value in `x` starting from the second value +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 floor = require( '@stdlib/math/base/special/floor' ); var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] ); -var N = floor( x.length / 2 ); -var v = sdsmeanors.ndarray( N, x, 2, 1 ); +var v = sdsmeanors.ndarray( 4, x, 2, 1 ); // returns 1.25 ``` @@ -141,7 +132,7 @@ var v = sdsmeanors.ndarray( N, x, 2, 1 ); ## Notes - If `N <= 0`, both functions return `NaN`. -- Accumulated intermediate values are stored as double-precision floating-point numbers. +- Accumulated intermediate values are stored as double-precision floating-point numbers. @@ -154,18 +145,12 @@ var v = sdsmeanors.ndarray( N, x, 2, 1 ); ```javascript -var randu = require( '@stdlib/random/base/randu' ); -var round = require( '@stdlib/math/base/special/round' ); -var Float32Array = require( '@stdlib/array/float32' ); +var discreteUniform = require( '@stdlib/random/array/discrete-uniform' ); var sdsmeanors = require( '@stdlib/stats/base/sdsmeanors' ); -var x; -var i; - -x = new Float32Array( 10 ); -for ( i = 0; i < x.length; i++ ) { - x[ i ] = round( (randu()*100.0) - 50.0 ); -} +var x = discreteUniform( 10, -50, 50, { + 'dtype': 'float32' +}); console.log( x ); var v = sdsmeanors( x.length, x, 1 ); @@ -176,6 +161,123 @@ console.log( v ); + + +* * * + +
+ +## C APIs + + + +
+ +
+ + + + + +
+ +### Usage + +```c +#include "stdlib/stats/base/sdsmeanors.h" +``` + +#### stdlib_strided_sdsmeanors( N, \*X, strideX ) + +Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array using ordinary recursive summation with extended accumulation. + +```c +const float x[] = { 1.0f, 2.0f, 3.0f }; + +float v = stdlib_strided_sdsmeanors( 3, x, 1 ); +// returns 2.0f +``` + +The function accepts the following arguments: + +- **N**: `[in] CBLAS_INT` number of indexed elements. +- **X**: `[in] float*` input array. +- **strideX**: `[in] CBLAS_INT` stride length for `X`. + +```c +float stdlib_strided_sdsmeanors( const CBLAS_INT N, const float *X, const CBLAS_INT strideX ); +``` + +#### stdlib_strided_sdsmeanors_ndarray( N, \*X, strideX, offsetX ) + +Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array using ordinary recursive summation with extended accumulation and alternative indexing semantics. + +```c +const float x[] = { 1.0f, 2.0f, 3.0f }; + +float v = stdlib_strided_sdsmeanors_ndarray( 3, x, 1, 0 ); +// returns 2.0f +``` + +The function accepts the following arguments: + +- **N**: `[in] CBLAS_INT` number of indexed elements. +- **X**: `[in] float*` input array. +- **strideX**: `[in] CBLAS_INT` stride length for `X`. +- **offsetX**: `[in] CBLAS_INT` starting index for `X`. + +```c +float stdlib_strided_sdsmeanors_ndarray( const CBLAS_INT N, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX ); +``` + +
+ + + + + +
+ +
+ + + + + +
+ +### Examples + +```c +#include "stdlib/stats/base/sdsmeanors.h" +#include + +int main( void ) { + // Create a strided array: + const float x[] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f }; + + // Specify the number of elements: + const int N = 4; + + // Specify the stride length: + const int strideX = 2; + + // Compute the arithmetic mean: + float v = stdlib_strided_sdsmeanors( N, x, strideX ); + + // Print the result: + printf( "mean: %f\n", v ); +} +``` + +
+ + + +
+ + +