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

This portion of the document is incomplete and undergoing massive expansion and editing.  All contributions and corrections are strongly encouraged.

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

Gfortran provides a rich set of intrinsic procedures that includes all the intrinsic procedures required by the Fortran 95 standard, a set of intrinsic procedures for backwards compatibility with Gnu Fortran 77 (i.e., g77), and a small selection of intrinsic procedures from the Fortran 2003 standard.  Any description here, which conflicts with a description in either the Fortran 95 standard or the Fortran 2003 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.  Gfortran 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 intrinsics 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.

Gfortran 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 option(s) 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, which is suitable for debugging purposes.

Option:
     gnu

Class:
     non-elemental 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

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

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

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     X = ABS(X)

Arguments:

     X   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         Option
     CABS(Z)    COMPLEX(4) Z   REAL(4)      f95, gnu
     DABS(X)    REAL(8)    X   REAL(8)      f95, gnu
     IABS(I)    INTEGER(4) I   INTEGER(4)   f95, gnu
     ZABS(Z)    COMPLEX(8) Z   COMPLEX(8)   gnu
     CDABS(Z)   COMPLEX(8) Z   COMPLEX(8)   gnu

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

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

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     C = ACHAR(I)

Arguments:

     I   The type shall be INTEGER(*).

Return value:
     The return value is of type CHARACTER with a length of one.  The kind type parameter is the same as  KIND('A').

Example:

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

ACOS --- Arc cosine function
============================

Description:
     ACOS(X) computes the arc cosine of X.

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     X = ACOS(X)

Arguments:

     X   The type shall be REAL(*) with a magnitude that is
     less than one.

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

Example:

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

Specific names:

     Name              Argument            Return type         Option
     DACOS(X)   REAL(8) X    REAL(8)      f95, gnu

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

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

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     STR = ADJUSTL(STR)

Arguments:

     STR   The type shall be CHARACTER.

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

Example:

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

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

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

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     STR = ADJUSTR(STR)

Arguments:

     STR   The type shall be CHARACTER.

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

Example:

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

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

Description:
     AIMAG(Z) yields the imaginary part of complex argument Z.

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     X = 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         Option
     DIMAG(Z)   COMPLEX(8) Z   REAL(8)      f95, gnu

AINT --- Imaginary part of complex number
=========================================

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

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     X = AINT(X) X = AINT(X, KIND)

Arguments:

     X      The type of the argument shall be REAL(*).
     KIND   (Optional) KIND shall be a scalar integer
     initialization expression.

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, then 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        Option
     DINT(X)   REAL(8) X   REAL(8)     f95, gnu

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.

Option:
     f95, gnu

Class:
     transformational function

Syntax:
     L = ALL(MASK) L = 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(X) checks the status of whether X is allocated.

Option:
     f95, gnu

Class:
     inquiry function

Syntax:
     L = ALLOCATED(X)

Arguments:

     X      The argument shall be an ALLOCATABLE array.

Return value:
     The return value is a scalar LOGICAL with the default logical kind type parameter.  If X is allocated, ALLOCATED(X) is .TRUE.; otherwise, it returns the .TRUE.

Example:

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

ANINT --- Imaginary part of complex number
==========================================

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

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     X = ANINT(X) X = ANINT(X, KIND)

Arguments:

     X      The type of the argument shall be REAL(*).
     KIND   (Optional) KIND shall be a scalar integer
     initialization expression.

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 X is greater than zero, then ANINT(X) returns AINT(X+0.5).  If X is less than or equal to zero, then return 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        Option
     DNINT(X)   REAL(8) X   REAL(8)     f95, gnu

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

Option:
     f95, gnu

Class:
     transformational function

Syntax:
     L = ANY(MASK) L = 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.

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     X = ASIN(X)

Arguments:

     X   The type shall be REAL(*), and a magnitude that is
     less than one.

Return value:
     The return value is of type REAL(*) and it lies in the range -\pi / 2 \leq \arccos (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         Option
     DASIN(X)   REAL(8) X    REAL(8)      f95, gnu

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

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

Option:
     f95, gnu

Class:
     inquiry function

Syntax:
     L = ASSOCIATED(PTR) L = ASSOCIATED(PTR [, TGT])

Arguments:

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

     The status of neither PTR nor TGT can be undefined.

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

     (A) If the optional TGT is not present, then ASSOCIATED(PTR)
          is true if PTR is associated with a target; otherwise, it returns false.

     (B) If TGT is present and a scalar target, the result is true if
          TGT is not a 0 sized storage sequence and the target associated with PTR occupies the same storage units.  If PTR is disassociated, then the result is false.

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

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

     (E) If TGT is present and an array pointer, the result is true if
          target associated with PTR and the target associated with TGT have the same shape, are not 0 sized arrays, are arrays whose elements are not 0 sized storage sequences, and TGT and PTR occupy the same storage units in array element order. The result is false, if either TGT or PTR 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

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

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

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     X = 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 \arcsin (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         Option
     DATAN(X)   REAL(8) X    REAL(8)      f95, gnu

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

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

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     X = 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 principle value of the complex number X + i Y.  If X is nonzero, then it lies in the range -\pi \le \arccos (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      Option
     DATAN2(X)   REAL(8) X   REAL(8)   f95, gnu

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

Description:
     BESJ0(X) computes the Bessel function of the first kind of order 0 of X.

Option:
     gnu

Class:
     elemental function

Syntax:
     X = BESJ0(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.4027... \leq Bessel (0,x) \leq 1.

Example:

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

Specific names:

     Name              Argument            Return type         Option
     DBESJ0(X)   REAL(8) X    REAL(8)      gnu

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

Description:
     BESJ1(X) computes the Bessel function of the first kind of order 1 of X.

Option:
     gnu

Class:
     elemental function

Syntax:
     X = BESJ1(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 .

Example:

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

Specific names:

     Name              Argument            Return type         Option
     DBESJ1(X)  REAL(8) X    REAL(8)      gnu

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

Description:
     BESJN(N, X) computes the Bessel function of the first kind of order N of X.

Option:
     gnu

Class:
     elemental function

Syntax:
     Y = BESJN(N, X)

Arguments:

     N   The type shall be INTEGER(*), and it shall be scalar.
     X   The type shall be REAL(*), and it shall be scalar.

Return value:
     The return value is a scalar of type REAL(*).

Example:

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

Specific names:

     Name               Argument              Return type         Option
     DBESJN(X)   INTEGER(*) N   REAL(8)      gnu
       REAL(8) X

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

Description:
     BESY0(X) computes the Bessel function of the second kind of order 0 of X.

Option:
     gnu

Class:
     elemental function

Syntax:
     X = BESY0(X)

Arguments:

     X   The type shall be REAL(*), and it shall be scalar.

Return value:
     The return value is a scalar of type REAL(*).

Example:

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

Specific names:

     Name              Argument            Return type         Option
     DBESY0(X)  REAL(8) X    REAL(8)      gnu

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

Description:
     BESY1(X) computes the Bessel function of the second kind of order 1 of X.

Option:
     gnu

Class:
     elemental function

Syntax:
     X = BESY1(X)

Arguments:

     X   The type shall be REAL(*), and it shall be scalar.

Return value:
     The return value is a scalar of type REAL(*).

Example:

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

Specific names:

     Name              Argument            Return type         Option
     DBESY1(X)  REAL(8) X    REAL(8)      gnu

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

Description:
     BESYN(N, X) computes the Bessel function of the second kind of order N of X.

Option:
     gnu

Class:
     elemental function

Syntax:
     Y = BESYN(N, X)

Arguments:

     N   The type shall be INTEGER(*), and it shall be scalar.
     X   The type shall be REAL(*), and it shall be scalar.

Return value:
     The return value is a scalar of type REAL(*).

Example:

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

Specific names:

     Name                 Argument              Return type       Option
     DBESYN(N,X)   INTEGER(*) N   REAL(8)    gnu
       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.

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     I = 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.

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     I = 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

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

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

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     X = CEILING(X[,KIND])

Arguments:

     X   The type shall be REAL(*).
     KIND   Optional scaler integer initialization expression.

Return value:
     The return value is of type INTEGER(KIND)

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

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

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

Option:
     f95, gnu

Class:
     elemental function

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

Arguments:

     I   The type shall be INTEGER(*).
     KIND   Optional scaler integer initialization expression.

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

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.

Option:
     f95, gnu

Class:
     elemental function

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

Arguments:

     X   The type may be INTEGER(*), REAL(*), or COMPLEX(*).
     Y   Optional, allowed if X is not COMPLEX(*).  May be INTEGER(*) or REAL(*).
     KIND   Optional scaler integer initialization expression.

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

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

COMMAND_ARGUMENT_COUNT --- Argument count function
==================================================

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

Option:
     f2003, gnu

Class:
     non-elemental function

Syntax:
     I = 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

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

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

Option:
     f95, gnu

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            Option
     DCONJG(Z)   COMPLEX(8) Z    COMPLEX(8)      gnu

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

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

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     X = COS(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_cos
            real :: x = 0.0
            x = cos(x)
          end program test_cos

Specific names:

     Name              Argument            Return type       Option
     DCOS(X)    REAL(8) X    REAL(8)    f95, gnu
     CCOS(X)  COMPLEX(4) X  COMPLEX(4)  f95, gnu
     ZCOS(X)  COMPLEX(8) X  COMPLEX(8)  f95, gnu
     CDCOS(X)  COMPLEX(8) X  COMPLEX(8)  f95, gnu

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

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

Option:
     f95, gnu

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 .

Example:

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

Specific names:

     Name              Argument            Return type         Option
     DCOSH(X)   REAL(8) X    REAL(8)      f95, gnu

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

Description:
     COUNT(MASK[,DIM]) 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 scaler of type INTEGER in the range of 1 /leq DIM /leq n) where n is the rank of MASK.

Option:
     f95, gnu

Class:
     transformational function

Syntax:
     I = COUNT(MASK[,DIM])

Arguments:

     MASK   The type shall be LOGICAL.
     DIM    The type shall be INTEGER.

Return value:
     The return value is of type INTEGER with 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.

Option:
     f95, gnu

Class:
     subroutine

Syntax:
     CPU_TIME(X)

Arguments:

     X   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

CSHIFT --- Circular shift function
==================================

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

Option:
     f95, gnu

Class:
     transformational function

Syntax:
     A = CSHIFT(A, SHIFT[,DIM])

Arguments:

     ARRAY    May be any type, not scaler.
     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

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

Option:
     f95, gnu

Class:
     subroutine

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

Arguments:

     DATE    (Optional) The type shall be CHARACTER(8) or larger.
     TIME    (OPtional) The type shall be CHARACTER(10) or larger.
     ZONE    (Optional) The type shall be CHARACTER(5) or larger.
     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

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

Description:
     DBLE(X) Converts X to double precision real type. DFLOAT is an alias for DBLE

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     X = DBLE(X) X = DFLOAT(X)

Arguments:

     X   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), dfloat(z)
          end program test_dble

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.

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     C = DCMPLX(X) C = 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(X) Converts X to double precision real type. DFLOAT is an alias for DBLE.  See DBLE.

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

Description:
     DIGITS(X) returns the number of significant 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.

Option:
     f95, gnu

Class:
     inquiry function

Syntax:
     C = 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
              complex :: z = (23.0,45.6)
              print *, digits(i)
              print *, digits(x)
              print *, digits(y)
          end program test_digits

DIM --- Dim function
====================

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

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     X = 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         Option
     IDIM(X,Y)   INTEGER(4) X,Y   INTEGER(4)   gnu
     DDIM(X,Y)   REAL(8) X,Y    REAL(8)   gnu

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

Description:
     DOT_PRODUCT(X,Y) computes the dot product multiplication of two vectors X and Y.  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(X*Y). If the vectors are COMPLEX(*), the result is SUM(CONJG(X)*Y). If the vectors are LOGICAL, the result is ANY(X.AND.Y).

Option:
     f95

Class:
     transformational function

Syntax:
     S = DOT_PRODUCT(X,Y)

Arguments:

     X   The type shall be numeric or LOGICAL, rank 1.
     Y   The type shall be numeric or LOGICAL, rank 1.

Return value:
     If the arguments are numeric, the return value is a scaler 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.

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     D = 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
              integer :: i
              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.

Option:
     gnu

Class:
     elemental function

Syntax:
     D = DREAL(Z)

Arguments:

     Z   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

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

     If DTIME is invoked as a function, it can not be invoked as a subroutine, and vice versa.

     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.

Option:
     gnu

Class:
     subroutine

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 start of program execution.

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

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

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

Option:
     gnu

Class:
     elemental function

Syntax:
     X = ERF(X)

Arguments:

     X   The type shall be REAL(*), and it shall be scalar.

Return value:
     The return value is a scalar of type REAL(*) and it is positive ( - 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         Option
     DERF(X)    REAL(8) X    REAL(8)      gnu

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

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

Option:
     gnu

Class:
     elemental function

Syntax:
     X = ERFC(X)

Arguments:

     X   The type shall be REAL(*), and it shall be scalar.

Return value:
     The return value is a scalar of type REAL(*) and it is positive ( 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         Option
     DERFC(X)   REAL(8) X    REAL(8)      gnu

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

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

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     X = 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         Option
     DEXP(X)    REAL(8) X    REAL(8)      f95, gnu
     CEXP(X)    COMPLEX(4) X    COMPLEX(4)      f95, gnu
     ZEXP(X)    COMPLEX(8) X    COMPLEX(8)      f95, gnu
     CDEXP(X)   COMPLEX(8) X    COMPLEX(8)      f95, gnu

LOG --- Logarithm function
==========================

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

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     X = 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.

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

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     X = LOG10(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_log10
            real(8) :: x = 10.0_8
            x = log10(x)
          end program test_log10

Specific names:

     Name              Argument            Return type         Option
     ALOG10(X)    REAL(4) X    REAL(4)      f95, gnu
     DLOG10(X)    REAL(8) X    REAL(8)      f95, gnu

SIN --- Sine function
=====================

Description:
     SIN(X) computes the sine of X.

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     X = SIN(X)

Arguments:

     X   The type shall be REAL(*) or
     COMPLEX(*).

Return value:
     The return value has same type and king than X.

Example:

          program test_sin
            real :: x = 0.0
            x = sin(x)
          end program test_sin

Specific names:

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

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

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

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     X = 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         Option
     DSINH(X)   REAL(8) X    REAL(8)      f95, gnu

SQRT --- Square-root function
=============================

Description:
     SQRT(X) computes the square root of X.

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     X = 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         Option
     DSQRT(X)    REAL(8) X    REAL(8)      f95, gnu
     CSQRT(X)    COMPLEX(4) X    COMPLEX(4)      f95, gnu
     ZSQRT(X)    COMPLEX(8) X    COMPLEX(8)      f95, gnu
     CDSQRT(X)   COMPLEX(8) X    COMPLEX(8)      f95, gnu

TAN --- Tangent function
========================

Description:
     TAN(X) computes the tangent of X.

Option:
     f95, gnu

Class:
     elemental function

Syntax:
     X = 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         Option
     DTAN(X)    REAL(8) X    REAL(8)      f95, gnu

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

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

Option:
     f95, gnu

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         Option
     DTANH(X)   REAL(8) X    REAL(8)      f95, gnu