Intrinsic Procedures
********************

Introduction to intrinsic procedures
====================================

The intrinsic procedures provided by GNU Fortran include all of the intrinsic procedures required by the Fortran 95 standard, a set of intrinsic procedures for backwards compatibility with G77, and a selection of intrinsic procedures from the Fortran 2003 and Fortran 2008 standards.  Any conflict between a description here and a description in either the Fortran 95 standard, the Fortran 2003 standard or the Fortran 2008 standard is unintentional, and the standard(s) should be considered authoritative.

The enumeration of the KIND type parameter is processor defined in the Fortran 95 standard.  GNU Fortran defines the default integer type and default real type by INTEGER(KIND=4) and REAL(KIND=4), respectively.  The standard mandates that both data types shall have another kind, which have more precision.  On typical target architectures supported by gfortran, this kind type parameter is KIND=8. Hence, REAL(KIND=8) and DOUBLE PRECISION are equivalent. In the description of generic intrinsic procedures, the kind type parameter will be specified by KIND=*, and in the description of specific names for an intrinsic procedure the kind type parameter will be explicitly given (e.g., REAL(KIND=4) or REAL(KIND=8)).  Finally, for brevity the optional KIND= syntax will be omitted.

Many of the intrinsic procedures take one or more optional arguments. This document follows the convention used in the Fortran 95 standard, and denotes such arguments by square brackets.

GNU Fortran offers the -std=f95 and -std=gnu options, which can be used to restrict the set of intrinsic procedures to a given standard.  By default, gfortran sets the -std=gnu option, and so all intrinsic procedures described here are accepted.  There is one caveat.  For a select group of intrinsic procedures, g77 implemented both a function and a subroutine.  Both classes have been implemented in gfortran for backwards compatibility with g77.  It is noted here that these functions and subroutines cannot be intermixed in a given subprogram.  In the descriptions that follow, the applicable standard for each intrinsic procedure is noted.

ABORT --- Abort the program
===========================

Description:
     ABORT causes immediate termination of the program.  On operating systems that support a core dump, ABORT will produce a core dump. It will also print a backtrace, unless -fno-backtrace is given.

Standard:
     GNU extension

Class:
     Subroutine

Syntax:
     CALL ABORT

Return value:
     Does not return.

Example:

          program test_abort
            integer :: i = 1, j = 2
            if (i /= j) call abort
          end program test_abort

See also:
     EXIT, KILL, BACKTRACE

ABS --- Absolute value
======================

Description:
     ABS(A) computes the absolute value of A.

Standard:
     Fortran 77 and later, has overloads that are GNU extensions

Class:
     Elemental function

Syntax:
     RESULT = ABS(A)

Arguments:

     A   The type of the argument shall be an INTEGER,
     REAL, or COMPLEX.

Return value:
     The return value is of the same type and kind as the argument except the return value is REAL for a COMPLEX argument.

Example:

          program test_abs
            integer :: i = -1
            real :: x = -1.e0
            complex :: z = (-1.e0,0.e0)
            i = abs(i)
            x = abs(x)
            x = abs(z)
          end program test_abs

Specific names:

     Name              Argument              Return type         Standard
     ABS(A)     REAL(4) A      REAL(4)      Fortran 77 and later
     CABS(A)    COMPLEX(4) A   REAL(4)      Fortran 77 and later
     DABS(A)    REAL(8) A      REAL(8)      Fortran 77 and later
     IABS(A)    INTEGER(4) A   INTEGER(4)   Fortran 77 and later
     BABS(A)   INTEGER(1) A   INTEGER(1)   GNU extension
     IIABS(A)   INTEGER(2) A   INTEGER(2)   GNU extension
     JIABS(A)   INTEGER(4) A   INTEGER(4)   GNU extension
     KIABS(A)   INTEGER(8) A   INTEGER(8)   GNU extension
     ZABS(A)    COMPLEX(8) A   COMPLEX(8)   GNU extension
     CDABS(A)   COMPLEX(8) A   COMPLEX(8)   GNU extension

ACCESS --- Checks file access modes
===================================

Description:
     ACCESS(NAME, MODE) checks whether the file NAME exists, is readable, writable or executable. Except for the executable check, ACCESS can be replaced by Fortran 95's INQUIRE.

Standard:
     GNU extension

Class:
     Inquiry function

Syntax:
     RESULT = ACCESS(NAME, MODE)

Arguments:

     NAME   Scalar CHARACTER of default kind with the
     file name. Tailing blank are ignored unless the character achar(0)
     is present, then all characters up to and excluding achar(0) are
     used as file name.
     MODE   Scalar CHARACTER of default kind with the
     file access mode, may be any concatenation of "r" (readable),
     "w" (writable) and "x" (executable), or " " to check
     for existence.

Return value:
     Returns a scalar INTEGER, which is 0 if the file is accessible in the given mode; otherwise or if an invalid argument has been given for MODE the value 1 is returned.

Example:

          program access_test
            implicit none
            character(len=*), parameter :: file  = 'test.dat'
            character(len=*), parameter :: file2 = 'test.dat  '//achar(0)
            if(access(file,' ') == 0) print *, trim(file),' is exists'
            if(access(file,'r') == 0) print *, trim(file),' is readable'
            if(access(file,'w') == 0) print *, trim(file),' is writable'
            if(access(file,'x') == 0) print *, trim(file),' is executable'
            if(access(file2,'rwx') == 0) &
              print *, trim(file2),' is readable, writable and executable'
          end program access_test

Specific names:

See also:

ACHAR --- Character in ASCII collating sequence
===============================================

Description:
     ACHAR(I) returns the character located at position I in the ASCII collating sequence.

Standard:
     Fortran 77 and later, with KIND argument Fortran 2003 and later

Class:
     Elemental function

Syntax:
     RESULT = ACHAR(I [, KIND])

Arguments:

     I      The type shall be INTEGER.
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     The return value is of type CHARACTER with a length of one. If the KIND argument is present, the return value is of the specified kind and of the default kind otherwise.

Example:

          program test_achar
            character c
            c = achar(32)
          end program test_achar

Note:
     See ICHAR for a discussion of converting between numerical values and formatted string representations.

See also:
     CHAR, IACHAR, ICHAR

ACOS --- Arccosine function
===========================

Description:
     ACOS(X) computes the arccosine of X (inverse of COS(X)).

Standard:
     Fortran 77 and later, for a complex argument Fortran 2008 or later

Class:
     Elemental function

Syntax:
     RESULT = ACOS(X)

Arguments:

     X   The type shall either be REAL with a magnitude that is
     less than or equal to one - or the type shall be COMPLEX.

Return value:
     The return value is of the same type and kind as X. The real part of the result is in radians and lies in the range 0 \leq \Re \acos(x) \leq \pi.

Example:

          program test_acos
            real(8) :: x = 0.866_8
            x = acos(x)
          end program test_acos

Specific names:

     Name              Argument           Return type       Standard
     ACOS(X)    REAL(4) X   REAL(4)    Fortran 77 and later
     DACOS(X)   REAL(8) X   REAL(8)    Fortran 77 and later

See also:
     Inverse function: COS Degrees function: ACOSD

ACOSD --- Arccosine function, degrees
=====================================

Description:
     ACOSD(X) computes the arccosine of X in degrees (inverse of COSD(X)).

     This function is for compatibility only and should be avoided in favor of standard constructs wherever possible.

Standard:
     GNU Extension, enabled with -fdec-math

Class:
     Elemental function

Syntax:
     RESULT = ACOSD(X)

Arguments:

     X   The type shall either be REAL with a magnitude that is
     less than or equal to one - or the type shall be COMPLEX.

Return value:
     The return value is of the same type and kind as X. The real part of the result is in degrees and lies in the range 0 \leq \Re \acos(x) \leq 180.

Example:

          program test_acosd
            real(8) :: x = 0.866_8
            x = acosd(x)
          end program test_acosd

Specific names:

     Name              Argument           Return type       Standard
     ACOSD(X)    REAL(4) X   REAL(4)    GNU Extension
     DACOSD(X)   REAL(8) X   REAL(8)    GNU Extension

See also:
     Inverse function: COSD Radians function: ACOS

ACOSH --- Inverse hyperbolic cosine function
============================================

Description:
     ACOSH(X) computes the inverse hyperbolic cosine of X.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = ACOSH(X)

Arguments:

     X   The type shall be REAL or COMPLEX.

Return value:
     The return value has the same type and kind as X. If X is complex, the imaginary part of the result is in radians and lies between 0 \leq \Im \acosh(x) \leq \pi.

Example:

          PROGRAM test_acosh
            REAL(8), DIMENSION(3) :: x = (/ 1.0, 2.0, 3.0 /)
            WRITE (*,*) ACOSH(x)
          END PROGRAM

Specific names:

     Name               Argument            Return type         Standard
     DACOSH(X)   REAL(8) X    REAL(8)      GNU extension

See also:
     Inverse function: COSH

ADJUSTL --- Left adjust a string
================================

Description:
     ADJUSTL(STRING) will left adjust a string by removing leading spaces. Spaces are inserted at the end of the string as needed.

Standard:
     Fortran 90 and later

Class:
     Elemental function

Syntax:
     RESULT = ADJUSTL(STRING)

Arguments:

     STRING   The type shall be CHARACTER.

Return value:
     The return value is of type CHARACTER and of the same kind as STRING where leading spaces are removed and the same number of spaces are inserted on the end of STRING.

Example:

          program test_adjustl
            character(len=20) :: str = '   gfortran'
            str = adjustl(str)
            print *, str
          end program test_adjustl

See also:
     ADJUSTR, TRIM

ADJUSTR --- Right adjust a string
=================================

Description:
     ADJUSTR(STRING) will right adjust a string by removing trailing spaces. Spaces are inserted at the start of the string as needed.

Standard:
     Fortran 95 and later

Class:
     Elemental function

Syntax:
     RESULT = ADJUSTR(STRING)

Arguments:

     STR   The type shall be CHARACTER.

Return value:
     The return value is of type CHARACTER and of the same kind as STRING where trailing spaces are removed and the same number of spaces are inserted at the start of STRING.

Example:

          program test_adjustr
            character(len=20) :: str = 'gfortran'
            str = adjustr(str)
            print *, str
          end program test_adjustr

See also:
     ADJUSTL, TRIM

AIMAG --- Imaginary part of complex number
==========================================

Description:
     AIMAG(Z) yields the imaginary part of complex argument Z. The IMAG(Z) and IMAGPART(Z) intrinsic functions are provided for compatibility with g77, and their use in new code is strongly discouraged.

Standard:
     Fortran 77 and later, has overloads that are GNU extensions

Class:
     Elemental function

Syntax:
     RESULT = AIMAG(Z)

Arguments:

     Z   The type of the argument shall be COMPLEX.

Return value:
     The return value is of type REAL with the kind type parameter of the argument.

Example:

          program test_aimag
            complex(4) z4
            complex(8) z8
            z4 = cmplx(1.e0_4, 0.e0_4)
            z8 = cmplx(0.e0_8, 1.e0_8)
            print *, aimag(z4), dimag(z8)
          end program test_aimag

Specific names:

     Name                 Argument              Return type       Standard
     AIMAG(Z)      COMPLEX Z      REAL       GNU extension
     DIMAG(Z)      COMPLEX(8) Z   REAL(8)    GNU extension
     IMAG(Z)       COMPLEX Z      REAL       GNU extension
     IMAGPART(Z)   COMPLEX Z      REAL       GNU extension

AINT --- Truncate to a whole number
===================================

Description:
     AINT(A [, KIND]) truncates its argument to a whole number.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = AINT(A [, KIND])

Arguments:

     A      The type of the argument shall be REAL.
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     The return value is of type REAL with the kind type parameter of the argument if the optional KIND is absent; otherwise, the kind type parameter will be given by KIND.  If the magnitude of X is less than one, AINT(X) returns zero.  If the magnitude is equal to or greater than one then it returns the largest whole number that does not exceed its magnitude.  The sign is the same as the sign of X.

Example:

          program test_aint
            real(4) x4
            real(8) x8
            x4 = 1.234E0_4
            x8 = 4.321_8
            print *, aint(x4), dint(x8)
            x8 = aint(x4,8)
          end program test_aint

Specific names:

     Name             Argument           Return type        Standard
     AINT(A)   REAL(4) A   REAL(4)     Fortran 77 and later
     DINT(A)   REAL(8) A   REAL(8)     Fortran 77 and later

ALARM --- Execute a routine after a given delay
===============================================

Description:
     ALARM(SECONDS, HANDLER [, STATUS]) causes external subroutine HANDLER to be executed after a delay of SECONDS by using alarm(2) to set up a signal and signal(2) to catch it. If STATUS is supplied, it will be returned with the number of seconds remaining until any previously scheduled alarm was due to be delivered, or zero if there was no previously scheduled alarm.

Standard:
     GNU extension

Class:
     Subroutine

Syntax:
     CALL ALARM(SECONDS, HANDLER [, STATUS])

Arguments:

     SECONDS   The type of the argument shall be a scalar
     INTEGER. It is INTENT(IN).
     HANDLER   Signal handler (INTEGER FUNCTION or
     SUBROUTINE) or dummy/global INTEGER scalar. The scalar
     values may be either SIG_IGN=1 to ignore the alarm generated
     or SIG_DFL=0 to set the default action. It is INTENT(IN).
     STATUS    (Optional) STATUS shall be a scalar
     variable of the default INTEGER kind. It is INTENT(OUT).

Example:

          program test_alarm
            external handler_print
            integer i
            call alarm (3, handler_print, i)
            print *, i
            call sleep(10)
          end program test_alarm

     This will cause the external routine HANDLER_PRINT to be called after 3 seconds.

ALL --- All values in MASK along DIM are true
=============================================

Description:
     ALL(MASK [, DIM]) determines if all the values are true in MASK in the array along dimension DIM.

Standard:
     Fortran 95 and later

Class:
     Transformational function

Syntax:
     RESULT = ALL(MASK [, DIM])

Arguments:

     MASK   The type of the argument shall be LOGICAL and
     it shall not be scalar.
     DIM    (Optional) DIM shall be a scalar integer
     with a value that lies between one and the rank of MASK.

Return value:
     ALL(MASK) returns a scalar value of type LOGICAL where the kind type parameter is the same as the kind type parameter of MASK.  If DIM is present, then ALL(MASK, DIM) returns an array with the rank of MASK minus 1.  The shape is determined from the shape of MASK where the DIM dimension is elided.

     (A)
          ALL(MASK) is true if all elements of MASK are true. It also is true if MASK has zero size; otherwise, it is false.

     (B)
          If the rank of MASK is one, then ALL(MASK,DIM) is equivalent to ALL(MASK).  If the rank is greater than one, then ALL(MASK,DIM) is determined by applying ALL to the array sections.

Example:

          program test_all
            logical l
            l = all((/.true., .true., .true./))
            print *, l
            call section
            contains
              subroutine section
                integer a(2,3), b(2,3)
                a = 1
                b = 1
                b(2,2) = 2
                print *, all(a .eq. b, 1)
                print *, all(a .eq. b, 2)
              end subroutine section
          end program test_all

ALLOCATED --- Status of an allocatable entity
=============================================

Description:
     ALLOCATED(ARRAY) and ALLOCATED(SCALAR) check the allocation status of ARRAY and SCALAR, respectively.

Standard:
     Fortran 95 and later.  Note, the SCALAR= keyword and allocatable scalar entities are available in Fortran 2003 and later.

Class:
     Inquiry function

Syntax:

     RESULT = ALLOCATED(ARRAY)
     RESULT = ALLOCATED(SCALAR)

Arguments:

     ARRAY      The argument shall be an ALLOCATABLE array.
     SCALAR     The argument shall be an ALLOCATABLE scalar.

Return value:
     The return value is a scalar LOGICAL with the default logical kind type parameter.  If the argument is allocated, then the result is .TRUE.; otherwise, it returns .FALSE.

Example:

          program test_allocated
            integer :: i = 4
            real(4), allocatable :: x(:)
            if (.not. allocated(x)) allocate(x(i))
          end program test_allocated

AND --- Bitwise logical AND
===========================

Description:
     Bitwise logical AND.

     This intrinsic routine is provided for backwards compatibility with GNU Fortran 77.  For integer arguments, programmers should consider the use of the IAND intrinsic defined by the Fortran standard.

Standard:
     GNU extension

Class:
     Function

Syntax:
     RESULT = AND(I, J)

Arguments:

     I   The type shall be either a scalar INTEGER
     type or a scalar LOGICAL type or a boz-literal-constant.
     J   The type shall be the same as the type of I or
     a boz-literal-constant. I and J shall not both be
     boz-literal-constants.  If either I or J is a
     boz-literal-constant, then the other argument must be a scalar INTEGER.

Return value:
     The return type is either a scalar INTEGER or a scalar LOGICAL.  If the kind type parameters differ, then the smaller kind type is implicitly converted to larger kind, and the return has the larger kind.  A boz-literal-constant is converted to an INTEGER with the kind type parameter of the other argument as-if a call to INT occurred.

Example:

          PROGRAM test_and
            LOGICAL :: T = .TRUE., F = .FALSE.
            INTEGER :: a, b
            DATA a / Z'F' /, b / Z'3' /

            WRITE (*,*) AND(T, T), AND(T, F), AND(F, T), AND(F, F)
            WRITE (*,*) AND(a, b)
          END PROGRAM

See also:
     Fortran 95 elemental function: IAND

ANINT --- Nearest whole number
==============================

Description:
     ANINT(A [, KIND]) rounds its argument to the nearest whole number.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = ANINT(A [, KIND])

Arguments:

     A      The type of the argument shall be REAL.
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     The return value is of type real with the kind type parameter of the argument if the optional KIND is absent; otherwise, the kind type parameter will be given by KIND.  If A is greater than zero, ANINT(A) returns AINT(X+0.5).  If A is less than or equal to zero then it returns AINT(X-0.5).

Example:

          program test_anint
            real(4) x4
            real(8) x8
            x4 = 1.234E0_4
            x8 = 4.321_8
            print *, anint(x4), dnint(x8)
            x8 = anint(x4,8)
          end program test_anint

Specific names:

     Name              Argument           Return type        Standard
     AINT(A)    REAL(4) A   REAL(4)     Fortran 77 and later
     DNINT(A)   REAL(8) A   REAL(8)     Fortran 77 and later

ANY --- Any value in MASK along DIM is true
===========================================

Description:
     ANY(MASK [, DIM]) determines if any of the values in the logical array MASK along dimension DIM are .TRUE..

Standard:
     Fortran 95 and later

Class:
     Transformational function

Syntax:
     RESULT = ANY(MASK [, DIM])

Arguments:

     MASK   The type of the argument shall be LOGICAL and
     it shall not be scalar.
     DIM    (Optional) DIM shall be a scalar integer
     with a value that lies between one and the rank of MASK.

Return value:
     ANY(MASK) returns a scalar value of type LOGICAL where the kind type parameter is the same as the kind type parameter of MASK.  If DIM is present, then ANY(MASK, DIM) returns an array with the rank of MASK minus 1.  The shape is determined from the shape of MASK where the DIM dimension is elided.

     (A)
          ANY(MASK) is true if any element of MASK is true; otherwise, it is false.  It also is false if MASK has zero size.

     (B)
          If the rank of MASK is one, then ANY(MASK,DIM) is equivalent to ANY(MASK).  If the rank is greater than one, then ANY(MASK,DIM) is determined by applying ANY to the array sections.

Example:

          program test_any
            logical l
            l = any((/.true., .true., .true./))
            print *, l
            call section
            contains
              subroutine section
                integer a(2,3), b(2,3)
                a = 1
                b = 1
                b(2,2) = 2
                print *, any(a .eq. b, 1)
                print *, any(a .eq. b, 2)
              end subroutine section
          end program test_any

ASIN --- Arcsine function
=========================

Description:
     ASIN(X) computes the arcsine of its X (inverse of SIN(X)).

Standard:
     Fortran 77 and later, for a complex argument Fortran 2008 or later

Class:
     Elemental function

Syntax:
     RESULT = ASIN(X)

Arguments:

     X   The type shall be either REAL and a magnitude that is
     less than or equal to one - or be COMPLEX.

Return value:
     The return value is of the same type and kind as X. The real part of the result is in radians and lies in the range -\pi/2 \leq \Re \asin(x) \leq \pi/2.

Example:

          program test_asin
            real(8) :: x = 0.866_8
            x = asin(x)
          end program test_asin

Specific names:

     Name              Argument            Return type         Standard
     ASIN(X)    REAL(4) X    REAL(4)      Fortran 77 and later
     DASIN(X)   REAL(8) X    REAL(8)      Fortran 77 and later

See also:
     Inverse function: SIN Degrees function: ASIND

ASIND --- Arcsine function, degrees
===================================

Description:
     ASIND(X) computes the arcsine of its X in degrees (inverse of SIND(X)).

     This function is for compatibility only and should be avoided in favor of standard constructs wherever possible.

Standard:
     GNU Extension, enabled with -fdec-math.

Class:
     Elemental function

Syntax:
     RESULT = ASIND(X)

Arguments:

     X   The type shall be either REAL and a magnitude that is
     less than or equal to one - or be COMPLEX.

Return value:
     The return value is of the same type and kind as X. The real part of the result is in degrees and lies in the range -90 \leq \Re \asin(x) \leq 90.

Example:

          program test_asind
            real(8) :: x = 0.866_8
            x = asind(x)
          end program test_asind

Specific names:

     Name              Argument            Return type         Standard
     ASIND(X)    REAL(4) X    REAL(4)      GNU Extension
     DASIND(X)   REAL(8) X    REAL(8)      GNU Extension

See also:
     Inverse function: SIND Radians function: ASIN

ASINH --- Inverse hyperbolic sine function
==========================================

Description:
     ASINH(X) computes the inverse hyperbolic sine of X.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = ASINH(X)

Arguments:

     X   The type shall be REAL or COMPLEX.

Return value:
     The return value is of the same type and kind as  X. If X is complex, the imaginary part of the result is in radians and lies between -\pi/2 \leq \Im \asinh(x) \leq \pi/2.

Example:

          PROGRAM test_asinh
            REAL(8), DIMENSION(3) :: x = (/ -1.0, 0.0, 1.0 /)
            WRITE (*,*) ASINH(x)
          END PROGRAM

Specific names:

     Name               Argument            Return type         Standard
     DASINH(X)   REAL(8) X    REAL(8)      GNU extension.

See also:
     Inverse function: SINH

ASSOCIATED --- Status of a pointer or pointer/target pair
=========================================================

Description:
     ASSOCIATED(POINTER [, TARGET]) determines the status of the pointer POINTER or if POINTER is associated with the target TARGET.

Standard:
     Fortran 95 and later

Class:
     Inquiry function

Syntax:
     RESULT = ASSOCIATED(POINTER [, TARGET])

Arguments:

     POINTER   POINTER shall have the POINTER attribute
     and it can be of any type.
     TARGET   (Optional) TARGET shall be a pointer or
     a target.  It must have the same type, kind type parameter, and
     array rank as POINTER.

     The association status of neither POINTER nor TARGET shall be undefined.

Return value:
     ASSOCIATED(POINTER) returns a scalar value of type LOGICAL(4). There are several cases:

     (A) When the optional TARGET is not present then
          ASSOCIATED(POINTER) is true if POINTER is associated with a target; otherwise, it returns false.

     (B) If TARGET is present and a scalar target, the result is true if
          TARGET is not a zero-sized storage sequence and the target associated with POINTER occupies the same storage units.  If POINTER is disassociated, the result is false.

     (C) If TARGET is present and an array target, the result is true if
          TARGET and POINTER have the same shape, are not zero-sized arrays, are arrays whose elements are not zero-sized storage sequences, and TARGET and POINTER occupy the same storage units in array element order. As in case(B), the result is false, if POINTER is disassociated.

     (D) If TARGET is present and an scalar pointer, the result is true
          if TARGET is associated with POINTER, the target associated with TARGET are not zero-sized storage sequences and occupy the same storage units. The result is false, if either TARGET or POINTER is disassociated.

     (E) If TARGET is present and an array pointer, the result is true if
          target associated with POINTER and the target associated with TARGET have the same shape, are not zero-sized arrays, are arrays whose elements are not zero-sized storage sequences, and TARGET and POINTER occupy the same storage units in array element order. The result is false, if either TARGET or POINTER is disassociated.

Example:

          program test_associated
             implicit none
             real, target  :: tgt(2) = (/1., 2./)
             real, pointer :: ptr(:)
             ptr => tgt
             if (associated(ptr)     .eqv. .false.) call abort
             if (associated(ptr,tgt) .eqv. .false.) call abort
          end program test_associated

See also:
     NULL

ATAN --- Arctangent function
============================

Description:
     ATAN(X) computes the arctangent of X.

Standard:
     Fortran 77 and later, for a complex argument and for two arguments Fortran 2008 or later

Class:
     Elemental function

Syntax:

     RESULT = ATAN(X)
     RESULT = ATAN(Y, X)

Arguments:

     X   The type shall be REAL or COMPLEX;
     if Y is present, X shall be REAL.
     Y shall be of the same type and kind as X.

Return value:
     The return value is of the same type and kind as X. If Y is present, the result is identical to ATAN2(Y,X). Otherwise, it the arcus tangent of X, where the real part of the result is in radians and lies in the range -\pi/2 \leq \Re \atan(x) \leq \pi/2.

Example:

          program test_atan
            real(8) :: x = 2.866_8
            x = atan(x)
          end program test_atan

Specific names:

     Name              Argument            Return type         Standard
     ATAN(X)    REAL(4) X    REAL(4)      Fortran 77 and later
     DATAN(X)   REAL(8) X    REAL(8)      Fortran 77 and later

See also:
     Inverse function: TAN Degrees function: ATAND

ATAND --- Arctangent function, degrees
======================================

Description:
     ATAND(X) computes the arctangent of X in degrees (inverse of TAND).

     This function is for compatibility only and should be avoided in favor of standard constructs wherever possible.

Standard:
     GNU Extension, enabled with -fdec-math.

Class:
     Elemental function

Syntax:

     RESULT = ATAND(X)
     RESULT = ATAND(Y, X)

Arguments:

     X   The type shall be REAL or COMPLEX;
     if Y is present, X shall be REAL.
     Y shall be of the same type and kind as X.

Return value:
     The return value is of the same type and kind as X. If Y is present, the result is identical to ATAND2(Y,X). Otherwise, it is the arcus tangent of X, where the real part of the result is in degrees and lies in the range -90 \leq \Re \atand(x) \leq 90.

Example:

          program test_atand
            real(8) :: x = 2.866_8
            x = atand(x)
          end program test_atand

Specific names:

     Name              Argument            Return type         Standard
     ATAND(X)    REAL(4) X    REAL(4)      GNU Extension
     DATAND(X)   REAL(8) X    REAL(8)      GNU Extension

See also:
     Inverse function: TAND Radians function: ATAN

ATAN2 --- Arctangent function
=============================

Description:
     ATAN2(Y, X) computes the principal value of the argument function of the complex number X + i Y.  This function can be used to transform from Cartesian into polar coordinates and allows to determine the angle in the correct quadrant.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = ATAN2(Y, X)

Arguments:

     Y   The type shall be REAL.
     X   The type and kind type parameter shall be the same as Y.
     If Y is zero, then X must be nonzero.

Return value:
     The return value has the same type and kind type parameter as Y. It is the principal value of the complex number X + i Y.  If X is nonzero, then it lies in the range -\pi \le \atan (x) \leq \pi. The sign is positive if Y is positive.  If Y is zero, then the return value is zero if X is strictly positive, \pi if X is negative and Y is positive zero (or the processor does not handle signed zeros), and -\pi if X is negative and Y is negative zero.  Finally, if X is zero, then the magnitude of the result is \pi/2.

Example:

          program test_atan2
            real(4) :: x = 1.e0_4, y = 0.5e0_4
            x = atan2(y,x)
          end program test_atan2

Specific names:

     Name                  Argument              Return type      Standard
     ATAN2(X, Y)    REAL(4) X, Y   REAL(4)   Fortran 77 and later
     DATAN2(X, Y)   REAL(8) X, Y   REAL(8)   Fortran 77 and later

See also:
     Alias: ATAN Degrees function: ATAN2D

ATAN2D --- Arctangent function, degrees
=======================================

Description:
     ATAN2D(Y, X) computes the principal value of the argument function of the complex number X + i Y in degrees.  This function can be used to transform from Cartesian into polar coordinates and allows to determine the angle in the correct quadrant.

     This function is for compatibility only and should be avoided in favor of standard constructs wherever possible.

Standard:
     GNU Extension, enabled with -fdec-math.

Class:
     Elemental function

Syntax:
     RESULT = ATAN2D(Y, X)

Arguments:

     Y   The type shall be REAL.
     X   The type and kind type parameter shall be the same as Y.
     If Y is zero, then X must be nonzero.

Return value:
     The return value has the same type and kind type parameter as Y. It is the principal value of the complex number X + i Y.  If X is nonzero, then it lies in the range -180 \le \atan (x) \leq 180. The sign is positive if Y is positive.  If Y is zero, then the return value is zero if X is strictly positive, 180 if X is negative and Y is positive zero (or the processor does not handle signed zeros), and -180 if X is negative and Y is negative zero.  Finally, if X is zero, then the magnitude of the result is 90.

Example:

          program test_atan2d
            real(4) :: x = 1.e0_4, y = 0.5e0_4
            x = atan2d(y,x)
          end program test_atan2d

Specific names:

     Name                  Argument              Return type      Standard
     ATAN2D(X, Y)    REAL(4) X, Y   REAL(4)   GNU Extension
     DATAN2D(X, Y)   REAL(8) X, Y   REAL(8)   GNU Extension

See also:
     Alias: ATAND Radians function: ATAN2

ATANH --- Inverse hyperbolic tangent function
=============================================

Description:
     ATANH(X) computes the inverse hyperbolic tangent of X.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = ATANH(X)

Arguments:

     X   The type shall be REAL or COMPLEX.

Return value:
     The return value has same type and kind as X. If X is complex, the imaginary part of the result is in radians and lies between -\pi/2 \leq \Im \atanh(x) \leq \pi/2.

Example:

          PROGRAM test_atanh
            REAL, DIMENSION(3) :: x = (/ -1.0, 0.0, 1.0 /)
            WRITE (*,*) ATANH(x)
          END PROGRAM

Specific names:

     Name               Argument            Return type         Standard
     DATANH(X)   REAL(8) X    REAL(8)      GNU extension

See also:
     Inverse function: TANH

ATOMIC_ADD --- Atomic ADD operation
===================================

Description:
     ATOMIC_ADD(ATOM, VALUE) atomically adds the value of VAR to the variable ATOM. When STAT is present and the invocation was successful, it is assigned the value 0. If it is present and the invocation has failed, it is assigned a positive value; in particular, for a coindexed ATOM, if the remote image has stopped, it is assigned the value of ISO_FORTRAN_ENV's STAT_STOPPED_IMAGE and if the remote image has failed, the value STAT_FAILED_IMAGE.

Standard:
     TS 18508 or later

Class:
     Atomic subroutine

Syntax:
     CALL ATOMIC_ADD (ATOM, VALUE [, STAT])

Arguments:

     ATOM     Scalar coarray or coindexed variable of integer
     type with ATOMIC_INT_KIND kind.
     VALUE    Scalar of the same type as ATOM. If the kind
     is different, the value is converted to the kind of ATOM.
     STAT     (optional) Scalar default-kind integer variable.

Example:

          program atomic
            use iso_fortran_env
            integer(atomic_int_kind) :: atom[*]
            call atomic_add (atom[1], this_image())
          end program atomic

See also:
     ATOMIC_DEFINE, ATOMIC_FETCH_ADD, ISO_FORTRAN_ENV, ATOMIC_AND, ATOMIC_OR, ATOMIC_XOR

ATOMIC_AND --- Atomic bitwise AND operation
===========================================

Description:
     ATOMIC_AND(ATOM, VALUE) atomically defines ATOM with the bitwise AND between the values of ATOM and VALUE. When STAT is present and the invocation was successful, it is assigned the value 0. If it is present and the invocation has failed, it is assigned a positive value; in particular, for a coindexed ATOM, if the remote image has stopped, it is assigned the value of ISO_FORTRAN_ENV's STAT_STOPPED_IMAGE and if the remote image has failed, the value STAT_FAILED_IMAGE.

Standard:
     TS 18508 or later

Class:
     Atomic subroutine

Syntax:
     CALL ATOMIC_AND (ATOM, VALUE [, STAT])

Arguments:

     ATOM     Scalar coarray or coindexed variable of integer
     type with ATOMIC_INT_KIND kind.
     VALUE    Scalar of the same type as ATOM. If the kind
     is different, the value is converted to the kind of ATOM.
     STAT     (optional) Scalar default-kind integer variable.

Example:

          program atomic
            use iso_fortran_env
            integer(atomic_int_kind) :: atom[*]
            call atomic_and (atom[1], int(b'10100011101'))
          end program atomic

See also:
     ATOMIC_DEFINE, ATOMIC_FETCH_AND, ISO_FORTRAN_ENV, ATOMIC_ADD, ATOMIC_OR, ATOMIC_XOR

ATOMIC_CAS --- Atomic compare and swap
======================================

Description:
     ATOMIC_CAS compares the variable ATOM with the value of COMPARE; if the value is the same, ATOM is set to the value of NEW. Additionally, OLD is set to the value of ATOM that was used for the comparison.  When STAT is present and the invocation was successful, it is assigned the value 0. If it is present and the invocation has failed, it is assigned a positive value; in particular, for a coindexed ATOM, if the remote image has stopped, it is assigned the value of ISO_FORTRAN_ENV's STAT_STOPPED_IMAGE and if the remote image has failed, the value STAT_FAILED_IMAGE.

Standard:
     TS 18508 or later

Class:
     Atomic subroutine

Syntax:
     CALL ATOMIC_CAS (ATOM, OLD, COMPARE, NEW [, STAT])

Arguments:

     ATOM      Scalar coarray or coindexed variable of either integer
     type with ATOMIC_INT_KIND kind or logical type with
     ATOMIC_LOGICAL_KIND kind.
     OLD       Scalar of the same type and kind as ATOM.
     COMPARE   Scalar variable of the same type and kind as
     ATOM.
     NEW       Scalar variable of the same type as ATOM. If kind
     is different, the value is converted to the kind of ATOM.
     STAT      (optional) Scalar default-kind integer variable.

Example:

          program atomic
            use iso_fortran_env
            logical(atomic_logical_kind) :: atom[*], prev
            call atomic_cas (atom[1], prev, .false., .true.))
          end program atomic

See also:
     ATOMIC_DEFINE, ATOMIC_REF, ISO_FORTRAN_ENV

ATOMIC_DEFINE --- Setting a variable atomically
===============================================

Description:
     ATOMIC_DEFINE(ATOM, VALUE) defines the variable ATOM with the value VALUE atomically. When STAT is present and the invocation was successful, it is assigned the value 0. If it is present and the invocation has failed, it is assigned a positive value; in particular, for a coindexed ATOM, if the remote image has stopped, it is assigned the value of ISO_FORTRAN_ENV's STAT_STOPPED_IMAGE and if the remote image has failed, the value STAT_FAILED_IMAGE.

Standard:
     Fortran 2008 and later; with STAT, TS 18508 or later

Class:
     Atomic subroutine

Syntax:
     CALL ATOMIC_DEFINE (ATOM, VALUE [, STAT])

Arguments:

     ATOM     Scalar coarray or coindexed variable of either integer
     type with ATOMIC_INT_KIND kind or logical type with
     ATOMIC_LOGICAL_KIND kind.

     VALUE    Scalar of the same type as ATOM. If the kind
     is different, the value is converted to the kind of ATOM.
     STAT     (optional) Scalar default-kind integer variable.

Example:

          program atomic
            use iso_fortran_env
            integer(atomic_int_kind) :: atom[*]
            call atomic_define (atom[1], this_image())
          end program atomic

See also:
     ATOMIC_REF, ATOMIC_CAS, ISO_FORTRAN_ENV, ATOMIC_ADD, ATOMIC_AND, ATOMIC_OR, ATOMIC_XOR

ATOMIC_FETCH_ADD --- Atomic ADD operation with prior fetch
==========================================================

Description:
     ATOMIC_FETCH_ADD(ATOM, VALUE, OLD) atomically stores the value of ATOM in OLD and adds the value of VAR to the variable ATOM. When STAT is present and the invocation was successful, it is assigned the value 0. If it is present and the invocation has failed, it is assigned a positive value; in particular, for a coindexed ATOM, if the remote image has stopped, it is assigned the value of ISO_FORTRAN_ENV's STAT_STOPPED_IMAGE and if the remote image has failed, the value STAT_FAILED_IMAGE.

Standard:
     TS 18508 or later

Class:
     Atomic subroutine

Syntax:
     CALL ATOMIC_FETCH_ADD (ATOM, VALUE, old [, STAT])

Arguments:

     ATOM     Scalar coarray or coindexed variable of integer
     type with ATOMIC_INT_KIND kind.
     ATOMIC_LOGICAL_KIND kind.

     VALUE    Scalar of the same type as ATOM. If the kind
     is different, the value is converted to the kind of ATOM.
     OLD      Scalar of the same type and kind as ATOM.
     STAT     (optional) Scalar default-kind integer variable.

Example:

          program atomic
            use iso_fortran_env
            integer(atomic_int_kind) :: atom[*], old
            call atomic_add (atom[1], this_image(), old)
          end program atomic

See also:
     ATOMIC_DEFINE, ATOMIC_ADD, ISO_FORTRAN_ENV, ATOMIC_FETCH_AND, ATOMIC_FETCH_OR, ATOMIC_FETCH_XOR

ATOMIC_FETCH_AND --- Atomic bitwise AND operation with prior fetch
==================================================================

Description:
     ATOMIC_AND(ATOM, VALUE) atomically stores the value of ATOM in OLD and defines ATOM with the bitwise AND between the values of ATOM and VALUE. When STAT is present and the invocation was successful, it is assigned the value 0. If it is present and the invocation has failed, it is assigned a positive value; in particular, for a coindexed ATOM, if the remote image has stopped, it is assigned the value of ISO_FORTRAN_ENV's STAT_STOPPED_IMAGE and if the remote image has failed, the value STAT_FAILED_IMAGE.

Standard:
     TS 18508 or later

Class:
     Atomic subroutine

Syntax:
     CALL ATOMIC_FETCH_AND (ATOM, VALUE, OLD [, STAT])

Arguments:

     ATOM     Scalar coarray or coindexed variable of integer
     type with ATOMIC_INT_KIND kind.
     VALUE    Scalar of the same type as ATOM. If the kind
     is different, the value is converted to the kind of ATOM.
     OLD      Scalar of the same type and kind as ATOM.
     STAT     (optional) Scalar default-kind integer variable.

Example:

          program atomic
            use iso_fortran_env
            integer(atomic_int_kind) :: atom[*], old
            call atomic_fetch_and (atom[1], int(b'10100011101'), old)
          end program atomic

See also:
     ATOMIC_DEFINE, ATOMIC_AND, ISO_FORTRAN_ENV, ATOMIC_FETCH_ADD, ATOMIC_FETCH_OR, ATOMIC_FETCH_XOR

ATOMIC_FETCH_OR --- Atomic bitwise OR operation with prior fetch
================================================================

Description:
     ATOMIC_OR(ATOM, VALUE) atomically stores the value of ATOM in OLD and defines ATOM with the bitwise OR between the values of ATOM and VALUE. When STAT is present and the invocation was successful, it is assigned the value 0. If it is present and the invocation has failed, it is assigned a positive value; in particular, for a coindexed ATOM, if the remote image has stopped, it is assigned the value of ISO_FORTRAN_ENV's STAT_STOPPED_IMAGE and if the remote image has failed, the value STAT_FAILED_IMAGE.

Standard:
     TS 18508 or later

Class:
     Atomic subroutine

Syntax:
     CALL ATOMIC_FETCH_OR (ATOM, VALUE, OLD [, STAT])

Arguments:

     ATOM     Scalar coarray or coindexed variable of integer
     type with ATOMIC_INT_KIND kind.
     VALUE    Scalar of the same type as ATOM. If the kind
     is different, the value is converted to the kind of ATOM.
     OLD      Scalar of the same type and kind as ATOM.
     STAT     (optional) Scalar default-kind integer variable.

Example:

          program atomic
            use iso_fortran_env
            integer(atomic_int_kind) :: atom[*], old
            call atomic_fetch_or (atom[1], int(b'10100011101'), old)
          end program atomic

See also:
     ATOMIC_DEFINE, ATOMIC_OR, ISO_FORTRAN_ENV, ATOMIC_FETCH_ADD, ATOMIC_FETCH_AND, ATOMIC_FETCH_XOR

ATOMIC_FETCH_XOR --- Atomic bitwise XOR operation with prior fetch
==================================================================

Description:
     ATOMIC_XOR(ATOM, VALUE) atomically stores the value of ATOM in OLD and defines ATOM with the bitwise XOR between the values of ATOM and VALUE. When STAT is present and the invocation was successful, it is assigned the value 0. If it is present and the invocation has failed, it is assigned a positive value; in particular, for a coindexed ATOM, if the remote image has stopped, it is assigned the value of ISO_FORTRAN_ENV's STAT_STOPPED_IMAGE and if the remote image has failed, the value STAT_FAILED_IMAGE.

Standard:
     TS 18508 or later

Class:
     Atomic subroutine

Syntax:
     CALL ATOMIC_FETCH_XOR (ATOM, VALUE, OLD [, STAT])

Arguments:

     ATOM     Scalar coarray or coindexed variable of integer
     type with ATOMIC_INT_KIND kind.
     VALUE    Scalar of the same type as ATOM. If the kind
     is different, the value is converted to the kind of ATOM.
     OLD      Scalar of the same type and kind as ATOM.
     STAT     (optional) Scalar default-kind integer variable.

Example:

          program atomic
            use iso_fortran_env
            integer(atomic_int_kind) :: atom[*], old
            call atomic_fetch_xor (atom[1], int(b'10100011101'), old)
          end program atomic

See also:
     ATOMIC_DEFINE, ATOMIC_XOR, ISO_FORTRAN_ENV, ATOMIC_FETCH_ADD, ATOMIC_FETCH_AND, ATOMIC_FETCH_OR

ATOMIC_OR --- Atomic bitwise OR operation
=========================================

Description:
     ATOMIC_OR(ATOM, VALUE) atomically defines ATOM with the bitwise AND between the values of ATOM and VALUE. When STAT is present and the invocation was successful, it is assigned the value 0. If it is present and the invocation has failed, it is assigned a positive value; in particular, for a coindexed ATOM, if the remote image has stopped, it is assigned the value of ISO_FORTRAN_ENV's STAT_STOPPED_IMAGE and if the remote image has failed, the value STAT_FAILED_IMAGE.

Standard:
     TS 18508 or later

Class:
     Atomic subroutine

Syntax:
     CALL ATOMIC_OR (ATOM, VALUE [, STAT])

Arguments:

     ATOM     Scalar coarray or coindexed variable of integer
     type with ATOMIC_INT_KIND kind.
     VALUE    Scalar of the same type as ATOM. If the kind
     is different, the value is converted to the kind of ATOM.
     STAT     (optional) Scalar default-kind integer variable.

Example:

          program atomic
            use iso_fortran_env
            integer(atomic_int_kind) :: atom[*]
            call atomic_or (atom[1], int(b'10100011101'))
          end program atomic

See also:
     ATOMIC_DEFINE, ATOMIC_FETCH_OR, ISO_FORTRAN_ENV, ATOMIC_ADD, ATOMIC_OR, ATOMIC_XOR

ATOMIC_REF --- Obtaining the value of a variable atomically
===========================================================

Description:
     ATOMIC_DEFINE(ATOM, VALUE) atomically assigns the value of the variable ATOM to VALUE. When STAT is present and the invocation was successful, it is assigned the value 0. If it is present and the invocation has failed, it is assigned a positive value; in particular, for a coindexed ATOM, if the remote image has stopped, it is assigned the value of ISO_FORTRAN_ENV's STAT_STOPPED_IMAGE and if the remote image has failed, the value STAT_FAILED_IMAGE.

Standard:
     Fortran 2008 and later; with STAT, TS 18508 or later

Class:
     Atomic subroutine

Syntax:
     CALL ATOMIC_REF(VALUE, ATOM [, STAT])

Arguments:

     VALUE    Scalar of the same type as ATOM. If the kind
     is different, the value is converted to the kind of ATOM.
     ATOM     Scalar coarray or coindexed variable of either integer
     type with ATOMIC_INT_KIND kind or logical type with
     ATOMIC_LOGICAL_KIND kind.
     STAT     (optional) Scalar default-kind integer variable.

Example:

          program atomic
            use iso_fortran_env
            logical(atomic_logical_kind) :: atom[*]
            logical :: val
            call atomic_ref (atom, .false.)
            ! ...
            call atomic_ref (atom, val)
            if (val) then
              print *, "Obtained"
            end if
          end program atomic

See also:
     ATOMIC_DEFINE, ATOMIC_CAS, ISO_FORTRAN_ENV, ATOMIC_FETCH_ADD, ATOMIC_FETCH_AND, ATOMIC_FETCH_OR, ATOMIC_FETCH_XOR

ATOMIC_XOR --- Atomic bitwise OR operation
==========================================

Description:
     ATOMIC_AND(ATOM, VALUE) atomically defines ATOM with the bitwise XOR between the values of ATOM and VALUE. When STAT is present and the invocation was successful, it is assigned the value 0. If it is present and the invocation has failed, it is assigned a positive value; in particular, for a coindexed ATOM, if the remote image has stopped, it is assigned the value of ISO_FORTRAN_ENV's STAT_STOPPED_IMAGE and if the remote image has failed, the value STAT_FAILED_IMAGE.

Standard:
     TS 18508 or later

Class:
     Atomic subroutine

Syntax:
     CALL ATOMIC_XOR (ATOM, VALUE [, STAT])

Arguments:

     ATOM     Scalar coarray or coindexed variable of integer
     type with ATOMIC_INT_KIND kind.
     VALUE    Scalar of the same type as ATOM. If the kind
     is different, the value is converted to the kind of ATOM.
     STAT     (optional) Scalar default-kind integer variable.

Example:

          program atomic
            use iso_fortran_env
            integer(atomic_int_kind) :: atom[*]
            call atomic_xor (atom[1], int(b'10100011101'))
          end program atomic

See also:
     ATOMIC_DEFINE, ATOMIC_FETCH_XOR, ISO_FORTRAN_ENV, ATOMIC_ADD, ATOMIC_OR, ATOMIC_XOR

BACKTRACE --- Show a backtrace
==============================

Description:
     BACKTRACE shows a backtrace at an arbitrary place in user code. Program execution continues normally afterwards. The backtrace information is printed to the unit corresponding to ERROR_UNIT in ISO_FORTRAN_ENV.

Standard:
     GNU Extension

Class:
     Subroutine

Syntax:
     CALL BACKTRACE

Arguments:
     None

See also:
     ABORT

BESSEL_J0 --- Bessel function of the first kind of order 0
==========================================================

Description:
     BESSEL_J0(X) computes the Bessel function of the first kind of order 0 of X. This function is available under the name BESJ0 as a GNU extension.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = BESSEL_J0(X)

Arguments:

     X   The type shall be REAL.

Return value:
     The return value is of type REAL and lies in the range  - 0.4027... \leq Bessel (0,x) \leq 1. It has the same kind as X.

Example:

          program test_besj0
            real(8) :: x = 0.0_8
            x = bessel_j0(x)
          end program test_besj0

Specific names:

     Name              Argument            Return type         Standard
     DBESJ0(X)   REAL(8) X    REAL(8)     GNU extension

BESSEL_J1 --- Bessel function of the first kind of order 1
==========================================================

Description:
     BESSEL_J1(X) computes the Bessel function of the first kind of order 1 of X. This function is available under the name BESJ1 as a GNU extension.

Standard:
     Fortran 2008

Class:
     Elemental function

Syntax:
     RESULT = BESSEL_J1(X)

Arguments:

     X   The type shall be REAL.

Return value:
     The return value is of type REAL and lies in the range  - 0.5818... \leq Bessel (0,x) \leq 0.5818 . It has the same kind as X.

Example:

          program test_besj1
            real(8) :: x = 1.0_8
            x = bessel_j1(x)
          end program test_besj1

Specific names:

     Name               Argument            Return type         Standard
     DBESJ1(X)   REAL(8) X    REAL(8)      GNU extension

BESSEL_JN --- Bessel function of the first kind
===============================================

Description:
     BESSEL_JN(N, X) computes the Bessel function of the first kind of order N of X. This function is available under the name BESJN as a GNU extension.  If N and X are arrays, their ranks and shapes shall conform.

     BESSEL_JN(N1, N2, X) returns an array with the Bessel functions of the first kind of the orders N1 to N2.

Standard:
     Fortran 2008 and later, negative N is allowed as GNU extension

Class:
     Elemental function, except for the transformational function BESSEL_JN(N1, N2, X)

Syntax:

     RESULT = BESSEL_JN(N, X)
     RESULT = BESSEL_JN(N1, N2, X)

Arguments:

     N   Shall be a scalar or an array of type  INTEGER.
     N1   Shall be a non-negative scalar of type  INTEGER.
     N2   Shall be a non-negative scalar of type  INTEGER.
     X   Shall be a scalar or an array of type  REAL;
     for BESSEL_JN(N1, N2, X) it shall be scalar.

Return value:
     The return value is a scalar of type REAL. It has the same kind as X.

Note:
     The transformational function uses a recurrence algorithm which might, for some values of X, lead to different results than calls to the elemental function.

Example:

          program test_besjn
            real(8) :: x = 1.0_8
            x = bessel_jn(5,x)
          end program test_besjn

Specific names:

     Name                  Argument              Return type         Standard
     DBESJN(N, X)   INTEGER N      REAL(8)      GNU extension
       REAL(8) X

BESSEL_Y0 --- Bessel function of the second kind of order 0
===========================================================

Description:
     BESSEL_Y0(X) computes the Bessel function of the second kind of order 0 of X. This function is available under the name BESY0 as a GNU extension.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = BESSEL_Y0(X)

Arguments:

     X   The type shall be REAL.

Return value:
     The return value is of type REAL. It has the same kind as X.

Example:

          program test_besy0
            real(8) :: x = 0.0_8
            x = bessel_y0(x)
          end program test_besy0

Specific names:

     Name              Argument            Return type         Standard
     DBESY0(X)  REAL(8) X    REAL(8)      GNU extension

BESSEL_Y1 --- Bessel function of the second kind of order 1
===========================================================

Description:
     BESSEL_Y1(X) computes the Bessel function of the second kind of order 1 of X. This function is available under the name BESY1 as a GNU extension.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = BESSEL_Y1(X)

Arguments:

     X   The type shall be REAL.

Return value:
     The return value is of type REAL. It has the same kind as X.

Example:

          program test_besy1
            real(8) :: x = 1.0_8
            x = bessel_y1(x)
          end program test_besy1

Specific names:

     Name              Argument            Return type         Standard
     DBESY1(X)  REAL(8) X    REAL(8)      GNU extension

BESSEL_YN --- Bessel function of the second kind
================================================

Description:
     BESSEL_YN(N, X) computes the Bessel function of the second kind of order N of X. This function is available under the name BESYN as a GNU extension.  If N and X are arrays, their ranks and shapes shall conform.

     BESSEL_YN(N1, N2, X) returns an array with the Bessel functions of the first kind of the orders N1 to N2.

Standard:
     Fortran 2008 and later, negative N is allowed as GNU extension

Class:
     Elemental function, except for the transformational function BESSEL_YN(N1, N2, X)

Syntax:

     RESULT = BESSEL_YN(N, X)
     RESULT = BESSEL_YN(N1, N2, X)

Arguments:

     N   Shall be a scalar or an array of type  INTEGER .
     N1   Shall be a non-negative scalar of type  INTEGER.
     N2   Shall be a non-negative scalar of type  INTEGER.
     X   Shall be a scalar or an array of type  REAL;
     for BESSEL_YN(N1, N2, X) it shall be scalar.

Return value:
     The return value is a scalar of type REAL. It has the same kind as X.

Note:
     The transformational function uses a recurrence algorithm which might, for some values of X, lead to different results than calls to the elemental function.

Example:

          program test_besyn
            real(8) :: x = 1.0_8
            x = bessel_yn(5,x)
          end program test_besyn

Specific names:

     Name                 Argument              Return type       Standard
     DBESYN(N,X)   INTEGER N   REAL(8)    GNU extension
       REAL(8) X

BGE --- Bitwise greater than or equal to
========================================

Description:
     Determines whether an integral is a bitwise greater than or equal to another.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = BGE(I, J)

Arguments:

     I   Shall be of INTEGER type.
     J   Shall be of INTEGER type, and of the same kind
     as I.

Return value:
     The return value is of type LOGICAL and of the default kind.

See also:
     BGT, BLE, BLT

BGT --- Bitwise greater than
============================

Description:
     Determines whether an integral is a bitwise greater than another.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = BGT(I, J)

Arguments:

     I   Shall be of INTEGER type.
     J   Shall be of INTEGER type, and of the same kind
     as I.

Return value:
     The return value is of type LOGICAL and of the default kind.

See also:
     BGE, BLE, BLT

BIT_SIZE --- Bit size inquiry function
======================================

Description:
     BIT_SIZE(I) returns the number of bits (integer precision plus sign bit) represented by the type of I.  The result of BIT_SIZE(I) is independent of the actual value of I.

Standard:
     Fortran 95 and later

Class:
     Inquiry function

Syntax:
     RESULT = BIT_SIZE(I)

Arguments:

     I   The type shall be INTEGER.

Return value:
     The return value is of type INTEGER

Example:

          program test_bit_size
              integer :: i = 123
              integer :: size
              size = bit_size(i)
              print *, size
          end program test_bit_size

BLE --- Bitwise less than or equal to
=====================================

Description:
     Determines whether an integral is a bitwise less than or equal to another.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = BLE(I, J)

Arguments:

     I   Shall be of INTEGER type.
     J   Shall be of INTEGER type, and of the same kind
     as I.

Return value:
     The return value is of type LOGICAL and of the default kind.

See also:
     BGT, BGE, BLT

BLT --- Bitwise less than
=========================

Description:
     Determines whether an integral is a bitwise less than another.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = BLT(I, J)

Arguments:

     I   Shall be of INTEGER type.
     J   Shall be of INTEGER type, and of the same kind
     as I.

Return value:
     The return value is of type LOGICAL and of the default kind.

See also:
     BGE, BGT, BLE

BTEST --- Bit test function
===========================

Description:
     BTEST(I,POS) returns logical .TRUE. if the bit at POS in I is set.  The counting of the bits starts at 0.

Standard:
     Fortran 95 and later, has overloads that are GNU extensions

Class:
     Elemental function

Syntax:
     RESULT = BTEST(I, POS)

Arguments:

     I   The type shall be INTEGER.
     POS   The type shall be INTEGER.

Return value:
     The return value is of type LOGICAL

Example:

          program test_btest
              integer :: i = 32768 + 1024 + 64
              integer :: pos
              logical :: bool
              do pos=0,16
                  bool = btest(i, pos)
                  print *, pos, bool
              end do
          end program test_btest

Specific names:

     Name             Argument           Return type               Standard
     BTEST(I,POS)   INTEGER I,POS   LOGICAL   F95 and later
     BBTEST(I,POS)   INTEGER(1) I,POS   LOGICAL(1)   GNU extension
     BITEST(I,POS)   INTEGER(2) I,POS   LOGICAL(2)   GNU extension
     BJTEST(I,POS)   INTEGER(4) I,POS   LOGICAL(4)   GNU extension
     BKTEST(I,POS)   INTEGER(8) I,POS   LOGICAL(8)   GNU extension

C_ASSOCIATED --- Status of a C pointer
======================================

Description:
     C_ASSOCIATED(c_ptr_1[, c_ptr_2]) determines the status of the C pointer C_PTR_1 or if C_PTR_1 is associated with the target C_PTR_2.

Standard:
     Fortran 2003 and later

Class:
     Inquiry function

Syntax:
     RESULT = C_ASSOCIATED(c_ptr_1[, c_ptr_2])

Arguments:

     C_PTR_1   Scalar of the type C_PTR or C_FUNPTR.
     C_PTR_2   (Optional) Scalar of the same type as C_PTR_1.

Return value:
     The return value is of type LOGICAL; it is .false. if either C_PTR_1 is a C NULL pointer or if C_PTR1 and C_PTR_2 point to different addresses.

Example:

          subroutine association_test(a,b)
            use iso_c_binding, only: c_associated, c_loc, c_ptr
            implicit none
            real, pointer :: a
            type(c_ptr) :: b
            if(c_associated(b, c_loc(a))) &
               stop 'b and a do not point to same target'
          end subroutine association_test

See also:
     C_LOC, C_FUNLOC

C_F_POINTER --- Convert C into Fortran pointer
==============================================

Description:
     C_F_POINTER(CPTR, FPTR[, SHAPE]) assigns the target of the C pointer CPTR to the Fortran pointer FPTR and specifies its shape.

Standard:
     Fortran 2003 and later

Class:
     Subroutine

Syntax:
     CALL C_F_POINTER(CPTR, FPTR[, SHAPE])

Arguments:

     CPTR    scalar of the type C_PTR. It is
     INTENT(IN).
     FPTR    pointer interoperable with CPTR. It is
     INTENT(OUT).
     SHAPE   (Optional) Rank-one array of type INTEGER
     with INTENT(IN). It shall be present
     if and only if FPTR is an array. The size
     must be equal to the rank of FPTR.

Example:

          program main
            use iso_c_binding
            implicit none
            interface
              subroutine my_routine(p) bind(c,name='myC_func')
                import :: c_ptr
                type(c_ptr), intent(out) :: p
              end subroutine
            end interface
            type(c_ptr) :: cptr
            real,pointer :: a(:)
            call my_routine(cptr)
            call c_f_pointer(cptr, a, [12])
          end program main

See also:
     C_LOC, C_F_PROCPOINTER

C_F_PROCPOINTER --- Convert C into Fortran procedure pointer
============================================================

Description:
     C_F_PROCPOINTER(CPTR, FPTR) Assign the target of the C function pointer CPTR to the Fortran procedure pointer FPTR.

Standard:
     Fortran 2003 and later

Class:
     Subroutine

Syntax:
     CALL C_F_PROCPOINTER(cptr, fptr)

Arguments:

     CPTR    scalar of the type C_FUNPTR. It is
     INTENT(IN).
     FPTR    procedure pointer interoperable with CPTR. It is
     INTENT(OUT).

Example:

          program main
            use iso_c_binding
            implicit none
            abstract interface
              function func(a)
                import :: c_float
                real(c_float), intent(in) :: a
                real(c_float) :: func
              end function
            end interface
            interface
               function getIterFunc() bind(c,name="getIterFunc")
                 import :: c_funptr
                 type(c_funptr) :: getIterFunc
               end function
            end interface
            type(c_funptr) :: cfunptr
            procedure(func), pointer :: myFunc
            cfunptr = getIterFunc()
            call c_f_procpointer(cfunptr, myFunc)
          end program main

See also:
     C_LOC, C_F_POINTER

C_FUNLOC --- Obtain the C address of a procedure
================================================

Description:
     C_FUNLOC(x) determines the C address of the argument.

Standard:
     Fortran 2003 and later

Class:
     Inquiry function

Syntax:
     RESULT = C_FUNLOC(x)

Arguments:

     X   Interoperable function or pointer to such function.

Return value:
     The return value is of type C_FUNPTR and contains the C address of the argument.

Example:

          module x
            use iso_c_binding
            implicit none
          contains
            subroutine sub(a) bind(c)
              real(c_float) :: a
              a = sqrt(a)+5.0
            end subroutine sub
          end module x
          program main
            use iso_c_binding
            use x
            implicit none
            interface
              subroutine my_routine(p) bind(c,name='myC_func')
                import :: c_funptr
                type(c_funptr), intent(in) :: p
              end subroutine
            end interface
            call my_routine(c_funloc(sub))
          end program main

See also:
     C_ASSOCIATED, C_LOC, C_F_POINTER, C_F_PROCPOINTER

C_LOC --- Obtain the C address of an object
===========================================

Description:
     C_LOC(X) determines the C address of the argument.

Standard:
     Fortran 2003 and later

Class:
     Inquiry function

Syntax:
     RESULT = C_LOC(X)

Arguments:

     X    Shall have either the POINTER or TARGET attribute. It shall not be a coindexed object. It shall either be a variable with interoperable type and kind type parameters, or be a scalar, nonpolymorphic variable with no length type parameters.

Return value:
     The return value is of type C_PTR and contains the C address of the argument.

Example:

          subroutine association_test(a,b)
            use iso_c_binding, only: c_associated, c_loc, c_ptr
            implicit none
            real, pointer :: a
            type(c_ptr) :: b
            if(c_associated(b, c_loc(a))) &
               stop 'b and a do not point to same target'
          end subroutine association_test

See also:
     C_ASSOCIATED, C_FUNLOC, C_F_POINTER, C_F_PROCPOINTER

C_SIZEOF --- Size in bytes of an expression
===========================================

Description:
     C_SIZEOF(X) calculates the number of bytes of storage the expression X occupies.

Standard:
     Fortran 2008

Class:
     Inquiry function of the module ISO_C_BINDING

Syntax:
     N = C_SIZEOF(X)

Arguments:

     X   The argument shall be an interoperable data entity.

Return value:
     The return value is of type integer and of the system-dependent kind C_SIZE_T (from the ISO_C_BINDING module). Its value is the number of bytes occupied by the argument.  If the argument has the POINTER attribute, the number of bytes of the storage area pointed to is returned.  If the argument is of a derived type with POINTER or ALLOCATABLE components, the return value does not account for the sizes of the data pointed to by these components.

Example:

             use iso_c_binding
             integer(c_int) :: i
             real(c_float) :: r, s(5)
             print *, (c_sizeof(s)/c_sizeof(r) == 5)
             end

     The example will print .TRUE. unless you are using a platform where default REAL variables are unusually padded.

See also:
     SIZEOF, STORAGE_SIZE

CEILING --- Integer ceiling function
====================================

Description:
     CEILING(A) returns the least integer greater than or equal to A.

Standard:
     Fortran 95 and later

Class:
     Elemental function

Syntax:
     RESULT = CEILING(A [, KIND])

Arguments:

     A   The type shall be REAL.
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     The return value is of type INTEGER(KIND) if KIND is present and a default-kind INTEGER otherwise.

Example:

          program test_ceiling
              real :: x = 63.29
              real :: y = -63.59
              print *, ceiling(x) ! returns 64
              print *, ceiling(y) ! returns -63
          end program test_ceiling

See also:
     FLOOR, NINT

CHAR --- Character conversion function
======================================

Description:
     CHAR(I [, KIND]) returns the character represented by the integer I.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = CHAR(I [, KIND])

Arguments:

     I   The type shall be INTEGER.
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     The return value is of type CHARACTER(1)

Example:

          program test_char
              integer :: i = 74
              character(1) :: c
              c = char(i)
              print *, i, c ! returns 'J'
          end program test_char

Specific names:

     Name             Argument           Return type               Standard
     CHAR(I)   INTEGER I   CHARACTER(LEN=1)   F77 and later

Note:
     See ICHAR for a discussion of converting between numerical values and formatted string representations.

See also:
     ACHAR, IACHAR, ICHAR

CHDIR --- Change working directory
==================================

Description:
     Change current working directory to a specified path.

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL CHDIR(NAME [, STATUS])
     STATUS = CHDIR(NAME)

Arguments:

     NAME     The type shall be CHARACTER of default
     kind and shall specify a valid path within the file system.
     STATUS   (Optional) INTEGER status flag of the default
     kind.  Returns 0 on success, and a system specific and nonzero error code
     otherwise.

Example:

          PROGRAM test_chdir
            CHARACTER(len=255) :: path
            CALL getcwd(path)
            WRITE(*,*) TRIM(path)
            CALL chdir("/tmp")
            CALL getcwd(path)
            WRITE(*,*) TRIM(path)
          END PROGRAM

See also:
     GETCWD

CHMOD --- Change access permissions of files
============================================

Description:
     CHMOD changes the permissions of a file.

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL CHMOD(NAME, MODE[, STATUS])
     STATUS = CHMOD(NAME, MODE)

Arguments:

     NAME   Scalar CHARACTER of default kind with the
     file name. Trailing blanks are ignored unless the character
     achar(0) is present, then all characters up to and excluding
     achar(0) are used as the file name.

     MODE   Scalar CHARACTER of default kind giving the
     file permission. MODE uses the same syntax as the chmod utility
     as defined by the POSIX standard. The argument shall either be a string of
     a nonnegative octal number or a symbolic mode.

     STATUS   (optional) scalar INTEGER, which is
     0 on success and nonzero otherwise.

Return value:
     In either syntax, STATUS is set to 0 on success and nonzero otherwise.

Example:
     CHMOD as subroutine

          program chmod_test
            implicit none
            integer :: status
            call chmod('test.dat','u+x',status)
            print *, 'Status: ', status
          end program chmod_test

     CHMOD as function:

          program chmod_test
            implicit none
            integer :: status
            status = chmod('test.dat','u+x')
            print *, 'Status: ', status
          end program chmod_test

CMPLX --- Complex conversion function
=====================================

Description:
     CMPLX(X [, Y [, KIND]]) returns a complex number where X is converted to the real component.  If Y is present it is converted to the imaginary component.  If Y is not present then the imaginary component is set to 0.0.  If X is complex then Y must not be present.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = CMPLX(X [, Y [, KIND]])

Arguments:

     X   The type may be INTEGER, REAL,
     or COMPLEX.
     Y   (Optional; only allowed if X is not
     COMPLEX.)  May be INTEGER or REAL.
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     The return value is of COMPLEX type, with a kind equal to KIND if it is specified.  If KIND is not specified, the result is of the default COMPLEX kind, regardless of the kinds of X and Y.

Example:

          program test_cmplx
              integer :: i = 42
              real :: x = 3.14
              complex :: z
              z = cmplx(i, x)
              print *, z, cmplx(x)
          end program test_cmplx

See also:
     COMPLEX

CO_BROADCAST --- Copy a value to all images the current set of images
=====================================================================

Description:
     CO_BROADCAST copies the value of argument A on the image with image index SOURCE_IMAGE to all images in the current team.  A becomes defined as if by intrinsic assignment.  If the execution was successful and STAT is present, it is assigned the value zero.  If the execution failed, STAT gets assigned a nonzero value and, if present, ERRMSG gets assigned a value describing the occurred error.

Standard:
     Technical Specification (TS) 18508 or later

Class:
     Collective subroutine

Syntax:
     CALL CO_BROADCAST(A, SOURCE_IMAGE [, STAT, ERRMSG])

Arguments:

     A              INTENT(INOUT) argument; shall have the same
     dynamic type and type paramters on all images of the current team. If it
     is an array, it shall have the same shape on all images.
     SOURCE_IMAGE   a scalar integer expression.
     It shall have the same the same value on all images and refer to an
     image of the current team.
     STAT           (optional) a scalar integer variable
     ERRMSG         (optional) a scalar character variable

Example:

          program test
            integer :: val(3)
            if (this_image() == 1) then
              val = [1, 5, 3]
            end if
            call co_broadcast (val, source_image=1)
            print *, this_image, ":", val
          end program test

See also:
     CO_MAX, CO_MIN, CO_SUM, CO_REDUCE

CO_MAX --- Maximal value on the current set of images
=====================================================

Description:
     CO_MAX determines element-wise the maximal value of A on all images of the current team.  If RESULT_IMAGE is present, the maximum values are returned in A on the specified image only and the value of A on the other images become undefined.  If RESULT_IMAGE is not present, the value is returned on all images.  If the execution was successful and STAT is present, it is assigned the value zero.  If the execution failed, STAT gets assigned a nonzero value and, if present, ERRMSG gets assigned a value describing the occurred error.

Standard:
     Technical Specification (TS) 18508 or later

Class:
     Collective subroutine

Syntax:
     CALL CO_MAX(A [, RESULT_IMAGE, STAT, ERRMSG])

Arguments:

     A              shall be an integer, real or character variable,
     which has the same type and type parameters on all images of the team.
     RESULT_IMAGE   (optional) a scalar integer expression; if
     present, it shall have the same the same value on all images and refer to an
     image of the current team.
     STAT           (optional) a scalar integer variable
     ERRMSG         (optional) a scalar character variable

Example:

          program test
            integer :: val
            val = this_image ()
            call co_max (val, result_image=1)
            if (this_image() == 1) then
              write(*,*) "Maximal value", val  ! prints num_images()
            end if
          end program test

See also:
     CO_MIN, CO_SUM, CO_REDUCE, CO_BROADCAST

CO_MIN --- Minimal value on the current set of images
=====================================================

Description:
     CO_MIN determines element-wise the minimal value of A on all images of the current team.  If RESULT_IMAGE is present, the minimal values are returned in A on the specified image only and the value of A on the other images become undefined.  If RESULT_IMAGE is not present, the value is returned on all images.  If the execution was successful and STAT is present, it is assigned the value zero.  If the execution failed, STAT gets assigned a nonzero value and, if present, ERRMSG gets assigned a value describing the occurred error.

Standard:
     Technical Specification (TS) 18508 or later

Class:
     Collective subroutine

Syntax:
     CALL CO_MIN(A [, RESULT_IMAGE, STAT, ERRMSG])

Arguments:

     A              shall be an integer, real or character variable,
     which has the same type and type parameters on all images of the team.
     RESULT_IMAGE   (optional) a scalar integer expression; if
     present, it shall have the same the same value on all images and refer to an
     image of the current team.
     STAT           (optional) a scalar integer variable
     ERRMSG         (optional) a scalar character variable

Example:

          program test
            integer :: val
            val = this_image ()
            call co_min (val, result_image=1)
            if (this_image() == 1) then
              write(*,*) "Minimal value", val  ! prints 1
            end if
          end program test

See also:
     CO_MAX, CO_SUM, CO_REDUCE, CO_BROADCAST

CO_REDUCE --- Reduction of values on the current set of images
==============================================================

Description:
     CO_REDUCE determines element-wise the reduction of the value of A on all images of the current team.  The pure function passed as OPERATOR is used to pairwise reduce the values of A by passing either the value of A of different images or the result values of such a reduction as argument.  If A is an array, the deduction is done element wise. If RESULT_IMAGE is present, the result values are returned in A on the specified image only and the value of A on the other images become undefined.  If RESULT_IMAGE is not present, the value is returned on all images.  If the execution was successful and STAT is present, it is assigned the value zero.  If the execution failed, STAT gets assigned a nonzero value and, if present, ERRMSG gets assigned a value describing the occurred error.

Standard:
     Technical Specification (TS) 18508 or later

Class:
     Collective subroutine

Syntax:
     CALL CO_REDUCE(A, OPERATOR, [, RESULT_IMAGE, STAT, ERRMSG])

Arguments:

     A              is an INTENT(INOUT) argument and shall be
     nonpolymorphic. If it is allocatable, it shall be allocated; if it is a pointer,
     it shall be associated.  A shall have the same type and type parameters on
     all images of the team; if it is an array, it shall have the same shape on all
     images.
     OPERATOR       pure function with two scalar nonallocatable
     arguments, which shall be nonpolymorphic and have the same type and type
     parameters as A.  The function shall return a nonallocatable scalar of
     the same type and type parameters as A.  The function shall be the same on
     all images and with regards to the arguments mathematically commutative and
     associative.  Note that OPERATOR may not be an elemental function, unless
     it is an intrisic function.
     RESULT_IMAGE   (optional) a scalar integer expression; if
     present, it shall have the same the same value on all images and refer to an
     image of the current team.
     STAT           (optional) a scalar integer variable
     ERRMSG         (optional) a scalar character variable

Example:

          program test
            integer :: val
            val = this_image ()
            call co_reduce (val, result_image=1, operator=myprod)
            if (this_image() == 1) then
              write(*,*) "Product value", val  ! prints num_images() factorial
            end if
          contains
            pure function myprod(a, b)
              integer, value :: a, b
              integer :: myprod
              myprod = a * b
            end function myprod
          end program test

Note:
     While the rules permit in principle an intrinsic function, none of the intrinsics in the standard fulfill the criteria of having a specific function, which takes two arguments of the same type and returning that type as result.

See also:
     CO_MIN, CO_MAX, CO_SUM, CO_BROADCAST

CO_SUM --- Sum of values on the current set of images
=====================================================

Description:
     CO_SUM sums up the values of each element of A on all images of the current team.  If RESULT_IMAGE is present, the summed-up values are returned in A on the specified image only and the value of A on the other images become undefined.  If RESULT_IMAGE is not present, the value is returned on all images.  If the execution was successful and STAT is present, it is assigned the value zero.  If the execution failed, STAT gets assigned a nonzero value and, if present, ERRMSG gets assigned a value describing the occurred error.

Standard:
     Technical Specification (TS) 18508 or later

Class:
     Collective subroutine

Syntax:
     CALL CO_MIN(A [, RESULT_IMAGE, STAT, ERRMSG])

Arguments:

     A              shall be an integer, real or complex variable,
     which has the same type and type parameters on all images of the team.
     RESULT_IMAGE   (optional) a scalar integer expression; if
     present, it shall have the same the same value on all images and refer to an
     image of the current team.
     STAT           (optional) a scalar integer variable
     ERRMSG         (optional) a scalar character variable

Example:

          program test
            integer :: val
            val = this_image ()
            call co_sum (val, result_image=1)
            if (this_image() == 1) then
              write(*,*) "The sum is ", val ! prints (n**2 + n)/2, with n = num_images()
            end if
          end program test

See also:
     CO_MAX, CO_MIN, CO_REDUCE, CO_BROADCAST

COMMAND_ARGUMENT_COUNT --- Get number of command line arguments
===============================================================

Description:
     COMMAND_ARGUMENT_COUNT returns the number of arguments passed on the command line when the containing program was invoked.

Standard:
     Fortran 2003 and later

Class:
     Inquiry function

Syntax:
     RESULT = COMMAND_ARGUMENT_COUNT()

Arguments:

     None

Return value:
     The return value is an INTEGER of default kind.

Example:

          program test_command_argument_count
              integer :: count
              count = command_argument_count()
              print *, count
          end program test_command_argument_count

See also:
     GET_COMMAND, GET_COMMAND_ARGUMENT

COMPILER_OPTIONS --- Options passed to the compiler
===================================================

Description:
     COMPILER_OPTIONS returns a string with the options used for compiling.

Standard:
     Fortran 2008

Class:
     Inquiry function of the module ISO_FORTRAN_ENV

Syntax:
     STR = COMPILER_OPTIONS()

Arguments:
     None.

Return value:
     The return value is a default-kind string with system-dependent length. It contains the compiler flags used to compile the file, which called the COMPILER_OPTIONS intrinsic.

Example:

             use iso_fortran_env
             print '(4a)', 'This file was compiled by ', &
                           compiler_version(), ' using the options ', &
                           compiler_options()
             end

See also:
     COMPILER_VERSION, ISO_FORTRAN_ENV

COMPILER_VERSION --- Compiler version string
============================================

Description:
     COMPILER_VERSION returns a string with the name and the version of the compiler.

Standard:
     Fortran 2008

Class:
     Inquiry function of the module ISO_FORTRAN_ENV

Syntax:
     STR = COMPILER_VERSION()

Arguments:
     None.

Return value:
     The return value is a default-kind string with system-dependent length. It contains the name of the compiler and its version number.

Example:

             use iso_fortran_env
             print '(4a)', 'This file was compiled by ', &
                           compiler_version(), ' using the options ', &
                           compiler_options()
             end

See also:
     COMPILER_OPTIONS, ISO_FORTRAN_ENV

COMPLEX --- Complex conversion function
=======================================

Description:
     COMPLEX(X, Y) returns a complex number where X is converted to the real component and Y is converted to the imaginary component.

Standard:
     GNU extension

Class:
     Elemental function

Syntax:
     RESULT = COMPLEX(X, Y)

Arguments:

     X   The type may be INTEGER or REAL.
     Y   The type may be INTEGER or REAL.

Return value:
     If X and Y are both of INTEGER type, then the return value is of default COMPLEX type.

     If X and Y are of REAL type, or one is of REAL type and one is of INTEGER type, then the return value is of COMPLEX type with a kind equal to that of the REAL argument with the highest precision.

Example:

          program test_complex
              integer :: i = 42
              real :: x = 3.14
              print *, complex(i, x)
          end program test_complex

See also:
     CMPLX

CONJG --- Complex conjugate function
====================================

Description:
     CONJG(Z) returns the conjugate of Z.  If Z is (x, y) then the result is (x, -y)

Standard:
     Fortran 77 and later, has overloads that are GNU extensions

Class:
     Elemental function

Syntax:
     Z = CONJG(Z)

Arguments:

     Z   The type shall be COMPLEX.

Return value:
     The return value is of type COMPLEX.

Example:

          program test_conjg
              complex :: z = (2.0, 3.0)
              complex(8) :: dz = (2.71_8, -3.14_8)
              z= conjg(z)
              print *, z
              dz = dconjg(dz)
              print *, dz
          end program test_conjg

Specific names:

     Name               Argument               Return type         Standard
     CONJG(Z)    COMPLEX Z       COMPLEX      GNU extension
     DCONJG(Z)   COMPLEX(8) Z    COMPLEX(8)   GNU extension

COS --- Cosine function
=======================

Description:
     COS(X) computes the cosine of X.

Standard:
     Fortran 77 and later, has overloads that are GNU extensions

Class:
     Elemental function

Syntax:
     RESULT = COS(X)

Arguments:

     X   The type shall be REAL or
     COMPLEX.

Return value:
     The return value is of the same type and kind as X. The real part of the result is in radians. If X is of the type REAL, the return value lies in the range  -1 \leq \cos (x) \leq 1.

Example:

          program test_cos
            real :: x = 0.0
            x = cos(x)
          end program test_cos

Specific names:

     Name              Argument              Return type         Standard
     COS(X)     REAL(4) X      REAL(4)      Fortran 77 and later
     DCOS(X)    REAL(8) X      REAL(8)      Fortran 77 and later
     CCOS(X)    COMPLEX(4) X   COMPLEX(4)   Fortran 77 and later
     ZCOS(X)    COMPLEX(8) X   COMPLEX(8)   GNU extension
     CDCOS(X)   COMPLEX(8) X   COMPLEX(8)   GNU extension

See also:
     Inverse function: ACOS Degrees function: COSD

COSD --- Cosine function, degrees
=================================

Description:
     COSD(X) computes the cosine of X in degrees.

     This function is for compatibility only and should be avoided in favor of standard constructs wherever possible.

Standard:
     GNU Extension, enabled with -fdec-math.

Class:
     Elemental function

Syntax:
     RESULT = COSD(X)

Arguments:

     X   The type shall be REAL or
     COMPLEX.

Return value:
     The return value is of the same type and kind as X. The real part of the result is in degrees.  If X is of the type REAL, the return value lies in the range  -1 \leq \cosd (x) \leq 1.

Example:

          program test_cosd
            real :: x = 0.0
            x = cosd(x)
          end program test_cosd

Specific names:

     Name              Argument              Return type         Standard
     COSD(X)     REAL(4) X      REAL(4)      GNU Extension
     DCOSD(X)    REAL(8) X      REAL(8)      GNU Extension
     CCOSD(X)    COMPLEX(4) X   COMPLEX(4)   GNU Extension
     ZCOSD(X)    COMPLEX(8) X   COMPLEX(8)   GNU extension
     CDCOSD(X)   COMPLEX(8) X   COMPLEX(8)   GNU extension

See also:
     Inverse function: ACOSD Radians function: COS

COSH --- Hyperbolic cosine function
===================================

Description:
     COSH(X) computes the hyperbolic cosine of X.

Standard:
     Fortran 77 and later, for a complex argument Fortran 2008 or later

Class:
     Elemental function

Syntax:
     X = COSH(X)

Arguments:

     X   The type shall be REAL or COMPLEX.

Return value:
     The return value has same type and kind as X. If X is complex, the imaginary part of the result is in radians. If X is REAL, the return value has a lower bound of one, \cosh (x) \geq 1.

Example:

          program test_cosh
            real(8) :: x = 1.0_8
            x = cosh(x)
          end program test_cosh

Specific names:

     Name              Argument            Return type         Standard
     COSH(X)    REAL(4) X    REAL(4)      Fortran 77 and later
     DCOSH(X)   REAL(8) X    REAL(8)      Fortran 77 and later

See also:
     Inverse function: ACOSH

COTAN --- Cotangent function
============================

Description:
     COTAN(X) computes the cotangent of X. Equivalent to COS(x) divided by SIN(x), or 1 / TAN(x).

     This function is for compatibility only and should be avoided in favor of standard constructs wherever possible.

Standard:
     GNU Extension, enabled with -fdec-math.

Class:
     Elemental function

Syntax:
     RESULT = COTAN(X)

Arguments:

     X   The type shall be REAL or COMPLEX.

Return value:
     The return value has same type and kind as X, and its value is in radians.

Example:

          program test_cotan
            real(8) :: x = 0.165_8
            x = cotan(x)
          end program test_cotan

Specific names:

     Name              Argument            Return type       Standard
     COTAN(X)     REAL(4) X    REAL(4)    GNU Extension
     DCOTAN(X)    REAL(8) X    REAL(8)    GNU Extension

See also:
     Converse function: TAN Degrees function: COTAND

COTAND --- Cotangent function, degrees
======================================

Description:
     COTAND(X) computes the cotangent of X in degrees.  Equivalent to COSD(x) divided by SIND(x), or 1 / TAND(x).

Standard:
     GNU Extension, enabled with -fdec-math.

     This function is for compatibility only and should be avoided in favor of standard constructs wherever possible.

Class:
     Elemental function

Syntax:
     RESULT = COTAND(X)

Arguments:

     X   The type shall be REAL or COMPLEX.

Return value:
     The return value has same type and kind as X, and its value is in degrees.

Example:

          program test_cotand
            real(8) :: x = 0.165_8
            x = cotand(x)
          end program test_cotand

Specific names:

     Name              Argument            Return type       Standard
     COTAND(X)     REAL(4) X    REAL(4)    GNU Extension
     DCOTAND(X)    REAL(8) X    REAL(8)    GNU Extension

See also:
     Converse function: TAND Radians function: COTAN

COUNT --- Count function
========================

Description:

     Counts the number of .TRUE. elements in a logical MASK, or, if the DIM argument is supplied, counts the number of elements along each row of the array in the DIM direction. If the array has zero size, or all of the elements of MASK are .FALSE., then the result is 0.

Standard:
     Fortran 95 and later, with KIND argument Fortran 2003 and later

Class:
     Transformational function

Syntax:
     RESULT = COUNT(MASK [, DIM, KIND])

Arguments:

     MASK   The type shall be LOGICAL.
     DIM    (Optional) The type shall be INTEGER.
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     The return value is of type INTEGER and of kind KIND. If KIND is absent, the return value is of default integer kind. If DIM is present, the result is an array with a rank one less than the rank of ARRAY, and a size corresponding to the shape of ARRAY with the DIM dimension removed.

Example:

          program test_count
              integer, dimension(2,3) :: a, b
              logical, dimension(2,3) :: mask
              a = reshape( (/ 1, 2, 3, 4, 5, 6 /), (/ 2, 3 /))
              b = reshape( (/ 0, 7, 3, 4, 5, 8 /), (/ 2, 3 /))
              print '(3i3)', a(1,:)
              print '(3i3)', a(2,:)
              print *
              print '(3i3)', b(1,:)
              print '(3i3)', b(2,:)
              print *
              mask = a.ne.b
              print '(3l3)', mask(1,:)
              print '(3l3)', mask(2,:)
              print *
              print '(3i3)', count(mask)
              print *
              print '(3i3)', count(mask, 1)
              print *
              print '(3i3)', count(mask, 2)
          end program test_count

CPU_TIME --- CPU elapsed time in seconds
========================================

Description:
     Returns a REAL value representing the elapsed CPU time in seconds.  This is useful for testing segments of code to determine execution time.

     If a time source is available, time will be reported with microsecond resolution. If no time source is available, TIME is set to -1.0.

     Note that TIME may contain a, system dependent, arbitrary offset and may not start with 0.0. For CPU_TIME, the absolute value is meaningless, only differences between subsequent calls to this subroutine, as shown in the example below, should be used.

Standard:
     Fortran 95 and later

Class:
     Subroutine

Syntax:
     CALL CPU_TIME(TIME)

Arguments:

     TIME   The type shall be REAL with INTENT(OUT).

Return value:
     None

Example:

          program test_cpu_time
              real :: start, finish
              call cpu_time(start)
                  ! put code to test here
              call cpu_time(finish)
              print '("Time = ",f6.3," seconds.")',finish-start
          end program test_cpu_time

See also:
     SYSTEM_CLOCK, DATE_AND_TIME

CSHIFT --- Circular shift elements of an array
==============================================

Description:
     CSHIFT(ARRAY, SHIFT [, DIM]) performs a circular shift on elements of ARRAY along the dimension of DIM.  If DIM is omitted it is taken to be 1.  DIM is a scalar of type INTEGER in the range of 1 \leq DIM \leq n) where n is the rank of ARRAY. If the rank of ARRAY is one, then all elements of ARRAY are shifted by SHIFT places.  If rank is greater than one, then all complete rank one sections of ARRAY along the given dimension are shifted.  Elements shifted out one end of each rank one section are shifted back in the other end.

Standard:
     Fortran 95 and later

Class:
     Transformational function

Syntax:
     RESULT = CSHIFT(ARRAY, SHIFT [, DIM])

Arguments:

     ARRAY    Shall be an array of any type.
     SHIFT    The type shall be INTEGER.
     DIM      The type shall be INTEGER.

Return value:
     Returns an array of same type and rank as the ARRAY argument.

Example:

          program test_cshift
              integer, dimension(3,3) :: a
              a = reshape( (/ 1, 2, 3, 4, 5, 6, 7, 8, 9 /), (/ 3, 3 /))
              print '(3i3)', a(1,:)
              print '(3i3)', a(2,:)
              print '(3i3)', a(3,:)
              a = cshift(a, SHIFT=(/1, 2, -1/), DIM=2)
              print *
              print '(3i3)', a(1,:)
              print '(3i3)', a(2,:)
              print '(3i3)', a(3,:)
          end program test_cshift

CTIME --- Convert a time into a string
======================================

Description:
     CTIME converts a system time value, such as returned by TIME8, to a string. The output will be of the form Sat Aug 19 18:13:14 1995.

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL CTIME(TIME, RESULT).
     RESULT = CTIME(TIME).

Arguments:

     TIME      The type shall be of type INTEGER.
     RESULT    The type shall be of type CHARACTER and
     of default kind. It is an INTENT(OUT) argument. If the length
     of this variable is too short for the time and date string to fit
     completely, it will be blank on procedure return.

Return value:
     The converted date and time as a string.

Example:

          program test_ctime
              integer(8) :: i
              character(len=30) :: date
              i = time8()

              ! Do something, main part of the program

              call ctime(i,date)
              print *, 'Program was started on ', date
          end program test_ctime

See Also:
     DATE_AND_TIME, GMTIME, LTIME, TIME, TIME8

DATE_AND_TIME --- Date and time subroutine
==========================================

Description:
     DATE_AND_TIME(DATE, TIME, ZONE, VALUES) gets the corresponding date and time information from the real-time system clock.  DATE is INTENT(OUT) and has form ccyymmdd.  TIME is INTENT(OUT) and has form hhmmss.sss.  ZONE is INTENT(OUT) and has form (+-)hhmm, representing the difference with respect to Coordinated Universal Time (UTC). Unavailable time and date parameters return blanks.

     VALUES is INTENT(OUT) and provides the following:

       VALUE(1):   The year
       VALUE(2):   The month
       VALUE(3):   The day of the month
       VALUE(4):   Time difference with UTC in minutes
       VALUE(5):   The hour of the day
       VALUE(6):   The minutes of the hour
       VALUE(7):   The seconds of the minute
       VALUE(8):   The milliseconds of the second

Standard:
     Fortran 95 and later

Class:
     Subroutine

Syntax:
     CALL DATE_AND_TIME([DATE, TIME, ZONE, VALUES])

Arguments:

     DATE    (Optional) The type shall be CHARACTER(LEN=8)
     or larger, and of default kind.
     TIME    (Optional) The type shall be CHARACTER(LEN=10)
     or larger, and of default kind.
     ZONE    (Optional) The type shall be CHARACTER(LEN=5)
     or larger, and of default kind.
     VALUES  (Optional) The type shall be INTEGER(8).

Return value:
     None

Example:

          program test_time_and_date
              character(8)  :: date
              character(10) :: time
              character(5)  :: zone
              integer,dimension(8) :: values
              ! using keyword arguments
              call date_and_time(date,time,zone,values)
              call date_and_time(DATE=date,ZONE=zone)
              call date_and_time(TIME=time)
              call date_and_time(VALUES=values)
              print '(a,2x,a,2x,a)', date, time, zone
              print '(8i5)', values
          end program test_time_and_date

See also:
     CPU_TIME, SYSTEM_CLOCK

DBLE --- Double conversion function
===================================

Description:
     DBLE(A) Converts A to double precision real type.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = DBLE(A)

Arguments:

     A   The type shall be INTEGER, REAL,
     or COMPLEX.

Return value:
     The return value is of type double precision real.

Example:

          program test_dble
              real    :: x = 2.18
              integer :: i = 5
              complex :: z = (2.3,1.14)
              print *, dble(x), dble(i), dble(z)
          end program test_dble

See also:
     REAL

DCMPLX --- Double complex conversion function
=============================================

Description:
     DCMPLX(X [,Y]) returns a double complex number where X is converted to the real component.  If Y is present it is converted to the imaginary component.  If Y is not present then the imaginary component is set to 0.0.  If X is complex then Y must not be present.

Standard:
     GNU extension

Class:
     Elemental function

Syntax:
     RESULT = DCMPLX(X [, Y])

Arguments:

     X   The type may be INTEGER, REAL,
     or COMPLEX.
     Y   (Optional if X is not COMPLEX.) May be
     INTEGER or REAL.

Return value:
     The return value is of type COMPLEX(8)

Example:

          program test_dcmplx
              integer :: i = 42
              real :: x = 3.14
              complex :: z
              z = cmplx(i, x)
              print *, dcmplx(i)
              print *, dcmplx(x)
              print *, dcmplx(z)
              print *, dcmplx(x,i)
          end program test_dcmplx

DIGITS --- Significant binary digits function
=============================================

Description:
     DIGITS(X) returns the number of significant binary digits of the internal model representation of X.  For example, on a system using a 32-bit floating point representation, a default real number would likely return 24.

Standard:
     Fortran 95 and later

Class:
     Inquiry function

Syntax:
     RESULT = DIGITS(X)

Arguments:

     X   The type may be INTEGER or REAL.

Return value:
     The return value is of type INTEGER.

Example:

          program test_digits
              integer :: i = 12345
              real :: x = 3.143
              real(8) :: y = 2.33
              print *, digits(i)
              print *, digits(x)
              print *, digits(y)
          end program test_digits

DIM --- Positive difference
===========================

Description:
     DIM(X,Y) returns the difference X-Y if the result is positive; otherwise returns zero.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = DIM(X, Y)

Arguments:

     X   The type shall be INTEGER or REAL
     Y   The type shall be the same type and kind as X.

Return value:
     The return value is of type INTEGER or REAL.

Example:

          program test_dim
              integer :: i
              real(8) :: x
              i = dim(4, 15)
              x = dim(4.345_8, 2.111_8)
              print *, i
              print *, x
          end program test_dim

Specific names:

     Name               Argument                 Return type         Standard
     DIM(X,Y)    REAL(4) X, Y      REAL(4)      Fortran 77 and later
     IDIM(X,Y)   INTEGER(4) X, Y   INTEGER(4)   Fortran 77 and later
     DDIM(X,Y)   REAL(8) X, Y      REAL(8)      Fortran 77 and later

DOT_PRODUCT --- Dot product function
====================================

Description:
     DOT_PRODUCT(VECTOR_A, VECTOR_B) computes the dot product multiplication of two vectors VECTOR_A and VECTOR_B.  The two vectors may be either numeric or logical and must be arrays of rank one and of equal size. If the vectors are INTEGER or REAL, the result is SUM(VECTOR_A*VECTOR_B). If the vectors are COMPLEX, the result is SUM(CONJG(VECTOR_A)*VECTOR_B). If the vectors are LOGICAL, the result is ANY(VECTOR_A .AND. VECTOR_B).

Standard:
     Fortran 95 and later

Class:
     Transformational function

Syntax:
     RESULT = DOT_PRODUCT(VECTOR_A, VECTOR_B)

Arguments:

     VECTOR_A   The type shall be numeric or LOGICAL, rank 1.
     VECTOR_B   The type shall be numeric if VECTOR_A is of numeric type or LOGICAL if VECTOR_A is of type LOGICAL. VECTOR_B shall be a rank-one array.

Return value:
     If the arguments are numeric, the return value is a scalar of numeric type, INTEGER, REAL, or COMPLEX.  If the arguments are LOGICAL, the return value is .TRUE. or .FALSE..

Example:

          program test_dot_prod
              integer, dimension(3) :: a, b
              a = (/ 1, 2, 3 /)
              b = (/ 4, 5, 6 /)
              print '(3i3)', a
              print *
              print '(3i3)', b
              print *
              print *, dot_product(a,b)
          end program test_dot_prod

DPROD --- Double product function
=================================

Description:
     DPROD(X,Y) returns the product X*Y.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = DPROD(X, Y)

Arguments:

     X   The type shall be REAL.
     Y   The type shall be REAL.

Return value:
     The return value is of type REAL(8).

Example:

          program test_dprod
              real :: x = 5.2
              real :: y = 2.3
              real(8) :: d
              d = dprod(x,y)
              print *, d
          end program test_dprod

Specific names:

     Name                Argument                 Return type         Standard
     DPROD(X,Y)   REAL(4) X, Y      REAL(8)      Fortran 77 and later

DREAL --- Double real part function
===================================

Description:
     DREAL(Z) returns the real part of complex variable Z.

Standard:
     GNU extension

Class:
     Elemental function

Syntax:
     RESULT = DREAL(A)

Arguments:

     A   The type shall be COMPLEX(8).

Return value:
     The return value is of type REAL(8).

Example:

          program test_dreal
              complex(8) :: z = (1.3_8,7.2_8)
              print *, dreal(z)
          end program test_dreal

See also:
     AIMAG

DSHIFTL --- Combined left shift
===============================

Description:
     DSHIFTL(I, J, SHIFT) combines bits of I and J. The rightmost SHIFT bits of the result are the leftmost SHIFT bits of J, and the remaining bits are the rightmost bits of I.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = DSHIFTL(I, J, SHIFT)

Arguments:

     I   Shall be of type INTEGER or a BOZ constant.
     J   Shall be of type INTEGER or a BOZ constant.
     If both I and J have integer type, then they shall have
     the same kind type parameter. I and J shall not both be
     BOZ constants.
     SHIFT   Shall be of type INTEGER. It shall
     be nonnegative.  If I is not a BOZ constant, then SHIFT
     shall be less than or equal to BIT_SIZE(I); otherwise,
     SHIFT shall be less than or equal to BIT_SIZE(J).

Return value:
     If either I or J is a BOZ constant, it is first converted as if by the intrinsic function INT to an integer type with the kind type parameter of the other.

See also:
     DSHIFTR

DSHIFTR --- Combined right shift
================================

Description:
     DSHIFTR(I, J, SHIFT) combines bits of I and J. The leftmost SHIFT bits of the result are the rightmost SHIFT bits of I, and the remaining bits are the leftmost bits of J.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = DSHIFTR(I, J, SHIFT)

Arguments:

     I   Shall be of type INTEGER or a BOZ constant.
     J   Shall be of type INTEGER or a BOZ constant.
     If both I and J have integer type, then they shall have
     the same kind type parameter. I and J shall not both be
     BOZ constants.
     SHIFT   Shall be of type INTEGER. It shall
     be nonnegative.  If I is not a BOZ constant, then SHIFT
     shall be less than or equal to BIT_SIZE(I); otherwise,
     SHIFT shall be less than or equal to BIT_SIZE(J).

Return value:
     If either I or J is a BOZ constant, it is first converted as if by the intrinsic function INT to an integer type with the kind type parameter of the other.

See also:
     DSHIFTL

DTIME --- Execution time subroutine (or function)
=================================================

Description:
     DTIME(VALUES, TIME) initially returns the number of seconds of runtime since the start of the process's execution in TIME.  VALUES returns the user and system components of this time in VALUES(1) and VALUES(2) respectively. TIME is equal to VALUES(1) + VALUES(2).

     Subsequent invocations of DTIME return values accumulated since the previous invocation.

     On some systems, the underlying timings are represented using types with sufficiently small limits that overflows (wrap around) are possible, such as 32-bit types. Therefore, the values returned by this intrinsic might be, or become, negative, or numerically less than previous values, during a single run of the compiled program.

     Please note, that this implementation is thread safe if used within OpenMP directives, i.e., its state will be consistent while called from multiple threads. However, if DTIME is called from multiple threads, the result is still the time since the last invocation. This may not give the intended results. If possible, use CPU_TIME instead.

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

     VALUES and TIME are INTENT(OUT) and provide the following:

       VALUES(1):   User time in seconds.
       VALUES(2):   System time in seconds.
       TIME:   Run time since start in seconds.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL DTIME(VALUES, TIME).
     TIME = DTIME(VALUES), (not recommended).

Arguments:

     VALUES  The type shall be REAL(4), DIMENSION(2).
     TIME  The type shall be REAL(4).

Return value:
     Elapsed time in seconds since the last invocation or since the start of program execution if not called before.

Example:

          program test_dtime
              integer(8) :: i, j
              real, dimension(2) :: tarray
              real :: result
              call dtime(tarray, result)
              print *, result
              print *, tarray(1)
              print *, tarray(2)
              do i=1,100000000    ! Just a delay
                  j = i * i - i
              end do
              call dtime(tarray, result)
              print *, result
              print *, tarray(1)
              print *, tarray(2)
          end program test_dtime

See also:
     CPU_TIME

EOSHIFT --- End-off shift elements of an array
==============================================

Description:
     EOSHIFT(ARRAY, SHIFT[, BOUNDARY, DIM]) performs an end-off shift on elements of ARRAY along the dimension of DIM.  If DIM is omitted it is taken to be 1.  DIM is a scalar of type INTEGER in the range of 1 \leq DIM \leq n) where n is the rank of ARRAY.  If the rank of ARRAY is one, then all elements of ARRAY are shifted by SHIFT places.  If rank is greater than one, then all complete rank one sections of ARRAY along the given dimension are shifted.  Elements shifted out one end of each rank one section are dropped.  If BOUNDARY is present then the corresponding value of from BOUNDARY is copied back in the other end.  If BOUNDARY is not present then the following are copied in depending on the type of ARRAY.

     Array Type   Boundary Value
     Numeric    0 of the type and kind of ARRAY.
     Logical    .FALSE..
     Character(LEN)   LEN blanks.

Standard:
     Fortran 95 and later

Class:
     Transformational function

Syntax:
     RESULT = EOSHIFT(ARRAY, SHIFT [, BOUNDARY, DIM])

Arguments:

     ARRAY    May be any type, not scalar.
     SHIFT    The type shall be INTEGER.
     BOUNDARY   Same type as ARRAY.
     DIM      The type shall be INTEGER.

Return value:
     Returns an array of same type and rank as the ARRAY argument.

Example:

          program test_eoshift
              integer, dimension(3,3) :: a
              a = reshape( (/ 1, 2, 3, 4, 5, 6, 7, 8, 9 /), (/ 3, 3 /))
              print '(3i3)', a(1,:)
              print '(3i3)', a(2,:)
              print '(3i3)', a(3,:)
              a = EOSHIFT(a, SHIFT=(/1, 2, 1/), BOUNDARY=-5, DIM=2)
              print *
              print '(3i3)', a(1,:)
              print '(3i3)', a(2,:)
              print '(3i3)', a(3,:)
          end program test_eoshift

EPSILON --- Epsilon function
============================

Description:
     EPSILON(X) returns the smallest number E of the same kind as X such that 1 + E > 1.

Standard:
     Fortran 95 and later

Class:
     Inquiry function

Syntax:
     RESULT = EPSILON(X)

Arguments:

     X   The type shall be REAL.

Return value:
     The return value is of same type as the argument.

Example:

          program test_epsilon
              real :: x = 3.143
              real(8) :: y = 2.33
              print *, EPSILON(x)
              print *, EPSILON(y)
          end program test_epsilon

ERF --- Error function
======================

Description:
     ERF(X) computes the error function of X.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = ERF(X)

Arguments:

     X   The type shall be REAL.

Return value:
     The return value is of type REAL, of the same kind as X and lies in the range -1 \leq erf (x) \leq 1 .

Example:

          program test_erf
            real(8) :: x = 0.17_8
            x = erf(x)
          end program test_erf

Specific names:

     Name              Argument            Return type         Standard
     DERF(X)    REAL(8) X    REAL(8)      GNU extension

ERFC --- Error function
=======================

Description:
     ERFC(X) computes the complementary error function of X.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = ERFC(X)

Arguments:

     X   The type shall be REAL.

Return value:
     The return value is of type REAL and of the same kind as X. It lies in the range  0 \leq erfc (x) \leq 2 .

Example:

          program test_erfc
            real(8) :: x = 0.17_8
            x = erfc(x)
          end program test_erfc

Specific names:

     Name              Argument            Return type         Standard
     DERFC(X)   REAL(8) X    REAL(8)      GNU extension

ERFC_SCALED --- Error function
==============================

Description:
     ERFC_SCALED(X) computes the exponentially-scaled complementary error function of X.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = ERFC_SCALED(X)

Arguments:

     X   The type shall be REAL.

Return value:
     The return value is of type REAL and of the same kind as X.

Example:

          program test_erfc_scaled
            real(8) :: x = 0.17_8
            x = erfc_scaled(x)
          end program test_erfc_scaled

ETIME --- Execution time subroutine (or function)
=================================================

Description:
     ETIME(VALUES, TIME) returns the number of seconds of runtime since the start of the process's execution in TIME.  VALUES returns the user and system components of this time in VALUES(1) and VALUES(2) respectively. TIME is equal to VALUES(1) + VALUES(2).

     On some systems, the underlying timings are represented using types with sufficiently small limits that overflows (wrap around) are possible, such as 32-bit types. Therefore, the values returned by this intrinsic might be, or become, negative, or numerically less than previous values, during a single run of the compiled program.

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

     VALUES and TIME are INTENT(OUT) and provide the following:

       VALUES(1):   User time in seconds.
       VALUES(2):   System time in seconds.
       TIME:   Run time since start in seconds.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL ETIME(VALUES, TIME).
     TIME = ETIME(VALUES), (not recommended).

Arguments:

     VALUES  The type shall be REAL(4), DIMENSION(2).
     TIME  The type shall be REAL(4).

Return value:
     Elapsed time in seconds since the start of program execution.

Example:

          program test_etime
              integer(8) :: i, j
              real, dimension(2) :: tarray
              real :: result
              call ETIME(tarray, result)
              print *, result
              print *, tarray(1)
              print *, tarray(2)
              do i=1,100000000    ! Just a delay
                  j = i * i - i
              end do
              call ETIME(tarray, result)
              print *, result
              print *, tarray(1)
              print *, tarray(2)
          end program test_etime

See also:
     CPU_TIME

EVENT_QUERY --- Query whether a coarray event has occurred
==========================================================

Description:
     EVENT_QUERY assignes the number of events to COUNT which have been posted to the EVENT variable and not yet been removed by calling EVENT WAIT. When STAT is present and the invocation was successful, it is assigned the value 0. If it is present and the invocation has failed, it is assigned a positive value and COUNT is assigned the value -1.

Standard:
     TS 18508 or later

Class:
     subroutine

Syntax:
     CALL EVENT_QUERY (EVENT, COUNT [, STAT])

Arguments:

     EVENT    (intent(IN)) Scalar of type EVENT_TYPE,
     defined in ISO_FORTRAN_ENV; shall not be coindexed.
     COUNT    (intent(out))Scalar integer with at least the
     precision of default integer.
     STAT     (optional) Scalar default-kind integer variable.

Example:

          program atomic
            use iso_fortran_env
            implicit none
            type(event_type) :: event_value_has_been_set[*]
            integer :: cnt
            if (this_image() == 1) then
              call event_query (event_value_has_been_set, cnt)
              if (cnt > 0) write(*,*) "Value has been set"
            elseif (this_image() == 2) then
              event post (event_value_has_been_set[1])
            end if
          end program atomic

EXECUTE_COMMAND_LINE --- Execute a shell command
================================================

Description:
     EXECUTE_COMMAND_LINE runs a shell command, synchronously or asynchronously.

     The COMMAND argument is passed to the shell and executed (The shell is sh on Unix systems, and cmd.exe on Windows.). If WAIT is present and has the value false, the execution of the command is asynchronous if the system supports it; otherwise, the command is executed synchronously using the C library's system call.

     The three last arguments allow the user to get status information.  After synchronous execution, EXITSTAT contains the integer exit code of the command, as returned by system.  CMDSTAT is set to zero if the command line was executed (whatever its exit status was). CMDMSG is assigned an error message if an error has occurred.

     Note that the system function need not be thread-safe. It is the responsibility of the user to ensure that system is not called concurrently.

     For asynchronous execution on supported targets, the POSIX posix_spawn or fork functions are used.  Also, a signal handler for the SIGCHLD signal is installed.

Standard:
     Fortran 2008 and later

Class:
     Subroutine

Syntax:
     CALL EXECUTE_COMMAND_LINE(COMMAND [, WAIT, EXITSTAT, CMDSTAT, CMDMSG ])

Arguments:

     COMMAND   Shall be a default CHARACTER scalar.
     WAIT   (Optional) Shall be a default LOGICAL scalar.
     EXITSTAT   (Optional) Shall be an INTEGER of the
     default kind.
     CMDSTAT   (Optional) Shall be an INTEGER of the
     default kind.
     CMDMSG   (Optional) Shall be an CHARACTER scalar of the
     default kind.

Example:

          program test_exec
            integer :: i

            call execute_command_line ("external_prog.exe", exitstat=i)
            print *, "Exit status of external_prog.exe was ", i

            call execute_command_line ("reindex_files.exe", wait=.false.)
            print *, "Now reindexing files in the background"

          end program test_exec

Note:

     Because this intrinsic is implemented in terms of the system function call, its behavior with respect to signaling is processor dependent. In particular, on POSIX-compliant systems, the SIGINT and SIGQUIT signals will be ignored, and the SIGCHLD will be blocked. As such, if the parent process is terminated, the child process might not be terminated alongside.

See also:
     SYSTEM

EXIT --- Exit the program with status.
======================================

Description:
     EXIT causes immediate termination of the program with status.  If status is omitted it returns the canonical success for the system.  All Fortran I/O units are closed.

Standard:
     GNU extension

Class:
     Subroutine

Syntax:
     CALL EXIT([STATUS])

Arguments:

     STATUS   Shall be an INTEGER of the default kind.

Return value:
     STATUS is passed to the parent process on exit.

Example:

          program test_exit
            integer :: STATUS = 0
            print *, 'This program is going to exit.'
            call EXIT(STATUS)
          end program test_exit

See also:
     ABORT, KILL

EXP --- Exponential function
============================

Description:
     EXP(X) computes the base e exponential of X.

Standard:
     Fortran 77 and later, has overloads that are GNU extensions

Class:
     Elemental function

Syntax:
     RESULT = EXP(X)

Arguments:

     X   The type shall be REAL or
     COMPLEX.

Return value:
     The return value has same type and kind as X.

Example:

          program test_exp
            real :: x = 1.0
            x = exp(x)
          end program test_exp

Specific names:

     Name              Argument               Return type           Standard
     EXP(X)     REAL(4) X       REAL(4)        Fortran 77 and later
     DEXP(X)    REAL(8) X       REAL(8)        Fortran 77 and later
     CEXP(X)    COMPLEX(4) X    COMPLEX(4)     Fortran 77 and later
     ZEXP(X)    COMPLEX(8) X    COMPLEX(8)     GNU extension
     CDEXP(X)   COMPLEX(8) X    COMPLEX(8)     GNU extension

EXPONENT --- Exponent function
==============================

Description:
     EXPONENT(X) returns the value of the exponent part of X. If X is zero the value returned is zero.

Standard:
     Fortran 95 and later

Class:
     Elemental function

Syntax:
     RESULT = EXPONENT(X)

Arguments:

     X   The type shall be REAL.

Return value:
     The return value is of type default INTEGER.

Example:

          program test_exponent
            real :: x = 1.0
            integer :: i
            i = exponent(x)
            print *, i
            print *, exponent(0.0)
          end program test_exponent

EXTENDS_TYPE_OF --- Query dynamic type for extension
====================================================

Description:
     Query dynamic type for extension.

Standard:
     Fortran 2003 and later

Class:
     Inquiry function

Syntax:
     RESULT = EXTENDS_TYPE_OF(A, MOLD)

Arguments:

     A   Shall be an object of extensible declared type or
     unlimited polymorphic.
     MOLD   Shall be an object of extensible declared type or
     unlimited polymorphic.

Return value:
     The return value is a scalar of type default logical. It is true if and only if the dynamic type of A is an extension type of the dynamic type of MOLD.

See also:
     SAME_TYPE_AS

FDATE --- Get the current time as a string
==========================================

Description:
     FDATE(DATE) returns the current date (using the same format as CTIME) in DATE. It is equivalent to CALL CTIME(DATE, TIME()).

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL FDATE(DATE).
     DATE = FDATE().

Arguments:

     DATE  The type shall be of type CHARACTER of the
     default kind. It is an INTENT(OUT) argument.  If the length of
     this variable is too short for the date and time string to fit
     completely, it will be blank on procedure return.

Return value:
     The current date and time as a string.

Example:

          program test_fdate
              integer(8) :: i, j
              character(len=30) :: date
              call fdate(date)
              print *, 'Program started on ', date
              do i = 1, 100000000 ! Just a delay
                  j = i * i - i
              end do
              call fdate(date)
              print *, 'Program ended on ', date
          end program test_fdate

See also:
     DATE_AND_TIME, CTIME

FGET --- Read a single character in stream mode from stdin
==========================================================

Description:
     Read a single character in stream mode from stdin by bypassing normal formatted output. Stream I/O should not be mixed with normal record-oriented (formatted or unformatted) I/O on the same unit; the results are unpredictable.

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

     Note that the FGET intrinsic is provided for backwards compatibility with g77.  GNU Fortran provides the Fortran 2003 Stream facility. Programmers should consider the use of new stream IO feature in new code for future portability. See also Fortran 2003 status.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL FGET(C [, STATUS])
     STATUS = FGET(C)

Arguments:

     C        The type shall be CHARACTER and of default
     kind.
     STATUS   (Optional) status flag of type INTEGER.
     Returns 0 on success, -1 on end-of-file, and a system specific positive
     error code otherwise.

Example:

          PROGRAM test_fget
            INTEGER, PARAMETER :: strlen = 100
            INTEGER :: status, i = 1
            CHARACTER(len=strlen) :: str = ""

            WRITE (*,*) 'Enter text:'
            DO
              CALL fget(str(i:i), status)
              if (status /= 0 .OR. i > strlen) exit
              i = i + 1
            END DO
            WRITE (*,*) TRIM(str)
          END PROGRAM

See also:
     FGETC, FPUT, FPUTC

FGETC --- Read a single character in stream mode
================================================

Description:
     Read a single character in stream mode by bypassing normal formatted output. Stream I/O should not be mixed with normal record-oriented (formatted or unformatted) I/O on the same unit; the results are unpredictable.

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

     Note that the FGET intrinsic is provided for backwards compatibility with g77.  GNU Fortran provides the Fortran 2003 Stream facility. Programmers should consider the use of new stream IO feature in new code for future portability. See also Fortran 2003 status.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL FGETC(UNIT, C [, STATUS])
     STATUS = FGETC(UNIT, C)

Arguments:

     UNIT     The type shall be INTEGER.
     C        The type shall be CHARACTER and of default
     kind.
     STATUS   (Optional) status flag of type INTEGER.
     Returns 0 on success, -1 on end-of-file and a system specific positive
     error code otherwise.

Example:

          PROGRAM test_fgetc
            INTEGER :: fd = 42, status
            CHARACTER :: c

            OPEN(UNIT=fd, FILE="/etc/passwd", ACTION="READ", STATUS = "OLD")
            DO
              CALL fgetc(fd, c, status)
              IF (status /= 0) EXIT
              call fput(c)
            END DO
            CLOSE(UNIT=fd)
          END PROGRAM

See also:
     FGET, FPUT, FPUTC

FINDLOC --- Search an array for a value
=======================================

Description:
     Determines the location of the element in the array with the value given in the VALUE argument, or, if the DIM argument is supplied, determines the locations of the maximum element along each row of the array in the DIM direction.  If MASK is present, only the elements for which MASK is .TRUE. are considered.  If more than one element in the array has the value VALUE, the location returned is that of the first such element in array element order if the BACK is not present or if it is .FALSE.. If BACK is true, the location returned is that of the last such element. If the array has zero size, or all of the elements of MASK are .FALSE., then the result is an array of zeroes.  Similarly, if DIM is supplied and all of the elements of MASK along a given row are zero, the result value for that row is zero.

Standard:
     Fortran 2008 and later.

Class:
     Transformational function

Syntax:

     RESULT = FINDLOC(ARRAY, VALUE, DIM [, MASK] [,KIND] [,BACK])
     RESULT = FINDLOC(ARRAY, VALUE, [, MASK] [,KIND] [,BACK])

Arguments:

     ARRAY   Shall be an array of intrinsic type.
     VALUE   A scalar of intrinsic type which is in type
     conformance with ARRAY.
     DIM   (Optional) Shall be a scalar of type
     INTEGER, with a value between one and the rank of ARRAY,
     inclusive.  It may not be an optional dummy argument.
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.
     BACK   (Optional) A scalar of type LOGICAL.

Return value:
     If DIM is absent, the result is a rank-one array with a length equal to the rank of ARRAY.  If DIM is present, the result is an array with a rank one less than the rank of ARRAY, and a size corresponding to the size of ARRAY with the DIM dimension removed.  If DIM is present and ARRAY has a rank of one, the result is a scalar.  If the optional argument KIND is present, the result is an integer of kind KIND, otherwise it is of default kind.

See also:
     MAXLOC, MINLOC

FLOOR --- Integer floor function
================================

Description:
     FLOOR(A) returns the greatest integer less than or equal to X.

Standard:
     Fortran 95 and later

Class:
     Elemental function

Syntax:
     RESULT = FLOOR(A [, KIND])

Arguments:

     A   The type shall be REAL.
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     The return value is of type INTEGER(KIND) if KIND is present and of default-kind INTEGER otherwise.

Example:

          program test_floor
              real :: x = 63.29
              real :: y = -63.59
              print *, floor(x) ! returns 63
              print *, floor(y) ! returns -64
          end program test_floor

See also:
     CEILING, NINT

FLUSH --- Flush I/O unit(s)
===========================

Description:
     Flushes Fortran unit(s) currently open for output. Without the optional argument, all units are flushed, otherwise just the unit specified.

Standard:
     GNU extension

Class:
     Subroutine

Syntax:
     CALL FLUSH(UNIT)

Arguments:

     UNIT   (Optional) The type shall be INTEGER.

Note:
     Beginning with the Fortran 2003 standard, there is a FLUSH statement that should be preferred over the FLUSH intrinsic.

     The FLUSH intrinsic and the Fortran 2003 FLUSH statement have identical effect: they flush the runtime library's I/O buffer so that the data becomes visible to other processes. This does not guarantee that the data is committed to disk.

     On POSIX systems, you can request that all data is transferred  to  the storage device by calling the fsync function, with the POSIX file descriptor of the I/O unit as argument (retrieved with GNU intrinsic FNUM). The following example shows how:

            ! Declare the interface for POSIX fsync function
            interface
              function fsync (fd) bind(c,name="fsync")
              use iso_c_binding, only: c_int
                integer(c_int), value :: fd
                integer(c_int) :: fsync
              end function fsync
            end interface

            ! Variable declaration
            integer :: ret

            ! Opening unit 10
            open (10,file="foo")

            ! ...
            ! Perform I/O on unit 10
            ! ...

            ! Flush and sync
            flush(10)
            ret = fsync(fnum(10))

            ! Handle possible error
            if (ret /= 0) stop "Error calling FSYNC"

FNUM --- File number function
=============================

Description:
     FNUM(UNIT) returns the POSIX file descriptor number corresponding to the open Fortran I/O unit UNIT.

Standard:
     GNU extension

Class:
     Function

Syntax:
     RESULT = FNUM(UNIT)

Arguments:

     UNIT   The type shall be INTEGER.

Return value:
     The return value is of type INTEGER

Example:

          program test_fnum
            integer :: i
            open (unit=10, status = "scratch")
            i = fnum(10)
            print *, i
            close (10)
          end program test_fnum

FPUT --- Write a single character in stream mode to stdout
==========================================================

Description:
     Write a single character in stream mode to stdout by bypassing normal formatted output. Stream I/O should not be mixed with normal record-oriented (formatted or unformatted) I/O on the same unit; the results are unpredictable.

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

     Note that the FGET intrinsic is provided for backwards compatibility with g77.  GNU Fortran provides the Fortran 2003 Stream facility. Programmers should consider the use of new stream IO feature in new code for future portability. See also Fortran 2003 status.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL FPUT(C [, STATUS])
     STATUS = FPUT(C)

Arguments:

     C        The type shall be CHARACTER and of default
     kind.
     STATUS   (Optional) status flag of type INTEGER.
     Returns 0 on success, -1 on end-of-file and a system specific positive
     error code otherwise.

Example:

          PROGRAM test_fput
            CHARACTER(len=10) :: str = "gfortran"
            INTEGER :: i
            DO i = 1, len_trim(str)
              CALL fput(str(i:i))
            END DO
          END PROGRAM

See also:
     FPUTC, FGET, FGETC

FPUTC --- Write a single character in stream mode
=================================================

Description:
     Write a single character in stream mode by bypassing normal formatted output. Stream I/O should not be mixed with normal record-oriented (formatted or unformatted) I/O on the same unit; the results are unpredictable.

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

     Note that the FGET intrinsic is provided for backwards compatibility with g77.  GNU Fortran provides the Fortran 2003 Stream facility. Programmers should consider the use of new stream IO feature in new code for future portability. See also Fortran 2003 status.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL FPUTC(UNIT, C [, STATUS])
     STATUS = FPUTC(UNIT, C)

Arguments:

     UNIT     The type shall be INTEGER.
     C        The type shall be CHARACTER and of default
     kind.
     STATUS   (Optional) status flag of type INTEGER.
     Returns 0 on success, -1 on end-of-file and a system specific positive
     error code otherwise.

Example:

          PROGRAM test_fputc
            CHARACTER(len=10) :: str = "gfortran"
            INTEGER :: fd = 42, i

            OPEN(UNIT = fd, FILE = "out", ACTION = "WRITE", STATUS="NEW")
            DO i = 1, len_trim(str)
              CALL fputc(fd, str(i:i))
            END DO
            CLOSE(fd)
          END PROGRAM

See also:
     FPUT, FGET, FGETC

FRACTION --- Fractional part of the model representation
========================================================

Description:
     FRACTION(X) returns the fractional part of the model representation of X.

Standard:
     Fortran 95 and later

Class:
     Elemental function

Syntax:
     Y = FRACTION(X)

Arguments:

     X   The type of the argument shall be a REAL.

Return value:
     The return value is of the same type and kind as the argument. The fractional part of the model representation of X is returned; it is X * RADIX(X)**(-EXPONENT(X)).

Example:

          program test_fraction
            real :: x
            x = 178.1387e-4
            print *, fraction(x), x * radix(x)**(-exponent(x))
          end program test_fraction

FREE --- Frees memory
=====================

Description:
     Frees memory previously allocated by MALLOC. The FREE intrinsic is an extension intended to be used with Cray pointers, and is provided in GNU Fortran to allow user to compile legacy code. For new code using Fortran 95 pointers, the memory de-allocation intrinsic is DEALLOCATE.

Standard:
     GNU extension

Class:
     Subroutine

Syntax:
     CALL FREE(PTR)

Arguments:

     PTR   The type shall be INTEGER. It represents the
     location of the memory that should be de-allocated.

Return value:
     None

Example:
     See MALLOC for an example.

See also:
     MALLOC

FSEEK --- Low level file positioning subroutine
===============================================

Description:
     Moves UNIT to the specified OFFSET. If WHENCE is set to 0, the OFFSET is taken as an absolute value SEEK_SET, if set to 1, OFFSET is taken to be relative to the current position SEEK_CUR, and if set to 2 relative to the end of the file SEEK_END. On error, STATUS is set to a nonzero value. If STATUS the seek fails silently.

     This intrinsic routine is not fully backwards compatible with g77. In g77, the FSEEK takes a statement label instead of a STATUS variable. If FSEEK is used in old code, change

            CALL FSEEK(UNIT, OFFSET, WHENCE, *label)

     to

            INTEGER :: status
            CALL FSEEK(UNIT, OFFSET, WHENCE, status)
            IF (status /= 0) GOTO label

     Please note that GNU Fortran provides the Fortran 2003 Stream facility. Programmers should consider the use of new stream IO feature in new code for future portability. See also Fortran 2003 status.

Standard:
     GNU extension

Class:
     Subroutine

Syntax:
     CALL FSEEK(UNIT, OFFSET, WHENCE[, STATUS])

Arguments:

     UNIT     Shall be a scalar of type INTEGER.
     OFFSET   Shall be a scalar of type INTEGER.
     WHENCE   Shall be a scalar of type INTEGER.
     Its value shall be either 0, 1 or 2.
     STATUS   (Optional) shall be a scalar of type
     INTEGER(4).

Example:

          PROGRAM test_fseek
            INTEGER, PARAMETER :: SEEK_SET = 0, SEEK_CUR = 1, SEEK_END = 2
            INTEGER :: fd, offset, ierr

            ierr   = 0
            offset = 5
            fd     = 10

            OPEN(UNIT=fd, FILE="fseek.test")
            CALL FSEEK(fd, offset, SEEK_SET, ierr)  ! move to OFFSET
            print *, FTELL(fd), ierr

            CALL FSEEK(fd, 0, SEEK_END, ierr)       ! move to end
            print *, FTELL(fd), ierr

            CALL FSEEK(fd, 0, SEEK_SET, ierr)       ! move to beginning
            print *, FTELL(fd), ierr

            CLOSE(UNIT=fd)
          END PROGRAM

See also:
     FTELL

FSTAT --- Get file status
=========================

Description:
     FSTAT is identical to STAT, except that information about an already opened file is obtained.

     The elements in VALUES are the same as described by STAT.

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL FSTAT(UNIT, VALUES [, STATUS])
     STATUS = FSTAT(UNIT, VALUES)

Arguments:

     UNIT     An open I/O unit number of type INTEGER.
     VALUES   The type shall be INTEGER(4), DIMENSION(13).
     STATUS   (Optional) status flag of type INTEGER(4). Returns 0
     on success and a system specific error code otherwise.

Example:
     See STAT for an example.

See also:
     To stat a link: LSTAT, to stat a file: STAT

FTELL --- Current stream position
=================================

Description:
     Retrieves the current position within an open file.

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL FTELL(UNIT, OFFSET)
     OFFSET = FTELL(UNIT)

Arguments:

     OFFSET    Shall of type INTEGER.
     UNIT      Shall of type INTEGER.

Return value:
     In either syntax, OFFSET is set to the current offset of unit number UNIT, or to -1 if the unit is not currently open.

Example:

          PROGRAM test_ftell
            INTEGER :: i
            OPEN(10, FILE="temp.dat")
            CALL ftell(10,i)
            WRITE(*,*) i
          END PROGRAM

See also:
     FSEEK

GAMMA --- Gamma function
========================

Description:
     GAMMA(X) computes Gamma (\Gamma) of X. For positive, integer values of X the Gamma function simplifies to the factorial function \Gamma(x)=(x-1)!.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     X = GAMMA(X)

Arguments:

     X   Shall be of type REAL and neither zero
     nor a negative integer.

Return value:
     The return value is of type REAL of the same kind as X.

Example:

          program test_gamma
            real :: x = 1.0
            x = gamma(x) ! returns 1.0
          end program test_gamma

Specific names:

     Name               Argument           Return type         Standard
     GAMMA(X)    REAL(4) X   REAL(4)      GNU Extension
     DGAMMA(X)   REAL(8) X   REAL(8)      GNU Extension

See also:
     Logarithm of the Gamma function: LOG_GAMMA

GERROR --- Get last system error message
========================================

Description:
     Returns the system error message corresponding to the last system error. This resembles the functionality of strerror(3) in C.

Standard:
     GNU extension

Class:
     Subroutine

Syntax:
     CALL GERROR(RESULT)

Arguments:

     RESULT    Shall of type CHARACTER and of default

Example:

          PROGRAM test_gerror
            CHARACTER(len=100) :: msg
            CALL gerror(msg)
            WRITE(*,*) msg
          END PROGRAM

See also:
     IERRNO, PERROR

GETARG --- Get command line arguments
=====================================

Description:
     Retrieve the POS-th argument that was passed on the command line when the containing program was invoked.

     This intrinsic routine is provided for backwards compatibility with GNU Fortran 77.  In new code, programmers should consider the use of the GET_COMMAND_ARGUMENT intrinsic defined by the Fortran 2003 standard.

Standard:
     GNU extension

Class:
     Subroutine

Syntax:
     CALL GETARG(POS, VALUE)

Arguments:

     POS     Shall be of type INTEGER and not wider than
     the default integer kind; POS \geq 0
     VALUE   Shall be of type CHARACTER and of default
     kind.
     VALUE   Shall be of type CHARACTER.

Return value:
     After GETARG returns, the VALUE argument holds the POSth command line argument. If VALUE cannot hold the argument, it is truncated to fit the length of VALUE. If there are less than POS arguments specified at the command line, VALUE will be filled with blanks. If POS = 0, VALUE is set to the name of the program (on systems that support this feature).

Example:

          PROGRAM test_getarg
            INTEGER :: i
            CHARACTER(len=32) :: arg

            DO i = 1, iargc()
              CALL getarg(i, arg)
              WRITE (*,*) arg
            END DO
          END PROGRAM

See also:
     GNU Fortran 77 compatibility function: IARGC

     Fortran 2003 functions and subroutines: GET_COMMAND, GET_COMMAND_ARGUMENT, COMMAND_ARGUMENT_COUNT

GET_COMMAND --- Get the entire command line
===========================================

Description:
     Retrieve the entire command line that was used to invoke the program.

Standard:
     Fortran 2003 and later

Class:
     Subroutine

Syntax:
     CALL GET_COMMAND([COMMAND, LENGTH, STATUS])

Arguments:

     COMMAND   (Optional) shall be of type CHARACTER and
     of default kind.
     LENGTH   (Optional) Shall be of type INTEGER and of
     default kind.
     STATUS   (Optional) Shall be of type INTEGER and of
     default kind.

Return value:
     If COMMAND is present, stores the entire command line that was used to invoke the program in COMMAND. If LENGTH is present, it is assigned the length of the command line. If STATUS is present, it is assigned 0 upon success of the command, -1 if COMMAND is too short to store the command line, or a positive value in case of an error.

Example:

          PROGRAM test_get_command
            CHARACTER(len=255) :: cmd
            CALL get_command(cmd)
            WRITE (*,*) TRIM(cmd)
          END PROGRAM

See also:
     GET_COMMAND_ARGUMENT, COMMAND_ARGUMENT_COUNT

GET_COMMAND_ARGUMENT --- Get command line arguments
===================================================

Description:
     Retrieve the NUMBER-th argument that was passed on the command line when the containing program was invoked.

Standard:
     Fortran 2003 and later

Class:
     Subroutine

Syntax:
     CALL GET_COMMAND_ARGUMENT(NUMBER [, VALUE, LENGTH, STATUS])

Arguments:

     NUMBER   Shall be a scalar of type INTEGER and of
     default kind, NUMBER \geq 0
     VALUE    (Optional) Shall be a scalar of type CHARACTER
     and of default kind.
     LENGTH   (Optional) Shall be a scalar of type INTEGER
     and of default kind.
     STATUS   (Optional) Shall be a scalar of type INTEGER
     and of default kind.

Return value:
     After GET_COMMAND_ARGUMENT returns, the VALUE argument holds the NUMBER-th command line argument. If VALUE cannot hold the argument, it is truncated to fit the length of VALUE. If there are less than NUMBER arguments specified at the command line, VALUE will be filled with blanks. If NUMBER = 0, VALUE is set to the name of the program (on systems that support this feature). The LENGTH argument contains the length of the NUMBER-th command line argument. If the argument retrieval fails, STATUS is a positive number; if VALUE contains a truncated command line argument, STATUS is -1; and otherwise the STATUS is zero.

Example:

          PROGRAM test_get_command_argument
            INTEGER :: i
            CHARACTER(len=32) :: arg

            i = 0
            DO
              CALL get_command_argument(i, arg)
              IF (LEN_TRIM(arg) == 0) EXIT

              WRITE (*,*) TRIM(arg)
              i = i+1
            END DO
          END PROGRAM

See also:
     GET_COMMAND, COMMAND_ARGUMENT_COUNT

GETCWD --- Get current working directory
========================================

Description:
     Get current working directory.

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL GETCWD(C [, STATUS])
     STATUS = GETCWD(C)

Arguments:

     C   The type shall be CHARACTER and of default kind.
     STATUS   (Optional) status flag. Returns 0 on success,
     a system specific and nonzero error code otherwise.

Example:

          PROGRAM test_getcwd
            CHARACTER(len=255) :: cwd
            CALL getcwd(cwd)
            WRITE(*,*) TRIM(cwd)
          END PROGRAM

See also:
     CHDIR

GETENV --- Get an environmental variable
========================================

Description:
     Get the VALUE of the environmental variable NAME.

     This intrinsic routine is provided for backwards compatibility with GNU Fortran 77.  In new code, programmers should consider the use of the GET_ENVIRONMENT_VARIABLE intrinsic defined by the Fortran 2003 standard.

     Note that GETENV need not be thread-safe. It is the responsibility of the user to ensure that the environment is not being updated concurrently with a call to the GETENV intrinsic.

Standard:
     GNU extension

Class:
     Subroutine

Syntax:
     CALL GETENV(NAME, VALUE)

Arguments:

     NAME    Shall be of type CHARACTER and of default kind.
     VALUE   Shall be of type CHARACTER and of default kind.

Return value:
     Stores the value of NAME in VALUE. If VALUE is not large enough to hold the data, it is truncated. If NAME is not set, VALUE will be filled with blanks.

Example:

          PROGRAM test_getenv
            CHARACTER(len=255) :: homedir
            CALL getenv("HOME", homedir)
            WRITE (*,*) TRIM(homedir)
          END PROGRAM

See also:
     GET_ENVIRONMENT_VARIABLE

GET_ENVIRONMENT_VARIABLE --- Get an environmental variable
==========================================================

Description:
     Get the VALUE of the environmental variable NAME.

     Note that GET_ENVIRONMENT_VARIABLE need not be thread-safe. It is the responsibility of the user to ensure that the environment is not being updated concurrently with a call to the GET_ENVIRONMENT_VARIABLE intrinsic.

Standard:
     Fortran 2003 and later

Class:
     Subroutine

Syntax:
     CALL GET_ENVIRONMENT_VARIABLE(NAME[, VALUE, LENGTH, STATUS, TRIM_NAME)

Arguments:

     NAME        Shall be a scalar of type CHARACTER
     and of default kind.
     VALUE       (Optional) Shall be a scalar of type CHARACTER
     and of default kind.
     LENGTH      (Optional) Shall be a scalar of type INTEGER
     and of default kind.
     STATUS      (Optional) Shall be a scalar of type INTEGER
     and of default kind.
     TRIM_NAME   (Optional) Shall be a scalar of type LOGICAL
     and of default kind.

Return value:
     Stores the value of NAME in VALUE. If VALUE is not large enough to hold the data, it is truncated. If NAME is not set, VALUE will be filled with blanks. Argument LENGTH contains the length needed for storing the environment variable NAME or zero if it is not present. STATUS is -1 if VALUE is present but too short for the environment variable; it is 1 if the environment variable does not exist and 2 if the processor does not support environment variables; in all other cases STATUS is zero. If TRIM_NAME is present with the value .FALSE., the trailing blanks in NAME are significant; otherwise they are not part of the environment variable name.

Example:

          PROGRAM test_getenv
            CHARACTER(len=255) :: homedir
            CALL get_environment_variable("HOME", homedir)
            WRITE (*,*) TRIM(homedir)
          END PROGRAM

GETGID --- Group ID function
============================

Description:
     Returns the numerical group ID of the current process.

Standard:
     GNU extension

Class:
     Function

Syntax:
     RESULT = GETGID()

Return value:
     The return value of GETGID is an INTEGER of the default kind.

Example:
     See GETPID for an example.

See also:
     GETPID, GETUID

GETLOG --- Get login name
=========================

Description:
     Gets the username under which the program is running.

Standard:
     GNU extension

Class:
     Subroutine

Syntax:
     CALL GETLOG(C)

Arguments:

     C   Shall be of type CHARACTER and of default kind.

Return value:
     Stores the current user name in LOGIN.  (On systems where POSIX functions geteuid and getpwuid are not available, and the getlogin function is not implemented either, this will return a blank string.)

Example:

          PROGRAM TEST_GETLOG
            CHARACTER(32) :: login
            CALL GETLOG(login)
            WRITE(*,*) login
          END PROGRAM

See also:
     GETUID

GETPID --- Process ID function
==============================

Description:
     Returns the numerical process identifier of the current process.

Standard:
     GNU extension

Class:
     Function

Syntax:
     RESULT = GETPID()

Return value:
     The return value of GETPID is an INTEGER of the default kind.

Example:

          program info
            print *, "The current process ID is ", getpid()
            print *, "Your numerical user ID is ", getuid()
            print *, "Your numerical group ID is ", getgid()
          end program info

See also:
     GETGID, GETUID

GETUID --- User ID function
===========================

Description:
     Returns the numerical user ID of the current process.

Standard:
     GNU extension

Class:
     Function

Syntax:
     RESULT = GETUID()

Return value:
     The return value of GETUID is an INTEGER of the default kind.

Example:
     See GETPID for an example.

See also:
     GETPID, GETLOG

GMTIME --- Convert time to GMT info
===================================

Description:
     Given a system time value TIME (as provided by the TIME intrinsic), fills VALUES with values extracted from it appropriate to the UTC time zone (Universal Coordinated Time, also known in some countries as GMT, Greenwich Mean Time), using gmtime(3).

     This intrinsic routine is provided for backwards compatibility with GNU Fortran 77.  In new code, programmers should consider the use of the DATE_AND_TIME intrinsic defined by the Fortran 95 standard.

Standard:
     GNU extension

Class:
     Subroutine

Syntax:
     CALL GMTIME(TIME, VALUES)

Arguments:

     TIME     An INTEGER scalar expression
     corresponding to a system time, with INTENT(IN).
     VALUES   A default INTEGER array with 9 elements,
     with INTENT(OUT).

Return value:
     The elements of VALUES are assigned as follows:

      1. Seconds after the minute, range 0--59 or 0--61 to allow for leap seconds

      2. Minutes after the hour, range 0--59

      3. Hours past midnight, range 0--23

      4. Day of month, range 1--31

      5. Number of months since January, range 0--11

      6. Years since 1900

      7. Number of days since Sunday, range 0--6

      8. Days since January 1, range 0--365

      9. Daylight savings indicator: positive if daylight savings is in effect, zero if not, and negative if the information is not available.

See also:
     DATE_AND_TIME, CTIME, LTIME, TIME, TIME8

HOSTNM --- Get system host name
===============================

Description:
     Retrieves the host name of the system on which the program is running.

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL HOSTNM(C [, STATUS])
     STATUS = HOSTNM(NAME)

Arguments:

     C      Shall of type CHARACTER and of default kind.
     STATUS    (Optional) status flag of type INTEGER.
     Returns 0 on success, or a system specific error code otherwise.

Return value:
     In either syntax, NAME is set to the current hostname if it can be obtained, or to a blank string otherwise.

HUGE --- Largest number of a kind
=================================

Description:
     HUGE(X) returns the largest number that is not an infinity in the model of the type of X.

Standard:
     Fortran 95 and later

Class:
     Inquiry function

Syntax:
     RESULT = HUGE(X)

Arguments:

     X   Shall be of type REAL or INTEGER.

Return value:
     The return value is of the same type and kind as X

Example:

          program test_huge_tiny
            print *, huge(0), huge(0.0), huge(0.0d0)
            print *, tiny(0.0), tiny(0.0d0)
          end program test_huge_tiny

HYPOT --- Euclidean distance function
=====================================

Description:
     HYPOT(X,Y) is the Euclidean distance function. It is equal to \sqrtX^2 + Y^2, without undue underflow or overflow.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = HYPOT(X, Y)

Arguments:

     X   The type shall be REAL.
     Y   The type and kind type parameter shall be the same as
     X.

Return value:
     The return value has the same type and kind type parameter as X.

Example:

          program test_hypot
            real(4) :: x = 1.e0_4, y = 0.5e0_4
            x = hypot(x,y)
          end program test_hypot

IACHAR --- Code in ASCII collating sequence
===========================================

Description:
     IACHAR(C) returns the code for the ASCII character in the first character position of C.

Standard:
     Fortran 95 and later, with KIND argument Fortran 2003 and later

Class:
     Elemental function

Syntax:
     RESULT = IACHAR(C [, KIND])

Arguments:

     C      Shall be a scalar CHARACTER, with INTENT(IN)
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     The return value is of type INTEGER and of kind KIND. If KIND is absent, the return value is of default integer kind.

Example:

          program test_iachar
            integer i
            i = iachar(' ')
          end program test_iachar

Note:
     See ICHAR for a discussion of converting between numerical values and formatted string representations.

See also:
     ACHAR, CHAR, ICHAR

IALL --- Bitwise AND of array elements
======================================

Description:
     Reduces with bitwise AND the elements of ARRAY along dimension DIM if the corresponding element in MASK is TRUE.

Standard:
     Fortran 2008 and later

Class:
     Transformational function

Syntax:

     RESULT = IALL(ARRAY[, MASK])
     RESULT = IALL(ARRAY, DIM[, MASK])

Arguments:

     ARRAY   Shall be an array of type INTEGER
     DIM     (Optional) shall be a scalar of type
     INTEGER with a value in the range from 1 to n, where n
     equals the rank of ARRAY.
     MASK    (Optional) shall be of type LOGICAL
     and either be a scalar or an array of the same shape as ARRAY.

Return value:
     The result is of the same type as ARRAY.

     If DIM is absent, a scalar with the bitwise ALL of all elements in ARRAY is returned. Otherwise, an array of rank n-1, where n equals the rank of ARRAY, and a shape similar to that of ARRAY with dimension DIM dropped is returned.

Example:

          PROGRAM test_iall
            INTEGER(1) :: a(2)

            a(1) = b'00100100'
            a(2) = b'01101010'

            ! prints 00100000
            PRINT '(b8.8)', IALL(a)
          END PROGRAM

See also:
     IANY, IPARITY, IAND

IAND --- Bitwise logical and
============================

Description:
     Bitwise logical AND.

Standard:
     Fortran 95 and later, has overloads that are GNU extensions

Class:
     Elemental function

Syntax:
     RESULT = IAND(I, J)

Arguments:

     I   The type shall be INTEGER or a boz-literal-constant.
     J   The type shall be INTEGER with the same
     kind type parameter as I or a boz-literal-constant.
     I and J shall not both be boz-literal-constants.

Return value:
     The return type is INTEGER with the kind type parameter of the arguments. A boz-literal-constant is converted to an INTEGER with the kind type parameter of the other argument as-if a call to INT occurred.

Example:

          PROGRAM test_iand
            INTEGER :: a, b
            DATA a / Z'F' /, b / Z'3' /
            WRITE (*,*) IAND(a, b)
          END PROGRAM

Specific names:

     Name              Argument              Return type         Standard
     IAND(A)     INTEGER A      INTEGER      Fortran 95 and later
     BIAND(A)   INTEGER(1) A   INTEGER(1)   GNU extension
     IIAND(A)   INTEGER(2) A   INTEGER(2)   GNU extension
     JIAND(A)   INTEGER(4) A   INTEGER(4)   GNU extension
     KIAND(A)   INTEGER(8) A   INTEGER(8)   GNU extension

See also:
     IOR, IEOR, IBITS, IBSET, IBCLR, NOT

IANY --- Bitwise OR of array elements
=====================================

Description:
     Reduces with bitwise OR (inclusive or) the elements of ARRAY along dimension DIM if the corresponding element in MASK is TRUE.

Standard:
     Fortran 2008 and later

Class:
     Transformational function

Syntax:

     RESULT = IANY(ARRAY[, MASK])
     RESULT = IANY(ARRAY, DIM[, MASK])

Arguments:

     ARRAY   Shall be an array of type INTEGER
     DIM     (Optional) shall be a scalar of type
     INTEGER with a value in the range from 1 to n, where n
     equals the rank of ARRAY.
     MASK    (Optional) shall be of type LOGICAL
     and either be a scalar or an array of the same shape as ARRAY.

Return value:
     The result is of the same type as ARRAY.

     If DIM is absent, a scalar with the bitwise OR of all elements in ARRAY is returned. Otherwise, an array of rank n-1, where n equals the rank of ARRAY, and a shape similar to that of ARRAY with dimension DIM dropped is returned.

Example:

          PROGRAM test_iany
            INTEGER(1) :: a(2)

            a(1) = b'00100100'
            a(2) = b'01101010'

            ! prints 01101110
            PRINT '(b8.8)', IANY(a)
          END PROGRAM

See also:
     IPARITY, IALL, IOR

IARGC --- Get the number of command line arguments
==================================================

Description:
     IARGC returns the number of arguments passed on the command line when the containing program was invoked.

     This intrinsic routine is provided for backwards compatibility with GNU Fortran 77.  In new code, programmers should consider the use of the COMMAND_ARGUMENT_COUNT intrinsic defined by the Fortran 2003 standard.

Standard:
     GNU extension

Class:
     Function

Syntax:
     RESULT = IARGC()

Arguments:
     None.

Return value:
     The number of command line arguments, type INTEGER(4).

Example:
     See GETARG

See also:
     GNU Fortran 77 compatibility subroutine: GETARG

     Fortran 2003 functions and subroutines: GET_COMMAND, GET_COMMAND_ARGUMENT, COMMAND_ARGUMENT_COUNT

IBCLR --- Clear bit
===================

Description:
     IBCLR returns the value of I with the bit at position POS set to zero.

Standard:
     Fortran 95 and later, has overloads that are GNU extensions

Class:
     Elemental function

Syntax:
     RESULT = IBCLR(I, POS)

Arguments:

     I   The type shall be INTEGER.
     POS   The type shall be INTEGER.

Return value:
     The return value is of type INTEGER and of the same kind as I.

Specific names:

     Name              Argument              Return type         Standard
     IBCLR(A)     INTEGER A      INTEGER      Fortran 95 and later
     BBCLR(A)   INTEGER(1) A   INTEGER(1)   GNU extension
     IIBCLR(A)   INTEGER(2) A   INTEGER(2)   GNU extension
     JIBCLR(A)   INTEGER(4) A   INTEGER(4)   GNU extension
     KIBCLR(A)   INTEGER(8) A   INTEGER(8)   GNU extension

See also:
     IBITS, IBSET, IAND, IOR, IEOR, MVBITS

IBITS --- Bit extraction
========================

Description:
     IBITS extracts a field of length LEN from I, starting from bit position POS and extending left for LEN bits.  The result is right-justified and the remaining bits are zeroed.  The value of POS+LEN must be less than or equal to the value BIT_SIZE(I).

Standard:
     Fortran 95 and later, has overloads that are GNU extensions

Class:
     Elemental function

Syntax:
     RESULT = IBITS(I, POS, LEN)

Arguments:

     I     The type shall be INTEGER.
     POS   The type shall be INTEGER.
     LEN   The type shall be INTEGER.

Return value:
     The return value is of type INTEGER and of the same kind as I.

Specific names:

     Name              Argument              Return type         Standard
     IBITS(A)     INTEGER A      INTEGER      Fortran 95 and later
     BBITS(A)   INTEGER(1) A   INTEGER(1)   GNU extension
     IIBITS(A)   INTEGER(2) A   INTEGER(2)   GNU extension
     JIBITS(A)   INTEGER(4) A   INTEGER(4)   GNU extension
     KIBITS(A)   INTEGER(8) A   INTEGER(8)   GNU extension

See also:
     BIT_SIZE, IBCLR, IBSET, IAND, IOR, IEOR

IBSET --- Set bit
=================

Description:
     IBSET returns the value of I with the bit at position POS set to one.

Standard:
     Fortran 95 and later, has overloads that are GNU extensions

Class:
     Elemental function

Syntax:
     RESULT = IBSET(I, POS)

Arguments:

     I   The type shall be INTEGER.
     POS   The type shall be INTEGER.

Return value:
     The return value is of type INTEGER and of the same kind as I.

Specific names:

     Name              Argument              Return type         Standard
     IBSET(A)     INTEGER A      INTEGER      Fortran 95 and later
     BBSET(A)   INTEGER(1) A   INTEGER(1)   GNU extension
     IIBSET(A)   INTEGER(2) A   INTEGER(2)   GNU extension
     JIBSET(A)   INTEGER(4) A   INTEGER(4)   GNU extension
     KIBSET(A)   INTEGER(8) A   INTEGER(8)   GNU extension

See also:
     IBCLR, IBITS, IAND, IOR, IEOR, MVBITS

ICHAR --- Character-to-integer conversion function
==================================================

Description:
     ICHAR(C) returns the code for the character in the first character position of C in the system's native character set. The correspondence between characters and their codes is not necessarily the same across different GNU Fortran implementations.

Standard:
     Fortran 95 and later, with KIND argument Fortran 2003 and later

Class:
     Elemental function

Syntax:
     RESULT = ICHAR(C [, KIND])

Arguments:

     C      Shall be a scalar CHARACTER, with INTENT(IN)
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     The return value is of type INTEGER and of kind KIND. If KIND is absent, the return value is of default integer kind.

Example:

          program test_ichar
            integer i
            i = ichar(' ')
          end program test_ichar

Specific names:

     Name               Argument               Return type         Standard
     ICHAR(C)    CHARACTER C     INTEGER(4)      Fortran 77 and later

Note:
     No intrinsic exists to convert between a numeric value and a formatted character string representation -- for instance, given the CHARACTER value '154', obtaining an INTEGER or REAL value with the value 154, or vice versa. Instead, this functionality is provided by internal-file I/O, as in the following example:

          program read_val
            integer value
            character(len=10) string, string2
            string = '154'

            ! Convert a string to a numeric value
            read (string,'(I10)') value
            print *, value

            ! Convert a value to a formatted string
            write (string2,'(I10)') value
            print *, string2
          end program read_val

See also:
     ACHAR, CHAR, IACHAR

IDATE --- Get current local time subroutine (day/month/year)
============================================================

Description:
     IDATE(VALUES) Fills VALUES with the numerical values at the current local time. The day (in the range 1-31), month (in the range 1-12), and year appear in elements 1, 2, and 3 of VALUES, respectively. The year has four significant digits.

     This intrinsic routine is provided for backwards compatibility with GNU Fortran 77.  In new code, programmers should consider the use of the DATE_AND_TIME intrinsic defined by the Fortran 95 standard.

Standard:
     GNU extension

Class:
     Subroutine

Syntax:
     CALL IDATE(VALUES)

Arguments:

     VALUES   The type shall be INTEGER, DIMENSION(3) and
     the kind shall be the default integer kind.

Return value:
     Does not return anything.

Example:

          program test_idate
            integer, dimension(3) :: tarray
            call idate(tarray)
            print *, tarray(1)
            print *, tarray(2)
            print *, tarray(3)
          end program test_idate

See also:
     DATE_AND_TIME

IEOR --- Bitwise logical exclusive or
=====================================

Description:
     IEOR returns the bitwise Boolean exclusive-OR of I and J.

Standard:
     Fortran 95 and later, has overloads that are GNU extensions

Class:
     Elemental function

Syntax:
     RESULT = IEOR(I, J)

Arguments:

     I   The type shall be INTEGER or a boz-literal-constant.
     J   The type shall be INTEGER with the same
     kind type parameter as I or a boz-literal-constant.
     I and J shall not both be boz-literal-constants.

Return value:
     The return type is INTEGER with the kind type parameter of the arguments. A boz-literal-constant is converted to an INTEGER with the kind type parameter of the other argument as-if a call to INT occurred.

Specific names:

     Name              Argument              Return type         Standard
     IEOR(A)     INTEGER A      INTEGER      Fortran 95 and later
     BIEOR(A)   INTEGER(1) A   INTEGER(1)   GNU extension
     IIEOR(A)   INTEGER(2) A   INTEGER(2)   GNU extension
     JIEOR(A)   INTEGER(4) A   INTEGER(4)   GNU extension
     KIEOR(A)   INTEGER(8) A   INTEGER(8)   GNU extension

See also:
     IOR, IAND, IBITS, IBSET, IBCLR, NOT

IERRNO --- Get the last system error number
===========================================

Description:
     Returns the last system error number, as given by the C errno variable.

Standard:
     GNU extension

Class:
     Function

Syntax:
     RESULT = IERRNO()

Arguments:
     None.

Return value:
     The return value is of type INTEGER and of the default integer kind.

See also:
     PERROR

IMAGE_INDEX --- Function that converts a cosubscript to an image index
======================================================================

Description:
     Returns the image index belonging to a cosubscript.

Standard:
     Fortran 2008 and later

Class:
     Inquiry function.

Syntax:
     RESULT = IMAGE_INDEX(COARRAY, SUB)

Arguments: None.

     COARRAY   Coarray of any type.
     SUB       default integer rank-1 array of a size equal to
     the corank of COARRAY.

Return value:
     Scalar default integer with the value of the image index which corresponds to the cosubscripts. For invalid cosubscripts the result is zero.

Example:

          INTEGER :: array[2,-1:4,8,*]
          ! Writes  28 (or 0 if there are fewer than 28 images)
          WRITE (*,*) IMAGE_INDEX (array, [2,0,3,1])

See also:
     THIS_IMAGE, NUM_IMAGES

INDEX --- Position of a substring within a string
=================================================

Description:
     Returns the position of the start of the first occurrence of string SUBSTRING as a substring in STRING, counting from one.  If SUBSTRING is not present in STRING, zero is returned.  If the BACK argument is present and true, the return value is the start of the last occurrence rather than the first.

Standard:
     Fortran 77 and later, with KIND argument Fortran 2003 and later

Class:
     Elemental function

Syntax:
     RESULT = INDEX(STRING, SUBSTRING [, BACK [, KIND]])

Arguments:

     STRING   Shall be a scalar CHARACTER, with
     INTENT(IN)
     SUBSTRING   Shall be a scalar CHARACTER, with
     INTENT(IN)
     BACK   (Optional) Shall be a scalar LOGICAL, with
     INTENT(IN)
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     The return value is of type INTEGER and of kind KIND. If KIND is absent, the return value is of default integer kind.

Specific names:

     Name                              Argument             Return type         Standard
     INDEX(STRING, SUBSTRING)   CHARACTER     INTEGER(4)   Fortran 77 and later

See also:
     SCAN, VERIFY

INT --- Convert to integer type
===============================

Description:
     Convert to integer type

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = INT(A [, KIND))

Arguments:

     A      Shall be of type INTEGER,
     REAL, or COMPLEX.
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     These functions return a INTEGER variable or array under the following rules:

     (A)
          If A is of type INTEGER, INT(A) = A

     (B)
          If A is of type REAL and |A| < 1, INT(A)
          equals 0. If |A| \geq 1, then INT(A) is the integer
          whose magnitude is the largest integer that does not exceed the magnitude
          of A and whose sign is the same as the sign of A.

     (C)
          If A is of type COMPLEX, rule B is applied to the real part of A.

Example:

          program test_int
            integer :: i = 42
            complex :: z = (-3.7, 1.0)
            print *, int(i)
            print *, int(z), int(z,8)
          end program

Specific names:

     Name              Argument            Return type         Standard
     INT(A)     REAL(4) A    INTEGER      Fortran 77 and later
     IFIX(A)    REAL(4) A    INTEGER      Fortran 77 and later
     IDINT(A)   REAL(8) A    INTEGER      Fortran 77 and later

INT2 --- Convert to 16-bit integer type
=======================================

Description:
     Convert to a KIND=2 integer type. This is equivalent to the standard INT intrinsic with an optional argument of KIND=2, and is only included for backwards compatibility.

     The SHORT intrinsic is equivalent to INT2.

Standard:
     GNU extension

Class:
     Elemental function

Syntax:
     RESULT = INT2(A)

Arguments:

     A      Shall be of type INTEGER,
     REAL, or COMPLEX.

Return value:
     The return value is a INTEGER(2) variable.

See also:
     INT, INT8, LONG

INT8 --- Convert to 64-bit integer type
=======================================

Description:
     Convert to a KIND=8 integer type. This is equivalent to the standard INT intrinsic with an optional argument of KIND=8, and is only included for backwards compatibility.

Standard:
     GNU extension

Class:
     Elemental function

Syntax:
     RESULT = INT8(A)

Arguments:

     A      Shall be of type INTEGER,
     REAL, or COMPLEX.

Return value:
     The return value is a INTEGER(8) variable.

See also:
     INT, INT2, LONG

IOR --- Bitwise logical or
==========================

Description:
     IOR returns the bitwise Boolean inclusive-OR of I and J.

Standard:
     Fortran 95 and later, has overloads that are GNU extensions

Class:
     Elemental function

Syntax:
     RESULT = IOR(I, J)

Arguments:

     I   The type shall be INTEGER or a boz-literal-constant.
     J   The type shall be INTEGER with the same
     kind type parameter as I or a boz-literal-constant.
     I and J shall not both be boz-literal-constants.

Return value:
     The return type is INTEGER with the kind type parameter of the arguments. A boz-literal-constant is converted to an INTEGER with the kind type parameter of the other argument as-if a call to INT occurred.

Specific names:

     Name              Argument              Return type         Standard
     IOR(A)     INTEGER A      INTEGER      Fortran 95 and later
     BIOR(A)   INTEGER(1) A   INTEGER(1)   GNU extension
     IIOR(A)   INTEGER(2) A   INTEGER(2)   GNU extension
     JIOR(A)   INTEGER(4) A   INTEGER(4)   GNU extension
     KIOR(A)   INTEGER(8) A   INTEGER(8)   GNU extension

See also:
     IEOR, IAND, IBITS, IBSET, IBCLR, NOT

IPARITY --- Bitwise XOR of array elements
=========================================

Description:
     Reduces with bitwise XOR (exclusive or) the elements of ARRAY along dimension DIM if the corresponding element in MASK is TRUE.

Standard:
     Fortran 2008 and later

Class:
     Transformational function

Syntax:

     RESULT = IPARITY(ARRAY[, MASK])
     RESULT = IPARITY(ARRAY, DIM[, MASK])

Arguments:

     ARRAY   Shall be an array of type INTEGER
     DIM     (Optional) shall be a scalar of type
     INTEGER with a value in the range from 1 to n, where n
     equals the rank of ARRAY.
     MASK    (Optional) shall be of type LOGICAL
     and either be a scalar or an array of the same shape as ARRAY.

Return value:
     The result is of the same type as ARRAY.

     If DIM is absent, a scalar with the bitwise XOR of all elements in ARRAY is returned. Otherwise, an array of rank n-1, where n equals the rank of ARRAY, and a shape similar to that of ARRAY with dimension DIM dropped is returned.

Example:

          PROGRAM test_iparity
            INTEGER(1) :: a(2)

            a(1) = b'00100100'
            a(2) = b'01101010'

            ! prints 01001110
            PRINT '(b8.8)', IPARITY(a)
          END PROGRAM

See also:
     IANY, IALL, IEOR, PARITY

IRAND --- Integer pseudo-random number
======================================

Description:
     IRAND(FLAG) returns a pseudo-random number from a uniform distribution between 0 and a system-dependent limit (which is in most cases 2147483647). If FLAG is 0, the next number in the current sequence is returned; if FLAG is 1, the generator is restarted by CALL SRAND(0); if FLAG has any other value, it is used as a new seed with SRAND.

     This intrinsic routine is provided for backwards compatibility with GNU Fortran 77. It implements a simple modulo generator as provided by g77. For new code, one should consider the use of RANDOM_NUMBER as it implements a superior algorithm.

Standard:
     GNU extension

Class:
     Function

Syntax:
     RESULT = IRAND(I)

Arguments:

     I   Shall be a scalar INTEGER of kind 4.

Return value:
     The return value is of INTEGER(kind=4) type.

Example:

          program test_irand
            integer,parameter :: seed = 86456

            call srand(seed)
            print *, irand(), irand(), irand(), irand()
            print *, irand(seed), irand(), irand(), irand()
          end program test_irand

IS_CONTIGUOUS --- Test whether an array is contiguous
=====================================================

Description:
     IS_CONTIGUOUS tests whether an array is contiguous.

Standard:
     Fortran 2008 and later

Class:
     Inquiry function

Syntax:
     RESULT = IS_CONTIGUOUS(ARRAY)

Arguments:

     ARRAY   Shall be an array of any type.

Return value:
     Returns a LOGICAL of the default kind, which .TRUE. if ARRAY is contiguous and false otherwise.

Example:

          program test
            integer :: a(10)
            a = [1,2,3,4,5,6,7,8,9,10]
            call sub (a)      ! every element, is contiguous
            call sub (a(::2)) ! every other element, is noncontiguous
          contains
            subroutine sub (x)
              integer :: x(:)
              if (is_contiguous (x)) then
                write (*,*) 'X is contiguous'
              else
                write (*,*) 'X is not contiguous'
              end if
            end subroutine sub
          end program test

IS_IOSTAT_END --- Test for end-of-file value
============================================

Description:
     IS_IOSTAT_END tests whether an variable has the value of the I/O status ``end of file''. The function is equivalent to comparing the variable with the IOSTAT_END parameter of the intrinsic module ISO_FORTRAN_ENV.

Standard:
     Fortran 2003 and later

Class:
     Elemental function

Syntax:
     RESULT = IS_IOSTAT_END(I)

Arguments:

     I   Shall be of the type INTEGER.

Return value:
     Returns a LOGICAL of the default kind, which .TRUE. if I has the value which indicates an end of file condition for IOSTAT= specifiers, and is .FALSE. otherwise.

Example:

          PROGRAM iostat
            IMPLICIT NONE
            INTEGER :: stat, i
            OPEN(88, FILE='test.dat')
            READ(88, *, IOSTAT=stat) i
            IF(IS_IOSTAT_END(stat)) STOP 'END OF FILE'
          END PROGRAM

IS_IOSTAT_EOR --- Test for end-of-record value
==============================================

Description:
     IS_IOSTAT_EOR tests whether an variable has the value of the I/O status ``end of record''. The function is equivalent to comparing the variable with the IOSTAT_EOR parameter of the intrinsic module ISO_FORTRAN_ENV.

Standard:
     Fortran 2003 and later

Class:
     Elemental function

Syntax:
     RESULT = IS_IOSTAT_EOR(I)

Arguments:

     I   Shall be of the type INTEGER.

Return value:
     Returns a LOGICAL of the default kind, which .TRUE. if I has the value which indicates an end of file condition for IOSTAT= specifiers, and is .FALSE. otherwise.

Example:

          PROGRAM iostat
            IMPLICIT NONE
            INTEGER :: stat, i(50)
            OPEN(88, FILE='test.dat', FORM='UNFORMATTED')
            READ(88, IOSTAT=stat) i
            IF(IS_IOSTAT_EOR(stat)) STOP 'END OF RECORD'
          END PROGRAM

ISATTY --- Whether a unit is a terminal device.
===============================================

Description:
     Determine whether a unit is connected to a terminal device.

Standard:
     GNU extension

Class:
     Function

Syntax:
     RESULT = ISATTY(UNIT)

Arguments:

     UNIT   Shall be a scalar INTEGER.

Return value:
     Returns .TRUE. if the UNIT is connected to a terminal device, .FALSE. otherwise.

Example:

          PROGRAM test_isatty
            INTEGER(kind=1) :: unit
            DO unit = 1, 10
              write(*,*) isatty(unit=unit)
            END DO
          END PROGRAM

See also:
     TTYNAM

ISHFT --- Shift bits
====================

Description:
     ISHFT returns a value corresponding to I with all of the bits shifted SHIFT places.  A value of SHIFT greater than zero corresponds to a left shift, a value of zero corresponds to no shift, and a value less than zero corresponds to a right shift.  If the absolute value of SHIFT is greater than BIT_SIZE(I), the value is undefined.  Bits shifted out from the left end or right end are lost; zeros are shifted in from the opposite end.

Standard:
     Fortran 95 and later, has overloads that are GNU extensions

Class:
     Elemental function

Syntax:
     RESULT = ISHFT(I, SHIFT)

Arguments:

     I   The type shall be INTEGER.
     SHIFT   The type shall be INTEGER.

Return value:
     The return value is of type INTEGER and of the same kind as I.

Specific names:

     Name              Argument              Return type         Standard
     ISHFT(A)     INTEGER A      INTEGER      Fortran 95 and later
     BSHFT(A)   INTEGER(1) A   INTEGER(1)   GNU extension
     IISHFT(A)   INTEGER(2) A   INTEGER(2)   GNU extension
     JISHFT(A)   INTEGER(4) A   INTEGER(4)   GNU extension
     KISHFT(A)   INTEGER(8) A   INTEGER(8)   GNU extension

See also:
     ISHFTC

ISHFTC --- Shift bits circularly
================================

Description:
     ISHFTC returns a value corresponding to I with the rightmost SIZE bits shifted circularly SHIFT places; that is, bits shifted out one end are shifted into the opposite end.  A value of SHIFT greater than zero corresponds to a left shift, a value of zero corresponds to no shift, and a value less than zero corresponds to a right shift.  The absolute value of SHIFT must be less than SIZE.  If the SIZE argument is omitted, it is taken to be equivalent to BIT_SIZE(I).

Standard:
     Fortran 95 and later, has overloads that are GNU extensions

Class:
     Elemental function

Syntax:
     RESULT = ISHFTC(I, SHIFT [, SIZE])

Arguments:

     I   The type shall be INTEGER.
     SHIFT   The type shall be INTEGER.
     SIZE   (Optional) The type shall be INTEGER;
     the value must be greater than zero and less than or equal to
     BIT_SIZE(I).

Return value:
     The return value is of type INTEGER and of the same kind as I.

Specific names:

     Name              Argument              Return type         Standard
     ISHFTC(A)     INTEGER A      INTEGER      Fortran 95 and later
     BSHFTC(A)   INTEGER(1) A   INTEGER(1)   GNU extension
     IISHFTC(A)   INTEGER(2) A   INTEGER(2)   GNU extension
     JISHFTC(A)   INTEGER(4) A   INTEGER(4)   GNU extension
     KISHFTC(A)   INTEGER(8) A   INTEGER(8)   GNU extension

See also:
     ISHFT

ISNAN --- Test for a NaN
========================

Description:
     ISNAN tests whether a floating-point value is an IEEE Not-a-Number (NaN).

Standard:
     GNU extension

Class:
     Elemental function

Syntax:
     ISNAN(X)

Arguments:

     X   Variable of the type REAL.

Return value:
     Returns a default-kind LOGICAL. The returned value is TRUE if X is a NaN and FALSE otherwise.

Example:

          program test_nan
            implicit none
            real :: x
            x = -1.0
            x = sqrt(x)
            if (isnan(x)) stop '"x" is a NaN'
          end program test_nan

ITIME --- Get current local time subroutine (hour/minutes/seconds)
==================================================================

Description:
     ITIME(VALUES) Fills VALUES with the numerical values at the current local time. The hour (in the range 1-24), minute (in the range 1-60), and seconds (in the range 1-60) appear in elements 1, 2, and 3 of VALUES, respectively.

     This intrinsic routine is provided for backwards compatibility with GNU Fortran 77.  In new code, programmers should consider the use of the DATE_AND_TIME intrinsic defined by the Fortran 95 standard.

Standard:
     GNU extension

Class:
     Subroutine

Syntax:
     CALL ITIME(VALUES)

Arguments:

     VALUES   The type shall be INTEGER, DIMENSION(3)
     and the kind shall be the default integer kind.

Return value:
     Does not return anything.

Example:

          program test_itime
            integer, dimension(3) :: tarray
            call itime(tarray)
            print *, tarray(1)
            print *, tarray(2)
            print *, tarray(3)
          end program test_itime

See also:
     DATE_AND_TIME

KILL --- Send a signal to a process
===================================

Description:

Standard:
     Sends the signal specified by SIG to the process PID. See kill(2).

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

Class:
     Subroutine, function

Syntax:

     CALL KILL(PID, SIG [, STATUS])
     STATUS = KILL(PID, SIG)

Arguments:

     PID   Shall be a scalar INTEGER with INTENT(IN).
     SIG   Shall be a scalar INTEGER with INTENT(IN).
     STATUS   [Subroutine](Optional)
     Shall be a scalar INTEGER.
     Returns 0 on success; otherwise a system-specific error code is returned.
     STATUS   [Function] The kind type parameter is that of
     pid.
     Returns 0 on success; otherwise a system-specific error code is returned.

See also:
     ABORT, EXIT

KIND --- Kind of an entity
==========================

Description:
     KIND(X) returns the kind value of the entity X.

Standard:
     Fortran 95 and later

Class:
     Inquiry function

Syntax:
     K = KIND(X)

Arguments:

     X   Shall be of type LOGICAL, INTEGER,
     REAL, COMPLEX or CHARACTER.

Return value:
     The return value is a scalar of type INTEGER and of the default integer kind.

Example:

          program test_kind
            integer,parameter :: kc = kind(' ')
            integer,parameter :: kl = kind(.true.)

            print *, "The default character kind is ", kc
            print *, "The default logical kind is ", kl
          end program test_kind

LBOUND --- Lower dimension bounds of an array
=============================================

Description:
     Returns the lower bounds of an array, or a single lower bound along the DIM dimension.

Standard:
     Fortran 95 and later, with KIND argument Fortran 2003 and later

Class:
     Inquiry function

Syntax:
     RESULT = LBOUND(ARRAY [, DIM [, KIND]])

Arguments:

     ARRAY   Shall be an array, of any type.
     DIM   (Optional) Shall be a scalar INTEGER.
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     The return value is of type INTEGER and of kind KIND. If KIND is absent, the return value is of default integer kind. If DIM is absent, the result is an array of the lower bounds of ARRAY.  If DIM is present, the result is a scalar corresponding to the lower bound of the array along that dimension.  If ARRAY is an expression rather than a whole array or array structure component, or if it has a zero extent along the relevant dimension, the lower bound is taken to be 1.

See also:
     UBOUND, LCOBOUND

LCOBOUND --- Lower codimension bounds of an array
=================================================

Description:
     Returns the lower bounds of a coarray, or a single lower cobound along the DIM codimension.

Standard:
     Fortran 2008 and later

Class:
     Inquiry function

Syntax:
     RESULT = LCOBOUND(COARRAY [, DIM [, KIND]])

Arguments:

     ARRAY   Shall be an coarray, of any type.
     DIM   (Optional) Shall be a scalar INTEGER.
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     The return value is of type INTEGER and of kind KIND. If KIND is absent, the return value is of default integer kind. If DIM is absent, the result is an array of the lower cobounds of COARRAY.  If DIM is present, the result is a scalar corresponding to the lower cobound of the array along that codimension.

See also:
     UCOBOUND, LBOUND

LEADZ --- Number of leading zero bits of an integer
===================================================

Description:
     LEADZ returns the number of leading zero bits of an integer.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = LEADZ(I)

Arguments:

     I   Shall be of type INTEGER.

Return value:
     The type of the return value is the default INTEGER. If all the bits of I are zero, the result value is BIT_SIZE(I).

Example:

          PROGRAM test_leadz
            WRITE (*,*) BIT_SIZE(1)  ! prints 32
            WRITE (*,*) LEADZ(1)     ! prints 31
          END PROGRAM

See also:
     BIT_SIZE, TRAILZ, POPCNT, POPPAR

LEN --- Length of a character entity
====================================

Description:
     Returns the length of a character string.  If STRING is an array, the length of an element of STRING is returned.  Note that STRING need not be defined when this intrinsic is invoked, since only the length, not the content, of STRING is needed.

Standard:
     Fortran 77 and later, with KIND argument Fortran 2003 and later

Class:
     Inquiry function

Syntax:
     L = LEN(STRING [, KIND])

Arguments:

     STRING   Shall be a scalar or array of type
     CHARACTER, with INTENT(IN)
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     The return value is of type INTEGER and of kind KIND. If KIND is absent, the return value is of default integer kind.

Specific names:

     Name                 Argument            Return type         Standard
     LEN(STRING)   CHARACTER    INTEGER      Fortran 77 and later

See also:
     LEN_TRIM, ADJUSTL, ADJUSTR

LEN_TRIM --- Length of a character entity without trailing blank characters
===========================================================================

Description:
     Returns the length of a character string, ignoring any trailing blanks.

Standard:
     Fortran 95 and later, with KIND argument Fortran 2003 and later

Class:
     Elemental function

Syntax:
     RESULT = LEN_TRIM(STRING [, KIND])

Arguments:

     STRING   Shall be a scalar of type CHARACTER,
     with INTENT(IN)
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     The return value is of type INTEGER and of kind KIND. If KIND is absent, the return value is of default integer kind.

See also:
     LEN, ADJUSTL, ADJUSTR

LGE --- Lexical greater than or equal
=====================================

Description:
     Determines whether one string is lexically greater than or equal to another string, where the two strings are interpreted as containing ASCII character codes.  If the String A and String B are not the same length, the shorter is compared as if spaces were appended to it to form a value that has the same length as the longer.

     In general, the lexical comparison intrinsics LGE, LGT, LLE, and LLT differ from the corresponding intrinsic operators .GE., .GT., .LE., and .LT., in that the latter use the processor's character ordering (which is not ASCII on some targets), whereas the former always use the ASCII ordering.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = LGE(STRING_A, STRING_B)

Arguments:

     STRING_A   Shall be of default CHARACTER type.
     STRING_B   Shall be of default CHARACTER type.

Return value:
     Returns .TRUE. if STRING_A >= STRING_B, and .FALSE. otherwise, based on the ASCII ordering.

Specific names:

     Name                             Argument            Return type         Standard
     LGE(STRING_A, STRING_B)   CHARACTER    LOGICAL      Fortran 77 and later

See also:
     LGT, LLE, LLT

LGT --- Lexical greater than
============================

Description:
     Determines whether one string is lexically greater than another string, where the two strings are interpreted as containing ASCII character codes.  If the String A and String B are not the same length, the shorter is compared as if spaces were appended to it to form a value that has the same length as the longer.

     In general, the lexical comparison intrinsics LGE, LGT, LLE, and LLT differ from the corresponding intrinsic operators .GE., .GT., .LE., and .LT., in that the latter use the processor's character ordering (which is not ASCII on some targets), whereas the former always use the ASCII ordering.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = LGT(STRING_A, STRING_B)

Arguments:

     STRING_A   Shall be of default CHARACTER type.
     STRING_B   Shall be of default CHARACTER type.

Return value:
     Returns .TRUE. if STRING_A > STRING_B, and .FALSE. otherwise, based on the ASCII ordering.

Specific names:

     Name                             Argument            Return type         Standard
     LGT(STRING_A, STRING_B)   CHARACTER    LOGICAL      Fortran 77 and later

See also:
     LGE, LLE, LLT

LINK --- Create a hard link
===========================

Description:
     Makes a (hard) link from file PATH1 to PATH2. A null character (CHAR(0)) can be used to mark the end of the names in PATH1 and PATH2; otherwise, trailing blanks in the file names are ignored.  If the STATUS argument is supplied, it contains 0 on success or a nonzero error code upon return; see link(2).

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL LINK(PATH1, PATH2 [, STATUS])
     STATUS = LINK(PATH1, PATH2)

Arguments:

     PATH1   Shall be of default CHARACTER type.
     PATH2   Shall be of default CHARACTER type.
     STATUS   (Optional) Shall be of default INTEGER type.

See also:
     SYMLNK, UNLINK

LLE --- Lexical less than or equal
==================================

Description:
     Determines whether one string is lexically less than or equal to another string, where the two strings are interpreted as containing ASCII character codes.  If the String A and String B are not the same length, the shorter is compared as if spaces were appended to it to form a value that has the same length as the longer.

     In general, the lexical comparison intrinsics LGE, LGT, LLE, and LLT differ from the corresponding intrinsic operators .GE., .GT., .LE., and .LT., in that the latter use the processor's character ordering (which is not ASCII on some targets), whereas the former always use the ASCII ordering.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = LLE(STRING_A, STRING_B)

Arguments:

     STRING_A   Shall be of default CHARACTER type.
     STRING_B   Shall be of default CHARACTER type.

Return value:
     Returns .TRUE. if STRING_A <= STRING_B, and .FALSE. otherwise, based on the ASCII ordering.

Specific names:

     Name                             Argument            Return type         Standard
     LLE(STRING_A, STRING_B)   CHARACTER    LOGICAL      Fortran 77 and later

See also:
     LGE, LGT, LLT

LLT --- Lexical less than
=========================

Description:
     Determines whether one string is lexically less than another string, where the two strings are interpreted as containing ASCII character codes.  If the String A and String B are not the same length, the shorter is compared as if spaces were appended to it to form a value that has the same length as the longer.

     In general, the lexical comparison intrinsics LGE, LGT, LLE, and LLT differ from the corresponding intrinsic operators .GE., .GT., .LE., and .LT., in that the latter use the processor's character ordering (which is not ASCII on some targets), whereas the former always use the ASCII ordering.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = LLT(STRING_A, STRING_B)

Arguments:

     STRING_A   Shall be of default CHARACTER type.
     STRING_B   Shall be of default CHARACTER type.

Return value:
     Returns .TRUE. if STRING_A < STRING_B, and .FALSE. otherwise, based on the ASCII ordering.

Specific names:

     Name                             Argument            Return type         Standard
     LLT(STRING_A, STRING_B)   CHARACTER    LOGICAL      Fortran 77 and later

See also:
     LGE, LGT, LLE

LNBLNK --- Index of the last non-blank character in a string
============================================================

Description:
     Returns the length of a character string, ignoring any trailing blanks. This is identical to the standard LEN_TRIM intrinsic, and is only included for backwards compatibility.

Standard:
     GNU extension

Class:
     Elemental function

Syntax:
     RESULT = LNBLNK(STRING)

Arguments:

     STRING   Shall be a scalar of type CHARACTER,
     with INTENT(IN)

Return value:
     The return value is of INTEGER(kind=4) type.

See also:
     INDEX intrinsic, LEN_TRIM

LOC --- Returns the address of a variable
=========================================

Description:
     LOC(X) returns the address of X as an integer.

Standard:
     GNU extension

Class:
     Inquiry function

Syntax:
     RESULT = LOC(X)

Arguments:

     X   Variable of any type.

Return value:
     The return value is of type INTEGER, with a KIND corresponding to the size (in bytes) of a memory address on the target machine.

Example:

          program test_loc
            integer :: i
            real :: r
            i = loc(r)
            print *, i
          end program test_loc

LOG --- Natural logarithm function
==================================

Description:
     LOG(X) computes the natural logarithm of X, i.e. the logarithm to the base e.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = LOG(X)

Arguments:

     X   The type shall be REAL or
     COMPLEX.

Return value:
     The return value is of type REAL or COMPLEX. The kind type parameter is the same as X. If X is COMPLEX, the imaginary part \omega is in the range -\pi < \omega \leq \pi.

Example:

          program test_log
            real(8) :: x = 2.7182818284590451_8
            complex :: z = (1.0, 2.0)
            x = log(x)    ! will yield (approximately) 1
            z = log(z)
          end program test_log

Specific names:

     Name              Argument            Return type         Standard
     ALOG(X)    REAL(4) X    REAL(4)      f95, gnu
     DLOG(X)    REAL(8) X    REAL(8)      f95, gnu
     CLOG(X)    COMPLEX(4) X    COMPLEX(4)      f95, gnu
     ZLOG(X)    COMPLEX(8) X    COMPLEX(8)      f95, gnu
     CDLOG(X)   COMPLEX(8) X    COMPLEX(8)      f95, gnu

LOG10 --- Base 10 logarithm function
====================================

Description:
     LOG10(X) computes the base 10 logarithm of X.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = LOG10(X)

Arguments:

     X   The type shall be REAL.

Return value:
     The return value is of type REAL or COMPLEX. The kind type parameter is the same as X.

Example:

          program test_log10
            real(8) :: x = 10.0_8
            x = log10(x)
          end program test_log10

Specific names:

     Name              Argument            Return type         Standard
     ALOG10(X)    REAL(4) X    REAL(4)      Fortran 95 and later
     DLOG10(X)    REAL(8) X    REAL(8)      Fortran 95 and later

LOG_GAMMA --- Logarithm of the Gamma function
=============================================

Description:
     LOG_GAMMA(X) computes the natural logarithm of the absolute value of the Gamma (\Gamma) function.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     X = LOG_GAMMA(X)

Arguments:

     X   Shall be of type REAL and neither zero
     nor a negative integer.

Return value:
     The return value is of type REAL of the same kind as X.

Example:

          program test_log_gamma
            real :: x = 1.0
            x = lgamma(x) ! returns 0.0
          end program test_log_gamma

Specific names:

     Name               Argument           Return type         Standard
     LGAMMA(X)   REAL(4) X   REAL(4)      GNU Extension
     ALGAMA(X)   REAL(4) X   REAL(4)      GNU Extension
     DLGAMA(X)   REAL(8) X   REAL(8)      GNU Extension

See also:
     Gamma function: GAMMA

LOGICAL --- Convert to logical type
===================================

Description:
     Converts one kind of LOGICAL variable to another.

Standard:
     Fortran 95 and later

Class:
     Elemental function

Syntax:
     RESULT = LOGICAL(L [, KIND])

Arguments:

     L      The type shall be LOGICAL.
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     The return value is a LOGICAL value equal to L, with a kind corresponding to KIND, or of the default logical kind if KIND is not given.

See also:
     INT, REAL, CMPLX

LONG --- Convert to integer type
================================

Description:
     Convert to a KIND=4 integer type, which is the same size as a C long integer.  This is equivalent to the standard INT intrinsic with an optional argument of KIND=4, and is only included for backwards compatibility.

Standard:
     GNU extension

Class:
     Elemental function

Syntax:
     RESULT = LONG(A)

Arguments:

     A      Shall be of type INTEGER,
     REAL, or COMPLEX.

Return value:
     The return value is a INTEGER(4) variable.

See also:
     INT, INT2, INT8

LSHIFT --- Left shift bits
==========================

Description:
     LSHIFT returns a value corresponding to I with all of the bits shifted left by SHIFT places.  SHIFT shall be nonnegative and less than or equal to BIT_SIZE(I), otherwise the result value is undefined.  Bits shifted out from the left end are lost; zeros are shifted in from the opposite end.

     This function has been superseded by the ISHFT intrinsic, which is standard in Fortran 95 and later, and the SHIFTL intrinsic, which is standard in Fortran 2008 and later.

Standard:
     GNU extension

Class:
     Elemental function

Syntax:
     RESULT = LSHIFT(I, SHIFT)

Arguments:

     I   The type shall be INTEGER.
     SHIFT   The type shall be INTEGER.

Return value:
     The return value is of type INTEGER and of the same kind as I.

See also:
     ISHFT, ISHFTC, RSHIFT, SHIFTA, SHIFTL, SHIFTR

LSTAT --- Get file status
=========================

Description:
     LSTAT is identical to STAT, except that if path is a symbolic link, then the link itself is statted, not the file that it refers to.

     The elements in VALUES are the same as described by STAT.

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL LSTAT(NAME, VALUES [, STATUS])
     STATUS = LSTAT(NAME, VALUES)

Arguments:

     NAME     The type shall be CHARACTER of the default
     kind, a valid path within the file system.
     VALUES   The type shall be INTEGER(4), DIMENSION(13).
     STATUS   (Optional) status flag of type INTEGER(4).
     Returns 0 on success and a system specific error code otherwise.

Example:
     See STAT for an example.

See also:
     To stat an open file: FSTAT, to stat a file: STAT

LTIME --- Convert time to local time info
=========================================

Description:
     Given a system time value TIME (as provided by the TIME intrinsic), fills VALUES with values extracted from it appropriate to the local time zone using localtime(3).

     This intrinsic routine is provided for backwards compatibility with GNU Fortran 77.  In new code, programmers should consider the use of the DATE_AND_TIME intrinsic defined by the Fortran 95 standard.

Standard:
     GNU extension

Class:
     Subroutine

Syntax:
     CALL LTIME(TIME, VALUES)

Arguments:

     TIME    An INTEGER scalar expression
     corresponding to a system time, with INTENT(IN).
     VALUES   A default INTEGER array with 9 elements,
     with INTENT(OUT).

Return value:
     The elements of VALUES are assigned as follows:

      1. Seconds after the minute, range 0--59 or 0--61 to allow for leap seconds

      2. Minutes after the hour, range 0--59

      3. Hours past midnight, range 0--23

      4. Day of month, range 1--31

      5. Number of months since January, range 0--11

      6. Years since 1900

      7. Number of days since Sunday, range 0--6

      8. Days since January 1, range 0--365

      9. Daylight savings indicator: positive if daylight savings is in effect, zero if not, and negative if the information is not available.

See also:
     DATE_AND_TIME, CTIME, GMTIME, TIME, TIME8

MALLOC --- Allocate dynamic memory
==================================

Description:
     MALLOC(SIZE) allocates SIZE bytes of dynamic memory and returns the address of the allocated memory. The MALLOC intrinsic is an extension intended to be used with Cray pointers, and is provided in GNU Fortran to allow the user to compile legacy code. For new code using Fortran 95 pointers, the memory allocation intrinsic is ALLOCATE.

Standard:
     GNU extension

Class:
     Function

Syntax:
     PTR = MALLOC(SIZE)

Arguments:

     SIZE   The type shall be INTEGER.

Return value:
     The return value is of type INTEGER(K), with K such that variables of type INTEGER(K) have the same size as C pointers (sizeof(void *)).

Example:
     The following example demonstrates the use of MALLOC and FREE with Cray pointers.

          program test_malloc
            implicit none
            integer i
            real*8 x(*), z
            pointer(ptr_x,x)

            ptr_x = malloc(20*8)
            do i = 1, 20
              x(i) = sqrt(1.0d0 / i)
            end do
            z = 0
            do i = 1, 20
              z = z + x(i)
              print *, z
            end do
            call free(ptr_x)
          end program test_malloc

See also:
     FREE

MASKL --- Left justified mask
=============================

Description:
     MASKL(I[, KIND]) has its leftmost I bits set to 1, and the remaining bits set to 0.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = MASKL(I[, KIND])

Arguments:

     I   Shall be of type INTEGER.
     KIND   Shall be a scalar constant expression of type
     INTEGER.

Return value:
     The return value is of type INTEGER. If KIND is present, it specifies the kind value of the return type; otherwise, it is of the default integer kind.

See also:
     MASKR

MASKR --- Right justified mask
==============================

Description:
     MASKL(I[, KIND]) has its rightmost I bits set to 1, and the remaining bits set to 0.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = MASKR(I[, KIND])

Arguments:

     I   Shall be of type INTEGER.
     KIND   Shall be a scalar constant expression of type
     INTEGER.

Return value:
     The return value is of type INTEGER. If KIND is present, it specifies the kind value of the return type; otherwise, it is of the default integer kind.

See also:
     MASKL

MATMUL --- matrix multiplication
================================

Description:
     Performs a matrix multiplication on numeric or logical arguments.

Standard:
     Fortran 95 and later

Class:
     Transformational function

Syntax:
     RESULT = MATMUL(MATRIX_A, MATRIX_B)

Arguments:

     MATRIX_A   An array of INTEGER,
     REAL, COMPLEX, or LOGICAL type, with a rank of
     one or two.
     MATRIX_B   An array of INTEGER,
     REAL, or COMPLEX type if MATRIX_A is of a numeric
     type; otherwise, an array of LOGICAL type. The rank shall be one
     or two, and the first (or only) dimension of MATRIX_B shall be
     equal to the last (or only) dimension of MATRIX_A.
     MATRIX_A and MATRIX_B shall not both be rank one arrays.

Return value:
     The matrix product of MATRIX_A and MATRIX_B.  The type and kind of the result follow the usual type and kind promotion rules, as for the * or .AND. operators.

See also:

MAX --- Maximum value of an argument list
=========================================

Description:
     Returns the argument with the largest (most positive) value.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = MAX(A1, A2 [, A3 [, ...]])

Arguments:

     A1            The type shall be INTEGER or
     REAL.
     A2, A3, ...   An expression of the same type and kind
     as A1.  (As a GNU extension, arguments of different kinds are
     permitted.)

Return value:
     The return value corresponds to the maximum value among the arguments, and has the same type and kind as the first argument.

Specific names:

     Name               Argument               Return type           Standard
     MAX0(A1)    INTEGER(4) A1   INTEGER(4)     Fortran 77 and later
     AMAX0(A1)   INTEGER(4) A1   REAL(MAX(X))   Fortran 77 and later
     MAX1(A1)    REAL A1         INT(MAX(X))    Fortran 77 and later
     AMAX1(A1)   REAL(4) A1      REAL(4)        Fortran 77 and later
     DMAX1(A1)   REAL(8) A1      REAL(8)        Fortran 77 and later

See also:
     MAXLOC MAXVAL, MIN

MAXEXPONENT --- Maximum exponent of a real kind
===============================================

Description:
     MAXEXPONENT(X) returns the maximum exponent in the model of the type of X.

Standard:
     Fortran 95 and later

Class:
     Inquiry function

Syntax:
     RESULT = MAXEXPONENT(X)

Arguments:

     X   Shall be of type REAL.

Return value:
     The return value is of type INTEGER and of the default integer kind.

Example:

          program exponents
            real(kind=4) :: x
            real(kind=8) :: y

            print *, minexponent(x), maxexponent(x)
            print *, minexponent(y), maxexponent(y)
          end program exponents

MAXLOC --- Location of the maximum value within an array
========================================================

Description:
     Determines the location of the element in the array with the maximum value, or, if the DIM argument is supplied, determines the locations of the maximum element along each row of the array in the DIM direction.  If MASK is present, only the elements for which MASK is .TRUE. are considered.  If more than one element in the array has the maximum value, the location returned is that of the first such element in array element order if the BACK is not present, or is false; if BACK is true, the location returned is that of the last such element. If the array has zero size, or all of the elements of MASK are .FALSE., then the result is an array of zeroes.  Similarly, if DIM is supplied and all of the elements of MASK along a given row are zero, the result value for that row is zero.

Standard:
     Fortran 95 and later; ARRAY of CHARACTER and the KIND argument are available in Fortran 2003 and later. The BACK argument is available in Fortran 2008 and later.

Class:
     Transformational function

Syntax:

     RESULT = MAXLOC(ARRAY, DIM [, MASK] [,KIND] [,BACK])
     RESULT = MAXLOC(ARRAY [, MASK] [,KIND] [,BACK])

Arguments:

     ARRAY   Shall be an array of type INTEGER or
     REAL.
     DIM     (Optional) Shall be a scalar of type
     INTEGER, with a value between one and the rank of ARRAY,
     inclusive.  It may not be an optional dummy argument.
     MASK    Shall be an array of type LOGICAL,
     and conformable with ARRAY.
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.
     BACK   (Optional) A scalar of type LOGICAL.

Return value:
     If DIM is absent, the result is a rank-one array with a length equal to the rank of ARRAY.  If DIM is present, the result is an array with a rank one less than the rank of ARRAY, and a size corresponding to the size of ARRAY with the DIM dimension removed.  If DIM is present and ARRAY has a rank of one, the result is a scalar.   If the optional argument KIND is present, the result is an integer of kind KIND, otherwise it is of default kind.

See also:
     FINDLOC, MAX, MAXVAL

MAXVAL --- Maximum value of an array
====================================

Description:
     Determines the maximum value of the elements in an array value, or, if the DIM argument is supplied, determines the maximum value along each row of the array in the DIM direction.  If MASK is present, only the elements for which MASK is .TRUE. are considered.  If the array has zero size, or all of the elements of MASK are .FALSE., then the result is -HUGE(ARRAY) if ARRAY is numeric, or a string of nulls if ARRAY is of character type.

Standard:
     Fortran 95 and later

Class:
     Transformational function

Syntax:

     RESULT = MAXVAL(ARRAY, DIM [, MASK])
     RESULT = MAXVAL(ARRAY [, MASK])

Arguments:

     ARRAY   Shall be an array of type INTEGER or
     REAL.
     DIM     (Optional) Shall be a scalar of type
     INTEGER, with a value between one and the rank of ARRAY,
     inclusive.  It may not be an optional dummy argument.
     MASK    Shall be an array of type LOGICAL,
     and conformable with ARRAY.

Return value:
     If DIM is absent, or if ARRAY has a rank of one, the result is a scalar.  If DIM is present, the result is an array with a rank one less than the rank of ARRAY, and a size corresponding to the size of ARRAY with the DIM dimension removed.  In all cases, the result is of the same type and kind as ARRAY.

See also:
     MAX, MAXLOC

MCLOCK --- Time function
========================

Description:
     Returns the number of clock ticks since the start of the process, based on the function clock(3) in the C standard library.

     This intrinsic is not fully portable, such as to systems with 32-bit INTEGER types but supporting times wider than 32 bits. Therefore, the values returned by this intrinsic might be, or become, negative, or numerically less than previous values, during a single run of the compiled program.

Standard:
     GNU extension

Class:
     Function

Syntax:
     RESULT = MCLOCK()

Return value:
     The return value is a scalar of type INTEGER(4), equal to the number of clock ticks since the start of the process, or -1 if the system does not support clock(3).

See also:
     CTIME, GMTIME, LTIME, MCLOCK, TIME

MCLOCK8 --- Time function (64-bit)
==================================

Description:
     Returns the number of clock ticks since the start of the process, based on the function clock(3) in the C standard library.

     Warning: this intrinsic does not increase the range of the timing values over that returned by clock(3). On a system with a 32-bit clock(3), MCLOCK8 will return a 32-bit value, even though it is converted to a 64-bit INTEGER(8) value. That means overflows of the 32-bit value can still occur. Therefore, the values returned by this intrinsic might be or become negative or numerically less than previous values during a single run of the compiled program.

Standard:
     GNU extension

Class:
     Function

Syntax:
     RESULT = MCLOCK8()

Return value:
     The return value is a scalar of type INTEGER(8), equal to the number of clock ticks since the start of the process, or -1 if the system does not support clock(3).

See also:
     CTIME, GMTIME, LTIME, MCLOCK, TIME8

MERGE --- Merge variables
=========================

Description:
     Select values from two arrays according to a logical mask.  The result is equal to TSOURCE if MASK is .TRUE., or equal to FSOURCE if it is .FALSE..

Standard:
     Fortran 95 and later

Class:
     Elemental function

Syntax:
     RESULT = MERGE(TSOURCE, FSOURCE, MASK)

Arguments:

     TSOURCE   May be of any type.
     FSOURCE   Shall be of the same type and type parameters
     as TSOURCE.
     MASK      Shall be of type LOGICAL.

Return value:
     The result is of the same type and type parameters as TSOURCE.

MERGE_BITS --- Merge of bits under mask
=======================================

Description:
     MERGE_BITS(I, J, MASK) merges the bits of I and J as determined by the mask.  The i-th bit of the result is equal to the i-th bit of I if the i-th bit of MASK is 1; it is equal to the i-th bit of J otherwise.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = MERGE_BITS(I, J, MASK)

Arguments:

     I   Shall be of type INTEGER or a boz-literal-constant.
     J   Shall be of type INTEGER with the same
     kind type parameter as I or a boz-literal-constant.
     I and J shall not both be boz-literal-constants.
     MASK   Shall be of type INTEGER or a boz-literal-constant
     and of the same kind as I.

Return value:
     The result is of the same type and kind as I.

MIN --- Minimum value of an argument list
=========================================

Description:
     Returns the argument with the smallest (most negative) value.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = MIN(A1, A2 [, A3, ...])

Arguments:

     A1            The type shall be INTEGER or
     REAL.
     A2, A3, ...   An expression of the same type and kind
     as A1.  (As a GNU extension, arguments of different kinds are
     permitted.)

Return value:
     The return value corresponds to the maximum value among the arguments, and has the same type and kind as the first argument.

Specific names:

     Name                Argument               Return type          Standard
     MIN0(A1)     INTEGER(4) A1   INTEGER(4)    Fortran 77 and later
     AMIN0(A1)    INTEGER(4) A1   REAL(4)       Fortran 77 and later
     MIN1(A1)     REAL A1         INTEGER(4)    Fortran 77 and later
     AMIN1(A1)    REAL(4) A1      REAL(4)       Fortran 77 and later
     DMIN1(A1)    REAL(8) A1      REAL(8)       Fortran 77 and later

See also:
     MAX, MINLOC, MINVAL

MINEXPONENT --- Minimum exponent of a real kind
===============================================

Description:
     MINEXPONENT(X) returns the minimum exponent in the model of the type of X.

Standard:
     Fortran 95 and later

Class:
     Inquiry function

Syntax:
     RESULT = MINEXPONENT(X)

Arguments:

     X   Shall be of type REAL.

Return value:
     The return value is of type INTEGER and of the default integer kind.

Example:
     See MAXEXPONENT for an example.

MINLOC --- Location of the minimum value within an array
========================================================

Description:
     Determines the location of the element in the array with the minimum value, or, if the DIM argument is supplied, determines the locations of the minimum element along each row of the array in the DIM direction.  If MASK is present, only the elements for which MASK is .TRUE. are considered.  If more than one element in the array has the minimum value, the location returned is that of the first such element in array element order if the BACK is not present, or is false; if BACK is true, the location returned is that of the last such element.  If the array has zero size, or all of the elements of MASK are .FALSE., then the result is an array of zeroes.  Similarly, if DIM is supplied and all of the elements of MASK along a given row are zero, the result value for that row is zero.

Standard:
     Fortran 95 and later; ARRAY of CHARACTER and the KIND argument are available in Fortran 2003 and later. The BACK argument is available in Fortran 2008 and later.

Class:
     Transformational function

Syntax:

     RESULT = MINLOC(ARRAY, DIM [, MASK] [,KIND] [,BACK])
     RESULT = MINLOC(ARRAY [, MASK], [,KIND] [,BACK])

Arguments:

     ARRAY   Shall be an array of type INTEGER,
     REAL or CHARACTER.
     DIM     (Optional) Shall be a scalar of type
     INTEGER, with a value between one and the rank of ARRAY,
     inclusive.  It may not be an optional dummy argument.
     MASK    Shall be an array of type LOGICAL,
     and conformable with ARRAY.
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.
     BACK   (Optional) A scalar of type LOGICAL.

Return value:
     If DIM is absent, the result is a rank-one array with a length equal to the rank of ARRAY.  If DIM is present, the result is an array with a rank one less than the rank of ARRAY, and a size corresponding to the size of ARRAY with the DIM dimension removed.  If DIM is present and ARRAY has a rank of one, the result is a scalar.  If the optional argument KIND is present, the result is an integer of kind KIND, otherwise it is of default kind.

See also:
     FINDLOC, MIN, MINVAL

MINVAL --- Minimum value of an array
====================================

Description:
     Determines the minimum value of the elements in an array value, or, if the DIM argument is supplied, determines the minimum value along each row of the array in the DIM direction.  If MASK is present, only the elements for which MASK is .TRUE. are considered.  If the array has zero size, or all of the elements of MASK are .FALSE., then the result is HUGE(ARRAY) if ARRAY is numeric, or a string of CHAR(255) characters if ARRAY is of character type.

Standard:
     Fortran 95 and later

Class:
     Transformational function

Syntax:

     RESULT = MINVAL(ARRAY, DIM [, MASK])
     RESULT = MINVAL(ARRAY [, MASK])

Arguments:

     ARRAY   Shall be an array of type INTEGER or
     REAL.
     DIM     (Optional) Shall be a scalar of type
     INTEGER, with a value between one and the rank of ARRAY,
     inclusive.  It may not be an optional dummy argument.
     MASK    Shall be an array of type LOGICAL,
     and conformable with ARRAY.

Return value:
     If DIM is absent, or if ARRAY has a rank of one, the result is a scalar.  If DIM is present, the result is an array with a rank one less than the rank of ARRAY, and a size corresponding to the size of ARRAY with the DIM dimension removed.  In all cases, the result is of the same type and kind as ARRAY.

See also:
     MIN, MINLOC

MOD --- Remainder function
==========================

Description:
     MOD(A,P) computes the remainder of the division of A by P.

Standard:
     Fortran 77 and later, has overloads that are GNU extensions

Class:
     Elemental function

Syntax:
     RESULT = MOD(A, P)

Arguments:

     A   Shall be a scalar of type INTEGER or REAL.
     P   Shall be a scalar of the same type and kind as A
     and not equal to zero.

Return value:
     The return value is the result of A - (INT(A/P) * P). The type and kind of the return value is the same as that of the arguments. The returned value has the same sign as A and a magnitude less than the magnitude of P.

Example:

          program test_mod
            print *, mod(17,3)
            print *, mod(17.5,5.5)
            print *, mod(17.5d0,5.5)
            print *, mod(17.5,5.5d0)

            print *, mod(-17,3)
            print *, mod(-17.5,5.5)
            print *, mod(-17.5d0,5.5)
            print *, mod(-17.5,5.5d0)

            print *, mod(17,-3)
            print *, mod(17.5,-5.5)
            print *, mod(17.5d0,-5.5)
            print *, mod(17.5,-5.5d0)
          end program test_mod

Specific names:

     Name               Arguments            Return type      Standard
     MOD(A,P)    INTEGER A,P   INTEGER   Fortran 95 and later
     AMOD(A,P)   REAL(4) A,P   REAL(4)   Fortran 95 and later
     DMOD(A,P)   REAL(8) A,P   REAL(8)   Fortran 95 and later
     BMOD(A,P)    INTEGER(1) A,P   INTEGER(1)   GNU extension
     IMOD(A,P)    INTEGER(2) A,P   INTEGER(2)   GNU extension
     JMOD(A,P)    INTEGER(4) A,P   INTEGER(4)   GNU extension
     KMOD(A,P)    INTEGER(8) A,P   INTEGER(8)   GNU extension

See also:
     MODULO

MODULO --- Modulo function
==========================

Description:
     MODULO(A,P) computes the A modulo P.

Standard:
     Fortran 95 and later

Class:
     Elemental function

Syntax:
     RESULT = MODULO(A, P)

Arguments:

     A   Shall be a scalar of type INTEGER or REAL.
     P   Shall be a scalar of the same type and kind as A.
     It shall not be zero.

Return value:
     The type and kind of the result are those of the arguments.

     If A and P are of type INTEGER:
          MODULO(A,P) has the value R such that A=Q*P+R, where Q is an integer and R is between 0 (inclusive) and P (exclusive).

     If A and P are of type REAL:
          MODULO(A,P) has the value of A - FLOOR (A / P) * P.

     The returned value has the same sign as P and a magnitude less than the magnitude of P.

Example:

          program test_modulo
            print *, modulo(17,3)
            print *, modulo(17.5,5.5)

            print *, modulo(-17,3)
            print *, modulo(-17.5,5.5)

            print *, modulo(17,-3)
            print *, modulo(17.5,-5.5)
          end program

See also:
     MOD

MOVE_ALLOC --- Move allocation from one object to another
=========================================================

Description:
     MOVE_ALLOC(FROM, TO) moves the allocation from FROM to TO.  FROM will become deallocated in the process.

Standard:
     Fortran 2003 and later

Class:
     Pure subroutine

Syntax:
     CALL MOVE_ALLOC(FROM, TO)

Arguments:

     FROM    ALLOCATABLE, INTENT(INOUT), may be
     of any type and kind.
     TO   ALLOCATABLE, INTENT(OUT), shall be
     of the same type, kind and rank as FROM.

Return value:
     None

Example:

          program test_move_alloc
              integer, allocatable :: a(:), b(:)

              allocate(a(3))
              a = [ 1, 2, 3 ]
              call move_alloc(a, b)
              print *, allocated(a), allocated(b)
              print *, b
          end program test_move_alloc

MVBITS --- Move bits from one integer to another
================================================

Description:
     Moves LEN bits from positions FROMPOS through FROMPOS+LEN-1 of FROM to positions TOPOS through TOPOS+LEN-1 of TO. The portion of argument TO not affected by the movement of bits is unchanged. The values of FROMPOS+LEN-1 and TOPOS+LEN-1 must be less than BIT_SIZE(FROM).

Standard:
     Fortran 95 and later, has overloads that are GNU extensions

Class:
     Elemental subroutine

Syntax:
     CALL MVBITS(FROM, FROMPOS, LEN, TO, TOPOS)

Arguments:

     FROM      The type shall be INTEGER.
     FROMPOS   The type shall be INTEGER.
     LEN       The type shall be INTEGER.
     TO        The type shall be INTEGER, of the
     same kind as FROM.
     TOPOS     The type shall be INTEGER.

Specific names:

     Name              Argument              Return type         Standard
     MVBITS(A)     INTEGER A      INTEGER      Fortran 95 and later
     BMVBITS(A)   INTEGER(1) A   INTEGER(1)   GNU extension
     IMVBITS(A)   INTEGER(2) A   INTEGER(2)   GNU extension
     JMVBITS(A)   INTEGER(4) A   INTEGER(4)   GNU extension
     KMVBITS(A)   INTEGER(8) A   INTEGER(8)   GNU extension

See also:
     IBCLR, IBSET, IBITS, IAND, IOR, IEOR

NEAREST --- Nearest representable number
========================================

Description:
     NEAREST(X, S) returns the processor-representable number nearest to X in the direction indicated by the sign of S.

Standard:
     Fortran 95 and later

Class:
     Elemental function

Syntax:
     RESULT = NEAREST(X, S)

Arguments:

     X   Shall be of type REAL.
     S   Shall be of type REAL and
     not equal to zero.

Return value:
     The return value is of the same type as X. If S is positive, NEAREST returns the processor-representable number greater than X and nearest to it. If S is negative, NEAREST returns the processor-representable number smaller than X and nearest to it.

Example:

          program test_nearest
            real :: x, y
            x = nearest(42.0, 1.0)
            y = nearest(42.0, -1.0)
            write (*,"(3(G20.15))") x, y, x - y
          end program test_nearest

NEW_LINE --- New line character
===============================

Description:
     NEW_LINE(C) returns the new-line character.

Standard:
     Fortran 2003 and later

Class:
     Inquiry function

Syntax:
     RESULT = NEW_LINE(C)

Arguments:

     C      The argument shall be a scalar or array of the
     type CHARACTER.

Return value:
     Returns a CHARACTER scalar of length one with the new-line character of the same kind as parameter C.

Example:

          program newline
            implicit none
            write(*,'(A)') 'This is record 1.'//NEW_LINE('A')//'This is record 2.'
          end program newline

NINT --- Nearest whole number
=============================

Description:
     NINT(A) rounds its argument to the nearest whole number.

Standard:
     Fortran 77 and later, with KIND argument Fortran 90 and later

Class:
     Elemental function

Syntax:
     RESULT = NINT(A [, KIND])

Arguments:

     A      The type of the argument shall be REAL.
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     Returns A with the fractional portion of its magnitude eliminated by rounding to the nearest whole number and with its sign preserved, converted to an INTEGER of the default kind.

Example:

          program test_nint
            real(4) x4
            real(8) x8
            x4 = 1.234E0_4
            x8 = 4.321_8
            print *, nint(x4), idnint(x8)
          end program test_nint

Specific names:

     Name               Argument             Return Type       Standard
     NINT(A)     REAL(4) A      INTEGER   Fortran 95 and later
     IDNINT(A)   REAL(8) A      INTEGER   Fortran 95 and later

See also:
     CEILING, FLOOR

NORM2 --- Euclidean vector norms
================================

Description:
     Calculates the Euclidean vector norm (L_2 norm) of of ARRAY along dimension DIM.

Standard:
     Fortran 2008 and later

Class:
     Transformational function

Syntax:

     RESULT = NORM2(ARRAY[, DIM])

Arguments:

     ARRAY   Shall be an array of type REAL
     DIM     (Optional) shall be a scalar of type
     INTEGER with a value in the range from 1 to n, where n
     equals the rank of ARRAY.

Return value:
     The result is of the same type as ARRAY.

     If DIM is absent, a scalar with the square root of the sum of all elements in ARRAY squared  is returned. Otherwise, an array of rank n-1, where n equals the rank of ARRAY, and a shape similar to that of ARRAY with dimension DIM dropped is returned.

Example:

          PROGRAM test_sum
            REAL :: x(5) = [ real :: 1, 2, 3, 4, 5 ]
            print *, NORM2(x)  ! = sqrt(55.) ~ 7.416
          END PROGRAM

NOT --- Logical negation
========================

Description:
     NOT returns the bitwise Boolean inverse of I.

Standard:
     Fortran 95 and later, has overloads that are GNU extensions

Class:
     Elemental function

Syntax:
     RESULT = NOT(I)

Arguments:

     I   The type shall be INTEGER.

Return value:
     The return type is INTEGER, of the same kind as the argument.

Specific names:

     Name              Argument              Return type         Standard
     NOT(A)     INTEGER A      INTEGER      Fortran 95 and later
     BNOT(A)   INTEGER(1) A   INTEGER(1)   GNU extension
     INOT(A)   INTEGER(2) A   INTEGER(2)   GNU extension
     JNOT(A)   INTEGER(4) A   INTEGER(4)   GNU extension
     KNOT(A)   INTEGER(8) A   INTEGER(8)   GNU extension

See also:
     IAND, IEOR, IOR, IBITS, IBSET, IBCLR

NULL --- Function that returns an disassociated pointer
=======================================================

Description:
     Returns a disassociated pointer.

     If MOLD is present, a disassociated pointer of the same type is returned, otherwise the type is determined by context.

     In Fortran 95, MOLD is optional. Please note that Fortran 2003 includes cases where it is required.

Standard:
     Fortran 95 and later

Class:
     Transformational function

Syntax:
     PTR => NULL([MOLD])

Arguments:

     MOLD   (Optional) shall be a pointer of any association
     status and of any type.

Return value:
     A disassociated pointer.

Example:

          REAL, POINTER, DIMENSION(:) :: VEC => NULL ()

See also:
     ASSOCIATED

NUM_IMAGES --- Function that returns the number of images
=========================================================

Description:
     Returns the number of images.

Standard:
     Fortran 2008 and later. With DISTANCE or FAILED argument, Technical Specification (TS) 18508 or later

Class:
     Transformational function

Syntax:
     RESULT = NUM_IMAGES(DISTANCE, FAILED)

Arguments:

     DISTANCE   (optional, intent(in)) Nonnegative scalar integer
     FAILED     (optional, intent(in)) Scalar logical expression

Return value:
     Scalar default-kind integer.  If DISTANCE is not present or has value 0, the number of images in the current team is returned. For values smaller or equal distance to the initial team, it returns the number of images index on the ancestor team which has a distance of DISTANCE from the invoking team. If DISTANCE is larger than the distance to the initial team, the number of images of the initial team is returned. If FAILED is not present the total number of images is returned; if it has the value .TRUE., the number of failed images is returned, otherwise, the number of images which do have not the failed status.

Example:

          INTEGER :: value[*]
          INTEGER :: i
          value = THIS_IMAGE()
          SYNC ALL
          IF (THIS_IMAGE() == 1) THEN
            DO i = 1, NUM_IMAGES()
              WRITE(*,'(2(a,i0))') 'value[', i, '] is ', value[i]
            END DO
          END IF

See also:
     THIS_IMAGE, IMAGE_INDEX

OR --- Bitwise logical OR
=========================

Description:
     Bitwise logical OR.

     This intrinsic routine is provided for backwards compatibility with GNU Fortran 77.  For integer arguments, programmers should consider the use of the IOR intrinsic defined by the Fortran standard.

Standard:
     GNU extension

Class:
     Function

Syntax:
     RESULT = OR(I, J)

Arguments:

     I   The type shall be either a scalar INTEGER
     type or a scalar LOGICAL type or a boz-literal-constant.
     J   The type shall be the same as the type of I or
     a boz-literal-constant. I and J shall not both be
     boz-literal-constants.  If either I and J is a
     boz-literal-constant, then the other argument must be a scalar INTEGER.

Return value:
     The return type is either a scalar INTEGER or a scalar LOGICAL.  If the kind type parameters differ, then the smaller kind type is implicitly converted to larger kind, and the return has the larger kind.  A boz-literal-constant is converted to an INTEGER with the kind type parameter of the other argument as-if a call to INT occurred.

Example:

          PROGRAM test_or
            LOGICAL :: T = .TRUE., F = .FALSE.
            INTEGER :: a, b
            DATA a / Z'F' /, b / Z'3' /

            WRITE (*,*) OR(T, T), OR(T, F), OR(F, T), OR(F, F)
            WRITE (*,*) OR(a, b)
          END PROGRAM

See also:
     Fortran 95 elemental function: IOR

PACK --- Pack an array into an array of rank one
================================================

Description:
     Stores the elements of ARRAY in an array of rank one.

     The beginning of the resulting array is made up of elements whose MASK equals TRUE. Afterwards, positions are filled with elements taken from VECTOR.

Standard:
     Fortran 95 and later

Class:
     Transformational function

Syntax:
     RESULT = PACK(ARRAY, MASK[,VECTOR])

Arguments:

     ARRAY    Shall be an array of any type.
     MASK     Shall be an array of type LOGICAL and
     of the same size as ARRAY. Alternatively, it may be a LOGICAL
     scalar.
     VECTOR   (Optional) shall be an array of the same type
     as ARRAY and of rank one. If present, the number of elements in
     VECTOR shall be equal to or greater than the number of true elements
     in MASK. If MASK is scalar, the number of elements in
     VECTOR shall be equal to or greater than the number of elements in
     ARRAY.

Return value:
     The result is an array of rank one and the same type as that of ARRAY. If VECTOR is present, the result size is that of VECTOR, the number of TRUE values in MASK otherwise.

Example:
     Gathering nonzero elements from an array:

          PROGRAM test_pack_1
            INTEGER :: m(6)
            m = (/ 1, 0, 0, 0, 5, 0 /)
            WRITE(*, FMT="(6(I0, ' '))") pack(m, m /= 0)  ! "1 5"
          END PROGRAM

     Gathering nonzero elements from an array and appending elements from VECTOR:

          PROGRAM test_pack_2
            INTEGER :: m(4)
            m = (/ 1, 0, 0, 2 /)
            WRITE(*, FMT="(4(I0, ' '))") pack(m, m /= 0, (/ 0, 0, 3, 4 /))  ! "1 2 3 4"
          END PROGRAM

See also:
     UNPACK

PARITY --- Reduction with exclusive OR
======================================

Description:
     Calculates the parity, i.e. the reduction using .XOR., of MASK along dimension DIM.

Standard:
     Fortran 2008 and later

Class:
     Transformational function

Syntax:

     RESULT = PARITY(MASK[, DIM])

Arguments:

     LOGICAL   Shall be an array of type LOGICAL
     DIM     (Optional) shall be a scalar of type
     INTEGER with a value in the range from 1 to n, where n
     equals the rank of MASK.

Return value:
     The result is of the same type as MASK.

     If DIM is absent, a scalar with the parity of all elements in MASK is returned, i.e. true if an odd number of elements is .true. and false otherwise.  If DIM is present, an array of rank n-1, where n equals the rank of ARRAY, and a shape similar to that of MASK with dimension DIM dropped is returned.

Example:

          PROGRAM test_sum
            LOGICAL :: x(2) = [ .true., .false. ]
            print *, PARITY(x) ! prints "T" (true).
          END PROGRAM

PERROR --- Print system error message
=====================================

Description:
     Prints (on the C stderr stream) a newline-terminated error message corresponding to the last system error. This is prefixed by STRING, a colon and a space. See perror(3).

Standard:
     GNU extension

Class:
     Subroutine

Syntax:
     CALL PERROR(STRING)

Arguments:

     STRING   A scalar of type CHARACTER and of the
     default kind.

See also:
     IERRNO

POPCNT --- Number of bits set
=============================

Description:
     POPCNT(I) returns the number of bits set ('1' bits) in the binary representation of I.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = POPCNT(I)

Arguments:

     I   Shall be of type INTEGER.

Return value:
     The return value is of type INTEGER and of the default integer kind.

See also:
     POPPAR, LEADZ, TRAILZ

Example:

          program test_population
            print *, popcnt(127),       poppar(127)
            print *, popcnt(huge(0_4)), poppar(huge(0_4))
            print *, popcnt(huge(0_8)), poppar(huge(0_8))
          end program test_population

POPPAR --- Parity of the number of bits set
===========================================

Description:
     POPPAR(I) returns parity of the integer I, i.e. the parity of the number of bits set ('1' bits) in the binary representation of I. It is equal to 0 if I has an even number of bits set, and 1 for an odd number of '1' bits.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = POPPAR(I)

Arguments:

     I   Shall be of type INTEGER.

Return value:
     The return value is of type INTEGER and of the default integer kind.

See also:
     POPCNT, LEADZ, TRAILZ

Example:

          program test_population
            print *, popcnt(127),       poppar(127)
            print *, popcnt(huge(0_4)), poppar(huge(0_4))
            print *, popcnt(huge(0_8)), poppar(huge(0_8))
          end program test_population

PRECISION --- Decimal precision of a real kind
==============================================

Description:
     PRECISION(X) returns the decimal precision in the model of the type of X.

Standard:
     Fortran 95 and later

Class:
     Inquiry function

Syntax:
     RESULT = PRECISION(X)

Arguments:

     X   Shall be of type REAL or COMPLEX.

Return value:
     The return value is of type INTEGER and of the default integer kind.

See also:
     SELECTED_REAL_KIND, RANGE

Example:

          program prec_and_range
            real(kind=4) :: x(2)
            complex(kind=8) :: y

            print *, precision(x), range(x)
            print *, precision(y), range(y)
          end program prec_and_range

PRESENT --- Determine whether an optional dummy argument is specified
=====================================================================

Description:
     Determines whether an optional dummy argument is present.

Standard:
     Fortran 95 and later

Class:
     Inquiry function

Syntax:
     RESULT = PRESENT(A)

Arguments:

     A   May be of any type and may be a pointer, scalar or array
     value, or a dummy procedure. It shall be the name of an optional dummy argument
     accessible within the current subroutine or function.

Return value:
     Returns either TRUE if the optional argument A is present, or FALSE otherwise.

Example:

          PROGRAM test_present
            WRITE(*,*) f(), f(42)      ! "F T"
          CONTAINS
            LOGICAL FUNCTION f(x)
              INTEGER, INTENT(IN), OPTIONAL :: x
              f = PRESENT(x)
            END FUNCTION
          END PROGRAM

PRODUCT --- Product of array elements
=====================================

Description:
     Multiplies the elements of ARRAY along dimension DIM if the corresponding element in MASK is TRUE.

Standard:
     Fortran 95 and later

Class:
     Transformational function

Syntax:

     RESULT = PRODUCT(ARRAY[, MASK])
     RESULT = PRODUCT(ARRAY, DIM[, MASK])

Arguments:

     ARRAY   Shall be an array of type INTEGER,
     REAL or COMPLEX.
     DIM     (Optional) shall be a scalar of type
     INTEGER with a value in the range from 1 to n, where n
     equals the rank of ARRAY.
     MASK    (Optional) shall be of type LOGICAL
     and either be a scalar or an array of the same shape as ARRAY.

Return value:
     The result is of the same type as ARRAY.

     If DIM is absent, a scalar with the product of all elements in ARRAY is returned. Otherwise, an array of rank n-1, where n equals the rank of ARRAY, and a shape similar to that of ARRAY with dimension DIM dropped is returned.

Example:

          PROGRAM test_product
            INTEGER :: x(5) = (/ 1, 2, 3, 4 ,5 /)
            print *, PRODUCT(x)                    ! all elements, product = 120
            print *, PRODUCT(x, MASK=MOD(x, 2)==1) ! odd elements, product = 15
          END PROGRAM

See also:
     SUM

RADIX --- Base of a model number
================================

Description:
     RADIX(X) returns the base of the model representing the entity X.

Standard:
     Fortran 95 and later

Class:
     Inquiry function

Syntax:
     RESULT = RADIX(X)

Arguments:

     X   Shall be of type INTEGER or REAL

Return value:
     The return value is a scalar of type INTEGER and of the default integer kind.

See also:
     SELECTED_REAL_KIND

Example:

          program test_radix
            print *, "The radix for the default integer kind is", radix(0)
            print *, "The radix for the default real kind is", radix(0.0)
          end program test_radix

RAN --- Real pseudo-random number
=================================

Description:
     For compatibility with HP FORTRAN 77/iX, the RAN intrinsic is provided as an alias for RAND.  See RAND for complete documentation.

Standard:
     GNU extension

Class:
     Function

See also:
     RAND, RANDOM_NUMBER

RAND --- Real pseudo-random number
==================================

Description:
     RAND(FLAG) returns a pseudo-random number from a uniform distribution between 0 and 1. If FLAG is 0, the next number in the current sequence is returned; if FLAG is 1, the generator is restarted by CALL SRAND(0); if FLAG has any other value, it is used as a new seed with SRAND.

     This intrinsic routine is provided for backwards compatibility with GNU Fortran 77. It implements a simple modulo generator as provided by g77. For new code, one should consider the use of RANDOM_NUMBER as it implements a superior algorithm.

Standard:
     GNU extension

Class:
     Function

Syntax:
     RESULT = RAND(I)

Arguments:

     I   Shall be a scalar INTEGER of kind 4.

Return value:
     The return value is of REAL type and the default kind.

Example:

          program test_rand
            integer,parameter :: seed = 86456

            call srand(seed)
            print *, rand(), rand(), rand(), rand()
            print *, rand(seed), rand(), rand(), rand()
          end program test_rand

See also:
     SRAND, RANDOM_NUMBER

RANDOM_INIT --- Initialize a pseudo-random number generator
===========================================================

Description:
     Initializes the state of the pseudorandom number generator used by RANDOM_NUMBER.

Standard:
     Fortran 2018

Class:
     Subroutine

Syntax:
     CALL RANDOM_INIT(REPEATABLE, IMAGE_DISTINCT)

Arguments:

     REPEATABLE   Shall be a scalar with a LOGICAL type,
     and it is INTENT(IN).  If it is .true., the seed is set to
     a processor-dependent value that is the same each time RANDOM_INIT
     is called from the same image.  The term ``same image'' means a single
     instance of program execution.  The sequence of random numbers is different
     for repeated execution of the program.  If it is .false., the seed
     is set to a processor-dependent value.
     IMAGE_DISTINCT   Shall be a scalar with a
     LOGICAL type, and it is INTENT(IN).  If it is .true.,
     the seed is set to a processor-dependent value that is distinct from th
     seed set by a call to RANDOM_INIT in another image.  If it is
     .false., the seed is set value that does depend which image called
     RANDOM_INIT.

Example:

          program test_random_seed
            implicit none
            real x(3), y(3)
            call random_init(.true., .true.)
            call random_number(x)
            call random_init(.true., .true.)
            call random_number(y)
            ! x and y are the same sequence
            if (any(x /= y)) call abort
          end program test_random_seed

See also:
     RANDOM_NUMBER, RANDOM_SEED

RANDOM_NUMBER --- Pseudo-random number
======================================

Description:
     Returns a single pseudorandom number or an array of pseudorandom numbers from the uniform distribution over the range  0 \leq x < 1.

     The runtime-library implements the xorshift1024* random number generator (RNG). This generator has a period of 2^1024 - 1, and when using multiple threads up to 2^512 threads can each generate 2^512 random numbers before any aliasing occurs.

     Note that in a multi-threaded program (e.g. using OpenMP directives), each thread will have its own random number state. For details of the seeding procedure, see the documentation for the RANDOM_SEED intrinsic.

Standard:
     Fortran 95 and later

Class:
     Subroutine

Syntax:
     RANDOM_NUMBER(HARVEST)

Arguments:

     HARVEST   Shall be a scalar or an array of type REAL.

Example:

          program test_random_number
            REAL :: r(5,5)
            CALL RANDOM_NUMBER(r)
          end program

See also:
     RANDOM_SEED, RANDOM_INIT

RANDOM_SEED --- Initialize a pseudo-random number sequence
==========================================================

Description:
     Restarts or queries the state of the pseudorandom number generator used by RANDOM_NUMBER.

     If RANDOM_SEED is called without arguments, it is seeded with random data retrieved from the operating system.

     As an extension to the Fortran standard, the GFortran RANDOM_NUMBER supports multiple threads. Each thread in a multi-threaded program has its own seed.  When RANDOM_SEED is called either without arguments or with the PUT argument, the given seed is copied into a master seed as well as the seed of the current thread. When a new thread uses RANDOM_NUMBER for the first time, the seed is copied from the master seed, and forwarded N * 2^512 steps to guarantee that the random stream does not alias any other stream in the system, where N is the number of threads that have used RANDOM_NUMBER so far during the program execution.

Standard:
     Fortran 95 and later

Class:
     Subroutine

Syntax:
     CALL RANDOM_SEED([SIZE, PUT, GET])

Arguments:

     SIZE   (Optional) Shall be a scalar and of type default
     INTEGER, with INTENT(OUT). It specifies the minimum size
     of the arrays used with the PUT and GET arguments.
     PUT    (Optional) Shall be an array of type default
     INTEGER and rank one. It is INTENT(IN) and the size of
     the array must be larger than or equal to the number returned by the
     SIZE argument.
     GET    (Optional) Shall be an array of type default
     INTEGER and rank one. It is INTENT(OUT) and the size
     of the array must be larger than or equal to the number returned by
     the SIZE argument.

Example:

          program test_random_seed
            implicit none
            integer, allocatable :: seed(:)
            integer :: n

            call random_seed(size = n)
            allocate(seed(n))
            call random_seed(get=seed)
            write (*, *) seed
          end program test_random_seed

See also:
     RANDOM_NUMBER, RANDOM_INIT

RANGE --- Decimal exponent range
================================

Description:
     RANGE(X) returns the decimal exponent range in the model of the type of X.

Standard:
     Fortran 95 and later

Class:
     Inquiry function

Syntax:
     RESULT = RANGE(X)

Arguments:

     X   Shall be of type INTEGER, REAL
     or COMPLEX.

Return value:
     The return value is of type INTEGER and of the default integer kind.

See also:
     SELECTED_REAL_KIND, PRECISION

Example:
     See PRECISION for an example.

RANK --- Rank of a data object
==============================

Description:
     RANK(A) returns the rank of a scalar or array data object.

Standard:
     Technical Specification (TS) 29113

Class:
     Inquiry function

Syntax:
     RESULT = RANK(A)

Arguments:

     A   can be of any type

Return value:
     The return value is of type INTEGER and of the default integer kind. For arrays, their rank is returned; for scalars zero is returned.

Example:

          program test_rank
            integer :: a
            real, allocatable :: b(:,:)

            print *, rank(a), rank(b) ! Prints:  0  2
          end program test_rank

REAL --- Convert to real type
=============================

Description:
     REAL(A [, KIND]) converts its argument A to a real type.  The REALPART function is provided for compatibility with g77, and its use is strongly discouraged.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:

     RESULT = REAL(A [, KIND])
     RESULT = REALPART(Z)

Arguments:

     A      Shall be INTEGER, REAL, or
     COMPLEX.
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     These functions return a REAL variable or array under the following rules:

     (A)
          REAL(A) is converted to a default real type if A is an integer or real variable.

     (B)
          REAL(A) is converted to a real type with the kind type parameter of A if A is a complex variable.

     (C)
          REAL(A, KIND) is converted to a real type with kind type parameter KIND if A is a complex, integer, or real variable.

Example:

          program test_real
            complex :: x = (1.0, 2.0)
            print *, real(x), real(x,8), realpart(x)
          end program test_real

Specific names:

     Name               Argument             Return type       Standard
     FLOAT(A)    INTEGER(4)    REAL(4)    Fortran 77 and later
     DFLOAT(A)   INTEGER(4)    REAL(8)    GNU extension
     FLOATI(A)   INTEGER(2)    REAL(4)    GNU extension
     FLOATJ(A)   INTEGER(4)    REAL(4)    GNU extension
     FLOATK(A)   INTEGER(8)    REAL(4)    GNU extension
     SNGL(A)     INTEGER(8)    REAL(4)    Fortran 77 and later

See also:
     DBLE

RENAME --- Rename a file
========================

Description:
     Renames a file from file PATH1 to PATH2. A null character (CHAR(0)) can be used to mark the end of the names in PATH1 and PATH2; otherwise, trailing blanks in the file names are ignored.  If the STATUS argument is supplied, it contains 0 on success or a nonzero error code upon return; see rename(2).

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL RENAME(PATH1, PATH2 [, STATUS])
     STATUS = RENAME(PATH1, PATH2)

Arguments:

     PATH1   Shall be of default CHARACTER type.
     PATH2   Shall be of default CHARACTER type.
     STATUS   (Optional) Shall be of default INTEGER type.

See also:
     LINK

REPEAT --- Repeated string concatenation
========================================

Description:
     Concatenates NCOPIES copies of a string.

Standard:
     Fortran 95 and later

Class:
     Transformational function

Syntax:
     RESULT = REPEAT(STRING, NCOPIES)

Arguments:

     STRING    Shall be scalar and of type CHARACTER.
     NCOPIES   Shall be scalar and of type INTEGER.

Return value:
     A new scalar of type CHARACTER built up from NCOPIES copies of STRING.

Example:

          program test_repeat
            write(*,*) repeat("x", 5)   ! "xxxxx"
          end program

RESHAPE --- Function to reshape an array
========================================

Description:
     Reshapes SOURCE to correspond to SHAPE. If necessary, the new array may be padded with elements from PAD or permuted as defined by ORDER.

Standard:
     Fortran 95 and later

Class:
     Transformational function

Syntax:
     RESULT = RESHAPE(SOURCE, SHAPE[, PAD, ORDER])

Arguments:

     SOURCE   Shall be an array of any type.
     SHAPE    Shall be of type INTEGER and an
     array of rank one. Its values must be positive or zero.
     PAD      (Optional) shall be an array of the same
     type as SOURCE.
     ORDER    (Optional) shall be of type INTEGER
     and an array of the same shape as SHAPE. Its values shall
     be a permutation of the numbers from 1 to n, where n is the size of
     SHAPE. If ORDER is absent, the natural ordering shall
     be assumed.

Return value:
     The result is an array of shape SHAPE with the same type as SOURCE.

Example:

          PROGRAM test_reshape
            INTEGER, DIMENSION(4) :: x
            WRITE(*,*) SHAPE(x)                       ! prints "4"
            WRITE(*,*) SHAPE(RESHAPE(x, (/2, 2/)))    ! prints "2 2"
          END PROGRAM

See also:
     SHAPE

RRSPACING --- Reciprocal of the relative spacing
================================================

Description:
     RRSPACING(X) returns the  reciprocal of the relative spacing of model numbers near X.

Standard:
     Fortran 95 and later

Class:
     Elemental function

Syntax:
     RESULT = RRSPACING(X)

Arguments:

     X   Shall be of type REAL.

Return value:
     The return value is of the same type and kind as X. The value returned is equal to ABS(FRACTION(X)) * FLOAT(RADIX(X))**DIGITS(X).

See also:
     SPACING

RSHIFT --- Right shift bits
===========================

Description:
     RSHIFT returns a value corresponding to I with all of the bits shifted right by SHIFT places.  SHIFT shall be nonnegative and less than or equal to BIT_SIZE(I), otherwise the result value is undefined.  Bits shifted out from the right end are lost. The fill is arithmetic: the bits shifted in from the left end are equal to the leftmost bit, which in two's complement representation is the sign bit.

     This function has been superseded by the SHIFTA intrinsic, which is standard in Fortran 2008 and later.

Standard:
     GNU extension

Class:
     Elemental function

Syntax:
     RESULT = RSHIFT(I, SHIFT)

Arguments:

     I   The type shall be INTEGER.
     SHIFT   The type shall be INTEGER.

Return value:
     The return value is of type INTEGER and of the same kind as I.

See also:
     ISHFT, ISHFTC, LSHIFT, SHIFTA, SHIFTR, SHIFTL

SAME_TYPE_AS --- Query dynamic types for equality
=================================================

Description:
     Query dynamic types for equality.

Standard:
     Fortran 2003 and later

Class:
     Inquiry function

Syntax:
     RESULT = SAME_TYPE_AS(A, B)

Arguments:

     A   Shall be an object of extensible declared type or
     unlimited polymorphic.
     B   Shall be an object of extensible declared type or
     unlimited polymorphic.

Return value:
     The return value is a scalar of type default logical. It is true if and only if the dynamic type of A is the same as the dynamic type of B.

See also:
     EXTENDS_TYPE_OF

SCALE --- Scale a real value
============================

Description:
     SCALE(X,I) returns X * RADIX(X)**I.

Standard:
     Fortran 95 and later

Class:
     Elemental function

Syntax:
     RESULT = SCALE(X, I)

Arguments:

     X   The type of the argument shall be a REAL.
     I   The type of the argument shall be a INTEGER.

Return value:
     The return value is of the same type and kind as X. Its value is X * RADIX(X)**I.

Example:

          program test_scale
            real :: x = 178.1387e-4
            integer :: i = 5
            print *, scale(x,i), x*radix(x)**i
          end program test_scale

SCAN --- Scan a string for the presence of a set of characters
==============================================================

Description:
     Scans a STRING for any of the characters in a SET of characters.

     If BACK is either absent or equals FALSE, this function returns the position of the leftmost character of STRING that is in SET. If BACK equals TRUE, the rightmost position is returned. If no character of SET is found in STRING, the result is zero.

Standard:
     Fortran 95 and later, with KIND argument Fortran 2003 and later

Class:
     Elemental function

Syntax:
     RESULT = SCAN(STRING, SET[, BACK [, KIND]])

Arguments:

     STRING   Shall be of type CHARACTER.
     SET      Shall be of type CHARACTER.
     BACK     (Optional) shall be of type LOGICAL.
     KIND     (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     The return value is of type INTEGER and of kind KIND. If KIND is absent, the return value is of default integer kind.

Example:

          PROGRAM test_scan
            WRITE(*,*) SCAN("FORTRAN", "AO")          ! 2, found 'O'
            WRITE(*,*) SCAN("FORTRAN", "AO", .TRUE.)  ! 6, found 'A'
            WRITE(*,*) SCAN("FORTRAN", "C++")         ! 0, found none
          END PROGRAM

See also:
     INDEX intrinsic, VERIFY

SECNDS --- Time function
========================

Description:
     SECNDS(X) gets the time in seconds from the real-time system clock. X is a reference time, also in seconds. If this is zero, the time in seconds from midnight is returned. This function is non-standard and its use is discouraged.

Standard:
     GNU extension

Class:
     Function

Syntax:
     RESULT = SECNDS (X)

Arguments:

     T       Shall be of type REAL(4).
     X       Shall be of type REAL(4).

Return value:
     None

Example:

          program test_secnds
              integer :: i
              real(4) :: t1, t2
              print *, secnds (0.0)   ! seconds since midnight
              t1 = secnds (0.0)       ! reference time
              do i = 1, 10000000      ! do something
              end do
              t2 = secnds (t1)        ! elapsed time
              print *, "Something took ", t2, " seconds."
          end program test_secnds

SECOND --- CPU time function
============================

Description:
     Returns a REAL(4) value representing the elapsed CPU time in seconds.  This provides the same functionality as the standard CPU_TIME intrinsic, and is only included for backwards compatibility.

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL SECOND(TIME)
     TIME = SECOND()

Arguments:

     TIME    Shall be of type REAL(4).

Return value:
     In either syntax, TIME is set to the process's current runtime in seconds.

See also:
     CPU_TIME

SELECTED_CHAR_KIND --- Choose character kind
============================================

Description:

     SELECTED_CHAR_KIND(NAME) returns the kind value for the character set named NAME, if a character set with such a name is supported, or -1 otherwise. Currently, supported character sets include ``ASCII'' and ``DEFAULT'', which are equivalent, and ``ISO_10646'' (Universal Character Set, UCS-4) which is commonly known as Unicode.

Standard:
     Fortran 2003 and later

Class:
     Transformational function

Syntax:
     RESULT = SELECTED_CHAR_KIND(NAME)

Arguments:

     NAME   Shall be a scalar and of the default character type.

Example:

          program character_kind
            use iso_fortran_env
            implicit none
            integer, parameter :: ascii = selected_char_kind ("ascii")
            integer, parameter :: ucs4  = selected_char_kind ('ISO_10646')

            character(kind=ascii, len=26) :: alphabet
            character(kind=ucs4,  len=30) :: hello_world

            alphabet = ascii_"abcdefghijklmnopqrstuvwxyz"
            hello_world = ucs4_'Hello World and Ni Hao -- ' &
                          // char (int (z'4F60'), ucs4)     &
                          // char (int (z'597D'), ucs4)

            write (*,*) alphabet

            open (output_unit, encoding='UTF-8')
            write (*,*) trim (hello_world)
          end program character_kind

SELECTED_INT_KIND --- Choose integer kind
=========================================

Description:
     SELECTED_INT_KIND(R) return the kind value of the smallest integer type that can represent all values ranging from -10^R (exclusive) to 10^R (exclusive). If there is no integer kind that accommodates this range, SELECTED_INT_KIND returns -1.

Standard:
     Fortran 95 and later

Class:
     Transformational function

Syntax:
     RESULT = SELECTED_INT_KIND(R)

Arguments:

     R   Shall be a scalar and of type INTEGER.

Example:

          program large_integers
            integer,parameter :: k5 = selected_int_kind(5)
            integer,parameter :: k15 = selected_int_kind(15)
            integer(kind=k5) :: i5
            integer(kind=k15) :: i15

            print *, huge(i5), huge(i15)

            ! The following inequalities are always true
            print *, huge(i5) >= 10_k5**5-1
            print *, huge(i15) >= 10_k15**15-1
          end program large_integers

SELECTED_REAL_KIND --- Choose real kind
=======================================

Description:
     SELECTED_REAL_KIND(P,R) returns the kind value of a real data type with decimal precision of at least P digits, exponent range of at least R, and with a radix of RADIX.

Standard:
     Fortran 95 and later, with RADIX Fortran 2008 or later

Class:
     Transformational function

Syntax:
     RESULT = SELECTED_REAL_KIND([P, R, RADIX])

Arguments:

     P   (Optional) shall be a scalar and of type INTEGER.
     R   (Optional) shall be a scalar and of type INTEGER.
     RADIX   (Optional) shall be a scalar and of type INTEGER.

     Before Fortran 2008, at least one of the arguments R or P shall be present; since Fortran 2008, they are assumed to be zero if absent.

Return value:

     SELECTED_REAL_KIND returns the value of the kind type parameter of a real data type with decimal precision of at least P digits, a decimal exponent range of at least R, and with the requested RADIX. If the RADIX parameter is absent, real kinds with any radix can be returned. If more than one real data type meet the criteria, the kind of the data type with the smallest decimal precision is returned. If no real data type matches the criteria, the result is

     -1 if the processor does not support a real data type with a
          precision greater than or equal to P, but the R and RADIX requirements can be fulfilled

     -2 if the processor does not support a real type with an exponent
          range greater than or equal to R, but P and RADIX are fulfillable

     -3 if RADIX but not P and R requirements
          are fulfillable

     -4 if RADIX and either P or R requirements
          are fulfillable

     -5 if there is no real type with the given RADIX

See also:
     PRECISION, RANGE, RADIX

Example:

          program real_kinds
            integer,parameter :: p6 = selected_real_kind(6)
            integer,parameter :: p10r100 = selected_real_kind(10,100)
            integer,parameter :: r400 = selected_real_kind(r=400)
            real(kind=p6) :: x
            real(kind=p10r100) :: y
            real(kind=r400) :: z

            print *, precision(x), range(x)
            print *, precision(y), range(y)
            print *, precision(z), range(z)
          end program real_kinds

SET_EXPONENT --- Set the exponent of the model
==============================================

Description:
     SET_EXPONENT(X, I) returns the real number whose fractional part is that that of X and whose exponent part is I.

Standard:
     Fortran 95 and later

Class:
     Elemental function

Syntax:
     RESULT = SET_EXPONENT(X, I)

Arguments:

     X   Shall be of type REAL.
     I   Shall be of type INTEGER.

Return value:
     The return value is of the same type and kind as X. The real number whose fractional part is that that of X and whose exponent part if I is returned; it is FRACTION(X) * RADIX(X)**I.

Example:

          PROGRAM test_setexp
            REAL :: x = 178.1387e-4
            INTEGER :: i = 17
            PRINT *, SET_EXPONENT(x, i), FRACTION(x) * RADIX(x)**i
          END PROGRAM

SHAPE --- Determine the shape of an array
=========================================

Description:
     Determines the shape of an array.

Standard:
     Fortran 95 and later, with KIND argument Fortran 2003 and later

Class:
     Inquiry function

Syntax:
     RESULT = SHAPE(SOURCE [, KIND])

Arguments:

     SOURCE   Shall be an array or scalar of any type.
     If SOURCE is a pointer it must be associated and allocatable
     arrays must be allocated.
     KIND     (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     An INTEGER array of rank one with as many elements as SOURCE has dimensions. The elements of the resulting array correspond to the extend of SOURCE along the respective dimensions. If SOURCE is a scalar, the result is the rank one array of size zero. If KIND is absent, the return value has the default integer kind otherwise the specified kind.

Example:

          PROGRAM test_shape
            INTEGER, DIMENSION(-1:1, -1:2) :: A
            WRITE(*,*) SHAPE(A)             ! (/ 3, 4 /)
            WRITE(*,*) SIZE(SHAPE(42))      ! (/ /)
          END PROGRAM

See also:
     RESHAPE, SIZE

SHIFTA --- Right shift with fill
================================

Description:
     SHIFTA returns a value corresponding to I with all of the bits shifted right by SHIFT places.  SHIFT that be nonnegative and less than or equal to BIT_SIZE(I), otherwise the result value is undefined.  Bits shifted out from the right end are lost. The fill is arithmetic: the bits shifted in from the left end are equal to the leftmost bit, which in two's complement representation is the sign bit.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = SHIFTA(I, SHIFT)

Arguments:

     I   The type shall be INTEGER.
     SHIFT   The type shall be INTEGER.

Return value:
     The return value is of type INTEGER and of the same kind as I.

See also:
     SHIFTL, SHIFTR

SHIFTL --- Left shift
=====================

Description:
     SHIFTL returns a value corresponding to I with all of the bits shifted left by SHIFT places.  SHIFT shall be nonnegative and less than or equal to BIT_SIZE(I), otherwise the result value is undefined.  Bits shifted out from the left end are lost, and bits shifted in from the right end are set to 0.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = SHIFTL(I, SHIFT)

Arguments:

     I   The type shall be INTEGER.
     SHIFT   The type shall be INTEGER.

Return value:
     The return value is of type INTEGER and of the same kind as I.

See also:
     SHIFTA, SHIFTR

SHIFTR --- Right shift
======================

Description:
     SHIFTR returns a value corresponding to I with all of the bits shifted right by SHIFT places.  SHIFT shall be nonnegative and less than or equal to BIT_SIZE(I), otherwise the result value is undefined.  Bits shifted out from the right end are lost, and bits shifted in from the left end are set to 0.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = SHIFTR(I, SHIFT)

Arguments:

     I   The type shall be INTEGER.
     SHIFT   The type shall be INTEGER.

Return value:
     The return value is of type INTEGER and of the same kind as I.

See also:
     SHIFTA, SHIFTL

SIGN --- Sign copying function
==============================

Description:
     SIGN(A,B) returns the value of A with the sign of B.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = SIGN(A, B)

Arguments:

     A   Shall be of type INTEGER or REAL
     B   Shall be of the same type and kind as A

Return value:
     The kind of the return value is that of A and B. If B\ge 0 then the result is ABS(A), else it is -ABS(A).

Example:

          program test_sign
            print *, sign(-12,1)
            print *, sign(-12,0)
            print *, sign(-12,-1)

            print *, sign(-12.,1.)
            print *, sign(-12.,0.)
            print *, sign(-12.,-1.)
          end program test_sign

Specific names:

     Name                Arguments                Return type         Standard
     SIGN(A,B)    REAL(4) A, B      REAL(4)      f77, gnu
     ISIGN(A,B)   INTEGER(4) A, B   INTEGER(4)   f77, gnu
     DSIGN(A,B)   REAL(8) A, B      REAL(8)      f77, gnu

SIGNAL --- Signal handling subroutine (or function)
===================================================

Description:
     SIGNAL(NUMBER, HANDLER [, STATUS]) causes external subroutine HANDLER to be executed with a single integer argument when signal NUMBER occurs.  If HANDLER is an integer, it can be used to turn off handling of signal NUMBER or revert to its default action.  See signal(2).

     If SIGNAL is called as a subroutine and the STATUS argument is supplied, it is set to the value returned by signal(2).

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL SIGNAL(NUMBER, HANDLER [, STATUS])
     STATUS = SIGNAL(NUMBER, HANDLER)

Arguments:

     NUMBER   Shall be a scalar integer, with INTENT(IN)
     HANDLER  Signal handler (INTEGER FUNCTION or
     SUBROUTINE) or dummy/global INTEGER scalar.
     INTEGER. It is INTENT(IN).
     STATUS   (Optional) STATUS shall be a scalar
     integer. It has INTENT(OUT).

Return value:
     The SIGNAL function returns the value returned by signal(2).

Example:

          program test_signal
            intrinsic signal
            external handler_print

            call signal (12, handler_print)
            call signal (10, 1)

            call sleep (30)
          end program test_signal

SIN --- Sine function
=====================

Description:
     SIN(X) computes the sine of X.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = SIN(X)

Arguments:

     X   The type shall be REAL or
     COMPLEX.

Return value:
     The return value has same type and kind as X.

Example:

          program test_sin
            real :: x = 0.0
            x = sin(x)
          end program test_sin

Specific names:

     Name              Argument               Return type         Standard
     SIN(X)     REAL(4) X       REAL(4)      f77, gnu
     DSIN(X)    REAL(8) X       REAL(8)      f95, gnu
     CSIN(X)    COMPLEX(4) X    COMPLEX(4)   f95, gnu
     ZSIN(X)    COMPLEX(8) X    COMPLEX(8)   f95, gnu
     CDSIN(X)   COMPLEX(8) X    COMPLEX(8)   f95, gnu

See also:
     Inverse function: ASIN Degrees function: SIND

SIND --- Sine function, degrees
===============================

Description:
     SIND(X) computes the sine of X in degrees.

     This function is for compatibility only and should be avoided in favor of standard constructs wherever possible.

Standard:
     GNU Extension, enabled with -fdec-math.

Class:
     Elemental function

Syntax:
     RESULT = SIND(X)

Arguments:

     X   The type shall be REAL or
     COMPLEX.

Return value:
     The return value has same type and kind as X, and its value is in degrees.

Example:

          program test_sind
            real :: x = 0.0
            x = sind(x)
          end program test_sind

Specific names:

     Name              Argument               Return type         Standard
     SIND(X)     REAL(4) X       REAL(4)      GNU Extension
     DSIND(X)    REAL(8) X       REAL(8)      GNU Extension
     CSIND(X)    COMPLEX(4) X    COMPLEX(4)   GNU Extension
     ZSIND(X)    COMPLEX(8) X    COMPLEX(8)   GNU Extension
     CDSIND(X)   COMPLEX(8) X    COMPLEX(8)   GNU Extension

See also:
     Inverse function: ASIND Radians function: SIN

SINH --- Hyperbolic sine function
=================================

Description:
     SINH(X) computes the hyperbolic sine of X.

Standard:
     Fortran 95 and later, for a complex argument Fortran 2008 or later

Class:
     Elemental function

Syntax:
     RESULT = SINH(X)

Arguments:

     X   The type shall be REAL or COMPLEX.

Return value:
     The return value has same type and kind as X.

Example:

          program test_sinh
            real(8) :: x = - 1.0_8
            x = sinh(x)
          end program test_sinh

Specific names:

     Name              Argument            Return type         Standard
     SINH(X)    REAL(4) X    REAL(4)      Fortran 95 and later
     DSINH(X)   REAL(8) X    REAL(8)      Fortran 95 and later

See also:
     ASINH

SIZE --- Determine the size of an array
=======================================

Description:
     Determine the extent of ARRAY along a specified dimension DIM, or the total number of elements in ARRAY if DIM is absent.

Standard:
     Fortran 95 and later, with KIND argument Fortran 2003 and later

Class:
     Inquiry function

Syntax:
     RESULT = SIZE(ARRAY[, DIM [, KIND]])

Arguments:

     ARRAY   Shall be an array of any type. If ARRAY is
     a pointer it must be associated and allocatable arrays must be allocated.
     DIM     (Optional) shall be a scalar of type INTEGER
     and its value shall be in the range from 1 to n, where n equals the rank
     of ARRAY.
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     The return value is of type INTEGER and of kind KIND. If KIND is absent, the return value is of default integer kind.

Example:

          PROGRAM test_size
            WRITE(*,*) SIZE((/ 1, 2 /))    ! 2
          END PROGRAM

See also:
     SHAPE, RESHAPE

SIZEOF --- Size in bytes of an expression
=========================================

Description:
     SIZEOF(X) calculates the number of bytes of storage the expression X occupies.

Standard:
     GNU extension

Class:
     Inquiry function

Syntax:
     N = SIZEOF(X)

Arguments:

     X   The argument shall be of any type, rank or shape.

Return value:
     The return value is of type integer and of the system-dependent kind C_SIZE_T (from the ISO_C_BINDING module). Its value is the number of bytes occupied by the argument.  If the argument has the POINTER attribute, the number of bytes of the storage area pointed to is returned.  If the argument is of a derived type with POINTER or ALLOCATABLE components, the return value does not account for the sizes of the data pointed to by these components. If the argument is polymorphic, the size according to the dynamic type is returned. The argument may not be a procedure or procedure pointer. Note that the code assumes for arrays that those are contiguous; for contiguous arrays, it returns the storage or an array element multiplied by the size of the array.

Example:

             integer :: i
             real :: r, s(5)
             print *, (sizeof(s)/sizeof(r) == 5)
             end

     The example will print .TRUE. unless you are using a platform where default REAL variables are unusually padded.

See also:
     C_SIZEOF, STORAGE_SIZE

SLEEP --- Sleep for the specified number of seconds
===================================================

Description:
     Calling this subroutine causes the process to pause for SECONDS seconds.

Standard:
     GNU extension

Class:
     Subroutine

Syntax:
     CALL SLEEP(SECONDS)

Arguments:

     SECONDS   The type shall be of default INTEGER.

Example:

          program test_sleep
            call sleep(5)
          end

SPACING --- Smallest distance between two numbers of a given type
=================================================================

Description:
     Determines the distance between the argument X and the nearest adjacent number of the same type.

Standard:
     Fortran 95 and later

Class:
     Elemental function

Syntax:
     RESULT = SPACING(X)

Arguments:

     X   Shall be of type REAL.

Return value:
     The result is of the same type as the input argument X.

Example:

          PROGRAM test_spacing
            INTEGER, PARAMETER :: SGL = SELECTED_REAL_KIND(p=6, r=37)
            INTEGER, PARAMETER :: DBL = SELECTED_REAL_KIND(p=13, r=200)

            WRITE(*,*) spacing(1.0_SGL)      ! "1.1920929E-07"          on i686
            WRITE(*,*) spacing(1.0_DBL)      ! "2.220446049250313E-016" on i686
          END PROGRAM

See also:
     RRSPACING

SPREAD --- Add a dimension to an array
======================================

Description:
     Replicates a SOURCE array NCOPIES times along a specified dimension DIM.

Standard:
     Fortran 95 and later

Class:
     Transformational function

Syntax:
     RESULT = SPREAD(SOURCE, DIM, NCOPIES)

Arguments:

     SOURCE    Shall be a scalar or an array of any type and
     a rank less than seven.
     DIM       Shall be a scalar of type INTEGER with a
     value in the range from 1 to n+1, where n equals the rank of SOURCE.
     NCOPIES   Shall be a scalar of type INTEGER.

Return value:
     The result is an array of the same type as SOURCE and has rank n+1 where n equals the rank of SOURCE.

Example:

          PROGRAM test_spread
            INTEGER :: a = 1, b(2) = (/ 1, 2 /)
            WRITE(*,*) SPREAD(A, 1, 2)            ! "1 1"
            WRITE(*,*) SPREAD(B, 1, 2)            ! "1 1 2 2"
          END PROGRAM

See also:
     UNPACK

SQRT --- Square-root function
=============================

Description:
     SQRT(X) computes the square root of X.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = SQRT(X)

Arguments:

     X   The type shall be REAL or
     COMPLEX.

Return value:
     The return value is of type REAL or COMPLEX. The kind type parameter is the same as X.

Example:

          program test_sqrt
            real(8) :: x = 2.0_8
            complex :: z = (1.0, 2.0)
            x = sqrt(x)
            z = sqrt(z)
          end program test_sqrt

Specific names:

     Name               Argument               Return type            Standard
     SQRT(X)     REAL(4) X       REAL(4)         Fortran 95 and later
     DSQRT(X)    REAL(8) X       REAL(8)         Fortran 95 and later
     CSQRT(X)    COMPLEX(4) X    COMPLEX(4)      Fortran 95 and later
     ZSQRT(X)    COMPLEX(8) X    COMPLEX(8)      GNU extension
     CDSQRT(X)   COMPLEX(8) X    COMPLEX(8)      GNU extension

SRAND --- Reinitialize the random number generator
==================================================

Description:
     SRAND reinitializes the pseudo-random number generator called by RAND and IRAND. The new seed used by the generator is specified by the required argument SEED.

Standard:
     GNU extension

Class:
     Subroutine

Syntax:
     CALL SRAND(SEED)

Arguments:

     SEED   Shall be a scalar INTEGER(kind=4).

Return value:
     Does not return anything.

Example:
     See RAND and IRAND for examples.

Notes:
     The Fortran standard specifies the intrinsic subroutines RANDOM_SEED to initialize the pseudo-random number generator and RANDOM_NUMBER to generate pseudo-random numbers. These subroutines should be used in new codes.

     Please note that in GNU Fortran, these two sets of intrinsics (RAND, IRAND and SRAND on the one hand, RANDOM_NUMBER and RANDOM_SEED on the other hand) access two independent pseudo-random number generators.

See also:
     RAND, RANDOM_SEED, RANDOM_NUMBER

STAT --- Get file status
========================

Description:
     This function returns information about a file. No permissions are required on the file itself, but execute (search) permission is required on all of the directories in path that lead to the file.

     The elements that are obtained and stored in the array VALUES:

     VALUES(1)      Device ID
     VALUES(2)      Inode number
     VALUES(3)      File mode
     VALUES(4)      Number of links
     VALUES(5)      Owner's uid
     VALUES(6)      Owner's gid
     VALUES(7)      ID of device containing directory entry for file (0 if not available)
     VALUES(8)      File size (bytes)
     VALUES(9)      Last access time
     VALUES(10)     Last modification time
     VALUES(11)     Last file status change time
     VALUES(12)     Preferred I/O block size (-1 if not available)
     VALUES(13)     Number of blocks allocated (-1 if not available)

     Not all these elements are relevant on all systems. If an element is not relevant, it is returned as 0.

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL STAT(NAME, VALUES [, STATUS])
     STATUS = STAT(NAME, VALUES)

Arguments:

     NAME     The type shall be CHARACTER, of the
     default kind and a valid path within the file system.
     VALUES   The type shall be INTEGER(4), DIMENSION(13).
     STATUS   (Optional) status flag of type INTEGER(4). Returns 0
     on success and a system specific error code otherwise.

Example:

          PROGRAM test_stat
            INTEGER, DIMENSION(13) :: buff
            INTEGER :: status

            CALL STAT("/etc/passwd", buff, status)

            IF (status == 0) THEN
              WRITE (*, FMT="('Device ID:',               T30, I19)") buff(1)
              WRITE (*, FMT="('Inode number:',            T30, I19)") buff(2)
              WRITE (*, FMT="('File mode (octal):',       T30, O19)") buff(3)
              WRITE (*, FMT="('Number of links:',         T30, I19)") buff(4)
              WRITE (*, FMT="('Owner''s uid:',            T30, I19)") buff(5)
              WRITE (*, FMT="('Owner''s gid:',            T30, I19)") buff(6)
              WRITE (*, FMT="('Device where located:',    T30, I19)") buff(7)
              WRITE (*, FMT="('File size:',               T30, I19)") buff(8)
              WRITE (*, FMT="('Last access time:',        T30, A19)") CTIME(buff(9))
              WRITE (*, FMT="('Last modification time',   T30, A19)") CTIME(buff(10))
              WRITE (*, FMT="('Last status change time:', T30, A19)") CTIME(buff(11))
              WRITE (*, FMT="('Preferred block size:',    T30, I19)") buff(12)
              WRITE (*, FMT="('No. of blocks allocated:', T30, I19)") buff(13)
            END IF
          END PROGRAM

See also:
     To stat an open file: FSTAT, to stat a link: LSTAT

STORAGE_SIZE --- Storage size in bits
=====================================

Description:
     Returns the storage size of argument A in bits.

Standard:
     Fortran 2008 and later

Class:
     Inquiry function

Syntax:
     RESULT = STORAGE_SIZE(A [, KIND])

Arguments:

     A   Shall be a scalar or array of any type.
     KIND   (Optional) shall be a scalar integer constant expression.

Return Value:
     The result is a scalar integer with the kind type parameter specified by KIND (or default integer type if KIND is missing). The result value is the size expressed in bits for an element of an array that has the dynamic type and type parameters of A.

See also:
     C_SIZEOF, SIZEOF

SUM --- Sum of array elements
=============================

Description:
     Adds the elements of ARRAY along dimension DIM if the corresponding element in MASK is TRUE.

Standard:
     Fortran 95 and later

Class:
     Transformational function

Syntax:

     RESULT = SUM(ARRAY[, MASK])
     RESULT = SUM(ARRAY, DIM[, MASK])

Arguments:

     ARRAY   Shall be an array of type INTEGER,
     REAL or COMPLEX.
     DIM     (Optional) shall be a scalar of type
     INTEGER with a value in the range from 1 to n, where n
     equals the rank of ARRAY.
     MASK    (Optional) shall be of type LOGICAL
     and either be a scalar or an array of the same shape as ARRAY.

Return value:
     The result is of the same type as ARRAY.

     If DIM is absent, a scalar with the sum of all elements in ARRAY is returned. Otherwise, an array of rank n-1, where n equals the rank of ARRAY, and a shape similar to that of ARRAY with dimension DIM dropped is returned.

Example:

          PROGRAM test_sum
            INTEGER :: x(5) = (/ 1, 2, 3, 4 ,5 /)
            print *, SUM(x)                        ! all elements, sum = 15
            print *, SUM(x, MASK=MOD(x, 2)==1)     ! odd elements, sum = 9
          END PROGRAM

See also:
     PRODUCT

SYMLNK --- Create a symbolic link
=================================

Description:
     Makes a symbolic link from file PATH1 to PATH2. A null character (CHAR(0)) can be used to mark the end of the names in PATH1 and PATH2; otherwise, trailing blanks in the file names are ignored.  If the STATUS argument is supplied, it contains 0 on success or a nonzero error code upon return; see symlink(2).  If the system does not supply symlink(2), ENOSYS is returned.

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL SYMLNK(PATH1, PATH2 [, STATUS])
     STATUS = SYMLNK(PATH1, PATH2)

Arguments:

     PATH1   Shall be of default CHARACTER type.
     PATH2   Shall be of default CHARACTER type.
     STATUS   (Optional) Shall be of default INTEGER type.

See also:
     LINK, UNLINK

SYSTEM --- Execute a shell command
==================================

Description:
     Passes the command COMMAND to a shell (see system(3)). If argument STATUS is present, it contains the value returned by system(3), which is presumably 0 if the shell command succeeded. Note that which shell is used to invoke the command is system-dependent and environment-dependent.

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

     Note that the system function need not be thread-safe. It is the responsibility of the user to ensure that system is not called concurrently.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL SYSTEM(COMMAND [, STATUS])
     STATUS = SYSTEM(COMMAND)

Arguments:

     COMMAND   Shall be of default CHARACTER type.
     STATUS    (Optional) Shall be of default INTEGER type.

See also:
     EXECUTE_COMMAND_LINE, which is part of the Fortran 2008 standard and should considered in new code for future portability.

SYSTEM_CLOCK --- Time function
==============================

Description:
     Determines the COUNT of a processor clock since an unspecified time in the past modulo COUNT_MAX, COUNT_RATE determines the number of clock ticks per second.  If the platform supports a monotonic clock, that clock is used and can, depending on the platform clock implementation, provide up to nanosecond resolution.  If a monotonic clock is not available, the implementation falls back to a realtime clock.

     COUNT_RATE is system dependent and can vary depending on the kind of the arguments. For KIND=4 arguments (and smaller integer kinds), COUNT represents milliseconds, while for KIND=8 arguments (and larger integer kinds), COUNT typically represents micro- or nanoseconds depending on resolution of the underlying platform clock. COUNT_MAX usually equals HUGE(COUNT_MAX). Note that the millisecond resolution of the KIND=4 version implies that the COUNT will wrap around in roughly 25 days. In order to avoid issues with the wrap around and for more precise timing, please use the KIND=8 version.

     If there is no clock, or querying the clock fails, COUNT is set to -HUGE(COUNT), and COUNT_RATE and COUNT_MAX are set to zero.

     When running on a platform using the GNU C library (glibc) version 2.16 or older, or a derivative thereof, the high resolution monotonic clock is available only when linking with the RT library.  This can be done explicitly by adding the -lrt flag when linking the application, but is also done implicitly when using OpenMP.

     On the Windows platform, the version with KIND=4 arguments uses the GetTickCount function, whereas the KIND=8 version uses QueryPerformanceCounter and QueryPerformanceCounterFrequency. For more information, and potential caveats, please see the platform documentation.

Standard:
     Fortran 95 and later

Class:
     Subroutine

Syntax:
     CALL SYSTEM_CLOCK([COUNT, COUNT_RATE, COUNT_MAX])

Arguments:

     COUNT        (Optional) shall be a scalar of type
     INTEGER with INTENT(OUT).
     COUNT_RATE   (Optional) shall be a scalar of type
     INTEGER or REAL, with INTENT(OUT).
     COUNT_MAX    (Optional) shall be a scalar of type
     INTEGER with INTENT(OUT).

Example:

          PROGRAM test_system_clock
            INTEGER :: count, count_rate, count_max
            CALL SYSTEM_CLOCK(count, count_rate, count_max)
            WRITE(*,*) count, count_rate, count_max
          END PROGRAM

See also:
     DATE_AND_TIME, CPU_TIME

TAN --- Tangent function
========================

Description:
     TAN(X) computes the tangent of X.

Standard:
     Fortran 77 and later, for a complex argument Fortran 2008 or later

Class:
     Elemental function

Syntax:
     RESULT = TAN(X)

Arguments:

     X   The type shall be REAL or COMPLEX.

Return value:
     The return value has same type and kind as X, and its value is in radians.

Example:

          program test_tan
            real(8) :: x = 0.165_8
            x = tan(x)
          end program test_tan

Specific names:

     Name              Argument            Return type       Standard
     TAN(X)     REAL(4) X    REAL(4)    Fortran 95 and later
     DTAN(X)    REAL(8) X    REAL(8)    Fortran 95 and later

See also:
     Inverse function: ATAN Degrees function: TAND

TAND --- Tangent function, degrees
==================================

Description:
     TAND(X) computes the tangent of X in degrees.

     This function is for compatibility only and should be avoided in favor of standard constructs wherever possible.

Standard:
     GNU Extension, enabled with -fdec-math.

Class:
     Elemental function

Syntax:
     RESULT = TAND(X)

Arguments:

     X   The type shall be REAL or COMPLEX.

Return value:
     The return value has same type and kind as X, and its value is in degrees.

Example:

          program test_tand
            real(8) :: x = 0.165_8
            x = tand(x)
          end program test_tand

Specific names:

     Name              Argument            Return type       Standard
     TAND(X)     REAL(4) X    REAL(4)    GNU Extension
     DTAND(X)    REAL(8) X    REAL(8)    GNU Extension

See also:
     Inverse function: ATAND Radians function: TAN

TANH --- Hyperbolic tangent function
====================================

Description:
     TANH(X) computes the hyperbolic tangent of X.

Standard:
     Fortran 77 and later, for a complex argument Fortran 2008 or later

Class:
     Elemental function

Syntax:
     X = TANH(X)

Arguments:

     X   The type shall be REAL or COMPLEX.

Return value:
     The return value has same type and kind as X. If X is complex, the imaginary part of the result is in radians. If X is REAL, the return value lies in the range - 1 \leq tanh(x) \leq 1 .

Example:

          program test_tanh
            real(8) :: x = 2.1_8
            x = tanh(x)
          end program test_tanh

Specific names:

     Name              Argument            Return type         Standard
     TANH(X)    REAL(4) X    REAL(4)      Fortran 95 and later
     DTANH(X)   REAL(8) X    REAL(8)      Fortran 95 and later

See also:
     ATANH

THIS_IMAGE --- Function that returns the cosubscript index of this image
========================================================================

Description:
     Returns the cosubscript for this image.

Standard:
     Fortran 2008 and later. With DISTANCE argument, Technical Specification (TS) 18508 or later

Class:
     Transformational function

Syntax:

     RESULT = THIS_IMAGE()
     RESULT = THIS_IMAGE(DISTANCE)
     RESULT = THIS_IMAGE(COARRAY [, DIM])

Arguments:

     DISTANCE   (optional, intent(in)) Nonnegative scalar integer
     (not permitted together with COARRAY).
     COARRAY   Coarray of any type  (optional; if DIM
     present, required).
     DIM       default integer scalar (optional). If present,
     DIM shall be between one and the corank of COARRAY.

Return value:
     Default integer. If COARRAY is not present, it is scalar; if DISTANCE is not present or has value 0, its value is the image index on the invoking image for the current team, for values smaller or equal distance to the initial team, it returns the image index on the ancestor team which has a distance of DISTANCE from the invoking team. If DISTANCE is larger than the distance to the initial team, the image index of the initial team is returned. Otherwise when the COARRAY is present, if DIM is not present, a rank-1 array with corank elements is returned, containing the cosubscripts for COARRAY specifying the invoking image. If DIM is present, a scalar is returned, with the value of the DIM element of THIS_IMAGE(COARRAY).

Example:

          INTEGER :: value[*]
          INTEGER :: i
          value = THIS_IMAGE()
          SYNC ALL
          IF (THIS_IMAGE() == 1) THEN
            DO i = 1, NUM_IMAGES()
              WRITE(*,'(2(a,i0))') 'value[', i, '] is ', value[i]
            END DO
          END IF

          ! Check whether the current image is the initial image
          IF (THIS_IMAGE(HUGE(1)) /= THIS_IMAGE())
            error stop "something is rotten here"

See also:
     NUM_IMAGES, IMAGE_INDEX

TIME --- Time function
======================

Description:
     Returns the current time encoded as an integer (in the manner of the function time(3) in the C standard library). This value is suitable for passing to CTIME, GMTIME, and LTIME.

     This intrinsic is not fully portable, such as to systems with 32-bit INTEGER types but supporting times wider than 32 bits. Therefore, the values returned by this intrinsic might be, or become, negative, or numerically less than previous values, during a single run of the compiled program.

     See TIME8, for information on a similar intrinsic that might be portable to more GNU Fortran implementations, though to fewer Fortran compilers.

Standard:
     GNU extension

Class:
     Function

Syntax:
     RESULT = TIME()

Return value:
     The return value is a scalar of type INTEGER(4).

See also:
     DATE_AND_TIME, CTIME, GMTIME, LTIME, MCLOCK, TIME8

TIME8 --- Time function (64-bit)
================================

Description:
     Returns the current time encoded as an integer (in the manner of the function time(3) in the C standard library). This value is suitable for passing to CTIME, GMTIME, and LTIME.

     Warning: this intrinsic does not increase the range of the timing values over that returned by time(3). On a system with a 32-bit time(3), TIME8 will return a 32-bit value, even though it is converted to a 64-bit INTEGER(8) value. That means overflows of the 32-bit value can still occur. Therefore, the values returned by this intrinsic might be or become negative or numerically less than previous values during a single run of the compiled program.

Standard:
     GNU extension

Class:
     Function

Syntax:
     RESULT = TIME8()

Return value:
     The return value is a scalar of type INTEGER(8).

See also:
     DATE_AND_TIME, CTIME, GMTIME, LTIME, MCLOCK8, TIME

TINY --- Smallest positive number of a real kind
================================================

Description:
     TINY(X) returns the smallest positive (non zero) number in the model of the type of X.

Standard:
     Fortran 95 and later

Class:
     Inquiry function

Syntax:
     RESULT = TINY(X)

Arguments:

     X   Shall be of type REAL.

Return value:
     The return value is of the same type and kind as X

Example:
     See HUGE for an example.

TRAILZ --- Number of trailing zero bits of an integer
=====================================================

Description:
     TRAILZ returns the number of trailing zero bits of an integer.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = TRAILZ(I)

Arguments:

     I   Shall be of type INTEGER.

Return value:
     The type of the return value is the default INTEGER. If all the bits of I are zero, the result value is BIT_SIZE(I).

Example:

          PROGRAM test_trailz
            WRITE (*,*) TRAILZ(8)  ! prints 3
          END PROGRAM

See also:
     BIT_SIZE, LEADZ, POPPAR, POPCNT

TRANSFER --- Transfer bit patterns
==================================

Description:
     Interprets the bitwise representation of SOURCE in memory as if it is the representation of a variable or array of the same type and type parameters as MOLD.

     This is approximately equivalent to the C concept of casting one type to another.

Standard:
     Fortran 95 and later

Class:
     Transformational function

Syntax:
     RESULT = TRANSFER(SOURCE, MOLD[, SIZE])

Arguments:

     SOURCE   Shall be a scalar or an array of any type.
     MOLD     Shall be a scalar or an array of any type.
     SIZE     (Optional) shall be a scalar of type
     INTEGER.

Return value:
     The result has the same type as MOLD, with the bit level representation of SOURCE.  If SIZE is present, the result is a one-dimensional array of length SIZE.  If SIZE is absent but MOLD is an array (of any size or shape), the result is a one- dimensional array of the minimum length needed to contain the entirety of the bitwise representation of SOURCE.   If SIZE is absent and MOLD is a scalar, the result is a scalar.

     If the bitwise representation of the result is longer than that of SOURCE, then the leading bits of the result correspond to those of SOURCE and any trailing bits are filled arbitrarily.

     When the resulting bit representation does not correspond to a valid representation of a variable of the same type as MOLD, the results are undefined, and subsequent operations on the result cannot be guaranteed to produce sensible behavior.  For example, it is possible to create LOGICAL variables for which VAR and .NOT.VAR both appear to be true.

Example:

          PROGRAM test_transfer
            integer :: x = 2143289344
            print *, transfer(x, 1.0)    ! prints "NaN" on i686
          END PROGRAM

TRANSPOSE --- Transpose an array of rank two
============================================

Description:
     Transpose an array of rank two. Element (i, j) of the result has the value MATRIX(j, i), for all i, j.

Standard:
     Fortran 95 and later

Class:
     Transformational function

Syntax:
     RESULT = TRANSPOSE(MATRIX)

Arguments:

     MATRIX   Shall be an array of any type and have a rank of two.

Return value:
     The result has the same type as MATRIX, and has shape (/ m, n /) if MATRIX has shape (/ n, m /).

TRIM --- Remove trailing blank characters of a string
=====================================================

Description:
     Removes trailing blank characters of a string.

Standard:
     Fortran 95 and later

Class:
     Transformational function

Syntax:
     RESULT = TRIM(STRING)

Arguments:

     STRING   Shall be a scalar of type CHARACTER.

Return value:
     A scalar of type CHARACTER which length is that of STRING less the number of trailing blanks.

Example:

          PROGRAM test_trim
            CHARACTER(len=10), PARAMETER :: s = "GFORTRAN  "
            WRITE(*,*) LEN(s), LEN(TRIM(s))  ! "10 8", with/without trailing blanks
          END PROGRAM

See also:
     ADJUSTL, ADJUSTR

TTYNAM --- Get the name of a terminal device.
=============================================

Description:
     Get the name of a terminal device. For more information, see ttyname(3).

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL TTYNAM(UNIT, NAME)
     NAME = TTYNAM(UNIT)

Arguments:

     UNIT   Shall be a scalar INTEGER.
     NAME   Shall be of type CHARACTER.

Example:

          PROGRAM test_ttynam
            INTEGER :: unit
            DO unit = 1, 10
              IF (isatty(unit=unit)) write(*,*) ttynam(unit)
            END DO
          END PROGRAM

See also:
     ISATTY

UBOUND --- Upper dimension bounds of an array
=============================================

Description:
     Returns the upper bounds of an array, or a single upper bound along the DIM dimension.

Standard:
     Fortran 95 and later, with KIND argument Fortran 2003 and later

Class:
     Inquiry function

Syntax:
     RESULT = UBOUND(ARRAY [, DIM [, KIND]])

Arguments:

     ARRAY   Shall be an array, of any type.
     DIM   (Optional) Shall be a scalar INTEGER.
     KIND  (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     The return value is of type INTEGER and of kind KIND. If KIND is absent, the return value is of default integer kind. If DIM is absent, the result is an array of the upper bounds of ARRAY.  If DIM is present, the result is a scalar corresponding to the upper bound of the array along that dimension.  If ARRAY is an expression rather than a whole array or array structure component, or if it has a zero extent along the relevant dimension, the upper bound is taken to be the number of elements along the relevant dimension.

See also:
     LBOUND, LCOBOUND

UCOBOUND --- Upper codimension bounds of an array
=================================================

Description:
     Returns the upper cobounds of a coarray, or a single upper cobound along the DIM codimension.

Standard:
     Fortran 2008 and later

Class:
     Inquiry function

Syntax:
     RESULT = UCOBOUND(COARRAY [, DIM [, KIND]])

Arguments:

     ARRAY   Shall be an coarray, of any type.
     DIM   (Optional) Shall be a scalar INTEGER.
     KIND   (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     The return value is of type INTEGER and of kind KIND. If KIND is absent, the return value is of default integer kind. If DIM is absent, the result is an array of the lower cobounds of COARRAY.  If DIM is present, the result is a scalar corresponding to the lower cobound of the array along that codimension.

See also:
     LCOBOUND, LBOUND

UMASK --- Set the file creation mask
====================================

Description:
     Sets the file creation mask to MASK. If called as a function, it returns the old value. If called as a subroutine and argument OLD if it is supplied, it is set to the old value. See umask(2).

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL UMASK(MASK [, OLD])
     OLD = UMASK(MASK)

Arguments:

     MASK   Shall be a scalar of type INTEGER.
     OLD   (Optional) Shall be a scalar of type
     INTEGER.

UNLINK --- Remove a file from the file system
=============================================

Description:
     Unlinks the file PATH. A null character (CHAR(0)) can be used to mark the end of the name in PATH; otherwise, trailing blanks in the file name are ignored.  If the STATUS argument is supplied, it contains 0 on success or a nonzero error code upon return; see unlink(2).

     This intrinsic is provided in both subroutine and function forms; however, only one form can be used in any given program unit.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL UNLINK(PATH [, STATUS])
     STATUS = UNLINK(PATH)

Arguments:

     PATH   Shall be of default CHARACTER type.
     STATUS   (Optional) Shall be of default INTEGER type.

See also:
     LINK, SYMLNK

UNPACK --- Unpack an array of rank one into an array
====================================================

Description:
     Store the elements of VECTOR in an array of higher rank.

Standard:
     Fortran 95 and later

Class:
     Transformational function

Syntax:
     RESULT = UNPACK(VECTOR, MASK, FIELD)

Arguments:

     VECTOR   Shall be an array of any type and rank one. It
     shall have at least as many elements as MASK has TRUE values.
     MASK     Shall be an array of type LOGICAL.
     FIELD    Shall be of the same type as VECTOR and have
     the same shape as MASK.

Return value:
     The resulting array corresponds to FIELD with TRUE elements of MASK replaced by values from VECTOR in array element order.

Example:

          PROGRAM test_unpack
            integer :: vector(2)  = (/1,1/)
            logical :: mask(4)  = (/ .TRUE., .FALSE., .FALSE., .TRUE. /)
            integer :: field(2,2) = 0, unity(2,2)

            ! result: unity matrix
            unity = unpack(vector, reshape(mask, (/2,2/)), field)
          END PROGRAM

See also:
     PACK, SPREAD

VERIFY --- Scan a string for characters not a given set
=======================================================

Description:
     Verifies that all the characters in STRING belong to the set of characters in SET.

     If BACK is either absent or equals FALSE, this function returns the position of the leftmost character of STRING that is not in SET. If BACK equals TRUE, the rightmost position is returned. If all characters of STRING are found in SET, the result is zero.

Standard:
     Fortran 95 and later, with KIND argument Fortran 2003 and later

Class:
     Elemental function

Syntax:
     RESULT = VERIFY(STRING, SET[, BACK [, KIND]])

Arguments:

     STRING   Shall be of type CHARACTER.
     SET      Shall be of type CHARACTER.
     BACK     (Optional) shall be of type LOGICAL.
     KIND     (Optional) An INTEGER initialization
     expression indicating the kind parameter of the result.

Return value:
     The return value is of type INTEGER and of kind KIND. If KIND is absent, the return value is of default integer kind.

Example:

          PROGRAM test_verify
            WRITE(*,*) VERIFY("FORTRAN", "AO")           ! 1, found 'F'
            WRITE(*,*) VERIFY("FORTRAN", "FOO")          ! 3, found 'R'
            WRITE(*,*) VERIFY("FORTRAN", "C++")          ! 1, found 'F'
            WRITE(*,*) VERIFY("FORTRAN", "C++", .TRUE.)  ! 7, found 'N'
            WRITE(*,*) VERIFY("FORTRAN", "FORTRAN")      ! 0' found none
          END PROGRAM

See also:
     SCAN, INDEX intrinsic

XOR --- Bitwise logical exclusive OR
====================================

Description:
     Bitwise logical exclusive or.

     This intrinsic routine is provided for backwards compatibility with GNU Fortran 77.  For integer arguments, programmers should consider the use of the IEOR intrinsic and for logical arguments the .NEQV. operator, which are both defined by the Fortran standard.

Standard:
     GNU extension

Class:
     Function

Syntax:
     RESULT = XOR(I, J)

Arguments:

     I   The type shall be either a scalar INTEGER
     type or a scalar LOGICAL type or a boz-literal-constant.
     J   The type shall be the same as the type of I or
     a boz-literal-constant. I and J shall not both be
     boz-literal-constants.  If either I and J is a
     boz-literal-constant, then the other argument must be a scalar INTEGER.

Return value:
     The return type is either a scalar INTEGER or a scalar LOGICAL.  If the kind type parameters differ, then the smaller kind type is implicitly converted to larger kind, and the return has the larger kind.  A boz-literal-constant is converted to an INTEGER with the kind type parameter of the other argument as-if a call to INT occurred.

Example:

          PROGRAM test_xor
            LOGICAL :: T = .TRUE., F = .FALSE.
            INTEGER :: a, b
            DATA a / Z'F' /, b / Z'3' /

            WRITE (*,*) XOR(T, T), XOR(T, F), XOR(F, T), XOR(F, F)
            WRITE (*,*) XOR(a, b)
          END PROGRAM

See also:
     Fortran 95 elemental function: IEOR

Intrinsic Modules
*****************

ISO_FORTRAN_ENV
===============

Standard:
     Fortran 2003 and later, except when otherwise noted

The ISO_FORTRAN_ENV module provides the following scalar default-integer named constants:

ATOMIC_INT_KIND:
     Default-kind integer constant to be used as kind parameter when defining integer variables used in atomic operations. (Fortran 2008 or later.)

ATOMIC_LOGICAL_KIND:
     Default-kind integer constant to be used as kind parameter when defining logical variables used in atomic operations. (Fortran 2008 or later.)

CHARACTER_KINDS:
     Default-kind integer constant array of rank one containing the supported kind parameters of the CHARACTER type. (Fortran 2008 or later.)

CHARACTER_STORAGE_SIZE:
     Size in bits of the character storage unit.

ERROR_UNIT:
     Identifies the preconnected unit used for error reporting.

FILE_STORAGE_SIZE:
     Size in bits of the file-storage unit.

INPUT_UNIT:
     Identifies the preconnected unit identified by the asterisk (*) in READ statement.

INT8, INT16, INT32, INT64:
     Kind type parameters to specify an INTEGER type with a storage size of 16, 32, and 64 bits. It is negative if a target platform does not support the particular kind. (Fortran 2008 or later.)

INTEGER_KINDS:
     Default-kind integer constant array of rank one containing the supported kind parameters of the INTEGER type. (Fortran 2008 or later.)

IOSTAT_END:
     The value assigned to the variable passed to the IOSTAT= specifier of an input/output statement if an end-of-file condition occurred.

IOSTAT_EOR:
     The value assigned to the variable passed to the IOSTAT= specifier of an input/output statement if an end-of-record condition occurred.

IOSTAT_INQUIRE_INTERNAL_UNIT:
     Scalar default-integer constant, used by INQUIRE for the IOSTAT= specifier to denote an that a unit number identifies an internal unit. (Fortran 2008 or later.)

NUMERIC_STORAGE_SIZE:
     The size in bits of the numeric storage unit.

LOGICAL_KINDS:
     Default-kind integer constant array of rank one containing the supported kind parameters of the LOGICAL type. (Fortran 2008 or later.)

OUTPUT_UNIT:
     Identifies the preconnected unit identified by the asterisk (*) in WRITE statement.

REAL32, REAL64, REAL128:
     Kind type parameters to specify a REAL type with a storage size of 32, 64, and 128 bits. It is negative if a target platform does not support the particular kind. (Fortran 2008 or later.)

REAL_KINDS:
     Default-kind integer constant array of rank one containing the supported kind parameters of the REAL type. (Fortran 2008 or later.)

STAT_LOCKED:
     Scalar default-integer constant used as STAT= return value by LOCK to denote that the lock variable is locked by the executing image. (Fortran 2008 or later.)

STAT_LOCKED_OTHER_IMAGE:
     Scalar default-integer constant used as STAT= return value by UNLOCK to denote that the lock variable is locked by another image. (Fortran 2008 or later.)

STAT_STOPPED_IMAGE:
     Positive, scalar default-integer constant used as STAT= return value if the argument in the statement requires synchronisation with an image, which has initiated the termination of the execution. (Fortran 2008 or later.)

STAT_FAILED_IMAGE:
     Positive, scalar default-integer constant used as STAT= return value if the argument in the statement requires communication with an image, which has is in the failed state. (TS 18508 or later.)

STAT_UNLOCKED:
     Scalar default-integer constant used as STAT= return value by UNLOCK to denote that the lock variable is unlocked. (Fortran 2008 or later.)

The module provides the following derived type:

LOCK_TYPE:
     Derived type with private components to be use with the LOCK and UNLOCK statement. A variable of its type has to be always declared as coarray and may not appear in a variable-definition context. (Fortran 2008 or later.)

The module also provides the following intrinsic procedures: COMPILER_OPTIONS and COMPILER_VERSION.

ISO_C_BINDING
=============

Standard:
     Fortran 2003 and later, GNU extensions

The following intrinsic procedures are provided by the module; their definition can be found in the section Intrinsic Procedures of this manual.

C_ASSOCIATED

C_F_POINTER

C_F_PROCPOINTER

C_FUNLOC

C_LOC

C_SIZEOF

The ISO_C_BINDING module provides the following named constants of type default integer, which can be used as KIND type parameters.

In addition to the integer named constants required by the Fortran 2003 standard and C_PTRDIFF_T of TS 29113, GNU Fortran provides as an extension named constants for the 128-bit integer types supported by the C compiler: C_INT128_T, C_INT_LEAST128_T, C_INT_FAST128_T. Furthermore, if __float128 is supported in C, the named constants C_FLOAT128, C_FLOAT128_COMPLEX are defined.

Fortran Type    Named constant           C type                                  Extension
INTEGER  C_INT             int
INTEGER  C_SHORT           short int
INTEGER  C_LONG            long int
INTEGER  C_LONG_LONG       long long int
INTEGER  C_SIGNED_CHAR     signed char/unsigned char
INTEGER  C_SIZE_T          size_t
INTEGER  C_INT8_T          int8_t
INTEGER  C_INT16_T         int16_t
INTEGER  C_INT32_T         int32_t
INTEGER  C_INT64_T         int64_t
INTEGER  C_INT128_T        int128_t                        Ext.
INTEGER  C_INT_LEAST8_T    int_least8_t
INTEGER  C_INT_LEAST16_T   int_least16_t
INTEGER  C_INT_LEAST32_T   int_least32_t
INTEGER  C_INT_LEAST64_T   int_least64_t
INTEGER  C_INT_LEAST128_T  int_least128_t                  Ext.
INTEGER  C_INT_FAST8_T     int_fast8_t
INTEGER  C_INT_FAST16_T    int_fast16_t
INTEGER  C_INT_FAST32_T    int_fast32_t
INTEGER  C_INT_FAST64_T    int_fast64_t
INTEGER  C_INT_FAST128_T   int_fast128_t                   Ext.
INTEGER  C_INTMAX_T        intmax_t
INTEGER  C_INTPTR_T        intptr_t
INTEGER  C_PTRDIFF_T       ptrdiff_t                       TS 29113
REAL     C_FLOAT           float
REAL     C_DOUBLE          double
REAL     C_LONG_DOUBLE     long double
REAL     C_FLOAT128        __float128                      Ext.
COMPLEX  C_FLOAT_COMPLEX   float _Complex
COMPLEX  C_DOUBLE_COMPLEX  double _Complex
COMPLEX  C_LONG_DOUBLE_COMPLEX  long double _Complex
REAL     C_FLOAT128_COMPLEX     __float128 _Complex        Ext.
LOGICAL  C_BOOL            _Bool
CHARACTER  C_CHAR          char

Additionally, the following parameters of type CHARACTER(KIND=C_CHAR) are defined.

Name                       C definition      Value
C_NULL_CHAR         null character    '\0'
C_ALERT             alert             '\a'
C_BACKSPACE         backspace         '\b'
C_FORM_FEED         form feed         '\f'
C_NEW_LINE          new line          '\n'
C_CARRIAGE_RETURN   carriage return   '\r'
C_HORIZONTAL_TAB    horizontal tab    '\t'
C_VERTICAL_TAB      vertical tab      '\v'

Moreover, the following two named constants are defined:

Name                   Type
C_NULL_PTR      C_PTR
C_NULL_FUNPTR   C_FUNPTR

Both are equivalent to the value NULL in C.

IEEE modules: IEEE_EXCEPTIONS, IEEE_ARITHMETIC, and IEEE_FEATURES
=================================================================

Standard:
     Fortran 2003 and later

The IEEE_EXCEPTIONS, IEEE_ARITHMETIC, and IEEE_FEATURES intrinsic modules provide support for exceptions and IEEE arithmetic, as defined in Fortran 2003 and later standards, and the IEC 60559:1989 standard (Binary floating-point arithmetic for microprocessor systems). These modules are only provided on the following supported platforms:

  * i386 and x86_64 processors

  * platforms which use the GNU C Library (glibc)

  * platforms with support for SysV/386 routines for floating point interface (including Solaris and BSDs)

  * platforms with the AIX OS

For full compliance with the Fortran standards, code using the IEEE_EXCEPTIONS or IEEE_ARITHMETIC modules should be compiled with the following options: -fno-unsafe-math-optimizations -frounding-math -fsignaling-nans.

OpenMP Modules OMP_LIB and OMP_LIB_KINDS
========================================

Standard:
     OpenMP Application Program Interface v4.5

The OpenMP Fortran runtime library routines are provided both in a form of two Fortran 90 modules, named OMP_LIB and OMP_LIB_KINDS, and in a form of a Fortran include file named omp_lib.h. The procedures provided by OMP_LIB can be found in the Introduction (GNU Offloading and Multi Processing Runtime Library) manual, the named constants defined in the modules are listed below.

For details refer to the actual OpenMP Application Program Interface v4.5 (http://www.openmp.org/wp-content/uploads/openmp-4.5.pdf). And for the pause-related constants to the OpenMP 5.0 specification.

OMP_LIB_KINDS provides the following scalar default-integer named constants:

omp_lock_kind

omp_lock_hint_kind

omp_nest_lock_kind

omp_pause_resource_kind

omp_proc_bind_kind

omp_sched_kind

OMP_LIB provides the scalar default-integer named constant openmp_version with a value of the form YYYYMM, where yyyy is the year and MM the month of the OpenMP version; for OpenMP v4.5 the value is 201511.

The following scalar integer named constants of the kind omp_sched_kind:

omp_sched_static

omp_sched_dynamic

omp_sched_guided

omp_sched_auto

And the following scalar integer named constants of the kind omp_proc_bind_kind:

omp_proc_bind_false

omp_proc_bind_true

omp_proc_bind_master

omp_proc_bind_close

omp_proc_bind_spread

The following scalar integer named constants are of the kind omp_lock_hint_kind:

omp_lock_hint_none

omp_lock_hint_uncontended

omp_lock_hint_contended

omp_lock_hint_nonspeculative

omp_lock_hint_speculative

And the following two scalar integer named constants are of the kind omp_pause_resource_kind:

omp_pause_soft

omp_pause_hard

OpenACC Module OPENACC
======================

Standard:
     OpenACC Application Programming Interface v2.0

The OpenACC Fortran runtime library routines are provided both in a form of a Fortran 90 module, named OPENACC, and in form of a Fortran include file named openacc_lib.h.  The procedures provided by OPENACC can be found in the Introduction (GNU Offloading and Multi Processing Runtime Library) manual, the named constants defined in the modules are listed below.

For details refer to the actual OpenACC Application Programming Interface v2.0 (http://www.openacc.org/).

OPENACC provides the scalar default-integer named constant openacc_version with a value of the form YYYYMM, where yyyy is the year and MM the month of the OpenACC version; for OpenACC v2.0 the value is 201306.