Language Reference

PAUSE

Purpose

The PAUSE statement temporarily suspends the execution of a program and prints the keyword PAUSE and, if specified, a character constant or digit string to unit 0.

Syntax

>>-PAUSE--+---------------+------------------------------------>< +-char_constant-+ '-digit_string--'

char_constant

is a scalar character constant that is not a Hollerith constant

digit_string

is a string of one to five digits

Rules

+-------------------------------IBM Extension--------------------------------+

After execution of a PAUSE statement, processing continues when you press the Enter key. If unit 5 is not connected to the terminal, the PAUSE statement does not suspend execution.

+----------------------------End of IBM Extension----------------------------+

+---------------------------------Fortran 95---------------------------------+

The PAUSE statement has been deleted in Fortran 95.

+-----------------------------End of Fortran 95------------------------------+

Examples

      PAUSE 'Ensure backup tape is in tape drive'
      PAUSE 10             ! Output:  PAUSE 10

Related Information

• Deleted Features

Language Reference

POINTER (Fortran 90)

Purpose

The POINTER attribute designates objects as pointer variables.

The term pointer refers to objects with the Fortran 90 POINTER attribute. The integer POINTER statement provides details on what was documented in previous versions of XL Fortran as the POINTER statement; these pointers are now referred to as integer pointers.

Syntax

>>-POINTER--+----+----------------------------------------------> '-::-' .-,-----------------------------------------------. V | >----object_name--+--------------------------------+-+--------->< '-(--deferred_shape_spec_list--)-'

deferred_shape_spec

is a colon (:), where each colon represents a dimension

Rules

object_name refers to a data object or function result. If object_name is declared elsewhere in the scoping unit with the DIMENSION attribute, the array specification must be a deferred_shape_spec_list.

object_name must not appear in an integer POINTER, NAMELIST, or EQUIVALENCE statement. If object_name is a component of a derived-type definition, any variables declared with that type cannot be specified in an EQUIVALENCE, DATA, or NAMELIST statement.

Pointer variables can appear in common blocks and block data program units.

+-------------------------------IBM Extension--------------------------------+

To ensure that Fortran 90 pointers are thread-specific, do not specify either the SAVE or STATIC attribute for the pointer. These attributes are either specified explicitly by the user, or implicitly through the use of the -qsave compiler option. Note, however, that if a non-static pointer is used in a pointer assignment statement where the target is static, all references to the pointer are, in fact, references to the static, shared target.

+----------------------------End of IBM Extension----------------------------+

An object having a component with the POINTER attribute can itself have the TARGET, INTENT, or ALLOCATABLE attibutes, although it cannot appear in a data transfer statement.

Attributes Compatible with the POINTER Attribute
AUTOMATIC DIMENSION INTENT OPTIONAL PRIVATE PROTECTED PUBLIC SAVE STATIC VOLATILE

These attributes apply only to the pointer itself, not to any associated targets, except for the DIMENSION attribute, which applies to associated targets.

Examples

Example1:

INTEGER, POINTER :: PTR(:)
INTEGER, TARGET :: TARG(5)
PTR => TARG                  ! PTR is associated with TARG and is
                             !   assigned an array specification of (5)
 
PTR(1) = 5                   ! TARG(1) has value of 5
PRINT *, FUNC()
CONTAINS
  REAL FUNCTION FUNC()
    POINTER :: FUNC          ! Function result is a pointer
 
       
  ·
  ·
  ·

  END FUNCTION
END

+-------------------------------IBM Extension--------------------------------+

Example 2: Fortran 90 pointers and threadsafing

FUNCTION MYFUNC(ARG)                ! MYPTR is thread-specific.
INTEGER, POINTER :: MYPTR           !  every thread that invokes
                                    !  'MYFUNC' will allocate a
ALLOCATE(MYPTR)                     !  new piece of storage that
MYPTR = ARG                         !  is only accessible within

  ·
  ·
  ·
                                    !  that thread.
ANYVAR = MYPTR
END FUNCTION

+----------------------------End of IBM Extension----------------------------+

Related Information

• Pointer Assignment
• TARGET
• ALLOCATED(ARRAY) or ALLOCATED(SCALAR)
• DEALLOCATE
• Pointer Association
• Deferred-Shape Arrays

Language Reference

XL Fortran (XLF)

The XLF language contains:

• Fortran 90

  The Fortran 90 language standard supports the FORTRAN 77 language standard. See Appendix A, Compatibility Across Standards for more details.

  +---------------------------------Fortran 95---------------------------------+

  
  
• Fortran 95

  Fortran 95 has removed a few features that were part of both the Fortran 90 and FORTRAN 77 language standards. The features that have been removed from the Fortran 95 standard were deemed to conform least with modern day programming practice by the Fortran standards committees. However, functionality has not been removed from Fortran 95 as efficient alternatives to the features deleted do exist. See Deleted Features for more information. XL Fortran continues to support the features that have been removed from the Fortran 95 standard, since it is intended to be compatible with the FORTRAN 77, Fortran 90 and Fortran 95 standards.

  Fortran 95 also provides an extensive set of additional language features. Some of these features are briefly discussed in the following section. The Fortran standard committees are responding to questions of interpretation about aspects of Fortran. Some of these questions may be related to language features that have been implemented in the XL Fortran compiler. Any answers given by these committees that are related to these language features may result in changes in future releases of the XL Fortran compiler, even if these changes result in incompatibilities with previous releases of the product.

  +-----------------------------End of Fortran 95------------------------------+

  +-------------------------------IBM Extension--------------------------------+

  
  
• IBM and industry extensions to the Fortran language

  XL Fortran supports a number of extensions to the FORTRAN 77, Fortran 90, and Fortran 95 language standards. These extensions include, among other things, support for the OpenMP specification, support for a series of service and utility procedures and support for the Pthreads Library Module. Some of these functions are discussed briefly in the next section.

  +----------------------------End of IBM Extension----------------------------+

Language Reference

+-------------------------------IBM Extension--------------------------------+

POINTER (integer)

Purpose

The integer POINTER statement specifies that the value of the variable int_pointer is to be used as the address for any reference to pointee.

The name of this statement has been changed from POINTER to integer POINTER to distinguish it from the Fortran 90 POINTER statement. The functionality and syntax for this statement remain the same as in previous releases of XL Fortran; only the name has changed.

Syntax

.-,-----------------------------. V | >>-POINTER----(--int_pointer--,--pointee--)-+------------------><

int_pointer

is the name of an integer pointer variable

pointee

is a variable name or array declarator

Rules

The compiler does not allocate storage for the pointee. Storage is associated with the pointee at execution time by the assignment of the address of a block of storage to the pointer. The pointee can become associated with either static or dynamic storage. A reference to a pointee requires that the associated pointer be defined.

An integer pointer is a scalar variable of type INTEGER(4) in 32-bit mode and type INTEGER(8) in 64-bit mode that cannot have a type explicitly assigned to it. You can use integer pointers in any expression or statement in which a variable of the same type as the integer pointer can be used. You can assign any data type to a pointee, but you cannot assign a storage class or initial value to a pointee.

An actual array that appears as a pointee in an integer POINTER statement is called a pointee array. You can dimension a pointee array in a type declaration statement, a DIMENSION statement, or in the integer POINTER statement itself.

If you specify the -qddim compiler option, a pointee array that appears in a main program can also have an adjustable array specification. In main programs and subprograms, the dimension size is evaluated when the pointee is referenced (dynamic dimensioning).

If you do not specify the -qddim compiler option, a pointee array that appears in a subprogram can have an adjustable array specification, and the dimension size is evaluated on entrance to the subprogram, not when the pointee is evaluated.

The following constraints apply to the definition and use of pointees and integer pointers:

• A pointee cannot be zero-sized.
• A pointee can be scalar, an assumed-sized array or an explicit-shape array.
• A pointee cannot appear in a COMMON, DATA, NAMELIST, or EQUIVALENCE statement.
• A pointee cannot have the following attributes: EXTERNAL, ALLOCATABLE, POINTER, TARGET, INTRINSIC, INTENT, OPTIONAL, SAVE, STATIC, AUTOMATIC, or PARAMETER.
• A pointee cannot be a dummy argument and therefore cannot appear in a FUNCTION, SUBROUTINE, or ENTRY statement.
• A pointee cannot be an automatic object, though a pointee can have nonconstant bounds or lengths.
• A pointee cannot be a generic interface block name.
• A pointee that is of derived type must be of sequence derived type.
• A function value cannot be a pointee.
• An integer pointer cannot be pointed to by another pointer. (A pointer cannot be a pointee.)
• |An integer pointer cannot have the following attributes: |
  • |ALLOCATABLE
  • |DIMENSION
  • |EXTERNAL
  • |INTRINSIC
  • |PARAMETER
  • |POINTER
  • |TARGET |
• An integer pointer cannot appear as a NAMELIST group name.
• An integer pointer cannot be a procedure.

Examples

     INTEGER A,B
     POINTER (P,I)
     IF (A<>0) THEN
       P=LOC(A)
     ELSE
       P=LOC(B)
     ENDIF
     I=0         ! Assigns 0 to either A or B, depending on A's value
     END

Related Information

• Integer Pointer Association
• LOC(X)
• -qddim Option in the User's Guide

+----------------------------End of IBM Extension----------------------------+

Language Reference

PRINT

Purpose

The PRINT statement is a data transfer output statement.

Syntax

>>-PRINT--+-name----------------------------+------------------>< '-format--+---------------------+-' '-,--output_item_list-'

name

is a namelist group name

output_item

is an output list item. An output list specifies the data to be transferred. An output list item can be:

• A variable. An array is treated as if all of its elements were specified in the order they are arranged in storage.

  A pointer must be associated with a target, and an allocatable object must be allocated. A derived-type object cannot have any ultimate component that is outside the scoping unit of this statement. The evaluation of output_item cannot result in a derived-type object that contains a pointer. The structure components of a structure in a formatted statement are treated as if they appear in the order of the derived-type definition; in an unformatted statement, the structure components are treated as a single value in their internal representation (including padding).

• An expression.
• An implied-DO list, as described under Implied-DO List.

format

is a format specifier that specifies the format to be used in the output operation. format is a format identifier that can be:

• The statement label of a FORMAT statement. The FORMAT statement must be in the same scoping unit.
• The name of a scalar INTEGER(4) or INTEGER(8) variable that was assigned the statement label of a FORMAT statement. The FORMAT statement must be in the same scoping unit.

  +---------------------------------Fortran 95---------------------------------+

  
  

  Fortran 95 does not permit assigning of a statement label.

  +-----------------------------End of Fortran 95------------------------------+

• A character constant. It cannot be a Hollerith constant. It must begin with a left parenthesis and end with a right parenthesis. Only the format codes described in the FORMAT statement can be used between the parentheses. Blank characters can precede the left parenthesis, or follow the right parenthesis.
• A character variable that contains character data whose leftmost character positions constitute a valid format. A valid format begins with a left parenthesis and ends with a right parenthesis. Only the format codes listed under FORMAT can be used between the parentheses. Blank characters can precede the left parenthesis, or follow the right parenthesis.
• An array of noncharacter intrinsic type.
• Any character expression, except one involving concatenation of an operand that specifies inherited length, unless the operand is the name of a constant.
• An asterisk, specifying list-directed formatting.
• A namelist specifier that specifies the name of a namelist list that you have previously defined.

Specifying the -qport=typestmt compiler option enables the TYPE statement which has identical functionality to the PRINT statement.

Implied-DO List

>>-(--do_object_list-- , ---------------------------------------> >--do_variable = arith_expr1, arith_expr2-----------------------> >--+---+--+-------------+--)----------------------------------->< '-,-' '-arith_expr3-'

do_object

is an output list item

do_variable

is a named scalar variable of type integer or real

arith_expr1, arith_expr2,  and  arith_expr3

are scalar numeric expressions

The range of an implied-DO list is the list do_object_list. The iteration count and the values of the DO variable are established from arith_expr1, arith_expr2, and arith_expr3, the same as for a DO statement. When the implied-DO list is executed, the items in the do_object_list are specified once for each iteration of the implied-DO list, with the appropriate substitution of values for any occurrence of the DO variable.

Examples

   PRINT 10, A,B,C
10 FORMAT (E4.2,G3.2E1,B3)

Related Information

• Chapter 8, Input/Output Concepts
• Chapter 9, Input/Output Formatting
• See the User's Guide for more information on -qport=typestmt.
• Deleted Features

Language Reference

PRIVATE

Purpose

The PRIVATE attribute specifies that a module entity is not accessible outside the module through use association.

Syntax

>>-PRIVATE--+------------------------+------------------------->< '-+----+--access_id_list-' '-::-'

access_id

is a generic specification or the name of a variable, procedure, derived type, constant, or namelist group

Rules

The PRIVATE attribute can appear only in the scope of a module.

Although multiple PRIVATE statements may appear in a module, only one statement that omits an access_id_list is permitted. A PRIVATE statement without an access_id_list sets the default accessibility to private for all potentially accessible entities in the module. If the module contains such a statement, it cannot also include a PUBLIC statement without an access_id_list. If the module does not contain such a statement, the default accessibility is public. Entities whose accessibility is not explicitly specified have default accessibility.

A procedure that has a generic identifier that is public is accessible through that identifier, even if its specific identifier is private. If a module procedure contains a private dummy argument or function result whose type has private accessibility, the module procedure must be declared to have private accessibility and must not have a generic identifier that has public accessibility.

If a PRIVATE statement is specified within a derived-type definition, all the components of the derived type become private.

A structure must be private if its derived type is private. A namelist group must be private if it contains any object that is private or contains private components. A derived type that has a component of derived type that is private must itself be private or have private components. A subprogram must be private if any of its arguments are of a derived type that is private. A function must be private if its result variable is of a derived type that is private.

Attributes Compatible with the PRIVATE Attribute
ALLOCATABLE DIMENSION EXTERNAL INTRINSIC PARAMETER POINTER PROTECTED SAVE STATIC TARGET VOLATILE

Examples

MODULE MC
   PUBLIC                     ! Default accessibility declared as public
   INTERFACE GEN
      MODULE PROCEDURE SUB1, SUB2
   END INTERFACE
   PRIVATE SUB1               ! SUB1 declared as private
   CONTAINS
      SUBROUTINE SUB1(I)
         INTEGER I
         I = I + 1
      END SUBROUTINE SUB1
      SUBROUTINE SUB2(I,J)
         I = I + J
      END SUBROUTINE
END MODULE MC
 
PROGRAM ABC
   USE MC
   K = 5
   CALL GEN(K)                ! SUB1 referenced because GEN has public
                              ! accessibility and appropriate argument
                              ! is passed
   CALL SUB2(K,4)
   PRINT *, K                 ! Value printed is 10
END PROGRAM

Related Information

• Derived Types
• Modules
• PROTECTED
• PUBLIC

Language Reference

PROGRAM

Purpose

The PROGRAM statement specifies that a program unit is a main program, the program unit that receives control from the system when the executable program is invoked at run time.

Syntax

>>-PROGRAM--name-----------------------------------------------><

name

is the name of the main program in which this statement appears

Rules

The PROGRAM statement is optional.

If specified, the PROGRAM statement must be the first statement of the main program.

If a program name is specified in the corresponding END statement, it must match name.

The program name is global to the executable program. This name must not be the same as the name of any common block, external procedure, or any other program unit in that executable program, or as any name that is local to the main program.

The name has no type, and it must not appear in any type declaration or specification statements. You cannot refer to a main program from a subprogram or from itself.

Examples

      PROGRAM DISPLAY_NUMBER_2
         INTEGER A
         A = 2
         PRINT *, A
      END PROGRAM DISPLAY_NUMBER_2

Related Information

Main Program

Language Reference

+-------------------------------IBM Extension--------------------------------+

|PROTECTED

|Purpose

|The PROTECTED attribute allows greater control over the |modification of module entities. A module procedure can only modify a |protected module entity or its subobjects if the same module defines both the |procedure and the entity.

|Syntax

|The PROTECTED attribute must only appear in the specification part |of the module.

|

>>-PROTECTED--+----+--entity_declaration_list------------------>< '-::-'

|

|entity

|A named variable not in a common block. |

|Rules

|If you specify that an object declared by an EQUIVALENCE statement has the PROTECTED |attribute, all objects specified in that EQUIVALENCE statement must |have the PROTECTEDattribute.

|A non-pointer object with the PROTECTED attribute accessed through |use association, is not definable.

|You must not specify the PROTECTED attribute for integer pointers.

|A pointer object with the PROTECTED attribute accessed through use |association, must not appear as any of the following: |

• |As a pointer object in a NULLIFY statement |or POINTER assignment statement
• |As an allocatable object in an ALLOCATE or DEALLOCATE statement.
• |As an actual argument in reference to a procedure, if the associated dummy |argument is a pointer with the INTENT(INOUT) or |INTENT(OUT) attribute.

Examples

|In the following example, the values of both age and val |can only be modified by the subroutines in which they are declared:

|      module mod1
|          integer, protected :: val
|          integer :: age
|          protected :: age
|          contains
|              subroutine set_val(arg)
|                  integer arg
|                   val = arg
|              end subroutine
|               subroutine set_age(arg)
|                  integer arg
|                   age  = arg
|              end subroutine
|      end module
|      program dt_init01
|          use mod1
|          implicit none
|          integer :: value, his_age
|          call set_val(88)
|          call set_age(38)
|          value = val
|          his_age = age
|          print *, value, his_age
|      end program

|Related Information

|Modules

|PRIVATE

|PUBLIC

+----------------------------End of IBM Extension----------------------------+

+-------------------------------IBM Extension--------------------------------+

           .-,------------------------------------------.
           V                                            |
>>-RECORD----/ type_name /--+----+--record_obj_dcl_list-+------><
                            '-::-'
 
 

>>-record_object_name--+----------------+----------------------><
                       '-(-array_spec-)-'
 
 

        STRUCTURE /S/
          INTEGER I
        END STRUCTURE
        STRUCTURE /DT/
          INTEGER I
        END STRUCTURE
        RECORD/DT/REC1,REC2,/S/REC3,REC4
                        

+----------------------------End of IBM Extension----------------------------+

+-------------------------------IBM Extension--------------------------------+

+----------------------------End of IBM Extension----------------------------+

+-------------------------------IBM Extension--------------------------------+

+----------------------------End of IBM Extension----------------------------+

      REWIND (9, IOSTAT=IOSS)

+-------------------------------IBM Extension--------------------------------+

+----------------------------End of IBM Extension----------------------------+

LOGICAL :: CALLED=.FALSE.
CALL SUB(CALLED)
CALLED=.TRUE.
CALL SUB(CALLED)
CONTAINS
  SUBROUTINE SUB(CALLED)
    INTEGER, SAVE :: J
    LOGICAL :: CALLED
    IF (CALLED.EQV..FALSE.) THEN
      J=2
    ELSE
      J=J+1
    ENDIF
    PRINT *, J                  ! Output on first call is 2
                                ! Output on second call is 3
  END SUBROUTINE
END

+-------------------------------IBM Extension--------------------------------+

+----------------------------End of IBM Extension----------------------------+

      ZERO: SELECT CASE(N)         ! start of CASE construct ZERO
 
        CASE DEFAULT ZERO
             OTHER: SELECT CASE(N) ! start of CASE construct OTHER
                CASE(:-1)
                   SIGNUM = -1
                CASE(1:) OTHER
                    SIGNUM = 1
             END SELECT OTHER
        CASE (0)
          SIGNUM = 0
 
      END SELECT ZERO

+-------------------------------IBM Extension--------------------------------+

+----------------------------End of IBM Extension----------------------------+

TYPE PERSON
  SEQUENCE
  CHARACTER*1 GENDER     ! Offset 0
  INTEGER(4) AGE         ! Offset 1
  CHARACTER(30) NAME     ! Offset 5
END TYPE PERSON

+-------------------------------IBM Extension--------------------------------+

+----------------------------End of IBM Extension----------------------------+

PARAMETER (PI = 3.14159)
REAL AREA,CIRCUM,R,RADIUS
AREA(R) = PI * (R**2)            ! Define statement functions
CIRCUM(R) = 2 * PI * R           !   AREA and CIRCUM
 
! Reference the statement functions
PRINT *,'The area is: ',AREA(RADIUS)
PRINT *,'The circumference is: ',CIRCUM(RADIUS)

+-------------------------------IBM Extension--------------------------------+

LOGICAL :: CALLED=.FALSE.
CALL SUB(CALLED)
CALLED=.TRUE.
CALL SUB(CALLED)
CONTAINS
  SUBROUTINE SUB(CALLED)
    INTEGER, STATIC :: J
    LOGICAL :: CALLED
    IF (CALLED.EQV..FALSE.) THEN
      J=2
    ELSE
      J=J+1
    ENDIF
    PRINT *, J                  ! Output on first call is 2
                                ! Output on second call is 3
  END SUBROUTINE
END

+----------------------------End of IBM Extension----------------------------+

+-------------------------------IBM Extension--------------------------------+

+----------------------------End of IBM Extension----------------------------+

+-------------------------------IBM Extension--------------------------------+

+----------------------------End of IBM Extension----------------------------+

STOP 'Abnormal Termination'    ! Output:  STOP Abnormal Termination
END
 
STOP                           ! No output
END

+---------------------------------Fortran 95---------------------------------+

+-----------------------------End of Fortran 95------------------------------+

+-------------------------------IBM Extension--------------------------------+

+----------------------------End of IBM Extension----------------------------+

RECURSIVE SUBROUTINE SUB(X,Y)
  INTEGER X,Y
  IF (X.LT.Y) THEN
    RETURN
  ELSE
    CALL SUB(X,Y+1)
  END IF
END SUBROUTINE SUB

+-------------------------------IBM Extension--------------------------------+

+----------------------------End of IBM Extension----------------------------+

   MODULE A
     REAL :: X=5.0
   END MODULE A
   MODULE B
     USE A
     PRIVATE :: X               !  X cannot be accessed through module B
     REAL :: C=80, D=50
   END MODULE B
   PROGRAM TEST
     INTEGER :: TX=7
     CALL SUB
     CONTAINS
 
     SUBROUTINE SUB
     USE B, ONLY : C
     USE B, T1 => C
     USE B, TX => C             !  C is given another local name
     USE A
     PRINT *, TX                !  Value written is 80 because use-associated
                                !  entity overrides host entity
     END SUBROUTINE
   END

+-------------------------------IBM Extension--------------------------------+

|Program validexm1
|  integer :: x = 10, y = 20
|  print *, 'before calling: ', x, y
|  call intersub(x, y)
|  print *, 'after calling: ', x, y
| 
|  contains
|  subroutine intersub(x,y)
|    integer, value ::  x
|    integer y
|    x = x + y
|    y = x*y
|    print *, 'in subroutine after changing: ', x, y
|  end subroutine
|end program validexm1
| 

|before calling: 10 20
|in subroutine after changing: 30 600
|after calling: 10 600
| 

+----------------------------End of IBM Extension----------------------------+

+-------------------------------IBM Extension--------------------------------+

VIRTUAL A(10), ARRAY(5,5,5), LIST(10,100)
VIRTUAL ARRAY2(1:5,1:5,1:5), LIST2(I,M)       ! adjustable array
VIRTUAL B(0:24), C(-4:2), DATA(0:9,-5:4,10)
VIRTUAL ARRAY (M*N*J,*)                       ! assumed-size array

+----------------------------End of IBM Extension----------------------------+

+-------------------------------IBM Extension--------------------------------+

      FUNCTION TEST ()
        REAL ONE, TWO, THREE
        COMMON /BLOCK1/A, B, C
        ...
        VOLATILE /BLOCK1/, ONE, TEST
! Common block elements A, B and C are considered volatile
! since common block BLOCK1 is declared volatile.
        ...
        EQUIVALENCE (ONE, TWO), (TWO, THREE)
! Variables TWO and THREE are volatile as they are equivalenced
! with variable ONE which is declared volatile.
      END FUNCTION

+----------------------------End of IBM Extension----------------------------+

+-------------------------------IBM Extension--------------------------------+

+----------------------------End of IBM Extension----------------------------+

+---------------------------------Fortran 95---------------------------------+

+-----------------------------End of Fortran 95------------------------------+

+---------------------------------Fortran 95---------------------------------+

+-----------------------------End of Fortran 95------------------------------+

+---------------------------------Fortran 95---------------------------------+

+-----------------------------End of Fortran 95------------------------------+

REAL, DIMENSION(10) :: A,B,C
 
!   In the following WHERE statement, the LOG of an element of A
!   is assigned to the corresponding element of B only if that
!   element of A is a positive value.
 
WHERE (A>0.0) B = LOG(A)
       
  ·
  ·
  ·

END

+---------------------------------Fortran 95---------------------------------+

INTERFACE ASSIGNMENT(=)
  ELEMENTAL SUBROUTINE MY_ASSIGNMENT(X, Y)
    LOGICAL, INTENT(OUT) :: X
    REAL, INTENT(IN) :: Y
  END SUBROUTINE MY_ASSIGNMENT
END INTERFACE
 
INTEGER A(10)
REAL C(10)
LOGICAL L_ARR(10)
 
C = (/ -10., 15.2, 25.5, -37.8, 274.8, 1.1, -37.8, -36.2, 140.1, 127.4 /)
A = (/ 1, 2, 7, 8, 3, 4, 9, 10, 5, 6 /)
L_ARR = .FALSE.
 
WHERE (A < 5) L_ARR = C
 
! DATA IN ARRAY L_ARR AT THIS POINT:
!
! L_ARR = F, T, F, F, T, T, F, F, F, F
 
END
 
ELEMENTAL SUBROUTINE MY_ASSIGNMENT(X, Y)
  LOGICAL, INTENT(OUT) :: X
  REAL, INTENT(IN) :: Y
 
  IF (Y < 0.0) THEN
    X = .FALSE.
  ELSE
    X = .TRUE.
  ENDIF
END SUBROUTINE MY_ASSIGNMENT

+-----------------------------End of Fortran 95------------------------------+

+-------------------------------IBM Extension--------------------------------+

+-------------------------------IBM Extension--------------------------------+

IF (ERROR_CONDITION) CALL ABORT

 /home/mark
IOT/Abort trap(coredump)

+----------------------------End of IBM Extension----------------------------+

! A is the array | 4 3 6 |, and B is the array | 3 5 2 |
!                | 2 4 1 |                     | 7 8 4 |
 
! Is every element in A less than the
! corresponding one in B?
      RES = ALL(A .LT. B)          ! result RES is false
 
! Are all elements in each column of A less than the
! corresponding column of B?
      RES = ALL(A .LT. B, DIM = 1) ! result RES is (f,t,f)
 
! Same question, but for each row of A and B.
      RES = ALL(A .LT. B, DIM = 2) ! result RES is (f,t)

INTEGER, ALLOCATABLE, DIMENSION(:) :: A
PRINT *, ALLOCATED(A)      ! A is not allocated yet.
ALLOCATE (A(1000))
PRINT *, ALLOCATED(A)      ! A is now allocated.
END

! A is the array | 9 -6 7 |, and B is the array | 2 7 8 |
!                | 3 -1 5 |                     | 5 6 9 |
 
! Is any element in A greater than or equal to the
! corresponding element in B?
      RES = ANY(A .GE. B)          ! result RES is true
 
! For each column in A, is there any element in the column
! greater than or equal to the corresponding element in B?
      RES = ANY(A .GE. B, DIM = 1) ! result RES is (t,f,f)
 
! Same question, but for each row of A and B.
      RES = ANY(A .GE. B, DIM = 2) ! result RES is (t,f)

REAL, POINTER, DIMENSION(:,:) :: A
REAL, TARGET, DIMENSION(5,10) :: B, C
 
NULLIFY (A)
PRINT *, ASSOCIATED (A)   ! False, not associated yet
 
A => B
PRINT *, ASSOCIATED (A)   ! True, because A is
                          ! associated with B
 
PRINT *, ASSOCIATED (A,C) ! False, A is not
                          ! associated with C
END

+-------------------------------IBM Extension--------------------------------+

    type                    bits
-----------                ------
 integer(1)                   08
 integer(2)                   16
 integer(4)                   32
 integer(8)                   64

+----------------------------End of IBM Extension----------------------------+

If A has the value
   | 1 2 |
   | 3 4 |
the value of BTEST (A, 2) is
   | false false |
   | false true  |
and the value of BTEST (2, A) is
   | true  false |
   | false false |

+---------------------------------Fortran 95---------------------------------+

+-----------------------------End of Fortran 95------------------------------+

CEILING(-3.7) has the value -3.
CEILING(3.7) has the value 4.
 

+---------------------------------Fortran 95---------------------------------+

CEILING(1000.1, KIND=2) has the value 1 001, with a kind type parameter of two.

+-----------------------------End of Fortran 95------------------------------+

! A is the array | T F F |, and B is the array | F F T |
!                | F T T |                     | T T T |
 
! How many corresponding elements in A and B
! are equivalent?
    RES = COUNT(A .EQV. B)        ! result RES is 3
 
! How many corresponding elements are equivalent
! in each column?
    RES = COUNT(A .EQV. B, DIM=1) ! result RES is (0,2,1)
 
! Same question, but for each row.
    RES = COUNT(A .EQV. B, DIM=2) ! result RES is (1,2)

+---------------------------------Fortran 95---------------------------------+

! The default value for cpu_time_type is used
REAL T1, T2
...         ! First chunk of code to be timed
CALL CPU_TIME(T1)
...         ! Second chunk of code to be timed
CALL CPU_TIME(T2)
print *, 'Time taken for first chunk of code: ', T1, 'seconds.'
print *, 'Time taken for both chunks of code: ', T2, 'seconds.'
print *, 'Time for second chunk of code was ', T2-T1, 'seconds.'

export XLFRTEOPTS=cpu_time_type=usertime

! Use setrteopts to set the cpu_time_type run-time option as many times
! as you need to
CALL setrteopts ('cpu_time_type=alltime')
CALL stallingloop
CALL CPU_TIME(T1)
print *, 'The sum of the user and system time is', T1, 'seconds'.
CALL setrteopts ('cpu_time_type=usertime')
CALL stallingloop
CALL CPU_TIME(T2)
print *, 'The total user time from the start of the program is', T2, 'seconds'.

+-----------------------------End of Fortran 95------------------------------+

! A is the array | A D G |
!                | B E H |
!                | C F I |
 
! Shift the first column down one, the second column
! up one, and leave the third column unchanged.
       RES = CSHIFT (A, SHIFT = (/-1,1,0/), DIM = 1)
! The result is | C E G |
!               | A F H |
!               | B D I |
 
! Do the same shifts as before, but on the rows
! instead of the columns.
       RES = CSHIFT (A, SHIFT = (/-1,1,0/), DIM = 2)
! The result is | G A D |
!               | E H B |
!               | C F I |

+-------------------------------IBM Extension--------------------------------+

MERGE ( TSOURCE, FSOURCE, arith_expr .op. 0 )
or
MERGE ( TSOURCE, FSOURCE, logical_expr .op. .TRUE. )

+----------------------------End of IBM Extension----------------------------+