mapReduceRight

Perform a single-pass map-reduce operation against each element in an array while iterating from right to left and return the accumulated result.

Usage

var mapReduceRight = require( '@stdlib/utils/map-reduce-right' );

mapReduceRight( arr, initial, mapper, reducer[, thisArg ] )

Performs a map-reduce operation against each element in an array while iterating from right to left and returns the accumulated result.

function square( value ) {
    return value * value;
}

function sum( accumulator, value ) {
    return accumulator + value;
}

var arr = [ 1, 2, 3, 4 ];

var out = mapReduceRight( arr, 0, square, sum );
// returns 30

The function accepts both array-like objects and ndarray-like objects.

var array = require( '@stdlib/ndarray/array' );

function square( value ) {
    return value * value;
}

function sum( accumulator, value ) {
    return accumulator + value;
}

var opts = {
    'dtype': 'generic'
};
var arr = array( [ [ 1, 2, 3 ], [ 4, 5, 6 ] ], opts );

var out = mapReduceRight( arr, 0, square, sum );
// returns 91

The mapping function is provided the following arguments:

  • value: array element.
  • index: element index.
  • arr: input array.

The reducing function is provided the following arguments:

  • accumulator: accumulated value.
  • value: result of applying the mapping function to the current array element.
  • index: element index.
  • arr: input array.

To set the this context when invoking the reducing function, provide a thisArg.

function square( value ) {
    return value * value;
}

function sum( accumulator, value ) {
    this.count += 1;
    return accumulator + value;
}

var arr = [ 1, 2, 3, 4 ];

var ctx = {
    'count': 0
};

var out = mapReduceRight( arr, 0, square, sum, ctx );
// returns 30

var mean = out / ctx.count;
// returns 7.5

Notes

  • The function supports array-like objects exposing getters and setters for array element access (e.g., Complex64Array, Complex128Array, etc).

    var Complex64Array = require( '@stdlib/array/complex64' );
var Complex64 = require( '@stdlib/complex/float32/ctor' );
var cceil = require( '@stdlib/math/base/special/cceil' );
var realf = require( '@stdlib/complex/float32/real' );
var imagf = require( '@stdlib/complex/float32/imag' );

function sum( acc, z ) {
    var re1 = realf( acc );
    var im1 = imagf( acc );
    var re2 = realf( z );
    var im2 = imagf( z );
    return new Complex64( re1+re2, im1+im2 );
}

var x = new Complex64Array( [ 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5 ] );

var v = mapReduceRight( x, new Complex64( 0.0, 0.0 ), cceil, sum );
// returns <Complex64>

var re = realf( v );
// returns 20.0

var im = imagf( v );
// returns 24.0

  • For ndarray-like objects, the function performs a single-pass map-reduce operation over the entire input ndarray (i.e., higher-order ndarray dimensions are flattened to a single-dimension).

  • When applying a function to ndarray-like objects, performance will be best for ndarray-like objects which are single-segment contiguous.

Examples

var filledarrayBy = require( '@stdlib/array/filled-by' );
var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ).factory;
var naryFunction = require( '@stdlib/utils/nary-function' );
var add = require( '@stdlib/math/base/ops/add' );
var abs = require( '@stdlib/math/base/special/abs' );
var array = require( '@stdlib/ndarray/array' );
var mapReduceRight = require( '@stdlib/utils/map-reduce-right' );

function fill( i ) {
    var rand = discreteUniform( -10*(i+1), 10*(i+1) );
    return filledarrayBy( 10, 'generic', rand );
}

// Create a two-dimensional ndarray (i.e., a matrix):
var x = array( filledarrayBy( 10, 'generic', fill ), {
    'dtype': 'generic',
    'flatten': true
});

// Create an explicit unary function:
var f1 = naryFunction( abs, 1 );

// Create an explicit binary function:
var f2 = naryFunction( add, 2 );

// Compute the sum of absolute values:
var out = mapReduceRight( x, 0, f1, f2 );

console.log( 'x:' );
console.log( x.data );

console.log( 'sum: %d', out );

See Also

  • @stdlib/utils/map-right: apply a function to each element in an array and assign the result to an element in an output array, iterating from right to left.
  • @stdlib/utils/map-reduce: perform a single-pass map-reduce operation against each element in an array and return the accumulated result.
  • @stdlib/utils/reduce-right: apply a function against an accumulator and each element in an array while iterating from right to left and return the accumulated result.
Did you find this page helpful?