add suggested changes

Author: MeKaustubh07

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

@@ -115,7 +115,7 @@ 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 value in `x` starting from the second value and to store in the last `N` elements of `y` starting from the last element:
+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 value in the strided input array starting from the second value and to store in the last `N` elements of the strided output array starting from the last element:
 
 ```javascript
 var Float64Array = require( '@stdlib/array/float64' );
@@ -308,7 +308,6 @@ int main( void ) {
 
 <!-- /.c -->
 
-
 <section class="references">
 
 ## References

lib/node_modules/@stdlib/blas/ext/base/dnancusumpw/benchmark/benchmark.js

@@ -79,12 +79,12 @@ function createBenchmark( len ) {
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
 			v = dnancusumpw( x.length, 0.0, x, 1, y, 1 );
-			if ( isnan( v[ i % len ] ) ) {
+			if ( isnan( v[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
 		}
 		b.toc();
-		if ( isnan( v[ i % len ] ) ) {
+		if ( isnan( v[ i%len ] ) ) {
 			b.fail( 'should not return NaN' );
 		}
 		b.pass( 'benchmark finished' );

lib/node_modules/@stdlib/blas/ext/base/dnancusumpw/benchmark/benchmark.native.js

@@ -84,12 +84,12 @@ function createBenchmark( len ) {
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
 			v = dnancusumpw( x.length, 0.0, x, 1, y, 1 );
-			if ( isnan( v[ i % len ] ) ) {
+			if ( isnan( v[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
 		}
 		b.toc();
-		if ( isnan( v[ i % len ] ) ) {
+		if ( isnan( v[ i%len ] ) ) {
 			b.fail( 'should not return NaN' );
 		}
 		b.pass( 'benchmark finished' );

lib/node_modules/@stdlib/blas/ext/base/dnancusumpw/benchmark/benchmark.ndarray.js

@@ -79,12 +79,12 @@ function createBenchmark( len ) {
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
 			v = dnancusumpw( x.length, 0.0, x, 1, 0, y, 1, 0 );
-			if ( isnan( v[ i % len ] ) ) {
+			if ( isnan( v[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
 		}
 		b.toc();
-		if ( isnan( v[ i % len ] ) ) {
+		if ( isnan( v[ i%len ] ) ) {
 			b.fail( 'should not return NaN' );
 		}
 		b.pass( 'benchmark finished' );

lib/node_modules/@stdlib/blas/ext/base/dnancusumpw/benchmark/benchmark.ndarray.native.js

@@ -84,12 +84,12 @@ function createBenchmark( len ) {
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
 			v = dnancusumpw( x.length, 0.0, x, 1, 0, y, 1, 0 );
-			if ( isnan( v[ i % len ] ) ) {
+			if ( isnan( v[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
 		}
 		b.toc();
-		if ( isnan( v[ i % len ] ) ) {
+		if ( isnan( v[ i%len ] ) ) {
 			b.fail( 'should not return NaN' );
 		}
 		b.pass( 'benchmark finished' );

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

@@ -16,12 +16,12 @@
 * limitations under the License.
 */
 
-#include <sys/time.h>
 #include "stdlib/blas/ext/base/dnancusumpw.h"
-#include <math.h>
-#include <stdio.h>
 #include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
 #include <time.h>
+#include <sys/time.h>
 
 #define NAME "dnancusumpw"
 #define ITERATIONS 1000000
@@ -101,8 +101,8 @@ static double benchmark1( int iterations, int len ) {
 	double t;
 	int i;
 
-	x = (double *)malloc( len * sizeof( double ) );
-	y = (double *)malloc( len * sizeof( double ) );
+	x = (double *)malloc( len * sizeof(double) );
+	y = (double *)malloc( len * sizeof(double) );
 
 	for ( i = 0; i < len; i++ ) {
 		if ( rand_double() < 0.2 ) {
@@ -121,7 +121,7 @@ static double benchmark1( int iterations, int len ) {
 		}
 	}
 	elapsed = tic() - t;
-	if ( y[ len - 1 ] != y[ len - 1 ] ) {
+	if ( y[ len-1 ] != y[ len-1 ] ) {
 		printf( "should not return NaN\n" );
 	}
 	free( x );
@@ -143,8 +143,8 @@ static double benchmark2( int iterations, int len ) {
 	double t;
 	int i;
 
-	x = (double *)malloc( len * sizeof( double ) );
-	y = (double *)malloc( len * sizeof( double ) );
+	x = (double *)malloc( len * sizeof(double) );
+	y = (double *)malloc( len * sizeof(double) );
 
 	for ( i = 0; i < len; i++ ) {
 		if ( rand_double() < 0.2 ) {
@@ -163,7 +163,7 @@ static double benchmark2( int iterations, int len ) {
 		}
 	}
 	elapsed = tic() - t;
-	if ( y[ len - 1 ] != y[ len - 1 ] ) {
+	if ( y[ len-1 ] != y[ len-1 ] ) {
 		printf( "should not return NaN\n" );
 	}
 	free( x );
@@ -189,7 +189,7 @@ int main( void ) {
 	count = 0;
 	for ( i = MIN; i <= MAX; i++ ) {
 		len = pow( 10, i );
-		iter = ITERATIONS / pow( 10, i - 1 );
+		iter = ITERATIONS / pow( 10, i-1 );
 		for ( j = 0; j < REPEATS; j++ ) {
 			count += 1;
 			printf( "# c::%s:len=%d\n", NAME, len );
@@ -200,7 +200,7 @@ int main( void ) {
 	}
 	for ( i = MIN; i <= MAX; i++ ) {
 		len = pow( 10, i );
-		iter = ITERATIONS / pow( 10, i - 1 );
+		iter = ITERATIONS / pow( 10, i-1 );
 		for ( j = 0; j < REPEATS; j++ ) {
 			count += 1;
 			printf( "# c::%s:ndarray:len=%d\n", NAME, len );

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

@@ -29,6 +29,14 @@ var ndarray = require( './ndarray.js' );
 /**
 * Computes the cumulative sum of double-precision floating-point strided array elements, ignoring `NaN` values and using pairwise summation.
 *
+* ## Method
+*
+* -   This implementation uses pairwise summation, which accrues rounding error `O(log2 N)` instead of `O(N)`. The recursion depth is also `O(log2 N)`.
+*
+* ## References
+*
+* -   Higham, Nicholas J. 1993. "The Accuracy of Floating Point Summation." _SIAM Journal on Scientific Computing_ 14 (4): 783–99. doi:[10.1137/0914050](https://doi.org/10.1137/0914050).
+*
 * @param {PositiveInteger} N - number of indexed elements
 * @param {number} sum - initial sum
 * @param {Float64Array} x - input array
@@ -42,9 +50,8 @@ var ndarray = require( './ndarray.js' );
 *
 * var x = new Float64Array( [ 1.0, -2.0, NaN ] );
 * var y = new Float64Array( x.length );
-* var N = x.length;
 *
-* var v = dnancusumpw( N, 0.0, x, 1, y, 1 );
+* var v = dnancusumpw( x.length, 0.0, x, 1, y, 1 );
 * // returns <Float64Array>[ 1.0, -1.0, -1.0 ]
 */
 function dnancusumpw( N, sum, x, strideX, y, strideY ) {

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

@@ -20,14 +20,29 @@
 
 // MODULES //
 
+var floor = require( '@stdlib/math/base/special/floor' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 
 
+// VARIABLES //
+
+// Blocksize for pairwise summation:
+var BLOCKSIZE = 128;
+
+
 // MAIN //
 
 /**
 * Computes the cumulative sum of double-precision floating-point strided array elements, ignoring `NaN` values and using pairwise summation.
 *
+* ## Method
+*
+* -   This implementation uses pairwise summation, which accrues rounding error `O(log2 N)` instead of `O(N)`. The recursion depth is also `O(log2 N)`.
+*
+* ## References
+*
+* -   Higham, Nicholas J. 1993. "The Accuracy of Floating Point Summation." _SIAM Journal on Scientific Computing_ 14 (4): 783–99. doi:[10.1137/0914050](https://doi.org/10.1137/0914050).
+*
 * @param {PositiveInteger} N - number of indexed elements
 * @param {number} sum - initial sum
 * @param {Float64Array} x - input array
@@ -50,21 +65,42 @@ var isnan = require( '@stdlib/math/base/assert/is-nan' );
 function dnancusumpw( N, sum, x, strideX, offsetX, y, strideY, offsetY ) {
 	var ix;
 	var iy;
+	var s;
+	var n;
 	var i;
 
 	if ( N <= 0 ) {
 		return y;
 	}
 	ix = offsetX;
 	iy = offsetY;
-	for ( i = 0; i < N; i++ ) {
-		if ( isnan( x[ ix ] ) === false ) {
-			sum += x[ ix ];
+	if ( N <= BLOCKSIZE ) {
+		if ( isnan( x[ ix ] ) ) {
+			s = 0.0;
+		} else {
+			s = x[ ix ];
 		}
-		y[ iy ] = sum;
+		y[ iy ] = sum + s;
 		ix += strideX;
 		iy += strideY;
+		for ( i = 1; i < N; i++ ) {
+			if ( isnan( x[ ix ] ) ) {
+				y[ iy ] = sum + s;
+				ix += strideX;
+				iy += strideY;
+				continue;
+			}
+			s += x[ ix ];
+			y[ iy ] = sum + s;
+			ix += strideX;
+			iy += strideY;
+		}
+		return y;
 	}
+	n = floor( N/2 );
+	dnancusumpw( n, sum, x, strideX, ix, y, strideY, iy );
+	iy += (n-1) * strideY;
+	dnancusumpw( N-n, y[ iy ], x, strideX, ix+(n*strideX), y, strideY, iy+strideY ); // eslint-disable-line max-len
 	return y;
 }
 

lib/node_modules/@stdlib/blas/ext/base/dnancusumpw/src/addon.c

@@ -65,4 +65,4 @@ static napi_value addon_method( napi_env env, napi_callback_info info ) {
 	return NULL;
 }
 
-STDLIB_NAPI_MODULE_EXPORT_FCN_WITH_METHOD( addon, "ndarray", addon_method );
+STDLIB_NAPI_MODULE_EXPORT_FCN_WITH_METHOD( addon, "ndarray", addon_method )

lib/node_modules/@stdlib/blas/ext/base/dnancusumpw/src/main.c

@@ -61,21 +61,42 @@ void API_SUFFIX(stdlib_strided_dnancusumpw_ndarray)( const CBLAS_INT N, const do
 	CBLAS_INT ix;
 	CBLAS_INT iy;
 	CBLAS_INT i;
+	CBLAS_INT n;
 	double s;
 
 	if ( N <= 0 ) {
 		return;
 	}
 	ix = offsetX;
 	iy = offsetY;
-	s = sum;
-	for ( i = 0; i < N; i++ ) {
-		if ( !stdlib_base_is_nan( X[ ix ] ) ) {
-			s += X[ ix ];
+
+	// Blocksize for pairwise summation...
+	if ( N <= 128 ) {
+		if ( stdlib_base_is_nan( X[ ix ] ) ) {
+			s = 0.0;
+		} else {
+			s = X[ ix ];
 		}
-		Y[ iy ] = s;
+		Y[ iy ] = sum + s;
 		ix += strideX;
 		iy += strideY;
+		for ( i = 1; i < N; i++ ) {
+			if ( stdlib_base_is_nan( X[ ix ] ) ) {
+				Y[ iy ] = sum + s;
+				ix += strideX;
+				iy += strideY;
+				continue;
+			}
+			s += X[ ix ];
+			Y[ iy ] = sum + s;
+			ix += strideX;
+			iy += strideY;
+		}
+		return;
 	}
+	n = N / 2;
+	API_SUFFIX(stdlib_strided_dnancusumpw_ndarray)( n, sum, X, strideX, ix, Y, strideY, iy );
+	iy += (n-1) * strideY;
+	API_SUFFIX(stdlib_strided_dnancusumpw_ndarray)( N-n, Y[ iy ], X, strideX, ix+(n*strideX), Y, strideY, iy+strideY );
 	return;
 }