refactor: refactor main.js logic and edge cases handling

Author: LoayAhmed304

lib/node_modules/@stdlib/ndarray/base/where/README.md

@@ -129,6 +129,10 @@ Each provided ndarray should be an object with the following properties:
 
 ## Notes
 
+-   `condition` ndarray must be a `boolean` or `uint8` ndarray.
+-   `condition`, `x`, `y`, and `out` ndarrays must have the same shape.
+-   `x` and `y` must have the same data type.
+-   The function **mutates** the input ndarrays shapes and strides if necessary.
 -   For very high-dimensional ndarrays which are non-contiguous, one should consider copying the underlying data to contiguous memory before conditionally assigning elements in order to achieve better performance.
 
 </section>

lib/node_modules/@stdlib/ndarray/base/where/docs/repl.txt

@@ -49,7 +49,7 @@
 
     // Using minimal ndarray-like objects...
     > condition = {
-    ...     'dtype': dtype,
+    ...     'dtype': 'uint8',
     ...     'data': cbuf,
     ...     'shape': shape,
     ...     'strides': sc,

lib/node_modules/@stdlib/ndarray/base/where/docs/types/index.d.ts

@@ -29,6 +29,8 @@ import { ndarray } from '@stdlib/types/ndarray';
 * @param arrays - array-like object containing three input ndarrays and one output ndarray
 * @throws arrays must have the same number of dimensions
 * @throws arrays must have the same shape
+* @throws {Error} condition array must be a boolean or uint8 ndarray
+* @throws {Error} x and y ndarrays must have the same dtype
 *
 * @example
 * var Float64Array = require( '@stdlib/array/float64' );
@@ -57,7 +59,7 @@ import { ndarray } from '@stdlib/types/ndarray';
 * var oo = 0;
 *
 * // Create the input and output ndarrays:
-* var condition = ndarray( 'float64', cbuf, shape, sc, oc, 'row-major' );
+* var condition = ndarray( 'uint8', cbuf, shape, sc, oc, 'row-major' );
 * var x = ndarray( 'float64', xbuf, shape, sx, ox, 'row-major' );
 * var y = ndarray( 'float64', ybuf, shape, sy, oy, 'row-major' );
 * var out = ndarray( 'float64', obuf, shape, so, oo, 'row-major' );

lib/node_modules/@stdlib/ndarray/base/where/docs/types/test.ts

@@ -24,7 +24,9 @@ import where = require( './index' );
 
 // The function returns `undefined`...
 {
-	const condition = zeros( [ 2, 2 ] );
+	const condition = zeros( [ 2, 2 ], {
+		'dtype': 'uint8'
+	});
 	const x = zeros( [ 2, 2 ] );
 	const y = zeros( [ 2, 2 ] );
 	const out = zeros( [ 2, 2 ] );

lib/node_modules/@stdlib/ndarray/base/where/lib/0d_accessors.js

@@ -92,7 +92,7 @@
 *
 * // Create the ndarray-like objects:
 * var condition = {
-*     'dtype': 'uint8',
+*     'dtype': 'bool',
 *     'data': cbuf,
 *     'shape': shape,
 *     'strides': sc,

lib/node_modules/@stdlib/ndarray/base/where/lib/main.js

@@ -223,6 +223,8 @@ function complex2real( x ) {
 * @param {ArrayLikeObject<Object>} arrays - array-like object containing one condition array, two input arrays, and one output array
 * @throws {Error} arrays must have the same number of dimensions
 * @throws {Error} arrays must have the same shape
+* @throws {Error} condition array must be a boolean or uint8 ndarray
+* @throws {Error} x and y ndarrays must have the same dtype
 * @returns {void}
 *
 * @example
@@ -328,6 +330,14 @@ function where( arrays ) {
 	y = ndarray2object( arrays[ 2 ] );
 	o = ndarray2object( arrays[ 3 ] );
 
+	if ( !isBooleanArray( c.data ) && c.dtype !== 'bool' && c.dtype !== 'uint8') {
+		throw new Error( format( 'invalid arguments. Condition array must be a boolean or uint8 ndarray. c.dtype=%s', c.dtype ) );
+	}
+
+	if ( x.dtype !== y.dtype ) {
+		throw new Error( format( 'invalid arguments. Input arrays must have the same data type. x.dtype=%s, y.dtype=%s', x.dtype, y.dtype ) );
+	}
+
 	// Always reinterpret condition array to uint8
 	if ( isBooleanArray( c.data ) ) {
 		c = boolean2uint8( c );
@@ -342,6 +352,7 @@ function where( arrays ) {
 		x = complex2real( x );
 		y = complex2real( y );
 		o = complex2real( o );
+
 		c.shape.push( 2 ); // real and imaginary components
 		c.strides.push( 0 ); // broadcast
 	}
@@ -363,7 +374,7 @@ function where( arrays ) {
 	}
 	// Determine whether we can avoid iteration altogether...
 	if ( ndims === 0 ) {
-		if ( hasAccessors( x, y, o ) ) {
+		if ( hasAccessors( c, x, y, o ) ) {
 			return ACCESSOR_WHERE[ ndims ]( c, x, y, o );
 		}
 		return WHERE[ ndims ]( c, x, y, o );
@@ -390,7 +401,7 @@ function where( arrays ) {
 	}
 	// Determine whether the ndarrays are one-dimensional and thus readily translate to one-dimensional strided arrays...
 	if ( ndims === 1 ) {
-		if ( hasAccessors( x, y, o ) ) {
+		if ( hasAccessors( c, x, y, o ) ) {
 			return ACCESSOR_WHERE[ ndims ]( c, x, y, o );
 		}
 		return WHERE[ ndims ]( c, x, y, o );
@@ -416,7 +427,7 @@ function where( arrays ) {
 		x.strides = [ sx[i] ];
 		y.strides = [ sy[i] ];
 		o.strides = [ so[i] ];
-		if ( hasAccessors( x, y, o ) ) {
+		if ( hasAccessors( c, x, y, o ) ) {
 			return ACCESSOR_WHERE[ 1 ]( c, x, y, o );
 		}
 		return WHERE[ 1 ]( c, x, y, o );
@@ -470,7 +481,7 @@ function where( arrays ) {
 			x.offset = ox;
 			y.offset = oy;
 			o.offset = oo;
-			if ( hasAccessors( x, y, o ) ) {
+			if ( hasAccessors( c, x, y, o ) ) {
 				return ACCESSOR_WHERE[ 1 ]( c, x, y, o );
 			}
 			return WHERE[ 1 ]( c, x, y, o );
@@ -480,7 +491,7 @@ function where( arrays ) {
 		// Determine whether we can use simple nested loops...
 		if ( ndims <= MAX_DIMS ) {
 			// So long as iteration for each respective array always moves in the same direction (i.e., no mixed sign strides), we can leverage cache-optimal (i.e., normal) nested loops without resorting to blocked iteration...
-			if ( hasAccessors( x, y, o ) ) {
+			if ( hasAccessors( c, x, y, o ) ) {
 				return ACCESSOR_WHERE[ ndims ]( c, x, y, o, ord === 1 );
 			}
 			return WHERE[ ndims ]( c, x, y, o, ord === 1 );
@@ -491,13 +502,13 @@ function where( arrays ) {
 
 	// Determine whether we can perform blocked iteration...
 	if ( ndims <= MAX_DIMS ) {
-		if ( hasAccessors( x, y, o ) ) {
+		if ( hasAccessors( c, x, y, o ) ) {
 			return BLOCKED_ACCESSOR_WHERE[ ndims-2 ]( c, x, y, o );
 		}
 		return BLOCKED_WHERE[ ndims-2 ]( c, x, y, o );
 	}
 	// Fall-through to linear view iteration without regard for how data is stored in memory (i.e., take the slow path)...
-	if ( hasAccessors( x, y, o ) ) {
+	if ( hasAccessors( c, x, y, o ) ) {
 		return accessorwherend( c, x, y, o );
 	}
 	wherend( c, x, y, o );

lib/node_modules/@stdlib/ndarray/base/where/test/test.1d.js

@@ -191,7 +191,7 @@ tape( 'the function conditionally assigns elements from a 1-dimensional input nd
 		-3.0,
 		-4.0
 	];
-	condition = ndarray( 'generic', toAccessorArray( cbuf ), [ 4 ], [ 1 ], 0, 'row-major' );
+	condition = ndarray( 'uint8', toAccessorArray( cbuf ), [ 4 ], [ 1 ], 0, 'row-major' );
 	x = ndarray( 'generic', toAccessorArray( xbuf ), [ 4 ], [ 1 ], 0, 'row-major' );
 	y = ndarray( 'generic', toAccessorArray( ybuf ), [ 4 ], [ 1 ], 0, 'row-major' );
 	out = ndarray( 'generic', toAccessorArray( zeros( 4, 'generic' ) ), [ 4 ], [ 1 ], 0, 'row-major' );

lib/node_modules/@stdlib/ndarray/base/where/test/test.js

@@ -37,6 +37,37 @@ tape( 'main export is a function', function test( t ) {
 	t.end();
 });
 
+tape( 'the function throws an error if provided input ndarrays which doesnot have the same data types', function test( t ) {
+	var condition;
+	var values;
+	var out;
+	var x;
+	var y;
+	var i;
+
+	condition = ndarray( 'uint8', [ 1, 0, 0, 1 ], [ 4 ], [ 1 ], 0, 'row-major' );
+	x = ndarray( 'float32', [ 1.0, 2.0, 3.0, 4.0 ], [ 4 ], [ 1 ], 0, 'row-major' );
+	out = ndarray( 'generic', zeros( 8, 'generic' ), [ 4 ], [ 1 ], 0, 'row-major' );
+
+	values = [
+		'float64',
+		'complex64',
+		'uint8',
+		'bool'
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			y = ndarray( value, [ -1.0, -2.0, -3.0, -4.0 ], [ 4 ], [ 1 ], 0, 'row-major' );
+			where( [ condition, x, y, out ] );
+		};
+	}
+});
+
 tape( 'the function throws an error if provided ndarrays which doesnot have the same shape', function test( t ) {
 	var condition;
 	var values;
@@ -68,6 +99,36 @@ tape( 'the function throws an error if provided ndarrays which doesnot have the
 	}
 });
 
+tape( 'the function throws an error if provided a non-boolean or uint8 condition ndarray', function test( t ) {
+	var condition;
+	var values;
+	var out;
+	var x;
+	var y;
+	var i;
+
+	x = ndarray( 'float32', [ 1.0, 2.0, 3.0, 4.0 ], [ 4 ], [ 1 ], 0, 'row-major' );
+	y = ndarray( 'float32', [ -1.0, -2.0, -3.0, -4.0 ], [ 4 ], [ 1 ], 0, 'row-major' );
+	out = ndarray( 'float32', zeros( 4, 'float32' ), [ 4 ], [ 1 ], 0, 'row-major' );
+
+	values = [
+		'float64',
+		'complex64',
+		'binary'
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			condition = ndarray( value, [ 1, 0, 0, 1 ], [ 4 ], [ 1 ], 0, 'row-major' );
+			where( [ condition, x, y, out ] );
+		};
+	}
+});
+
 tape( 'the function conditionally assigns elements from an input ndarray to an output ndarray (boolean)', function test( t ) {
 	var condition;
 	var expected;