nlcpy.ufunc.reduceat

ufunc.reduceat(self, array, indices, axis=0, dtype=None, out=None)

Performs a (local) reduce with specified slices over a single axis.

For i in range(len(indices)), reduceat computes ufunc.reduce(a[indices[i]:indices[i+1]]), which becomes the i-th generalized “row” parallel to axis in the final result (i.e., in a 2-D array, for example, axis = 0, it becomes the i-th row, but if axis = 1, it becomes the i-th column). There are three exceptions to this:

  • when i = len(indices) - 1 (so for the last index), indices[i+1] = a.shape[axis].

  • if indices[i] >= indices[i + 1], the i-th generalized “row” is simply a[indices[i]].

  • if indices[i] >= len(a) or indices[i] < 0 , an error is raised. The shape of the output depends on the size of indices, and may be larger than a (this happens if len(indices) > a.shape[axis]).

Parameters
arrayarray_like

The array to act on.

indicesarray_like

Paired indices, comma separated (not colon), specifying slices to reduce.

axisint, optional

The axis along which to apply the reduceat.

dtypedtype, optional

The type used to represent the intermediate results. Defaults to the data type of the output array if this is provided, or the data type of the input array if no output array is provided.

outndarray, None, or tuple of ndarray and None, optional

A location into which the result is stored. If not provided or None, a freshly-allocated array is returned.

Returns
rndarray

The reduced array. If out was supplied, r is a reference to out.

Note

A descriptive example:

If a is 1-D, the function ufunc.accumulate(a) is the same as ufunc.reduceat(a, indices)[::2] where indices is range(len(array) - 1) with a zero placed in every other element: indices = zeros(2 * len(a) - 1), indices[1::2] = range(1, len(a)).

Don’t be fooled by this attribute’s name: reduceat(a) is not necessarily smaller than a.

Restriction

  • If a list is passed to the parameter a of power.reduceat(), there are cases where ValueError occurs.

Examples

To take the running sum of four successive values:

>>> import nlcpy as vp
>>> vp.add.reduceat(vp.arange(8),[0,4, 1,5, 2,6, 3,7])[::2]
array([ 6, 10, 14, 18])

A 2-D example:

>>> x = vp.linspace(0, 15, 16).reshape(4,4)
>>> x    
array([[ 0.,  1.,  2.,  3.],
       [ 4.,  5.,  6.,  7.],
       [ 8.,  9., 10., 11.],
       [12., 13., 14., 15.]])
# reduce such that the result has the following five rows:
# [row1 + row2 + row3]
# [row4]
# [row2]
# [row3]
# [row1 + row2 + row3 + row4]
>>> vp.add.reduceat(x, [0, 3, 1, 2, 0])   
array([[12., 15., 18., 21.],
       [12., 13., 14., 15.],
       [ 4.,  5.,  6.,  7.],
       [ 8.,  9., 10., 11.],
       [24., 28., 32., 36.]])
# reduce such that result has the following two columns:
# [col1 * col2 * col3, col4]
>>> vp.multiply.reduceat(x, [0, 3], 1)  
array([[   0.,    3.],
       [ 120.,    7.],
       [ 720.,   11.],
       [2184.,   15.]])