Reductions

Reduction operations take one or more distributed arrays as input. They combine the elements to produce one or more scalar values, or arrays of lower rank. Adlib provides a large set of reduction operations, supporting the many kinds of reduction available as ``intrinsic functions'' in Fortran. Here we mention only a few of the simplest reductions. One difference between reduction operations and other collective operations is reduction operations do not support Java Object type.

The maxval() operation simply returns the maximum of all elements of an array. It has prototypes

where $t$ now runs over all Java numeric types--that is, all Java primitive types except boolean. The result is broadcast to the active process group, and returned by the function. Other reduction operations with similar interfaces are minval(), sum() and product(). Of these minval() is minimum value, sum() adds the elements of a in an unspecified order, and product() multiplies them.

The boolean reductions:

behave in a similar way. The method any() returns true if any element of a is true. The method all() returns true if all elements of a are true. The method count() returns a count of the number of true elements in a.

The method dotProduct() is also logically a reduction, but it takes two one-dimensional arrays as arguments and returns their scalar product--the sum of pairwise products of elements. The situation with element types is complicated because the types of the two arguments needn't be identical. If they are different, standard Java binary numeric promotions are applied--for example if the dot product of an int array with a float array is a float value. The prototypes are

and

If either of $t_1$ or $t_2$ is a floating point type (float or double) the result type, $t_3$, is double). Otherwise the result type $t_3$ is long. The argument multiarrays must have the same shape and must be aligned. The result is broadcast to all members of the active process group. The second form takes boolean as the arguments and returns the logical ``or'' of all the pairwise logical ``ands'' of elements.

The methods maxloc() and minloc() return respectively the maximum and minimum values of all elements of an array--similar to maxval() and minval()--but also output the index tuple in the array at which the extreme value was found. The prototypical forms are:

where loc is an ordinary Java array of length $R$, the rank of a. On exit it contains the (broadcast) global subscripts of the extreme value.

For each of the simple reductions that combine all elements of an array into a single value, there is a corresponding ``dimensional reduction'', which just reduces along a selected dimension of the input array, and outputs an array of values of rank one less than the input. The method maxvalDim(), for example, has the form:

The dimension argument takes a value, $d$, in the range $0, \ldots, R - 1$ where $R$ is the rank of a. The result array, res, must have rank $R - 1$. It must be aligned with the input array a, with replicated alignment in the $d$th dimension of a. In other words, the distribution groups of a and res must be the same, and

$$\begin{minipage}[t]{\linewidth}\small\begin{tabbing} \verb$ res.rng($$i$\verb$).isAligned(a.rng($$i$\verb$))$ \end{tabbing}\end{minipage}$$

for $i < d$, and

$$\begin{minipage}[t]{\linewidth}\small\begin{tabbing} \verb$ res.rng($$i$\verb$).isAligned(a.rng($$i + 1$\verb$))$ \end{tabbing}\end{minipage}$$

for $d \le i < R - 1$. The reductions minvalDim(), sumDim(), productDim(), anyDim(), allDim(), countDim() are defined in a similar way. The maxloc() and minloc() reductions have ``dimensional'' forms:

where the array loc has the same rank and alignment as res (since the reduction is in a single dimension, only one index value--for the specified dimension--needs to be returned per extreme value). Currently there is no ``Dim'' form of dotProduct().

Finally all the numeric simple reductions and dimensional reductions all have ``masked'' variants. These take an extra boolean array aligned with the source array. For example

ignores all elements of a for which the corresponding element of mask is false.

One omission in the current version of the library is a facility for user-defined reduction operations. It also omits various arithmetic reductions that might seem natural in Java, such as bitwise, and, or, and xor. There is no fundamental reason for these omissions, and this might change in future releases.