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:- 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; - 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 - 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 function is
- 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*_{1},*i*_{2}) could be computed as`SUM(A(`. More generally, in*i*_{1},1 :*i*_{2}))`SUM_PREFIX(ARRAY, DIM)`, result element*i*_{1},*i*_{2},...,*i*_{DIM},...,*i*_{n}could be computed as`SUM(ARRAY(`. (Note the colon before i_DIM in that last expression.)*i*_{1},*i*_{2},...,*i*_{DIM},...,*i*_{n}))*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.- If the function is

*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 | \ /