diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/README.md b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/README.md index d7493979401d..e257809e34d9 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/README.md +++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/README.md @@ -54,11 +54,11 @@ The function has the following parameters: - **N**: number of indexed elements. - **x**: input [`Float64Array`][@stdlib/array/float64]. -- **strideX**: index increment for `x`. +- **strideX**: stride length for `x`. - **out**: output [`Float64Array`][@stdlib/array/float64] whose first element is the sum and whose second element is the number of non-NaN elements. -- **strideOut**: index increment for `out`. +- **strideOut**: stride length for `out`. -The `N` and `stride` parameters determine which elements are accessed at runtime. For example, to compute the sum of every other element in `x`, +The `N` and stride parameters determine which elements are accessed at runtime. For example, to compute the sum of every other element in `x`, ```javascript var Float64Array = require( '@stdlib/array/float64' ); @@ -106,7 +106,7 @@ The function has the following additional parameters: - **offsetX**: starting index for `x`. - **offsetOut**: starting index for `out`. -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 sum of 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, offset parameters support indexing semantics based on starting indices. For example, to calculate the sum of every other element starting from the second element: ```javascript var Float64Array = require( '@stdlib/array/float64' ); @@ -166,6 +166,132 @@ console.log( out ); + + +* * * + +
+ +## C APIs + + + +
+ +
+ + + + + +
+ +### Usage + +```c +#include "stdlib/blas/ext/base/dnannsumors.h" +``` + +#### stdlib_strided_dnannsumors( N, \*X, strideX, \*n ) + +Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using ordinary recursive summation. + +```c +const double x[] = { 1.0, 2.0, 0.0/0.0, 4.0 }; +CBLAS_INT n = 0; + +double v = stdlib_strided_dnannsumors( 4, x, 1, &n ); +// returns 7.0 +``` + +The function accepts the following arguments: + +- **N**: `[in] CBLAS_INT` number of indexed elements. +- **X**: `[in] double*` input array. +- **strideX**: `[in] CBLAS_INT` stride length for `X`. +- **n**: `[out] CBLAS_INT*` number of non-NaN elements. + +```c +double stdlib_strided_dnannsumors( const CBLAS_INT N, const double *X, const CBLAS_INT strideX, CBLAS_INT *n ); +``` + +#### stdlib_strided_dnannsumors_ndarray( N, \*X, strideX, offsetX, \*n ) + +Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using ordinary recursive summation and alternative indexing semantics. + +```c +const double x[] = { 1.0, 2.0, 0.0/0.0, 4.0 }; +CBLAS_INT n = 0; + +double v = stdlib_strided_dnannsumors_ndarray( 4, x, 1, 0, &n ); +// returns 7.0 +``` + +The function accepts the following arguments: + +- **N**: `[in] CBLAS_INT` number of indexed elements. +- **X**: `[in] double*` input array. +- **strideX**: `[in] CBLAS_INT` stride length for `X`. +- **offsetX**: `[in] CBLAS_INT` starting index for `X`. +- **n**: `[out] CBLAS_INT*` number of non-NaN elements. + +```c +double stdlib_strided_dnannsumors_ndarray( const CBLAS_INT N, const double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, CBLAS_INT *n ); +``` + +
+ + + + + +
+ +
+ + + + + +
+ +### Examples + +```c +#include "stdlib/blas/ext/base/dnannsumors.h" +#include "stdlib/blase/base/shared.h" +#include + +int main( void ) { + // Create a strided array: + const double x[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 0.0/0.0, 0.0/0.0 }; + + // Specify the number of elements: + const int N = 5; + + // Specify the stride length: + const int strideX = 2; + + // Initialize a variable for storing the number of non-NaN elements: + CBLAS_INT n = 0; + + // Compute the sum: + double v = stdlib_strided_dnannsumors( N, x, strideX, &n ); + + // Print the result: + printf( "sum: %lf\n", v ); + printf( "n: %"CBLAS_IFMT"\n", n ); +} +``` + +
+ + + +
+ + +
diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/benchmark/benchmark.js index 755f11a8aa0d..4d2257a7a65e 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/benchmark/benchmark.js +++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/benchmark/benchmark.js @@ -33,6 +33,19 @@ var dnannsumors = require( './../lib/dnannsumors.js' ); // FUNCTIONS // +/** +* Returns a random number. +* +* @private +* @returns {number} random number +*/ +function rand() { + if ( bernoulli( 0.8 ) > 0 ) { + return uniform( -10.0, 10.0 ); + } + return NaN; +} + /** * Creates a benchmark function. * @@ -46,13 +59,6 @@ function createBenchmark( len ) { out = new Float64Array( 2 ); return benchmark; - function rand() { - if ( bernoulli( 0.8 ) > 0 ) { - return uniform( -10.0, 10.0 ); - } - return NaN; - } - function benchmark( b ) { var i; diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/benchmark/benchmark.native.js index f43f452b4490..f84ba3760bff 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/benchmark/benchmark.native.js +++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/benchmark/benchmark.native.js @@ -42,6 +42,19 @@ var opts = { // FUNCTIONS // +/** +* Returns a random number. +* +* @private +* @returns {number} random number +*/ +function rand() { + if ( bernoulli( 0.8 ) > 0 ) { + return uniform( -10.0, 10.0 ); + } + return NaN; +} + /** * Creates a benchmark function. * @@ -55,13 +68,6 @@ function createBenchmark( len ) { out = new Float64Array( 2 ); return benchmark; - function rand() { - if ( bernoulli( 0.8 ) > 0 ) { - return uniform( -10.0, 10.0 ); - } - return NaN; - } - function benchmark( b ) { var i; diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/benchmark/benchmark.ndarray.js index 28c0514d012d..4fc746c4e269 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/benchmark/benchmark.ndarray.js +++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/benchmark/benchmark.ndarray.js @@ -33,6 +33,19 @@ var dnannsumors = require( './../lib/ndarray.js' ); // FUNCTIONS // +/** +* Returns a random number. +* +* @private +* @returns {number} random number +*/ +function rand() { + if ( bernoulli( 0.8 ) > 0 ) { + return uniform( -10.0, 10.0 ); + } + return NaN; +} + /** * Creates a benchmark function. * @@ -46,13 +59,6 @@ function createBenchmark( len ) { out = new Float64Array( 2 ); return benchmark; - function rand() { - if ( bernoulli( 0.8 ) > 0 ) { - return uniform( -10.0, 10.0 ); - } - return NaN; - } - function benchmark( b ) { var i; diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/benchmark/benchmark.ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/benchmark/benchmark.ndarray.native.js index 83ce7a04f3b4..641de067a529 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/benchmark/benchmark.ndarray.native.js +++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/benchmark/benchmark.ndarray.native.js @@ -42,6 +42,19 @@ var opts = { // FUNCTIONS // +/** +* Returns a random number. +* +* @private +* @returns {number} random number +*/ +function rand() { + if ( bernoulli( 0.8 ) > 0 ) { + return uniform( -10.0, 10.0 ); + } + return NaN; +} + /** * Creates a benchmark function. * @@ -55,13 +68,6 @@ function createBenchmark( len ) { out = new Float64Array( 2 ); return benchmark; - function rand() { - if ( bernoulli( 0.8 ) > 0 ) { - return uniform( -10.0, 10.0 ); - } - return NaN; - } - function benchmark( b ) { var i; diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/benchmark/c/benchmark.length.c b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/benchmark/c/benchmark.length.c index 29daa9082e38..c5c5c6c233f1 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/benchmark/c/benchmark.length.c +++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/benchmark/c/benchmark.length.c @@ -17,6 +17,7 @@ */ #include "stdlib/blas/ext/base/dnannsumors.h" +#include "stdlib/blas/base/shared.h" #include #include #include @@ -94,10 +95,10 @@ static double rand_double( void ) { * @param len array length * @return elapsed time in seconds */ -static double benchmark( int iterations, int len ) { +static double benchmark1( int iterations, int len ) { double elapsed; double x[ len ]; - int64_t n; + CBLAS_INT n; double v; double t; int i; @@ -126,6 +127,45 @@ static double benchmark( int iterations, int len ) { 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; + double x[ len ]; + CBLAS_INT n; + double v; + double t; + int i; + + for ( i = 0; i < len; i++ ) { + if ( rand_double() < 0.2 ) { + x[ i ] = 0.0 / 0.0; // NaN + } else { + x[ i ] = ( rand_double() * 20000.0 ) - 10000.0; + } + } + v = 0.0; + n = 0; + t = tic(); + for ( i = 0; i < iterations; i++ ) { + v = stdlib_strided_dnannsumors_ndarray( len, x, 1, 0, &n ); + if ( v != v || n < 0 ) { + printf( "should not return NaN\n" ); + break; + } + } + elapsed = tic() - t; + if ( v != v || n < 0 ) { + printf( "should not return NaN\n" ); + } + return elapsed; +} + /** * Main execution sequence. */ @@ -148,7 +188,18 @@ int main( void ) { for ( j = 0; j < REPEATS; j++ ) { count += 1; printf( "# c::%s:len=%d\n", NAME, len ); - elapsed = benchmark( iter, 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 ); } diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/docs/repl.txt b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/docs/repl.txt index 2f33889e38b1..70761fb274be 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/docs/repl.txt +++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/docs/repl.txt @@ -3,7 +3,7 @@ Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using ordinary recursive summation. - The `N` and `stride` parameters determine which elements are accessed at + The `N` and stride parameters determine which elements are accessed at runtime. Indexing is relative to the first index. To introduce an offset, use a typed @@ -20,13 +20,13 @@ Input array. strideX: integer - Index increment for `x`. + Stride length for `x`. out: Float64Array Output array. strideOut: integer - Index increment for `out`. + Stride length for `out`. Returns ------- @@ -42,29 +42,28 @@ > {{alias}}( x.length, x, 1, out, 1 ) [ 1.0, 3 ] - // Using `N` and `stride` parameters: + // Using `N` and stride parameters: > x = new {{alias:@stdlib/array/float64}}( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ] ); > out = new {{alias:@stdlib/array/float64}}( 2 ); - > var N = {{alias:@stdlib/math/base/special/floor}}( x.length / 2 ); - > {{alias}}( N, x, 2, out, 1 ) + > {{alias}}( 4, x, 2, out, 1 ) [ 1.0, 3 ] // Using view offsets: > var x0 = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, 3.0, 2.0, 5.0, 1.0, NaN, NaN ] ); > var x1 = new {{alias:@stdlib/array/float64}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); - > N = {{alias:@stdlib/math/base/special/floor}}( x0.length / 2 ); > out = new {{alias:@stdlib/array/float64}}( 2 ); - > {{alias}}( N, x1, 2, out, 1 ) + > {{alias}}( 4, x1, 2, out, 1 ) [ 1.0, 3 ] + {{alias}}.ndarray( N, x, strideX, offsetX, out, strideOut, offsetOut ) Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using ordinary recursive summation and alternative indexing semantics. While typed array views mandate a view offset based on the underlying - buffer, the `offset` parameter supports indexing semantics based on a - starting index. + buffer, offset parameters support indexing semantics based on starting + indices. Parameters ---------- @@ -75,7 +74,7 @@ Input array. strideX: integer - Index increment for `x`. + Stride length for `x`. offsetX: integer Starting index for `x`. @@ -84,7 +83,7 @@ Output array. strideOut: integer - Index increment for `out`. + Stride length for `out`. offsetOut: integer Starting index for `out`. @@ -105,9 +104,8 @@ // Using offset parameter: > var x = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, 3.0, 2.0, 5.0, 1.0, NaN, NaN ] ); - > var N = {{alias:@stdlib/math/base/special/floor}}( x.length / 2 ); > out = new {{alias:@stdlib/array/float64}}( 2 ); - > {{alias}}.ndarray( N, x, 2, 1, out, 1, 0 ) + > {{alias}}.ndarray( 4, x, 2, 1, out, 1, 0 ) [ 1.0, 3 ] See Also diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/examples/c/example.c b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/examples/c/example.c index bbb460d9a78d..6ee2d877ec21 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/examples/c/example.c +++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/examples/c/example.c @@ -17,27 +17,27 @@ */ #include "stdlib/blas/ext/base/dnannsumors.h" -#include +#include "stdlib/blas/base/shared.h" #include -#include + int main( void ) { // Create a strided array: const double x[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 0.0/0.0, 0.0/0.0 }; // Specify the number of elements: - const int64_t N = 5; + const int N = 5; // Specify the stride length: - const int64_t stride = 2; + const int strideX = 2; // Initialize a variable for storing the number of non-NaN elements: - int64_t n = 0; + CBLAS_INT n = 0; // Compute the sum: - double v = stdlib_strided_dnannsumors( N, x, stride, &n ); + double v = stdlib_strided_dnannsumors( N, x, strideX, &n ); // Print the result: printf( "sum: %lf\n", v ); - printf( "n: %"PRId64"\n", n ); + printf( "n: %"CBLAS_IFMT"\n", n ); } diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/include/stdlib/blas/ext/base/dnannsumors.h b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/include/stdlib/blas/ext/base/dnannsumors.h index f6330ac5783c..434c2dac557b 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/include/stdlib/blas/ext/base/dnannsumors.h +++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/include/stdlib/blas/ext/base/dnannsumors.h @@ -19,7 +19,7 @@ #ifndef STDLIB_BLAS_EXT_BASE_DNANNSUMORS_H #define STDLIB_BLAS_EXT_BASE_DNANNSUMORS_H -#include +#include "stdlib/blas/base/shared.h" /* * If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler. @@ -31,7 +31,12 @@ extern "C" { /** * Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using ordinary recursive summation. */ -double stdlib_strided_dnannsumors( const int64_t N, const double *X, const int64_t stride, int64_t *n ); +double API_SUFFIX(stdlib_strided_dnannsumors)( const CBLAS_INT N, const double *X, const CBLAS_INT strideX, CBLAS_INT *n ); + +/** +* Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using ordinary recursive summation and alternative indexing semantics. +*/ +double API_SUFFIX(stdlib_strided_dnannsumors_ndarray)( const CBLAS_INT N, const double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, CBLAS_INT *n ); #ifdef __cplusplus } diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/lib/dnannsumors.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/lib/dnannsumors.js index cac9a0f0d5f8..cdd2d9a21076 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/lib/dnannsumors.js +++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/lib/dnannsumors.js @@ -20,7 +20,8 @@ // MODULES // -var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var stride2offset = require( '@stdlib/strided/base/stride2offset' ); +var ndarray = require( './ndarray.js' ); // MAIN // @@ -45,49 +46,16 @@ var isnan = require( '@stdlib/math/base/assert/is-nan' ); * // returns [ 1.0, 3 ] */ function dnannsumors( N, x, strideX, out, strideOut ) { - var sum; var ix; var io; - var n; - var i; - if ( strideX < 0 ) { - ix = (1-N) * strideX; - } else { - ix = 0; - } + ix = stride2offset( N, strideX ); if ( strideOut < 0 ) { io = -strideOut; } else { io = 0; } - sum = 0.0; - if ( N <= 0 ) { - out[ io ] = sum; - out[ io+strideOut ] = 0; - return out; - } - if ( N === 1 || strideX === 0 ) { - if ( isnan( x[ ix ] ) ) { - out[ io ] = sum; - out[ io+strideOut ] = 0; - return out; - } - out[ io ] = x[ ix ]; - out[ io+strideOut ] = 1; - return out; - } - n = 0; - for ( i = 0; i < N; i++ ) { - if ( isnan( x[ ix ] ) === false ) { - sum += x[ ix ]; - n += 1; - } - ix += strideX; - } - out[ io ] = sum; - out[ io+strideOut ] = n; - return out; + return ndarray( N, x, strideX, ix, out, strideOut, io ); } diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/lib/ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/lib/ndarray.js index 682b6d0caabd..af74b786a1ed 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/lib/ndarray.js +++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/lib/ndarray.js @@ -53,23 +53,22 @@ function dnannsumors( N, x, strideX, offsetX, out, strideOut, offsetOut ) { var n; var i; - ix = offsetX; - io = offsetOut; - sum = 0.0; + io = offsetOut; if ( N <= 0 ) { out[ io ] = sum; out[ io+strideOut ] = 0; return out; } - if ( N === 1 || strideX === 0 ) { + ix = offsetX; + if ( strideX === 0 ) { if ( isnan( x[ ix ] ) ) { out[ io ] = sum; out[ io+strideOut ] = 0; return out; } - out[ io ] = x[ ix ]; - out[ io+strideOut ] = 1; + out[ io ] = x[ ix ] * N; + out[ io+strideOut ] = N; return out; } n = 0; diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/lib/ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/lib/ndarray.native.js index ba8cc6d85ecf..66bbb1bb4b6f 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/lib/ndarray.native.js +++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/lib/ndarray.native.js @@ -20,9 +20,7 @@ // MODULES // -var minViewBufferIndex = require( '@stdlib/strided/base/min-view-buffer-index' ); -var offsetView = require( '@stdlib/strided/base/offset-view' ); -var addon = require( './dnannsumors.native.js' ); +var addon = require( './../src/addon.node' ); // MAIN // @@ -49,16 +47,7 @@ var addon = require( './dnannsumors.native.js' ); * // returns [ 5.0, 4 ] */ function dnannsumors( N, x, strideX, offsetX, out, strideOut, offsetOut ) { - var viewOut; - var viewX; - offsetX = minViewBufferIndex( N, strideX, offsetX ); - if ( strideOut < 0 ) { - offsetOut += strideOut; - } - - viewX = offsetView( x, offsetX ); - viewOut = offsetView( out, offsetOut ); - addon( N, viewX, strideX, viewOut, strideOut ); + addon.ndarray( N, x, strideX, offsetX, out, strideOut, offsetOut ); return out; } diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/manifest.json b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/manifest.json index 28a611eb7345..afff6bbbe3e4 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/manifest.json +++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/manifest.json @@ -28,53 +28,53 @@ { "task": "build", "src": [ - "./src/dnannsumors.c" + "./src/main.c" ], "include": [ "./include" ], - "libraries": [ - "-lm" - ], + "libraries": [], "libpath": [], "dependencies": [ "@stdlib/napi/export", "@stdlib/napi/argv", "@stdlib/napi/argv-int64", "@stdlib/napi/argv-strided-float64array", - "@stdlib/math/base/assert/is-nan" + "@stdlib/math/base/assert/is-nan", + "@stdlib/blas/base/shared", + "@stdlib/strided/base/stride2offset" ] }, { "task": "benchmark", "src": [ - "./src/dnannsumors.c" + "./src/main.c" ], "include": [ "./include" ], - "libraries": [ - "-lm" - ], + "libraries": [], "libpath": [], "dependencies": [ - "@stdlib/math/base/assert/is-nan" + "@stdlib/math/base/assert/is-nan", + "@stdlib/blas/base/shared", + "@stdlib/strided/base/stride2offset" ] }, { "task": "examples", "src": [ - "./src/dnannsumors.c" + "./src/main.c" ], "include": [ "./include" ], - "libraries": [ - "-lm" - ], + "libraries": [], "libpath": [], "dependencies": [ - "@stdlib/math/base/assert/is-nan" + "@stdlib/math/base/assert/is-nan", + "@stdlib/blas/base/shared", + "@stdlib/strided/base/stride2offset" ] } ] diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/src/addon.c b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/src/addon.c index cde04f40fe29..5a454f42932e 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/src/addon.c +++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/src/addon.c @@ -17,6 +17,7 @@ */ #include "stdlib/blas/ext/base/dnannsumors.h" +#include "stdlib/blas/base/shared.h" #include "stdlib/napi/export.h" #include "stdlib/napi/argv.h" #include "stdlib/napi/argv_int64.h" @@ -38,7 +39,7 @@ static napi_value addon( napi_env env, napi_callback_info info ) { STDLIB_NAPI_ARGV_STRIDED_FLOAT64ARRAY( env, X, N, strideX, argv, 1 ); STDLIB_NAPI_ARGV_STRIDED_FLOAT64ARRAY( env, Out, 2, strideOut, argv, 3 ); - int64_t io; + int io; if ( strideOut < 0 ) { io = -strideOut; } else { @@ -46,11 +47,37 @@ static napi_value addon( napi_env env, napi_callback_info info ) { } double *out = Out; - int64_t n; - out[ io ] = stdlib_strided_dnannsumors( N, X, strideX, &n ); + CBLAS_INT n; + out[ io ] = API_SUFFIX(stdlib_strided_dnannsumors)( N, X, strideX, &n ); out[ io + strideOut ] = (double)n; return NULL; } -STDLIB_NAPI_MODULE_EXPORT_FCN( addon ) +/** +* Receives JavaScript callback invocation data. +* +* @param env environment under which the function is invoked +* @param info callback data +* @return Node-API value +*/ +static napi_value addon_method( napi_env env, napi_callback_info info ) { + STDLIB_NAPI_ARGV( env, info, argv, argc, 7 ); + STDLIB_NAPI_ARGV_INT64( env, N, argv, 0 ); + STDLIB_NAPI_ARGV_INT64( env, strideX, argv, 2 ); + STDLIB_NAPI_ARGV_INT64( env, offsetX, argv, 3 ); + STDLIB_NAPI_ARGV_INT64( env, strideOut, argv, 5 ); + STDLIB_NAPI_ARGV_INT64( env, offsetOut, argv, 6 ); + STDLIB_NAPI_ARGV_STRIDED_FLOAT64ARRAY( env, X, N, strideX, argv, 1 ); + STDLIB_NAPI_ARGV_STRIDED_FLOAT64ARRAY( env, Out, 2, strideOut, argv, 4 ); + + int io = offsetOut; + double *out = Out; + CBLAS_INT n; + out[ io ] = API_SUFFIX(stdlib_strided_dnannsumors_ndarray)( N, X, strideX, offsetX, &n ); + out[ io+strideOut ] = (double)n; + + return NULL; +} + +STDLIB_NAPI_MODULE_EXPORT_FCN_WITH_METHOD( addon, "ndarray", addon_method ) diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/src/dnannsumors.c b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/src/dnannsumors.c deleted file mode 100644 index 5566c0807f29..000000000000 --- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/src/dnannsumors.c +++ /dev/null @@ -1,62 +0,0 @@ -/** -* @license Apache-2.0 -* -* Copyright (c) 2020 The Stdlib Authors. -* -* Licensed under the Apache License, Version 2.0 (the "License"); -* you may not use this file except in compliance with the License. -* You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, software -* distributed under the License is distributed on an "AS IS" BASIS, -* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -* See the License for the specific language governing permissions and -* limitations under the License. -*/ - -#include "stdlib/blas/ext/base/dnannsumors.h" -#include "stdlib/math/base/assert/is_nan.h" -#include - -/** -* Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using ordinary recursive summation. -* -* @param N number of indexed elements -* @param X input array -* @param stride stride length -* @param n pointer for storing the number of non-NaN elements -* @return output value -*/ -double stdlib_strided_dnannsumors( const int64_t N, const double *X, const int64_t stride, int64_t *n ) { - double sum; - int64_t ix; - int64_t i; - - sum = 0.0; - *n = 0; - if ( N <= 0 ) { - return sum; - } - if ( N == 1 || stride == 0 ) { - if ( stdlib_base_is_nan( X[ 0 ] ) ) { - return sum; - } - *n += 1; - return X[ 0 ]; - } - if ( stride < 0 ) { - ix = (1-N) * stride; - } else { - ix = 0; - } - for ( i = 0; i < N; i++ ) { - if ( !stdlib_base_is_nan( X[ ix ] ) ) { - sum += X[ ix ]; - *n += 1; - } - ix += stride; - } - return sum; -} diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/src/main.c b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/src/main.c new file mode 100644 index 000000000000..a43cc7fd384f --- /dev/null +++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/src/main.c @@ -0,0 +1,74 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2020 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include "stdlib/blas/ext/base/dnannsumors.h" +#include "stdlib/strided/base/stride2offset.h" +#include "stdlib/math/base/assert/is_nan.h" +#include "stdlib/blas/base/shared.h" + +/** +* Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using ordinary recursive summation. +* +* @param N number of indexed elements +* @param X input array +* @param strideX stride length +* @param n number of non-NaN elements +* @return output value +*/ +double API_SUFFIX(stdlib_strided_dnannsumors)( const CBLAS_INT N, const double *X, const CBLAS_INT strideX, CBLAS_INT *n ) { + CBLAS_INT ox = stdlib_strided_stride2offset( N, strideX ); + return API_SUFFIX(stdlib_strided_dnannsumors_ndarray)( N, X, strideX, ox, n ); +} + +/** +* Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using ordinary recursive summation and alternative indexing semantics. +* +* @param N number of indexed elements +* @param X input array +* @param strideX stride length +* @param offsetX starting index +* @param n number of non-NaN elements +* @return output value +*/ +double API_SUFFIX(stdlib_strided_dnannsumors_ndarray)( const CBLAS_INT N, const double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, CBLAS_INT *n ) { + double sum; + CBLAS_INT ix; + CBLAS_INT i; + + sum = 0.0; + *n = 0; + if ( N <= 0 ) { + return sum; + } + ix = offsetX; + if ( strideX == 0 ) { + if ( stdlib_base_is_nan( X[ ix ] ) ) { + return sum; + } + *n += N; + return X[ ix ] * N; + } + for ( i = 0; i < N; i++ ) { + if ( !stdlib_base_is_nan( X[ ix ] ) ) { + sum += X[ ix ]; + *n += 1; + } + ix += strideX; + } + return sum; +} diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/test/test.dnannsumors.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/test/test.dnannsumors.js index 0694312d02c7..74265cbba6e3 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/test/test.dnannsumors.js +++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/test/test.dnannsumors.js @@ -215,7 +215,7 @@ tape( 'the function supports negative `stride` parameters', function test( t ) { t.end(); }); -tape( 'if provided a `stride` parameter equal to `0`, the function returns a sum equal to the first element', function test( t ) { +tape( 'if provided a `stride` parameter equal to `0`, the function returns a sum of the first element repeated N times', function test( t ) { var expected; var out; var x; @@ -226,7 +226,7 @@ tape( 'if provided a `stride` parameter equal to `0`, the function returns a sum out = new Float64Array( 2 ); v = dnannsumors( x.length, x, 0, out, 1 ); - expected = new Float64Array( [ 1.0, 1.0 ] ); + expected = new Float64Array( [ 5.0, 5.0 ] ); t.deepEqual( v, expected, 'returns expected value' ); t.end(); diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/test/test.dnannsumors.native.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/test/test.dnannsumors.native.js index 46f48a04c58f..8716af177db7 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/test/test.dnannsumors.native.js +++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/test/test.dnannsumors.native.js @@ -224,7 +224,7 @@ tape( 'the function supports negative `stride` parameters', opts, function test( t.end(); }); -tape( 'if provided a `stride` parameter equal to `0`, the function returns a sum equal to the first element', opts, function test( t ) { +tape( 'if provided a `stride` parameter equal to `0`, the function returns a sum of the first element repeated N times', opts, function test( t ) { var expected; var out; var x; @@ -235,7 +235,7 @@ tape( 'if provided a `stride` parameter equal to `0`, the function returns a sum out = new Float64Array( 2 ); v = dnannsumors( x.length, x, 0, out, 1 ); - expected = new Float64Array( [ 1.0, 1.0 ] ); + expected = new Float64Array( [ 5.0, 5.0 ] ); t.deepEqual( v, expected, 'returns expected value' ); t.end(); diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/test/test.ndarray.js index 3d895b56fb4a..daae94f7a2a4 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/test/test.ndarray.js +++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/test/test.ndarray.js @@ -215,7 +215,7 @@ tape( 'the function supports a negative `stride` parameter', function test( t ) t.end(); }); -tape( 'if provided a `stride` parameter equal to `0`, the function returns the first indexed element', function test( t ) { +tape( 'if provided a `stride` parameter equal to `0`, the function returns a sum of the first element repeated N times', function test( t ) { var expected; var out; var x; @@ -226,7 +226,7 @@ tape( 'if provided a `stride` parameter equal to `0`, the function returns the f out = new Float64Array( 2 ); v = dnannsumors( x.length, x, 0, 0, out, 1, 0 ); - expected = new Float64Array( [ 1.0, 1.0 ] ); + expected = new Float64Array( [ 5.0, 5.0 ] ); t.deepEqual( v, expected, 'returns expected value' ); t.end(); diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/test/test.ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/test/test.ndarray.native.js index bc495e39216a..85481a880db3 100644 --- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/test/test.ndarray.native.js +++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumors/test/test.ndarray.native.js @@ -224,7 +224,7 @@ tape( 'the function supports a negative `stride` parameter', opts, function test t.end(); }); -tape( 'if provided a `stride` parameter equal to `0`, the function returns the first indexed element', opts, function test( t ) { +tape( 'if provided a `stride` parameter equal to `0`, the function returns a sum of the first element repeated N times', opts, function test( t ) { var expected; var out; var x; @@ -235,7 +235,7 @@ tape( 'if provided a `stride` parameter equal to `0`, the function returns the f out = new Float64Array( 2 ); v = dnannsumors( x.length, x, 0, 0, out, 1, 0 ); - expected = new Float64Array( [ 1.0, 1.0 ] ); + expected = new Float64Array( [ 5.0, 5.0 ] ); t.deepEqual( v, expected, 'returns expected value' ); t.end();