fix: refactor implementation to only support a single reduction dimension

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: passed
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: passed
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---

Author: kgryte

lib/node_modules/@stdlib/blas/ext/index-of/examples/index.js

@@ -32,9 +32,9 @@ var xbuf = discreteUniform( 10, 0, 20, {
 var x = new ndarray( 'float64', xbuf, [ 5, 2 ], [ 2, 1 ], 0, 'row-major' );
 console.log( ndarray2array( x ) );
 
-// Find index:
+// Perform operation:
 var idx = indexOf( x, 10.0, {
-	'dims': [ 0 ]
+	'dim': 0
 });
 
 // Print the results:

lib/node_modules/@stdlib/blas/ext/index-of/lib/base.js

@@ -55,7 +55,7 @@ var table = {
 // MAIN //
 
 /**
-* Returns the first index of a specified search element along one or more ndarray dimensions.
+* Returns the first index of a specified search element along an ndarray dimension.
 *
 * @private
 * @name indexOf
@@ -84,10 +84,10 @@ var table = {
 * var xbuf = new Float64Array( [ 1.0, 2.0, -3.0, 4.0, -5.0, 6.0 ] );
 *
 * // Define the shape of the input array:
-* var sh = [ 3, 1, 2 ];
+* var sh = [ 6 ];
 *
 * // Define the array strides:
-* var sx = [ 2, 2, 1 ];
+* var sx = [ 1 ];
 *
 * // Define the index offset:
 * var ox = 0;
@@ -105,7 +105,7 @@ var table = {
 *     'dtype': 'int32'
 * })
 *
-* // Find index:
+* // Perform operation:
 * var out = indexOf( x, searchElement, fromIndex );
 * // returns <ndarray>
 *

lib/node_modules/@stdlib/blas/ext/index-of/lib/index.js

@@ -19,7 +19,7 @@
 'use strict';
 
 /**
-* Return the first index of a specified search element along one or more ndarray dimensions.
+* Return the first index of a specified search element along an ndarray dimension.
 *
 * @module @stdlib/blas/ext/index-of
 *
@@ -43,7 +43,7 @@
 * // Create an input ndarray:
 * var x = new ndarray( 'float64', xbuf, sh, sx, ox, 'row-major' );
 *
-* // Find index:
+* // Perform operation:
 * var out = indexOf( x, 4.0 );
 * // returns <ndarray>
 *

lib/node_modules/@stdlib/blas/ext/index-of/lib/main.js

@@ -21,8 +21,7 @@
 // MODULES //
 
 var hasOwnProp = require( '@stdlib/assert/has-own-property' );
-var objectAssign = require( '@stdlib/object/assign' );
-var isObject = require( '@stdlib/assert/is-object' );
+var isPlainObject = require( '@stdlib/assert/is-plain-object' );
 var isInteger = require( '@stdlib/assert/is-integer' ).isPrimitive;
 var isndarrayLike = require( '@stdlib/assert/is-ndarray-like' );
 var broadcastScalar = require( '@stdlib/ndarray/base/broadcast-scalar' );
@@ -44,118 +43,151 @@ var DEFAULT_DTYPE = defaults.get( 'dtypes.integer_index' );
 // MAIN //
 
 /**
-* Returns the first index of a specified search element along one or more ndarray dimensions.
+* Returns the first index of a specified search element along an ndarray dimension.
 *
 * @name indexOf
 * @type {Function}
 * @param {ndarrayLike} x - input ndarray
 * @param {(ndarrayLike|*)} searchElement - search element
 * @param {(ndarrayLike|integer)} [fromIndex] - index from which to begin searching
 * @param {Options} [options] - function options
-* @param {IntegerArray} [options.dims] - list of dimensions over which to perform operation
+* @param {IntegerArray} [options.dim=-1] - dimension over which to perform operation
 * @param {boolean} [options.keepdims=false] - boolean indicating whether the reduced dimensions should be included in the returned ndarray as singleton dimensions
 * @param {string} [options.dtype] - output ndarray data type
 * @throws {TypeError} first argument must be an ndarray-like object
 * @throws {TypeError} the function must be provided at least two arguments
 * @throws {TypeError} third argument must be either an ndarray-like object or an integer
 * @throws {TypeError} options argument must be an object
-* @throws {RangeError} dimension indices must not exceed input ndarray bounds
-* @throws {RangeError} number of dimension indices must not exceed the number of input ndarray dimensions
+* @throws {RangeError} dimension index must not exceed input ndarray bounds
 * @throws {Error} must provide valid options
 * @returns {ndarray} output ndarray
 *
 * @example
 * var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
 * var ndarray = require( '@stdlib/ndarray/ctor' );
 *
 * // Create a data buffer:
 * var xbuf = new Float64Array( [ 1.0, 2.0, -3.0, 4.0, -5.0, 6.0 ] );
 *
 * // Define the shape of the input array:
-* var sh = [ 3, 1, 2 ];
+* var sh = [ 2, 3 ];
 *
 * // Define the array strides:
-* var sx = [ 2, 2, 1 ];
+* var sx = [ 3, 1 ];
 *
 * // Define the index offset:
 * var ox = 0;
 *
 * // Create an input ndarray:
 * var x = new ndarray( 'float64', xbuf, sh, sx, ox, 'row-major' );
 *
-* // Find index:
-* var out = indexOf( x, 4.0 );
+* // Perform operation:
+* var out = indexOf( x, -5.0 );
 * // returns <ndarray>
 *
-* var idx = out.get();
-* // returns 3
+* var arr = ndarray2array( out );
+* // returns [ -1, 1 ]
 */
-function indexOf( x, searchElement, fromIndex, options ) {
+function indexOf( x, searchElement, fromIndex ) {
+	var hasOptions;
+	var options;
 	var nargs;
 	var opts;
+	var fidx;
+	var iflg;
 	var ord;
 	var dt;
 	var sh;
-
-	if ( !isndarrayLike( x ) ) {
-		throw new TypeError( format( 'invalid argument. The first argument must be an ndarray-like object. Value: `%s`.', x ) );
-	}
+	var v;
 
 	nargs = arguments.length;
-	if ( nargs < 2 ) {
-		throw new TypeError( format( 'invalid argument. The function must be provided at least two arguments. Value: `%s`.', nargs ) );
-	}
 
+	if ( !isndarrayLike( x ) ) {
+		throw new TypeError( format( 'invalid argument. First argument must be an ndarray. Value: `%s`.', x ) );
+	}
 	// Resolve input ndarray meta data:
 	dt = getDType( x );
 	ord = getOrder( x );
 
-	// Initialize options object:
-	opts = {};
-
-	// Case: indexOf( x, searchElement )
-	if ( nargs === 2 ) {
-		fromIndex = 0;
+	if ( nargs < 2 ) {
+		throw new TypeError( format( 'invalid argument. Second argument must be either an ndarray or a scalar value. Value: `%s`.', searchElement ) );
 	}
-	// Case: indexOf( x, searchElement, options )
-	else if (
-		nargs === 3 &&
-		!isndarrayLike( fromIndex ) &&
-		isObject( fromIndex )
-	) {
-		opts = objectAssign( opts, fromIndex );
-		fromIndex = 0;
+	// Initialize an options object:
+	opts = {
+		'dims': [ -1 ], // default behavior is to perform a reduction over the last dimension
+		'keepdims': false
+	};
+
+	// Initialize the `fromIndex` to the first element along a dimension:
+	fidx = 0;
+
+	// Initialize a flag indicating whether the `fromIndex` argument is a scalar:
+	iflg = true;
+
+	// Initialize a flag indicating whether an `options` argument was provided:
+	hasOptions = false;
+
+	// Case: indexOf( x, search_element, ??? )
+	if ( nargs === 3 ) {
+		// Case: indexOf( x, search_element, from_index_scalar )
+		if ( isInteger( fromIndex ) ) {
+			fidx = fromIndex;
+		}
+		// Case: indexOf( x, search_element, from_index_ndarray )
+		else if ( isndarrayLike( fromIndex ) ) {
+			fidx = fromIndex;
+			iflg = false;
+		}
+		// Case: indexOf( x, search_element, options )
+		else {
+			options = fromIndex;
+			hasOptions = true;
+		}
 	}
-	// Case: indexOf( x, searchElement, fromIndex, options )
-	else if ( nargs === 4 ) {
-		if ( !isObject( options ) ) {
-			throw new TypeError( format( 'invalid argument. The fourth argument must be an object. Value: `%s`.', options ) );
+	// Case: indexOf( x, search_element, from_index, options )
+	else if ( nargs > 3 ) {
+		// Case: indexOf( x, search_element, from_index_scalar, options )
+		if ( isInteger( fromIndex ) ) {
+			fidx = fromIndex;
+		}
+		// Case: indexOf( x, search_element, from_index_ndarray, options )
+		else if ( isndarrayLike( fromIndex ) ) {
+			fidx = fromIndex;
 		}
-		opts = objectAssign( opts, options );
+		// Case: indexOf( x, search_element, ???, options )
+		else {
+			throw new TypeError( format( 'invalid argument. Third argument must be either an ndarray or an integer. Value: `%s`.', fromIndex ) );
+		}
+		options = arguments[ 3 ];
+		hasOptions = true;
 	}
-
-	// Resolve shape for broadcasting
-	if ( hasOwnProp( opts, 'dims' ) ) {
-		sh = nonCoreShape( getShape( x ), opts.dims );
-	} else {
-		sh = [];
+	if ( hasOptions && !isPlainObject( options ) ) {
+		throw new TypeError( format( 'invalid argument. Options argument must be an object. Value: `%s`.', options ) );
+	}
+	// Resolve provided options...
+	if ( hasOwnProp( options, 'dim' ) ) {
+		opts.dims[ 0 ] = options.dim;
+	}
+	if ( hasOwnProp( options, 'keepdims' ) ) {
+		opts.keepdims = options.keepdims;
 	}
+	// Resolve the list of non-reduced dimensions:
+	sh = nonCoreShape( getShape( x ), opts.dims );
 
+	// Broadcast the search element to match the shape of the non-reduced dimensions...
 	if ( isndarrayLike( searchElement ) ) {
-		searchElement = maybeBroadcastArray( searchElement, sh );
+		v = maybeBroadcastArray( searchElement, sh );
 	} else {
-		searchElement = broadcastScalar( searchElement, dt, sh, ord );
+		v = broadcastScalar( searchElement, dt, sh, ord );
 	}
-
-	if ( isndarrayLike( fromIndex ) ) {
-		fromIndex = maybeBroadcastArray( fromIndex, sh );
-	} else if ( isInteger( fromIndex ) ) {
-		fromIndex = broadcastScalar( fromIndex, DEFAULT_DTYPE, sh, ord );
+	// Broadcast the `fromIndex` to match the shape of the non-reduced dimensions...
+	if ( iflg ) {
+		fidx = broadcastScalar( fidx, DEFAULT_DTYPE, sh, ord );
 	} else {
-		throw new TypeError( format( 'invalid argument. Third argument must be either an ndarray or an integer. Value: `%s`.', fromIndex ) );
+		fidx = maybeBroadcastArray( fidx, sh );
 	}
-
-	return base( x, searchElement, fromIndex, opts );
+	return base( x, v, fidx, opts );
 }
 
 

lib/node_modules/@stdlib/blas/ext/index-of/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stdlib/blas/ext/index-of",
   "version": "0.0.0",
-  "description": "Return the first index of a specified search element along one or more ndarray dimensions.",
+  "description": "Return the first index of a specified search element along an ndarray dimension.",
   "license": "Apache-2.0",
   "author": {
     "name": "The Stdlib Authors",
@@ -56,12 +56,7 @@
     "search",
     "element",
     "array",
-    "ndarray",
-    "strided",
-    "double",
-    "float",
-    "float64",
-    "float64array"
+    "ndarray"
   ],
   "__stdlib__": {}
 }