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

lib/node_modules/@stdlib/blas/ext/base/ndarray/cfill-equal/README.md

@@ -55,8 +55,16 @@ var alpha = scalar2ndarray( new Complex64( 5.0, 5.0 ), {
     'dtype': 'complex64'
 });
 
-cfillEqual( [ x, searchElement, alpha ] );
-// x => <ndarray>[ <Complex64>[ 5.0, 5.0 ], <Complex64>[ -2.0, 3.0 ], <Complex64>[ 5.0, 5.0 ], <Complex64>[ 4.0, -6.0 ] ]
+var start = scalar2ndarray( 0, {
+    'dtype': 'generic'
+});
+
+var end = scalar2ndarray( 2, {
+    'dtype': 'generic'
+});
+
+cfillEqual( [ x, searchElement, alpha, start, end ] );
+// x => <ndarray>[ <Complex64>[ 5.0, 5.0 ], <Complex64>[ -2.0, 3.0 ], <Complex64>[ 0.0, 0.0 ], <Complex64>[ 4.0, -6.0 ] ]
 ```
 
 The function has the following parameters:
@@ -66,6 +74,8 @@ The function has the following parameters:
     -   a one-dimensional input ndarray.
     -   a zero-dimensional ndarray containing the search element.
     -   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>
 
@@ -76,6 +86,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).
 -   When comparing elements, the function checks for equality of real and imaginary components using the strict equality operator `===`. As a consequence, `NaN` components are considered distinct (i.e., as `NaN === NaN` always evaluates to `false`, elements having one or more `NaN` components are never replaced), and `-0` and `+0` are considered the same.
 
 </section>
@@ -114,7 +125,17 @@ var alpha = scalar2ndarray( new Complex64( 5.0, 5.0 ), {
 });
 console.log( 'Alpha:', ndarraylike2scalar( alpha ) );
 
-cfillEqual( [ x, searchElement, alpha ] );
+var start = scalar2ndarray( 5, {
+    'dtype': 'generic'
+});
+console.log( 'Start Index:', ndarraylike2scalar( start ) );
+
+var end = scalar2ndarray( 15, {
+    'dtype': 'generic'
+});
+console.log( 'End Index:', ndarraylike2scalar( end ) );
+
+cfillEqual( [ x, searchElement, alpha, start, end ] );
 console.log( ndarray2array( x ) );
 ```
 

lib/node_modules/@stdlib/blas/ext/base/ndarray/cfill-equal/benchmark/benchmark.js

@@ -50,7 +50,9 @@ var options = {
 function createBenchmark( len ) {
 	var searchElement;
 	var alpha;
+	var start;
 	var xbuf;
+	var end;
 	var x;
 	var i;
 
@@ -76,6 +78,12 @@ function createBenchmark( len ) {
 			'dtype': 'complex64'
 		})
 	];
+	start = scalar2ndarray( 0, {
+		'dtype': 'generic'
+	});
+	end = scalar2ndarray( len, {
+		'dtype': 'generic'
+	});
 	return benchmark;
 
 	/**
@@ -90,7 +98,7 @@ function createBenchmark( len ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			out = cfillEqual( [ x, searchElement[ i%2 ], alpha[ i%2 ] ] );
+			out = cfillEqual( [ x, searchElement[ i%2 ], alpha[ i%2 ], start, end ] ); // eslint-disable-line max-len
 			if ( typeof out !== 'object' ) {
 				b.fail( 'should return an ndarray' );
 			}

lib/node_modules/@stdlib/blas/ext/base/ndarray/cfill-equal/docs/repl.txt

@@ -7,6 +7,10 @@
     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).
+
     When comparing elements, the function checks for equality of real and
     imaginary components using the strict equality operator `===`. As a
     consequence, `NaN` components are considered distinct (i.e., as
@@ -22,6 +26,8 @@
         - a one-dimensional input ndarray.
         - a zero-dimensional ndarray containing the search element.
         - 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
     -------
@@ -35,7 +41,9 @@
     > var v = {{alias:@stdlib/ndarray/from-scalar}}( s, { 'dtype': 'complex64' } );
     > var a = new {{alias:@stdlib/complex/float32/ctor}}( 5.0, 5.0 );
     > var alpha = {{alias:@stdlib/ndarray/from-scalar}}( a, { 'dtype': 'complex64' } );
-    > {{alias}}( [ x, v, alpha ] )
+    > var st = {{alias:@stdlib/ndarray/from-scalar}}( 0, { 'dtype': 'generic' } );
+    > var en = {{alias:@stdlib/ndarray/from-scalar}}( 2, { 'dtype': 'generic' } );
+    > {{alias}}( [ x, v, alpha, st, en ] )
     <ndarray>[ <Complex64>[ 5.0, 5.0 ], <Complex64>[ -2.0, 3.0 ] ]
 
     See Also

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

@@ -33,6 +33,8 @@ import { Complex64 } from '@stdlib/types/complex';
 *     -   a one-dimensional input ndarray.
 *     -   a zero-dimensional ndarray containing the search element.
 *     -   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).
 *
 * -   When comparing elements, the function checks for equality of real and imaginary components using the strict equality operator `===`. As a consequence, `NaN` components are considered distinct (i.e., as `NaN === NaN` always evaluates to `false`, elements having one or more `NaN` components are never replaced), and `-0` and `+0` are considered the same.
 *
@@ -54,10 +56,18 @@ import { Complex64 } from '@stdlib/types/complex';
 *     'dtype': 'complex64'
 * });
 *
-* var out = cfillEqual( [ x, searchElement, alpha ] );
-* // returns <ndarray>[ <Complex64>[ 5.0, 5.0 ], <Complex64>[ -2.0, 3.0 ], <Complex64>[ 5.0, 5.0 ], <Complex64>[ 4.0, -6.0 ] ]
+* var start = scalar2ndarray( 0, {
+*     'dtype': 'generic'
+* });
+*
+* var end = scalar2ndarray( 2, {
+*     'dtype': 'generic'
+* });
+*
+* var out = cfillEqual( [ x, searchElement, alpha, start, end ] );
+* // returns <ndarray>[ <Complex64>[ 5.0, 5.0 ], <Complex64>[ -2.0, 3.0 ], <Complex64>[ 0.0, 0.0 ], <Complex64>[ 4.0, -6.0 ] ]
 */
-declare function cfillEqual( arrays: [ complex64ndarray, typedndarray<Complex64>, typedndarray<Complex64> ] ): complex64ndarray;
+declare function cfillEqual( arrays: [ complex64ndarray, typedndarray<Complex64>, typedndarray<Complex64>, typedndarray<number>, typedndarray<number> ] ): complex64ndarray;
 
 
 // EXPORTS //

lib/node_modules/@stdlib/blas/ext/base/ndarray/cfill-equal/docs/types/test.ts

@@ -37,8 +37,14 @@ import cfillEqual = require( './index' );
 	const alpha = scalar2ndarray( new Complex64( 5.0, 5.0 ), {
 		'dtype': 'complex64'
 	});
+	const start = scalar2ndarray( 0, {
+		'dtype': 'generic'
+	});
+	const end = scalar2ndarray( 10, {
+		'dtype': 'generic'
+	});
 
-	cfillEqual( [ x, searchElement, alpha ] ); // $ExpectType complex64ndarray
+	cfillEqual( [ x, searchElement, alpha, start, end ] ); // $ExpectType complex64ndarray
 }
 
 // The compiler throws an error if the function is provided a first argument which is not an array of ndarrays...
@@ -65,7 +71,13 @@ import cfillEqual = require( './index' );
 	const alpha = scalar2ndarray( new Complex64( 5.0, 5.0 ), {
 		'dtype': 'complex64'
 	});
+	const start = scalar2ndarray( 0, {
+		'dtype': 'generic'
+	});
+	const end = scalar2ndarray( 10, {
+		'dtype': 'generic'
+	});
 
 	cfillEqual(); // $ExpectError
-	cfillEqual( [ x, searchElement, alpha ], {} ); // $ExpectError
+	cfillEqual( [ x, searchElement, alpha, start, end ], {} ); // $ExpectError
 }

lib/node_modules/@stdlib/blas/ext/base/ndarray/cfill-equal/examples/index.js

@@ -43,5 +43,15 @@ var alpha = scalar2ndarray( new Complex64( 5.0, 5.0 ), {
 });
 console.log( 'Alpha:', ndarraylike2scalar( alpha ) );
 
-cfillEqual( [ x, searchElement, alpha ] );
+var start = scalar2ndarray( 5, {
+	'dtype': 'generic'
+});
+console.log( 'Start Index:', ndarraylike2scalar( start ) );
+
+var end = scalar2ndarray( 15, {
+	'dtype': 'generic'
+});
+console.log( 'End Index:', ndarraylike2scalar( end ) );
+
+cfillEqual( [ x, searchElement, alpha, start, end ] );
 console.log( ndarray2array( x ) );

lib/node_modules/@stdlib/blas/ext/base/ndarray/cfill-equal/lib/index.js

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

lib/node_modules/@stdlib/blas/ext/base/ndarray/cfill-equal/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/cfill-equal' ).ndarray;
 var ndarraylike2scalar = require( '@stdlib/ndarray/base/ndarraylike2scalar' );
+var strided = require( '@stdlib/blas/ext/base/cfill-equal' ).ndarray;
 
 
 // MAIN //
@@ -40,6 +41,8 @@ var ndarraylike2scalar = require( '@stdlib/ndarray/base/ndarraylike2scalar' );
 *     -   a one-dimensional input ndarray.
 *     -   a zero-dimensional ndarray containing the search element.
 *     -   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).
 *
 * -   When comparing elements, the function checks for equality of real and imaginary components using the strict equality operator `===`. As a consequence, `NaN` components are considered distinct (i.e., as `NaN === NaN` always evaluates to `false`, elements having one or more `NaN` components are never replaced), and `-0` and `+0` are considered the same.
 *
@@ -61,18 +64,41 @@ var ndarraylike2scalar = require( '@stdlib/ndarray/base/ndarraylike2scalar' );
 *     'dtype': 'complex64'
 * });
 *
-* var out = cfillEqual( [ x, searchElement, alpha ] );
-* // returns <ndarray>[ <Complex64>[ 5.0, 5.0 ], <Complex64>[ -2.0, 3.0 ], <Complex64>[ 5.0, 5.0 ], <Complex64>[ 4.0, -6.0 ] ]
+* var start = scalar2ndarray( 0, {
+*     'dtype': 'generic'
+* });
+*
+* var end = scalar2ndarray( 2, {
+*     'dtype': 'generic'
+* });
+*
+* var out = cfillEqual( [ x, searchElement, alpha, start, end ] );
+* // returns <ndarray>[ <Complex64>[ 5.0, 5.0 ], <Complex64>[ -2.0, 3.0 ], <Complex64>[ 0.0, 0.0 ], <Complex64>[ 4.0, -6.0 ] ]
 */
 function cfillEqual( arrays ) {
 	var searchElement;
+	var stride;
+	var offset;
 	var alpha;
+	var start;
+	var end;
+	var N;
 	var x;
 
 	x = arrays[ 0 ];
 	searchElement = ndarraylike2scalar( arrays[ 1 ] );
 	alpha = ndarraylike2scalar( arrays[ 2 ] );
-	strided( numelDimension( x, 0 ), searchElement, alpha, getData( x ), getStride( x, 0 ), getOffset( x ) ); // eslint-disable-line max-len
+
+	N = numelDimension( x, 0 );
+	start = clipIndex( ndarraylike2scalar( arrays[ 3 ] ), N );
+	end = clipIndex( ndarraylike2scalar( arrays[ 4 ] ), N );
+	if ( start >= end ) {
+		return x;
+	}
+	stride = getStride( x, 0 );
+	offset = getOffset( x ) + ( stride*start );
+
+	strided( end-start, searchElement, alpha, getData( x ), stride, offset );
 	return x;
 }