feat!: add start and end parameter support to blas/ext/base/ndarray/gfill-nan

lib/node_modules/@stdlib/blas/ext/base/ndarray/gfill-nan/README.md

@@ -50,8 +50,16 @@ var alpha = scalar2ndarray( 0.0, {
     'dtype': 'generic'
 });
 
-gfillNaN( [ x, alpha ] );
-// x => <ndarray>[ 0.0, -2.0, 3.0, 0.0, 4.0, -6.0 ]
+var start = scalar2ndarray( 0, {
+    'dtype': 'generic'
+});
+
+var end = scalar2ndarray( 2, {
+    'dtype': 'generic'
+});
+
+gfillNaN( [ x, alpha, start, end ] );
+// x => <ndarray>[ 0.0, -2.0, 3.0, NaN, 4.0, -6.0 ]
 ```
 
 The function has the following parameters:
@@ -60,6 +68,8 @@ The function has the following parameters:
 
     -   a one-dimensional input ndarray.
     -   a zero-dimensional ndarray containing the scalar constant.
+    -   a zero-dimensional ndarray containing the starting index (inclusive).
+    -   a zero-dimensional ndarray containing the ending index (exclusive).
 
 </section>
 
@@ -70,6 +80,7 @@ The function has the following parameters:
 ## Notes
 
 -   The input ndarray is modified **in-place** (i.e., the input ndarray is **mutated**).
+-   If a specified `start` or `end` index is negative, the function resolves the respective index by counting backward from the last element (where `-1` refers to the last element).
 
 </section>
 
@@ -92,13 +103,19 @@ var opts = {
     'dtype': 'generic'
 };
 
-var x = nans( [ 10 ], opts );
+var x = nans( [ 20 ], opts );
 console.log( ndarray2array( x ) );
 
 var alpha = scalar2ndarray( 5, opts );
 console.log( 'Alpha: %d', ndarraylike2scalar( alpha ) );
 
-gfillNaN( [ x, alpha ] );
+var start = scalar2ndarray( 5, opts );
+console.log( 'Start Index: %d', ndarraylike2scalar( start ) );
+
+var end = scalar2ndarray( 15, opts );
+console.log( 'End Index: %d', ndarraylike2scalar( end ) );
+
+gfillNaN( [ x, alpha, start, end ] );
 console.log( ndarray2array( x ) );
 ```
 

lib/node_modules/@stdlib/blas/ext/base/ndarray/gfill-nan/benchmark/benchmark.js

@@ -63,10 +63,14 @@ function clbk( value, indices ) {
 */
 function createBenchmark( len ) {
 	var alpha;
+	var start;
+	var end;
 	var x;
 
 	x = fillBy( zeros( [ len ], options ), clbk );
 	alpha = scalar2ndarray( 0.0, options );
+	start = scalar2ndarray( 0, options );
+	end = scalar2ndarray( len, options );
 	return benchmark;
 
 	/**
@@ -81,7 +85,7 @@ function createBenchmark( len ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			out = gfillNaN( [ x, alpha ] );
+			out = gfillNaN( [ x, alpha, start, end ] );
 			if ( typeof out !== 'object' ) {
 				b.fail( 'should return an ndarray' );
 			}

lib/node_modules/@stdlib/blas/ext/base/ndarray/gfill-nan/docs/repl.txt

@@ -6,13 +6,19 @@
     The input ndarray is modified *in-place* (i.e., the input ndarray is
     *mutated*).
 
+    If a specified `start` or `end` index is negative, the function resolves
+    the respective index by counting backward from the last element (where `-1`
+    refers to the last element).
+
     Parameters
     ----------
     arrays: ArrayLikeObject<ndarray>
         Array-like object containing the following ndarrays:
 
         - a one-dimensional input ndarray.
         - a zero-dimensional ndarray containing the scalar constant.
+        - a zero-dimensional ndarray containing the starting index (inclusive).
+        - a zero-dimensional ndarray containing the ending index (exclusive).
 
     Returns
     -------
@@ -25,8 +31,10 @@
     > var x = {{alias:@stdlib/ndarray/vector/ctor}}( buf, 'generic' );
     > var opts = { 'dtype': 'generic' };
     > var alpha = {{alias:@stdlib/ndarray/from-scalar}}( 0.0, opts );
-    > {{alias}}( [ x, alpha ] )
-    <ndarray>[ 0.0, -2.0, 3.0, 0.0, 4.0, -6.0 ]
+    > var st = {{alias:@stdlib/ndarray/from-scalar}}( 0, opts );
+    > var en = {{alias:@stdlib/ndarray/from-scalar}}( 2, opts );
+    > {{alias}}( [ x, alpha, st, en ] )
+    <ndarray>[ 0.0, -2.0, 3.0, NaN, 4.0, -6.0 ]
 
     See Also
     --------

lib/node_modules/@stdlib/blas/ext/base/ndarray/gfill-nan/docs/types/index.d.ts

@@ -31,6 +31,8 @@ import { typedndarray } from '@stdlib/types/ndarray';
 *
 *     -   a one-dimensional input ndarray.
 *     -   a zero-dimensional ndarray containing the scalar constant.
+*     -   a zero-dimensional ndarray containing the starting index (inclusive).
+*     -   a zero-dimensional ndarray containing the ending index (exclusive).
 *
 * @param arrays - array-like object containing ndarrays
 * @returns input ndarray
@@ -45,10 +47,18 @@ import { typedndarray } from '@stdlib/types/ndarray';
 *     'dtype': 'generic'
 * });
 *
-* var out = gfillNaN( [ x, alpha ] );
-* // returns <ndarray>[ 0.0, -2.0, 3.0, 0.0, 4.0, -6.0 ]
+* var start = scalar2ndarray( 0, {
+*     'dtype': 'generic'
+* });
+*
+* var end = scalar2ndarray( 2, {
+*     'dtype': 'generic'
+* });
+*
+* var out = gfillNaN( [ x, alpha, start, end ] );
+* // returns <ndarray>[ 0.0, -2.0, 3.0, NaN, 4.0, -6.0 ]
 */
-declare function gfillNaN<T = unknown, U = unknown, V extends typedndarray<T | U> = typedndarray<T | U>>( arrays: [ V, typedndarray<U> ] ): V;
+declare function gfillNaN<T = unknown, U = unknown, V extends typedndarray<T | U> = typedndarray<T | U>>( arrays: [ V, typedndarray<U>, typedndarray<number>, typedndarray<number> ] ): V;
 
 
 // EXPORTS //

lib/node_modules/@stdlib/blas/ext/base/ndarray/gfill-nan/docs/types/test.ts

@@ -33,8 +33,14 @@ import gfillNaN = require( './index' );
 	const alpha = scalar2ndarray( 0.0, {
 		'dtype': 'generic'
 	});
+	const start = scalar2ndarray( 0, {
+		'dtype': 'generic'
+	});
+	const end = scalar2ndarray( 10, {
+		'dtype': 'generic'
+	});
 
-	gfillNaN( [ x, alpha ] ); // $ExpectType genericndarray<number>
+	gfillNaN( [ x, alpha, start, end ] ); // $ExpectType genericndarray<number>
 }
 
 // The compiler throws an error if the function is provided a first argument which is not an array of ndarrays...
@@ -58,7 +64,13 @@ import gfillNaN = require( './index' );
 	const alpha = scalar2ndarray( 0.0, {
 		'dtype': 'generic'
 	});
+	const start = scalar2ndarray( 0, {
+		'dtype': 'generic'
+	});
+	const end = scalar2ndarray( 10, {
+		'dtype': 'generic'
+	});
 
 	gfillNaN(); // $ExpectError
-	gfillNaN( [ x, alpha ], {} ); // $ExpectError
+	gfillNaN( [ x, alpha, start, end ], {} ); // $ExpectError
 }

lib/node_modules/@stdlib/blas/ext/base/ndarray/gfill-nan/examples/index.js

@@ -28,11 +28,17 @@ var opts = {
 	'dtype': 'generic'
 };
 
-var x = nans( [ 10 ], opts );
+var x = nans( [ 20 ], opts );
 console.log( ndarray2array( x ) );
 
 var alpha = scalar2ndarray( 5, opts );
 console.log( 'Alpha: %d', ndarraylike2scalar( alpha ) );
 
-gfillNaN( [ x, alpha ] );
+var start = scalar2ndarray( 5, opts );
+console.log( 'Start Index: %d', ndarraylike2scalar( start ) );
+
+var end = scalar2ndarray( 15, opts );
+console.log( 'End Index: %d', ndarraylike2scalar( end ) );
+
+gfillNaN( [ x, alpha, start, end ] );
 console.log( ndarray2array( x ) );

lib/node_modules/@stdlib/blas/ext/base/ndarray/gfill-nan/lib/index.js

@@ -34,8 +34,16 @@
 *     'dtype': 'generic'
 * });
 *
-* var out = gfillNaN( [ x, alpha ] );
-* // returns <ndarray>[ 0.0, -2.0, 3.0, 0.0, 4.0, -6.0 ]
+* var start = scalar2ndarray( 0, {
+*     'dtype': 'generic'
+* });
+*
+* var end = scalar2ndarray( 2, {
+*     'dtype': 'generic'
+* });
+*
+* var out = gfillNaN( [ x, alpha, start, end ] );
+* // returns <ndarray>[ 0.0, -2.0, 3.0, NaN, 4.0, -6.0 ]
 */
 
 // MODULES //

lib/node_modules/@stdlib/blas/ext/base/ndarray/gfill-nan/lib/main.js

@@ -21,11 +21,12 @@
 // MODULES //
 
 var numelDimension = require( '@stdlib/ndarray/base/numel-dimension' );
+var clipIndex = require( '@stdlib/ndarray/base/clip-index' );
 var getStride = require( '@stdlib/ndarray/base/stride' );
 var getOffset = require( '@stdlib/ndarray/base/offset' );
 var getData = require( '@stdlib/ndarray/base/data-buffer' );
-var strided = require( '@stdlib/blas/ext/base/gfill-nan' ).ndarray;
 var ndarraylike2scalar = require( '@stdlib/ndarray/base/ndarraylike2scalar' );
+var strided = require( '@stdlib/blas/ext/base/gfill-nan' ).ndarray;
 
 
 // MAIN //
@@ -39,6 +40,8 @@ var ndarraylike2scalar = require( '@stdlib/ndarray/base/ndarraylike2scalar' );
 *
 *     -   a one-dimensional input ndarray.
 *     -   a zero-dimensional ndarray containing the scalar constant.
+*     -   a zero-dimensional ndarray containing the starting index (inclusive).
+*     -   a zero-dimensional ndarray containing the ending index (exclusive).
 *
 * @param {ArrayLikeObject<Object>} arrays - array-like object containing ndarrays
 * @returns {ndarray} input ndarray
@@ -53,16 +56,39 @@ var ndarraylike2scalar = require( '@stdlib/ndarray/base/ndarraylike2scalar' );
 *     'dtype': 'generic'
 * });
 *
-* var out = gfillNaN( [ x, alpha ] );
-* // returns <ndarray>[ 0.0, -2.0, 3.0, 0.0, 4.0, -6.0 ]
+* var start = scalar2ndarray( 0, {
+*     'dtype': 'generic'
+* });
+*
+* var end = scalar2ndarray( 2, {
+*     'dtype': 'generic'
+* });
+*
+* var out = gfillNaN( [ x, alpha, start, end ] );
+* // returns <ndarray>[ 0.0, -2.0, 3.0, NaN, 4.0, -6.0 ]
 */
 function gfillNaN( arrays ) {
+	var stride;
+	var offset;
 	var alpha;
+	var start;
+	var end;
+	var N;
 	var x;
 
 	x = arrays[ 0 ];
 	alpha = ndarraylike2scalar( arrays[ 1 ] );
-	strided( numelDimension( x, 0 ), alpha, getData( x ), getStride( x, 0 ), getOffset( x ) ); // eslint-disable-line max-len
+
+	N = numelDimension( x, 0 );
+	start = clipIndex( ndarraylike2scalar( arrays[ 2 ] ), N );
+	end = clipIndex( ndarraylike2scalar( arrays[ 3 ] ), N );
+	if ( start >= end ) {
+		return x;
+	}
+	stride = getStride( x, 0 );
+	offset = getOffset( x ) + ( stride*start );
+
+	strided( end-start, alpha, getData( x ), stride, offset );
 	return x;
 }