refactor: update implementation and clean-up

---
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: passed
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: passed
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - 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: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---

Author: kgryte

lib/node_modules/@stdlib/stats/base/ndarray/max-by/README.md

@@ -60,11 +60,10 @@ The function has the following parameters:
 -   **clbk**: callback function.
 -   **thisArg**: callback execution context (_optional_).
 
-The invoked callback is provided four arguments:
+The invoked callback is provided three arguments:
 
--   **value**: array element.
--   **aidx**: array index.
--   **sidx**: strided index (`offset + aidx*stride`).
+-   **value**: current array element.
+-   **idx**: current array element index.
 -   **array**: input ndarray.
 
 To set the callback execution context, provide a `thisArg`.
@@ -99,6 +98,8 @@ var count = ctx.count;
 ## Notes
 
 -   If provided an empty one-dimensional ndarray, the function returns `NaN`.
+-   A provided callback function should return a numeric value.
+-   If a provided callback function does not return any value (or equivalently, explicitly returns `undefined`), the value is **ignored**.
 
 </section>
 

lib/node_modules/@stdlib/stats/base/ndarray/max-by/docs/repl.txt

@@ -5,6 +5,17 @@
 
     If provided an empty ndarray, the function returns `NaN`.
 
+    The callback function is provided three arguments:
+
+    - value: current array element.
+    - index: current array index.
+    - array: the input ndarray.
+
+    The callback function should return a numeric value.
+
+    If the callback function does not return any value (or equivalently,
+    explicitly returns `undefined`), the value is ignored.
+
     Parameters
     ----------
     arrays: ArrayLikeObject<ndarray>

lib/node_modules/@stdlib/stats/base/ndarray/max-by/docs/types/index.d.ts

@@ -20,63 +20,51 @@
 
 /// <reference types="@stdlib/types"/>
 
-import { ndarray, typedndarray } from '@stdlib/types/ndarray';
+import { typedndarray } from '@stdlib/types/ndarray';
 
 /**
 * Returns the result of callback function.
 *
 * @returns result
 */
-type Nullary<U> = ( this: U ) => number | void;
+type Nullary<ThisArg> = ( this: ThisArg ) => number | void;
 
 /**
 * Returns the result of callback function.
 *
-* @param value - array element
+* @param value - current array element
 * @returns result
 */
-type Unary<T, U> = ( this: U, value: T ) => number | void;
+type Unary<T, ThisArg> = ( this: ThisArg, value: T ) => number | void;
 
 /**
 * Returns the result of callback function.
 *
-* @param value - array element
-* @param aidx - array index
+* @param value - current array element
+* @param index - current array element index
 * @returns result
 */
-type Binary<T, U> = ( this: U, value: T, aidx: number ) => number | void;
+type Binary<T, ThisArg> = ( this: ThisArg, value: T, index: number ) => number | void;
 
 /**
 * Returns the result of callback function.
 *
-* @param value - array element
-* @param aidx - array index
-* @param sidx - strided index (offset + aidx*stride)
-* @returns result
-*/
-type Ternary<T, U> = ( this: U, value: T, aidx: number, sidx: number ) => number | void;
-
-/**
-* Returns the result of callback function.
-*
-* @param value - array element
-* @param aidx - array index
-* @param sidx - strided index (offset + aidx*stride)
+* @param value - current array element
+* @param index - current array element index
 * @param array - input ndarray
 * @returns result
 */
-type Quaternary<T, U> = ( this: U, value: T, aidx: number, sidx: number, array: typedndarray<T> ) => number | void;
+type Ternary<T, U, ThisArg> = ( this: ThisArg, value: T, index: number, array: U ) => number | void;
 
 /**
 * Returns the result of callback function.
 *
-* @param value - array element
-* @param aidx - array index
-* @param sidx - strided index (offset + aidx*stride)
+* @param value - current array element
+* @param index - current array element index
 * @param array - input ndarray
 * @returns result
 */
-type Callback<T, U> = Nullary<U> | Unary<T, U> | Binary<T, U> | Ternary<T, U> | Quaternary<T, U>;
+type Callback<T, U, ThisArg> = Nullary<ThisArg> | Unary<T, ThisArg> | Binary<T, ThisArg> | Ternary<T, U, ThisArg>;
 
 /**
 * Computes the maximum value of a one-dimensional ndarray via a callback function.
@@ -99,7 +87,7 @@ type Callback<T, U> = Nullary<U> | Unary<T, U> | Binary<T, U> | Ternary<T, U> |
 * var v = maxBy( [ x ], clbk );
 * // returns 8.0
 */
-declare function maxBy<T = unknown, U = unknown, V extends ndarray = ndarray>( arrays: [ V ], clbk: Callback<T, U>, thisArg?: ThisParameterType<Callback<T, U>> ): number;
+declare function maxBy<T = unknown, U extends typedndarray<T> = typedndarray<T>, ThisArg = unknown>( arrays: [ U ], clbk: Callback<T, U, ThisArg>, thisArg?: ThisParameterType<Callback<T, U, ThisArg>> ): number;
 
 
 // EXPORTS //

lib/node_modules/@stdlib/stats/base/ndarray/max-by/lib/main.js

@@ -52,7 +52,21 @@ var strided = require( '@stdlib/stats/base/max-by' ).ndarray;
 */
 function maxBy( arrays, clbk, thisArg ) {
 	var x = arrays[ 0 ];
-	return strided( numelDimension( x, 0 ), getData( x ), getStride( x, 0 ), getOffset( x ), clbk, thisArg ); // eslint-disable-line max-len
+	return strided( numelDimension( x, 0 ), getData( x ), getStride( x, 0 ), getOffset( x ), wrapper, null ); // eslint-disable-line max-len
+
+	/**
+	* Invokes a provided callback.
+	*
+	* @private
+	* @param {*} value - current array element
+	* @param {NonNegativeInteger} aidx - current array element index
+	* @param {NonNegativeInteger} sidx - current strided array element index
+	* @param {Collection} arr - input array
+	* @returns {*} result
+	*/
+	function wrapper( value, aidx ) {
+		return clbk.call( thisArg, value, aidx, x );
+	}
 }
 
 

lib/node_modules/@stdlib/stats/base/ndarray/max-by/test/test.js

@@ -180,7 +180,12 @@ tape( 'the function supports one-dimensional ndarrays having non-zero offsets',
 });
 
 tape( 'the function supports providing an execution context', function test( t ) {
+	var expected;
+	var indices;
+	var values;
+	var arrays;
 	var ctx;
+	var arr;
 	var x;
 	var v;
 
@@ -198,14 +203,47 @@ tape( 'the function supports providing an execution context', function test( t )
 		'count': 0
 	};
 
-	v = maxBy( [ vector( x, 4, 2, 0 ) ], clbk, ctx );
+	indices = [];
+	values = [];
+	arrays = [];
+
+	arr = vector( x, 4, 2, 0 );
+	v = maxBy( [ arr ], clbk, ctx );
 
 	t.strictEqual( v, 8.0, 'returns expected value' );
 	t.strictEqual( ctx.count, 4, 'returns expected value' );
+
+	expected = [
+		1.0,
+		2.0,
+		-2.0,
+		4.0
+	];
+	t.deepEqual( values, expected, 'returns expected value' );
+
+	expected = [
+		0,
+		1,
+		2,
+		3
+	];
+	t.deepEqual( indices, expected, 'returns expected value' );
+
+	expected = [
+		arr,
+		arr,
+		arr,
+		arr
+	];
+	t.deepEqual( arrays, expected, 'returns expected value' );
+
 	t.end();
 
-	function clbk( v ) {
+	function clbk( v, idx, arr ) {
 		this.count += 1; // eslint-disable-line no-invalid-this
+		values.push( v );
+		indices.push( idx );
+		arrays.push( arr );
 		return v * 2.0;
 	}
 });