feat: add accessor arrays support to blas/ext/base/gcusum

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

@@ -128,6 +128,7 @@ gcusum.ndarray( 4, 0.0, x, 2, 1, y, -1, y.length-1 );
 ## Notes
 
 -   If `N <= 0`, both functions return `y` unchanged.
+-   Both functions support array-like objects having getter and setter accessors for array element access (e.g., [`@stdlib/array/base/accessor`][@stdlib/array/base/accessor])
 -   Depending on the environment, the typed versions ([`dcusum`][@stdlib/blas/ext/base/dcusum], [`scusum`][@stdlib/blas/ext/base/scusum], etc.) are likely to be significantly more performant.
 
 </section>
@@ -190,6 +191,8 @@ console.log( y );
 
 [mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
 
+[@stdlib/array/base/accessor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/base/accessor
+
 <!-- <related-links> -->
 
 [@stdlib/blas/ext/base/dcusum]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/ext/base/dcusum

lib/node_modules/@stdlib/blas/ext/base/gcusum/docs/types/index.d.ts

@@ -20,7 +20,17 @@
 
 /// <reference types="@stdlib/types"/>
 
-import { NumericArray } from '@stdlib/types/array';
+import { NumericArray, Collection, AccessorArrayLike } from '@stdlib/types/array';
+
+/**
+* Input array.
+*/
+type InputArray = NumericArray | Collection<number> | AccessorArrayLike<number>;
+
+/**
+* Output array.
+*/
+type OutputArray = NumericArray | Collection<number> | AccessorArrayLike<number>;
 
 /**
 * Interface describing `gcusum`.
@@ -44,7 +54,7 @@ interface Routine {
 	* gcusum( x.length, 0.0, x, 1, y, 1 );
 	* // y => [ 1.0, -1.0, 1.0 ]
 	*/
-	( N: number, sum: number, x: NumericArray, strideX: number, y: NumericArray, strideY: number ): NumericArray;
+	<T extends OutputArray>( N: number, sum: number, x: InputArray, strideX: number, y: T, strideY: number ): T;
 
 	/**
 	* Computes the cumulative sum of strided array elements using alternative indexing semantics.
@@ -66,7 +76,7 @@ interface Routine {
 	* gcusum.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 );
 	* // y => [ 1.0, -1.0, 1.0 ]
 	*/
-	ndarray( N: number, sum: number, x: NumericArray, strideX: number, offsetX: number, y: NumericArray, strideY: number, offsetY: number ): NumericArray;
+	ndarray<T extends OutputArray>( N: number, sum: number, x: InputArray, strideX: number, offsetX: number, y: T, strideY: number, offsetY: number ): T;
 }
 
 /**

lib/node_modules/@stdlib/blas/ext/base/gcusum/docs/types/test.ts

@@ -16,6 +16,7 @@
 * limitations under the License.
 */
 
+import AccessorArray = require( '@stdlib/array/base/accessor' );
 import gcusum = require( './index' );
 
 
@@ -26,7 +27,8 @@ import gcusum = require( './index' );
 	const x = new Float64Array( 10 );
 	const y = new Float64Array( 10 );
 
-	gcusum( x.length, 0.0, x, 1, y, 1 ); // $ExpectType NumericArray
+	gcusum( x.length, 0.0, x, 1, y, 1 ); // $ExpectType Float64Array
+	gcusum( x.length, 0.0, new AccessorArray( x ), 1, new AccessorArray( y ), 1 ); // $ExpectType AccessorArray<number>
 }
 
 // The compiler throws an error if the function is provided a first argument which is not a number...
@@ -139,7 +141,8 @@ import gcusum = require( './index' );
 	const x = new Float64Array( 10 );
 	const y = new Float64Array( 10 );
 
-	gcusum.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectType NumericArray
+	gcusum.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectType Float64Array
+	gcusum.ndarray( x.length, 0.0, new AccessorArray( x ), 1, 0, new AccessorArray( y ), 1, 0 ); // $ExpectType AccessorArray<number>
 }
 
 // The compiler throws an error if the `ndarray` method is provided a first argument which is not a number...

lib/node_modules/@stdlib/blas/ext/base/gcusum/test/test.main.js

@@ -21,8 +21,8 @@
 // MODULES //
 
 var tape = require( 'tape' );
-var floor = require( '@stdlib/math/base/special/floor' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
 var Float64Array = require( '@stdlib/array/float64' );
 var gcusum = require( './../lib' );
 
@@ -128,6 +128,94 @@ tape( 'the function computes the cumulative sum', function test( t ) {
 	t.end();
 });
 
+tape( 'the function computes the cumulative sum (accessors)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+	var i;
+
+	x = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];
+	y = [ 0.0, 0.0, 0.0, 0.0, 0.0 ];
+
+	gcusum( x.length, 0.0, toAccessorArray( x ), 1, toAccessorArray( y ), 1 );
+	expected = [
+		1.0,
+		3.0,
+		6.0,
+		10.0,
+		15.0
+	];
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = [ 1.0, 2.0, 3.0, 4.0, 5.0 ];
+	y = [ 0.0, 0.0, 0.0, 0.0, 0.0 ];
+
+	gcusum( x.length, 10.0, toAccessorArray( x ), 1, toAccessorArray( y ), 1 );
+	expected = [
+		11.0,
+		13.0,
+		16.0,
+		20.0,
+		25.0
+	];
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = [ NaN, NaN ];
+	y = [ 0.0, 0.0 ];
+	gcusum( x.length, 0.0, toAccessorArray( x ), 1, toAccessorArray( y ), 1 );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( isnan( y[ i ] ), true, 'returns expected value. i: ' + i );
+	}
+
+	x = [ 1.0, NaN, 3.0, NaN ];
+	y = [ 0.0, 0.0, 0.0, 0.0 ];
+	gcusum( x.length, 0.0, toAccessorArray( x ), 1, toAccessorArray( y ), 1 );
+
+	expected = [
+		1.0,
+		NaN,
+		NaN,
+		NaN
+	];
+	for ( i = 0; i < y.length; i++ ) {
+		if ( isnan( expected[ i ] ) ) {
+			t.strictEqual( isnan( y[ i ] ), true, 'returns expected value. i: ' + i );
+		} else {
+			t.strictEqual( y[ i ], expected[ i ], true, 'returns expected value. i: ' + i );
+		}
+	}
+
+	x = [ 1.0, 1.0e100, 1.0, -1.0e100 ];
+	y = [ 0.0, 0.0, 0.0, 0.0 ];
+	gcusum( x.length, 0.0, toAccessorArray( x ), 1, toAccessorArray( y ), 1 );
+
+	expected = [
+		1.0,
+		1.0e100,
+		1.0e100,
+		2.0
+	];
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = [];
+	y = [];
+	expected = [];
+	for ( i = 0; i < 1e3; i++ ) {
+		x.push( i+1 );
+		y.push( 0.0 );
+		if ( i === 0 ) {
+			expected.push( x[ i ] );
+		} else {
+			expected.push( expected[ i-1 ] + x[ i ] );
+		}
+	}
+	gcusum( x.length, 0.0, toAccessorArray( x ), 1, toAccessorArray( 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;
@@ -142,6 +230,20 @@ tape( 'the function returns a reference to the output array', function test( t )
 	t.end();
 });
 
+tape( 'the function returns a reference to the output array (accessors)', function test( t ) {
+	var out;
+	var x;
+	var y;
+
+	x = toAccessorArray( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+	y = toAccessorArray( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+	out = gcusum( 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;
@@ -165,7 +267,6 @@ tape( 'the function supports an `x` stride', function test( t ) {
 	var expected;
 	var x;
 	var y;
-	var N;
 
 	x = [
 		1.0, // 0
@@ -181,9 +282,36 @@ tape( 'the function supports an `x` stride', function test( t ) {
 		0.0,
 		0.0
 	];
-	N = 3;
 
-	gcusum( N, 0.0, x, 2, y, 1 );
+	gcusum( 3, 0.0, x, 2, y, 1 );
+
+	expected = [ 1.0, 4.0, 9.0, 0.0, 0.0 ];
+
+	t.deepEqual( y, expected, 'deep equal' );
+	t.end();
+});
+
+tape( 'the function supports an `x` stride (accessors)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = [
+		1.0, // 0
+		2.0,
+		3.0, // 1
+		4.0,
+		5.0  // 2
+	];
+	y = [
+		0.0, // 0
+		0.0, // 1
+		0.0, // 2
+		0.0,
+		0.0
+	];
+
+	gcusum( 3, 0.0, toAccessorArray( x ), 2, toAccessorArray( y ), 1 );
 
 	expected = [ 1.0, 4.0, 9.0, 0.0, 0.0 ];
 
@@ -195,7 +323,6 @@ tape( 'the function supports a `y` stride', function test( t ) {
 	var expected;
 	var x;
 	var y;
-	var N;
 
 	x = [
 		1.0, // 0
@@ -211,9 +338,36 @@ tape( 'the function supports a `y` stride', function test( t ) {
 		0.0,
 		0.0  // 2
 	];
-	N = 3;
 
-	gcusum( N, 0.0, x, 1, y, 2 );
+	gcusum( 3, 0.0, x, 1, y, 2 );
+
+	expected = [ 1.0, 0.0, 3.0, 0.0, 6.0 ];
+
+	t.deepEqual( y, expected, 'deep equal' );
+	t.end();
+});
+
+tape( 'the function supports a `y` stride (accessors)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = [
+		1.0, // 0
+		2.0, // 1
+		3.0, // 2
+		4.0,
+		5.0
+	];
+	y = [
+		0.0, // 0
+		0.0,
+		0.0, // 1
+		0.0,
+		0.0  // 2
+	];
+
+	gcusum( 3, 0.0, toAccessorArray( x ), 1, toAccessorArray( y ), 2 );
 
 	expected = [ 1.0, 0.0, 3.0, 0.0, 6.0 ];
 
@@ -225,7 +379,6 @@ tape( 'the function supports negative strides', function test( t ) {
 	var expected;
 	var x;
 	var y;
-	var N;
 
 	x = [
 		1.0, // 2
@@ -241,9 +394,36 @@ tape( 'the function supports negative strides', function test( t ) {
 		0.0,
 		0.0
 	];
-	N = 3;
 
-	gcusum( N, 0.0, x, -2, y, -1 );
+	gcusum( 3, 0.0, x, -2, y, -1 );
+
+	expected = [ 9.0, 8.0, 5.0, 0.0, 0.0 ];
+
+	t.deepEqual( y, expected, 'deep equal' );
+	t.end();
+});
+
+tape( 'the function supports negative strides (accessors)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = [
+		1.0, // 2
+		2.0,
+		3.0, // 1
+		4.0,
+		5.0  // 0
+	];
+	y = [
+		0.0, // 2
+		0.0, // 1
+		0.0, // 0
+		0.0,
+		0.0
+	];
+
+	gcusum( 3, 0.0, toAccessorArray( x ), -2, toAccessorArray( y ), -1 );
 
 	expected = [ 9.0, 8.0, 5.0, 0.0, 0.0 ];
 
@@ -255,7 +435,6 @@ tape( 'the function supports complex access patterns', function test( t ) {
 	var expected;
 	var x;
 	var y;
-	var N;
 
 	x = [
 		1.0, // 0
@@ -273,9 +452,8 @@ tape( 'the function supports complex access patterns', function test( t ) {
 		0.0,
 		0.0
 	];
-	N = 3;
 
-	gcusum( N, 0.0, x, 2, y, -1 );
+	gcusum( 3, 0.0, x, 2, y, -1 );
 
 	expected = [ 9.0, 4.0, 1.0, 0.0, 0.0, 0.0 ];
 
@@ -289,7 +467,6 @@ tape( 'the function supports view offsets', function test( t ) {
 	var y0;
 	var x1;
 	var y1;
-	var N;
 
 	// Initial arrays...
 	x0 = new Float64Array([
@@ -313,9 +490,7 @@ tape( 'the function supports view offsets', function test( t ) {
 	x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // begin at 2nd element
 	y1 = new Float64Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 ); // begin at the 4th element
 
-	N = floor( x0.length / 2 );
-
-	gcusum( N, 0.0, x1, -2, y1, 1 );
+	gcusum( 3, 0.0, x1, -2, y1, 1 );
 	expected = new Float64Array( [ 0.0, 0.0, 0.0, 6.0, 10.0, 12.0 ] );
 
 	t.deepEqual( y0, expected, 'deep equal' );