An array constructor is a sequence of scalar values that is
  interpreted as a rank-one array.  The array element values are
  those specified in the sequence.  An array constructor takes the
  following form:

     (/ac-value-list/)

     ac-value-list  Is a list of one or more expressions
                    or implied-do loops. Each ac-value must
                    have the same type and kind type parameter.

  An implied-do loop in an array constructor takes the following
  form:

    (ac-value-expr, do-variable = expr1, expr2 [,expr3])

    ac-value-expr  Is a scalar expression evaluated for each
                   value of the d-variable to produce an array
                   element value.

    do-variable    Is the name of a scalar integer variable.
                   Its scope is that of the implied-do loop.

    expr           Is a scalar integer expression. The expr1
                   and expr2 specify a range of values for
                   the loop; expr3 specifies the stride.

  The array constructor has the same type as the ac-value-list
  expressions.

  If the sequence of values specified by the array constructor is
  empty (there are no expressions or the implied-do loop produces no
  values), the rank-one array has a size of zero.

  The ac-value specifies the following:

   o  If it is a scalar expression, its value specifies an element of
      the array constructor.

   o  If it is an array expression, the values of the elements of the
      expression, in array element order, specify the corresponding
      sequence of elements of the array constructor.

   o  If it is an implied-do loop, it is expanded to form an array
      constructor value sequence under the control of the DO
      variable, as in the DO construct.

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

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

  There are three forms for an ac-value, as follows:

    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/)

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

  The following are alternative forms for array constructors:

   o  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]

   o  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
        D = (/(I, I=1, 5, 2)/)     ! Implied-do loop form

  The following example shows an array constructor using an
  implied-do loop:

    INTEGER ARRAY_C(10)
    ARRAY_C = (/(I, I=30, 48, 2)/)

  The values of ARRAYC are the even numbers 30 through 48.

  The following example shows an array constructor of derived type
  that uses a structure constructor:

    TYPE EMPLOYEE
      INTEGER ID
      CHARACTER(LEN=30) NAME
    END TYPE EMPLOYEE

    TYPE(EMPLOYEE) CC_4T(4)
    CC_4T = (/EMPLOYEE(2732,"JONES"), EMPLOYEE(0217,"LEE"),     &
              EMPLOYEE(1889,"RYAN"), EMPLOYEE(4339,"EMERSON")/)

  The following example shows how the RESHAPE intrinsic function is
  used to create a multidimensional array:

    E = (/2.3, 4.7, 6.6/)
    D = RESHAPE(SOURCE = (/3.5,(/2.0,1.0/),E/), SHAPE = (/2,3/))

  D is a rank-two array with shape (2,3) containing the following
  elements:

    3.5   1.0   4.7
    2.0   2.3   6.6