Array Prefix and Suffix Functions

Next: Array Sorting Functions Up: Library Procedures Previous: Array Combining Scatter Functions

Array Prefix and Suffix Functions

In a scan of a vector, each element of the result is a function of the elements of the vector that precede it (for a prefix scan) or that follow it (for a suffix scan). These functions provide scan operations on arrays and subarrays. The functions have the general form

XXX_PREFIX(ARRAY, DIM, MASK, SEGMENT, EXCLUSIVE)
XXX_SUFFIX(ARRAY, DIM, MASK, SEGMENT, EXCLUSIVE)

except in the special cases noted below. The allowed values of XXX are ALL, ANY, COPY, COUNT, IALL, IANY, IPARITY, MAXVAL, MINVAL, PARITY, PRODUCT, and SUM.

When comments below apply to both prefix and suffix forms of the routines, we will refer to them as YYYFIX functions.

The arguments DIM, MASK, SEGMENT, and EXCLUSIVE are optional. The COPY_YYYFIX functions do not have MASK or EXCLUSIVE arguments. The ALL_YYYFIX, ANY_YYYFIX, COUNT_YYYFIX, and PARITY_YYYFIX functions do not have MASK arguments. Their ARRAY argument must be of type logical; it is denoted MASK in their specifications in Section 7.7.

The arguments MASK and SEGMENT must be of type logical. SEGMENT must have the same shape as ARRAY. MASK must be conformable with ARRAY. EXCLUSIVE is a logical scalar. DIM is a scalar integer between one and the rank of ARRAY.

Result Value. The result has the same shape as ARRAY, and, with the exception of COUNT_YYYFIX, the same type and kind type parameter as ARRAY. (The result of COUNT_YYYFIX is default integer.)

In every case, every element of the result is determined by the values of certain selected elements of ARRAY in a way that is specific to the particular function and is described in its specification. The optional arguments affect the selection of elements of ARRAY for each element of the result; the selected elements of ARRAY are said to contribute to the result element. This section describes fully which elements of ARRAY contribute to a given element of the result.

If no elements of ARRAY are selected for a given element of the result, that result element is set to a default value that is specific to the particular function and is described in its specification.

For any given element r of the result, let a be the corresponding element of ARRAY. Every element of ARRAY contributes to r unless disqualified by one of the following rules.

If the function is XXX_PREFIX, no element that follows in the array element ordering of ARRAY contributes to r. If the function is XXX_SUFFIX, no element that precedes a in the array element ordering of ARRAY contributes to r.
If the DIM argument is provided, an element z of ARRAY does not contribute to r unless all its indices, excepting only the index for dimension DIM, are the same as the corresponding indices of a. (It follows that if the DIM argument is omitted, then ARRAY, MASK, and SEGMENT are processed in array element order, as if temporarily regarded as rank-one arrays. If the DIM argument is present, then a family of completely independent scan operations are carried out along the selected dimension of ARRAY.)
If the MASK argument is provided, an element z of ARRAY contributes to r only if the element of MASK corresponding to z is true. (It follows that array elements corresponding to positions where the MASK is false do not contribute anywhere to the result. However, the result is nevertheless defined at all positions, even positions where the MASK is false.)
If the SEGMENT argument is provided, an element z of ARRAY does not contribute if there is some intermediate element w of ARRAY, possibly z itself, with all of the following properties:
1. If the function is XXX_PREFIX, w does not precede z but does precede a in the array element ordering; if the function is XXX_SUFFIX, w does not follow z but does follow a in the array element ordering;
2. If the DIM argument is present, all the indices of w, excepting only the index for dimension DIM, are the same as the corresponding indices of a; and
3. The element of SEGMENT corresponding to w does not have the same value as the element of SEGMENT corresponding to a. (In other words, z can contribute only if there is an unbroken string of SEGMENT values, all alike, extending from z through a.)
If the EXCLUSIVE argument is provided and is true, then itself does not contribute to r.

These general rules lead to the following important cases:

Case (i): If ARRAY has rank one, element i of the result of XXX_PREFIX(ARRAY) is determined by the first i elements of ARRAY; element SIZE(ARRAY)-i+1 of the result of XXX_SUFFIX(ARRAY) is determined by the last i elements of ARRAY.

Case (ii): If ARRAY has rank greater than one, then each element of the result of XXX_PREFIX(ARRAY) has a value determined by the corresponding element of the ARRAY and all elements of ARRAY that precede a in array element order. For XXX_SUFFIX, a is determined by the elements of ARRAY that correspond to or follow a in array element order.

Case (iii): Each element of the result of XXX_PREFIX(ARRAY,MASK=MASK) is determined by selected elements of ARRAY, namely the corresponding element of the ARRAY and all elements of ARRAY that precede in array element order, but an element of ARRAY may contribute to the result only if the corresponding element of MASK is true. If this restriction results in selecting no array elements to contribute to some element of the result, then that element of the result is set to the default value for the given function.

Case (iv): Each element of the result of XXX_PREFIX(ARRAY,DIM=DIM) is determined by selected elements of ARRAY, namely the corresponding element of the ARRAY and all elements of ARRAY that precede along dimension DIM; for example, in SUM_PREFIX(A(1:N,1:N), DIM=2), result element (i₁, i₂) could be computed as SUM(A(i₁,1 : i₂)). More generally, in SUM_PREFIX(ARRAY, DIM), result element i₁, i₂,...,i_DIM,...,i_n could be computed as SUM(ARRAY( i₁, i₂,...,i_DIM,...,i_n )) . (Note the colon before i_DIM in that last expression.)

Case (v): If ARRAY has rank one, then element of the result of XXX_PREFIX(ARRAY, EXCLUSIVE=.TRUE.) is determined by the first i-1 elements of ARRAY.

Case (vi): The options may be used in any combination.

Advice to users.A new segment begins at every transition from false to true or true to false; thus a segment is indicated by a maximal contiguous subsequence of like logical values:

(/T,T,T,F,T,F,F,F,T,F,F,T/)
  ----- - - ----- - --- -    seven segments

(End of advice to users.)

Rationale.One existing library delimits the segments by indicating the start of each segment. Another delimits the segments by indicating the stop of each segment. Each method has its advantages. There is also the question of whether this convention should change when performing a suffix rather than a prefix. HPF adopts the symmetric representation above. The main advantages of this representation are:

(A)

It is symmetrical, in that the same segment specifier may be meaningfully used for prefix and suffix without changing its interpretation (start versus stop).

(B)

The start-bit or stop-bit representation is easily converted to this form by using PARITY_PREFIX or PARITY_SUFFIX. These might be standard idioms for a compiler to recognize:

SUM_PREFIX(FOO,SEGMENT=PARITY_PREFIX(START_BITS))
SUM_PREFIX(FOO,SEGMENT=PARITY_SUFFIX(STOP_BITS))
SUM_SUFFIX(FOO,SEGMENT=PARITY_SUFFIX(START_BITS))
SUM_SUFFIX(FOO,SEGMENT=PARITY_PREFIX(STOP_BITS))

(End of rationale.)

Examples. The examples below illustrate all possible combinations of optional arguments for SUM_PREFIX. The default value for SUM_YYYFIX is zero.

Case (i): SUM_PREFIX((/1,3,5,7/)) is [1 4 9 16].

Case (ii):

                  /       \
                  | 1 2 3 |
If B is the array | 4 5 6 |,
                  | 7 8 9 |
                  \       /

                                /          \
                                |  1 14 30 |
then SUM_PREFIX(B) is the array |  5 19 36 |.
                                | 12 27 45 |
                                \          /

Case (iii): If A is the array [3 5 -2 -1 7 4 8], then SUM_PREFIX(A, MASK = A .LT. 6) is [3 8 6 5 5 9 9]

Case (iv):

                  /       \ 
                  | 1 2 3 |
If B is the array | 4 5 6 |,
                  | 7 8 9 |
                  \       /

                                       /          \
                                       |  1  2  3 |
then SUM_PREFIX(B, DIM=1) is the array |  5  7  9 |.
                                       | 12 15 18 |
                                       \          /



                                      /         \
                                      | 1  3  6 |
and SUM_PREFIX(B, DIM=2) is the array | 4  9 15 |.
                                      | 7 15 24 |
                                      \         /

Case (v): SUM_PREFIX((/1,3,5,7/), EXCLUSIVE=.TRUE.) is [0 1 4 9].

Case (vi):

                   /                \
                   |  1  2  3  4  5 |
If  B is the array |  6  7  8  9 10 |,  M is the array
                   | 11 12 13 14 15 |
                   \                /

   /           \                       /           \
   | T T T T T |                       | T T F F F |
   | F F T T T |,   and S is the array | F T T F F |,   then:
   | T F T F F |                       | T T T T T |
   \           /                       \           /

SUM_PREFIX(B, DIM=2, MASK=M, SEGMENT=S, EXCLUSIVE=.TRUE.) is
                                                     /               \
                                                     | 0  1  0  3  7 |
                                                     | 0  0  0  0  9 |.
                                                     | 0 11 11 24 24 |
                                                     \               /

SUM_PREFIX(B, DIM=2, MASK=M, SEGMENT=S, EXCLUSIVE=.FALSE.) is
                                                     /                \
                                                     | 1  3  3  7  12 |
                                                     | 0  0  8  9  19 |.
                                                     | 11 11 24 24 24 |
                                                     \                /

                                                  /               \
                                                  | 0  1  3  6 10 |
SUM_PREFIX(B, DIM=2, MASK=M, EXCLUSIVE=.TRUE.) is | 0  0  0  8 17 |.
                                                  | 0 11 11 24 24 |
                                                  \               /

                                                   /                \
                                                   |  1  3  6 10 15 |
SUM_PREFIX(B, DIM=2, MASK=M, EXCLUSIVE=.FALSE.) is |  0  0  8 17 27 |.
                                                   | 11 11 24 24 24 |
                                                   \                /

                                                     /               \
                                                     | 0  1  0  3  7 |
SUM_PREFIX(B, DIM=2, SEGMENT=S, EXCLUSIVE=.TRUE.) is | 0  0  7  0  9 |.
                                                     | 0 11 23 36 50 |
                                                     \               /


                                                      /                \
                                                      |  1  3  3  7 12 |
SUM_PREFIX(B, DIM=2, SEGMENT=S, EXCLUSIVE=.FALSE.) is |  6  7 15  9 19 |.
                                                      | 11 23 36 50 65 |
                                                      \                /


                                          /               \
                                          | 0  1  3  6 10 |
SUM_PREFIX(B, DIM=2, EXCLUSIVE=.TRUE.) is | 0  6 13 21 30 |.
                                          | 0 11 23 36 50 |
                                          \               /

                                           /                \
                                           |  1  3  6 10 15 |
SUM_PREFIX(B, DIM=2, EXCLUSIVE=.FALSE.) is |  6 13 21 30 40 |.
                                           | 11 23 36 50 65 |
                                           \                /

                                                      /            \
                                                      | 0 11 0 0 0 |
SUM_PREFIX(B, MASK=M, SEGMENT=S, EXCLUSIVE=.TRUE.) is | 0 13 0 4 5 |.
                                                      | 0 13 8 0 0 |
                                                      \            /

SUM_PREFIX(B, MASK=M, SEGMENT=S, EXCLUSIVE=.FALSE.) is
                                                     /                \
                                                     |  1 13  3  4  5 |
                                                     |  0 13  8 13 15 |.
                                                     | 11 13 21  0  0 |
                                                     \                /

                                           /               \
                                           | 0 12 14 38 51 |
SUM_PREFIX(B, MASK=M, EXCLUSIVE=.TRUE.) is | 1 14 17 42 66 |.
                                           | 1 14 25 51 66 |
                                           \               /

                                            /                \
                                            |  1 14 17 42 56 |
SUM_PREFIX(B, MASK=M, EXCLUSIVE=.FALSE.) is |  1 14 25 51 66 |.
                                            | 12 14 38 51 66 |
                                            \                /

                                              /            \
                                              | 0 11 0 0 0 |
SUM_PREFIX(B, SEGMENT=S, EXCLUSIVE=.TRUE.) is | 0 13 0 4 5 |.
                                              | 0 20 8 0 0 |
                                              \            /

                                               /                \
                                               |  1 13  3  4  5 |
SUM_PREFIX(B, SEGMENT=S, EXCLUSIVE=.FALSE.) is |  6 20  8 13 15 |.
                                               | 11 32 21 14 15 |
                                               \                /

                                   /                \
                                   | 0 18 39 63  90 |
SUM_PREFIX(B, EXCLUSIVE=.TRUE.) is | 1 20 42 67  95 |
                                   | 7 27 50 76 105 |
                                   \                /

                                    /                 \
                                    |  0 18 39 63  90 |
SUM_PREFIX(B, EXCLUSIVE=.FALSE.) is |  1 20 42 67  95 |
                                    | 18 39 63 90 120 |
                                    \                 /

Next: Array Sorting Functions Up: Library Procedures Previous: Array Combining Scatter Functions