diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/README.md b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/README.md
index 7c9708a4a43f..c039427b8926 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/README.md
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/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' );
@@ -164,8 +164,136 @@ console.log( out );
+
+
* * *
+
+
+## C APIs
+
+
+
+
+
+
+
+
+
+
+
+### Usage
+
+```c
+#include "stdlib/blas/ext/base/dnannsumkbn.h"
+```
+
+#### stdlib_strided_dnannsumkbn( N, \*X, strideX, \*n )
+
+Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+
+```c
+#include "stdlib/blas/base/shared.h"
+
+const double x[] = { 1.0, 2.0, 0.0/0.0, 4.0 };
+CBLAS_INT n = 0;
+
+double v = stdlib_strided_dnannsumkbn( 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*` pointer for storing the number of non-NaN elements.
+
+```c
+double stdlib_strided_dnannsumkbn( const CBLAS_INT N, const double *X, const CBLAS_INT strideX, CBLAS_INT *n );
+```
+
+#### stdlib_strided_dnannsumkbn_ndarray( N, \*X, strideX, offsetX, \*n )
+
+Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using an improved Kahan–Babuška algorithm and alternative indexing semantics.
+
+```c
+#include "stdlib/blas/base/shared.h"
+
+const double x[] = { 1.0, 2.0, 0.0/0.0, 4.0 };
+CBLAS_INT n = 0;
+
+double v = stdlib_strided_dnannsumkbn_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*` pointer for storing the number of non-NaN elements.
+
+```c
+double stdlib_strided_dnannsumkbn_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/dnannsumkbn.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_dnannsumkbn( N, x, strideX, &n );
+
+ // Print the result:
+ printf( "sum: %lf\n", v );
+ printf( "n: %"CBLAS_IFMT"\n", n );
+}
+```
+
+
+
+
+
+
+
+
+
## References
diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/benchmark/benchmark.js
index 2850c16dd58a..81ae9d819649 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/benchmark/benchmark.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/benchmark/benchmark.js
@@ -33,6 +33,19 @@ var dnannsumkbn = require( './../lib/dnannsumkbn.js' );
// FUNCTIONS //
+/**
+* Returns a random number.
+*
+* @private
+* @returns {number} random number
+*/
+function rand() {
+ if ( bernoulli( 0.7 ) > 0 ) {
+ return discreteUniform( -10.0, 10.0 );
+ }
+ return NaN;
+}
+
/**
* Creates a benchmark function.
*
@@ -46,12 +59,6 @@ function createBenchmark( len ) {
out = new Float64Array( 2 );
return benchmark;
- function rand() {
- if ( bernoulli( 0.7 ) > 0 ) {
- return discreteUniform( -10, 10 );
- }
- }
-
function benchmark( b ) {
var i;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/benchmark/benchmark.native.js
index 12f4a9059d81..bb96e0464bb2 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/benchmark/benchmark.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/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.7 ) > 0 ) {
+ return discreteUniform( -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.7 ) > 0 ) {
- return discreteUniform( -10, 10 );
- }
- return NaN;
- }
-
function benchmark( b ) {
var i;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/benchmark/benchmark.ndarray.js
index b7c3c480c348..24d3008d88a4 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/benchmark/benchmark.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/benchmark/benchmark.ndarray.js
@@ -33,6 +33,19 @@ var dnannsumkbn = require( './../lib/ndarray.js' );
// FUNCTIONS //
+/**
+* Returns a random number.
+*
+* @private
+* @returns {number} random number
+*/
+function rand() {
+ if ( bernoulli( 0.7 ) > 0 ) {
+ return discreteUniform( -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.7 ) > 0 ) {
- return discreteUniform( -10, 10 );
- }
- return NaN;
- }
-
function benchmark( b ) {
var i;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/benchmark/benchmark.ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/benchmark/benchmark.ndarray.native.js
index 37e59f79a795..8919083cf2d4 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/benchmark/benchmark.ndarray.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/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.7 ) > 0 ) {
+ return discreteUniform( -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.7 ) > 0 ) {
- return discreteUniform( -10, 10 );
- }
- return NaN;
- }
-
function benchmark( b ) {
var i;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/benchmark/c/benchmark.length.c b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/benchmark/c/benchmark.length.c
index 70171814fc49..511533669c2b 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/benchmark/c/benchmark.length.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/benchmark/c/benchmark.length.c
@@ -17,6 +17,7 @@
*/
#include "stdlib/blas/ext/base/dnannsumkbn.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;
@@ -113,6 +114,7 @@ static double benchmark( int iterations, int len ) {
n = 0;
t = tic();
for ( i = 0; i < iterations; i++ ) {
+ // cppcheck-suppress uninitvar
v = stdlib_strided_dnannsumkbn( len, x, 1, &n );
if ( v != v || n < 0 ) {
printf( "should not return NaN\n" );
@@ -126,6 +128,46 @@ 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++ ) {
+ // cppcheck-suppress uninitvar
+ v = stdlib_strided_dnannsumkbn_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 +190,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/dnannsumkbn/docs/repl.txt b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/docs/repl.txt
index 14010bb16fb7..da252628e372 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/docs/repl.txt
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/docs/repl.txt
@@ -3,8 +3,8 @@
Computes the sum of double-precision floating-point strided array elements,
ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
- The `N` and `stride` parameters determine which elements in the strided
- array are accessed at runtime.
+ 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.
@@ -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,7 +42,7 @@
> {{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 );
> {{alias}}( 4, x, 2, out, 1 )
@@ -62,8 +62,8 @@
alternative indexing semantics.
While typed array views mandate a view offset based on the underlying
- buffer, the offsetX and offsetY parameter supports indexing semantics
- based on a starting index.
+ buffer, offset parameters support indexing semantics based on starting
+ indices.
Parameters
----------
@@ -74,7 +74,7 @@
Input array.
strideX: integer
- Index increment for `x`.
+ Stride length for `x`.
offsetX: integer
Starting index for `x`.
@@ -83,7 +83,7 @@
Output array.
strideOut: integer
- Index increment for `out`.
+ Stride length for `out`.
offsetOut: integer
Starting index for `out`.
@@ -99,7 +99,7 @@
// Standard Usage:
> var x = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, NaN, 2.0 ] );
> var out = new {{alias:@stdlib/array/float64}}( 2 );
- > {{alias}}.ndarray( x.length, x, 1, 0, out, 1, 0 )
+ > {{alias}}.ndarray( 4, x, 1, 0, out, 1, 0 )
[ 1.0, 3 ]
// Using offset parameter:
diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/examples/c/example.c b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/examples/c/example.c
index 1aab6016b8a0..165802a7eee1 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/examples/c/example.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/examples/c/example.c
@@ -17,27 +17,26 @@
*/
#include "stdlib/blas/ext/base/dnannsumkbn.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_dnannsumkbn( N, x, stride, &n );
+ double v = stdlib_strided_dnannsumkbn( 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/dnannsumkbn/include/stdlib/blas/ext/base/dnannsumkbn.h b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/include/stdlib/blas/ext/base/dnannsumkbn.h
index 98733f05e7e7..c84e4d30f221 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/include/stdlib/blas/ext/base/dnannsumkbn.h
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/include/stdlib/blas/ext/base/dnannsumkbn.h
@@ -19,7 +19,7 @@
#ifndef STDLIB_BLAS_EXT_BASE_DNANNSUMKBN_H
#define STDLIB_BLAS_EXT_BASE_DNANNSUMKBN_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 an improved Kahan–Babuška algorithm.
*/
-double stdlib_strided_dnannsumkbn( const int64_t N, const double *X, const int64_t stride, int64_t *n );
+double API_SUFFIX(stdlib_strided_dnannsumkbn)( 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 an improved Kahan–Babuška algorithm and alternative indexing semantics.
+*/
+double API_SUFFIX(stdlib_strided_dnannsumkbn_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/dnannsumkbn/lib/dnannsumkbn.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/lib/dnannsumkbn.js
index 7149e76b9a00..46f5d46ccce8 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/lib/dnannsumkbn.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/lib/dnannsumkbn.js
@@ -20,8 +20,8 @@
// MODULES //
-var isnan = require( '@stdlib/math/base/assert/is-nan' );
-var abs = require( '@stdlib/math/base/special/abs' );
+var stride2offset = require( '@stdlib/strided/base/stride2offset' );
+var ndarray = require( './ndarray.js' );
// MAIN //
@@ -54,60 +54,12 @@ var abs = require( '@stdlib/math/base/special/abs' );
* // returns [ 1.0, 3 ]
*/
function dnannsumkbn( N, x, strideX, out, strideOut ) {
- var sum;
var ix;
var io;
- var v;
- var t;
- var c;
- var n;
- var i;
- if ( strideX < 0 ) {
- ix = (1-N) * strideX;
- } else {
- ix = 0;
- }
- 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;
- }
- c = 0.0;
- n = 0;
- for ( i = 0; i < N; i++ ) {
- v = x[ ix ];
- if ( isnan( v ) === false ) {
- t = sum + v;
- if ( abs( sum ) >= abs( v ) ) {
- c += (sum-t) + v;
- } else {
- c += (v-t) + sum;
- }
- sum = t;
- n += 1;
- }
- ix += strideX;
- }
- out[ io ] = sum + c;
- out[ io+strideOut ] = n;
- return out;
+ ix = stride2offset( N, strideX );
+ io = stride2offset( 2, strideOut );
+ return ndarray( N, x, strideX, ix, out, strideOut, io );
}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/lib/ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/lib/ndarray.js
index 48c496820962..48b71c4fb84e 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/lib/ndarray.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/lib/ndarray.js
@@ -58,30 +58,27 @@ var abs = require( '@stdlib/math/base/special/abs' );
function dnannsumkbn( N, x, strideX, offsetX, out, strideOut, offsetOut ) {
var sum;
var ix;
- var io;
var v;
var t;
var c;
var n;
var i;
- ix = offsetX;
- io = offsetOut;
-
sum = 0.0;
if ( N <= 0 ) {
- out[ io ] = sum;
- out[ io+strideOut ] = 0;
+ out[ offsetOut ] = sum;
+ out[ offsetOut+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;
+ out[ offsetOut ] = sum;
+ out[ offsetOut+strideOut ] = 0;
return out;
}
- out[ io ] = x[ ix ];
- out[ io+strideOut ] = 1;
+ out[ offsetOut ] = x[ ix ] * N;
+ out[ offsetOut+strideOut ] = N;
return out;
}
c = 0.0;
@@ -100,8 +97,8 @@ function dnannsumkbn( N, x, strideX, offsetX, out, strideOut, offsetOut ) {
}
ix += strideX;
}
- out[ io ] = sum + c;
- out[ io+strideOut ] = n;
+ out[ offsetOut ] = sum + c;
+ out[ offsetOut+strideOut ] = n;
return out;
}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/lib/ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/lib/ndarray.native.js
index e8e546c448a7..9c20e11b2a71 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/lib/ndarray.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/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( './dnannsumkbn.native.js' );
+var addon = require( './../src/addon.node' );
// MAIN //
@@ -49,17 +47,7 @@ var addon = require( './dnannsumkbn.native.js' );
* // returns [ 5.0, 4 ]
*/
function dnannsumkbn( 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/dnannsumkbn/manifest.json b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/manifest.json
index 718554dcf606..ef4d072fe70a 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/manifest.json
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/manifest.json
@@ -28,53 +28,56 @@
{
"task": "build",
"src": [
- "./src/dnannsumkbn.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/math/base/special/abs",
+ "@stdlib/blas/base/shared",
+ "@stdlib/strided/base/stride2offset"
]
},
{
"task": "benchmark",
"src": [
- "./src/dnannsumkbn.c"
+ "./src/main.c"
],
"include": [
"./include"
],
- "libraries": [
- "-lm"
- ],
+ "libraries": [],
"libpath": [],
"dependencies": [
- "@stdlib/math/base/assert/is-nan"
+ "@stdlib/math/base/assert/is-nan",
+ "@stdlib/math/base/special/abs",
+ "@stdlib/blas/base/shared",
+ "@stdlib/strided/base/stride2offset"
]
},
{
"task": "examples",
"src": [
- "./src/dnannsumkbn.c"
+ "./src/main.c"
],
"include": [
"./include"
],
- "libraries": [
- "-lm"
- ],
+ "libraries": [],
"libpath": [],
"dependencies": [
- "@stdlib/math/base/assert/is-nan"
+ "@stdlib/math/base/assert/is-nan",
+ "@stdlib/math/base/special/abs",
+ "@stdlib/blas/base/shared",
+ "@stdlib/strided/base/stride2offset"
]
}
]
diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/src/addon.c b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/src/addon.c
index 21a7deefb892..0e0e8718658f 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/src/addon.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/src/addon.c
@@ -17,12 +17,14 @@
*/
#include "stdlib/blas/ext/base/dnannsumkbn.h"
+#include "stdlib/blas/base/shared.h"
#include "stdlib/napi/export.h"
#include "stdlib/napi/argv.h"
#include "stdlib/napi/argv_int64.h"
#include "stdlib/napi/argv_strided_float64array.h"
+#include "stdlib/strided/base/stride2offset.h"
+#include
#include
-#include
/**
* Receives JavaScript callback invocation data.
@@ -39,19 +41,36 @@ 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;
- if ( strideOut < 0 ) {
- io = -strideOut;
- } else {
- io = 0;
- }
+ int64_t io = stdlib_strided_stride2offset( 2, strideOut );
+ CBLAS_INT n;
+ Out[ io ] = API_SUFFIX(stdlib_strided_dnannsumkbn)( N, X, strideX, &n );
+ Out[ io+strideOut ] = (double)n;
- double *out = Out;
- int64_t n;
- out[ io ] = stdlib_strided_dnannsumkbn( N, X, strideX, &n );
- out[ io+strideOut ] = (double)n;
+ return NULL;
+}
+
+/**
+* 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 );
+
+ CBLAS_INT n;
+ Out[ offsetOut ] = API_SUFFIX(stdlib_strided_dnannsumkbn_ndarray)( N, X, strideX, offsetX, &n );
+ Out[ offsetOut+strideOut ] = (double)n;
return NULL;
}
-STDLIB_NAPI_MODULE_EXPORT_FCN( addon )
+STDLIB_NAPI_MODULE_EXPORT_FCN_WITH_METHOD( addon, "ndarray", addon_method )
diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/src/dnannsumkbn.c b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/src/dnannsumkbn.c
deleted file mode 100644
index 8dc8dbad44de..000000000000
--- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/src/dnannsumkbn.c
+++ /dev/null
@@ -1,82 +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/dnannsumkbn.h"
-#include "stdlib/math/base/assert/is_nan.h"
-#include
-#include
-
-/**
-* Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
-*
-* ## Method
-*
-* - This implementation uses an "improved Kahan–Babuška algorithm", as described by Neumaier (1974).
-*
-* ## References
-*
-* - Neumaier, Arnold. 1974. "Rounding Error Analysis of Some Methods for Summing Finite Sums." _Zeitschrift Für Angewandte Mathematik Und Mechanik_ 54 (1): 39–51. doi:[10.1002/zamm.19740540106](https://doi.org/10.1002/zamm.19740540106).
-*
-* @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_dnannsumkbn( const int64_t N, const double *X, const int64_t stride, int64_t *n ) {
- double sum;
- int64_t ix;
- int64_t i;
- double v;
- double t;
- double c;
-
- 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;
- }
- c = 0.0;
- for ( i = 0; i < N; i++ ) {
- v = X[ ix ];
- if ( !stdlib_base_is_nan( v ) ) {
- t = sum + v;
- if ( fabs( sum ) >= fabs( v ) ) {
- c += (sum-t) + v;
- } else {
- c += (v-t) + sum;
- }
- sum = t;
- *n += 1;
- }
- ix += stride;
- }
- return sum + c;
-}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/src/main.c b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/src/main.c
new file mode 100644
index 000000000000..7459f10e6071
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/src/main.c
@@ -0,0 +1,102 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2024 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/dnannsumkbn.h"
+#include "stdlib/strided/base/stride2offset.h"
+#include "stdlib/math/base/assert/is_nan.h"
+#include "stdlib/math/base/special/abs.h"
+#include "stdlib/blas/base/shared.h"
+
+/**
+* Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+*
+* ## Method
+*
+* - This implementation uses an "improved Kahan–Babuška algorithm", as described by Neumaier (1974).
+*
+* ## References
+*
+* - Neumaier, Arnold. 1974. "Rounding Error Analysis of Some Methods for Summing Finite Sums." _Zeitschrift Für Angewandte Mathematik Und Mechanik_ 54 (1): 39–51. doi:[10.1002/zamm.19740540106](https://doi.org/10.1002/zamm.19740540106).
+*
+* @param N number of indexed elements
+* @param X input array
+* @param strideX stride length
+* @param n pointer for storing the number of non-NaN elements
+* @return output value
+*/
+double API_SUFFIX(stdlib_strided_dnannsumkbn)( 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_dnannsumkbn_ndarray)( N, X, strideX, ox, n );
+}
+
+/**
+* Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using an improved Kahan–Babuška algorithm and alternative indexing semantics.
+*
+* ## Method
+*
+* - This implementation uses an "improved Kahan–Babuška algorithm", as described by Neumaier (1974).
+*
+* ## References
+*
+* - Neumaier, Arnold. 1974. "Rounding Error Analysis of Some Methods for Summing Finite Sums." _Zeitschrift Für Angewandte Mathematik Und Mechanik_ 54 (1): 39–51. doi:[10.1002/zamm.19740540106](https://doi.org/10.1002/zamm.19740540106).
+*
+* @param N number of indexed elements
+* @param X input array
+* @param strideX stride length
+* @param offsetX starting index
+* @param n pointer for storing the number of non-NaN elements
+* @return output value
+*/
+double API_SUFFIX(stdlib_strided_dnannsumkbn_ndarray)( const CBLAS_INT N, const double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, CBLAS_INT *n ) {
+ CBLAS_INT ix;
+ CBLAS_INT i;
+ double sum;
+ double v;
+ double t;
+ double c;
+
+ 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;
+ }
+ c = 0.0;
+ for ( i = 0; i < N; i++ ) {
+ v = X[ ix ];
+ if ( !stdlib_base_is_nan( v ) ) {
+ t = sum + v;
+ if ( stdlib_base_abs( sum ) >= stdlib_base_abs( v ) ) {
+ c += (sum-t) + v;
+ } else {
+ c += (v-t) + sum;
+ }
+ sum = t;
+ *n += 1;
+ }
+ ix += strideX;
+ }
+ return sum + c;
+}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/test/test.dnannsumkbn.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/test/test.dnannsumkbn.js
index 37f71ea7bd68..827fa8ef5c77 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/test/test.dnannsumkbn.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/test/test.dnannsumkbn.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 the 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 = dnannsumkbn( 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/dnannsumkbn/test/test.dnannsumkbn.native.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/test/test.dnannsumkbn.native.js
index 1cd6842af9b0..db71a389d272 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/test/test.dnannsumkbn.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/test/test.dnannsumkbn.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 the 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 = dnannsumkbn( 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/dnannsumkbn/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/test/test.ndarray.js
index 97d2d396ca01..ba07429ebe6a 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/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 the 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 = dnannsumkbn( 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/dnannsumkbn/test/test.ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/test/test.ndarray.native.js
index a44484c7456e..a9c95fe273ce 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/test/test.ndarray.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnannsumkbn/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 the 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 = dnannsumkbn( 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();