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 even if the option -fno-dump-core is in effect, which is suitable for debugging purposes.

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

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
     CABS(A)    COMPLEX(4) Z   REAL(4)      Fortran 77 and later
     DABS(A)    REAL(8)    X   REAL(8)      Fortran 77 and later
     IABS(A)    INTEGER(4) I   INTEGER(4)   Fortran 77 and later
     ZABS(A)    COMPLEX(8) Z   COMPLEX(8)   GNU extension
     CDABS(A)   COMPLEX(8) Z   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

Class:
     Elemental function

Syntax:
     RESULT = ACOS(X)

Arguments:

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

Return value:
     The return value is of type REAL and it lies in the range  0 \leq \acos(x) \leq \pi. The return value if of the same kind as X.

Example:

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

Specific names:

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

See also:
     Inverse function: COS

ACOSH --- Hyperbolic arccosine function
=======================================

Description:
     ACOSH(X) computes the hyperbolic arccosine of X (inverse of COSH(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

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
     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
     DINT(X)   REAL(8) X   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) checks the status of whether X is allocated.

Standard:
     Fortran 95 and later

Class:
     Inquiry function

Syntax:
     RESULT = ALLOCATED(ARRAY)

Arguments:

     ARRAY      The argument shall be an ALLOCATABLE array.

Return value:
     The return value is a scalar LOGICAL with the default logical kind type parameter.  If ARRAY is allocated, ALLOCATED(ARRAY) 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.
     J   The type shall be the same as the type of I.

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.

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

Class:
     Elemental function

Syntax:
     RESULT = ASIN(X)

Arguments:

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

Return value:
     The return value is of type REAL and it lies in the range -\pi / 2 \leq \asin (x) \leq \pi / 2.  The kind type parameter is the same as X.

Example:

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

Specific names:

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

See also:
     Inverse function: SIN

ASINH --- Hyperbolic arcsine function
=====================================

Description:
     ASINH(X) computes the hyperbolic arcsine of X (inverse of SINH(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.

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

Class:
     Elemental function

Syntax:
     RESULT = ATAN(X)

Arguments:

     X   The type shall be REAL.

Return value:
     The return value is of type REAL and it lies in the range  - \pi / 2 \leq \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
     DATAN(X)   REAL(8) X    REAL(8)      Fortran 77 and later

See also:
     Inverse function: TAN

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

Description:
     ATAN2(Y, X) computes the arctangent of the complex number X + i Y.

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 positive and \pi if X is negative.  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
     DATAN2(X)   REAL(8) X   REAL(8)   Fortran 77 and later

ATANH --- Hyperbolic arctangent function
========================================

Description:
     ATANH(X) computes the hyperbolic arctangent of X (inverse of TANH(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.

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

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, and it shall be scalar.

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, and it shall be scalar.

Return value:
     The return value is of type REAL and it 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 both arguments are arrays, their ranks and shapes shall conform.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = BESSEL_JN(N, X)

Arguments:

     N   Shall be a scalar or an array of type  INTEGER.
     X   Shall be a scalar or an array of type  REAL.

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

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(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, and it shall be scalar.

Return value:
     The return value is a scalar 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, and it shall be scalar.

Return value:
     The return value is a scalar 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 both arguments are arrays, their ranks and shapes shall conform.

Standard:
     Fortran 2008 and later

Class:
     Elemental function

Syntax:
     RESULT = BESSEL_YN(N, X)

Arguments:

     N   Shall be a scalar or an array of type  INTEGER.
     X   Shall be a scalar or an array of type  REAL.

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

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

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

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

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

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

Description:
     C_ASSOCIATED(c_prt_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_prt_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_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_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.

     Note: Due to the currently lacking support of procedure pointers in GNU Fortran this function is not fully operable.

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_F_POINTER --- Convert C into Fortran pointer
==============================================

Description:
     C_F_POINTER(CPTR, FPTR[, SHAPE]) Assign the target the C pointer CPTR to the Fortran pointer FPTR and specify 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_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   Associated scalar pointer or interoperable scalar
     or allocated allocatable variable with TARGET attribute.

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:
     Intrinsic function

Syntax:
     N = C_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 doesn't 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

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

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 function invokes /bin/chmod and might therefore not work on all platforms.

     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 MODE
     argument of /bin/chmod.

     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

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 of type INTEGER(4)

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

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
     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 type REAL and it lies in the range  -1 \leq \cos (x) \leq 1.  The kind type parameter is the same as X.

Example:

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

Specific names:

     Name              Argument              Return type         Standard
     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

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

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

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     X = COSH(X)

Arguments:

     X   The type shall be REAL.

Return value:
     The return value is of type REAL and it is positive ( \cosh (x) \geq 0 ).  For a REAL argument X, \cosh (x) \geq 1 . The return value is of the same kind as X.

Example:

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

Specific names:

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

See also:
     Inverse function: ACOSH

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

Description:

     COUNT(MASK [, DIM [, KIND]]) counts the number of .TRUE. elements of MASK 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 MASK.

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. The result has a rank equal to that of MASK.

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 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), (not recommended).

Arguments:

     TIME      The type shall be of type INTEGER(KIND=8).
     RESULT    The type shall be of type CHARACTER and
     of default kind.

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:
     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:
     DFLOAT, FLOAT, 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

DFLOAT --- Double conversion function
=====================================

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

Standard:
     GNU extension

Class:
     Elemental function

Syntax:
     RESULT = DFLOAT(A)

Arguments:

     A   The type shall be INTEGER.

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

Example:

          program test_dfloat
              integer :: i = 5
              print *, dfloat(i)
          end program test_dfloat

See also:
     DBLE, FLOAT, REAL

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

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

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

Description:
     DTIME(TARRAY, RESULT) initially returns the number of seconds of runtime since the start of the process's execution in RESULT.  TARRAY returns the user and system components of this time in TARRAY(1) and TARRAY(2) respectively. RESULT is equal to TARRAY(1) + TARRAY(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.

     TARRAY and RESULT are INTENT(OUT) and provide the following:

       TARRAY(1):   User time in seconds.
       TARRAY(2):   System time in seconds.
       RESULT:   Run time since start in seconds.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL DTIME(TARRAY, RESULT).
     RESULT = DTIME(TARRAY), (not recommended).

Arguments:

     TARRAY  The type shall be REAL, DIMENSION(2).
     RESULT  The type shall be REAL.

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(TARRAY, RESULT) returns the number of seconds of runtime since the start of the process's execution in RESULT.  TARRAY returns the user and system components of this time in TARRAY(1) and TARRAY(2) respectively. RESULT is equal to TARRAY(1) + TARRAY(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.

     TARRAY and RESULT are INTENT(OUT) and provide the following:

       TARRAY(1):   User time in seconds.
       TARRAY(2):   System time in seconds.
       RESULT:   Run time since start in seconds.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL ETIME(TARRAY, RESULT).
     RESULT = ETIME(TARRAY), (not recommended).

Arguments:

     TARRAY  The type shall be REAL, DIMENSION(2).
     RESULT  The type shall be REAL.

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

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

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.

     DATE is an INTENT(OUT) CHARACTER variable of the default kind.

Standard:
     GNU extension

Class:
     Subroutine, function

Syntax:

     CALL FDATE(DATE).
     DATE = FDATE(), (not recommended).

Arguments:

     DATE  The type shall be of type CHARACTER of the
     default kind

Return value:
     The current date 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

FLOAT --- Convert integer to default real
=========================================

Description:
     FLOAT(A) converts the integer A to a default real value.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = FLOAT(A)

Arguments:

     A   The type shall be INTEGER.

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

Example:

          program test_float
              integer :: i = 1
              if (float(i) /= 1.) call abort
          end program test_float

See also:
     DBLE, DFLOAT, REAL

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

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

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

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.

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

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

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 BUFF 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, BUFF [, STATUS])

Arguments:

     UNIT     An open I/O unit number of type INTEGER.
     BUFF     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 can not 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)

Arguments:

     COMMAND   Shall be of type CHARACTER and of default
     kind.

Return value:
     Stores the entire command line that was used to invoke the program in COMMAND. If COMMAND is not large enough, the command will be truncated.

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(4),
     NUMBER \geq 0
     VALUE    Shall be a scalar of type CHARACTER
     and of default kind.
     LENGTH   (Option) Shall be a scalar of type INTEGER(4).
     STATUS   (Option) Shall be a scalar of type INTEGER(4).

Return value:
     After GET_COMMAND_ARGUMENT returns, the VALUE argument holds the NUMBER-th command line argument. If VALUE can not 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])

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.

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.

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(1).
     VALUE       Shall be a scalar of type CHARACTER(1).
     LENGTH      Shall be a scalar of type INTEGER(4).
     STATUS      Shall be a scalar of type INTEGER(4).
     TRIM_NAME   Shall be a scalar of type LOGICAL(4).

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 TIME8() 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).

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 0--31

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

      6. Years since 1900

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

      8. Days since January 1

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

See also:
     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

IAND --- Bitwise logical and
============================

Description:
     Bitwise logical AND.

Standard:
     Fortran 95 and later

Class:
     Elemental function

Syntax:
     RESULT = IAND(I, J)

Arguments:

     I   The type shall be INTEGER.
     J   The type shall be INTEGER, of the same
     kind as I.  (As a GNU extension, different kinds are also
     permitted.)

Return value:
     The return type is INTEGER, of the same kind as the arguments.  (If the argument kinds differ, it is of the same kind as the larger argument.)

Example:

          PROGRAM test_iand
            INTEGER :: a, b
            DATA a / Z'F' /, b / Z'3' /
            WRITE (*,*) IAND(a, b)
          END PROGRAM

See also:
     IOR, IEOR, IBITS, IBSET, IBCLR, NOT

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

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.

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

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.

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

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.

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:
     Fortan 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

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(TARRAY) Fills TARRAY 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 TARRAY, respectively. The year has four significant digits.

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

IEOR --- Bitwise logical exclusive or
=====================================

Description:
     IEOR returns the bitwise boolean exclusive-OR of I and J.

Standard:
     Fortran 95 and later

Class:
     Elemental function

Syntax:
     RESULT = IEOR(I, J)

Arguments:

     I   The type shall be INTEGER.
     J   The type shall be INTEGER, of the same
     kind as I.  (As a GNU extension, different kinds are also
     permitted.)

Return value:
     The return type is INTEGER, of the same kind as the arguments.  (If the argument kinds differ, it is of the same kind as the larger argument.)

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() function.

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

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.

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) equals the largest integer that does not exceed
          the range 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
     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

Class:
     Elemental function

Syntax:
     RESULT = IOR(I, J)

Arguments:

     I   The type shall be INTEGER.
     J   The type shall be INTEGER, of the same
     kind as I.  (As a GNU extension, different kinds are also
     permitted.)

Return value:
     The return type is INTEGER, of the same kind as the arguments.  (If the argument kinds differ, it is of the same kind as the larger argument.)

See also:
     IEOR, IAND, IBITS, IBSET, IBCLR, NOT

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_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

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.

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

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.

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:
     IDATE(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.

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

KILL --- Send a signal to a process
===================================

Description:

Standard:
     Sends the signal specified by SIGNAL 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(C, VALUE [, STATUS])

Arguments:

     C   Shall be a scalar INTEGER, with
     INTENT(IN)
     VALUE   Shall be a scalar INTEGER, with
     INTENT(IN)
     STATUS   (Optional) status flag of type INTEGER(4) or
     INTEGER(8). Returns 0 on success, or a system-specific error code
     otherwise.

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

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 (*,*) LEADZ(1)  ! prints 8 if BITSIZE(I) has the value 32
          END PROGRAM

See also:
     BIT_SIZE, TRAILZ

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.

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.

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.

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.

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.

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 --- Logarithm function
==========================

Description:
     LOG(X) computes the logarithm of X.

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 \leq \omega \leq \pi.

Example:

          program test_log
            real(8) :: x = 1.0_8
            complex :: z = (1.0, 2.0)
            x = log(x)
            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.  If the absolute value of SHIFT is greater than BIT_SIZE(I), the 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.

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

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 BUFF 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(FILE, BUFF [, STATUS])

Arguments:

     FILE     The type shall be CHARACTER of the default
     kind, a valid path within the file system.
     BUFF     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 STIME (as provided by the TIME8() intrinsic), fills TARRAY with values extracted from it appropriate to the local time zone using localtime(3).

Standard:
     GNU extension

Class:
     Subroutine

Syntax:
     CALL LTIME(STIME, TARRAY)

Arguments:

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

Return value:
     The elements of TARRAY 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 0--31

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

      6. Years since 1900

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

      8. Days since January 1

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

See also:
     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. This example is intended to run on 32-bit systems, where the default integer kind is suitable to store pointers; on 64-bit systems, ptr_x would need to be declared as integer(kind=8).

          program test_malloc
            integer i
            integer ptr_x
            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

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.

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(I)     INTEGER(4) I   INTEGER(4)     Fortran 77 and later
     AMAX0(I)    INTEGER(4) I   REAL(MAX(X))   Fortran 77 and later
     MAX1(X)     REAL X      INT(MAX(X))    Fortran 77 and later
     AMAX1(X)    REAL(4)    X   REAL(4)        Fortran 77 and later
     DMAX1(X)    REAL(8)    X   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 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

Class:
     Transformational function

Syntax:

     RESULT = MAXLOC(ARRAY, DIM [, MASK])
     RESULT = MAXLOC(ARRAY [, MASK])

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.

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.  In all cases, the result is of default INTEGER type.

See also:
     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,
     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.

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 UNIX function clock(3).

     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 UNIX function clock(3).

     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.

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(I)     INTEGER(4) I   INTEGER(4)     Fortran 77 and later
     AMIN0(I)    INTEGER(4) I   REAL(MIN(X))   Fortran 77 and later
     MIN1(X)     REAL X      INT(MIN(X))    Fortran 77 and later
     AMIN1(X)    REAL(4)    X   REAL(4)        Fortran 77 and later
     DMIN1(X)    REAL(8)    X   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 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

Class:
     Transformational function

Syntax:

     RESULT = MINLOC(ARRAY, DIM [, MASK])
     RESULT = MINLOC(ARRAY [, MASK])

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.

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.  In all cases, the result is of default INTEGER type.

See also:
     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,
     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.

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. It is calculated as A - (INT(A/P) * P).

Standard:
     Fortran 77 and later

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 as A and not
     equal to zero

Return value:
     The kind of the return value is the result of cross-promoting the kinds of the arguments.

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
     AMOD(A,P)   REAL(4)   REAL(4)   Fortran 95 and later
     DMOD(A,P)   REAL(8)   REAL(8)   Fortran 95 and later

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

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.

     In all cases, if P is zero the result is processor-dependent.

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

MOVE_ALLOC --- Move allocation from one object to another
=========================================================

Description:
     MOVE_ALLOC(SRC, DEST) moves the allocation from SRC to DEST.  SRC will become deallocated in the process.

Standard:
     Fortran 2003 and later

Class:
     Subroutine

Syntax:
     CALL MOVE_ALLOC(SRC, DEST)

Arguments:

     SRC    ALLOCATABLE, INTENT(INOUT), may be
     of any type and kind.
     DEST   ALLOCATABLE, INTENT(OUT), shall be
     of the same type, kind and rank as SRC.

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

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.

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   (Optional) 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(X) 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(X [, KIND])

Arguments:

     X      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           Standard
     IDNINT(X)   REAL(8)     Fortran 95 and later

See also:
     CEILING, FLOOR

NOT --- Logical negation
========================

Description:
     NOT returns the bitwise boolean inverse of I.

Standard:
     Fortran 95 and later

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.

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 dissassociated 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

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(X, Y)

Arguments:

     X   The type shall be either a scalar INTEGER
     type or a scalar LOGICAL type.
     Y   The type shall be the same as the type of X.

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.

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

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

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.

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.

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(FLAG)

Arguments:

     FLAG   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_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 George Marsaglia's KISS (Keep It Simple Stupid) random number generator (RNG). This RNG combines:

      1. The congruential generator x(n) = 69069 \cdot x(n-1) + 1327217885 with a period of 2^32,

      2. A 3-shift shift-register generator with a period of 2^32 - 1,

      3. Two 16-bit multiply-with-carry generators with a period of 597273182964842497 > 2^59.

     The overall period exceeds 2^123.

     Please note, this RNG is thread safe if used within OpenMP directives, i.e., its state will be consistent while called from multiple threads. However, the KISS generator does not create random numbers in parallel from multiple sources, but in sequence from a single source. If an OpenMP-enabled application heavily relies on random numbers, one should consider employing a dedicated parallel random number generator instead.

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 init_random_seed()         ! see example of RANDOM_SEED
            CALL RANDOM_NUMBER(r)
          end program

See also:
     RANDOM_SEED

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 initialized to a default state. The example below shows how to initialize the random seed based on the system's time.

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:

          SUBROUTINE init_random_seed()
            INTEGER :: i, n, clock
            INTEGER, DIMENSION(:), ALLOCATABLE :: seed

            CALL RANDOM_SEED(size = n)
            ALLOCATE(seed(n))

            CALL SYSTEM_CLOCK(COUNT=clock)

            seed = clock + 37 * (/ (i - 1, i = 1, n) /)
            CALL RANDOM_SEED(PUT = seed)

            DEALLOCATE(seed)
          END SUBROUTINE

See also:
     RANDOM_NUMBER

RANGE --- Decimal exponent range of a real kind
===============================================

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 REAL or COMPLEX.

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

Example:
     See PRECISION for an example.

REAL --- Convert to real type
=============================

Description:
     REAL(X [, KIND]) converts its argument X to a real type.  The REALPART(X) function is provided for compatibility with g77, and its use is strongly discouraged.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:

     RESULT = REAL(X [, KIND])
     RESULT = REALPART(Z)

Arguments:

     X      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(X) is converted to a default real type if X is an integer or real variable.

     (B)
          REAL(X) is converted to a real type with the kind type parameter of X if X is a complex variable.

     (C)
          REAL(X, KIND) is converted to a real type with kind type parameter KIND if X 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

See also:
     DBLE, DFLOAT, FLOAT

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.  If the absolute value of SHIFT is greater than BIT_SIZE(I), the 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.

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

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.

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 ascii_kind
            integer,parameter :: ascii = selected_char_kind("ascii")
            character(kind=ascii, len=26) :: s

            s = ascii_"abcdefghijklmnopqrstuvwxyz"
            print *, s
          end program ascii_kind

SELECTED_INT_KIND --- Choose integer kind
=========================================

Description:
     SELECTED_INT_KIND(I) return the kind value of the smallest integer type that can represent all values ranging from -10^I (exclusive) to 10^I (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(I)

Arguments:

     I   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 and exponent range greater at least R.

Standard:
     Fortran 95 and later

Class:
     Transformational function

Syntax:
     RESULT = SELECTED_REAL_KIND(P, R)

Arguments:

     P   (Optional) shall be a scalar and of type INTEGER.
     R   (Optional) shall be a scalar and of type INTEGER.

     At least one argument shall be present.

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 and a decimal exponent range of at least R. 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

     -2 if the processor does not support a real type with an exponent
          range greater than or equal to R

     -3 if neither is supported.

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

Class:
     Inquiry function

Syntax:
     RESULT = SHAPE(SOURCE)

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.

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.

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

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
     ISIGN(A,P)   INTEGER(4)   INTEGER(4)   f95, gnu
     DSIGN(A,P)   REAL(8)   REAL(8)   f95, 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
     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:
     ASIN

SINH --- Hyperbolic sine function
=================================

Description:
     SINH(X) computes the hyperbolic sine of X.

Standard:
     Fortran 95 and later

Class:
     Elemental function

Syntax:
     RESULT = SINH(X)

Arguments:

     X   The type shall be REAL.

Return value:
     The return value is of type REAL.

Example:

          program test_sinh
            real(8) :: x = - 1.0_8
            x = sinh(x)
          end program test_sinh

Specific names:

     Name              Argument            Return type         Standard
     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:
     Intrinsic 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 doesn't account for the sizes of the data pointed to by these components.

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

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

SNGL --- Convert double precision real to default real
======================================================

Description:
     SNGL(A) converts the double precision real A to a default real value. This is an archaic form of REAL that is specific to one type for A.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     RESULT = SNGL(A)

Arguments:

     A   The type shall be a double precision REAL.

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

See also:
     DBLE

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
     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 2003 standard specifies the intrinsic RANDOM_SEED to initialize the pseudo-random numbers generator and RANDOM_NUMBER to generate pseudo-random numbers. 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 BUFF:

     buff(1)      Device ID
     buff(2)      Inode number
     buff(3)      File mode
     buff(4)      Number of links
     buff(5)      Owner's uid
     buff(6)      Owner's gid
     buff(7)      ID of device containing directory entry for file (0 if not available)
     buff(8)      File size (bytes)
     buff(9)      Last access time
     buff(10)     Last modification time
     buff(11)     Last file status change time
     buff(12)     Preferred I/O block size (-1 if not available)
     buff(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(FILE,BUFF[,STATUS])

Arguments:

     FILE     The type shall be CHARACTER, of the
     default kind and a valid path within the file system.
     BUFF     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

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.

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:

SYSTEM_CLOCK --- Time function
==============================

Description:
     Determines the COUNT of milliseconds of wall clock time since the Epoch (00:00:00 UTC, January 1, 1970) modulo COUNT_MAX, COUNT_RATE determines the number of clock ticks per second. COUNT_RATE and COUNT_MAX are constant and specific to gfortran.

     If there is no clock, COUNT is set to -HUGE(COUNT), and COUNT_RATE and COUNT_MAX are set to zero

Standard:
     Fortran 95 and later

Class:
     Subroutine

Syntax:
     CALL SYSTEM_CLOCK([COUNT, COUNT_RATE, COUNT_MAX])

Arguments:

Arguments:

     COUNT        (Optional) shall be a scalar of type default
     INTEGER with INTENT(OUT).
     COUNT_RATE   (Optional) shall be a scalar of type default
     INTEGER with INTENT(OUT).
     COUNT_MAX    (Optional) shall be a scalar of type default
     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

Class:
     Elemental function

Syntax:
     RESULT = TAN(X)

Arguments:

     X   The type shall be REAL.

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

Example:

          program test_tan
            real(8) :: x = 0.165_8
            x = tan(x)
          end program test_tan

Specific names:

     Name              Argument            Return type         Standard
     DTAN(X)    REAL(8) X    REAL(8)      Fortran 95 and later

See also:
     ATAN

TANH --- Hyperbolic tangent function
====================================

Description:
     TANH(X) computes the hyperbolic tangent of X.

Standard:
     Fortran 77 and later

Class:
     Elemental function

Syntax:
     X = TANH(X)

Arguments:

     X   The type shall be REAL.

Return value:
     The return value is of type REAL and 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
     DTANH(X)   REAL(8) X    REAL(8)      Fortran 95 and later

See also:
     ATANH

TIME --- Time function
======================

Description:
     Returns the current time encoded as an integer (in the manner of the UNIX function time(3)). 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:
     CTIME, GMTIME, LTIME, MCLOCK, TIME8

TIME8 --- Time function (64-bit)
================================

Description:
     Returns the current time encoded as an integer (in the manner of the UNIX function time(3)). 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:
     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

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

UMASK --- Set the file creation mask
====================================

Description:
     Sets the file creation mask to MASK and returns the old value in argument OLD if it is supplied. See umask(2).

Standard:
     GNU extension

Class:
     Subroutine

Syntax:
     CALL UMASK(MASK [, OLD])

Arguments:

     MASK   Shall be a scalar of type INTEGER.
     MASK   (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 the absence of a set of characters
===============================================================

Description:
     Verifies that all the characters in a SET are present in a STRING.

     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 SET are found in STRING, 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 defined by the Fortran standard.

Standard:
     GNU extension

Class:
     Function

Syntax:
     RESULT = XOR(X, Y)

Arguments:

     X   The type shall be either  a scalar INTEGER
     type or a scalar LOGICAL type.
     Y   The type shall be the same as the type of I.

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.

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

The ISO_FORTRAN_ENV module provides the following scalar default-integer named constants:

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.

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.

NUMERIC_STORAGE_SIZE:
     The size in bits of the numeric storage unit.

OUTPUT_UNIT:
     Identifies the preconnected unit identified by the asterisk (*) in WRITE statement.

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

The ISO_C_BINDING module provides the following named constants of the type integer, which can be used as KIND type parameter. Note that GNU Fortran currently does not support the C_INT_FAST... KIND type parameters (marked by an asterisk (*) in the list below). The C_INT_FAST... parameters have therefore the value -2 and cannot be used as KIND type parameter of the INTEGER type.

In addition to the integer named constants required by the Fortran 2003 standard, 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.

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
REAL     C_FLOAT           float
REAL     C_DOUBLE          double
REAL     C_LONG_DOUBLE     long double
COMPLEX  C_FLOAT_COMPLEX   float _Complex
COMPLEX  C_DOUBLE_COMPLEX  double _Complex
COMPLEX  C_LONG_DOUBLE_COMPLEX  long double _Complex
LOGICAL  C_BOOL            _Bool
CHARACTER  C_CHAR          char

Additionally, the following (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'

OpenMP Modules OMP_LIB and OMP_LIB_KINDS
========================================

Standard:
     OpenMP Application Program Interface v3.0

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 OpenMP runtime library) manual, the named constants defined in the OMP_LIB_KINDS module are listed below.

For details refer to the actual OpenMP Application Program Interface v3.0 (http://www.openmp.org/mp-documents/spec30.pdf).

OMP_LIB_KINDS provides the following scalar default-integer named constants:

omp_integer_kind

omp_logical_kind

omp_lock_kind

omp_nest_lock_kind

omp_sched_kind