fix: remove perf logic in order to ensure expected indices in callback

Author: kgryte

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

@@ -21,7 +21,6 @@
 // MODULES //
 
 var iterationOrder = require( '@stdlib/ndarray/base/iteration-order' );
-var minmaxViewBufferIndex = require( '@stdlib/ndarray/base/minmax-view-buffer-index' );
 var ndarray2object = require( '@stdlib/ndarray/base/ndarraylike2object' );
 var blockedaccessormap2d = require( './2d_blocked_accessors.js' );
 var blockedaccessormap3d = require( './3d_blocked_accessors.js' );
@@ -191,18 +190,11 @@ var MAX_DIMS = MAP.length -1;
 */
 function map( arrays, fcn, thisArg ) {
 	var ndims;
-	var xmmv;
-	var ymmv;
 	var shx;
 	var shy;
 	var iox;
 	var ioy;
 	var len;
-	var sx;
-	var sy;
-	var ox;
-	var oy;
-	var ns;
 	var x;
 	var y;
 	var i;
@@ -228,19 +220,13 @@ function map( arrays, fcn, thisArg ) {
 	}
 	// Verify that the input and output arrays have the same dimensions...
 	len = 1; // number of elements
-	ns = 0; // number of singleton dimensions
 	for ( i = 0; i < ndims; i++ ) {
 		d = shx[ i ];
 		if ( d !== shy[ i ] ) {
 			throw new Error( 'invalid arguments. Array must have the same shape.' );
 		}
 		// Note that, if one of the dimensions is `0`, the length will be `0`...
 		len *= d;
-
-		// Check whether the current dimension is a singleton dimension...
-		if ( d === 1 ) {
-			ns += 1;
-		}
 	}
 	// Check whether we were provided empty ndarrays...
 	if ( len === 0 ) {
@@ -253,63 +239,12 @@ function map( arrays, fcn, thisArg ) {
 		}
 		return MAP[ ndims ]( x, y, fcn, thisArg );
 	}
-
-	sx = x.strides;
-	sy = y.strides;
-
-	// Determine whether the ndarray has only **one** non-singleton dimension (e.g., ndims=4, shape=[10,1,1,1]) so that we can treat the ndarrays as being equivalent to one-dimensional strided arrays...
-	if ( ns === ndims-1 ) {
-		// Get the index of the non-singleton dimension...
-		for ( i = 0; i < ndims; i++ ) {
-			if ( shx[ i ] !== 1 ) {
-				break;
-			}
-		}
-		x.shape = [ shx[i] ];
-		y.shape = x.shape;
-		x.strides = [ sx[i] ];
-		y.strides = [ sy[i] ];
-		if ( x.accessorProtocol || y.accessorProtocol ) {
-			return ACCESSOR_MAP[ 1 ]( x, y, fcn, thisArg );
-		}
-		return MAP[ 1 ]( x, y, fcn, thisArg );
-	}
-
-	iox = iterationOrder( sx ); // +/-1
-	ioy = iterationOrder( sy ); // +/-1
+	// Determine iteration order:
+	iox = iterationOrder( x.strides ); // +/-1
+	ioy = iterationOrder( y.strides ); // +/-1
 
 	// Determine whether we can avoid blocked iteration...
 	if ( iox !== 0 && ioy !== 0 && iox === ioy ) {
-		// Determine the minimum and maximum linear indices which are accessible by the array views:
-		xmmv = minmaxViewBufferIndex( shx, sx, x.offset );
-		ymmv = minmaxViewBufferIndex( shy, sy, y.offset );
-
-		// Determine whether we can ignore shape (and strides) and treat the ndarrays as linear one-dimensional strided arrays...
-		if ( len === ( xmmv[1]-xmmv[0]+1 ) && len === ( ymmv[1]-ymmv[0]+1 ) ) {
-			// Note: the above is equivalent to @stdlib/ndarray/base/assert/is-contiguous, but in-lined so we can retain computed values...
-			if ( iox === 1 ) {
-				ox = xmmv[ 0 ];
-			} else {
-				ox = xmmv[ 1 ];
-			}
-			if ( ioy === 1 ) {
-				oy = ymmv[ 0 ];
-			} else {
-				oy = ymmv[ 1 ];
-			}
-			x.shape = [ len ];
-			y.shape = x.shape;
-			x.strides = [ iox ];
-			y.strides = [ ioy ];
-			x.offset = ox;
-			y.offset = oy;
-			if ( x.accessorProtocol || y.accessorProtocol ) {
-				return ACCESSOR_MAP[ 1 ]( x, y, fcn, thisArg );
-			}
-			return MAP[ 1 ]( x, y, fcn, thisArg );
-		}
-		// At least one ndarray is non-contiguous, so we cannot directly use one-dimensional array functionality...
-
 		// 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...
@@ -320,8 +255,6 @@ function map( arrays, fcn, thisArg ) {
 		}
 		// Fall-through to blocked iteration...
 	}
-	// At this point, we're either dealing with non-contiguous n-dimensional arrays, high dimensional n-dimensional arrays, and/or arrays having differing memory layouts, so our only hope is that we can still perform blocked iteration...
-
 	// Determine whether we can perform blocked iteration...
 	if ( ndims <= MAX_DIMS ) {
 		if ( x.accessorProtocol || y.accessorProtocol ) {