From a113ea9a3ca9ed099030e80fd19f6c9bd0aa2eba Mon Sep 17 00:00:00 2001
From: kaustubh <kaustubh.mp007@gmail.com>
Date: Sat, 27 Dec 2025 17:30:14 +0530
Subject: [PATCH 1/9] feat: add blas/ext/base/snancusumkbn

---
 .../blas/ext/base/snancusumkbn/README.md      | 340 ++++++++++++++++
 .../base/snancusumkbn/benchmark/benchmark.js  | 114 ++++++
 .../benchmark/benchmark.native.js             | 119 ++++++
 .../benchmark/benchmark.ndarray.js            | 114 ++++++
 .../benchmark/benchmark.ndarray.native.js     | 119 ++++++
 .../base/snancusumkbn/benchmark/c/Makefile    | 146 +++++++
 .../benchmark/c/benchmark.length.c            | 213 ++++++++++
 .../blas/ext/base/snancusumkbn/binding.gyp    | 170 ++++++++
 .../blas/ext/base/snancusumkbn/docs/repl.txt  | 121 ++++++
 .../base/snancusumkbn/docs/types/index.d.ts   | 106 +++++
 .../ext/base/snancusumkbn/docs/types/test.ts  | 280 ++++++++++++++
 .../ext/base/snancusumkbn/examples/c/Makefile | 146 +++++++
 .../base/snancusumkbn/examples/c/example.c    |  41 ++
 .../ext/base/snancusumkbn/examples/index.js   |  41 ++
 .../blas/ext/base/snancusumkbn/include.gypi   |  53 +++
 .../stdlib/blas/ext/base/snancusumkbn.h       |  45 +++
 .../blas/ext/base/snancusumkbn/lib/index.js   |  70 ++++
 .../blas/ext/base/snancusumkbn/lib/main.js    |  35 ++
 .../blas/ext/base/snancusumkbn/lib/native.js  |  35 ++
 .../blas/ext/base/snancusumkbn/lib/ndarray.js | 114 ++++++
 .../base/snancusumkbn/lib/ndarray.native.js   |  58 +++
 .../ext/base/snancusumkbn/lib/snancusumkbn.js |  65 ++++
 .../snancusumkbn/lib/snancusumkbn.native.js   |  56 +++
 .../blas/ext/base/snancusumkbn/manifest.json  |  85 ++++
 .../blas/ext/base/snancusumkbn/package.json   |  83 ++++
 .../blas/ext/base/snancusumkbn/src/Makefile   |  70 ++++
 .../blas/ext/base/snancusumkbn/src/addon.c    |  68 ++++
 .../blas/ext/base/snancusumkbn/src/main.c     | 127 ++++++
 .../blas/ext/base/snancusumkbn/test/test.js   |  82 ++++
 .../base/snancusumkbn/test/test.ndarray.js    | 357 +++++++++++++++++
 .../snancusumkbn/test/test.ndarray.native.js  | 366 ++++++++++++++++++
 .../snancusumkbn/test/test.snancusumkbn.js    | 304 +++++++++++++++
 .../test/test.snancusumkbn.native.js          | 313 +++++++++++++++
 33 files changed, 4456 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/README.md
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/Makefile
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/benchmark.length.c
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/binding.gyp
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/repl.txt
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/index.d.ts
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/test.ts
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/Makefile
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/example.c
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/index.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include.gypi
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include/stdlib/blas/ext/base/snancusumkbn.h
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/index.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/main.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/native.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.native.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.native.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/manifest.json
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/package.json
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/Makefile
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/main.c
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.native.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.native.js

diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/README.md b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/README.md
new file mode 100644
index 000000000000..27b1db49f968
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/README.md
@@ -0,0 +1,340 @@
+<!--
+
+@license Apache-2.0
+
+Copyright (c) 2025 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.
+
+-->
+
+# snancusumkbn
+
+> Calculate the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+
+<section class="intro">
+
+</section>
+
+<!-- /.intro -->
+
+<section class="usage">
+
+## Usage
+
+```javascript
+var snancusumkbn = require( '@stdlib/blas/ext/base/snancusumkbn' );
+```
+
+#### snancusumkbn( N, sum, x, strideX, y, strideY )
+
+Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+
+```javascript
+var Float32Array = require( '@stdlib/array/float32' );
+
+var x = new Float32Array( [ 1.0, -2.0, NaN ] );
+var y = new Float32Array( x.length );
+
+snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+// y => <Float32Array>[ 1.0, -1.0, -1.0 ]
+
+x = new Float32Array( [ 1.0, -2.0, NaN ] );
+y = new Float32Array( x.length );
+
+snancusumkbn( x.length, 10.0, x, 1, y, 1 );
+// y => <Float32Array>[ 11.0, 9.0, 9.0 ]
+```
+
+The function has the following parameters:
+
+-   **N**: number of indexed elements.
+-   **sum**: initial sum.
+-   **x**: input [`Float32Array`][@stdlib/array/float32].
+-   **strideX**: stride length for `x`.
+-   **y**: output [`Float32Array`][@stdlib/array/float32].
+-   **strideY**: stride length for `y`.
+
+The `N` and stride parameters determine which elements in the strided arrays are accessed at runtime. For example, to compute the cumulative sum of every other element:
+
+```javascript
+var Float32Array = require( '@stdlib/array/float32' );
+
+var x = new Float32Array( [ 1.0, 2.0, 2.0, -7.0, -2.0, 3.0, NaN, NaN ] );
+var y = new Float32Array( x.length );
+
+var v = snancusumkbn( 4, 0.0, x, 2, y, 1 );
+// y => <Float32Array>[ 1.0, 3.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0 ]
+```
+
+Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
+
+<!-- eslint-disable stdlib/capitalized-comments -->
+
+```javascript
+var Float32Array = require( '@stdlib/array/float32' );
+
+// Initial arrays...
+var x0 = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, NaN, NaN ] );
+var y0 = new Float32Array( x0.length );
+
+// Create offset views...
+var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+var y1 = new Float32Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 ); // start at 4th element
+
+snancusumkbn( 4, 0.0, x1, -2, y1, 1 );
+// y0 => <Float32Array>[ 0.0, 0.0, 0.0, 0.0, 2.0, 0.0, 1.0, 0.0 ]
+```
+
+#### snancusumkbn.ndarray( N, sum, x, strideX, offsetX, y, strideY, offsetY )
+
+Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm and alternative indexing semantics.
+
+```javascript
+var Float32Array = require( '@stdlib/array/float32' );
+
+var x = new Float32Array( [ 1.0, -2.0, NaN ] );
+var y = new Float32Array( x.length );
+
+snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 );
+// y => <Float32Array>[ 1.0, -1.0, -1.0 ]
+```
+
+The function has the following additional parameters:
+
+-   **offsetX**: starting index for `x`.
+-   **offsetY**: starting index for `y`.
+
+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 cumulative sum of every other element in the strided input array starting from the second element and to store in the last `N` elements of the strided output array starting from the last element:
+
+```javascript
+var Float32Array = require( '@stdlib/array/float32' );
+
+var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, NaN, NaN ] );
+var y = new Float32Array( x.length );
+
+snancusumkbn.ndarray( 4, 0.0, x, 2, 1, y, -1, y.length-1 );
+// y => <Float32Array>[ 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, -1.0, 1.0 ]
+```
+
+</section>
+
+<!-- /.usage -->
+
+<section class="notes">
+
+## Notes
+
+-   If `N <= 0`, both functions return `y` unchanged.
+
+</section>
+
+<!-- /.notes -->
+
+<section class="examples">
+
+## Examples
+
+<!-- eslint no-undef: "error" -->
+
+```javascript
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var zeros = require( '@stdlib/array/zeros' );
+var snancusumkbn = require( '@stdlib/blas/ext/base/snancusumkbn' );
+
+function rand() {
+    if ( bernoulli( 0.7 ) > 0 ) {
+        return discreteUniform( 0, 100 );
+    }
+    return NaN;
+}
+
+var x = filledarrayBy( 10, 'float32', rand );
+console.log( x );
+
+var y = zeros( 10, 'float32' );
+console.log( y );
+
+snancusumkbn( x.length, 0.0, x, 1, y, -1 );
+console.log( y );
+```
+
+</section>
+
+<!-- /.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/snancusumkbn.h"
+```
+
+#### stdlib_strided_snancusumkbn( N, sum, \*X, strideX, \*Y, strideY )
+
+Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+
+```c
+const float x[] = { 1.0f, 2.0f, 3.0f, 4.0f };
+float y[] = { 0.0f, 0.0f, 0.0f, 0.0f };
+
+stdlib_strided_snancusumkbn( 4, 0.0f, x, 1, y, 1 );
+```
+
+The function accepts the following arguments:
+
+-   **N**: `[in] CBLAS_INT` number of indexed elements.
+-   **sum**: `[in] float` initial sum.
+-   **X**: `[in] float*` input array.
+-   **strideX**: `[in] CBLAS_INT` stride length for `X`.
+-   **Y**: `[out] float*` output array.
+-   **strideY**: `[in] CBLAS_INT` stride length for `Y`.
+
+```c
+void stdlib_strided_snancusumkbn( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, float *Y, const CBLAS_INT strideY );
+```
+
+<!-- lint disable maximum-heading-length -->
+
+#### stdlib_strided_snancusumkbn_ndarray( N, sum, \*X, strideX, offsetX, \*Y, strideY, offsetY )
+
+<!-- lint enable maximum-heading-length -->
+
+Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm and alternative indexing semantics.
+
+```c
+const float x[] = { 1.0f, 2.0f, 3.0f, 4.0f };
+float y[] = { 0.0f, 0.0f, 0.0f, 0.0f };
+
+stdlib_strided_snancusumkbn_ndarray( 4, 0.0f, x, 1, 0, y, 1, 0 );
+```
+
+The function accepts the following arguments:
+
+-   **N**: `[in] CBLAS_INT` number of indexed elements.
+-   **sum**: `[in] float` initial sum.
+-   **X**: `[in] float*` input array.
+-   **strideX**: `[in] CBLAS_INT` stride length for `X`.
+-   **offsetX**: `[in] CBLAS_INT` starting index for `X`.
+-   **Y**: `[out] float*` output array.
+-   **strideY**: `[in] CBLAS_INT` stride length for `Y`.
+-   **offsetY**: `[in] CBLAS_INT` starting index for `Y`.
+
+```c
+void stdlib_strided_snancusumkbn_ndarray( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, float *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY );
+```
+
+</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/snancusumkbn.h"
+#include <stdio.h>
+
+int main( void ) {
+    // Create strided arrays:
+    const float x[] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 0.0f/0.0f, 0.0f/0.0f };
+    float y[] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
+
+    // Specify the number of elements:
+    const int N = 4;
+
+    // Specify stride lengths:
+    const int strideX = 2;
+    const int strideY = -2;
+
+    // Compute the cumulative sum:
+    stdlib_strided_snancusumkbn( N, 0.0f, x, strideX, y, strideY );
+
+    // Print the result:
+    for ( int i = 0; i < 8; i++ ) {
+        printf( "y[ %d ] = %f\n", i, y[ i ] );
+    }
+}
+```
+
+</section>
+
+<!-- /.examples -->
+
+</section>
+
+<!-- /.c -->
+
+<section class="references">
+
+## 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][@neumaier:1974a].
+
+</section>
+
+<!-- /.references -->
+
+<!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
+
+<section class="related">
+
+</section>
+
+<!-- /.related -->
+
+<!-- Section for all links. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="links">
+
+[@stdlib/array/float32]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/float32
+
+[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
+
+[@neumaier:1974a]: https://doi.org/10.1002/zamm.19740540106
+
+</section>
+
+<!-- /.links -->
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js
new file mode 100644
index 000000000000..778ad2137e4b
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js
@@ -0,0 +1,114 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var uniform = require( '@stdlib/random/base/uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var zeros = require( '@stdlib/array/zeros' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var pkg = require( './../package.json' ).name;
+var snancusumkbn = require( './../lib/snancusumkbn.js' );
+
+
+// VARIABLES //
+
+var options = {
+	'dtype': 'float32'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Returns a random number.
+*
+* @private
+* @returns {number} random number
+*/
+function rand() {
+	if ( bernoulli( 0.8 ) > 0 ) {
+		return uniform( -100.0, 100.0 );
+	}
+	return NaN;
+}
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+	var x = filledarrayBy( len, options.dtype, rand );
+	var y = zeros( len, options.dtype );
+	return benchmark;
+
+	function benchmark( b ) {
+		var v;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			x[ 0 ] += 1.0;
+			v = snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+			if ( isnanf( v[ i % len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnanf( v[ i % len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var f;
+	var i;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( i = min; i <= max; i++ ) {
+		len = pow( 10, i );
+		f = createBenchmark( len );
+		bench( pkg+':len='+len, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js
new file mode 100644
index 000000000000..1f450baa6464
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js
@@ -0,0 +1,119 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var resolve = require( 'path' ).resolve;
+var bench = require( '@stdlib/bench' );
+var uniform = require( '@stdlib/random/base/uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var zeros = require( '@stdlib/array/zeros' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var tryRequire = require( '@stdlib/utils/try-require' );
+var pkg = require( './../package.json' ).name;
+
+
+// VARIABLES //
+
+var options = {
+	'dtype': 'float32'
+};
+var snancusumkbn = tryRequire( resolve( __dirname, './../lib/snancusumkbn.native.js' ) );
+var opts = {
+	'skip': ( snancusumkbn instanceof Error )
+};
+
+
+// FUNCTIONS //
+
+/**
+* Returns a random number.
+*
+* @private
+* @returns {number} random number
+*/
+function rand() {
+	if ( bernoulli( 0.8 ) > 0 ) {
+		return uniform( -100.0, 100.0 );
+	}
+	return NaN;
+}
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+	var x = filledarrayBy( len, options.dtype, rand );
+	var y = zeros( len, options.dtype );
+	return benchmark;
+
+	function benchmark( b ) {
+		var v;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			x[ 0 ] += 1.0;
+			v = snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+			if ( isnanf( v[ i % len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnanf( v[ i % len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var f;
+	var i;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( i = min; i <= max; i++ ) {
+		len = pow( 10, i );
+		f = createBenchmark( len );
+		bench( pkg+'::native:len='+len, opts, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js
new file mode 100644
index 000000000000..657c033b19d8
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js
@@ -0,0 +1,114 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var uniform = require( '@stdlib/random/base/uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var zeros = require( '@stdlib/array/zeros' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var pkg = require( './../package.json' ).name;
+var snancusumkbn = require( './../lib/ndarray.js' );
+
+
+// VARIABLES //
+
+var options = {
+	'dtype': 'float32'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Returns a random number.
+*
+* @private
+* @returns {number} random number
+*/
+function rand() {
+	if ( bernoulli( 0.8 ) > 0 ) {
+		return uniform( -100.0, 100.0 );
+	}
+	return NaN;
+}
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+	var x = filledarrayBy( len, options.dtype, rand );
+	var y = zeros( len, options.dtype );
+	return benchmark;
+
+	function benchmark( b ) {
+		var v;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			x[ 0 ] += 1.0;
+			v = snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+			if ( isnanf( v[ i % len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnanf( v[ i % len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var f;
+	var i;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( i = min; i <= max; i++ ) {
+		len = pow( 10, i );
+		f = createBenchmark( len );
+		bench( pkg+':ndarray:len='+len, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js
new file mode 100644
index 000000000000..9eba60dc5a6c
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js
@@ -0,0 +1,119 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var resolve = require( 'path' ).resolve;
+var bench = require( '@stdlib/bench' );
+var uniform = require( '@stdlib/random/base/uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var zeros = require( '@stdlib/array/zeros' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var tryRequire = require( '@stdlib/utils/try-require' );
+var pkg = require( './../package.json' ).name;
+
+
+// VARIABLES //
+
+var options = {
+	'dtype': 'float32'
+};
+var snancusumkbn = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) );
+var opts = {
+	'skip': ( snancusumkbn instanceof Error )
+};
+
+
+// FUNCTIONS //
+
+/**
+* Returns a random number.
+*
+* @private
+* @returns {number} random number
+*/
+function rand() {
+	if ( bernoulli( 0.8 ) > 0 ) {
+		return uniform( -100.0, 100.0 );
+	}
+	return NaN;
+}
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+	var x = filledarrayBy( len, options.dtype, rand );
+	var y = zeros( len, options.dtype );
+	return benchmark;
+
+	function benchmark( b ) {
+		var v;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			x[ 0 ] += 1.0;
+			v = snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+			if ( isnanf( v[ i % len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnanf( v[ i % len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var f;
+	var i;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( i = min; i <= max; i++ ) {
+		len = pow( 10, i );
+		f = createBenchmark( len );
+		bench( pkg+'::native:ndarray:len='+len, opts, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/Makefile b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/Makefile
new file mode 100644
index 000000000000..cce2c865d7ad
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/Makefile
@@ -0,0 +1,146 @@
+#/
+# @license Apache-2.0
+#
+# Copyright (c) 2025 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.
+#/
+
+# VARIABLES #
+
+ifndef VERBOSE
+	QUIET := @
+else
+	QUIET :=
+endif
+
+# Determine the OS ([1][1], [2][2]).
+#
+# [1]: https://en.wikipedia.org/wiki/Uname#Examples
+# [2]: http://stackoverflow.com/a/27776822/2225624
+OS ?= $(shell uname)
+ifneq (, $(findstring MINGW,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring MSYS,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring CYGWIN,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring Windows_NT,$(OS)))
+	OS := WINNT
+endif
+endif
+endif
+endif
+
+# Define the program used for compiling C source files:
+ifdef C_COMPILER
+	CC := $(C_COMPILER)
+else
+	CC := gcc
+endif
+
+# Define the command-line options when compiling C files:
+CFLAGS ?= \
+	-std=c99 \
+	-O3 \
+	-Wall \
+	-pedantic
+
+# Determine whether to generate position independent code ([1][1], [2][2]).
+#
+# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options
+# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option
+ifeq ($(OS), WINNT)
+	fPIC ?=
+else
+	fPIC ?= -fPIC
+endif
+
+# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`):
+INCLUDE ?=
+
+# List of source files:
+SOURCE_FILES ?=
+
+# List of libraries (e.g., `-lopenblas -lpthread`):
+LIBRARIES ?=
+
+# List of library paths (e.g., `-L /foo/bar -L /beep/boop`):
+LIBPATH ?=
+
+# List of C targets:
+c_targets := benchmark.length.out
+
+
+# RULES #
+
+#/
+# Compiles source files.
+#
+# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`)
+# @param {string} [CFLAGS] - C compiler options
+# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`)
+# @param {string} [SOURCE_FILES] - list of source files
+# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`)
+# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`)
+#
+# @example
+# make
+#
+# @example
+# make all
+#/
+all: $(c_targets)
+
+.PHONY: all
+
+#/
+# Compiles C source files.
+#
+# @private
+# @param {string} CC - C compiler (e.g., `gcc`)
+# @param {string} CFLAGS - C compiler options
+# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`)
+# @param {string} SOURCE_FILES - list of source files
+# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`)
+# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`)
+#/
+$(c_targets): %.out: %.c
+	$(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES)
+
+#/
+# Runs compiled benchmarks.
+#
+# @example
+# make run
+#/
+run: $(c_targets)
+	$(QUIET) ./$<
+
+.PHONY: run
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean:
+	$(QUIET) -rm -f *.o *.out
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/benchmark.length.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/benchmark.length.c
new file mode 100644
index 000000000000..dfe6030755b4
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/benchmark.length.c
@@ -0,0 +1,213 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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 <sys/time.h>
+#include "stdlib/blas/ext/base/snancusumkbn.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#define NAME "snancusumkbn"
+#define ITERATIONS 1000000
+#define REPEATS 3
+#define MIN 1
+#define MAX 6
+
+/**
+* Prints the TAP version.
+*/
+static void print_version( void ) {
+	printf( "TAP version 13\n" );
+}
+
+/**
+* Prints the TAP summary.
+*
+* @param total     total number of tests
+* @param passing   total number of passing tests
+*/
+static void print_summary( int total, int passing ) {
+	printf( "#\n" );
+	printf( "1..%d\n", total ); // TAP plan
+	printf( "# total %d\n", total );
+	printf( "# pass  %d\n", passing );
+	printf( "#\n" );
+	printf( "# ok\n" );
+}
+
+/**
+* Prints benchmarks results.
+*
+* @param iterations  number of iterations
+* @param elapsed     elapsed time in seconds
+*/
+static void print_results( int iterations, float elapsed ) {
+	float rate = (float)iterations / elapsed;
+	printf( "  ---\n" );
+	printf( "  iterations: %d\n", iterations );
+	printf( "  elapsed: %0.9f\n", elapsed );
+	printf( "  rate: %0.9f\n", rate );
+	printf( "  ...\n" );
+}
+
+/**
+* Returns a clock time.
+*
+* @return clock time
+*/
+static float tic( void ) {
+	struct timeval now;
+	gettimeofday( &now, NULL );
+	return (float)now.tv_sec + (float)now.tv_usec / 1.0e6f;
+}
+
+/**
+* Generates a random number on the interval [0,1).
+*
+* @return random number
+*/
+static float rand_float( void ) {
+	int r = rand();
+	return (float)r / ( (float)RAND_MAX + 1.0f );
+}
+
+/**
+* Runs a benchmark.
+*
+* @param iterations   number of iterations
+* @param len          array length
+* @return             elapsed time in seconds
+*/
+static float benchmark1( int iterations, int len ) {
+	float elapsed;
+	float *x;
+	float *y;
+	float t;
+	int i;
+
+	x = (float *)malloc( len * sizeof( float ) );
+	y = (float *)malloc( len * sizeof( float ) );
+	for ( i = 0; i < len; i++ ) {
+		if ( rand_float() < 0.2f ) {
+			x[ i ] = 0.0f / 0.0f; // NaN
+		} else {
+			x[ i ] = ( rand_float() * 20000.0f ) - 10000.0f;
+		}
+		y[ i ] = 0.0f;
+	}
+	t = tic();
+	for ( i = 0; i < iterations; i++ ) {
+		x[ 0 ] += 1.0f;
+		stdlib_strided_snancusumkbn( len, 0.0f, x, 1, y, 1 );
+		if ( y[ 0 ] != y[ 0 ] ) {
+			printf( "should not return NaN\n" );
+			break;
+		}
+	}
+	elapsed = tic() - t;
+	if ( y[ len - 1 ] != y[ len - 1 ] ) {
+		printf( "should not return NaN\n" );
+	}
+	free( x );
+	free( y );
+	return elapsed;
+}
+
+/**
+* Runs a benchmark.
+*
+* @param iterations   number of iterations
+* @param len          array length
+* @return             elapsed time in seconds
+*/
+static float benchmark2( int iterations, int len ) {
+	float elapsed;
+	float *x;
+	float *y;
+	float t;
+	int i;
+
+	x = (float *)malloc( len * sizeof( float ) );
+	y = (float *)malloc( len * sizeof( float ) );
+	for ( i = 0; i < len; i++ ) {
+		if ( rand_float() < 0.2f ) {
+			x[ i ] = 0.0f / 0.0f; // NaN
+		} else {
+			x[ i ] = ( rand_float() * 20000.0f ) - 10000.0f;
+		}
+		y[ i ] = 0.0f;
+	}
+	t = tic();
+	for ( i = 0; i < iterations; i++ ) {
+		x[ 0 ] += 1.0f;
+		stdlib_strided_snancusumkbn_ndarray( len, 0.0f, x, 1, 0, y, 1, 0 );
+		if ( y[ 0 ] != y[ 0 ] ) {
+			printf( "should not return NaN\n" );
+			break;
+		}
+	}
+	elapsed = tic() - t;
+	if ( y[ len - 1 ] != y[ len - 1 ] ) {
+		printf( "should not return NaN\n" );
+	}
+	free( x );
+	free( y );
+	return elapsed;
+}
+
+/**
+* Main execution sequence.
+*/
+int main( void ) {
+	float elapsed;
+	int count;
+	int iter;
+	int len;
+	int i;
+	int j;
+
+	// Use the current time to seed the random number generator:
+	srand( time( NULL ) );
+
+	print_version();
+	count = 0;
+	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:len=%d\n", NAME, 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 );
+		}
+	}
+	print_summary( count, count );
+}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/binding.gyp b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/binding.gyp
new file mode 100644
index 000000000000..68a1ca11d160
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/binding.gyp
@@ -0,0 +1,170 @@
+# @license Apache-2.0
+#
+# Copyright (c) 2025 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.
+
+# A `.gyp` file for building a Node.js native add-on.
+#
+# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md
+# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md
+{
+  # List of files to include in this file:
+  'includes': [
+    './include.gypi',
+  ],
+
+  # Define variables to be used throughout the configuration for all targets:
+  'variables': {
+    # Target name should match the add-on export name:
+    'addon_target_name%': 'addon',
+
+    # Set variables based on the host OS:
+    'conditions': [
+      [
+        'OS=="win"',
+        {
+          # Define the object file suffix:
+          'obj': 'obj',
+        },
+        {
+          # Define the object file suffix:
+          'obj': 'o',
+        }
+      ], # end condition (OS=="win")
+    ], # end conditions
+  }, # end variables
+
+  # Define compile targets:
+  'targets': [
+
+    # Target to generate an add-on:
+    {
+      # The target name should match the add-on export name:
+      'target_name': '<(addon_target_name)',
+
+      # Define dependencies:
+      'dependencies': [],
+
+      # Define directories which contain relevant include headers:
+      'include_dirs': [
+        # Local include directory:
+        '<@(include_dirs)',
+      ],
+
+      # List of source files:
+      'sources': [
+        '<@(src_files)',
+      ],
+
+      # Settings which should be applied when a target's object files are used as linker input:
+      'link_settings': {
+        # Define libraries:
+        'libraries': [
+          '<@(libraries)',
+        ],
+
+        # Define library directories:
+        'library_dirs': [
+          '<@(library_dirs)',
+        ],
+      },
+
+      # C/C++ compiler flags:
+      'cflags': [
+        # Enable commonly used warning options:
+        '-Wall',
+
+        # Aggressive optimization:
+        '-O3',
+      ],
+
+      # C specific compiler flags:
+      'cflags_c': [
+        # Specify the C standard to which a program is expected to conform:
+        '-std=c99',
+      ],
+
+      # C++ specific compiler flags:
+      'cflags_cpp': [
+        # Specify the C++ standard to which a program is expected to conform:
+        '-std=c++11',
+      ],
+
+      # Linker flags:
+      'ldflags': [],
+
+      # Apply conditions based on the host OS:
+      'conditions': [
+        [
+          'OS=="mac"',
+          {
+            # Linker flags:
+            'ldflags': [
+              '-undefined dynamic_lookup',
+              '-Wl,-no-pie',
+              '-Wl,-search_paths_first',
+            ],
+          },
+        ], # end condition (OS=="mac")
+        [
+          'OS!="win"',
+          {
+            # C/C++ flags:
+            'cflags': [
+              # Generate platform-independent code:
+              '-fPIC',
+            ],
+          },
+        ], # end condition (OS!="win")
+      ], # end conditions
+    }, # end target <(addon_target_name)
+
+    # Target to copy a generated add-on to a standard location:
+    {
+      'target_name': 'copy_addon',
+
+      # Declare that the output of this target is not linked:
+      'type': 'none',
+
+      # Define dependencies:
+      'dependencies': [
+        # Require that the add-on be generated before building this target:
+        '<(addon_target_name)',
+      ],
+
+      # Define a list of actions:
+      'actions': [
+        {
+          'action_name': 'copy_addon',
+          'message': 'Copying addon...',
+
+          # Explicitly list the inputs in the command-line invocation below:
+          'inputs': [],
+
+          # Declare the expected outputs:
+          'outputs': [
+            '<(addon_output_dir)/<(addon_target_name).node',
+          ],
+
+          # Define the command-line invocation:
+          'action': [
+            'cp',
+            '<(PRODUCT_DIR)/<(addon_target_name).node',
+            '<(addon_output_dir)/<(addon_target_name).node',
+          ],
+        },
+      ], # end actions
+    }, # end target copy_addon
+  ], # end targets
+}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/repl.txt b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/repl.txt
new file mode 100644
index 000000000000..f8488b0d626b
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/repl.txt
@@ -0,0 +1,121 @@
+
+{{alias}}( N, sum, x, strideX, y, strideY )
+    Computes the cumulative sum of single-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 arrays
+    are accessed at runtime.
+
+    Indexing is relative to the first index. To introduce an offset, use a typed
+    array view.
+
+    If `N <= 0`, the function returns `y` unchanged.
+
+    Parameters
+    ----------
+    N: integer
+        Number of indexed elements.
+
+    sum: number
+        Initial sum.
+
+    x: Float32Array
+        Input array.
+
+    strideX: integer
+        Stride length for `x`.
+
+    y: Float32Array
+        Output array.
+
+    strideY: integer
+        Stride length for `y`.
+
+    Returns
+    -------
+    out: Float32Array
+        Output array.
+
+    Examples
+    --------
+    // Standard Usage:
+    > var x = new {{alias:@stdlib/array/float32}}( [ 1.0, NaN, 2.0 ] );
+    > var y = new {{alias:@stdlib/array/float32}}( x.length );
+    > {{alias}}( x.length, 0.0, x, 1, y, 1 )
+    <Float32Array>[ 1.0, 1.0, 3.0 ]
+
+    // Using `N` and stride parameters:
+    > x = new {{alias:@stdlib/array/float32}}( [ -2.0, 1.0, 1.0, NaN, 2.0, -1.0 ] );
+    > y = new {{alias:@stdlib/array/float32}}( x.length );
+    > {{alias}}( 3, 0.0, x, 2, y, 2 )
+    <Float32Array>[ -2.0, 0.0, -1.0, 0.0, 1.0, 0.0 ]
+
+    // Using view offsets:
+    > var x0 = new {{alias:@stdlib/array/float32}}( [ 1.0, -2.0, 3.0, NaN, 5.0, -1.0 ] );
+    > var y0 = new {{alias:@stdlib/array/float32}}( x0.length );
+    > var x1 = new {{alias:@stdlib/array/float32}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 );
+    > var y1 = new {{alias:@stdlib/array/float32}}( y0.buffer, y0.BYTES_PER_ELEMENT*3 );
+    > {{alias}}( 3, 0.0, x1, 2, y1, 1 )
+    <Float32Array>[ -2.0, -2.0, -3.0 ]
+    > y0
+    <Float32Array>[ 0.0, 0.0, 0.0, -2.0, -2.0, -3.0 ]
+
+
+{{alias}}.ndarray( N, sum, x, strideX, offsetX, y, strideY, offsetY )
+    Computes the cumulative sum of single-precision floating-point strided array
+    elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm
+    and alternative indexing semantics.
+
+    While typed array views mandate a view offset based on the underlying
+    buffer, the offset parameters support indexing semantics based on starting
+    indices.
+
+    Parameters
+    ----------
+    N: integer
+        Number of indexed elements.
+
+    sum: number
+        Initial sum.
+
+    x: Float32Array
+        Input array.
+
+    strideX: integer
+        Stride length for `x`.
+
+    offsetX: integer
+        Starting index for `x`.
+
+    y: Float32Array
+        Output array.
+
+    strideY: integer
+        Stride length for `y`.
+
+    offsetY: integer
+        Starting index for `y`.
+
+    Returns
+    -------
+    out: Float32Array
+        Output array.
+
+    Examples
+    --------
+    // Standard Usage:
+    > var x = new {{alias:@stdlib/array/float32}}( [ 1.0, -2.0, NaN ] );
+    > var y = new {{alias:@stdlib/array/float32}}( x.length );
+    > {{alias}}.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 )
+    <Float32Array>[ 1.0, -1.0, -1.0 ]
+
+    // Advanced indexing:
+    > x = new {{alias:@stdlib/array/float32}}( [ NaN, -2.0, 3.0, 2.0, 5.0, -1.0 ] );
+    > y = new {{alias:@stdlib/array/float32}}( x.length );
+    > {{alias}}.ndarray( 3, 0.0, x, 2, 1, y, -1, y.length-1 )
+    <Float32Array>[ 0.0, 0.0, 0.0, -1.0, 0.0, -2.0 ]
+
+    See Also
+    --------
+
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/index.d.ts
new file mode 100644
index 000000000000..981167bcdbb2
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/index.d.ts
@@ -0,0 +1,106 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+// TypeScript Version: 4.1
+
+/**
+* Interface describing `snancusumkbn`.
+*/
+interface Routine {
+	/**
+	* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+	*
+	* @param N - number of indexed elements
+	* @param sum - initial sum
+	* @param x - input array
+	* @param strideX - stride length for `x`
+	* @param y - output array
+	* @param strideY - stride length for `y`
+	* @returns output array
+	*
+	* @example
+	* var Float32Array = require( '@stdlib/array/float32' );
+	*
+	* var x = new Float32Array( [ 1.0, NaN, 2.0 ] );
+	* var y = new Float32Array( x.length );
+	*
+	* snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	* // y => <Float32Array>[ 1.0, 1.0, 3.0 ]
+	*/
+	( N: number, sum: number, x: Float32Array, strideX: number, y: Float32Array, strideY: number ): Float32Array;
+
+	/**
+	* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm and alternative indexing semantics.
+	*
+	* @param N - number of indexed elements
+	* @param sum - initial sum
+	* @param x - input array
+	* @param strideX - stride length for `x`
+	* @param offsetX - starting index for `x`
+	* @param y - output array
+	* @param strideY - stride length for `y`
+	* @param offsetY - starting index for `y`
+	* @returns output array
+	*
+	* @example
+	* var Float32Array = require( '@stdlib/array/float32' );
+	*
+	* var x = new Float32Array( [ 1.0, -2.0, NaN ] );
+	* var y = new Float32Array( x.length );
+	*
+	* snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	* // y => <Float32Array>[ 1.0, -1.0, -1.0 ]
+	*/
+	ndarray( N: number, sum: number, x: Float32Array, strideX: number, offsetX: number, y: Float32Array, strideY: number, offsetY: number ): Float32Array;
+}
+
+/**
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+*
+* @param N - number of indexed elements
+* @param sum - initial sum
+* @param x - input array
+* @param strideX - stride length for `x`
+* @param y - output array
+* @param strideY - stride length for `y`
+* @returns output array
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+*
+* var x = new Float32Array( [ 1.0, -2.0, NaN ] );
+* var y = new Float32Array( x.length );
+*
+* snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+* // y => <Float32Array>[ 1.0, -1.0, -1.0 ]
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+*
+* var x = new Float32Array( [ 1.0, -2.0, NaN ] );
+* var y = new Float32Array( x.length );
+*
+* snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 );
+* // y => <Float32Array>[ 1.0, -1.0, -1.0 ]
+*/
+declare var snancusumkbn: Routine;
+
+
+// EXPORTS //
+
+export = snancusumkbn;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/test.ts b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/test.ts
new file mode 100644
index 000000000000..0096e1b5b350
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/test.ts
@@ -0,0 +1,280 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+import snancusumkbn = require( './index' );
+
+
+// TESTS //
+
+// The function returns a Float32Array...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 ); // $ExpectType Float32Array
+}
+
+// The compiler throws an error if the function is provided a first argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn( '10', 0.0, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( true, 0.0, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( false, 0.0, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( null, 0.0, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( undefined, 0.0, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( [], 0.0, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( {}, 0.0, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( ( x: number ): number => x, 0.0, x, 1, y, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn( x.length, '10', x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, true, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, false, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, null, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, undefined, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, [], x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, {}, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, ( x: number ): number => x, x, 1, y, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a third argument which is not a Float32Array...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn( x.length, 0.0, 10, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, '10', 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, true, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, false, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, null, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, undefined, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, [ '1' ], 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, {}, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, ( x: number ): number => x, 1, y, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fourth argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn( x.length, 0.0, x, '10', y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, true, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, false, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, null, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, undefined, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, [], y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, {}, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, ( x: number ): number => x, y, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fifth argument which is not a Float32Array...
+{
+	const x = new Float32Array( 10 );
+
+	snancusumkbn( x.length, 0.0, x, 1, 10, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, '10', 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, true, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, false, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, null, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, undefined, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, [ '1' ], 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, {}, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, ( x: number ): number => x, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a sixth argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn( x.length, 0.0, x, 1, y, '10' ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, y, true ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, y, false ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, y, null ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, y, undefined ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, y, [] ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, y, {} ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, y, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn(); // $ExpectError
+	snancusumkbn( x.length ); // $ExpectError
+	snancusumkbn( x.length, 0.0 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, y ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, y, 1, 10 ); // $ExpectError
+}
+
+// Attached to main export is an `ndarray` method which returns a Float32Array...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectType Float32Array
+}
+
+// The compiler throws an error if the `ndarray` method is provided a first argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn.ndarray( '10', 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( true, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( false, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( null, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( undefined, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( [], 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( {}, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( ( x: number ): number => x, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a second argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn.ndarray( x.length, '10', x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, true, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, false, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, null, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, undefined, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, [], x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, {}, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, ( x: number ): number => x, x, 1, 0, y, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a third argument which is not a Float32Array...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn.ndarray( x.length, 0.0, 10, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, '10', 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, true, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, false, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, null, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, undefined, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, [ '1' ], 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, {}, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, ( x: number ): number => x, 1, 0, y, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn.ndarray( x.length, 0.0, x, '10', 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, true, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, false, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, null, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, undefined, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, [], 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, {}, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, ( x: number ): number => x, 0, y, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, '10', y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, true, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, false, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, null, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, undefined, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, [], y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, {}, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, ( x: number ): number => x, y, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a sixth argument which is not a Float32Array...
+{
+	const x = new Float32Array( 10 );
+
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, 10, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, '10', 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, true, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, false, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, null, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, undefined, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, [ '1' ], 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, {}, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, ( x: number ): number => x, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a seventh argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, '10', 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, true, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, false, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, null, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, undefined, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, [], 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, {}, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, ( x: number ): number => x, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided an eighth argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, '10' ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, true ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, false ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, null ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, undefined ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, [] ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, {} ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided an unsupported number of arguments...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn.ndarray(); // $ExpectError
+	snancusumkbn.ndarray( x.length ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0, 10 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/Makefile b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/Makefile
new file mode 100644
index 000000000000..25ced822f96a
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/Makefile
@@ -0,0 +1,146 @@
+#/
+# @license Apache-2.0
+#
+# Copyright (c) 2025 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.
+#/
+
+# VARIABLES #
+
+ifndef VERBOSE
+	QUIET := @
+else
+	QUIET :=
+endif
+
+# Determine the OS ([1][1], [2][2]).
+#
+# [1]: https://en.wikipedia.org/wiki/Uname#Examples
+# [2]: http://stackoverflow.com/a/27776822/2225624
+OS ?= $(shell uname)
+ifneq (, $(findstring MINGW,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring MSYS,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring CYGWIN,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring Windows_NT,$(OS)))
+	OS := WINNT
+endif
+endif
+endif
+endif
+
+# Define the program used for compiling C source files:
+ifdef C_COMPILER
+	CC := $(C_COMPILER)
+else
+	CC := gcc
+endif
+
+# Define the command-line options when compiling C files:
+CFLAGS ?= \
+	-std=c99 \
+	-O3 \
+	-Wall \
+	-pedantic
+
+# Determine whether to generate position independent code ([1][1], [2][2]).
+#
+# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options
+# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option
+ifeq ($(OS), WINNT)
+	fPIC ?=
+else
+	fPIC ?= -fPIC
+endif
+
+# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`):
+INCLUDE ?=
+
+# List of source files:
+SOURCE_FILES ?=
+
+# List of libraries (e.g., `-lopenblas -lpthread`):
+LIBRARIES ?=
+
+# List of library paths (e.g., `-L /foo/bar -L /beep/boop`):
+LIBPATH ?=
+
+# List of C targets:
+c_targets := example.out
+
+
+# RULES #
+
+#/
+# Compiles source files.
+#
+# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`)
+# @param {string} [CFLAGS] - C compiler options
+# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`)
+# @param {string} [SOURCE_FILES] - list of source files
+# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`)
+# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`)
+#
+# @example
+# make
+#
+# @example
+# make all
+#/
+all: $(c_targets)
+
+.PHONY: all
+
+#/
+# Compiles C source files.
+#
+# @private
+# @param {string} CC - C compiler (e.g., `gcc`)
+# @param {string} CFLAGS - C compiler options
+# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`)
+# @param {string} SOURCE_FILES - list of source files
+# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`)
+# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`)
+#/
+$(c_targets): %.out: %.c
+	$(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES)
+
+#/
+# Runs compiled examples.
+#
+# @example
+# make run
+#/
+run: $(c_targets)
+	$(QUIET) ./$<
+
+.PHONY: run
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean:
+	$(QUIET) -rm -f *.o *.out
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/example.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/example.c
new file mode 100644
index 000000000000..602bdb365b3b
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/example.c
@@ -0,0 +1,41 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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/snancusumkbn.h"
+#include <stdio.h>
+
+int main( void ) {
+	// Create strided arrays:
+	const float x[] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 0.0f / 0.0f, 0.0f / 0.0f, 8.0f };
+	float y[] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
+
+	// Specify the number of elements:
+	const int N = 4;
+
+	// Specify stride lengths:
+	const int strideX = 2;
+	const int strideY = -2;
+
+	// Compute the cumulative sum:
+	stdlib_strided_snancusumkbn( N, 0.0f, x, strideX, y, strideY );
+
+	// Print the result:
+	for ( int i = 0; i < 8; i++ ) {
+		printf( "y[ %d ] = %f\n", i, y[ i ] );
+	}
+}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/index.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/index.js
new file mode 100644
index 000000000000..b19d8cbbef62
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/index.js
@@ -0,0 +1,41 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+'use strict';
+
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var zeros = require( '@stdlib/array/zeros' );
+var snancusumkbn = require( './../lib' );
+
+function rand() {
+	if ( bernoulli( 0.7 ) > 0 ) {
+		return discreteUniform( 0, 100 );
+	}
+	return NaN;
+}
+
+var x = filledarrayBy( 10, 'float32', rand );
+console.log( x );
+
+var y = zeros( x.length, 'float32' );
+console.log( y );
+
+snancusumkbn( x.length, 0.0, x, 1, y, -1 );
+console.log( y );
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include.gypi b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include.gypi
new file mode 100644
index 000000000000..ecfaf82a3279
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include.gypi
@@ -0,0 +1,53 @@
+# @license Apache-2.0
+#
+# Copyright (c) 2025 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.
+
+# A GYP include file for building a Node.js native add-on.
+#
+# Main documentation:
+#
+# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md
+# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md
+{
+  # Define variables to be used throughout the configuration for all targets:
+  'variables': {
+    # Source directory:
+    'src_dir': './src',
+
+    # Include directories:
+    'include_dirs': [
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).include; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+
+    # Add-on destination directory:
+    'addon_output_dir': './src',
+
+    # Source files:
+    'src_files': [
+      '<(src_dir)/addon.c',
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).src; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+
+    # Library dependencies:
+    'libraries': [
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).libraries; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+
+    # Library directories:
+    'library_dirs': [
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).libpath; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+  }, # end variables
+}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include/stdlib/blas/ext/base/snancusumkbn.h b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include/stdlib/blas/ext/base/snancusumkbn.h
new file mode 100644
index 000000000000..fe2b89c86a2a
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include/stdlib/blas/ext/base/snancusumkbn.h
@@ -0,0 +1,45 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+#ifndef STDLIB_BLAS_EXT_BASE_SNANCUSUMKBN_H
+#define STDLIB_BLAS_EXT_BASE_SNANCUSUMKBN_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.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+*/
+void API_SUFFIX( stdlib_strided_snancusumkbn )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, float *Y, const CBLAS_INT strideY );
+
+/**
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm and alternative indexing semantics.
+*/
+void API_SUFFIX( stdlib_strided_snancusumkbn_ndarray )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, float *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !STDLIB_BLAS_EXT_BASE_SNANCUSUMKBN_H
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/index.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/index.js
new file mode 100644
index 000000000000..066ff94623ae
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/index.js
@@ -0,0 +1,70 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+'use strict';
+
+/**
+* Compute the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+*
+* @module @stdlib/blas/ext/base/snancusumkbn
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+* var snancusumkbn = require( '@stdlib/blas/ext/base/snancusumkbn' );
+*
+* var x = new Float32Array( [ 1.0, -2.0, NaN ] );
+* var y = new Float32Array( x.length );
+*
+* snancusumkbn( 3, 0.0, x, 1, y, 1 );
+* // y => <Float32Array>[ 1.0, -1.0, -1.0 ]
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+* var snancusumkbn = require( '@stdlib/blas/ext/base/snancusumkbn' );
+*
+* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, NaN, 3.0, NaN ] );
+* var y = new Float32Array( x.length );
+*
+* snancusumkbn.ndarray( 4, 0.0, x, 2, 1, y, 1, 0 );
+* // y => <Float32Array>[ 1.0, -1.0, -1.0, -1.0, 0.0, 0.0, 0.0, 0.0 ]
+*/
+
+// MODULES //
+
+var join = require( 'path' ).join;
+var tryRequire = require( '@stdlib/utils/try-require' );
+var isError = require( '@stdlib/assert/is-error' );
+var main = require( './main.js' );
+
+
+// MAIN //
+
+var snancusumkbn;
+var tmp = tryRequire( join( __dirname, './native.js' ) );
+if ( isError( tmp ) ) {
+	snancusumkbn = main;
+} else {
+	snancusumkbn = tmp;
+}
+
+
+// EXPORTS //
+
+module.exports = snancusumkbn;
+
+// exports: { "ndarray": "snancusumkbn.ndarray" }
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/main.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/main.js
new file mode 100644
index 000000000000..154bf71a2416
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/main.js
@@ -0,0 +1,35 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var snancusumkbn = require( '@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js' );
+var ndarray = require( './ndarray.js' );
+
+
+// MAIN //
+
+setReadOnly( snancusumkbn, 'ndarray', ndarray );
+
+
+// EXPORTS //
+
+module.exports = snancusumkbn;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/native.js
new file mode 100644
index 000000000000..81faffe49cb7
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/native.js
@@ -0,0 +1,35 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var snancusumkbn = require( './snancusumkbn.native.js' );
+var ndarray = require( './ndarray.native.js' );
+
+
+// MAIN //
+
+setReadOnly( snancusumkbn, 'ndarray', ndarray );
+
+
+// EXPORTS //
+
+module.exports = snancusumkbn;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js
new file mode 100644
index 000000000000..4bdc924c5f8f
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js
@@ -0,0 +1,114 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var absf = require( '@stdlib/math/base/special/absf' );
+
+
+// MAIN //
+
+/**
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+*
+* @param {PositiveInteger} N - number of indexed elements
+* @param {number} sum - initial sum
+* @param {Float32Array} x - input array
+* @param {integer} strideX - stride length for `x`
+* @param {NonNegativeInteger} offsetX - starting index for `x`
+* @param {Float32Array} y - output array
+* @param {integer} strideY - stride length `y`
+* @param {NonNegativeInteger} offsetY - starting index for `y`
+* @returns {Float32Array} output array
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+*
+* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, NaN, NaN ] );
+* var y = new Float32Array( x.length );
+*
+* var v = snancusumkbn( 4, 0.0, x, 2, 1, y, 1, 0 );
+* // returns <Float32Array>[ 1.0, -1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0 ]
+*/
+function snancusumkbn( N, sum, x, strideX, offsetX, y, strideY, offsetY ) {
+	var ix;
+	var iy;
+	var s;
+	var v;
+	var t;
+	var c;
+	var i;
+
+	if ( N <= 0 ) {
+		return y;
+	}
+	ix = offsetX;
+	iy = offsetY;
+	s = sum;
+
+	// In order to preserve the sign of zero which can be lost during compensated summation below, find the first non-zero element...
+	if ( s === 0.0 ) {
+		for ( i = 0; i < N; i++ ) {
+			v = x[ ix ];
+			if ( isnanf( v ) ) {
+				y[ iy ] = s;
+				ix += strideX;
+				iy += strideY;
+				continue;
+			}
+			if ( v !== 0.0 ) {
+				break;
+			}
+			s += v;
+			y[ iy ] = s;
+			ix += strideX;
+			iy += strideY;
+		}
+	} else {
+		i = 0;
+	}
+	c = 0.0;
+	for ( ; i < N; i++ ) {
+		v = x[ ix ];
+		if ( isnanf( v ) ) {
+			y[ iy ] = s + c;
+			ix += strideX;
+			iy += strideY;
+			continue;
+		}
+		t = s + v;
+		if ( absf( s ) >= absf( v ) ) {
+			c += (s-t) + v;
+		} else {
+			c += (v-t) + s;
+		}
+		s = t;
+		y[ iy ] = s + c;
+		ix += strideX;
+		iy += strideY;
+	}
+	return y;
+}
+
+
+// EXPORTS //
+
+module.exports = snancusumkbn;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.native.js
new file mode 100644
index 000000000000..0d8bb4549eb3
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.native.js
@@ -0,0 +1,58 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var addon = require( './../src/addon.node' );
+
+
+// MAIN //
+
+/**
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+*
+* @param {PositiveInteger} N - number of indexed elements
+* @param {number} sum - initial sum
+* @param {Float32Array} x - input array
+* @param {integer} strideX - stride length for `x`
+* @param {NonNegativeInteger} offsetX - starting index for `x`
+* @param {Float32Array} y - output array
+* @param {integer} strideY - stride length for `y`
+* @param {NonNegativeInteger} offsetY - starting index for `y`
+* @returns {Float32Array} output array
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+*
+* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, NaN, NaN ] );
+* var y = new Float32Array( x.length );
+*
+* var v = snancusumkbn( 4, 0.0, x, 2, 1, y, 1, 0 );
+* // returns <Float32Array>[ 1.0, -1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0 ]
+*/
+function snancusumkbn( N, sum, x, strideX, offsetX, y, strideY, offsetY ) {
+	addon.ndarray( N, sum, x, strideX, offsetX, y, strideY, offsetY );
+	return y;
+}
+
+
+// EXPORTS //
+
+module.exports = snancusumkbn;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js
new file mode 100644
index 000000000000..03225d68cc34
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js
@@ -0,0 +1,65 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var stride2offset = require( '@stdlib/strided/base/stride2offset' );
+var ndarray = require( '@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js' );
+
+
+// MAIN //
+
+/**
+* Computes the cumulative sum of single-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 {PositiveInteger} N - number of indexed elements
+* @param {number} sum - initial sum
+* @param {Float32Array} x - input array
+* @param {integer} strideX - stride length for `x`
+* @param {Float32Array} y - output array
+* @param {integer} strideY - stride length for `y`
+* @returns {Float32Array} output array
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+*
+* var x = new Float32Array( [ 1.0, -2.0, NaN ] );
+* var y = new Float32Array( x.length );
+*
+* var v = snancusumkbn( 3, 0.0, x, 1, y, 1 );
+* // returns <Float32Array>[ 1.0, -1.0, -1.0 ]
+*/
+function snancusumkbn( N, sum, x, strideX, y, strideY ) {
+	ndarray( N, sum, x, strideX, stride2offset( N, strideX ), y, strideY, stride2offset( N, strideY ) ); // eslint-disable-line max-len
+	return y;
+}
+
+
+// EXPORTS //
+
+module.exports = snancusumkbn;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.native.js
new file mode 100644
index 000000000000..c18f35555c3b
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.native.js
@@ -0,0 +1,56 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var addon = require( './../src/addon.node' );
+
+
+// MAIN //
+
+/**
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+*
+* @param {PositiveInteger} N - number of indexed elements
+* @param {number} sum - initial sum
+* @param {Float32Array} x - input array
+* @param {integer} strideX - stride length for `x`
+* @param {Float32Array} y - output array
+* @param {integer} strideY - stride length for `y`
+* @returns {Float32Array} output array
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+*
+* var x = new Float32Array( [ 1.0, -2.0, NaN ] );
+* var y = new Float32Array( x.length );
+*
+* var v = snancusumkbn( 3, 0.0, x, 1, y, 1 );
+* // returns <Float32Array>[ 1.0, -1.0, -1.0 ]
+*/
+function snancusumkbn( N, sum, x, strideX, y, strideY ) {
+	addon( N, sum, x, strideX, y, strideY );
+	return y;
+}
+
+
+// EXPORTS //
+
+module.exports = snancusumkbn;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/manifest.json b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/manifest.json
new file mode 100644
index 000000000000..dd379d1d4144
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/manifest.json
@@ -0,0 +1,85 @@
+{
+  "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/math/base/special/absf",
+        "@stdlib/math/base/assert/is-nanf",
+        "@stdlib/blas/base/shared",
+        "@stdlib/strided/base/stride2offset",
+        "@stdlib/napi/argv",
+        "@stdlib/napi/argv-int64",
+        "@stdlib/napi/argv-float",
+        "@stdlib/napi/argv-strided-float32array",
+        "@stdlib/napi/export"
+      ]
+    },
+    {
+      "task": "benchmark",
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/math/base/special/absf",
+        "@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/special/absf",
+        "@stdlib/math/base/assert/is-nanf",
+        "@stdlib/blas/base/shared",
+        "@stdlib/strided/base/stride2offset"
+      ]
+    }
+  ]
+}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/package.json b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/package.json
new file mode 100644
index 000000000000..0ae6f5809535
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/package.json
@@ -0,0 +1,83 @@
+{
+  "name": "@stdlib/blas/ext/base/snancusumkbn",
+  "version": "0.0.0",
+  "description": "Calculate the cumulative sum of single-precision floating-point strided array elements ignoring NaN values and using an improved Kahan–Babuška algorithm.",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "The Stdlib Authors",
+    "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+  },
+  "contributors": [
+    {
+      "name": "The Stdlib Authors",
+      "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+    }
+  ],
+  "main": "./lib",
+  "browser": "./lib/main.js",
+  "gypfile": true,
+  "directories": {
+    "benchmark": "./benchmark",
+    "doc": "./docs",
+    "example": "./examples",
+    "include": "./include",
+    "lib": "./lib",
+    "src": "./src",
+    "test": "./test"
+  },
+  "types": "./docs/types",
+  "scripts": {},
+  "homepage": "https://github.com/stdlib-js/stdlib",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/stdlib-js/stdlib.git"
+  },
+  "bugs": {
+    "url": "https://github.com/stdlib-js/stdlib/issues"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "engines": {
+    "node": ">=0.10.0",
+    "npm": ">2.7.0"
+  },
+  "os": [
+    "aix",
+    "darwin",
+    "freebsd",
+    "linux",
+    "macos",
+    "openbsd",
+    "sunos",
+    "win32",
+    "windows"
+  ],
+  "keywords": [
+    "stdlib",
+    "stdmath",
+    "statistics",
+    "stats",
+    "mathematics",
+    "math",
+    "blas",
+    "extended",
+    "sum",
+    "total",
+    "summation",
+    "cumulative",
+    "accumulate",
+    "kbn",
+    "kahan",
+    "compensated",
+    "strided",
+    "strided array",
+    "typed",
+    "array",
+    "float32",
+    "single",
+    "float32array"
+  ],
+  "__stdlib__": {
+    "wasm": false
+  }
+}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/Makefile b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/Makefile
new file mode 100644
index 000000000000..7733b6180cb4
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/Makefile
@@ -0,0 +1,70 @@
+#/
+# @license Apache-2.0
+#
+# Copyright (c) 2025 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.
+#/
+
+# VARIABLES #
+
+ifndef VERBOSE
+	QUIET := @
+else
+	QUIET :=
+endif
+
+# Determine the OS ([1][1], [2][2]).
+#
+# [1]: https://en.wikipedia.org/wiki/Uname#Examples
+# [2]: http://stackoverflow.com/a/27776822/2225624
+OS ?= $(shell uname)
+ifneq (, $(findstring MINGW,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring MSYS,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring CYGWIN,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring Windows_NT,$(OS)))
+	OS := WINNT
+endif
+endif
+endif
+endif
+
+
+# RULES #
+
+#/
+# Removes generated files for building an add-on.
+#
+# @example
+# make clean-addon
+#/
+clean-addon:
+	$(QUIET) -rm -f *.o *.node
+
+.PHONY: clean-addon
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean: clean-addon
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c
new file mode 100644
index 000000000000..5e6f0b28c9dd
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c
@@ -0,0 +1,68 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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 <node_api.h>
+#include "stdlib/blas/base/shared.h"
+#include "stdlib/blas/ext/base/snancusumkbn.h"
+#include "stdlib/napi/argv.h"
+#include "stdlib/napi/argv_float.h"
+#include "stdlib/napi/argv_int32.h"
+#include "stdlib/napi/argv_strided_float32array.h"
+#include "stdlib/napi/export.h"
+
+/**
+* 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( napi_env env, napi_callback_info info ) {
+	STDLIB_NAPI_ARGV( env, info, argv, argc, 6 );
+	STDLIB_NAPI_ARGV_INT32( env, N, argv, 0 );
+	STDLIB_NAPI_ARGV_FLOAT( env, sum, argv, 1 );
+	STDLIB_NAPI_ARGV_INT32( env, strideX, argv, 3 );
+	STDLIB_NAPI_ARGV_INT32( env, strideY, argv, 5 );
+	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, X, N, strideX, argv, 2 );
+	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, Y, N, strideY, argv, 4 );
+	API_SUFFIX( stdlib_strided_snancusumkbn )( N, sum, X, strideX, Y, strideY );
+	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, 8 );
+	STDLIB_NAPI_ARGV_INT32( env, N, argv, 0 );
+	STDLIB_NAPI_ARGV_FLOAT( env, sum, argv, 1 );
+	STDLIB_NAPI_ARGV_INT32( env, strideX, argv, 3 );
+	STDLIB_NAPI_ARGV_INT32( env, offsetX, argv, 4 );
+	STDLIB_NAPI_ARGV_INT32( env, strideY, argv, 6 );
+	STDLIB_NAPI_ARGV_INT32( env, offsetY, argv, 7 );
+	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, X, N, strideX, argv, 2 );
+	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, Y, N, strideY, argv, 5 );
+	API_SUFFIX( stdlib_strided_snancusumkbn_ndarray )( N, sum, X, strideX, offsetX, Y, strideY, offsetY );
+	return NULL;
+}
+
+STDLIB_NAPI_MODULE_EXPORT_FCN_WITH_METHOD( addon, "ndarray", addon_method )
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/main.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/main.c
new file mode 100644
index 000000000000..a4e9ab0ec9f2
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/main.c
@@ -0,0 +1,127 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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/base/shared.h"
+#include "stdlib/blas/ext/base/snancusumkbn.h"
+#include "stdlib/math/base/assert/is_nanf.h"
+#include "stdlib/math/base/special/absf.h"
+#include "stdlib/strided/base/stride2offset.h"
+
+/**
+* Computes the cumulative sum of single-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 sum      initial sum
+* @param X        input array
+* @param strideX  stride length for X
+* @param Y        output array
+* @param strideY  stride length for Y
+*/
+void API_SUFFIX( stdlib_strided_snancusumkbn )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, float *Y, const CBLAS_INT strideY ) {
+	const CBLAS_INT ox = stdlib_strided_stride2offset( N, strideX );
+	const CBLAS_INT oy = stdlib_strided_stride2offset( N, strideY );
+	API_SUFFIX( stdlib_strided_snancusumkbn_ndarray )( N, sum, X, strideX, ox, Y, strideY, oy );
+}
+
+/**
+* Computes the cumulative sum of single-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 sum      initial sum
+* @param X        input array
+* @param strideX  stride length for X
+* @param offsetX  starting index for X
+* @param Y        output array
+* @param strideY  stride length for Y
+* @param offsetY  starting index for Y
+*/
+void API_SUFFIX( stdlib_strided_snancusumkbn_ndarray )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, float *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY ) {
+	CBLAS_INT ix;
+	CBLAS_INT iy;
+	CBLAS_INT i;
+	float s;
+	float v;
+	float t;
+	float c;
+
+	if ( N <= 0 ) {
+		return;
+	}
+	ix = offsetX;
+	iy = offsetY;
+	s = sum;
+
+	// In order to preserve the sign of zero which can be lost during compensated summation below, find the first non-zero element...
+	if ( s == 0.0f ) {
+		for ( i = 0; i < N; i++ ) {
+			v = X[ ix ];
+			if ( stdlib_base_is_nanf( v ) ) {
+				Y[ iy ] = s;
+				ix += strideX;
+				iy += strideY;
+				continue;
+			}
+			if ( v != 0.0f ) {
+				break;
+			}
+			s += v;
+			Y[ iy ] = s;
+			ix += strideX;
+			iy += strideY;
+		}
+	} else {
+		i = 0;
+	}
+	c = 0.0f;
+	for ( ; i < N; i++ ) {
+		v = X[ ix ];
+		if ( stdlib_base_is_nanf( v ) ) {
+			Y[ iy ] = s + c;
+			ix += strideX;
+			iy += strideY;
+			continue;
+		}
+		t = s + v;
+		if ( stdlib_base_absf( s ) >= stdlib_base_absf( v ) ) {
+			c += ( s - t ) + v;
+		} else {
+			c += ( v - t ) + s;
+		}
+		s = t;
+		Y[ iy ] = s + c;
+		ix += strideX;
+		iy += strideY;
+	}
+	return;
+}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.js
new file mode 100644
index 000000000000..bbc4fec76d8b
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.js
@@ -0,0 +1,82 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var proxyquire = require( 'proxyquire' );
+var IS_BROWSER = require( '@stdlib/assert/is-browser' );
+var snancusumkbn = require( './../lib' );
+
+
+// VARIABLES //
+
+var opts = {
+	'skip': IS_BROWSER
+};
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof snancusumkbn, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'attached to the main export is a method providing an ndarray interface', function test( t ) {
+	t.strictEqual( typeof snancusumkbn.ndarray, 'function', 'method is a function' );
+	t.end();
+});
+
+tape( 'if a native implementation is available, the main export is the native implementation', opts, function test( t ) {
+	var snancusumkbn = proxyquire( './../lib', {
+		'@stdlib/utils/try-require': tryRequire
+	});
+
+	t.strictEqual( snancusumkbn, mock, 'returns expected value' );
+	t.end();
+
+	function tryRequire() {
+		return mock;
+	}
+
+	function mock() {
+		// Mock...
+	}
+});
+
+tape( 'if a native implementation is not available, the main export is a JavaScript implementation', opts, function test( t ) {
+	var snancusumkbn;
+	var main;
+
+	main = require( './../lib/snancusumkbn.js' );
+
+	snancusumkbn = proxyquire( './../lib', {
+		'@stdlib/utils/try-require': tryRequire
+	});
+
+	t.strictEqual( snancusumkbn, main, 'returns expected value' );
+	t.end();
+
+	function tryRequire() {
+		return new Error( 'Cannot find module' );
+	}
+});
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.js
new file mode 100644
index 000000000000..d610d24deb92
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.js
@@ -0,0 +1,357 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var Float32Array = require( '@stdlib/array/float32' );
+var isSameFloat32Array = require( '@stdlib/assert/is-same-float32array' );
+var snancusumkbn = require( './../lib/ndarray.js' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof snancusumkbn, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 8', function test( t ) {
+	t.strictEqual( snancusumkbn.length, 8, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function calculates the cumulative sum (ignoring NaN values)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+	var i;
+
+	x = new Float32Array( [ 1.0, 2.0, NaN, NaN, 5.0 ] );
+	y = new Float32Array( x.length );
+
+	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	expected = new Float32Array([
+		1.0,
+		3.0,
+		3.0,
+		3.0,
+		8.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, 2.0, NaN, NaN, 5.0 ] );
+	y = new Float32Array( x.length );
+
+	snancusumkbn( x.length, 10.0, x, 1, 0, y, 1, 0 );
+	expected = new Float32Array([
+		11.0,
+		13.0,
+		13.0,
+		13.0,
+		18.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ NaN, NaN ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	expected = new Float32Array([
+		0.0,
+		0.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, NaN, 3.0, NaN ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+
+	expected = new Float32Array([
+		1.0,
+		1.0,
+		4.0,
+		4.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, 1.0e38, NaN, -1.0e38 ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+
+	expected = new Float32Array([
+		1.0,
+		1.0e38,
+		1.0e38,
+		1.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( 1e3 );
+	y = new Float32Array( x.length );
+	expected = new Float32Array( x.length );
+	for ( i = 0; i < x.length; i++ ) {
+		x[ i ] = i + 1;
+		if ( i === 0 ) {
+			expected[ i ] += x[ i ];
+		} else {
+			expected[ i ] += expected[ i-1 ] + x[ i ];
+		}
+	}
+	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function preserves the sign of zero', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array( [ -0.0, -0.0, -0.0, 0.0, 1.0 ] );
+	y = new Float32Array( x.length );
+
+	snancusumkbn( x.length, -0.0, x, 1, 0, y, 1, 0 );
+	expected = new Float32Array([
+		-0.0,
+		-0.0,
+		-0.0,
+		0.0,
+		1.0
+	]);
+	t.strictEqual( isSameFloat32Array( y, expected ), true, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns a reference to the output array', function test( t ) {
+	var out;
+	var x;
+	var y;
+
+	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+	y = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+	out = snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+
+	t.strictEqual( out, y, 'same reference' );
+	t.end();
+});
+
+tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `y` unchanged', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+	y = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );
+
+	expected = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );
+
+	snancusumkbn( -1, 0.0, x, 1, 0, y, 1, 0 );
+	t.deepEqual( y, expected, 'returns `y` unchanged' );
+
+	snancusumkbn( 0, 0.0, x, 1, 0, y, 1, 0 );
+	t.deepEqual( y, expected, 'returns `y` unchanged' );
+
+	t.end();
+});
+
+tape( 'the function supports an `x` stride', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0,
+		NaN, // 1
+		NaN,
+		5.0  // 2
+	]);
+	y = new Float32Array([
+		0.0, // 0
+		0.0, // 1
+		0.0, // 2
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, 2, 0, y, 1, 0 );
+
+	expected = new Float32Array( [ 1.0, 1.0, 6.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports a `y` stride', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0, // 1
+		NaN, // 2
+		4.0,
+		5.0
+	]);
+	y = new Float32Array([
+		0.0, // 0
+		0.0,
+		0.0, // 1
+		0.0,
+		0.0  // 2
+	]);
+
+	snancusumkbn( 3, 0.0, x, 1, 0, y, 2, 0 );
+
+	expected = new Float32Array( [ 1.0, 0.0, 3.0, 0.0, 3.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports negative strides', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		NaN, // 2
+		NaN,
+		3.0, // 1
+		4.0,
+		5.0  // 0
+	]);
+	y = new Float32Array([
+		0.0, // 2
+		0.0, // 1
+		0.0, // 0
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, -2, x.length-1, y, -1, 2 );
+
+	expected = new Float32Array( [ 8.0, 8.0, 5.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports an `x` offset', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		2.0,
+		NaN,  // 0
+		NaN,
+		-2.0, // 1
+		-2.0,
+		2.0,  // 2
+		3.0,
+		4.0   // 3
+	]);
+	y = new Float32Array([
+		0.0, // 0
+		0.0, // 1
+		0.0, // 2
+		0.0, // 3
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 4, 0.0, x, 2, 1, y, 1, 0 );
+
+	expected = new Float32Array( [ 0.0, -2.0, 0.0, 4.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports a `y` offset', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		2.0,  // 0
+		1.0,  // 1
+		2.0,  // 2
+		NaN, // 3
+		NaN,
+		2.0,
+		3.0,
+		4.0
+	]);
+	y = new Float32Array([
+		0.0,
+		0.0, // 0
+		0.0,
+		0.0, // 1
+		0.0,
+		0.0, // 2
+		0.0,
+		0.0  // 3
+	]);
+
+	snancusumkbn( 4, 0.0, x, 1, 0, y, 2, 1 );
+
+	expected = new Float32Array( [ 0.0, 2.0, 0.0, 3.0, 0.0, 5.0, 0.0, 5.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports complex access patterns', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0,
+		3.0, // 1
+		4.0,
+		NaN, // 2
+		NaN
+	]);
+	y = new Float32Array([
+		0.0,  // 2
+		0.0,  // 1
+		0.0,  // 0
+		0.0,
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, 2, 0, y, -1, 2 );
+
+	expected = new Float32Array( [ 4.0, 4.0, 1.0, 0.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.native.js
new file mode 100644
index 000000000000..e5da3a6a0913
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.native.js
@@ -0,0 +1,366 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var resolve = require( 'path' ).resolve;
+var tape = require( 'tape' );
+var Float32Array = require( '@stdlib/array/float32' );
+var isSameFloat32Array = require( '@stdlib/assert/is-same-float32array' );
+var tryRequire = require( '@stdlib/utils/try-require' );
+
+
+// VARIABLES //
+
+var snancusumkbn = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) );
+var opts = {
+	'skip': ( snancusumkbn instanceof Error )
+};
+
+
+// TESTS //
+
+tape( 'main export is a function', opts, function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof snancusumkbn, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 8', opts, function test( t ) {
+	t.strictEqual( snancusumkbn.length, 8, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function calculates the cumulative sum (ignoring NaN values)', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+	var i;
+
+	x = new Float32Array( [ 1.0, 2.0, NaN, NaN, 5.0 ] );
+	y = new Float32Array( x.length );
+
+	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	expected = new Float32Array([
+		1.0,
+		3.0,
+		3.0,
+		3.0,
+		8.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, 2.0, NaN, NaN, 5.0 ] );
+	y = new Float32Array( x.length );
+
+	snancusumkbn( x.length, 10.0, x, 1, 0, y, 1, 0 );
+	expected = new Float32Array([
+		11.0,
+		13.0,
+		13.0,
+		13.0,
+		18.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ NaN, NaN ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	expected = new Float32Array([
+		0.0,
+		0.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, NaN, 3.0, NaN ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+
+	expected = new Float32Array([
+		1.0,
+		1.0,
+		4.0,
+		4.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, 1.0e38, NaN, -1.0e38 ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+
+	expected = new Float32Array([
+		1.0,
+		1.0e38,
+		1.0e38,
+		1.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( 1e3 );
+	y = new Float32Array( x.length );
+	expected = new Float32Array( x.length );
+	for ( i = 0; i < x.length; i++ ) {
+		x[ i ] = i + 1;
+		if ( i === 0 ) {
+			expected[ i ] += x[ i ];
+		} else {
+			expected[ i ] += expected[ i-1 ] + x[ i ];
+		}
+	}
+	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function preserves the sign of zero', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array( [ -0.0, -0.0, -0.0, 0.0, 1.0 ] );
+	y = new Float32Array( x.length );
+
+	snancusumkbn( x.length, -0.0, x, 1, 0, y, 1, 0 );
+	expected = new Float32Array([
+		-0.0,
+		-0.0,
+		-0.0,
+		0.0,
+		1.0
+	]);
+	t.strictEqual( isSameFloat32Array( y, expected ), true, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns a reference to the output array', opts, function test( t ) {
+	var out;
+	var x;
+	var y;
+
+	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+	y = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+	out = snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+
+	t.strictEqual( out, y, 'same reference' );
+	t.end();
+});
+
+tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `y` unchanged', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+	y = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );
+
+	expected = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );
+
+	snancusumkbn( -1, 0.0, x, 1, 0, y, 1, 0 );
+	t.deepEqual( y, expected, 'returns `y` unchanged' );
+
+	snancusumkbn( 0, 0.0, x, 1, 0, y, 1, 0 );
+	t.deepEqual( y, expected, 'returns `y` unchanged' );
+
+	t.end();
+});
+
+tape( 'the function supports an `x` stride', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0,
+		NaN, // 1
+		NaN,
+		5.0  // 2
+	]);
+	y = new Float32Array([
+		0.0, // 0
+		0.0, // 1
+		0.0, // 2
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, 2, 0, y, 1, 0 );
+
+	expected = new Float32Array( [ 1.0, 1.0, 6.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports a `y` stride', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0, // 1
+		NaN, // 2
+		4.0,
+		5.0
+	]);
+	y = new Float32Array([
+		0.0, // 0
+		0.0,
+		0.0, // 1
+		0.0,
+		0.0  // 2
+	]);
+
+	snancusumkbn( 3, 0.0, x, 1, 0, y, 2, 0 );
+
+	expected = new Float32Array( [ 1.0, 0.0, 3.0, 0.0, 3.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports negative strides', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		NaN, // 2
+		NaN,
+		3.0, // 1
+		4.0,
+		5.0  // 0
+	]);
+	y = new Float32Array([
+		0.0, // 2
+		0.0, // 1
+		0.0, // 0
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, -2, x.length-1, y, -1, 2 );
+
+	expected = new Float32Array( [ 8.0, 8.0, 5.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports an `x` offset', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		2.0,
+		1.0,  // 0
+		2.0,
+		-2.0, // 1
+		-2.0,
+		2.0,  // 2
+		3.0,
+		NaN   // 3
+	]);
+	y = new Float32Array([
+		0.0, // 0
+		0.0, // 1
+		0.0, // 2
+		0.0, // 3
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 4, 0.0, x, 2, 1, y, 1, 0 );
+
+	expected = new Float32Array( [ 1.0, -1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports a `y` offset', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		2.0,  // 0
+		1.0,  // 1
+		2.0,  // 2
+		NaN, // 3
+		-2.0,
+		2.0,
+		3.0,
+		4.0
+	]);
+	y = new Float32Array([
+		0.0,
+		0.0, // 0
+		0.0,
+		0.0, // 1
+		0.0,
+		0.0, // 2
+		0.0,
+		0.0  // 3
+	]);
+
+	snancusumkbn( 4, 0.0, x, 1, 0, y, 2, 1 );
+
+	expected = new Float32Array( [ 0.0, 2.0, 0.0, 3.0, 0.0, 5.0, 0.0, 5.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports complex access patterns', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0,
+		3.0, // 1
+		4.0,
+		5.0, // 2
+		NaN
+	]);
+	y = new Float32Array([
+		0.0,  // 2
+		0.0,  // 1
+		0.0,  // 0
+		0.0,
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, 2, 0, y, -1, 2 );
+
+	expected = new Float32Array( [ 9.0, 4.0, 1.0, 0.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.js
new file mode 100644
index 000000000000..16e473947228
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.js
@@ -0,0 +1,304 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var Float32Array = require( '@stdlib/array/float32' );
+var snancusumkbn = require( './../lib/snancusumkbn.js' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof snancusumkbn, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 6', function test( t ) {
+	t.strictEqual( snancusumkbn.length, 6, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function computes the cumulative sum (ignoring NaN values)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+	var i;
+
+	x = new Float32Array( [ 1.0, 2.0, NaN, 4.0, NaN ] );
+	y = new Float32Array( x.length );
+
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	expected = new Float32Array([
+		1.0,
+		3.0,
+		3.0,
+		7.0,
+		7.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, 2.0, NaN, NaN, 5.0 ] );
+	y = new Float32Array( x.length );
+
+	snancusumkbn( x.length, 10.0, x, 1, y, 1 );
+	expected = new Float32Array([
+		11.0,
+		13.0,
+		13.0,
+		13.0,
+		18.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ NaN, NaN ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	expected = new Float32Array([
+		0.0,
+		0.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, NaN, 3.0, NaN ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+
+	expected = new Float32Array([
+		1.0,
+		1.0,
+		4.0,
+		4.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, 1.0e38, NaN, -1.0e38 ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+
+	expected = new Float32Array([
+		1.0,
+		1.0e38,
+		1.0e38,
+		1.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( 1e3 );
+	y = new Float32Array( x.length );
+	expected = new Float32Array( x.length );
+	for ( i = 0; i < x.length; i++ ) {
+		x[ i ] = i + 1;
+		if ( i === 0 ) {
+			expected[ i ] += x[ i ];
+		} else {
+			expected[ i ] += expected[ i-1 ] + x[ i ];
+		}
+	}
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns a reference to the output array', function test( t ) {
+	var out;
+	var x;
+	var y;
+
+	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+	y = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+	out = snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+
+	t.strictEqual( out, y, 'same reference' );
+	t.end();
+});
+
+tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `y` unchanged', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+	y = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );
+
+	expected = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );
+
+	snancusumkbn( -1, 0.0, x, 1, y, 1 );
+	t.deepEqual( y, expected, 'returns `y` unchanged' );
+
+	snancusumkbn( 0, 0.0, x, 1, y, 1 );
+	t.deepEqual( y, expected, 'returns `y` unchanged' );
+
+	t.end();
+});
+
+tape( 'the function supports an `x` stride', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0,
+		NaN, // 1
+		4.0,
+		5.0  // 2
+	]);
+	y = new Float32Array([
+		0.0, // 0
+		0.0, // 1
+		0.0, // 2
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, 2, y, 1 );
+
+	expected = new Float32Array( [ 1.0, 1.0, 6.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports a `y` stride', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0, // 1
+		NaN, // 2
+		NaN,
+		5.0
+	]);
+	y = new Float32Array([
+		0.0, // 0
+		0.0,
+		0.0, // 1
+		0.0,
+		0.0  // 2
+	]);
+
+	snancusumkbn( 3, 0.0, x, 1, y, 2 );
+
+	expected = new Float32Array( [ 1.0, 0.0, 3.0, 0.0, 3.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports negative strides', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		NaN, // 2
+		2.0,
+		3.0, // 1
+		4.0,
+		5.0  // 0
+	]);
+	y = new Float32Array([
+		0.0, // 2
+		0.0, // 1
+		0.0, // 0
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, -2, y, -1 );
+
+	expected = new Float32Array( [ 8.0, 8.0, 5.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports complex access patterns', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0,
+		NaN, // 1
+		NaN,
+		5.0, // 2
+		6.0
+	]);
+	y = new Float32Array([
+		0.0,  // 2
+		0.0,  // 1
+		0.0,  // 0
+		0.0,
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, 2, y, -1 );
+
+	expected = new Float32Array( [ 6.0, 1.0, 1.0, 0.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports view offsets', function test( t ) {
+	var expected;
+	var x0;
+	var y0;
+	var x1;
+	var y1;
+
+	// Initial arrays...
+	x0 = new Float32Array([
+		1.0,
+		NaN, // 2
+		NaN,
+		4.0, // 1
+		5.0,
+		6.0  // 0
+	]);
+	y0 = new Float32Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0, // 0
+		0.0, // 1
+		0.0  // 2
+	]);
+
+	// Create offset views...
+	x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // begin at 2nd element
+	y1 = new Float32Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 ); // begin at 4th element
+
+	snancusumkbn( 3, 0.0, x1, -2, y1, 1 );
+	expected = new Float32Array( [ 0.0, 0.0, 0.0, 6.0, 10.0, 10.0 ] );
+
+	t.deepEqual( y0, expected, 'returns expected value' );
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.native.js
new file mode 100644
index 000000000000..4e02c12c3377
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.native.js
@@ -0,0 +1,313 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var resolve = require( 'path' ).resolve;
+var tape = require( 'tape' );
+var Float32Array = require( '@stdlib/array/float32' );
+var tryRequire = require( '@stdlib/utils/try-require' );
+
+
+// VARIABLES //
+
+var snancusumkbn = tryRequire( resolve( __dirname, './../lib/snancusumkbn.native.js' ) );
+var opts = {
+	'skip': ( snancusumkbn instanceof Error )
+};
+
+
+// TESTS //
+
+tape( 'main export is a function', opts, function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof snancusumkbn, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 6', opts, function test( t ) {
+	t.strictEqual( snancusumkbn.length, 6, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function computes the cumulative sum (ignoring NaN values)', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+	var i;
+
+	x = new Float32Array( [ 1.0, 2.0, NaN, NaN, 5.0 ] );
+	y = new Float32Array( x.length );
+
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	expected = new Float32Array([
+		1.0,
+		3.0,
+		3.0,
+		3.0,
+		8.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, 2.0, NaN, NaN, 5.0 ] );
+	y = new Float32Array( x.length );
+
+	snancusumkbn( x.length, 10.0, x, 1, y, 1 );
+	expected = new Float32Array([
+		11.0,
+		13.0,
+		13.0,
+		13.0,
+		18.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ NaN, NaN ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	expected = new Float32Array([
+		0.0,
+		0.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, NaN, 3.0, NaN ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+
+	expected = new Float32Array([
+		1.0,
+		1.0,
+		4.0,
+		4.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, 1.0e38, NaN, -1.0e38 ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+
+	expected = new Float32Array([
+		1.0,
+		1.0e38,
+		1.0e38,
+		1.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( 1e3 );
+	y = new Float32Array( x.length );
+	expected = new Float32Array( x.length );
+	for ( i = 0; i < x.length; i++ ) {
+		x[ i ] = i + 1;
+		if ( i === 0 ) {
+			expected[ i ] += x[ i ];
+		} else {
+			expected[ i ] += expected[ i-1 ] + x[ i ];
+		}
+	}
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns a reference to the output array', opts, function test( t ) {
+	var out;
+	var x;
+	var y;
+
+	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+	y = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+	out = snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+
+	t.strictEqual( out, y, 'same reference' );
+	t.end();
+});
+
+tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `y` unchanged', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+	y = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );
+
+	expected = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );
+
+	snancusumkbn( -1, 0.0, x, 1, y, 1 );
+	t.deepEqual( y, expected, 'returns `y` unchanged' );
+
+	snancusumkbn( 0, 0.0, x, 1, y, 1 );
+	t.deepEqual( y, expected, 'returns `y` unchanged' );
+
+	t.end();
+});
+
+tape( 'the function supports an `x` stride', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		NaN, // 0
+		2.0,
+		NaN, // 1
+		4.0,
+		5.0  // 2
+	]);
+	y = new Float32Array([
+		0.0, // 0
+		0.0, // 1
+		0.0, // 2
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, 2, y, 1 );
+
+	expected = new Float32Array( [ 0.0, 0.0, 5.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports a `y` stride', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0, // 1
+		NaN, // 2
+		4.0,
+		5.0
+	]);
+	y = new Float32Array([
+		0.0, // 0
+		0.0,
+		0.0, // 1
+		0.0,
+		0.0  // 2
+	]);
+
+	snancusumkbn( 3, 0.0, x, 1, y, 2 );
+
+	expected = new Float32Array( [ 1.0, 0.0, 3.0, 0.0, 3.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports negative strides', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		NaN, // 2
+		2.0,
+		3.0, // 1
+		4.0,
+		5.0  // 0
+	]);
+	y = new Float32Array([
+		0.0, // 2
+		0.0, // 1
+		0.0, // 0
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, -2, y, -1 );
+
+	expected = new Float32Array( [ 8.0, 8.0, 5.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports complex access patterns', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0,
+		NaN, // 1
+		NaN,
+		5.0, // 2
+		6.0
+	]);
+	y = new Float32Array([
+		0.0,  // 2
+		0.0,  // 1
+		0.0,  // 0
+		0.0,
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, 2, y, -1 );
+
+	expected = new Float32Array( [ 6.0, 1.0, 1.0, 0.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports view offsets', opts, function test( t ) {
+	var expected;
+	var x0;
+	var y0;
+	var x1;
+	var y1;
+
+	// Initial arrays...
+	x0 = new Float32Array([
+		1.0,
+		NaN, // 2
+		3.0,
+		4.0, // 1
+		5.0,
+		6.0  // 0
+	]);
+	y0 = new Float32Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0, // 0
+		0.0, // 1
+		0.0  // 2
+	]);
+
+	// Create offset views...
+	x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // begin at 2nd element
+	y1 = new Float32Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 ); // begin at 4th element
+
+	snancusumkbn( 3, 0.0, x1, -2, y1, 1 );
+	expected = new Float32Array( [ 0.0, 0.0, 0.0, 6.0, 10.0, 10.0 ] );
+
+	t.deepEqual( y0, expected, 'returns expected value' );
+	t.end();
+});

From 3a8b9b269b1417f3621a24d90f4edd97bee78784 Mon Sep 17 00:00:00 2001
From: kaustubh <kaustubh.mp007@gmail.com>
Date: Sat, 27 Dec 2025 19:52:37 +0530
Subject: [PATCH 2/9] added f32 implementation

---
 .../blas/ext/base/snancusumkbn/lib/ndarray.js       | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js
index 4bdc924c5f8f..b2103738b738 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js
@@ -20,6 +20,7 @@
 
 // MODULES //
 
+var f32 = require( '@stdlib/number/float64/base/to-float32' );
 var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var absf = require( '@stdlib/math/base/special/absf' );
 
@@ -77,7 +78,7 @@ function snancusumkbn( N, sum, x, strideX, offsetX, y, strideY, offsetY ) {
 			if ( v !== 0.0 ) {
 				break;
 			}
-			s += v;
+			s = f32( s + v );
 			y[ iy ] = s;
 			ix += strideX;
 			iy += strideY;
@@ -89,19 +90,19 @@ function snancusumkbn( N, sum, x, strideX, offsetX, y, strideY, offsetY ) {
 	for ( ; i < N; i++ ) {
 		v = x[ ix ];
 		if ( isnanf( v ) ) {
-			y[ iy ] = s + c;
+			y[ iy ] = f32( s + c );
 			ix += strideX;
 			iy += strideY;
 			continue;
 		}
-		t = s + v;
+		t = f32( s + v );
 		if ( absf( s ) >= absf( v ) ) {
-			c += (s-t) + v;
+			c = f32( c + f32( f32( s - t ) + v ) );
 		} else {
-			c += (v-t) + s;
+			c = f32( c + f32( f32( v - t ) + s ) );
 		}
 		s = t;
-		y[ iy ] = s + c;
+		y[ iy ] = f32( s + c );
 		ix += strideX;
 		iy += strideY;
 	}

From ed77ab21c96f4825740ad29079f2a77092d9122f Mon Sep 17 00:00:00 2001
From: kaustubh <kaustubh.mp007@gmail.com>
Date: Sat, 27 Dec 2025 20:34:32 +0530
Subject: [PATCH 3/9] Use  instead of string concatenation

---
 .../@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js  | 3 ++-
 .../blas/ext/base/snancusumkbn/benchmark/benchmark.native.js   | 3 ++-
 .../blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js  | 3 ++-
 .../base/snancusumkbn/benchmark/benchmark.ndarray.native.js    | 3 ++-
 4 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js
index 778ad2137e4b..32ad54719e82 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js
@@ -27,6 +27,7 @@ var filledarrayBy = require( '@stdlib/array/filled-by' );
 var zeros = require( '@stdlib/array/zeros' );
 var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var pow = require( '@stdlib/math/base/special/pow' );
+var format = require( '@stdlib/string/format' );
 var pkg = require( './../package.json' ).name;
 var snancusumkbn = require( './../lib/snancusumkbn.js' );
 
@@ -107,7 +108,7 @@ function main() {
 	for ( i = min; i <= max; i++ ) {
 		len = pow( 10, i );
 		f = createBenchmark( len );
-		bench( pkg+':len='+len, f );
+		bench( format( '%s:len=%d', pkg, len ), f );
 	}
 }
 
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js
index 1f450baa6464..b08b799fe44f 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js
@@ -28,6 +28,7 @@ var filledarrayBy = require( '@stdlib/array/filled-by' );
 var zeros = require( '@stdlib/array/zeros' );
 var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var pow = require( '@stdlib/math/base/special/pow' );
+var format = require( '@stdlib/string/format' );
 var tryRequire = require( '@stdlib/utils/try-require' );
 var pkg = require( './../package.json' ).name;
 
@@ -112,7 +113,7 @@ function main() {
 	for ( i = min; i <= max; i++ ) {
 		len = pow( 10, i );
 		f = createBenchmark( len );
-		bench( pkg+'::native:len='+len, opts, f );
+		bench( format( '%s::native:len=%d', pkg, len ), opts, f );
 	}
 }
 
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js
index 657c033b19d8..8b511c2dc0a3 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js
@@ -27,6 +27,7 @@ var filledarrayBy = require( '@stdlib/array/filled-by' );
 var zeros = require( '@stdlib/array/zeros' );
 var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var pow = require( '@stdlib/math/base/special/pow' );
+var format = require( '@stdlib/string/format' );
 var pkg = require( './../package.json' ).name;
 var snancusumkbn = require( './../lib/ndarray.js' );
 
@@ -107,7 +108,7 @@ function main() {
 	for ( i = min; i <= max; i++ ) {
 		len = pow( 10, i );
 		f = createBenchmark( len );
-		bench( pkg+':ndarray:len='+len, f );
+		bench( format( '%s:ndarray:len=%d', pkg, len ), f );
 	}
 }
 
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js
index 9eba60dc5a6c..76a972243f0f 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js
@@ -28,6 +28,7 @@ var filledarrayBy = require( '@stdlib/array/filled-by' );
 var zeros = require( '@stdlib/array/zeros' );
 var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var pow = require( '@stdlib/math/base/special/pow' );
+var format = require( '@stdlib/string/format' );
 var tryRequire = require( '@stdlib/utils/try-require' );
 var pkg = require( './../package.json' ).name;
 
@@ -112,7 +113,7 @@ function main() {
 	for ( i = min; i <= max; i++ ) {
 		len = pow( 10, i );
 		f = createBenchmark( len );
-		bench( pkg+'::native:ndarray:len='+len, opts, f );
+		bench( format( '%s::native:ndarray:len=%d', pkg, len ), opts, f );
 	}
 }
 

From 79b3e968693cbb48b2223d81c3e5a4b5e59de8fc Mon Sep 17 00:00:00 2001
From: kaustubh <kaustubh.mp007@gmail.com>
Date: Tue, 30 Dec 2025 11:03:18 +0530
Subject: [PATCH 4/9] feat: add blas/ext/base/snancusumkbn2

---
 .../ext/base/snancusumkbn/docs/types/test.ts  | 280 ------------------
 .../{snancusumkbn => snancusumkbn2}/README.md |  56 ++--
 .../benchmark/benchmark.js                    |   4 +-
 .../benchmark/benchmark.native.js             |   6 +-
 .../benchmark/benchmark.ndarray.js            |   4 +-
 .../benchmark/benchmark.ndarray.native.js     |   6 +-
 .../benchmark/c/Makefile                      |   0
 .../benchmark/c/benchmark.length.c            |   8 +-
 .../binding.gyp                               |   0
 .../docs/repl.txt                             |   8 +-
 .../docs/types/index.d.ts                     |  20 +-
 .../ext/base/snancusumkbn2/docs/types/test.ts | 280 ++++++++++++++++++
 .../examples/c/Makefile                       |   0
 .../examples/c/example.c                      |   4 +-
 .../examples/index.js                         |   4 +-
 .../include.gypi                              |   0
 .../stdlib/blas/ext/base/snancusumkbn2.h}     |  14 +-
 .../lib/index.js                              |  22 +-
 .../lib/main.js                               |   6 +-
 .../lib/native.js                             |   6 +-
 .../lib/ndarray.js                            |  55 ++--
 .../lib/ndarray.native.js                     |   8 +-
 .../lib/snancusumkbn2.js}                     |  14 +-
 .../lib/snancusumkbn2.native.js}              |   8 +-
 .../manifest.json                             |   0
 .../package.json                              |   6 +-
 .../src/Makefile                              |   0
 .../src/addon.c                               |  26 +-
 .../src/main.c                                |  43 ++-
 .../test/test.js                              |  18 +-
 .../test/test.ndarray.js                      |  38 +--
 .../test/test.ndarray.native.js               |  40 +--
 .../test/test.snancusumkbn2.js}               |  34 +--
 .../test/test.snancusumkbn2.native.js}        |  36 +--
 34 files changed, 543 insertions(+), 511 deletions(-)
 delete mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/test.ts
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/README.md (76%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/benchmark/benchmark.js (95%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/benchmark/benchmark.native.js (92%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/benchmark/benchmark.ndarray.js (95%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/benchmark/benchmark.ndarray.native.js (92%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/benchmark/c/Makefile (100%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/benchmark/c/benchmark.length.c (95%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/binding.gyp (100%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/docs/repl.txt (93%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/docs/types/index.d.ts (80%)
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/docs/types/test.ts
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/examples/c/Makefile (100%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/examples/c/example.c (90%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/examples/index.js (92%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/include.gypi (100%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn/include/stdlib/blas/ext/base/snancusumkbn.h => snancusumkbn2/include/stdlib/blas/ext/base/snancusumkbn2.h} (56%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/lib/index.js (73%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/lib/main.js (82%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/lib/native.js (85%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/lib/ndarray.js (64%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/lib/ndarray.native.js (85%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn/lib/snancusumkbn.js => snancusumkbn2/lib/snancusumkbn2.js} (69%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn/lib/snancusumkbn.native.js => snancusumkbn2/lib/snancusumkbn2.native.js} (84%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/manifest.json (100%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/package.json (92%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/src/Makefile (100%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/src/addon.c (73%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/src/main.c (58%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/test/test.js (76%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/test/test.ndarray.js (86%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn => snancusumkbn2}/test/test.ndarray.native.js (85%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn/test/test.snancusumkbn.js => snancusumkbn2/test/test.snancusumkbn2.js} (86%)
 rename lib/node_modules/@stdlib/blas/ext/base/{snancusumkbn/test/test.snancusumkbn.native.js => snancusumkbn2/test/test.snancusumkbn2.native.js} (86%)

diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/test.ts b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/test.ts
deleted file mode 100644
index 0096e1b5b350..000000000000
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/test.ts
+++ /dev/null
@@ -1,280 +0,0 @@
-/*
-* @license Apache-2.0
-*
-* Copyright (c) 2025 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.
-*/
-
-import snancusumkbn = require( './index' );
-
-
-// TESTS //
-
-// The function returns a Float32Array...
-{
-	const x = new Float32Array( 10 );
-	const y = new Float32Array( 10 );
-
-	snancusumkbn( x.length, 0.0, x, 1, y, 1 ); // $ExpectType Float32Array
-}
-
-// The compiler throws an error if the function is provided a first argument which is not a number...
-{
-	const x = new Float32Array( 10 );
-	const y = new Float32Array( 10 );
-
-	snancusumkbn( '10', 0.0, x, 1, y, 1 ); // $ExpectError
-	snancusumkbn( true, 0.0, x, 1, y, 1 ); // $ExpectError
-	snancusumkbn( false, 0.0, x, 1, y, 1 ); // $ExpectError
-	snancusumkbn( null, 0.0, x, 1, y, 1 ); // $ExpectError
-	snancusumkbn( undefined, 0.0, x, 1, y, 1 ); // $ExpectError
-	snancusumkbn( [], 0.0, x, 1, y, 1 ); // $ExpectError
-	snancusumkbn( {}, 0.0, x, 1, y, 1 ); // $ExpectError
-	snancusumkbn( ( x: number ): number => x, 0.0, x, 1, y, 1 ); // $ExpectError
-}
-
-// The compiler throws an error if the function is provided a second argument which is not a number...
-{
-	const x = new Float32Array( 10 );
-	const y = new Float32Array( 10 );
-
-	snancusumkbn( x.length, '10', x, 1, y, 1 ); // $ExpectError
-	snancusumkbn( x.length, true, x, 1, y, 1 ); // $ExpectError
-	snancusumkbn( x.length, false, x, 1, y, 1 ); // $ExpectError
-	snancusumkbn( x.length, null, x, 1, y, 1 ); // $ExpectError
-	snancusumkbn( x.length, undefined, x, 1, y, 1 ); // $ExpectError
-	snancusumkbn( x.length, [], x, 1, y, 1 ); // $ExpectError
-	snancusumkbn( x.length, {}, x, 1, y, 1 ); // $ExpectError
-	snancusumkbn( x.length, ( x: number ): number => x, x, 1, y, 1 ); // $ExpectError
-}
-
-// The compiler throws an error if the function is provided a third argument which is not a Float32Array...
-{
-	const x = new Float32Array( 10 );
-	const y = new Float32Array( 10 );
-
-	snancusumkbn( x.length, 0.0, 10, 1, y, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, '10', 1, y, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, true, 1, y, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, false, 1, y, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, null, 1, y, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, undefined, 1, y, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, [ '1' ], 1, y, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, {}, 1, y, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, ( x: number ): number => x, 1, y, 1 ); // $ExpectError
-}
-
-// The compiler throws an error if the function is provided a fourth argument which is not a number...
-{
-	const x = new Float32Array( 10 );
-	const y = new Float32Array( 10 );
-
-	snancusumkbn( x.length, 0.0, x, '10', y, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, true, y, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, false, y, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, null, y, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, undefined, y, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, [], y, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, {}, y, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, ( x: number ): number => x, y, 1 ); // $ExpectError
-}
-
-// The compiler throws an error if the function is provided a fifth argument which is not a Float32Array...
-{
-	const x = new Float32Array( 10 );
-
-	snancusumkbn( x.length, 0.0, x, 1, 10, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, 1, '10', 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, 1, true, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, 1, false, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, 1, null, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, 1, undefined, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, 1, [ '1' ], 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, 1, {}, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, 1, ( x: number ): number => x, 1 ); // $ExpectError
-}
-
-// The compiler throws an error if the function is provided a sixth argument which is not a number...
-{
-	const x = new Float32Array( 10 );
-	const y = new Float32Array( 10 );
-
-	snancusumkbn( x.length, 0.0, x, 1, y, '10' ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, 1, y, true ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, 1, y, false ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, 1, y, null ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, 1, y, undefined ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, 1, y, [] ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, 1, y, {} ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, 1, y, ( x: number ): number => x ); // $ExpectError
-}
-
-// The compiler throws an error if the function is provided an unsupported number of arguments...
-{
-	const x = new Float32Array( 10 );
-	const y = new Float32Array( 10 );
-
-	snancusumkbn(); // $ExpectError
-	snancusumkbn( x.length ); // $ExpectError
-	snancusumkbn( x.length, 0.0 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, 1 ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, 1, y ); // $ExpectError
-	snancusumkbn( x.length, 0.0, x, 1, y, 1, 10 ); // $ExpectError
-}
-
-// Attached to main export is an `ndarray` method which returns a Float32Array...
-{
-	const x = new Float32Array( 10 );
-	const y = new Float32Array( 10 );
-
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectType Float32Array
-}
-
-// The compiler throws an error if the `ndarray` method is provided a first argument which is not a number...
-{
-	const x = new Float32Array( 10 );
-	const y = new Float32Array( 10 );
-
-	snancusumkbn.ndarray( '10', 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( true, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( false, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( null, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( undefined, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( [], 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( {}, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( ( x: number ): number => x, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
-}
-
-// The compiler throws an error if the `ndarray` method is provided a second argument which is not a number...
-{
-	const x = new Float32Array( 10 );
-	const y = new Float32Array( 10 );
-
-	snancusumkbn.ndarray( x.length, '10', x, 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, true, x, 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, false, x, 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, null, x, 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, undefined, x, 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, [], x, 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, {}, x, 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, ( x: number ): number => x, x, 1, 0, y, 1, 0 ); // $ExpectError
-}
-
-// The compiler throws an error if the `ndarray` method is provided a third argument which is not a Float32Array...
-{
-	const x = new Float32Array( 10 );
-	const y = new Float32Array( 10 );
-
-	snancusumkbn.ndarray( x.length, 0.0, 10, 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, '10', 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, true, 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, false, 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, null, 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, undefined, 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, [ '1' ], 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, {}, 1, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, ( x: number ): number => x, 1, 0, y, 1, 0 ); // $ExpectError
-}
-
-// The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number...
-{
-	const x = new Float32Array( 10 );
-	const y = new Float32Array( 10 );
-
-	snancusumkbn.ndarray( x.length, 0.0, x, '10', 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, true, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, false, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, null, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, undefined, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, [], 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, {}, 0, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, ( x: number ): number => x, 0, y, 1, 0 ); // $ExpectError
-}
-
-// The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a number...
-{
-	const x = new Float32Array( 10 );
-	const y = new Float32Array( 10 );
-
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, '10', y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, true, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, false, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, null, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, undefined, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, [], y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, {}, y, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, ( x: number ): number => x, y, 1, 0 ); // $ExpectError
-}
-
-// The compiler throws an error if the `ndarray` method is provided a sixth argument which is not a Float32Array...
-{
-	const x = new Float32Array( 10 );
-
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, 10, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, '10', 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, true, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, false, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, null, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, undefined, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, [ '1' ], 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, {}, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, ( x: number ): number => x, 1, 0 ); // $ExpectError
-}
-
-// The compiler throws an error if the `ndarray` method is provided a seventh argument which is not a number...
-{
-	const x = new Float32Array( 10 );
-	const y = new Float32Array( 10 );
-
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, '10', 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, true, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, false, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, null, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, undefined, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, [], 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, {}, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, ( x: number ): number => x, 0 ); // $ExpectError
-}
-
-// The compiler throws an error if the `ndarray` method is provided an eighth argument which is not a number...
-{
-	const x = new Float32Array( 10 );
-	const y = new Float32Array( 10 );
-
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, '10' ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, true ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, false ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, null ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, undefined ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, [] ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, {} ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, ( x: number ): number => x ); // $ExpectError
-}
-
-// The compiler throws an error if the `ndarray` method is provided an unsupported number of arguments...
-{
-	const x = new Float32Array( 10 );
-	const y = new Float32Array( 10 );
-
-	snancusumkbn.ndarray(); // $ExpectError
-	snancusumkbn.ndarray( x.length ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1 ); // $ExpectError
-	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0, 10 ); // $ExpectError
-}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/README.md b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/README.md
similarity index 76%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/README.md
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/README.md
index 27b1db49f968..51230477530e 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/README.md
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/README.md
@@ -18,9 +18,9 @@ limitations under the License.
 
 -->
 
-# snancusumkbn
+# snancusumkbn2
 
-> Calculate the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+> Calculate the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
 
 <section class="intro">
 
@@ -33,12 +33,12 @@ limitations under the License.
 ## Usage
 
 ```javascript
-var snancusumkbn = require( '@stdlib/blas/ext/base/snancusumkbn' );
+var snancusumkbn2 = require( '@stdlib/blas/ext/base/snancusumkbn2' );
 ```
 
-#### snancusumkbn( N, sum, x, strideX, y, strideY )
+#### snancusumkbn2( N, sum, x, strideX, y, strideY )
 
-Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
 
 ```javascript
 var Float32Array = require( '@stdlib/array/float32' );
@@ -46,13 +46,13 @@ var Float32Array = require( '@stdlib/array/float32' );
 var x = new Float32Array( [ 1.0, -2.0, NaN ] );
 var y = new Float32Array( x.length );
 
-snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+snancusumkbn2( x.length, 0.0, x, 1, y, 1 );
 // y => <Float32Array>[ 1.0, -1.0, -1.0 ]
 
 x = new Float32Array( [ 1.0, -2.0, NaN ] );
 y = new Float32Array( x.length );
 
-snancusumkbn( x.length, 10.0, x, 1, y, 1 );
+snancusumkbn2( x.length, 10.0, x, 1, y, 1 );
 // y => <Float32Array>[ 11.0, 9.0, 9.0 ]
 ```
 
@@ -73,7 +73,7 @@ var Float32Array = require( '@stdlib/array/float32' );
 var x = new Float32Array( [ 1.0, 2.0, 2.0, -7.0, -2.0, 3.0, NaN, NaN ] );
 var y = new Float32Array( x.length );
 
-var v = snancusumkbn( 4, 0.0, x, 2, y, 1 );
+var v = snancusumkbn2( 4, 0.0, x, 2, y, 1 );
 // y => <Float32Array>[ 1.0, 3.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0 ]
 ```
 
@@ -92,13 +92,13 @@ var y0 = new Float32Array( x0.length );
 var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
 var y1 = new Float32Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 ); // start at 4th element
 
-snancusumkbn( 4, 0.0, x1, -2, y1, 1 );
+snancusumkbn2( 4, 0.0, x1, -2, y1, 1 );
 // y0 => <Float32Array>[ 0.0, 0.0, 0.0, 0.0, 2.0, 0.0, 1.0, 0.0 ]
 ```
 
-#### snancusumkbn.ndarray( N, sum, x, strideX, offsetX, y, strideY, offsetY )
+#### snancusumkbn2.ndarray( N, sum, x, strideX, offsetX, y, strideY, offsetY )
 
-Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm and alternative indexing semantics.
+Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm and alternative indexing semantics.
 
 ```javascript
 var Float32Array = require( '@stdlib/array/float32' );
@@ -106,7 +106,7 @@ var Float32Array = require( '@stdlib/array/float32' );
 var x = new Float32Array( [ 1.0, -2.0, NaN ] );
 var y = new Float32Array( x.length );
 
-snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 );
+snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 );
 // y => <Float32Array>[ 1.0, -1.0, -1.0 ]
 ```
 
@@ -123,7 +123,7 @@ var Float32Array = require( '@stdlib/array/float32' );
 var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, NaN, NaN ] );
 var y = new Float32Array( x.length );
 
-snancusumkbn.ndarray( 4, 0.0, x, 2, 1, y, -1, y.length-1 );
+snancusumkbn2.ndarray( 4, 0.0, x, 2, 1, y, -1, y.length-1 );
 // y => <Float32Array>[ 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, -1.0, 1.0 ]
 ```
 
@@ -152,7 +152,7 @@ var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
 var bernoulli = require( '@stdlib/random/base/bernoulli' );
 var filledarrayBy = require( '@stdlib/array/filled-by' );
 var zeros = require( '@stdlib/array/zeros' );
-var snancusumkbn = require( '@stdlib/blas/ext/base/snancusumkbn' );
+var snancusumkbn2 = require( '@stdlib/blas/ext/base/snancusumkbn2' );
 
 function rand() {
     if ( bernoulli( 0.7 ) > 0 ) {
@@ -167,7 +167,7 @@ console.log( x );
 var y = zeros( 10, 'float32' );
 console.log( y );
 
-snancusumkbn( x.length, 0.0, x, 1, y, -1 );
+snancusumkbn2( x.length, 0.0, x, 1, y, -1 );
 console.log( y );
 ```
 
@@ -198,18 +198,18 @@ console.log( y );
 ### Usage
 
 ```c
-#include "stdlib/blas/ext/base/snancusumkbn.h"
+#include "stdlib/blas/ext/base/snancusumkbn2.h"
 ```
 
-#### stdlib_strided_snancusumkbn( N, sum, \*X, strideX, \*Y, strideY )
+#### stdlib_strided_snancusumkbn2( N, sum, \*X, strideX, \*Y, strideY )
 
-Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
 
 ```c
 const float x[] = { 1.0f, 2.0f, 3.0f, 4.0f };
 float y[] = { 0.0f, 0.0f, 0.0f, 0.0f };
 
-stdlib_strided_snancusumkbn( 4, 0.0f, x, 1, y, 1 );
+stdlib_strided_snancusumkbn2( 4, 0.0f, x, 1, y, 1 );
 ```
 
 The function accepts the following arguments:
@@ -222,22 +222,22 @@ The function accepts the following arguments:
 -   **strideY**: `[in] CBLAS_INT` stride length for `Y`.
 
 ```c
-void stdlib_strided_snancusumkbn( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, float *Y, const CBLAS_INT strideY );
+void stdlib_strided_snancusumkbn2( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, float *Y, const CBLAS_INT strideY );
 ```
 
 <!-- lint disable maximum-heading-length -->
 
-#### stdlib_strided_snancusumkbn_ndarray( N, sum, \*X, strideX, offsetX, \*Y, strideY, offsetY )
+#### stdlib_strided_snancusumkbn2_ndarray( N, sum, \*X, strideX, offsetX, \*Y, strideY, offsetY )
 
 <!-- lint enable maximum-heading-length -->
 
-Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm and alternative indexing semantics.
+Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm and alternative indexing semantics.
 
 ```c
 const float x[] = { 1.0f, 2.0f, 3.0f, 4.0f };
 float y[] = { 0.0f, 0.0f, 0.0f, 0.0f };
 
-stdlib_strided_snancusumkbn_ndarray( 4, 0.0f, x, 1, 0, y, 1, 0 );
+stdlib_strided_snancusumkbn2_ndarray( 4, 0.0f, x, 1, 0, y, 1, 0 );
 ```
 
 The function accepts the following arguments:
@@ -252,7 +252,7 @@ The function accepts the following arguments:
 -   **offsetY**: `[in] CBLAS_INT` starting index for `Y`.
 
 ```c
-void stdlib_strided_snancusumkbn_ndarray( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, float *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY );
+void stdlib_strided_snancusumkbn2_ndarray( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, float *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY );
 ```
 
 </section>
@@ -274,7 +274,7 @@ void stdlib_strided_snancusumkbn_ndarray( const CBLAS_INT N, const float sum, co
 ### Examples
 
 ```c
-#include "stdlib/blas/ext/base/snancusumkbn.h"
+#include "stdlib/blas/ext/base/snancusumkbn2.h"
 #include <stdio.h>
 
 int main( void ) {
@@ -290,7 +290,7 @@ int main( void ) {
     const int strideY = -2;
 
     // Compute the cumulative sum:
-    stdlib_strided_snancusumkbn( N, 0.0f, x, strideX, y, strideY );
+    stdlib_strided_snancusumkbn2( N, 0.0f, x, strideX, y, strideY );
 
     // Print the result:
     for ( int i = 0; i < 8; i++ ) {
@@ -311,7 +311,7 @@ int main( void ) {
 
 ## 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][@neumaier:1974a].
+-   Klein, Andreas. 2005. "A Generalized Kahan-Babuška-Summation-Algorithm." _Computing_ 76 (3): 279–93. doi:[10.1007/s00607-005-0139-x][@klein:2005a].
 
 </section>
 
@@ -333,7 +333,7 @@ int main( void ) {
 
 [mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
 
-[@neumaier:1974a]: https://doi.org/10.1002/zamm.19740540106
+[@klein:2005a]: https://doi.org/10.1007/s00607-005-0139-x
 
 </section>
 
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.js
similarity index 95%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.js
index 32ad54719e82..c725c8ed9ced 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.js
@@ -29,7 +29,7 @@ var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var format = require( '@stdlib/string/format' );
 var pkg = require( './../package.json' ).name;
-var snancusumkbn = require( './../lib/snancusumkbn.js' );
+var snancusumkbn2 = require( './../lib/snancusumkbn2.js' );
 
 
 // VARIABLES //
@@ -73,7 +73,7 @@ function createBenchmark( len ) {
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
 			x[ 0 ] += 1.0;
-			v = snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+			v = snancusumkbn2( x.length, 0.0, x, 1, y, 1 );
 			if ( isnanf( v[ i % len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.native.js
similarity index 92%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.native.js
index b08b799fe44f..37d45eb575f9 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.native.js
@@ -38,9 +38,9 @@ var pkg = require( './../package.json' ).name;
 var options = {
 	'dtype': 'float32'
 };
-var snancusumkbn = tryRequire( resolve( __dirname, './../lib/snancusumkbn.native.js' ) );
+var snancusumkbn2 = tryRequire( resolve( __dirname, './../lib/snancusumkbn2.native.js' ) );
 var opts = {
-	'skip': ( snancusumkbn instanceof Error )
+	'skip': ( snancusumkbn2 instanceof Error )
 };
 
 
@@ -78,7 +78,7 @@ function createBenchmark( len ) {
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
 			x[ 0 ] += 1.0;
-			v = snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+			v = snancusumkbn2( x.length, 0.0, x, 1, y, 1 );
 			if ( isnanf( v[ i % len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.js
similarity index 95%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.js
index 8b511c2dc0a3..5d555de147fa 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.js
@@ -29,7 +29,7 @@ var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var pow = require( '@stdlib/math/base/special/pow' );
 var format = require( '@stdlib/string/format' );
 var pkg = require( './../package.json' ).name;
-var snancusumkbn = require( './../lib/ndarray.js' );
+var snancusumkbn2 = require( './../lib/ndarray.js' );
 
 
 // VARIABLES //
@@ -73,7 +73,7 @@ function createBenchmark( len ) {
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
 			x[ 0 ] += 1.0;
-			v = snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+			v = snancusumkbn2( x.length, 0.0, x, 1, 0, y, 1, 0 );
 			if ( isnanf( v[ i % len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.native.js
similarity index 92%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.native.js
index 76a972243f0f..e40fd1bee1ef 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.native.js
@@ -38,9 +38,9 @@ var pkg = require( './../package.json' ).name;
 var options = {
 	'dtype': 'float32'
 };
-var snancusumkbn = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) );
+var snancusumkbn2 = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) );
 var opts = {
-	'skip': ( snancusumkbn instanceof Error )
+	'skip': ( snancusumkbn2 instanceof Error )
 };
 
 
@@ -78,7 +78,7 @@ function createBenchmark( len ) {
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
 			x[ 0 ] += 1.0;
-			v = snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+			v = snancusumkbn2( x.length, 0.0, x, 1, 0, y, 1, 0 );
 			if ( isnanf( v[ i % len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/Makefile b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/c/Makefile
similarity index 100%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/Makefile
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/c/Makefile
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/benchmark.length.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/c/benchmark.length.c
similarity index 95%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/benchmark.length.c
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/c/benchmark.length.c
index dfe6030755b4..b7c8125aae9a 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/benchmark.length.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/c/benchmark.length.c
@@ -17,13 +17,13 @@
 */
 
 #include <sys/time.h>
-#include "stdlib/blas/ext/base/snancusumkbn.h"
+#include "stdlib/blas/ext/base/snancusumkbn2.h"
 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
 
-#define NAME "snancusumkbn"
+#define NAME "snancusumkbn2"
 #define ITERATIONS 1000000
 #define REPEATS 3
 #define MIN 1
@@ -114,7 +114,7 @@ static float benchmark1( int iterations, int len ) {
 	t = tic();
 	for ( i = 0; i < iterations; i++ ) {
 		x[ 0 ] += 1.0f;
-		stdlib_strided_snancusumkbn( len, 0.0f, x, 1, y, 1 );
+		stdlib_strided_snancusumkbn2( len, 0.0f, x, 1, y, 1 );
 		if ( y[ 0 ] != y[ 0 ] ) {
 			printf( "should not return NaN\n" );
 			break;
@@ -156,7 +156,7 @@ static float benchmark2( int iterations, int len ) {
 	t = tic();
 	for ( i = 0; i < iterations; i++ ) {
 		x[ 0 ] += 1.0f;
-		stdlib_strided_snancusumkbn_ndarray( len, 0.0f, x, 1, 0, y, 1, 0 );
+		stdlib_strided_snancusumkbn2_ndarray( len, 0.0f, x, 1, 0, y, 1, 0 );
 		if ( y[ 0 ] != y[ 0 ] ) {
 			printf( "should not return NaN\n" );
 			break;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/binding.gyp b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/binding.gyp
similarity index 100%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/binding.gyp
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/binding.gyp
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/repl.txt b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/docs/repl.txt
similarity index 93%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/repl.txt
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/docs/repl.txt
index f8488b0d626b..611bbd2560f6 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/repl.txt
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/docs/repl.txt
@@ -1,8 +1,8 @@
 
 {{alias}}( N, sum, x, strideX, y, strideY )
     Computes the cumulative sum of single-precision floating-point strided array
-    elements ignoring `NaN` values and using an improved Kahan–Babuška
-    algorithm.
+    elements ignoring `NaN` values and using a second-order iterative
+    Kahan–Babuška algorithm.
 
     The `N` and stride parameters determine which elements in the strided arrays
     are accessed at runtime.
@@ -64,8 +64,8 @@
 
 {{alias}}.ndarray( N, sum, x, strideX, offsetX, y, strideY, offsetY )
     Computes the cumulative sum of single-precision floating-point strided array
-    elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm
-    and alternative indexing semantics.
+    elements ignoring `NaN` values and using a second-order iterative
+    Kahan–Babuška algorithm and alternative indexing semantics.
 
     While typed array views mandate a view offset based on the underlying
     buffer, the offset parameters support indexing semantics based on starting
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/docs/types/index.d.ts
similarity index 80%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/index.d.ts
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/docs/types/index.d.ts
index 981167bcdbb2..6b70e888f38d 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/docs/types/index.d.ts
@@ -19,11 +19,11 @@
 // TypeScript Version: 4.1
 
 /**
-* Interface describing `snancusumkbn`.
+* Interface describing `snancusumkbn2`.
 */
 interface Routine {
 	/**
-	* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+	* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
 	*
 	* @param N - number of indexed elements
 	* @param sum - initial sum
@@ -39,13 +39,13 @@ interface Routine {
 	* var x = new Float32Array( [ 1.0, NaN, 2.0 ] );
 	* var y = new Float32Array( x.length );
 	*
-	* snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	* snancusumkbn2( x.length, 0.0, x, 1, y, 1 );
 	* // y => <Float32Array>[ 1.0, 1.0, 3.0 ]
 	*/
 	( N: number, sum: number, x: Float32Array, strideX: number, y: Float32Array, strideY: number ): Float32Array;
 
 	/**
-	* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm and alternative indexing semantics.
+	* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm and alternative indexing semantics.
 	*
 	* @param N - number of indexed elements
 	* @param sum - initial sum
@@ -63,14 +63,14 @@ interface Routine {
 	* var x = new Float32Array( [ 1.0, -2.0, NaN ] );
 	* var y = new Float32Array( x.length );
 	*
-	* snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	* snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 );
 	* // y => <Float32Array>[ 1.0, -1.0, -1.0 ]
 	*/
 	ndarray( N: number, sum: number, x: Float32Array, strideX: number, offsetX: number, y: Float32Array, strideY: number, offsetY: number ): Float32Array;
 }
 
 /**
-* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
 *
 * @param N - number of indexed elements
 * @param sum - initial sum
@@ -86,7 +86,7 @@ interface Routine {
 * var x = new Float32Array( [ 1.0, -2.0, NaN ] );
 * var y = new Float32Array( x.length );
 *
-* snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+* snancusumkbn2( x.length, 0.0, x, 1, y, 1 );
 * // y => <Float32Array>[ 1.0, -1.0, -1.0 ]
 *
 * @example
@@ -95,12 +95,12 @@ interface Routine {
 * var x = new Float32Array( [ 1.0, -2.0, NaN ] );
 * var y = new Float32Array( x.length );
 *
-* snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 );
+* snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 );
 * // y => <Float32Array>[ 1.0, -1.0, -1.0 ]
 */
-declare var snancusumkbn: Routine;
+declare var snancusumkbn2: Routine;
 
 
 // EXPORTS //
 
-export = snancusumkbn;
+export = snancusumkbn2;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/docs/types/test.ts b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/docs/types/test.ts
new file mode 100644
index 000000000000..d666e51964a0
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/docs/types/test.ts
@@ -0,0 +1,280 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+import snancusumkbn2 = require( './index' );
+
+
+// TESTS //
+
+// The function returns a Float32Array...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn2( x.length, 0.0, x, 1, y, 1 ); // $ExpectType Float32Array
+}
+
+// The compiler throws an error if the function is provided a first argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn2( '10', 0.0, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn2( true, 0.0, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn2( false, 0.0, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn2( null, 0.0, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn2( undefined, 0.0, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn2( [], 0.0, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn2( {}, 0.0, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn2( ( x: number ): number => x, 0.0, x, 1, y, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn2( x.length, '10', x, 1, y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, true, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, false, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, null, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, undefined, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, [], x, 1, y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, {}, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, ( x: number ): number => x, x, 1, y, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a third argument which is not a Float32Array...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn2( x.length, 0.0, 10, 1, y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, '10', 1, y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, true, 1, y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, false, 1, y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, null, 1, y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, undefined, 1, y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, [ '1' ], 1, y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, {}, 1, y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, ( x: number ): number => x, 1, y, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fourth argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn2( x.length, 0.0, x, '10', y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, true, y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, false, y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, null, y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, undefined, y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, [], y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, {}, y, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, ( x: number ): number => x, y, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fifth argument which is not a Float32Array...
+{
+	const x = new Float32Array( 10 );
+
+	snancusumkbn2( x.length, 0.0, x, 1, 10, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, 1, '10', 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, 1, true, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, 1, false, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, 1, null, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, 1, undefined, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, 1, [ '1' ], 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, 1, {}, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, 1, ( x: number ): number => x, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a sixth argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn2( x.length, 0.0, x, 1, y, '10' ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, 1, y, true ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, 1, y, false ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, 1, y, null ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, 1, y, undefined ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, 1, y, [] ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, 1, y, {} ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, 1, y, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn2(); // $ExpectError
+	snancusumkbn2( x.length ); // $ExpectError
+	snancusumkbn2( x.length, 0.0 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, 1 ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, 1, y ); // $ExpectError
+	snancusumkbn2( x.length, 0.0, x, 1, y, 1, 10 ); // $ExpectError
+}
+
+// Attached to main export is an `ndarray` method which returns a Float32Array...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectType Float32Array
+}
+
+// The compiler throws an error if the `ndarray` method is provided a first argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn2.ndarray( '10', 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( true, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( false, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( null, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( undefined, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( [], 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( {}, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( ( x: number ): number => x, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a second argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn2.ndarray( x.length, '10', x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, true, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, false, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, null, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, undefined, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, [], x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, {}, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, ( x: number ): number => x, x, 1, 0, y, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a third argument which is not a Float32Array...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn2.ndarray( x.length, 0.0, 10, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, '10', 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, true, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, false, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, null, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, undefined, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, [ '1' ], 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, {}, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, ( x: number ): number => x, 1, 0, y, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn2.ndarray( x.length, 0.0, x, '10', 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, true, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, false, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, null, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, undefined, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, [], 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, {}, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, ( x: number ): number => x, 0, y, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, '10', y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, true, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, false, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, null, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, undefined, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, [], y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, {}, y, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, ( x: number ): number => x, y, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a sixth argument which is not a Float32Array...
+{
+	const x = new Float32Array( 10 );
+
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, 10, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, '10', 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, true, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, false, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, null, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, undefined, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, [ '1' ], 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, {}, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, ( x: number ): number => x, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a seventh argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, '10', 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, true, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, false, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, null, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, undefined, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, [], 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, {}, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, ( x: number ): number => x, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided an eighth argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, 1, '10' ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, 1, true ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, 1, false ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, 1, null ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, 1, undefined ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, 1, [] ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, 1, {} ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, 1, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided an unsupported number of arguments...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn2.ndarray(); // $ExpectError
+	snancusumkbn2.ndarray( x.length ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, 1 ); // $ExpectError
+	snancusumkbn2.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0, 10 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/Makefile b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/examples/c/Makefile
similarity index 100%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/Makefile
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/examples/c/Makefile
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/example.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/examples/c/example.c
similarity index 90%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/example.c
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/examples/c/example.c
index 602bdb365b3b..003d23055887 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/example.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/examples/c/example.c
@@ -16,7 +16,7 @@
 * limitations under the License.
 */
 
-#include "stdlib/blas/ext/base/snancusumkbn.h"
+#include "stdlib/blas/ext/base/snancusumkbn2.h"
 #include <stdio.h>
 
 int main( void ) {
@@ -32,7 +32,7 @@ int main( void ) {
 	const int strideY = -2;
 
 	// Compute the cumulative sum:
-	stdlib_strided_snancusumkbn( N, 0.0f, x, strideX, y, strideY );
+	stdlib_strided_snancusumkbn2( N, 0.0f, x, strideX, y, strideY );
 
 	// Print the result:
 	for ( int i = 0; i < 8; i++ ) {
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/index.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/examples/index.js
similarity index 92%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/index.js
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/examples/index.js
index b19d8cbbef62..1ab6a646c658 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/index.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/examples/index.js
@@ -22,7 +22,7 @@ var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
 var bernoulli = require( '@stdlib/random/base/bernoulli' );
 var filledarrayBy = require( '@stdlib/array/filled-by' );
 var zeros = require( '@stdlib/array/zeros' );
-var snancusumkbn = require( './../lib' );
+var snancusumkbn2 = require( './../lib' );
 
 function rand() {
 	if ( bernoulli( 0.7 ) > 0 ) {
@@ -37,5 +37,5 @@ console.log( x );
 var y = zeros( x.length, 'float32' );
 console.log( y );
 
-snancusumkbn( x.length, 0.0, x, 1, y, -1 );
+snancusumkbn2( x.length, 0.0, x, 1, y, -1 );
 console.log( y );
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include.gypi b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/include.gypi
similarity index 100%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include.gypi
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/include.gypi
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include/stdlib/blas/ext/base/snancusumkbn.h b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/include/stdlib/blas/ext/base/snancusumkbn2.h
similarity index 56%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include/stdlib/blas/ext/base/snancusumkbn.h
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/include/stdlib/blas/ext/base/snancusumkbn2.h
index fe2b89c86a2a..49025b79c414 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include/stdlib/blas/ext/base/snancusumkbn.h
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/include/stdlib/blas/ext/base/snancusumkbn2.h
@@ -16,8 +16,8 @@
 * limitations under the License.
 */
 
-#ifndef STDLIB_BLAS_EXT_BASE_SNANCUSUMKBN_H
-#define STDLIB_BLAS_EXT_BASE_SNANCUSUMKBN_H
+#ifndef STDLIB_BLAS_EXT_BASE_SNANCUSUMKBN2_H
+#define STDLIB_BLAS_EXT_BASE_SNANCUSUMKBN2_H
 
 #include "stdlib/blas/base/shared.h"
 
@@ -29,17 +29,17 @@ extern "C" {
 #endif
 
 /**
-* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
 */
-void API_SUFFIX( stdlib_strided_snancusumkbn )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, float *Y, const CBLAS_INT strideY );
+void API_SUFFIX( stdlib_strided_snancusumkbn2 )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, float *Y, const CBLAS_INT strideY );
 
 /**
-* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm and alternative indexing semantics.
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm and alternative indexing semantics.
 */
-void API_SUFFIX( stdlib_strided_snancusumkbn_ndarray )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, float *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY );
+void API_SUFFIX( stdlib_strided_snancusumkbn2_ndarray )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, float *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY );
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif // !STDLIB_BLAS_EXT_BASE_SNANCUSUMKBN_H
+#endif // !STDLIB_BLAS_EXT_BASE_SNANCUSUMKBN2_H
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/index.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/index.js
similarity index 73%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/index.js
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/index.js
index 066ff94623ae..13060a0f086a 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/index.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/index.js
@@ -19,28 +19,28 @@
 'use strict';
 
 /**
-* Compute the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+* Compute the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
 *
-* @module @stdlib/blas/ext/base/snancusumkbn
+* @module @stdlib/blas/ext/base/snancusumkbn2
 *
 * @example
 * var Float32Array = require( '@stdlib/array/float32' );
-* var snancusumkbn = require( '@stdlib/blas/ext/base/snancusumkbn' );
+* var snancusumkbn2 = require( '@stdlib/blas/ext/base/snancusumkbn2' );
 *
 * var x = new Float32Array( [ 1.0, -2.0, NaN ] );
 * var y = new Float32Array( x.length );
 *
-* snancusumkbn( 3, 0.0, x, 1, y, 1 );
+* snancusumkbn2( 3, 0.0, x, 1, y, 1 );
 * // y => <Float32Array>[ 1.0, -1.0, -1.0 ]
 *
 * @example
 * var Float32Array = require( '@stdlib/array/float32' );
-* var snancusumkbn = require( '@stdlib/blas/ext/base/snancusumkbn' );
+* var snancusumkbn2 = require( '@stdlib/blas/ext/base/snancusumkbn2' );
 *
 * var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, NaN, 3.0, NaN ] );
 * var y = new Float32Array( x.length );
 *
-* snancusumkbn.ndarray( 4, 0.0, x, 2, 1, y, 1, 0 );
+* snancusumkbn2.ndarray( 4, 0.0, x, 2, 1, y, 1, 0 );
 * // y => <Float32Array>[ 1.0, -1.0, -1.0, -1.0, 0.0, 0.0, 0.0, 0.0 ]
 */
 
@@ -54,17 +54,17 @@ var main = require( './main.js' );
 
 // MAIN //
 
-var snancusumkbn;
+var snancusumkbn2;
 var tmp = tryRequire( join( __dirname, './native.js' ) );
 if ( isError( tmp ) ) {
-	snancusumkbn = main;
+	snancusumkbn2 = main;
 } else {
-	snancusumkbn = tmp;
+	snancusumkbn2 = tmp;
 }
 
 
 // EXPORTS //
 
-module.exports = snancusumkbn;
+module.exports = snancusumkbn2;
 
-// exports: { "ndarray": "snancusumkbn.ndarray" }
+// exports: { "ndarray": "snancusumkbn2.ndarray" }
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/main.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/main.js
similarity index 82%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/main.js
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/main.js
index 154bf71a2416..aea8c79d995f 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/main.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/main.js
@@ -21,15 +21,15 @@
 // MODULES //
 
 var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
-var snancusumkbn = require( '@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js' );
+var snancusumkbn2 = require( './snancusumkbn2.js' );
 var ndarray = require( './ndarray.js' );
 
 
 // MAIN //
 
-setReadOnly( snancusumkbn, 'ndarray', ndarray );
+setReadOnly( snancusumkbn2, 'ndarray', ndarray );
 
 
 // EXPORTS //
 
-module.exports = snancusumkbn;
+module.exports = snancusumkbn2;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/native.js
similarity index 85%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/native.js
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/native.js
index 81faffe49cb7..146a1dcff6a1 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/native.js
@@ -21,15 +21,15 @@
 // MODULES //
 
 var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
-var snancusumkbn = require( './snancusumkbn.native.js' );
+var snancusumkbn2 = require( './snancusumkbn2.native.js' );
 var ndarray = require( './ndarray.native.js' );
 
 
 // MAIN //
 
-setReadOnly( snancusumkbn, 'ndarray', ndarray );
+setReadOnly( snancusumkbn2, 'ndarray', ndarray );
 
 
 // EXPORTS //
 
-module.exports = snancusumkbn;
+module.exports = snancusumkbn2;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/ndarray.js
similarity index 64%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/ndarray.js
index b2103738b738..13817966396a 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/ndarray.js
@@ -28,7 +28,15 @@ var absf = require( '@stdlib/math/base/special/absf' );
 // MAIN //
 
 /**
-* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
+*
+* ## Method
+*
+* -   This implementation uses a second-order iterative Kahan–Babuška algorithm, as described by Klein (2005).
+*
+* ## References
+*
+* -   Klein, Andreas. 2005. "A Generalized Kahan-Babuška-Summation-Algorithm." _Computing_ 76 (3): 279–93. doi:[10.1007/s00607-005-0139-x](https://doi.org/10.1007/s00607-005-0139-x).
 *
 * @param {PositiveInteger} N - number of indexed elements
 * @param {number} sum - initial sum
@@ -46,13 +54,15 @@ var absf = require( '@stdlib/math/base/special/absf' );
 * var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, NaN, NaN ] );
 * var y = new Float32Array( x.length );
 *
-* var v = snancusumkbn( 4, 0.0, x, 2, 1, y, 1, 0 );
+* var v = snancusumkbn2( 4, 0.0, x, 2, 1, y, 1, 0 );
 * // returns <Float32Array>[ 1.0, -1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0 ]
 */
-function snancusumkbn( N, sum, x, strideX, offsetX, y, strideY, offsetY ) {
+function snancusumkbn2( N, sum, x, strideX, offsetX, y, strideY, offsetY ) {
+	var ccs;
 	var ix;
 	var iy;
-	var s;
+	var cs;
+	var cc;
 	var v;
 	var t;
 	var c;
@@ -63,14 +73,13 @@ function snancusumkbn( N, sum, x, strideX, offsetX, y, strideY, offsetY ) {
 	}
 	ix = offsetX;
 	iy = offsetY;
-	s = sum;
 
 	// In order to preserve the sign of zero which can be lost during compensated summation below, find the first non-zero element...
-	if ( s === 0.0 ) {
+	if ( sum === 0.0 ) {
 		for ( i = 0; i < N; i++ ) {
 			v = x[ ix ];
 			if ( isnanf( v ) ) {
-				y[ iy ] = s;
+				y[ iy ] = sum;
 				ix += strideX;
 				iy += strideY;
 				continue;
@@ -78,31 +87,41 @@ function snancusumkbn( N, sum, x, strideX, offsetX, y, strideY, offsetY ) {
 			if ( v !== 0.0 ) {
 				break;
 			}
-			s = f32( s + v );
-			y[ iy ] = s;
+			sum = f32( sum + v );
+			y[ iy ] = sum;
 			ix += strideX;
 			iy += strideY;
 		}
 	} else {
 		i = 0;
 	}
-	c = 0.0;
+	ccs = 0.0; // second order correction term for lost low order bits
+	cs = 0.0; // first order correction term for lost low order bits
 	for ( ; i < N; i++ ) {
 		v = x[ ix ];
 		if ( isnanf( v ) ) {
-			y[ iy ] = f32( s + c );
+			y[ iy ] = f32( sum + f32( cs + ccs ) );
 			ix += strideX;
 			iy += strideY;
 			continue;
 		}
-		t = f32( s + v );
-		if ( absf( s ) >= absf( v ) ) {
-			c = f32( c + f32( f32( s - t ) + v ) );
+		t = f32( sum + v );
+		if ( absf( sum ) >= absf( v ) ) {
+			c = f32( f32( sum - t ) + v );
 		} else {
-			c = f32( c + f32( f32( v - t ) + s ) );
+			c = f32( f32( v - t ) + sum );
 		}
-		s = t;
-		y[ iy ] = f32( s + c );
+		sum = t;
+		t = f32( cs + c );
+		if ( absf( cs ) >= absf( c ) ) {
+			cc = f32( f32( cs - t ) + c );
+		} else {
+			cc = f32( f32( c - t ) + cs );
+		}
+		cs = t;
+		ccs = f32( ccs + cc );
+
+		y[ iy ] = f32( sum + f32( cs + ccs ) );
 		ix += strideX;
 		iy += strideY;
 	}
@@ -112,4 +131,4 @@ function snancusumkbn( N, sum, x, strideX, offsetX, y, strideY, offsetY ) {
 
 // EXPORTS //
 
-module.exports = snancusumkbn;
+module.exports = snancusumkbn2;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/ndarray.native.js
similarity index 85%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.native.js
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/ndarray.native.js
index 0d8bb4549eb3..50a09380d501 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/ndarray.native.js
@@ -26,7 +26,7 @@ var addon = require( './../src/addon.node' );
 // MAIN //
 
 /**
-* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
 *
 * @param {PositiveInteger} N - number of indexed elements
 * @param {number} sum - initial sum
@@ -44,10 +44,10 @@ var addon = require( './../src/addon.node' );
 * var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, NaN, NaN ] );
 * var y = new Float32Array( x.length );
 *
-* var v = snancusumkbn( 4, 0.0, x, 2, 1, y, 1, 0 );
+* var v = snancusumkbn2( 4, 0.0, x, 2, 1, y, 1, 0 );
 * // returns <Float32Array>[ 1.0, -1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0 ]
 */
-function snancusumkbn( N, sum, x, strideX, offsetX, y, strideY, offsetY ) {
+function snancusumkbn2( N, sum, x, strideX, offsetX, y, strideY, offsetY ) {
 	addon.ndarray( N, sum, x, strideX, offsetX, y, strideY, offsetY );
 	return y;
 }
@@ -55,4 +55,4 @@ function snancusumkbn( N, sum, x, strideX, offsetX, y, strideY, offsetY ) {
 
 // EXPORTS //
 
-module.exports = snancusumkbn;
+module.exports = snancusumkbn2;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.js
similarity index 69%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.js
index 03225d68cc34..953d255f08da 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.js
@@ -21,21 +21,21 @@
 // MODULES //
 
 var stride2offset = require( '@stdlib/strided/base/stride2offset' );
-var ndarray = require( '@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js' );
+var ndarray = require( '@stdlib/blas/ext/base/snancusumkbn2/lib/ndarray.js' );
 
 
 // MAIN //
 
 /**
-* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
 *
 * ## Method
 *
-* -   This implementation uses an "improved Kahan–Babuška algorithm", as described by Neumaier (1974).
+* -   This implementation uses a second-order iterative Kahan–Babuška algorithm, as described by Klein (2005).
 *
 * ## 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).
+* -   Klein, Andreas. 2005. "A Generalized Kahan-Babuška-Summation-Algorithm." _Computing_ 76 (3): 279–93. doi:[10.1007/s00607-005-0139-x](https://doi.org/10.1007/s00607-005-0139-x).
 *
 * @param {PositiveInteger} N - number of indexed elements
 * @param {number} sum - initial sum
@@ -51,10 +51,10 @@ var ndarray = require( '@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js' );
 * var x = new Float32Array( [ 1.0, -2.0, NaN ] );
 * var y = new Float32Array( x.length );
 *
-* var v = snancusumkbn( 3, 0.0, x, 1, y, 1 );
+* var v = snancusumkbn2( 3, 0.0, x, 1, y, 1 );
 * // returns <Float32Array>[ 1.0, -1.0, -1.0 ]
 */
-function snancusumkbn( N, sum, x, strideX, y, strideY ) {
+function snancusumkbn2( N, sum, x, strideX, y, strideY ) {
 	ndarray( N, sum, x, strideX, stride2offset( N, strideX ), y, strideY, stride2offset( N, strideY ) ); // eslint-disable-line max-len
 	return y;
 }
@@ -62,4 +62,4 @@ function snancusumkbn( N, sum, x, strideX, y, strideY ) {
 
 // EXPORTS //
 
-module.exports = snancusumkbn;
+module.exports = snancusumkbn2;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.native.js
similarity index 84%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.native.js
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.native.js
index c18f35555c3b..7803a1a229fe 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.native.js
@@ -26,7 +26,7 @@ var addon = require( './../src/addon.node' );
 // MAIN //
 
 /**
-* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
 *
 * @param {PositiveInteger} N - number of indexed elements
 * @param {number} sum - initial sum
@@ -42,10 +42,10 @@ var addon = require( './../src/addon.node' );
 * var x = new Float32Array( [ 1.0, -2.0, NaN ] );
 * var y = new Float32Array( x.length );
 *
-* var v = snancusumkbn( 3, 0.0, x, 1, y, 1 );
+* var v = snancusumkbn2( 3, 0.0, x, 1, y, 1 );
 * // returns <Float32Array>[ 1.0, -1.0, -1.0 ]
 */
-function snancusumkbn( N, sum, x, strideX, y, strideY ) {
+function snancusumkbn2( N, sum, x, strideX, y, strideY ) {
 	addon( N, sum, x, strideX, y, strideY );
 	return y;
 }
@@ -53,4 +53,4 @@ function snancusumkbn( N, sum, x, strideX, y, strideY ) {
 
 // EXPORTS //
 
-module.exports = snancusumkbn;
+module.exports = snancusumkbn2;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/manifest.json b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/manifest.json
similarity index 100%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/manifest.json
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/manifest.json
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/package.json b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/package.json
similarity index 92%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/package.json
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/package.json
index 0ae6f5809535..c53df549fe1c 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/package.json
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/package.json
@@ -1,7 +1,7 @@
 {
-  "name": "@stdlib/blas/ext/base/snancusumkbn",
+  "name": "@stdlib/blas/ext/base/snancusumkbn2",
   "version": "0.0.0",
-  "description": "Calculate the cumulative sum of single-precision floating-point strided array elements ignoring NaN values and using an improved Kahan–Babuška algorithm.",
+  "description": "Calculate the cumulative sum of single-precision floating-point strided array elements ignoring NaN values and using a second-order iterative Kahan–Babuška algorithm.",
   "license": "Apache-2.0",
   "author": {
     "name": "The Stdlib Authors",
@@ -66,7 +66,7 @@
     "summation",
     "cumulative",
     "accumulate",
-    "kbn",
+    "kbn2",
     "kahan",
     "compensated",
     "strided",
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/Makefile b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/Makefile
similarity index 100%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/Makefile
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/Makefile
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/addon.c
similarity index 73%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/addon.c
index 5e6f0b28c9dd..ed5d5f407e8d 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/addon.c
@@ -18,10 +18,10 @@
 
 #include <node_api.h>
 #include "stdlib/blas/base/shared.h"
-#include "stdlib/blas/ext/base/snancusumkbn.h"
+#include "stdlib/blas/ext/base/snancusumkbn2.h"
 #include "stdlib/napi/argv.h"
 #include "stdlib/napi/argv_float.h"
-#include "stdlib/napi/argv_int32.h"
+#include "stdlib/napi/argv_int64.h"
 #include "stdlib/napi/argv_strided_float32array.h"
 #include "stdlib/napi/export.h"
 
@@ -34,13 +34,13 @@
 */
 static napi_value addon( napi_env env, napi_callback_info info ) {
 	STDLIB_NAPI_ARGV( env, info, argv, argc, 6 );
-	STDLIB_NAPI_ARGV_INT32( env, N, argv, 0 );
+	STDLIB_NAPI_ARGV_INT64( env, N, argv, 0 );
 	STDLIB_NAPI_ARGV_FLOAT( env, sum, argv, 1 );
-	STDLIB_NAPI_ARGV_INT32( env, strideX, argv, 3 );
-	STDLIB_NAPI_ARGV_INT32( env, strideY, argv, 5 );
+	STDLIB_NAPI_ARGV_INT64( env, strideX, argv, 3 );
+	STDLIB_NAPI_ARGV_INT64( env, strideY, argv, 5 );
 	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, X, N, strideX, argv, 2 );
 	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, Y, N, strideY, argv, 4 );
-	API_SUFFIX( stdlib_strided_snancusumkbn )( N, sum, X, strideX, Y, strideY );
+	API_SUFFIX( stdlib_strided_snancusumkbn2 )( N, sum, X, strideX, Y, strideY );
 	return NULL;
 }
 
@@ -53,16 +53,16 @@ static napi_value addon( napi_env env, napi_callback_info info ) {
 */
 static napi_value addon_method( napi_env env, napi_callback_info info ) {
 	STDLIB_NAPI_ARGV( env, info, argv, argc, 8 );
-	STDLIB_NAPI_ARGV_INT32( env, N, argv, 0 );
+	STDLIB_NAPI_ARGV_INT64( env, N, argv, 0 );
 	STDLIB_NAPI_ARGV_FLOAT( env, sum, argv, 1 );
-	STDLIB_NAPI_ARGV_INT32( env, strideX, argv, 3 );
-	STDLIB_NAPI_ARGV_INT32( env, offsetX, argv, 4 );
-	STDLIB_NAPI_ARGV_INT32( env, strideY, argv, 6 );
-	STDLIB_NAPI_ARGV_INT32( env, offsetY, argv, 7 );
+	STDLIB_NAPI_ARGV_INT64( env, strideX, argv, 3 );
+	STDLIB_NAPI_ARGV_INT64( env, offsetX, argv, 4 );
+	STDLIB_NAPI_ARGV_INT64( env, strideY, argv, 6 );
+	STDLIB_NAPI_ARGV_INT64( env, offsetY, argv, 7 );
 	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, X, N, strideX, argv, 2 );
 	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, Y, N, strideY, argv, 5 );
-	API_SUFFIX( stdlib_strided_snancusumkbn_ndarray )( N, sum, X, strideX, offsetX, Y, strideY, offsetY );
+	API_SUFFIX( stdlib_strided_snancusumkbn2_ndarray )( N, sum, X, strideX, offsetX, Y, strideY, offsetY );
 	return NULL;
 }
 
-STDLIB_NAPI_MODULE_EXPORT_FCN_WITH_METHOD( addon, "ndarray", addon_method )
+STDLIB_NAPI_MODULE_EXPORT_FCN_WITH_METHOD( addon, "ndarray", addon_method );
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/main.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/main.c
similarity index 58%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/main.c
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/main.c
index a4e9ab0ec9f2..25ac02146674 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/main.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/main.c
@@ -17,21 +17,21 @@
 */
 
 #include "stdlib/blas/base/shared.h"
-#include "stdlib/blas/ext/base/snancusumkbn.h"
+#include "stdlib/blas/ext/base/snancusumkbn2.h"
 #include "stdlib/math/base/assert/is_nanf.h"
 #include "stdlib/math/base/special/absf.h"
 #include "stdlib/strided/base/stride2offset.h"
 
 /**
-* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
 *
 * ## Method
 *
-* -   This implementation uses an "improved Kahan–Babuška algorithm", as described by Neumaier (1974).
+* -   This implementation uses a "second-order iterative Kahan–Babuška algorithm", as described by Klein (2005).
 *
 * ## 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).
+* -   Klein, Andreas. 2005. "A Generalized Kahan-Babuška-Summation-Algorithm." _Computing_ 76 (3): 279-93. doi:[10.1007/s00607-005-0139-x](https://doi.org/10.1007/s00607-005-0139-x).
 *
 * @param N        number of indexed elements
 * @param sum      initial sum
@@ -40,22 +40,22 @@
 * @param Y        output array
 * @param strideY  stride length for Y
 */
-void API_SUFFIX( stdlib_strided_snancusumkbn )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, float *Y, const CBLAS_INT strideY ) {
+void API_SUFFIX( stdlib_strided_snancusumkbn2 )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, float *Y, const CBLAS_INT strideY ) {
 	const CBLAS_INT ox = stdlib_strided_stride2offset( N, strideX );
 	const CBLAS_INT oy = stdlib_strided_stride2offset( N, strideY );
-	API_SUFFIX( stdlib_strided_snancusumkbn_ndarray )( N, sum, X, strideX, ox, Y, strideY, oy );
+	API_SUFFIX( stdlib_strided_snancusumkbn2_ndarray )( N, sum, X, strideX, ox, Y, strideY, oy );
 }
 
 /**
-* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm and alternative indexing semantics.
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm and alternative indexing semantics.
 *
 * ## Method
 *
-* -   This implementation uses an "improved Kahan–Babuška algorithm", as described by Neumaier (1974).
+* -   This implementation uses a "second-order iterative Kahan–Babuška algorithm", as described by Klein (2005).
 *
 * ## 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).
+* -   Klein, Andreas. 2005. "A Generalized Kahan-Babuška-Summation-Algorithm." _Computing_ 76 (3): 279-93. doi:[10.1007/s00607-005-0139-x](https://doi.org/10.1007/s00607-005-0139-x).
 *
 * @param N        number of indexed elements
 * @param sum      initial sum
@@ -66,10 +66,13 @@ void API_SUFFIX( stdlib_strided_snancusumkbn )( const CBLAS_INT N, const float s
 * @param strideY  stride length for Y
 * @param offsetY  starting index for Y
 */
-void API_SUFFIX( stdlib_strided_snancusumkbn_ndarray )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, float *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY ) {
+void API_SUFFIX( stdlib_strided_snancusumkbn2_ndarray )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, float *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY ) {
 	CBLAS_INT ix;
 	CBLAS_INT iy;
 	CBLAS_INT i;
+	float ccs;
+	float cs;
+	float cc;
 	float s;
 	float v;
 	float t;
@@ -103,23 +106,33 @@ void API_SUFFIX( stdlib_strided_snancusumkbn_ndarray )( const CBLAS_INT N, const
 	} else {
 		i = 0;
 	}
-	c = 0.0f;
+	ccs = 0.0f; // second order correction term for lost low order bits
+	cs = 0.0f; // first order correction term for lost low order bits
 	for ( ; i < N; i++ ) {
 		v = X[ ix ];
 		if ( stdlib_base_is_nanf( v ) ) {
-			Y[ iy ] = s + c;
+			Y[ iy ] = s + cs + ccs;
 			ix += strideX;
 			iy += strideY;
 			continue;
 		}
 		t = s + v;
 		if ( stdlib_base_absf( s ) >= stdlib_base_absf( v ) ) {
-			c += ( s - t ) + v;
+			c = ( s - t ) + v;
 		} else {
-			c += ( v - t ) + s;
+			c = ( v - t ) + s;
 		}
 		s = t;
-		Y[ iy ] = s + c;
+		t = cs + c;
+		if ( stdlib_base_absf( cs ) >= stdlib_base_absf( c ) ) {
+			cc = ( cs - t ) + c;
+		} else {
+			cc = ( c - t ) + cs;
+		}
+		cs = t;
+		ccs += cc;
+
+		Y[ iy ] = s + cs + ccs;
 		ix += strideX;
 		iy += strideY;
 	}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.js
similarity index 76%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.js
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.js
index bbc4fec76d8b..322b4be7ebcb 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.js
@@ -23,7 +23,7 @@
 var tape = require( 'tape' );
 var proxyquire = require( 'proxyquire' );
 var IS_BROWSER = require( '@stdlib/assert/is-browser' );
-var snancusumkbn = require( './../lib' );
+var snancusumkbn2 = require( './../lib' );
 
 
 // VARIABLES //
@@ -37,21 +37,21 @@ var opts = {
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.strictEqual( typeof snancusumkbn, 'function', 'main export is a function' );
+	t.strictEqual( typeof snancusumkbn2, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'attached to the main export is a method providing an ndarray interface', function test( t ) {
-	t.strictEqual( typeof snancusumkbn.ndarray, 'function', 'method is a function' );
+	t.strictEqual( typeof snancusumkbn2.ndarray, 'function', 'method is a function' );
 	t.end();
 });
 
 tape( 'if a native implementation is available, the main export is the native implementation', opts, function test( t ) {
-	var snancusumkbn = proxyquire( './../lib', {
+	var snancusumkbn2 = proxyquire( './../lib', {
 		'@stdlib/utils/try-require': tryRequire
 	});
 
-	t.strictEqual( snancusumkbn, mock, 'returns expected value' );
+	t.strictEqual( snancusumkbn2, mock, 'returns expected value' );
 	t.end();
 
 	function tryRequire() {
@@ -64,16 +64,16 @@ tape( 'if a native implementation is available, the main export is the native im
 });
 
 tape( 'if a native implementation is not available, the main export is a JavaScript implementation', opts, function test( t ) {
-	var snancusumkbn;
+	var snancusumkbn2;
 	var main;
 
-	main = require( './../lib/snancusumkbn.js' );
+	main = require( './../lib/snancusumkbn2.js' );
 
-	snancusumkbn = proxyquire( './../lib', {
+	snancusumkbn2 = proxyquire( './../lib', {
 		'@stdlib/utils/try-require': tryRequire
 	});
 
-	t.strictEqual( snancusumkbn, main, 'returns expected value' );
+	t.strictEqual( snancusumkbn2, main, 'returns expected value' );
 	t.end();
 
 	function tryRequire() {
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.ndarray.js
similarity index 86%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.js
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.ndarray.js
index d610d24deb92..f3448b147520 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.ndarray.js
@@ -23,19 +23,19 @@
 var tape = require( 'tape' );
 var Float32Array = require( '@stdlib/array/float32' );
 var isSameFloat32Array = require( '@stdlib/assert/is-same-float32array' );
-var snancusumkbn = require( './../lib/ndarray.js' );
+var snancusumkbn2 = require( './../lib/ndarray.js' );
 
 
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.strictEqual( typeof snancusumkbn, 'function', 'main export is a function' );
+	t.strictEqual( typeof snancusumkbn2, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function has an arity of 8', function test( t ) {
-	t.strictEqual( snancusumkbn.length, 8, 'returns expected value' );
+	t.strictEqual( snancusumkbn2.length, 8, 'returns expected value' );
 	t.end();
 });
 
@@ -48,7 +48,7 @@ tape( 'the function calculates the cumulative sum (ignoring NaN values)', functi
 	x = new Float32Array( [ 1.0, 2.0, NaN, NaN, 5.0 ] );
 	y = new Float32Array( x.length );
 
-	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	snancusumkbn2( x.length, 0.0, x, 1, 0, y, 1, 0 );
 	expected = new Float32Array([
 		1.0,
 		3.0,
@@ -61,7 +61,7 @@ tape( 'the function calculates the cumulative sum (ignoring NaN values)', functi
 	x = new Float32Array( [ 1.0, 2.0, NaN, NaN, 5.0 ] );
 	y = new Float32Array( x.length );
 
-	snancusumkbn( x.length, 10.0, x, 1, 0, y, 1, 0 );
+	snancusumkbn2( x.length, 10.0, x, 1, 0, y, 1, 0 );
 	expected = new Float32Array([
 		11.0,
 		13.0,
@@ -73,7 +73,7 @@ tape( 'the function calculates the cumulative sum (ignoring NaN values)', functi
 
 	x = new Float32Array( [ NaN, NaN ] );
 	y = new Float32Array( x.length );
-	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	snancusumkbn2( x.length, 0.0, x, 1, 0, y, 1, 0 );
 	expected = new Float32Array([
 		0.0,
 		0.0
@@ -82,7 +82,7 @@ tape( 'the function calculates the cumulative sum (ignoring NaN values)', functi
 
 	x = new Float32Array( [ 1.0, NaN, 3.0, NaN ] );
 	y = new Float32Array( x.length );
-	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	snancusumkbn2( x.length, 0.0, x, 1, 0, y, 1, 0 );
 
 	expected = new Float32Array([
 		1.0,
@@ -94,7 +94,7 @@ tape( 'the function calculates the cumulative sum (ignoring NaN values)', functi
 
 	x = new Float32Array( [ 1.0, 1.0e38, NaN, -1.0e38 ] );
 	y = new Float32Array( x.length );
-	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	snancusumkbn2( x.length, 0.0, x, 1, 0, y, 1, 0 );
 
 	expected = new Float32Array([
 		1.0,
@@ -115,7 +115,7 @@ tape( 'the function calculates the cumulative sum (ignoring NaN values)', functi
 			expected[ i ] += expected[ i-1 ] + x[ i ];
 		}
 	}
-	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	snancusumkbn2( x.length, 0.0, x, 1, 0, y, 1, 0 );
 	t.deepEqual( y, expected, 'returns expected value' );
 
 	t.end();
@@ -129,7 +129,7 @@ tape( 'the function preserves the sign of zero', function test( t ) {
 	x = new Float32Array( [ -0.0, -0.0, -0.0, 0.0, 1.0 ] );
 	y = new Float32Array( x.length );
 
-	snancusumkbn( x.length, -0.0, x, 1, 0, y, 1, 0 );
+	snancusumkbn2( x.length, -0.0, x, 1, 0, y, 1, 0 );
 	expected = new Float32Array([
 		-0.0,
 		-0.0,
@@ -149,7 +149,7 @@ tape( 'the function returns a reference to the output array', function test( t )
 	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
 	y = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );
 
-	out = snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	out = snancusumkbn2( x.length, 0.0, x, 1, 0, y, 1, 0 );
 
 	t.strictEqual( out, y, 'same reference' );
 	t.end();
@@ -165,10 +165,10 @@ tape( 'if provided an `N` parameter less than or equal to `0`, the function retu
 
 	expected = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );
 
-	snancusumkbn( -1, 0.0, x, 1, 0, y, 1, 0 );
+	snancusumkbn2( -1, 0.0, x, 1, 0, y, 1, 0 );
 	t.deepEqual( y, expected, 'returns `y` unchanged' );
 
-	snancusumkbn( 0, 0.0, x, 1, 0, y, 1, 0 );
+	snancusumkbn2( 0, 0.0, x, 1, 0, y, 1, 0 );
 	t.deepEqual( y, expected, 'returns `y` unchanged' );
 
 	t.end();
@@ -194,7 +194,7 @@ tape( 'the function supports an `x` stride', function test( t ) {
 		0.0
 	]);
 
-	snancusumkbn( 3, 0.0, x, 2, 0, y, 1, 0 );
+	snancusumkbn2( 3, 0.0, x, 2, 0, y, 1, 0 );
 
 	expected = new Float32Array( [ 1.0, 1.0, 6.0, 0.0, 0.0 ] );
 
@@ -222,7 +222,7 @@ tape( 'the function supports a `y` stride', function test( t ) {
 		0.0  // 2
 	]);
 
-	snancusumkbn( 3, 0.0, x, 1, 0, y, 2, 0 );
+	snancusumkbn2( 3, 0.0, x, 1, 0, y, 2, 0 );
 
 	expected = new Float32Array( [ 1.0, 0.0, 3.0, 0.0, 3.0 ] );
 
@@ -250,7 +250,7 @@ tape( 'the function supports negative strides', function test( t ) {
 		0.0
 	]);
 
-	snancusumkbn( 3, 0.0, x, -2, x.length-1, y, -1, 2 );
+	snancusumkbn2( 3, 0.0, x, -2, x.length-1, y, -1, 2 );
 
 	expected = new Float32Array( [ 8.0, 8.0, 5.0, 0.0, 0.0 ] );
 
@@ -284,7 +284,7 @@ tape( 'the function supports an `x` offset', function test( t ) {
 		0.0
 	]);
 
-	snancusumkbn( 4, 0.0, x, 2, 1, y, 1, 0 );
+	snancusumkbn2( 4, 0.0, x, 2, 1, y, 1, 0 );
 
 	expected = new Float32Array( [ 0.0, -2.0, 0.0, 4.0, 0.0, 0.0, 0.0, 0.0 ] );
 
@@ -318,7 +318,7 @@ tape( 'the function supports a `y` offset', function test( t ) {
 		0.0  // 3
 	]);
 
-	snancusumkbn( 4, 0.0, x, 1, 0, y, 2, 1 );
+	snancusumkbn2( 4, 0.0, x, 1, 0, y, 2, 1 );
 
 	expected = new Float32Array( [ 0.0, 2.0, 0.0, 3.0, 0.0, 5.0, 0.0, 5.0 ] );
 
@@ -348,7 +348,7 @@ tape( 'the function supports complex access patterns', function test( t ) {
 		0.0
 	]);
 
-	snancusumkbn( 3, 0.0, x, 2, 0, y, -1, 2 );
+	snancusumkbn2( 3, 0.0, x, 2, 0, y, -1, 2 );
 
 	expected = new Float32Array( [ 4.0, 4.0, 1.0, 0.0, 0.0, 0.0 ] );
 
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.ndarray.native.js
similarity index 85%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.native.js
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.ndarray.native.js
index e5da3a6a0913..8870807e26cb 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.ndarray.native.js
@@ -29,9 +29,9 @@ var tryRequire = require( '@stdlib/utils/try-require' );
 
 // VARIABLES //
 
-var snancusumkbn = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) );
+var snancusumkbn2 = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) );
 var opts = {
-	'skip': ( snancusumkbn instanceof Error )
+	'skip': ( snancusumkbn2 instanceof Error )
 };
 
 
@@ -39,12 +39,12 @@ var opts = {
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.strictEqual( typeof snancusumkbn, 'function', 'main export is a function' );
+	t.strictEqual( typeof snancusumkbn2, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function has an arity of 8', opts, function test( t ) {
-	t.strictEqual( snancusumkbn.length, 8, 'returns expected value' );
+	t.strictEqual( snancusumkbn2.length, 8, 'returns expected value' );
 	t.end();
 });
 
@@ -57,7 +57,7 @@ tape( 'the function calculates the cumulative sum (ignoring NaN values)', opts,
 	x = new Float32Array( [ 1.0, 2.0, NaN, NaN, 5.0 ] );
 	y = new Float32Array( x.length );
 
-	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	snancusumkbn2( x.length, 0.0, x, 1, 0, y, 1, 0 );
 	expected = new Float32Array([
 		1.0,
 		3.0,
@@ -70,7 +70,7 @@ tape( 'the function calculates the cumulative sum (ignoring NaN values)', opts,
 	x = new Float32Array( [ 1.0, 2.0, NaN, NaN, 5.0 ] );
 	y = new Float32Array( x.length );
 
-	snancusumkbn( x.length, 10.0, x, 1, 0, y, 1, 0 );
+	snancusumkbn2( x.length, 10.0, x, 1, 0, y, 1, 0 );
 	expected = new Float32Array([
 		11.0,
 		13.0,
@@ -82,7 +82,7 @@ tape( 'the function calculates the cumulative sum (ignoring NaN values)', opts,
 
 	x = new Float32Array( [ NaN, NaN ] );
 	y = new Float32Array( x.length );
-	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	snancusumkbn2( x.length, 0.0, x, 1, 0, y, 1, 0 );
 	expected = new Float32Array([
 		0.0,
 		0.0
@@ -91,7 +91,7 @@ tape( 'the function calculates the cumulative sum (ignoring NaN values)', opts,
 
 	x = new Float32Array( [ 1.0, NaN, 3.0, NaN ] );
 	y = new Float32Array( x.length );
-	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	snancusumkbn2( x.length, 0.0, x, 1, 0, y, 1, 0 );
 
 	expected = new Float32Array([
 		1.0,
@@ -103,7 +103,7 @@ tape( 'the function calculates the cumulative sum (ignoring NaN values)', opts,
 
 	x = new Float32Array( [ 1.0, 1.0e38, NaN, -1.0e38 ] );
 	y = new Float32Array( x.length );
-	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	snancusumkbn2( x.length, 0.0, x, 1, 0, y, 1, 0 );
 
 	expected = new Float32Array([
 		1.0,
@@ -124,7 +124,7 @@ tape( 'the function calculates the cumulative sum (ignoring NaN values)', opts,
 			expected[ i ] += expected[ i-1 ] + x[ i ];
 		}
 	}
-	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	snancusumkbn2( x.length, 0.0, x, 1, 0, y, 1, 0 );
 	t.deepEqual( y, expected, 'returns expected value' );
 
 	t.end();
@@ -138,7 +138,7 @@ tape( 'the function preserves the sign of zero', opts, function test( t ) {
 	x = new Float32Array( [ -0.0, -0.0, -0.0, 0.0, 1.0 ] );
 	y = new Float32Array( x.length );
 
-	snancusumkbn( x.length, -0.0, x, 1, 0, y, 1, 0 );
+	snancusumkbn2( x.length, -0.0, x, 1, 0, y, 1, 0 );
 	expected = new Float32Array([
 		-0.0,
 		-0.0,
@@ -158,7 +158,7 @@ tape( 'the function returns a reference to the output array', opts, function tes
 	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
 	y = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );
 
-	out = snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	out = snancusumkbn2( x.length, 0.0, x, 1, 0, y, 1, 0 );
 
 	t.strictEqual( out, y, 'same reference' );
 	t.end();
@@ -174,10 +174,10 @@ tape( 'if provided an `N` parameter less than or equal to `0`, the function retu
 
 	expected = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );
 
-	snancusumkbn( -1, 0.0, x, 1, 0, y, 1, 0 );
+	snancusumkbn2( -1, 0.0, x, 1, 0, y, 1, 0 );
 	t.deepEqual( y, expected, 'returns `y` unchanged' );
 
-	snancusumkbn( 0, 0.0, x, 1, 0, y, 1, 0 );
+	snancusumkbn2( 0, 0.0, x, 1, 0, y, 1, 0 );
 	t.deepEqual( y, expected, 'returns `y` unchanged' );
 
 	t.end();
@@ -203,7 +203,7 @@ tape( 'the function supports an `x` stride', opts, function test( t ) {
 		0.0
 	]);
 
-	snancusumkbn( 3, 0.0, x, 2, 0, y, 1, 0 );
+	snancusumkbn2( 3, 0.0, x, 2, 0, y, 1, 0 );
 
 	expected = new Float32Array( [ 1.0, 1.0, 6.0, 0.0, 0.0 ] );
 
@@ -231,7 +231,7 @@ tape( 'the function supports a `y` stride', opts, function test( t ) {
 		0.0  // 2
 	]);
 
-	snancusumkbn( 3, 0.0, x, 1, 0, y, 2, 0 );
+	snancusumkbn2( 3, 0.0, x, 1, 0, y, 2, 0 );
 
 	expected = new Float32Array( [ 1.0, 0.0, 3.0, 0.0, 3.0 ] );
 
@@ -259,7 +259,7 @@ tape( 'the function supports negative strides', opts, function test( t ) {
 		0.0
 	]);
 
-	snancusumkbn( 3, 0.0, x, -2, x.length-1, y, -1, 2 );
+	snancusumkbn2( 3, 0.0, x, -2, x.length-1, y, -1, 2 );
 
 	expected = new Float32Array( [ 8.0, 8.0, 5.0, 0.0, 0.0 ] );
 
@@ -293,7 +293,7 @@ tape( 'the function supports an `x` offset', opts, function test( t ) {
 		0.0
 	]);
 
-	snancusumkbn( 4, 0.0, x, 2, 1, y, 1, 0 );
+	snancusumkbn2( 4, 0.0, x, 2, 1, y, 1, 0 );
 
 	expected = new Float32Array( [ 1.0, -1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0 ] );
 
@@ -327,7 +327,7 @@ tape( 'the function supports a `y` offset', opts, function test( t ) {
 		0.0  // 3
 	]);
 
-	snancusumkbn( 4, 0.0, x, 1, 0, y, 2, 1 );
+	snancusumkbn2( 4, 0.0, x, 1, 0, y, 2, 1 );
 
 	expected = new Float32Array( [ 0.0, 2.0, 0.0, 3.0, 0.0, 5.0, 0.0, 5.0 ] );
 
@@ -357,7 +357,7 @@ tape( 'the function supports complex access patterns', opts, function test( t )
 		0.0
 	]);
 
-	snancusumkbn( 3, 0.0, x, 2, 0, y, -1, 2 );
+	snancusumkbn2( 3, 0.0, x, 2, 0, y, -1, 2 );
 
 	expected = new Float32Array( [ 9.0, 4.0, 1.0, 0.0, 0.0, 0.0 ] );
 
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.snancusumkbn2.js
similarity index 86%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.js
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.snancusumkbn2.js
index 16e473947228..41f9bb4c53fe 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.snancusumkbn2.js
@@ -22,19 +22,19 @@
 
 var tape = require( 'tape' );
 var Float32Array = require( '@stdlib/array/float32' );
-var snancusumkbn = require( './../lib/snancusumkbn.js' );
+var snancusumkbn2 = require( '@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.js' );
 
 
 // TESTS //
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.strictEqual( typeof snancusumkbn, 'function', 'main export is a function' );
+	t.strictEqual( typeof snancusumkbn2, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function has an arity of 6', function test( t ) {
-	t.strictEqual( snancusumkbn.length, 6, 'returns expected value' );
+	t.strictEqual( snancusumkbn2.length, 6, 'returns expected value' );
 	t.end();
 });
 
@@ -47,7 +47,7 @@ tape( 'the function computes the cumulative sum (ignoring NaN values)', function
 	x = new Float32Array( [ 1.0, 2.0, NaN, 4.0, NaN ] );
 	y = new Float32Array( x.length );
 
-	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	snancusumkbn2( x.length, 0.0, x, 1, y, 1 );
 	expected = new Float32Array([
 		1.0,
 		3.0,
@@ -60,7 +60,7 @@ tape( 'the function computes the cumulative sum (ignoring NaN values)', function
 	x = new Float32Array( [ 1.0, 2.0, NaN, NaN, 5.0 ] );
 	y = new Float32Array( x.length );
 
-	snancusumkbn( x.length, 10.0, x, 1, y, 1 );
+	snancusumkbn2( x.length, 10.0, x, 1, y, 1 );
 	expected = new Float32Array([
 		11.0,
 		13.0,
@@ -72,7 +72,7 @@ tape( 'the function computes the cumulative sum (ignoring NaN values)', function
 
 	x = new Float32Array( [ NaN, NaN ] );
 	y = new Float32Array( x.length );
-	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	snancusumkbn2( x.length, 0.0, x, 1, y, 1 );
 	expected = new Float32Array([
 		0.0,
 		0.0
@@ -81,7 +81,7 @@ tape( 'the function computes the cumulative sum (ignoring NaN values)', function
 
 	x = new Float32Array( [ 1.0, NaN, 3.0, NaN ] );
 	y = new Float32Array( x.length );
-	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	snancusumkbn2( x.length, 0.0, x, 1, y, 1 );
 
 	expected = new Float32Array([
 		1.0,
@@ -93,7 +93,7 @@ tape( 'the function computes the cumulative sum (ignoring NaN values)', function
 
 	x = new Float32Array( [ 1.0, 1.0e38, NaN, -1.0e38 ] );
 	y = new Float32Array( x.length );
-	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	snancusumkbn2( x.length, 0.0, x, 1, y, 1 );
 
 	expected = new Float32Array([
 		1.0,
@@ -114,7 +114,7 @@ tape( 'the function computes the cumulative sum (ignoring NaN values)', function
 			expected[ i ] += expected[ i-1 ] + x[ i ];
 		}
 	}
-	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	snancusumkbn2( x.length, 0.0, x, 1, y, 1 );
 	t.deepEqual( y, expected, 'returns expected value' );
 
 	t.end();
@@ -128,7 +128,7 @@ tape( 'the function returns a reference to the output array', function test( t )
 	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
 	y = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );
 
-	out = snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	out = snancusumkbn2( x.length, 0.0, x, 1, y, 1 );
 
 	t.strictEqual( out, y, 'same reference' );
 	t.end();
@@ -144,10 +144,10 @@ tape( 'if provided an `N` parameter less than or equal to `0`, the function retu
 
 	expected = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );
 
-	snancusumkbn( -1, 0.0, x, 1, y, 1 );
+	snancusumkbn2( -1, 0.0, x, 1, y, 1 );
 	t.deepEqual( y, expected, 'returns `y` unchanged' );
 
-	snancusumkbn( 0, 0.0, x, 1, y, 1 );
+	snancusumkbn2( 0, 0.0, x, 1, y, 1 );
 	t.deepEqual( y, expected, 'returns `y` unchanged' );
 
 	t.end();
@@ -173,7 +173,7 @@ tape( 'the function supports an `x` stride', function test( t ) {
 		0.0
 	]);
 
-	snancusumkbn( 3, 0.0, x, 2, y, 1 );
+	snancusumkbn2( 3, 0.0, x, 2, y, 1 );
 
 	expected = new Float32Array( [ 1.0, 1.0, 6.0, 0.0, 0.0 ] );
 
@@ -201,7 +201,7 @@ tape( 'the function supports a `y` stride', function test( t ) {
 		0.0  // 2
 	]);
 
-	snancusumkbn( 3, 0.0, x, 1, y, 2 );
+	snancusumkbn2( 3, 0.0, x, 1, y, 2 );
 
 	expected = new Float32Array( [ 1.0, 0.0, 3.0, 0.0, 3.0 ] );
 
@@ -229,7 +229,7 @@ tape( 'the function supports negative strides', function test( t ) {
 		0.0
 	]);
 
-	snancusumkbn( 3, 0.0, x, -2, y, -1 );
+	snancusumkbn2( 3, 0.0, x, -2, y, -1 );
 
 	expected = new Float32Array( [ 8.0, 8.0, 5.0, 0.0, 0.0 ] );
 
@@ -259,7 +259,7 @@ tape( 'the function supports complex access patterns', function test( t ) {
 		0.0
 	]);
 
-	snancusumkbn( 3, 0.0, x, 2, y, -1 );
+	snancusumkbn2( 3, 0.0, x, 2, y, -1 );
 
 	expected = new Float32Array( [ 6.0, 1.0, 1.0, 0.0, 0.0, 0.0 ] );
 
@@ -296,7 +296,7 @@ tape( 'the function supports view offsets', function test( t ) {
 	x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // begin at 2nd element
 	y1 = new Float32Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 ); // begin at 4th element
 
-	snancusumkbn( 3, 0.0, x1, -2, y1, 1 );
+	snancusumkbn2( 3, 0.0, x1, -2, y1, 1 );
 	expected = new Float32Array( [ 0.0, 0.0, 0.0, 6.0, 10.0, 10.0 ] );
 
 	t.deepEqual( y0, expected, 'returns expected value' );
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.snancusumkbn2.native.js
similarity index 86%
rename from lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.native.js
rename to lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.snancusumkbn2.native.js
index 4e02c12c3377..ede5e03513ac 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.snancusumkbn2.native.js
@@ -28,9 +28,9 @@ var tryRequire = require( '@stdlib/utils/try-require' );
 
 // VARIABLES //
 
-var snancusumkbn = tryRequire( resolve( __dirname, './../lib/snancusumkbn.native.js' ) );
+var snancusumkbn2 = tryRequire( resolve( __dirname, './../lib/snancusumkbn2.native.js' ) );
 var opts = {
-	'skip': ( snancusumkbn instanceof Error )
+	'skip': ( snancusumkbn2 instanceof Error )
 };
 
 
@@ -38,12 +38,12 @@ var opts = {
 
 tape( 'main export is a function', opts, function test( t ) {
 	t.ok( true, __filename );
-	t.strictEqual( typeof snancusumkbn, 'function', 'main export is a function' );
+	t.strictEqual( typeof snancusumkbn2, 'function', 'main export is a function' );
 	t.end();
 });
 
 tape( 'the function has an arity of 6', opts, function test( t ) {
-	t.strictEqual( snancusumkbn.length, 6, 'returns expected value' );
+	t.strictEqual( snancusumkbn2.length, 6, 'returns expected value' );
 	t.end();
 });
 
@@ -56,7 +56,7 @@ tape( 'the function computes the cumulative sum (ignoring NaN values)', opts, fu
 	x = new Float32Array( [ 1.0, 2.0, NaN, NaN, 5.0 ] );
 	y = new Float32Array( x.length );
 
-	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	snancusumkbn2( x.length, 0.0, x, 1, y, 1 );
 	expected = new Float32Array([
 		1.0,
 		3.0,
@@ -69,7 +69,7 @@ tape( 'the function computes the cumulative sum (ignoring NaN values)', opts, fu
 	x = new Float32Array( [ 1.0, 2.0, NaN, NaN, 5.0 ] );
 	y = new Float32Array( x.length );
 
-	snancusumkbn( x.length, 10.0, x, 1, y, 1 );
+	snancusumkbn2( x.length, 10.0, x, 1, y, 1 );
 	expected = new Float32Array([
 		11.0,
 		13.0,
@@ -81,7 +81,7 @@ tape( 'the function computes the cumulative sum (ignoring NaN values)', opts, fu
 
 	x = new Float32Array( [ NaN, NaN ] );
 	y = new Float32Array( x.length );
-	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	snancusumkbn2( x.length, 0.0, x, 1, y, 1 );
 	expected = new Float32Array([
 		0.0,
 		0.0
@@ -90,7 +90,7 @@ tape( 'the function computes the cumulative sum (ignoring NaN values)', opts, fu
 
 	x = new Float32Array( [ 1.0, NaN, 3.0, NaN ] );
 	y = new Float32Array( x.length );
-	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	snancusumkbn2( x.length, 0.0, x, 1, y, 1 );
 
 	expected = new Float32Array([
 		1.0,
@@ -102,7 +102,7 @@ tape( 'the function computes the cumulative sum (ignoring NaN values)', opts, fu
 
 	x = new Float32Array( [ 1.0, 1.0e38, NaN, -1.0e38 ] );
 	y = new Float32Array( x.length );
-	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	snancusumkbn2( x.length, 0.0, x, 1, y, 1 );
 
 	expected = new Float32Array([
 		1.0,
@@ -123,7 +123,7 @@ tape( 'the function computes the cumulative sum (ignoring NaN values)', opts, fu
 			expected[ i ] += expected[ i-1 ] + x[ i ];
 		}
 	}
-	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	snancusumkbn2( x.length, 0.0, x, 1, y, 1 );
 	t.deepEqual( y, expected, 'returns expected value' );
 
 	t.end();
@@ -137,7 +137,7 @@ tape( 'the function returns a reference to the output array', opts, function tes
 	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
 	y = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );
 
-	out = snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	out = snancusumkbn2( x.length, 0.0, x, 1, y, 1 );
 
 	t.strictEqual( out, y, 'same reference' );
 	t.end();
@@ -153,10 +153,10 @@ tape( 'if provided an `N` parameter less than or equal to `0`, the function retu
 
 	expected = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );
 
-	snancusumkbn( -1, 0.0, x, 1, y, 1 );
+	snancusumkbn2( -1, 0.0, x, 1, y, 1 );
 	t.deepEqual( y, expected, 'returns `y` unchanged' );
 
-	snancusumkbn( 0, 0.0, x, 1, y, 1 );
+	snancusumkbn2( 0, 0.0, x, 1, y, 1 );
 	t.deepEqual( y, expected, 'returns `y` unchanged' );
 
 	t.end();
@@ -182,7 +182,7 @@ tape( 'the function supports an `x` stride', opts, function test( t ) {
 		0.0
 	]);
 
-	snancusumkbn( 3, 0.0, x, 2, y, 1 );
+	snancusumkbn2( 3, 0.0, x, 2, y, 1 );
 
 	expected = new Float32Array( [ 0.0, 0.0, 5.0, 0.0, 0.0 ] );
 
@@ -210,7 +210,7 @@ tape( 'the function supports a `y` stride', opts, function test( t ) {
 		0.0  // 2
 	]);
 
-	snancusumkbn( 3, 0.0, x, 1, y, 2 );
+	snancusumkbn2( 3, 0.0, x, 1, y, 2 );
 
 	expected = new Float32Array( [ 1.0, 0.0, 3.0, 0.0, 3.0 ] );
 
@@ -238,7 +238,7 @@ tape( 'the function supports negative strides', opts, function test( t ) {
 		0.0
 	]);
 
-	snancusumkbn( 3, 0.0, x, -2, y, -1 );
+	snancusumkbn2( 3, 0.0, x, -2, y, -1 );
 
 	expected = new Float32Array( [ 8.0, 8.0, 5.0, 0.0, 0.0 ] );
 
@@ -268,7 +268,7 @@ tape( 'the function supports complex access patterns', opts, function test( t )
 		0.0
 	]);
 
-	snancusumkbn( 3, 0.0, x, 2, y, -1 );
+	snancusumkbn2( 3, 0.0, x, 2, y, -1 );
 
 	expected = new Float32Array( [ 6.0, 1.0, 1.0, 0.0, 0.0, 0.0 ] );
 
@@ -305,7 +305,7 @@ tape( 'the function supports view offsets', opts, function test( t ) {
 	x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // begin at 2nd element
 	y1 = new Float32Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 ); // begin at 4th element
 
-	snancusumkbn( 3, 0.0, x1, -2, y1, 1 );
+	snancusumkbn2( 3, 0.0, x1, -2, y1, 1 );
 	expected = new Float32Array( [ 0.0, 0.0, 0.0, 6.0, 10.0, 10.0 ] );
 
 	t.deepEqual( y0, expected, 'returns expected value' );

From 03c9082deda6f214da403434b7f40f9d846e6ba2 Mon Sep 17 00:00:00 2001
From: kaustubh <kaustubh.mp007@gmail.com>
Date: Tue, 30 Dec 2025 14:16:59 +0530
Subject: [PATCH 5/9] Fix ESLint error: use relative path for internal require

---
 .../@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.js    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.js
index 953d255f08da..a9127ca2ff19 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.js
@@ -21,7 +21,7 @@
 // MODULES //
 
 var stride2offset = require( '@stdlib/strided/base/stride2offset' );
-var ndarray = require( '@stdlib/blas/ext/base/snancusumkbn2/lib/ndarray.js' );
+var ndarray = require( './ndarray.js' );
 
 
 // MAIN //

From 1b81847d206fd2499363af752d04817f795633c7 Mon Sep 17 00:00:00 2001
From: kaustubh <kaustubh.mp007@gmail.com>
Date: Tue, 30 Dec 2025 14:26:32 +0530
Subject: [PATCH 6/9] lint

---
 .../blas/ext/base/snancusumkbn2/test/test.snancusumkbn2.js      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.snancusumkbn2.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.snancusumkbn2.js
index 41f9bb4c53fe..cd41f17fa626 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.snancusumkbn2.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.snancusumkbn2.js
@@ -22,7 +22,7 @@
 
 var tape = require( 'tape' );
 var Float32Array = require( '@stdlib/array/float32' );
-var snancusumkbn2 = require( '@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.js' );
+var snancusumkbn2 = require( './../lib/snancusumkbn2.js' );
 
 
 // TESTS //

From 5d7cee2c760bc26491988e089edd8d3d582b3d0d Mon Sep 17 00:00:00 2001
From: kaustubh <kaustubh.mp007@gmail.com>
Date: Sun, 11 Jan 2026 14:02:47 +0530
Subject: [PATCH 7/9] Update JSDoc comment

---
 .../blas/ext/base/snancusumkbn2/benchmark/benchmark.js      | 6 ++++++
 .../ext/base/snancusumkbn2/benchmark/benchmark.native.js    | 6 ++++++
 .../ext/base/snancusumkbn2/benchmark/benchmark.ndarray.js   | 6 ++++++
 .../snancusumkbn2/benchmark/benchmark.ndarray.native.js     | 6 ++++++
 4 files changed, 24 insertions(+)

diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.js
index c725c8ed9ced..455ed54e8bb5 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.js
@@ -66,6 +66,12 @@ function createBenchmark( len ) {
 	var y = zeros( len, options.dtype );
 	return benchmark;
 
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
 	function benchmark( b ) {
 		var v;
 		var i;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.native.js
index 37d45eb575f9..d89ff4adfaeb 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.native.js
@@ -71,6 +71,12 @@ function createBenchmark( len ) {
 	var y = zeros( len, options.dtype );
 	return benchmark;
 
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
 	function benchmark( b ) {
 		var v;
 		var i;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.js
index 5d555de147fa..effe6446980e 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.js
@@ -66,6 +66,12 @@ function createBenchmark( len ) {
 	var y = zeros( len, options.dtype );
 	return benchmark;
 
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
 	function benchmark( b ) {
 		var v;
 		var i;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.native.js
index e40fd1bee1ef..78d24b9a0f03 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.native.js
@@ -71,6 +71,12 @@ function createBenchmark( len ) {
 	var y = zeros( len, options.dtype );
 	return benchmark;
 
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
 	function benchmark( b ) {
 		var v;
 		var i;

From 4cc36d922e80ea503712ddfcccd82e71a000ff95 Mon Sep 17 00:00:00 2001
From: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com>
Date: Sun, 11 Jan 2026 10:04:00 +0000
Subject: [PATCH 8/9] chore: update copyright years

---
 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/README.md  | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.js  | 2 +-
 .../blas/ext/base/snancusumkbn2/benchmark/benchmark.native.js   | 2 +-
 .../blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.js  | 2 +-
 .../base/snancusumkbn2/benchmark/benchmark.ndarray.native.js    | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn2/benchmark/c/Makefile    | 2 +-
 .../blas/ext/base/snancusumkbn2/benchmark/c/benchmark.length.c  | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn2/binding.gyp             | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn2/docs/types/index.d.ts   | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn2/docs/types/test.ts      | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn2/examples/c/Makefile     | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn2/examples/c/example.c    | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn2/examples/index.js       | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn2/include.gypi            | 2 +-
 .../snancusumkbn2/include/stdlib/blas/ext/base/snancusumkbn2.h  | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn2/lib/index.js            | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn2/lib/main.js             | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn2/lib/native.js           | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn2/lib/ndarray.js          | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn2/lib/ndarray.native.js   | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.js    | 2 +-
 .../blas/ext/base/snancusumkbn2/lib/snancusumkbn2.native.js     | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn2/src/Makefile            | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn2/src/addon.c             | 2 +-
 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/main.c | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn2/test/test.js            | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn2/test/test.ndarray.js    | 2 +-
 .../blas/ext/base/snancusumkbn2/test/test.ndarray.native.js     | 2 +-
 .../blas/ext/base/snancusumkbn2/test/test.snancusumkbn2.js      | 2 +-
 .../ext/base/snancusumkbn2/test/test.snancusumkbn2.native.js    | 2 +-
 30 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/README.md b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/README.md
index 51230477530e..cb3da3014222 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/README.md
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/README.md
@@ -2,7 +2,7 @@
 
 @license Apache-2.0
 
-Copyright (c) 2025 The Stdlib Authors.
+Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.js
index 455ed54e8bb5..daf2b423568d 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.native.js
index d89ff4adfaeb..a550073ae934 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.native.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.js
index effe6446980e..78ce1e2a955f 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.native.js
index 78d24b9a0f03..980073c51170 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/benchmark.ndarray.native.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/c/Makefile b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/c/Makefile
index cce2c865d7ad..0756dc7da20a 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/c/Makefile
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/c/Makefile
@@ -1,7 +1,7 @@
 #/
 # @license Apache-2.0
 #
-# Copyright (c) 2025 The Stdlib Authors.
+# Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/c/benchmark.length.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/c/benchmark.length.c
index b7c8125aae9a..bb09906398da 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/c/benchmark.length.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/benchmark/c/benchmark.length.c
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/binding.gyp b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/binding.gyp
index 68a1ca11d160..0d6508a12e99 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/binding.gyp
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/binding.gyp
@@ -1,6 +1,6 @@
 # @license Apache-2.0
 #
-# Copyright (c) 2025 The Stdlib Authors.
+# Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/docs/types/index.d.ts
index 6b70e888f38d..1de950070b9f 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/docs/types/index.d.ts
@@ -1,7 +1,7 @@
 /*
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/docs/types/test.ts b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/docs/types/test.ts
index d666e51964a0..8b0cc4597194 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/docs/types/test.ts
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/docs/types/test.ts
@@ -1,7 +1,7 @@
 /*
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/examples/c/Makefile b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/examples/c/Makefile
index 25ced822f96a..c8f8e9a1517b 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/examples/c/Makefile
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/examples/c/Makefile
@@ -1,7 +1,7 @@
 #/
 # @license Apache-2.0
 #
-# Copyright (c) 2025 The Stdlib Authors.
+# Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/examples/c/example.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/examples/c/example.c
index 003d23055887..f287be59fbcf 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/examples/c/example.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/examples/c/example.c
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/examples/index.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/examples/index.js
index 1ab6a646c658..96ef0cd58514 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/examples/index.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/examples/index.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/include.gypi b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/include.gypi
index ecfaf82a3279..bee8d41a2caf 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/include.gypi
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/include.gypi
@@ -1,6 +1,6 @@
 # @license Apache-2.0
 #
-# Copyright (c) 2025 The Stdlib Authors.
+# Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/include/stdlib/blas/ext/base/snancusumkbn2.h b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/include/stdlib/blas/ext/base/snancusumkbn2.h
index 49025b79c414..fc8762d968ea 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/include/stdlib/blas/ext/base/snancusumkbn2.h
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/include/stdlib/blas/ext/base/snancusumkbn2.h
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/index.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/index.js
index 13060a0f086a..897afe0b1b40 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/index.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/index.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/main.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/main.js
index aea8c79d995f..ae8f81e7d335 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/main.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/main.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/native.js
index 146a1dcff6a1..53a17ae00917 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/native.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/ndarray.js
index 13817966396a..3a7ad3931256 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/ndarray.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/ndarray.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/ndarray.native.js
index 50a09380d501..1660854cab0e 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/ndarray.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/ndarray.native.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.js
index a9127ca2ff19..860574e19b35 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.native.js
index 7803a1a229fe..4c283270d666 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/lib/snancusumkbn2.native.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/Makefile b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/Makefile
index 7733b6180cb4..2caf905cedbe 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/Makefile
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/Makefile
@@ -1,7 +1,7 @@
 #/
 # @license Apache-2.0
 #
-# Copyright (c) 2025 The Stdlib Authors.
+# Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/addon.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/addon.c
index ed5d5f407e8d..cb4df58f6024 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/addon.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/addon.c
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/main.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/main.c
index 25ac02146674..319149e88d43 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/main.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/main.c
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.js
index 322b4be7ebcb..dd4b28567857 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.ndarray.js
index f3448b147520..8319bde29975 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.ndarray.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.ndarray.native.js
index 8870807e26cb..9da836b23c03 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.ndarray.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.ndarray.native.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.snancusumkbn2.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.snancusumkbn2.js
index cd41f17fa626..7ad3a1db2532 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.snancusumkbn2.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.snancusumkbn2.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.snancusumkbn2.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.snancusumkbn2.native.js
index ede5e03513ac..001d7f7ceceb 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.snancusumkbn2.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/test/test.snancusumkbn2.native.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.

From 56ee2836035f842c5791f6b5c500f1b03d55a7b0 Mon Sep 17 00:00:00 2001
From: kaustubh <kaustubh.mp007@gmail.com>
Date: Sun, 25 Jan 2026 22:18:44 +0530
Subject: [PATCH 9/9] fixed spacing

---
 .../include/stdlib/blas/ext/base/snancusumkbn2.h       |  4 ++--
 .../@stdlib/blas/ext/base/snancusumkbn2/src/addon.c    | 10 +++++-----
 .../@stdlib/blas/ext/base/snancusumkbn2/src/main.c     |  6 +++---
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/include/stdlib/blas/ext/base/snancusumkbn2.h b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/include/stdlib/blas/ext/base/snancusumkbn2.h
index fc8762d968ea..8c49fbadf854 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/include/stdlib/blas/ext/base/snancusumkbn2.h
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/include/stdlib/blas/ext/base/snancusumkbn2.h
@@ -31,12 +31,12 @@ extern "C" {
 /**
 * Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
 */
-void API_SUFFIX( stdlib_strided_snancusumkbn2 )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, float *Y, const CBLAS_INT strideY );
+void API_SUFFIX(stdlib_strided_snancusumkbn2)( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, float *Y, const CBLAS_INT strideY );
 
 /**
 * Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm and alternative indexing semantics.
 */
-void API_SUFFIX( stdlib_strided_snancusumkbn2_ndarray )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, float *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY );
+void API_SUFFIX(stdlib_strided_snancusumkbn2_ndarray)( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, float *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY );
 
 #ifdef __cplusplus
 }
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/addon.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/addon.c
index cb4df58f6024..250d65232532 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/addon.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/addon.c
@@ -16,14 +16,14 @@
 * limitations under the License.
 */
 
-#include <node_api.h>
-#include "stdlib/blas/base/shared.h"
 #include "stdlib/blas/ext/base/snancusumkbn2.h"
+#include "stdlib/blas/base/shared.h"
+#include "stdlib/napi/export.h"
 #include "stdlib/napi/argv.h"
 #include "stdlib/napi/argv_float.h"
 #include "stdlib/napi/argv_int64.h"
 #include "stdlib/napi/argv_strided_float32array.h"
-#include "stdlib/napi/export.h"
+#include <node_api.h>
 
 /**
 * Receives JavaScript callback invocation data.
@@ -40,7 +40,7 @@ static napi_value addon( napi_env env, napi_callback_info info ) {
 	STDLIB_NAPI_ARGV_INT64( env, strideY, argv, 5 );
 	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, X, N, strideX, argv, 2 );
 	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, Y, N, strideY, argv, 4 );
-	API_SUFFIX( stdlib_strided_snancusumkbn2 )( N, sum, X, strideX, Y, strideY );
+	API_SUFFIX(stdlib_strided_snancusumkbn2)( N, sum, X, strideX, Y, strideY );
 	return NULL;
 }
 
@@ -61,7 +61,7 @@ static napi_value addon_method( napi_env env, napi_callback_info info ) {
 	STDLIB_NAPI_ARGV_INT64( env, offsetY, argv, 7 );
 	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, X, N, strideX, argv, 2 );
 	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, Y, N, strideY, argv, 5 );
-	API_SUFFIX( stdlib_strided_snancusumkbn2_ndarray )( N, sum, X, strideX, offsetX, Y, strideY, offsetY );
+	API_SUFFIX(stdlib_strided_snancusumkbn2_ndarray)( N, sum, X, strideX, offsetX, Y, strideY, offsetY );
 	return NULL;
 }
 
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/main.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/main.c
index 319149e88d43..179d9412d4d1 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/main.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn2/src/main.c
@@ -40,10 +40,10 @@
 * @param Y        output array
 * @param strideY  stride length for Y
 */
-void API_SUFFIX( stdlib_strided_snancusumkbn2 )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, float *Y, const CBLAS_INT strideY ) {
+void API_SUFFIX(stdlib_strided_snancusumkbn2)( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, float *Y, const CBLAS_INT strideY ) {
 	const CBLAS_INT ox = stdlib_strided_stride2offset( N, strideX );
 	const CBLAS_INT oy = stdlib_strided_stride2offset( N, strideY );
-	API_SUFFIX( stdlib_strided_snancusumkbn2_ndarray )( N, sum, X, strideX, ox, Y, strideY, oy );
+	API_SUFFIX(stdlib_strided_snancusumkbn2_ndarray)( N, sum, X, strideX, ox, Y, strideY, oy );
 }
 
 /**
@@ -66,7 +66,7 @@ void API_SUFFIX( stdlib_strided_snancusumkbn2 )( const CBLAS_INT N, const float
 * @param strideY  stride length for Y
 * @param offsetY  starting index for Y
 */
-void API_SUFFIX( stdlib_strided_snancusumkbn2_ndarray )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, float *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY ) {
+void API_SUFFIX(stdlib_strided_snancusumkbn2_ndarray)( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, float *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY ) {
 	CBLAS_INT ix;
 	CBLAS_INT iy;
 	CBLAS_INT i;