mlpy.auxiliary.array.accum(accmap, a, func=None, size=None, fill_value=0, dtype=None)[source]

An accumulation function similar to Matlab’s accumarray function.


accmap : array_like

This is the “accumulation map”. It maps input (i.e. indices into a) to their destination in the output array. The first a.ndim dimensions of accmap must be the same as a.shape. That is, accmap.shape[:a.ndim] must equal a.shape. For example, if a has shape (15,4), then accmap.shape[:2] must equal (15,4). In this case accmap[i,j] gives the index into the output array where element (i,j) of a is to be accumulated. If the output is, say, a 2D, then accmap must have shape (15,4,2). The value in the last dimension give indices into the output array. If the output is 1D, then the shape of accmap can be either (15,4) or (15,4,1)

a : array_like or float or int

The input data to be accumulated.

func : callable or None

The accumulation function. The function will be passed a list of values from a to be accumulated. If None, numpy.sum is assumed.

size : array_like or tuple

The size of the output array. If None, the size will be determined from accmap.

fill_value : scalar

The default value for elements of the output array.

dtype : dtype

The data type of the output array. If None, the data type of a is used.


array_like :

The accumulated results.

The shape of out is size if size is given. Otherwise the shape is determined by the (lexicographically) largest indices of the output found in accmap.


>>> from numpy import array, prod, float64
>>> a = array([[1,2,3],[4,-1,6],[-1,8,9]])
>>> a
array([[ 1,  2,  3],
       [ 4, -1,  6],
       [-1,  8,  9]])

Sum the diagonals:

>>> accmap = array([[0,1,2],[2,0,1],[1,2,0]])
>>> s = accum(accmap, a)
array([9, 7, 15])

A 2D output, from sub-arrays with shapes and positions like this:

[ (2,2) (2,1)]
[ (1,2) (1,1)]
>>> accmap = array([
...     [[0,0],[0,0],[0,1]],
...     [[0,0],[0,0],[0,1]],
...     [[1,0],[1,0],[1,1]],
... ])

Accumulate using a product:

>>> accum(accmap, a, func=prod, dtype=float64)
array([[ -8.,  18.],
       [ -8.,   9.]])

Same accmap, but create an array of lists of values:

>>> accum(accmap, a, func=lambda x: x, dtype='O')
array([[[1, 2, 4, -1], [3, 6]],
       [[-1, 8], [9]]], dtype=object)


Adapted from

Project: Code from SciPy Cookbook.
Code author: Warren Weckesser
License: CC-Wiki