Permits masked array assignment, which lets you perform an array
  operation on selected elements.  This kind of assignment masks the
  evaluation of expressions and assignment of values in array
  assignment statements, according to the value of a logical array
  expression.

  WHERE can be specified as a construct or statement.  Format:

  Statement form:

    WHERE (mask-expr1) assign-stmt

  Construct form:

    [name :] WHERE (mask-expr1)
       [where-body-stmt]...
    [ELSEWHERE (mask-expr2) [name]
       [where-body-stmt]...]
    [ELSEWHERE [name]
       [where-body-stmt]...]
    END WHERE [name]

    name             Is the name of the WHERE construct.

    mask-expr1       Are logical array expressions (called
    mask-expr2       mask expressions).

    assign-stmt      Is an assignment statement of the form:

                     array variable = array expression

    where-body-stmt  Is one of the following:
                     o An "assign-stmt"
                     o A WHERE statement or construct

  If a construct name is specified in a WHERE statement, the same
  name must appear in the corresponding END WHERE statement.  The
  same construct name can optionally appear in any ELSEWHERE
  statement in the construct.  (ELSEWHERE cannot specify a different
  name.)

  In each assignment statement, the mask expression, the variable
  being assigned to, and the expression on the right side, must all
  be conformable.  Also, the assignment statement cannot be a defined
  assignment.

  Each mask expression in the WHERE construct must be conformable.

  Only the WHERE statement (or the first line of the WHERE construct)
  can be labeled as a branch target statement.

  The following is an example of a WHERE statement:

    INTEGER A, B, C
    DIMENSION A(5), B(5), C(5)
    DATA A /0,1,1,1,0/
    DATA B /10,11,12,13,14/
    C = -1

    WHERE(A .NE. 0) C = B / A

  The resulting array C contains:  -1,11,12,13, and -1.

  The assignment statement is only executed for those elements where
  the mask is true.  Think of the mask expression in this example as
  being evaluated first into a logical array which has the value true
  for those elements where A is positive.

  This array of trues and falses is applied to the arrays A, B and C
  in the assignment statement.  The right side is only evaluated for
  elements for which the mask is true; assignment on the left side is
  only performed for those elements for which the mask is true.  The
  elements for which the mask is false do not get assigned a value.

  In a WHERE construct the mask expression is evaluated first and
  only once.  Every assignment statement following the WHERE is
  executed as if it were a WHERE statement with "mask-expr1" and
  every assignment statement following the ELSEWHERE is executed as
  if it were a WHERE statement with ".NOT.  mask-expr1".  If
  ELSEWHERE specifies "mask-expr2", it is executed as "(.NOT.
  mask-expr1) .AND.  mask-expr2".

  You should be careful if the statements have side effects, or
  modify each other or the mask expression.

  The following is an example of the WHERE construct:

    DIMENSION PRESSURE(1000), TEMP(1000), PRECIPITATION(1000)
    WHERE(PRESSURE .GE. 1.0)
      PRESSURE = PRESSURE + 1.0
      TEMP = TEMP - 10.0
    ELSEWHERE
      PRECIPITATION = .TRUE.
    ENDWHERE

  The mask is applied to the arguments of functions on the right side
  of the assignment if they are considered to be elemental functions.
  Only elemental intrinsics are considered elemental functions.
  Transformational intrinsics, inquiry intrinsics, and functions or
  operations defined in the subprogram are considered to be
  nonelemental functions.

  Consider the following example using LOG, an elemental function:

    WHERE(A .GT. 0)  B = LOG(A)

  The mask is applied to A, and LOG is executed only for the positive
  values of A.  The result of the LOG is assigned to those elements
  of B where the mask is true.

  Consider the following example using SUM, a nonelemental function:

    REAL A, B
    DIMENSION A(10,10), B(10)
    WHERE(B .GT. 0.0)  B = SUM(A, DIM=1)

  Since SUM is nonelemental, it is evaluated fully for all of A.
  Then, the assignment only happens for those elements for which the
  mask evaluated to true.

  Consider the following example:

    REAL A, B, C
    DIMENSION A(10,10), B(10), C(10)
    WHERE(C .GT. 0.0)  B = SUM(LOG(A), DIM=1)/C

  Because SUM is nonelemental, all of its arguments are evaluated
  fully regardless of whether they are elemental or not.  In this
  example, LOG(A) is fully evaluated for all elements in A even
  though LOG is elemental.  Notice that the mask is applied to the
  result of the SUM and to C to determine the right side.  One way of
  thinking about this is that everything inside the argument list of
  a nonelemental function does not use the mask, everything outside
  does.