feat: complete implementation

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---

Author: aayush0325

lib/node_modules/@stdlib/blas/ext/base/gsumpw/lib/accessors.js

@@ -18,6 +18,17 @@
 
 'use strict';
 
+// MODULES //
+
+var floor = require( '@stdlib/math/base/special/floor' );
+
+
+// VARIABLES //
+
+// Blocksize for pairwise summation (NOTE: decreasing the blocksize decreases rounding error as more pairs are summed, but also decreases performance. Because the inner loop is unrolled eight times, the blocksize is effectively `16`.):
+var BLOCKSIZE = 128;
+
+
 // MAIN //
 
 /**
@@ -52,22 +63,80 @@ function gsumpw( N, x, strideX, offsetX ) {
 	var xbuf;
 	var get;
 	var ix;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var s7;
+	var M;
+	var n;
 	var s;
 	var i;
 
+	if ( N <= 0 ) {
+		return 0.0;
+	}
+
 	// Cache reference to array data:
 	xbuf = x.data;
 
 	// Cache a reference to the element accessor:
 	get = x.accessors[ 0 ];
+
 	ix = offsetX;
 	if ( strideX === 0 ) {
 		return N * get( xbuf, ix );
 	}
 	s = 0.0;
 
-	// TODO --- for ( i = 0; i < N; i++ ) {}
-	return s;
+	if ( N <= 8 ) {
+		s = 0.0;
+		for ( i = 0; i < N; i++ ) {
+			s += get( xbuf, ix );
+			ix += strideX;
+		}
+		return s;
+	}
+	if ( N <= BLOCKSIZE ) {
+		// Sum a block with 8 accumulators (by loop unrolling, we lower the effective blocksize to 16)...
+		s0 = get( xbuf, ix );
+		s1 = get( xbuf, ix+strideX );
+		s2 = get( xbuf, ix+(2*strideX) );
+		s3 = get( xbuf, ix+(3*strideX) );
+		s4 = get( xbuf, ix+(4*strideX) );
+		s5 = get( xbuf, ix+(5*strideX) );
+		s6 = get( xbuf, ix+(6*strideX) );
+		s7 = get( xbuf, ix+(7*strideX) );
+
+		M = N % 8;
+		for ( i = 8; i < N-M; i += 8 ) {
+			s0 += get( xbuf, ix );
+			s1 += get( xbuf, ix+strideX );
+			s2 += get( xbuf, ix+(2*strideX) );
+			s3 += get( xbuf, ix+(3*strideX) );
+			s4 += get( xbuf, ix+(4*strideX) );
+			s5 += get( xbuf, ix+(5*strideX) );
+			s6 += get( xbuf, ix+(6*strideX) );
+			s7 += get( xbuf, ix+(7*strideX) );
+			ix += 8 * strideX;
+		}
+		// Pairwise sum the accumulators:
+		s = ( (s0+s1) + (s2+s3) ) + ( (s4+s5) + (s6+s7) );
+
+		// Clean-up loop...
+		for ( i; i < N; i++ ) {
+			s += x[ ix ];
+			ix += strideX;
+		}
+		return s;
+	}
+	// Recurse by dividing by two, but avoiding non-multiples of unroll factor...
+	n = floor( N/2 );
+	n -= n % 8;
+	return gsumpw( n, x, strideX, ix ) + gsumpw( N-n, x, strideX, ix+(n*strideX) ); // eslint-disable-line max-len
 }
 
 

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

@@ -21,6 +21,8 @@
 // MODULES //
 
 var floor = require( '@stdlib/math/base/special/floor' );
+var arraylike2object = require( '@stdlib/array/base/arraylike2object' );
+var accessors = require( './accessors.js' );
 
 
 // VARIABLES //
@@ -66,12 +68,17 @@ function gsumpw( N, x, strideX, offsetX ) {
 	var s7;
 	var M;
 	var s;
+	var o;
 	var n;
 	var i;
 
 	if ( N <= 0 ) {
 		return 0.0;
 	}
+	o = arraylike2object( x );
+	if ( o.accessorProtocol ) {
+		return accessors( N, o, strideX, offsetX );
+	}
 	ix = offsetX;
 	if ( strideX === 0 ) {
 		return N * x[ ix ];