feat: add C ndarray API and refactor blas/ext/base/dnannsumpw

lib/node_modules/@stdlib/blas/ext/base/dnannsumpw/README.md

@@ -58,7 +58,7 @@ The function has the following parameters:
 - **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`.
 
-The `N` and `stride` parameters determine which elements are accessed at runtime. For example, to compute the sum of every other element in the strided array,
+The `N` and stride parameters determine which elements are accessed at runtime. For example, to compute the sum of every other element in the strided array,
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
@@ -106,7 +106,7 @@ The function has the following additional parameters:
 - **offsetX**: starting index for the strided array.
 - **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 the strided array 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 value in the strided array starting from the second value:
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
@@ -165,8 +165,132 @@ console.log( out );
 
 <!-- /.examples -->
 
+<!-- C interface documentation. -->
+
 * * *
 
+<section class="c">
+
+## C APIs
+
+<!-- Section to include introductory text. Make sure to keep an empty line after the intro `section` element and another before the `/section` close. -->
+
+<section class="intro">
+
+</section>
+
+<!-- /.intro -->
+
+<!-- C usage documentation. -->
+
+<section class="usage">
+
+### Usage
+
+```c
+#include "stdlib/blas/ext/base/dnannsumpw.h"
+```
+
+#### stdlib_strided_dnannsumpw( N, \*X, strideX, \*n )
+
+Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using pairwise summation.
+
+```c
+const double x[] = { 1.0, 2.0, 0.0/0.0, 4.0 };
+CBLAS_INT n = 0;
+
+double v = stdlib_strided_dnannsumpw( 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` index increment for `X`.
+- **n**: `[out] CBLAS_INT*` number of non-NaN elements.
+
+```c
+double stdlib_strided_dnannsumpw( const CBLAS_INT N, const double *X, const CBLAS_INT strideX, CBLAS_INT *n );
+```
+
+#### stdlib_strided_dnannsumpw_ndarray( N, \*X, strideX, offsetX, \*n )
+
+Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using pairwise 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_dnannsumpw_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` index increment for `X`.
+- **offsetX**: `[in] CBLAS_INT` starting index for `X`.
+- **n**: `[out] CBLAS_INT*` number of non-NaN elements.
+
+```c
+double stdlib_strided_dnannsumpw_ndarray( const CBLAS_INT N, const double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, CBLAS_INT *n );
+```
+
+</section>
+
+<!-- /.usage -->
+
+<!-- C API usage notes. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="notes">
+
+</section>
+
+<!-- /.notes -->
+
+<!-- C API usage examples. -->
+
+<section class="examples">
+
+### Examples
+
+```c
+#include "stdlib/blas/ext/base/dnannsumpw.h"
+#include "stdlib/blase/base/shared.h"
+#include <stdio.h>
+
+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_dnannsumpw( N, x, strideX, &n );
+
+ // Print the result:
+ printf( "sum: %lf\n", v );
+ printf( "n: %"CBLAS_IFMT"\n", n );
+}
+```
+
+</section>
+
+<!-- /.examples -->
+
+</section>
+
+<!-- /.c -->
+
 <section class="references">
 
 ## References

lib/node_modules/@stdlib/blas/ext/base/dnannsumpw/benchmark/c/benchmark.length.c

@@ -17,6 +17,7 @@
 */
 
 #include "stdlib/blas/ext/base/dnannsumpw.h"
+#include "stdlib/blas/base/shared.h"
 #include <stdlib.h>
 #include <stdio.h>
 #include <math.h>
@@ -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_dnannsumpw_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 );
  }

lib/node_modules/@stdlib/blas/ext/base/dnannsumpw/docs/repl.txt

@@ -3,7 +3,7 @@
  Computes the sum of double-precision floating-point strided array elements,
  ignoring `NaN` values and using pairwise 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
@@ -62,8 +62,8 @@
  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
  ----------

lib/node_modules/@stdlib/blas/ext/base/dnannsumpw/examples/c/example.c

@@ -17,27 +17,26 @@
 */
 
 #include "stdlib/blas/ext/base/dnannsumpw.h"
-#include <stdint.h>
+#include "stdlib/blas/base/shared.h"
 #include <stdio.h>
-#include <inttypes.h>
 
 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_dnannsumpw( N, x, stride, &n );
+ double v = stdlib_strided_dnannsumpw( N, x, strideX, &n );
 
  // Print the result:
  printf( "sum: %lf\n", v );
- printf( "n: %"PRId64"\n", n );
+ printf( "n: %"CBLAS_IFMT"\n", n );
 }

lib/node_modules/@stdlib/blas/ext/base/dnannsumpw/include/stdlib/blas/ext/base/dnannsumpw.h

@@ -19,7 +19,7 @@
 #ifndef STDLIB_BLAS_EXT_BASE_DNANNSUMPW_H
 #define STDLIB_BLAS_EXT_BASE_DNANNSUMPW_H
 
-#include <stdint.h>
+#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 pairwise summation.
 */
-double stdlib_strided_dnannsumpw( const int64_t N, const double *X, const int64_t stride, int64_t *n );
+double API_SUFFIX(stdlib_strided_dnannsumpw)( 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 pairwise summation and alternative indexing semantics.
+*/
+double API_SUFFIX(stdlib_strided_dnannsumpw_ndarray)( const CBLAS_INT N, const double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, CBLAS_INT *n );
 
 #ifdef __cplusplus
 }

lib/node_modules/@stdlib/blas/ext/base/dnannsumpw/lib/dnannsumpw.js

@@ -20,7 +20,8 @@
 
 // MODULES //
 
-var sumpw = require( './sumpw.js' );
+var stride2offset = require( '@stdlib/strided/base/stride2offset' );
+var ndarray = require( './ndarray.js' );
 
 
 // MAIN //
@@ -55,20 +56,14 @@ var sumpw = require( './sumpw.js' );
 function dnannsumpw( N, x, strideX, out, strideOut ) {
  var ix;
  var io;
- if ( strideX < 0 ) {
- ix = (1-N) * strideX;
- } else {
- ix = 0;
- }
+
+ ix = stride2offset( N, strideX );
  if ( strideOut < 0 ) {
  io = -strideOut;
  } else {
  io = 0;
  }
- out[ io ] = 0.0;
- out[ io+strideOut ] = 0;
- sumpw( N, x, strideX, ix, out, strideOut, io );
- return out;
+ return ndarray( N, x, strideX, ix, out, strideOut, io );
 }
 
 

lib/node_modules/@stdlib/blas/ext/base/dnannsumpw/lib/ndarray.js

@@ -38,10 +38,10 @@ var sumpw = require( './sumpw.js' );
 *
 * @param {PositiveInteger} N - number of indexed elements
 * @param {Float64Array} x - input array
-* @param {integer} strideX - `x` stride length
+* @param {integer} strideX - `x` index increment
 * @param {NonNegativeInteger} offsetX - `x` starting index
 * @param {Float64Array} out - output array
-* @param {integer} strideOut - `out` stride length
+* @param {integer} strideOut - `out` index increment
 * @param {NonNegativeInteger} offsetOut - `out` starting index
 * @returns {Float64Array} output array
 *
@@ -55,10 +55,7 @@ var sumpw = require( './sumpw.js' );
 * // returns <Float64Array>[ 5.0, 4 ]
 */
 function dnannsumpw( N, x, strideX, offsetX, out, strideOut, offsetOut ) {
- out[ offsetOut ] = 0.0;
- out[ offsetOut+strideOut ] = 0;
- sumpw( N, x, strideX, offsetX, out, strideOut, offsetOut );
- return out;
+ return sumpw( N, x, strideX, offsetX, out, strideOut, offsetOut );
 }