@stdlib/blas-ext-base-dsnannsumors 0.2.2 → 0.3.0

package/NOTICE

@@ -1 +1 @@
-Copyright (c) 2016-2024 The Stdlib Authors.
+Copyright (c) 2016-2026 The Stdlib Authors.

package/README.md

@@ -78,22 +78,20 @@ The function has the following parameters:
 
 -   **N**: number of indexed elements.
 -   **x**: input [`Float32Array`][@stdlib/array/float32].
--   **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:
 
 ```javascript
 var Float32Array = require( '@stdlib/array-float32' );
 var Float64Array = require( '@stdlib/array-float64' );
-var floor = require( '@stdlib/math-base-special-floor' );
 
 var x = new Float32Array( [ 1.0, 2.0, NaN, -7.0, NaN, 3.0, 4.0, 2.0 ] );
 var out = new Float64Array( 2 );
-var N = floor( x.length / 2 );
 
-var v = dsnannsumors( N, x, 2, out, 1 );
+var v = dsnannsumors( 4, x, 2, out, 1 );
 // returns <Float64Array>[ 5.0, 2 ]
 ```
 
@@ -104,7 +102,6 @@ Note that indexing is relative to the first index. To introduce an offset, use [
 ```javascript
 var Float32Array = require( '@stdlib/array-float32' );
 var Float64Array = require( '@stdlib/array-float64' );
-var floor = require( '@stdlib/math-base-special-floor' );
 
 var x0 = new Float32Array( [ 2.0, 1.0, NaN, -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
@@ -112,15 +109,13 @@ var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd
 var out0 = new Float64Array( 4 );
 var out1 = new Float64Array( out0.buffer, out0.BYTES_PER_ELEMENT*2 ); // start at 3rd element
 
-var N = floor( x0.length / 2 );
-
-var v = dsnannsumors( N, x1, 2, out1, 1 );
+var v = dsnannsumors( 4, x1, 2, out1, 1 );
 // returns <Float64Array>[ 5.0, 4 ]
 ```
 
 #### dsnannsumors.ndarray( N, x, strideX, offsetX, out, strideOut, offsetOut )
 
-Computes the sum of single-precision floating-point strided array elements, ignoring `NaN` values and using ordinary recursive summation with extended accumulation and alternative indexing semantics.
+Computes the sum of single-precision floating-point strided array elements, ignoring `NaN` values, using ordinary recursive summation with extended accumulation and alternative indexing semantics, and returning an extended precision result.
 
 ```javascript
 var Float32Array = require( '@stdlib/array-float32' );
@@ -138,18 +133,16 @@ 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, the 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 Float32Array = require( '@stdlib/array-float32' );
 var Float64Array = require( '@stdlib/array-float64' );
-var floor = require( '@stdlib/math-base-special-floor' );
 
 var x = new Float32Array( [ 2.0, 1.0, NaN, -2.0, -2.0, 2.0, 3.0, 4.0 ] );
 var out = new Float64Array( 4 );
-var N = floor( x.length / 2 );
 
-var v = dsnannsumors.ndarray( N, x, 2, 1, out, 2, 1 );
+var v = dsnannsumors.ndarray( 4, x, 2, 1, out, 2, 1 );
 // returns <Float64Array>[ 0.0, 5.0, 0.0, 4 ]
 ```
 
@@ -175,23 +168,21 @@ var v = dsnannsumors.ndarray( N, x, 2, 1, out, 2, 1 );
 <!-- eslint no-undef: "error" -->
 
 ```javascript
-var randu = require( '@stdlib/random-base-randu' );
-var round = require( '@stdlib/math-base-special-round' );
+var discreteUniform = require( '@stdlib/random-base-discrete-uniform' );
+var bernoulli = require( '@stdlib/random-base-bernoulli' );
+var filledarrayBy = require( '@stdlib/array-filled-by' );
 var Float32Array = require( '@stdlib/array-float32' );
 var Float64Array = require( '@stdlib/array-float64' );
 var dsnannsumors = require( '@stdlib/blas-ext-base-dsnannsumors' );
 
-var x;
-var i;
-
-x = new Float32Array( 10 );
-for ( i = 0; i < x.length; i++ ) {
-    if ( randu() < 0.2 ) {
-        x[ i ] = NaN;
-    } else {
-        x[ i ] = round( randu()*100.0 );
+function rand() {
+    if ( bernoulli( 0.5 ) < 0.2 ) {
+        return NaN;
     }
+    return discreteUniform( 0, 100 );
 }
+
+var x = filledarrayBy( 10, 'float32', rand );
 console.log( x );
 
 var out = new Float64Array( 2 );
@@ -203,6 +194,136 @@ 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/dsnannsumors.h"
+```
+
+#### stdlib_strided_dsnannsumors( N, \*X, strideX, \*n )
+
+Computes the sum of single-precision floating-point strided array elements, ignoring `NaN` values, using ordinary recursive summation with extended accumulation, and returning an extended precision result.
+
+```c
+#include "stdlib/blas/base/shared.h"
+
+const float x[] = { 1.0f, -2.0f, 0.0f/0.0f, 2.0f };
+CBLAS_INT n = 0;
+
+double v = stdlib_strided_dsnannsumors( 4, x, 1, &n );
+// returns 1.0
+```
+
+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`.
+-   **n**: `[out] CBLAS_INT*` pointer for storing the number of non-NaN elements.
+
+```c
+double stdlib_strided_dsnannsumors( const CBLAS_INT N, const float *X, const CBLAS_INT strideX, CBLAS_INT *n );
+```
+
+#### stdlib_strided_dsnannsumors_ndarray( N, \*X, strideX, offsetX, \*n )
+
+Computes the sum of single-precision floating-point strided array elements, ignoring `NaN` values, using ordinary recursive summation with extended accumulation and alternative indexing semantics, and returning an extended precision result.
+
+```c
+#include "stdlib/blas/base/shared.h"
+
+const float x[] = { 1.0f, -2.0f, 0.0f/0.0f, 2.0f };
+CBLAS_INT n = 0;
+
+double v = stdlib_strided_dsnannsumors_ndarray( 4, x, 1, 0, &n );
+// returns 1.0
+```
+
+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`.
+-   **n**: `[out] CBLAS_INT*` pointer for storing the number of non-NaN elements.
+
+```c
+double stdlib_strided_dsnannsumors_ndarray( const CBLAS_INT N, const float *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/dsnannsumors.h"
+#include "stdlib/blas/base/shared.h"
+#include <stdio.h>
+
+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, 0.0f/0.0f, 0.0f/0.0f };
+
+    // 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_dsnannsumors( N, x, strideX, &n );
+
+    // Print the result:
+    printf( "sum: %lf\n", v );
+    printf( "n: %"CBLAS_IFMT"\n", n );
+}
+```
+
+</section>
+
+<!-- /.examples -->
+
+</section>
+
+<!-- /.c -->
+
 <!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
 
 <section class="related">
@@ -245,7 +366,7 @@ See [LICENSE][stdlib-license].
 
 ## Copyright
 
-Copyright &copy; 2016-2024. The Stdlib [Authors][stdlib-authors].
+Copyright &copy; 2016-2026. The Stdlib [Authors][stdlib-authors].
 
 </section>
 
@@ -258,8 +379,8 @@ Copyright &copy; 2016-2024. The Stdlib [Authors][stdlib-authors].
 [npm-image]: http://img.shields.io/npm/v/@stdlib/blas-ext-base-dsnannsumors.svg
 [npm-url]: https://npmjs.org/package/@stdlib/blas-ext-base-dsnannsumors
 
-[test-image]: https://github.com/stdlib-js/blas-ext-base-dsnannsumors/actions/workflows/test.yml/badge.svg?branch=v0.2.2
-[test-url]: https://github.com/stdlib-js/blas-ext-base-dsnannsumors/actions/workflows/test.yml?query=branch:v0.2.2
+[test-image]: https://github.com/stdlib-js/blas-ext-base-dsnannsumors/actions/workflows/test.yml/badge.svg?branch=v0.3.0
+[test-url]: https://github.com/stdlib-js/blas-ext-base-dsnannsumors/actions/workflows/test.yml?query=branch:v0.3.0
 
 [coverage-image]: https://img.shields.io/codecov/c/github/stdlib-js/blas-ext-base-dsnannsumors/main.svg
 [coverage-url]: https://codecov.io/github/stdlib-js/blas-ext-base-dsnannsumors?branch=main
@@ -271,8 +392,8 @@ Copyright &copy; 2016-2024. The Stdlib [Authors][stdlib-authors].
 
 -->
 
-[chat-image]: https://img.shields.io/gitter/room/stdlib-js/stdlib.svg
-[chat-url]: https://app.gitter.im/#/room/#stdlib-js_stdlib:gitter.im
+[chat-image]: https://img.shields.io/badge/zulip-join_chat-brightgreen.svg
+[chat-url]: https://stdlib.zulipchat.com
 
 [stdlib]: https://github.com/stdlib-js/stdlib
 

package/dist/index.js

@@ -1,9 +1,9 @@
-"use strict";var p=function(s,a){return function(){return a||s((a={exports:{}}).exports,a),a.exports}};var _=p(function(I,R){
-var j=require('@stdlib/math-base-assert-is-nan/dist');function x(s,a,m,e,r){var v,q,n,f,i;if(m<0?q=(1-s)*m:q=0,r<0?n=-r:n=0,v=0,s<=0)return e[n]=v,e[n+r]=0,e;if(s===1||m===0)return j(a[q])?(e[n]=v,e[n+r]=0,e):(e[n]=a[q],e[n+r]=1,e);for(f=0,i=0;i<s;i++)j(a[q])===!1&&(v+=a[q],f+=1),q+=m;return e[n]=v,e[n+r]=f,e}R.exports=x
-});var g=p(function(J,b){
-var E=require('@stdlib/math-base-assert-is-nan/dist');function z(s,a,m,e,r,v,q){var n,f,i,c,l;if(f=e,i=q,n=0,s<=0)return r[i]=n,r[i+v]=0,r;if(s===1||m===0)return E(a[f])?(r[i]=n,r[i+v]=0,r):(r[i]=a[f],r[i+v]=1,r);for(c=0,l=0;l<s;l++)E(a[f])===!1&&(n+=a[f],c+=1),f+=m;return r[i]=n,r[i+v]=c,r}b.exports=z
-});var u=p(function(K,k){
-var A=require('@stdlib/utils-define-nonenumerable-read-only-property/dist'),h=_(),B=g();A(h,"ndarray",B);k.exports=h
-});var C=require("path").join,D=require('@stdlib/utils-try-require/dist'),F=require('@stdlib/assert-is-error/dist'),G=u(),y,w=D(C(__dirname,"./native.js"));F(w)?y=G:y=w;module.exports=y;
+"use strict";var u=function(e,a){return function(){return a||e((a={exports:{}}).exports,a),a.exports}};var y=u(function(I,l){
+var j=require('@stdlib/math-base-assert-is-nan/dist');function k(e,a,v,m,r,i,n){var q,s,c,p;if(q=0,e<=0)return r[n]=q,r[n+i]=0,r;if(s=m,v===0)return j(a[s])?(r[n]=q,r[n+i]=0,r):(r[n]=a[s]*e,r[n+i]=e,r);for(c=0,p=0;p<e;p++)j(a[s])===!1&&(q+=a[s],c+=1),s+=v;return r[n]=q,r[n+i]=c,r}l.exports=k
+});var _=u(function(J,R){
+var x=require('@stdlib/strided-base-stride2offset/dist'),w=y();function z(e,a,v,m,r){var i,n;return i=x(e,v),n=x(2,r),w(e,a,v,i,m,r,n)}R.exports=z
+});var g=u(function(K,b){
+var A=require('@stdlib/utils-define-nonenumerable-read-only-property/dist'),E=_(),B=y();A(E,"ndarray",B);b.exports=E
+});var C=require("path").join,D=require('@stdlib/utils-try-require/dist'),F=require('@stdlib/assert-is-error/dist'),G=g(),d,h=D(C(__dirname,"./native.js"));F(h)?d=G:d=h;module.exports=d;
 /** @license Apache-2.0 */
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["../lib/dsnannsumors.js", "../lib/ndarray.js", "../lib/main.js", "../lib/index.js"],
-  "sourcesContent": ["/**\n* @license Apache-2.0\n*\n* Copyright (c) 2020 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar isnan = require( '@stdlib/math-base-assert-is-nan' );\n\n\n// MAIN //\n\n/**\n* Computes the sum of single-precision floating-point strided array elements, ignoring `NaN` values, using ordinary recursive summation with extended accumulation, and returning an extended precision result.\n*\n* @param {PositiveInteger} N - number of indexed elements\n* @param {Float32Array} x - input array\n* @param {integer} strideX - `x` stride length\n* @param {Float64Array} out - output array\n* @param {integer} strideOut - `out` stride length\n* @returns {Float64Array} output array\n*\n* @example\n* var Float32Array = require( '@stdlib/array-float32' );\n* var Float64Array = require( '@stdlib/array-float64' );\n*\n* var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n* var out = new Float64Array( 2 );\n*\n* var v = dsnannsumors( x.length, x, 1, out, 1 );\n* // returns <Float64Array>[ 1.0, 3 ]\n*/\nfunction dsnannsumors( N, x, strideX, out, strideOut ) {\n\tvar sum;\n\tvar ix;\n\tvar io;\n\tvar n;\n\tvar i;\n\n\tif ( strideX < 0 ) {\n\t\tix = (1-N) * strideX;\n\t} else {\n\t\tix = 0;\n\t}\n\tif ( strideOut < 0 ) {\n\t\tio = -strideOut;\n\t} else {\n\t\tio = 0;\n\t}\n\tsum = 0.0;\n\tif ( N <= 0 ) {\n\t\tout[ io ] = sum;\n\t\tout[ io+strideOut ] = 0;\n\t\treturn out;\n\t}\n\tif ( N === 1 || strideX === 0 ) {\n\t\tif ( isnan( x[ ix ] ) ) {\n\t\t\tout[ io ] = sum;\n\t\t\tout[ io+strideOut ] = 0;\n\t\t\treturn out;\n\t\t}\n\t\tout[ io ] = x[ ix ];\n\t\tout[ io+strideOut ] = 1;\n\t\treturn out;\n\t}\n\tn = 0;\n\tfor ( i = 0; i < N; i++ ) {\n\t\tif ( isnan( x[ ix ] ) === false ) {\n\t\t\tsum += x[ ix ];\n\t\t\tn += 1;\n\t\t}\n\t\tix += strideX;\n\t}\n\tout[ io ] = sum;\n\tout[ io+strideOut ] = n;\n\treturn out;\n}\n\n\n// EXPORTS //\n\nmodule.exports = dsnannsumors;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2020 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar isnan = require( '@stdlib/math-base-assert-is-nan' );\n\n\n// MAIN //\n\n/**\n* Computes the sum of single-precision floating-point strided array elements, ignoring `NaN` values, using ordinary recursive summation with extended accumulation, and returning an extended precision result.\n*\n* @param {PositiveInteger} N - number of indexed elements\n* @param {Float32Array} x - input array\n* @param {integer} strideX - `x` stride length\n* @param {NonNegativeInteger} offsetX - `x` starting index\n* @param {Float64Array} out - output array\n* @param {integer} strideOut - `out` stride length\n* @param {NonNegativeInteger} offsetOut - `out` starting index\n* @returns {Float64Array} output array\n*\n* @example\n* var Float32Array = require( '@stdlib/array-float32' );\n* var Float64Array = require( '@stdlib/array-float64' );\n* var floor = require( '@stdlib/math-base-special-floor' );\n*\n* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN, NaN ] );\n* var out = new Float64Array( 2 );\n*\n* var N = floor( x.length / 2 );\n*\n* var v = dsnannsumors( N, x, 2, 1, out, 1, 0 );\n* // returns <Float64Array>[ 5.0, 4 ]\n*/\nfunction dsnannsumors( N, x, strideX, offsetX, out, strideOut, offsetOut ) {\n\tvar sum;\n\tvar ix;\n\tvar io;\n\tvar n;\n\tvar i;\n\n\tix = offsetX;\n\tio = offsetOut;\n\n\tsum = 0.0;\n\tif ( N <= 0 ) {\n\t\tout[ io ] = sum;\n\t\tout[ io+strideOut ] = 0;\n\t\treturn out;\n\t}\n\tif ( N === 1 || strideX === 0 ) {\n\t\tif ( isnan( x[ ix ] ) ) {\n\t\t\tout[ io ] = sum;\n\t\t\tout[ io+strideOut ] = 0;\n\t\t\treturn out;\n\t\t}\n\t\tout[ io ] = x[ ix ];\n\t\tout[ io+strideOut ] = 1;\n\t\treturn out;\n\t}\n\tn = 0;\n\tfor ( i = 0; i < N; i++ ) {\n\t\tif ( isnan( x[ ix ] ) === false ) {\n\t\t\tsum += x[ ix ];\n\t\t\tn += 1;\n\t\t}\n\t\tix += strideX;\n\t}\n\tout[ io ] = sum;\n\tout[ io+strideOut ] = n;\n\treturn out;\n}\n\n\n// EXPORTS //\n\nmodule.exports = dsnannsumors;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2020 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );\nvar dsnannsumors = require( './dsnannsumors.js' );\nvar ndarray = require( './ndarray.js' );\n\n\n// MAIN //\n\nsetReadOnly( dsnannsumors, 'ndarray', ndarray );\n\n\n// EXPORTS //\n\nmodule.exports = dsnannsumors;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2020 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n/**\n* Compute the sum of single-precision floating-point strided array elements, ignoring `NaN` values, using ordinary recursive summation with extended accumulation, and returning an extended precision result.\n*\n* @module @stdlib/blas-ext-base-dsnannsumors\n*\n* @example\n* var Float32Array = require( '@stdlib/array-float32' );\n* var Float64Array = require( '@stdlib/array-float64' );\n* var dsnannsumors = require( '@stdlib/blas-ext-base-dsnannsumors' );\n*\n* var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n* var out = new Float64Array( 2 );\n*\n* var v = dsnannsumors( x.length, x, 1, out, 1 );\n* // returns <Float64Array>[ 1.0, 3 ]\n*\n* @example\n* var Float32Array = require( '@stdlib/array-float32' );\n* var Float64Array = require( '@stdlib/array-float64' );\n* var floor = require( '@stdlib/math-base-special-floor' );\n* var dsnannsumors = require( '@stdlib/blas-ext-base-dsnannsumors' );\n*\n* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN, NaN ] );\n* var out = new Float64Array( 2 );\n*\n* var N = floor( x.length / 2 );\n*\n* var v = dsnannsumors.ndarray( N, x, 2, 1, out, 1, 0 );\n* // returns <Float64Array>[ 5.0, 4 ]\n*/\n\n// MODULES //\n\nvar join = require( 'path' ).join;\nvar tryRequire = require( '@stdlib/utils-try-require' );\nvar isError = require( '@stdlib/assert-is-error' );\nvar main = require( './main.js' );\n\n\n// MAIN //\n\nvar dsnannsumors;\nvar tmp = tryRequire( join( __dirname, './native.js' ) );\nif ( isError( tmp ) ) {\n\tdsnannsumors = main;\n} else {\n\tdsnannsumors = tmp;\n}\n\n\n// EXPORTS //\n\nmodule.exports = dsnannsumors;\n\n// exports: { \"ndarray\": \"dsnannsumors.ndarray\" }\n"],
-  "mappings": "uGAAA,IAAAA,EAAAC,EAAA,SAAAC,EAAAC,EAAA,cAsBA,IAAIC,EAAQ,QAAS,iCAAkC,EAyBvD,SAASC,EAAcC,EAAGC,EAAGC,EAASC,EAAKC,EAAY,CACtD,IAAIC,EACAC,EACAC,EACAC,EACA,EAaJ,GAXKN,EAAU,EACdI,GAAM,EAAEN,GAAKE,EAEbI,EAAK,EAEDF,EAAY,EAChBG,EAAK,CAACH,EAENG,EAAK,EAENF,EAAM,EACDL,GAAK,EACT,OAAAG,EAAKI,CAAG,EAAIF,EACZF,EAAKI,EAAGH,CAAU,EAAI,EACfD,EAER,GAAKH,IAAM,GAAKE,IAAY,EAC3B,OAAKJ,EAAOG,EAAGK,CAAG,CAAE,GACnBH,EAAKI,CAAG,EAAIF,EACZF,EAAKI,EAAGH,CAAU,EAAI,EACfD,IAERA,EAAKI,CAAG,EAAIN,EAAGK,CAAG,EAClBH,EAAKI,EAAGH,CAAU,EAAI,EACfD,GAGR,IADAK,EAAI,EACE,EAAI,EAAG,EAAIR,EAAG,IACdF,EAAOG,EAAGK,CAAG,CAAE,IAAM,KACzBD,GAAOJ,EAAGK,CAAG,EACbE,GAAK,GAENF,GAAMJ,EAEP,OAAAC,EAAKI,CAAG,EAAIF,EACZF,EAAKI,EAAGH,CAAU,EAAII,EACfL,CACR,CAKAN,EAAO,QAAUE,IChGjB,IAAAU,EAAAC,EAAA,SAAAC,EAAAC,EAAA,cAsBA,IAAIC,EAAQ,QAAS,iCAAkC,EA8BvD,SAASC,EAAcC,EAAGC,EAAGC,EAASC,EAASC,EAAKC,EAAWC,EAAY,CAC1E,IAAIC,EACAC,EACAC,EACAC,EACAC,EAMJ,GAJAH,EAAKL,EACLM,EAAKH,EAELC,EAAM,EACDP,GAAK,EACT,OAAAI,EAAKK,CAAG,EAAIF,EACZH,EAAKK,EAAGJ,CAAU,EAAI,EACfD,EAER,GAAKJ,IAAM,GAAKE,IAAY,EAC3B,OAAKJ,EAAOG,EAAGO,CAAG,CAAE,GACnBJ,EAAKK,CAAG,EAAIF,EACZH,EAAKK,EAAGJ,CAAU,EAAI,EACfD,IAERA,EAAKK,CAAG,EAAIR,EAAGO,CAAG,EAClBJ,EAAKK,EAAGJ,CAAU,EAAI,EACfD,GAGR,IADAM,EAAI,EACEC,EAAI,EAAGA,EAAIX,EAAGW,IACdb,EAAOG,EAAGO,CAAG,CAAE,IAAM,KACzBD,GAAON,EAAGO,CAAG,EACbE,GAAK,GAENF,GAAMN,EAEP,OAAAE,EAAKK,CAAG,EAAIF,EACZH,EAAKK,EAAGJ,CAAU,EAAIK,EACfN,CACR,CAKAP,EAAO,QAAUE,IC9FjB,IAAAa,EAAAC,EAAA,SAAAC,EAAAC,EAAA,cAsBA,IAAIC,EAAc,QAAS,uDAAwD,EAC/EC,EAAe,IACfC,EAAU,IAKdF,EAAaC,EAAc,UAAWC,CAAQ,EAK9CH,EAAO,QAAUE,ICmBjB,IAAIE,EAAO,QAAS,MAAO,EAAE,KACzBC,EAAa,QAAS,2BAA4B,EAClDC,EAAU,QAAS,yBAA0B,EAC7CC,EAAO,IAKPC,EACAC,EAAMJ,EAAYD,EAAM,UAAW,aAAc,CAAE,EAClDE,EAASG,CAAI,EACjBD,EAAeD,EAEfC,EAAeC,EAMhB,OAAO,QAAUD",
-  "names": ["require_dsnannsumors", "__commonJSMin", "exports", "module", "isnan", "dsnannsumors", "N", "x", "strideX", "out", "strideOut", "sum", "ix", "io", "n", "require_ndarray", "__commonJSMin", "exports", "module", "isnan", "dsnannsumors", "N", "x", "strideX", "offsetX", "out", "strideOut", "offsetOut", "sum", "ix", "io", "n", "i", "require_main", "__commonJSMin", "exports", "module", "setReadOnly", "dsnannsumors", "ndarray", "join", "tryRequire", "isError", "main", "dsnannsumors", "tmp"]
+  "sources": ["../lib/ndarray.js", "../lib/dsnannsumors.js", "../lib/main.js", "../lib/index.js"],
+  "sourcesContent": ["/**\n* @license Apache-2.0\n*\n* Copyright (c) 2020 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar isnan = require( '@stdlib/math-base-assert-is-nan' );\n\n\n// MAIN //\n\n/**\n* Computes the sum of single-precision floating-point strided array elements, ignoring `NaN` values, using ordinary recursive summation with extended accumulation, and returning an extended precision result.\n*\n* @param {PositiveInteger} N - number of indexed elements\n* @param {Float32Array} x - input array\n* @param {integer} strideX - `x` stride length\n* @param {NonNegativeInteger} offsetX - `x` starting index\n* @param {Float64Array} out - output array\n* @param {integer} strideOut - `out` stride length\n* @param {NonNegativeInteger} offsetOut - `out` starting index\n* @returns {Float64Array} output array\n*\n* @example\n* var Float32Array = require( '@stdlib/array-float32' );\n* var Float64Array = require( '@stdlib/array-float64' );\n*\n* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN, NaN ] );\n* var out = new Float64Array( 2 );\n*\n* var v = dsnannsumors( 5, x, 2, 1, out, 1, 0 );\n* // returns <Float64Array>[ 5.0, 4 ]\n*/\nfunction dsnannsumors( N, x, strideX, offsetX, out, strideOut, offsetOut ) {\n\tvar sum;\n\tvar ix;\n\tvar n;\n\tvar i;\n\n\tsum = 0.0;\n\tif ( N <= 0 ) {\n\t\tout[ offsetOut ] = sum;\n\t\tout[ offsetOut+strideOut ] = 0;\n\t\treturn out;\n\t}\n\tix = offsetX;\n\tif ( strideX === 0 ) {\n\t\tif ( isnan( x[ ix ] ) ) {\n\t\t\tout[ offsetOut ] = sum;\n\t\t\tout[ offsetOut+strideOut ] = 0;\n\t\t\treturn out;\n\t\t}\n\t\tout[ offsetOut ] = x[ ix ] * N;\n\t\tout[ offsetOut+strideOut ] = N;\n\t\treturn out;\n\t}\n\tn = 0;\n\tfor ( i = 0; i < N; i++ ) {\n\t\tif ( isnan( x[ ix ] ) === false ) {\n\t\t\tsum += x[ ix ];\n\t\t\tn += 1;\n\t\t}\n\t\tix += strideX;\n\t}\n\tout[ offsetOut ] = sum;\n\tout[ offsetOut+strideOut ] = n;\n\treturn out;\n}\n\n\n// EXPORTS //\n\nmodule.exports = dsnannsumors;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2020 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar stride2offset = require( '@stdlib/strided-base-stride2offset' );\nvar ndarray = require( './ndarray.js' );\n\n\n// MAIN //\n\n/**\n* Computes the sum of single-precision floating-point strided array elements, ignoring `NaN` values, using ordinary recursive summation with extended accumulation, and returning an extended precision result.\n*\n* @param {PositiveInteger} N - number of indexed elements\n* @param {Float32Array} x - input array\n* @param {integer} strideX - `x` stride length\n* @param {Float64Array} out - output array\n* @param {integer} strideOut - `out` stride length\n* @returns {Float64Array} output array\n*\n* @example\n* var Float32Array = require( '@stdlib/array-float32' );\n* var Float64Array = require( '@stdlib/array-float64' );\n*\n* var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n* var out = new Float64Array( 2 );\n*\n* var v = dsnannsumors( x.length, x, 1, out, 1 );\n* // returns <Float64Array>[ 1.0, 3 ]\n*/\nfunction dsnannsumors( N, x, strideX, out, strideOut ) {\n\tvar ix;\n\tvar io;\n\n\tix = stride2offset( N, strideX );\n\tio = stride2offset( 2, strideOut );\n\treturn ndarray( N, x, strideX, ix, out, strideOut, io );\n}\n\n\n// EXPORTS //\n\nmodule.exports = dsnannsumors;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2020 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n// MODULES //\n\nvar setReadOnly = require( '@stdlib/utils-define-nonenumerable-read-only-property' );\nvar dsnannsumors = require( './dsnannsumors.js' );\nvar ndarray = require( './ndarray.js' );\n\n\n// MAIN //\n\nsetReadOnly( dsnannsumors, 'ndarray', ndarray );\n\n\n// EXPORTS //\n\nmodule.exports = dsnannsumors;\n", "/**\n* @license Apache-2.0\n*\n* Copyright (c) 2020 The Stdlib Authors.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*    http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n\n'use strict';\n\n/**\n* Compute the sum of single-precision floating-point strided array elements, ignoring `NaN` values, using ordinary recursive summation with extended accumulation, and returning an extended precision result.\n*\n* @module @stdlib/blas-ext-base-dsnannsumors\n*\n* @example\n* var Float32Array = require( '@stdlib/array-float32' );\n* var Float64Array = require( '@stdlib/array-float64' );\n* var dsnannsumors = require( '@stdlib/blas-ext-base-dsnannsumors' );\n*\n* var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );\n* var out = new Float64Array( 2 );\n*\n* var v = dsnannsumors( x.length, x, 1, out, 1 );\n* // returns <Float64Array>[ 1.0, 3 ]\n*\n* @example\n* var Float32Array = require( '@stdlib/array-float32' );\n* var Float64Array = require( '@stdlib/array-float64' );\n* var dsnannsumors = require( '@stdlib/blas-ext-base-dsnannsumors' );\n*\n* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN, NaN ] );\n* var out = new Float64Array( 2 );\n*\n* var v = dsnannsumors.ndarray( 5, x, 2, 1, out, 1, 0 );\n* // returns <Float64Array>[ 5.0, 4 ]\n*/\n\n// MODULES //\n\nvar join = require( 'path' ).join;\nvar tryRequire = require( '@stdlib/utils-try-require' );\nvar isError = require( '@stdlib/assert-is-error' );\nvar main = require( './main.js' );\n\n\n// MAIN //\n\nvar dsnannsumors;\nvar tmp = tryRequire( join( __dirname, './native.js' ) );\nif ( isError( tmp ) ) {\n\tdsnannsumors = main;\n} else {\n\tdsnannsumors = tmp;\n}\n\n\n// EXPORTS //\n\nmodule.exports = dsnannsumors;\n\n// exports: { \"ndarray\": \"dsnannsumors.ndarray\" }\n"],
+  "mappings": "uGAAA,IAAAA,EAAAC,EAAA,SAAAC,EAAAC,EAAA,cAsBA,IAAIC,EAAQ,QAAS,iCAAkC,EA2BvD,SAASC,EAAcC,EAAGC,EAAGC,EAASC,EAASC,EAAKC,EAAWC,EAAY,CAC1E,IAAIC,EACAC,EACAC,EACAC,EAGJ,GADAH,EAAM,EACDP,GAAK,EACT,OAAAI,EAAKE,CAAU,EAAIC,EACnBH,EAAKE,EAAUD,CAAU,EAAI,EACtBD,EAGR,GADAI,EAAKL,EACAD,IAAY,EAChB,OAAKJ,EAAOG,EAAGO,CAAG,CAAE,GACnBJ,EAAKE,CAAU,EAAIC,EACnBH,EAAKE,EAAUD,CAAU,EAAI,EACtBD,IAERA,EAAKE,CAAU,EAAIL,EAAGO,CAAG,EAAIR,EAC7BI,EAAKE,EAAUD,CAAU,EAAIL,EACtBI,GAGR,IADAK,EAAI,EACEC,EAAI,EAAGA,EAAIV,EAAGU,IACdZ,EAAOG,EAAGO,CAAG,CAAE,IAAM,KACzBD,GAAON,EAAGO,CAAG,EACbC,GAAK,GAEND,GAAMN,EAEP,OAAAE,EAAKE,CAAU,EAAIC,EACnBH,EAAKE,EAAUD,CAAU,EAAII,EACtBL,CACR,CAKAP,EAAO,QAAUE,ICxFjB,IAAAY,EAAAC,EAAA,SAAAC,EAAAC,EAAA,cAsBA,IAAIC,EAAgB,QAAS,oCAAqC,EAC9DC,EAAU,IAyBd,SAASC,EAAcC,EAAGC,EAAGC,EAASC,EAAKC,EAAY,CACtD,IAAIC,EACAC,EAEJ,OAAAD,EAAKR,EAAeG,EAAGE,CAAQ,EAC/BI,EAAKT,EAAe,EAAGO,CAAU,EAC1BN,EAASE,EAAGC,EAAGC,EAASG,EAAIF,EAAKC,EAAWE,CAAG,CACvD,CAKAV,EAAO,QAAUG,IC5DjB,IAAAQ,EAAAC,EAAA,SAAAC,EAAAC,EAAA,cAsBA,IAAIC,EAAc,QAAS,uDAAwD,EAC/EC,EAAe,IACfC,EAAU,IAKdF,EAAaC,EAAc,UAAWC,CAAQ,EAK9CH,EAAO,QAAUE,ICgBjB,IAAIE,EAAO,QAAS,MAAO,EAAE,KACzBC,EAAa,QAAS,2BAA4B,EAClDC,EAAU,QAAS,yBAA0B,EAC7CC,EAAO,IAKPC,EACAC,EAAMJ,EAAYD,EAAM,UAAW,aAAc,CAAE,EAClDE,EAASG,CAAI,EACjBD,EAAeD,EAEfC,EAAeC,EAMhB,OAAO,QAAUD",
+  "names": ["require_ndarray", "__commonJSMin", "exports", "module", "isnan", "dsnannsumors", "N", "x", "strideX", "offsetX", "out", "strideOut", "offsetOut", "sum", "ix", "n", "i", "require_dsnannsumors", "__commonJSMin", "exports", "module", "stride2offset", "ndarray", "dsnannsumors", "N", "x", "strideX", "out", "strideOut", "ix", "io", "require_main", "__commonJSMin", "exports", "module", "setReadOnly", "dsnannsumors", "ndarray", "join", "tryRequire", "isError", "main", "dsnannsumors", "tmp"]
 }

package/docs/types/index.d.ts

@@ -63,7 +63,7 @@ interface Routine {
 	* var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );
 	* var out = new Float64Array( 2 );
 	*
-	* var v = dsnannsumors( x.length, x, 1, 0, out, 1, 0 );
+	* var v = dsnannsumors.ndarray( x.length, x, 1, 0, out, 1, 0 );
 	* // returns <Float64Array>[ 1.0, 3 ]
 	*/
 	ndarray( N: number, x: Float32Array, strideX: number, offsetX: number, out: Float64Array, strideOut: number, offsetOut: number ): Float64Array;
@@ -96,7 +96,7 @@ interface Routine {
 * var x = new Float32Array( [ 1.0, -2.0, NaN, 2.0 ] );
 * var out = new Float64Array( 2 );
 *
-* var v = dsnannsumors( x.length, x, 1, 0, out, 1, 0 );
+* var v = dsnannsumors.ndarray( x.length, x, 1, 0, out, 1, 0 );
 * // returns <Float64Array>[ 1.0, 3 ]
 */
 declare var dsnannsumors: Routine;

package/include/stdlib/blas/ext/base/dsnannsumors.h

@@ -16,13 +16,10 @@
 * limitations under the License.
 */
 
-/**
-* Header file containing function declarations.
-*/
 #ifndef STDLIB_BLAS_EXT_BASE_DSNANNSUMORS_H
 #define STDLIB_BLAS_EXT_BASE_DSNANNSUMORS_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.
@@ -34,7 +31,12 @@ extern "C" {
 /**
 * Computes the sum of single-precision floating-point strided array elements, ignoring `NaN` values, using ordinary recursive summation with extended accumulation, and returning an extended precision result.
 */
-double stdlib_strided_dsnannsumors( const int64_t N, const float *X, const int64_t stride, int64_t *n );
+double API_SUFFIX(stdlib_strided_dsnannsumors)( const CBLAS_INT N, const float *X, const CBLAS_INT strideX, CBLAS_INT *n );
+
+/**
+* Computes the sum of single-precision floating-point strided array elements, ignoring `NaN` values, using ordinary recursive summation with extended accumulation and alternative indexing semantics, and returning an extended precision result.
+*/
+double API_SUFFIX(stdlib_strided_dsnannsumors_ndarray)( const CBLAS_INT N, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, CBLAS_INT *n );
 
 #ifdef __cplusplus
 }

package/lib/dsnannsumors.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 //
@@ -46,49 +47,12 @@ var isnan = require( '@stdlib/math-base-assert-is-nan' );
 * // returns <Float64Array>[ 1.0, 3 ]
 */
 function dsnannsumors( 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;
-	}
-	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;
+	ix = stride2offset( N, strideX );
+	io = stride2offset( 2, strideOut );
+	return ndarray( N, x, strideX, ix, out, strideOut, io );
 }
 
 

package/lib/index.js

@@ -37,15 +37,12 @@
 * @example
 * var Float32Array = require( '@stdlib/array-float32' );
 * var Float64Array = require( '@stdlib/array-float64' );
-* var floor = require( '@stdlib/math-base-special-floor' );
 * var dsnannsumors = require( '@stdlib/blas-ext-base-dsnannsumors' );
 *
 * var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0, NaN, NaN ] );
 * var out = new Float64Array( 2 );
 *
-* var N = floor( x.length / 2 );
-*
-* var v = dsnannsumors.ndarray( N, x, 2, 1, out, 1, 0 );
+* var v = dsnannsumors.ndarray( 5, x, 2, 1, out, 1, 0 );
 * // returns <Float64Array>[ 5.0, 4 ]
 */
 

package/lib/ndarray.js

@@ -40,40 +40,34 @@ var isnan = require( '@stdlib/math-base-assert-is-nan' );
 * @example
 * var Float32Array = require( '@stdlib/array-float32' );
 * var Float64Array = require( '@stdlib/array-float64' );
-* 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, NaN, NaN ] );
 * var out = new Float64Array( 2 );
 *
-* var N = floor( x.length / 2 );
-*
-* var v = dsnannsumors( N, x, 2, 1, out, 1, 0 );
+* var v = dsnannsumors( 5, x, 2, 1, out, 1, 0 );
 * // returns <Float64Array>[ 5.0, 4 ]
 */
 function dsnannsumors( N, x, strideX, offsetX, out, strideOut, offsetOut ) {
 	var sum;
 	var ix;
-	var io;
 	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;
 	}
 	n = 0;
@@ -84,8 +78,8 @@ function dsnannsumors( N, x, strideX, offsetX, out, strideOut, offsetOut ) {
 		}
 		ix += strideX;
 	}
-	out[ io ] = sum;
-	out[ io+strideOut ] = n;
+	out[ offsetOut ] = sum;
+	out[ offsetOut+strideOut ] = n;
 	return out;
 }
 

package/lib/ndarray.native.js

@@ -20,9 +20,7 @@
 
 // MODULES //
 
-var Float32Array = require( '@stdlib/array-float32' );
-var Float64Array = require( '@stdlib/array-float64' );
-var addon = require( './dsnannsumors.native.js' );
+var addon = require( './../src/addon.node' );
 
 
 // MAIN //
@@ -42,28 +40,15 @@ var addon = require( './dsnannsumors.native.js' );
 * @example
 * var Float32Array = require( '@stdlib/array-float32' );
 * var Float64Array = require( '@stdlib/array-float64' );
-* 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, NaN, NaN ] );
 * var out = new Float64Array( 2 );
 *
-* var N = floor( x.length / 2 );
-*
-* var v = dsnannsumors( N, x, 2, 1, out, 1, 0 );
+* var v = dsnannsumors( 5, x, 2, 1, out, 1, 0 );
 * // returns <Float64Array>[ 5.0, 4 ]
 */
 function dsnannsumors( N, x, strideX, offsetX, out, strideOut, offsetOut ) {
-	var viewOut;
-	var viewX;
-	if ( strideX < 0 ) {
-		offsetX += (N-1) * strideX;
-	}
-	if ( strideOut < 0 ) {
-		offsetOut += strideOut;
-	}
-	viewX = new Float32Array( x.buffer, x.byteOffset+(x.BYTES_PER_ELEMENT*offsetX), x.length-offsetX ); // eslint-disable-line max-len
-	viewOut = new Float64Array( out.buffer, out.byteOffset+(out.BYTES_PER_ELEMENT*offsetOut), out.length-offsetOut ); // eslint-disable-line max-len
-	addon( N, viewX, strideX, viewOut, strideOut );
+	addon.ndarray( N, x, strideX, offsetX, out, strideOut, offsetOut );
 	return out;
 }
 

package/manifest.json

@@ -1,42 +1,82 @@
 {
-	"options": {},
-	"fields": [
-		{
-			"field": "src",
-			"resolve": true,
-			"relative": true
-		},
-		{
-			"field": "include",
-			"resolve": true,
-			"relative": true
-		},
-		{
-			"field": "libraries",
-			"resolve": false,
-			"relative": false
-		},
-		{
-			"field": "libpath",
-			"resolve": true,
-			"relative": false
-		}
-	],
-	"confs": [
-		{
-			"src": [
-				"./src/dsnannsumors.c"
-			],
-			"include": [
-				"./include"
-			],
-			"libraries": [
-				"-lm"
-			],
-			"libpath": [],
-			"dependencies": [
-				"@stdlib/math-base-assert-is-nanf"
-			]
-		}
-	]
+  "options": {
+    "task": "build"
+  },
+  "fields": [
+    {
+      "field": "src",
+      "resolve": true,
+      "relative": true
+    },
+    {
+      "field": "include",
+      "resolve": true,
+      "relative": true
+    },
+    {
+      "field": "libraries",
+      "resolve": false,
+      "relative": false
+    },
+    {
+      "field": "libpath",
+      "resolve": true,
+      "relative": false
+    }
+  ],
+  "confs": [
+    {
+      "task": "build",
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/napi-export",
+        "@stdlib/napi-argv",
+        "@stdlib/napi-argv-int64",
+        "@stdlib/napi-argv-strided-float32array",
+        "@stdlib/napi-argv-strided-float64array",
+        "@stdlib/math-base-assert-is-nanf",
+        "@stdlib/blas-base-shared",
+        "@stdlib/strided-base-stride2offset"
+      ]
+    },
+    {
+      "task": "benchmark",
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/math-base-assert-is-nanf",
+        "@stdlib/blas-base-shared",
+        "@stdlib/strided-base-stride2offset"
+      ]
+    },
+    {
+      "task": "examples",
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/math-base-assert-is-nanf",
+        "@stdlib/blas-base-shared",
+        "@stdlib/strided-base-stride2offset"
+      ]
+    }
+  ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stdlib/blas-ext-base-dsnannsumors",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Calculate the sum of single-precision floating-point strided array elements, ignoring NaN values, using ordinary recursive summation with extended accumulation, and returning an extended precision result.",
   "license": "Apache-2.0",
   "author": {
@@ -35,10 +35,17 @@
   },
   "dependencies": {
     "@stdlib/assert-is-error": "^0.2.2",
-    "@stdlib/math-base-assert-is-nan": "^0.2.1",
+    "@stdlib/blas-base-shared": "^0.1.0",
+    "@stdlib/math-base-assert-is-nan": "^0.2.2",
     "@stdlib/math-base-assert-is-nanf": "^0.2.2",
+    "@stdlib/napi-argv": "^0.2.2",
+    "@stdlib/napi-argv-int64": "^0.2.2",
+    "@stdlib/napi-argv-strided-float32array": "^0.2.2",
+    "@stdlib/napi-argv-strided-float64array": "^0.2.2",
+    "@stdlib/napi-export": "^0.3.0",
+    "@stdlib/strided-base-stride2offset": "^0.1.0",
     "@stdlib/utils-define-nonenumerable-read-only-property": "^0.2.2",
-    "@stdlib/utils-library-manifest": "^0.2.1",
+    "@stdlib/utils-library-manifest": "^0.2.3",
     "@stdlib/utils-try-require": "^0.2.2"
   },
   "devDependencies": {},
@@ -79,7 +86,6 @@
     "single",
     "float32array"
   ],
-  "__stdlib__": {},
   "funding": {
     "type": "opencollective",
     "url": "https://opencollective.com/stdlib"

package/src/addon.c

@@ -0,0 +1,79 @@
+/**
+* @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/dsnannsumors.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_float32array.h"
+#include "stdlib/napi/argv_strided_float64array.h"
+#include "stdlib/strided/base/stride2offset.h"
+#include <stdint.h>
+#include <node_api.h>
+
+/**
+* Receives JavaScript callback invocation data.
+*
+* @private
+* @param env    environment under which the function is invoked
+* @param info   callback data
+* @return       Node-API value
+*/
+static napi_value addon( napi_env env, napi_callback_info info ) {
+	STDLIB_NAPI_ARGV( env, info, argv, argc, 5 );
+	STDLIB_NAPI_ARGV_INT64( env, N, argv, 0 );
+	STDLIB_NAPI_ARGV_INT64( env, strideX, argv, 2 );
+	STDLIB_NAPI_ARGV_INT64( env, strideOut, argv, 4 );
+	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, X, N, strideX, argv, 1 );
+	STDLIB_NAPI_ARGV_STRIDED_FLOAT64ARRAY( env, Out, 2, strideOut, argv, 3 );
+
+	int64_t io = stdlib_strided_stride2offset( 2, strideOut );
+	CBLAS_INT n;
+	Out[ io ] = API_SUFFIX(stdlib_strided_dsnannsumors)( N, X, strideX, &n );
+	Out[ io + strideOut ] = (double)n;
+
+	return NULL;
+}
+
+/**
+* Receives JavaScript callback invocation data.
+*
+* @private
+* @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_FLOAT32ARRAY( 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_dsnannsumors_ndarray)( N, X, strideX, offsetX, &n );
+	Out[ offsetOut + strideOut ] = (double)n;
+
+	return NULL;
+}
+
+STDLIB_NAPI_MODULE_EXPORT_FCN_WITH_METHOD( addon, "ndarray", addon_method )

package/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/dsnannsumors.h"
+#include "stdlib/strided/base/stride2offset.h"
+#include "stdlib/math/base/assert/is_nanf.h"
+#include "stdlib/blas/base/shared.h"
+
+/**
+* Computes the sum of single-precision floating-point strided array elements, ignoring `NaN` values, using ordinary recursive summation with extended accumulation, and returning an extended precision result.
+*
+* @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_dsnannsumors)( const CBLAS_INT N, const float *X, const CBLAS_INT strideX, CBLAS_INT *n ) {
+	CBLAS_INT ox = stdlib_strided_stride2offset( N, strideX );
+	return API_SUFFIX(stdlib_strided_dsnannsumors_ndarray)( N, X, strideX, ox, n );
+}
+
+/**
+* Computes the sum of single-precision floating-point strided array elements, ignoring `NaN` values, using ordinary recursive summation with extended accumulation and alternative indexing semantics, and returning an extended precision result.
+*
+* @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_dsnannsumors_ndarray)( const CBLAS_INT N, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, CBLAS_INT *n ) {
+	CBLAS_INT ix;
+	CBLAS_INT i;
+	double sum;
+
+	sum = 0.0;
+	*n = 0;
+	if ( N <= 0 ) {
+		return sum;
+	}
+	ix = offsetX;
+	if ( strideX == 0 ) {
+		if ( stdlib_base_is_nanf( X[ ix ] ) ) {
+			return sum;
+		}
+		*n += N;
+		return X[ ix ] * N;
+	}
+	for ( i = 0; i < N; i++ ) {
+		if ( !stdlib_base_is_nanf( X[ ix ] ) ) {
+			sum += (double)X[ ix ];
+			*n += 1;
+		}
+		ix += strideX;
+	}
+	return sum;
+}

package/src/addon.cpp

@@ -1,162 +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/dsnannsumors.h"
-#include <node_api.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <assert.h>
-
-/**
-* Add-on namespace.
-*/
-namespace stdlib_blas_ext_base_dsnannsumors {
-
-	/**
-	* Computes the sum of single-precision floating-point strided array elements, ignoring `NaN` values, using ordinary recursive summation with extended accumulation, and returning an extended precision result.
-	*
-	* ## Notes
-	*
-	* -   When called from JavaScript, the function expects five arguments:
-	*
-	*     -   `N`: number of indexed elements
-	*     -   `X`: input array
-	*     -   `strideX`: `X` stride length
-	*     -   `Out`: output array
-	*     -   `strideOut`: `Out` stride length
-	*/
-	napi_value node_dsnannsumors( napi_env env, napi_callback_info info ) {
-		napi_status status;
-
-		size_t argc = 5;
-		napi_value argv[ 5 ];
-		status = napi_get_cb_info( env, info, &argc, argv, nullptr, nullptr );
-		assert( status == napi_ok );
-
-		if ( argc < 5 ) {
-			napi_throw_error( env, nullptr, "invalid invocation. Must provide 5 arguments." );
-			return nullptr;
-		}
-
-		napi_valuetype vtype0;
-		status = napi_typeof( env, argv[ 0 ], &vtype0 );
-		assert( status == napi_ok );
-		if ( vtype0 != napi_number ) {
-			napi_throw_type_error( env, nullptr, "invalid argument. First argument must be a number." );
-			return nullptr;
-		}
-
-		bool res1;
-		status = napi_is_typedarray( env, argv[ 1 ], &res1 );
-		assert( status == napi_ok );
-		if ( res1 == false ) {
-			napi_throw_type_error( env, nullptr, "invalid argument. Second argument must be a Float32Array." );
-			return nullptr;
-		}
-
-		napi_valuetype vtype2;
-		status = napi_typeof( env, argv[ 2 ], &vtype2 );
-		assert( status == napi_ok );
-		if ( vtype2 != napi_number ) {
-			napi_throw_type_error( env, nullptr, "invalid argument. Third argument must be a number." );
-			return nullptr;
-		}
-
-		bool res3;
-		status = napi_is_typedarray( env, argv[ 3 ], &res3 );
-		assert( status == napi_ok );
-		if ( res3 == false ) {
-			napi_throw_type_error( env, nullptr, "invalid argument. Fourth argument must be a Float64Array." );
-			return nullptr;
-		}
-
-		napi_valuetype vtype4;
-		status = napi_typeof( env, argv[ 4 ], &vtype4 );
-		assert( status == napi_ok );
-		if ( vtype4 != napi_number ) {
-			napi_throw_type_error( env, nullptr, "invalid argument. Fifth argument must be a number." );
-			return nullptr;
-		}
-
-		int64_t N;
-		status = napi_get_value_int64( env, argv[ 0 ], &N );
-		assert( status == napi_ok );
-
-		int64_t strideX;
-		status = napi_get_value_int64( env, argv[ 2 ], &strideX );
-		assert( status == napi_ok );
-
-		int64_t strideOut;
-		status = napi_get_value_int64( env, argv[ 4 ], &strideOut );
-		assert( status == napi_ok );
-
-		napi_typedarray_type vtype1;
-		size_t xlen;
-		void *X;
-		status = napi_get_typedarray_info( env, argv[ 1 ], &vtype1, &xlen, &X, nullptr, nullptr );
-		assert( status == napi_ok );
-		if ( vtype1 != napi_float32_array ) {
-			napi_throw_type_error( env, nullptr, "invalid argument. Second argument must be a Float32Array." );
-			return nullptr;
-		}
-		if ( (N-1)*llabs(strideX) >= (int64_t)xlen ) {
-			napi_throw_range_error( env, nullptr, "invalid argument. Second argument has insufficient elements based on the associated stride and the number of indexed elements." );
-			return nullptr;
-		}
-
-		napi_typedarray_type vtype3;
-		size_t olen;
-		void *Out;
-		status = napi_get_typedarray_info( env, argv[ 3 ], &vtype3, &olen, &Out, nullptr, nullptr );
-		assert( status == napi_ok );
-		if ( vtype3 != napi_float64_array ) {
-			napi_throw_type_error( env, nullptr, "invalid argument. Fourth argument must be a Float64Array." );
-			return nullptr;
-		}
-		if ( llabs(strideOut) > (int64_t)olen ) {
-			napi_throw_range_error( env, nullptr, "invalid argument. Fourth argument has insufficient elements based on the associated stride and the required number of output elements." );
-			return nullptr;
-		}
-
-		int64_t io;
-		if ( strideOut < 0 ) {
-			io = -strideOut;
-		} else {
-			io = 0;
-		}
-
-		double *out = (double *)Out;
-		int64_t n;
-		out[ io ] = stdlib_strided_dsnannsumors( N, (float *)X, strideX, &n );
-		out[ io+strideOut ] = (double)n;
-
-		return nullptr;
-
-	}
-
-	napi_value Init( napi_env env, napi_value exports ) {
-		napi_status status;
-		napi_value fcn;
-		status = napi_create_function( env, "exports", NAPI_AUTO_LENGTH, node_dsnannsumors, NULL, &fcn );
-		assert( status == napi_ok );
-		return fcn;
-	}
-
-	NAPI_MODULE( NODE_GYP_MODULE_NAME, Init )
-} // end namespace stdlib_blas_ext_base_dsnannsumors

package/src/dsnannsumors.c

@@ -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/dsnannsumors.h"
-#include "stdlib/math/base/assert/is_nanf.h"
-#include <stdint.h>
-
-/**
-* Computes the sum of single-precision floating-point strided array elements, ignoring `NaN` values, using ordinary recursive summation with extended accumulation, and returning an extended precision result.
-*
-* @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_dsnannsumors( const int64_t N, const float *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_nanf( 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_nanf( X[ ix ] ) ) {
-			sum += (double)X[ ix ];
-			*n += 1;
-		}
-		ix += stride;
-	}
-	return sum;
-}