Array Constructors

Description

If type-spec is omitted, each ac-value-list expression must have the same type and kind type parameters, and the same length parameters. In this case, the array constructed has the same type as the ac-value-list expressions.

If type-spec appears, it specifies the type and type parameters of the array constructor. Each ac-value-list expression must be compatible with intrinsic assignment to a variable of this type and type parameters. Each value is converted to the type parameters of the array constructor in accordance with the rules of intrinsic assignment.

If type-spec specifies an intrinsic type, each ac-value-list expression must be of an intrinsic type that conforms with a variable of type type-spec.

If type-spec specifies a derived type, all ac-value-list expressions must be of that derived type and must have the same kind type parameter values as specified by type-spec.

If the sequence of values specified by the array constructor is empty (an empty array expression or the implied-DO loop produces no values), the rank-one array has a size of zero.

An ac-value is interpreted as follows:

The following shows the three forms of an ac-value:

  C1 = (/4,8,7,6/)                  ! A scalar expression
  C2 = (/B(I, 1:5), B(I:J, 7:9)/)   ! An array expression
  C3 = (/(I, I=1, 4)/)              ! An implied-DO loop

You can also mix these forms, for example:

  C4 = (/4, A(1:5), (I, I=1, 4), 7/)

If every expression in an array constructor is a constant expression, the array constructor is a constant expression.

If type-spec is omitted, Intel® Fortran allows the numeric expressions to be of different kind types, but not different types. The resultant numeric array is the type and kind type of the first expression in the ac-value-list. For example:

 INTEGER, PARAMETER :: K(2) = [4, 8]
! The following line prints 4.000000       8.00000000000000
PRINT *, REAL (K(1), K(1)), REAL (K(2), K(2))   
! The following line prints 4.000000       8.000000
PRINT *, [ (REAL (K(I), K(I)), I=1,20]          

If type-spec is omitted, Intel® Fortran allows the character expressions to be of different character lengths. The length of the resultant character array is the maximum of the lengths of the individual character expressions. For example:

print *,len ( (/'a','ab','abc','d'/) )
print *,'++'//(/'a','ab','abc','d'/)//'--'

This causes the following to be displayed:

           3
 ++a  --++ab --++abc--++d  --

If an implied-DO loop is contained within another implied-DO loop (nested), they cannot have the same DO variable (do-variable).

To define arrays of more than one dimension, use the RESHAPE intrinsic function.

The following are alternative forms for array constructors:

• Square brackets (instead of parentheses and slashes) to enclose array constructors; for example, the following two array constructors are equivalent:

    INTEGER C(4)
    C = (/4,8,7,6/)
    C = [4,8,7,6]

• A colon-separated triplet (instead of an implied-DO loop) to specify a range of values and a stride; for example, the following two array constructors are equivalent:

    INTEGER D(3)
    D = (/1:5:2/)              ! Triplet form - also [1:5:2]
    D = (/(I, I=1, 5, 2)/)     ! implied-DO loop form
  

  The stride is optional; it defaults to 1. For example, the following two array constructors are equivalent:

    INTEGER E(5)
    E = (/1:5/)              ! Triplet form with default stride – also [1:5]
    E = (/(I, I=1, 5)/)      ! implied-DO loop form