feat: add reduce method to array/complex64

lib/node_modules/@stdlib/array/complex64/docs/types/index.d.ts

@@ -195,6 +195,60 @@ type TernaryMapFcn<U> = ( this: U, value: Complex64, index: number, arr: Complex
 */
 type MapFcn<U> = NullaryMapFcn<U> | UnaryMapFcn<U> | BinaryMapFcn<U> | TernaryMapFcn<U>;
 
+/**
+* Reducer function invoked for each element in an array.
+*
+* @returns accumulated result
+*/
+type NullaryReducer<U, V> = ( this: U ) => V;
+
+/**
+* Reducer function invoked for each element in an array.
+*
+* @param acc - accumulated result
+* @returns accumulated result
+*/
+type UnaryReducer<U, V> = ( this: U, acc: V ) => V;
+
+/**
+* Reducer function invoked for each element in an array.
+*
+* @param acc - accumulated result
+* @param value - current array element
+* @returns accumulated result
+*/
+type BinaryReducer<U, V> = ( this: U, acc: V, value: Complex64 ) => V;
+
+/**
+* Reducer function invoked for each element in an array.
+*
+* @param acc - accumulated result
+* @param value - current array element
+* @param index - current array element index
+* @returns accumulated result
+*/
+type TernaryReducer<U, V> = ( this: U, acc: V, value: Complex64, index: number ) => V;
+
+/**
+* @param acc - accumulated result
+* @param value - current array element
+* @param index - current array element index
+* @param arr - array on which the method was called
+* @returns accumulated result
+*/
+type QuaternaryReducer<U, V> = ( this: U, acc: V, value: Complex64, index: number, arr: Complex64Array ) => V;
+
+/**
+* Reducer function invoked for each element in an array.
+*
+* @param acc - accumulated result
+* @param value - current array element
+* @param index - current array element index
+* @param arr - array on which the method was called
+* @returns accumulated result
+*/
+type Reducer = NullaryReducer<U, V> | UnaryReducer<U, V> | BinaryReducer<U, V> | TernaryReducer<U, V> | QuaternaryReducer<U, V>;
+
 /**
 * Class for creating a 64-bit complex number array.
 */
@@ -813,6 +867,36 @@ declare class Complex64Array implements Complex64ArrayInterface {
 	*/
 	map<U = unknown>( fcn: MapFcn<U>, thisArg?: ThisParameterType<MapFcn<U>> ): Complex64Array;
 
+	/**
+	* Applies a provided callback function on each element of the array, in order, passing in the return value from the calculation on the preceding element and returning the accumulated result upon completion.
+	*
+	* @param reducer - callback function
+	* @param initialValue - initial value
+	* @returns accumulated result
+	*
+	* @example
+	* var realf = require( '@stdlib/complex/realf' );
+	* var imagf = require( '@stdlib/complex/imagf' );
+	* var caddf = require( '@stdlib/math/base/ops/caddf' );
+	* var Complex64 = require( '@stdlib/complex/float32' );
+	*
+	* var arr = new Complex64Array( 3 );
+	*
+	* arr.set( [ 1.0, 1.0 ], 0 );
+	* arr.set( [ 2.0, 2.0 ], 1 );
+	* arr.set( [ 3.0, 3.0 ], 2 );
+	*
+	* var z = arr.reduce( caddf );
+	* // returns <Complex64>
+	*
+	* var re = realf( z );
+	* // returns 6.0
+	*
+	* var im = imagf( z );
+	* // returns 6.0
+	*/
+	reduce<U = unknown, V = unknown>( reducer: Reducer<U, V>, initialValue?: V ): V;
+
 	/**
 	* Reverses an array in-place.
 	*

lib/node_modules/@stdlib/array/complex64/lib/main.js

@@ -1699,6 +1699,71 @@ setReadOnly( Complex64Array.prototype, 'map', function map( fcn, thisArg ) {
 	return out;
 });
 
+/**
+* Returns value that results from running the reducer callback function to completion over the entire typed array.
+*
+* @name reduce
+* @memberof Complex64Array.prototype
+* @type {Function}
+* @param {Function} reducer - callback function
+* @param {*} [initialValue] - initial value
+* @throws {TypeError} `this` must be a complex number array
+* @throws {TypeError} first argument must be a function
+* @returns {*} accumulated result
+*
+* @example
+* var realf = require( '@stdlib/complex/realf' );
+* var imagf = require( '@stdlib/complex/imagf' );
+* var caddf = require( '@stdlib/math/base/ops/caddf' );
+* var Complex64 = require( '@stdlib/complex/float32' );
+*
+* var arr = new Complex64Array( 3 );
+*
+* arr.set( [ 1.0, 1.0 ], 0 );
+* arr.set( [ 2.0, 2.0 ], 1 );
+* arr.set( [ 3.0, 3.0 ], 2 );
+*
+* var z = arr.reduce( caddf );
+* // returns <Complex64>
+*
+* var re = realf( z );
+* // returns 6.0
+*
+* var im = imagf( z );
+* // returns 6.0
+*/
+setReadOnly( Complex64Array.prototype, 'reduce', function reduce( reducer, initialValue ) {
+	var buf;
+	var acc;
+	var len;
+	var v;
+	var i;
+
+	if ( !isComplexArray( this ) ) {
+		throw new TypeError( 'invalid invocation. `this` is not a complex number array.' );
+	}
+	if ( !isFunction( reducer ) ) {
+		throw new TypeError( format( 'invalid argument. First argument must be a function. Value: `%s`.', reducer ) );
+	}
+	buf = this._buffer;
+	len = this._length;
+	if ( arguments.length > 1 ) {
+		i = 0;
+		acc = initialValue;
+	} else {
+		if ( len === 0 ) {
+			throw new TypeError( 'invalid argument. If not provided an initial value, input array must contain at least one element.' );
+		}
+		acc = getComplex64( buf, 0 );
+		i = 1;
+	}
+	for ( ; i < len; i++ ) {
+		v = getComplex64( buf, i );
+		acc = reducer( acc, v, i, this );
+	}
+	return acc;
+});
+
 /**
 * Reverses an array in-place.
 *