fix: refactor implementation to only support a single reduction dimension

kgryte · kgryte · commit 34f1b7340727 · 2025-07-10T21:40:23.000-07:00
---
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: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - 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
---
diff --git a/lib/node_modules/@stdlib/blas/ext/index-of/lib/assign.js b/lib/node_modules/@stdlib/blas/ext/index-of/lib/assign.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,39 +43,38 @@ var DEFAULT_DTYPE = defaults.get( 'dtypes.integer_index' );
 // MAIN //
 
 /**
-* Returns the first index of a specified search element along one or more ndarray dimensions and assigns the results to a provided output ndarray.
+* Returns the first index of a specified search element along an ndarray dimension and assigns the results to a provided output ndarray.
 *
-* @name assign
-* @type {Function}
 * @param {ndarrayLike} x - input ndarray
 * @param {(ndarrayLike|*)} searchElement - search element
 * @param {(ndarrayLike|integer)} [fromIndex] - index from which to begin searching
 * @param {ndarrayLike} out - output ndarray
 * @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
 * @throws {TypeError} function must be provided at least three arguments
 * @throws {TypeError} first argument must be an ndarray-like object
 * @throws {TypeError} third argument must be either an ndarray-like object or an integer
-* @throws {TypeError} fourth argument must be an ndarray-like object
+* @throws {TypeError} output argument must be an ndarray-like object
 * @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 dimension index must not exceed input ndarray bounds
+* @throws {RangeError} first argument must have at least one dimension
 * @throws {Error} must provide valid options
 * @returns {ndarray} output ndarray
 *
 * @example
 * var Float64Array = require( '@stdlib/array/float64' );
 * var zeros = require( '@stdlib/ndarray/zeros' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
 * var ndarray = require( '@stdlib/ndarray/ctor' );
 *
 * // Create data buffers:
 * var xbuf = new Float64Array( [ 1.0, 2.0, -3.0, 4.0, -5.0, 6.0 ] );
 *
 * // Define the shape of the input array:
-* var shape = [ 3, 1, 2 ];
+* var shape = [ 2, 3 ];
 *
 * // Define the array strides:
-* var strides = [ 2, 2, 1 ];
+* var strides = [ 3, 1 ];
 *
 * // Define the index offset:
 * var offset = 0;
@@ -85,91 +83,138 @@ var DEFAULT_DTYPE = defaults.get( 'dtypes.integer_index' );
 * var x = new ndarray( 'float64', xbuf, shape, strides, offset, 'row-major' );
 *
 * // Create an output ndarray:
-* var y = zeros( [], {
+* var y = zeros( [ 2 ], {
 *     'dtype': 'int32'
 * });
 *
 * // Perform operation:
-* var out = assign( x, 4.0, y );
+* var out = assign( x, -5.0, y );
 * // returns <ndarray>
 *
 * var bool = ( out === y );
 * // returns true
 *
-* var idx = out.get();
-* // returns 3
+* var arr = ndarray2array( out );
+* // returns [ -1, 1 ]
 */
-function assign( x, searchElement, fromIndex, out, options ) {
+function assign( x, searchElement, fromIndex, out ) {
+	var hasOptions;
+	var options;
 	var nargs;
 	var opts;
+	var fidx;
+	var iflg;
 	var ord;
 	var dt;
 	var sh;
+	var v;
+	var o;
 
 	nargs = arguments.length;
-	if ( nargs < 3 ) {
-		throw new TypeError( format( 'invalid argument. The function must be provided at least three arguments. Value: `%s`.', nargs ) );
-	}
-
 	if ( !isndarrayLike( x ) ) {
-		throw new TypeError( format( 'invalid argument. The first argument must be an ndarray-like object. Value: `%s`.', x ) );
+		throw new TypeError( format( 'invalid argument. The first argument must be an ndarray. Value: `%s`.', x ) );
+	}
+	if ( nargs < 2 ) {
+		throw new TypeError( format( 'invalid argument. Second argument must be either an ndarray or a scalar value. Value: `%s`.', searchElement ) );
+	}
+	if ( nargs < 3 ) {
+		throw new TypeError( format( 'invalid argument. Third argument must be an ndarray. Value: `%s`.', fromIndex ) );
 	}
-
 	// Resolve input ndarray meta data:
 	dt = getDType( x );
 	ord = getOrder( x );
 
-	// Initialize options object:
-	opts = {};
+	// Initialize an options object:
+	opts = {
+		'dims': [ -1 ] // default behavior is to perform a reduction over the last dimension
+	};
+
+	// 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: assign( x, searchElement, out )
+	// Case: assign( x, search_element, out )
 	if ( nargs === 3 ) {
-		out = fromIndex;
-		fromIndex = 0;
+		o = fromIndex;
 	}
-	// Case: assign( x, searchElement, out, options )
-	else if (
-		nargs === 4 &&
-		isndarrayLike( fromIndex ) &&
-		!isndarrayLike( out ) &&
-		isObject( out )
-	) {
-		opts = objectAssign( opts, out );
-		out = fromIndex;
-		fromIndex = 0;
+	// Case: assign( x, search_element, ???, ??? )
+	else if ( nargs === 4 ) {
+		// Case: assign( x, search_element, from_index, out )
+		if ( isndarrayLike( out ) ) {
+			o = out;
+
+			// Case: assign( x, search_element, from_index_scalar, out )
+			if ( isInteger( fromIndex ) ) {
+				fidx = fromIndex;
+			}
+			// Case: assign( x, search_element, from_index_ndarray, out )
+			else if ( isndarrayLike( fromIndex ) ) {
+				fidx = fromIndex;
+				iflg = false;
+			}
+			// Case: assign( x, search_element, ???, out )
+			else {
+				throw new TypeError( format( 'invalid argument. Third argument must be either an ndarray or an integer. Value: `%s`.', fromIndex ) );
+			}
+		}
+		// Case: assign( x, search_element, out, options )
+		else {
+			o = fromIndex;
+			options = out;
+			hasOptions = true;
+		}
 	}
-	// Case: assign( x, searchElement, fromIndex, out, options )
-	else if ( nargs === 5 ) {
-		if ( !isObject( options ) ) {
-			throw new TypeError( format( 'invalid argument. The fifth argument must be an object. Value: `%s`.', options ) );
+	// Case: assign( x, search_element, from_index, out, options )
+	else { // nargs > 4
+		// Case: assign( x, search_element, from_index_scalar, out, options )
+		if ( isInteger( fromIndex ) ) {
+			fidx = fromIndex;
+		}
+		// Case: assign( x, search_element, from_index_ndarray, out, options )
+		else if ( isndarrayLike( fromIndex ) ) {
+			fidx = fromIndex;
+			iflg = false;
 		}
-		opts = objectAssign( opts, options );
+		// Case: assign( x, search_element, ???, out, options )
+		else {
+			throw new TypeError( format( 'invalid argument. Third argument must be either an ndarray or an integer. Value: `%s`.', fromIndex ) );
+		}
+		o = out;
+		options = arguments[ 4 ];
+		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;
+	}
+	// Resolve the list of non-reduced dimensions:
+	sh = getShape( x );
+	if ( sh.length < 1 ) {
+		throw new RangeError( 'invalid argument. First argument must have at least one dimension.' );
 	}
+	sh = nonCoreShape( sh, opts.dims );
 
-	// Normalize search element:
+	// 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 ); // WARNING: potential for undesired value casting (e.g., if `searchElement` is `null` and cast to `float64`, the broadcasted scalar will be `0`, not `null`!)
 	}
-
-	// Normalize from index:
-	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, out, opts );
+	return base( x, v, fidx, o, opts );
 }
 
 
diff --git a/lib/node_modules/@stdlib/blas/ext/index-of/lib/main.js b/lib/node_modules/@stdlib/blas/ext/index-of/lib/main.js
@@ -45,8 +45,6 @@ var DEFAULT_DTYPE = defaults.get( 'dtypes.integer_index' );
 /**
 * 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
@@ -59,6 +57,7 @@ var DEFAULT_DTYPE = defaults.get( 'dtypes.integer_index' );
 * @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 index must not exceed input ndarray bounds
+* @throws {RangeError} first argument must have at least one dimension
 * @throws {Error} must provide valid options
 * @returns {ndarray} output ndarray
 *
@@ -102,17 +101,16 @@ function indexOf( x, searchElement, fromIndex ) {
 	var v;
 
 	nargs = arguments.length;
-
 	if ( !isndarrayLike( x ) ) {
 		throw new TypeError( format( 'invalid argument. First argument must be an ndarray. Value: `%s`.', x ) );
 	}
+	if ( nargs < 2 ) {
+		throw new TypeError( format( 'invalid argument. Second argument must be either an ndarray or a scalar value. Value: `%s`.', searchElement ) );
+	}
 	// Resolve input ndarray meta data:
 	dt = getDType( x );
 	ord = getOrder( x );
 
-	if ( nargs < 2 ) {
-		throw new TypeError( format( 'invalid argument. Second argument must be either an ndarray or a scalar value. Value: `%s`.', searchElement ) );
-	}
 	// Initialize an options object:
 	opts = {
 		'dims': [ -1 ], // default behavior is to perform a reduction over the last dimension
@@ -154,6 +152,7 @@ function indexOf( x, searchElement, fromIndex ) {
 		// Case: indexOf( x, search_element, from_index_ndarray, options )
 		else if ( isndarrayLike( fromIndex ) ) {
 			fidx = fromIndex;
+			iflg = false;
 		}
 		// Case: indexOf( x, search_element, ???, options )
 		else {
@@ -173,13 +172,17 @@ function indexOf( x, searchElement, fromIndex ) {
 		opts.keepdims = options.keepdims;
 	}
 	// Resolve the list of non-reduced dimensions:
-	sh = nonCoreShape( getShape( x ), opts.dims );
+	sh = getShape( x );
+	if ( sh.length < 1 ) {
+		throw new RangeError( 'invalid argument. First argument must have at least one dimension.' );
+	}
+	sh = nonCoreShape( sh, opts.dims );
 
 	// Broadcast the search element to match the shape of the non-reduced dimensions...
 	if ( isndarrayLike( searchElement ) ) {
 		v = maybeBroadcastArray( searchElement, sh );
 	} else {
-		v = broadcastScalar( searchElement, dt, sh, ord );
+		v = broadcastScalar( searchElement, dt, sh, ord ); // WARNING: potential for undesired value casting (e.g., if `searchElement` is `null` and cast to `float64`, the broadcasted scalar will be `0`, not `null`!)
 	}
 	// Broadcast the `fromIndex` to match the shape of the non-reduced dimensions...
 	if ( iflg ) {
