Array operations areperformed
in parallel. That is, an operation is performed on each element independently
and in any order. The practical effect of this is that, because
an assignment statement may have the same array on both the left
and right-hand sides, the right-hand side is fully evaluated before
any assignment takes place. This means that in some cases the compiler
may create temporary space to hold intermediate results of the computation.
A scalar may
appear in an array expression. If the scalar is used in an expression
containing whole array references—for example
a = b + 2.0 ! a and b are conformable arrays of type real |
then the effect is as if the scalar were evaluated and then
broadcast to form a conformable array of elements, each having the
value of the scalar. Thus, a scalar used in an array context is
conformable with the array or arrays involved.
Zero-sized arrays may
also appear in an array expression. Although they have no elements, they
do have a shape and must therefore follow the rule of conformable
arrays. Because scalars are conformable with any array, they may
therefore appear in an operation involving a zero-sized array.
The following illustrates
valid and invalid array expressions.
 |
SUBROUTINE foo(a,b,c)
! a is an assumed-shape array with rank-one
REAL :: a(:)
! b is a pointer to a rank-two array
REAL, POINTER :: b(:,:)
! c is an assumed-size array
REAL :: c(*)
! d is an allocatable array; its shape can only be defined in an
! ALLOCATE statement
REAL, ALLOCATABLE :: d(:)
! create the array d with the same size as a; a and d have
! the same shape and are therefore conformable
ALLOCATE(d(SIZE(a)))
! copy the array a into d
d = a
! sets each element of the array associated with b to 0.0;
! the effect is as if the scalar were broadcast into a
! temporary array, with the same shape as b; b is then assigned
! to theleft-hand side
b = 0.0
! corresponding elements of a and d are added together and then
! stored back into the corresponding array element of d
d = a + d
! conceptually the operand SQRT(d) is evaluated into an
! intermediate array with the same shape as d; each element of
! the intermediate array will be added to the corresponding
! element of a and stored into the corresponding element of d
d = a + SQRT(d)
DEALLOCATE(d)
! examples of illegal uses of arrays:
! ILLEGAL - c is an assumed-size array and so has no shape;
! an assumed-size array may not be used as a whole array
! operand(except in an argument list)
a = c
! ILLEGAL - the arrays a and b do not have the same shape and are
! therefore not conformable
a = a + b
! ILLEGAL - d was previously deallocated and must not be
! referenced subsequently
a = a + d
END SUBROUTINE foo |
|
Printable version
