X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=gcc%2Ffortran%2Fintrinsic.texi;h=7e01315a41f3c03dd8791b5df9e698ae00d43ce7;hp=7ee368361246519f3876610ff94f791edfe6d99e;hb=266e3ca1fd604c5a0d8b887849665fcf3dae91fd;hpb=57f524d757d72f67ae4cc4a491a21350ec2d0fff diff --git a/gcc/fortran/intrinsic.texi b/gcc/fortran/intrinsic.texi index 7ee36836124..7e01315a41f 100644 --- a/gcc/fortran/intrinsic.texi +++ b/gcc/fortran/intrinsic.texi @@ -1,5 +1,5 @@ @ignore -Copyright (C) 2005, 2006, 2007 +Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. This is part of the GNU Fortran manual. For copying conditions, see the file gfortran.texi. @@ -7,10 +7,9 @@ For copying conditions, see the file gfortran.texi. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with the -Invariant Sections being ``GNU General Public License'' and ``Funding -Free Software'', the Front-Cover texts being (a) (see below), and with -the Back-Cover Texts being (b) (see below). A copy of the license is -included in the gfdl(7) man page. +Invariant Sections being ``Funding Free Software'', the Front-Cover +Texts being (a) (see below), and with the Back-Cover Texts being (b) +(see below). A copy of the license is included in the gfdl(7) man page. Some basic guidelines for editing this document: @@ -62,14 +61,20 @@ Some basic guidelines for editing this document: * @code{ATAN}: ATAN, Arctangent function * @code{ATAN2}: ATAN2, Arctangent function * @code{ATANH}: ATANH, Hyperbolic arctangent function -* @code{BESJ0}: BESJ0, Bessel function of the first kind of order 0 -* @code{BESJ1}: BESJ1, Bessel function of the first kind of order 1 -* @code{BESJN}: BESJN, Bessel function of the first kind -* @code{BESY0}: BESY0, Bessel function of the second kind of order 0 -* @code{BESY1}: BESY1, Bessel function of the second kind of order 1 -* @code{BESYN}: BESYN, Bessel function of the second kind +* @code{BESSEL_J0}: BESSEL_J0, Bessel function of the first kind of order 0 +* @code{BESSEL_J1}: BESSEL_J1, Bessel function of the first kind of order 1 +* @code{BESSEL_JN}: BESSEL_JN, Bessel function of the first kind +* @code{BESSEL_Y0}: BESSEL_Y0, Bessel function of the second kind of order 0 +* @code{BESSEL_Y1}: BESSEL_Y1, Bessel function of the second kind of order 1 +* @code{BESSEL_YN}: BESSEL_YN, Bessel function of the second kind * @code{BIT_SIZE}: BIT_SIZE, Bit size inquiry function * @code{BTEST}: BTEST, Bit test function +* @code{C_ASSOCIATED}: C_ASSOCIATED, Status of a C pointer +* @code{C_F_POINTER}: C_F_POINTER, Convert C into Fortran pointer +* @code{C_F_PROCPOINTER}: C_F_PROCPOINTER, Convert C into Fortran procedure pointer +* @code{C_FUNLOC}: C_FUNLOC, Obtain the C address of a procedure +* @code{C_LOC}: C_LOC, Obtain the C address of an object +* @code{C_SIZEOF}: C_SIZEOF, Size in bytes of an expression * @code{CEILING}: CEILING, Integer ceiling function * @code{CHAR}: CHAR, Integer-to-character conversion function * @code{CHDIR}: CHDIR, Change working directory @@ -98,6 +103,7 @@ Some basic guidelines for editing this document: * @code{EPSILON}: EPSILON, Epsilon function * @code{ERF}: ERF, Error function * @code{ERFC}: ERFC, Complementary error function +* @code{ERFC_SCALED}: ERFC_SCALED, Exponentially-scaled complementary error function * @code{ETIME}: ETIME, Execution time subroutine (or function) * @code{EXIT}: EXIT, Exit the program with status. * @code{EXP}: EXP, Exponential function @@ -116,6 +122,7 @@ Some basic guidelines for editing this document: * @code{FSEEK}: FSEEK, Low level file positioning subroutine * @code{FSTAT}: FSTAT, Get file status * @code{FTELL}: FTELL, Current stream position +* @code{GAMMA}: GAMMA, Gamma function * @code{GERROR}: GERROR, Get last system error message * @code{GETARG}: GETARG, Get command line arguments * @code{GET_COMMAND}: GET_COMMAND, Get the entire command line @@ -130,6 +137,7 @@ Some basic guidelines for editing this document: * @code{GMTIME}: GMTIME, Convert time to GMT info * @code{HOSTNM}: HOSTNM, Get system host name * @code{HUGE}: HUGE, Largest number of a kind +* @code{HYPOT}: HYPOT, Euclidian distance function * @code{IACHAR}: IACHAR, Code in @acronym{ASCII} collating sequence * @code{IAND}: IAND, Bitwise logical and * @code{IARGC}: IARGC, Get the number of command line arguments @@ -140,19 +148,23 @@ Some basic guidelines for editing this document: * @code{IDATE}: IDATE, Current local time (day/month/year) * @code{IEOR}: IEOR, Bitwise logical exclusive or * @code{IERRNO}: IERRNO, Function to get the last system error number -* @code{INDEX}: INDEX, Position of a substring within a string +* @code{INDEX}: INDEX intrinsic, Position of a substring within a string * @code{INT}: INT, Convert to integer type * @code{INT2}: INT2, Convert to 16-bit integer type * @code{INT8}: INT8, Convert to 64-bit integer type * @code{IOR}: IOR, Bitwise logical or * @code{IRAND}: IRAND, Integer pseudo-random number +* @code{IS_IOSTAT_END}: IS_IOSTAT_END, Test for end-of-file value +* @code{IS_IOSTAT_EOR}: IS_IOSTAT_EOR, Test for end-of-record value * @code{ISATTY}: ISATTY, Whether a unit is a terminal device * @code{ISHFT}: ISHFT, Shift bits * @code{ISHFTC}: ISHFTC, Shift bits circularly +* @code{ISNAN}: ISNAN, Tests for a NaN * @code{ITIME}: ITIME, Current local time (hour/minutes/seconds) * @code{KILL}: KILL, Send a signal to a process * @code{KIND}: KIND, Kind of an entity * @code{LBOUND}: LBOUND, Lower dimension bounds of an array +* @code{LEADZ}: LEADZ, Number of leading zero bits of an integer * @code{LEN}: LEN, Length of a character entity * @code{LEN_TRIM}: LEN_TRIM, Length of a character entity without trailing blank characters * @code{LGE}: LGE, Lexical greater than or equal @@ -164,6 +176,7 @@ Some basic guidelines for editing this document: * @code{LOC}: LOC, Returns the address of a variable * @code{LOG}: LOG, Logarithm function * @code{LOG10}: LOG10, Base 10 logarithm function +* @code{LOG_GAMMA}: LOG_GAMMA, Logarithm of the Gamma function * @code{LOGICAL}: LOGICAL, Convert to logical type * @code{LONG}: LONG, Convert to integer type * @code{LSHIFT}: LSHIFT, Left shift bits @@ -201,7 +214,7 @@ Some basic guidelines for editing this document: * @code{RANDOM_NUMBER}: RANDOM_NUMBER, Pseudo-random number * @code{RANDOM_SEED}: RANDOM_SEED, Initialize a pseudo-random number sequence * @code{RAND}: RAND, Real pseudo-random number -* @code{RANGE}: RANGE, Decimal exponent range of a real kind +* @code{RANGE}: RANGE, Decimal exponent range * @code{RAN}: RAN, Real pseudo-random number * @code{REAL}: REAL, Convert to real type * @code{RENAME}: RENAME, Rename a file @@ -213,6 +226,7 @@ Some basic guidelines for editing this document: * @code{SCAN}: SCAN, Scan a string for the presence of a set of characters * @code{SECNDS}: SECNDS, Time function * @code{SECOND}: SECOND, CPU time function +* @code{SELECTED_CHAR_KIND}: SELECTED_CHAR_KIND, Choose character kind * @code{SELECTED_INT_KIND}: SELECTED_INT_KIND, Choose integer kind * @code{SELECTED_REAL_KIND}: SELECTED_REAL_KIND, Choose real kind * @code{SET_EXPONENT}: SET_EXPONENT, Set the exponent of the model @@ -222,6 +236,7 @@ Some basic guidelines for editing this document: * @code{SIN}: SIN, Sine function * @code{SINH}: SINH, Hyperbolic sine function * @code{SIZE}: SIZE, Function to determine the size of an array +* @code{SIZEOF}: SIZEOF, Determine the size in bytes of an expression * @code{SLEEP}: SLEEP, Sleep for the specified number of seconds * @code{SNGL}: SNGL, Convert double precision real to default real * @code{SPACING}: SPACING, Smallest distance between two numbers of a given type @@ -238,6 +253,7 @@ Some basic guidelines for editing this document: * @code{TIME}: TIME, Time function * @code{TIME8}: TIME8, Time function (64-bit) * @code{TINY}: TINY, Smallest positive number of a real kind +* @code{TRAILZ}: TRAILZ, Number of trailing zero bits of an integer * @code{TRANSFER}: TRANSFER, Transfer bit patterns * @code{TRANSPOSE}: TRANSPOSE, Transpose an array of rank two * @code{TRIM}: TRIM, Remove trailing blank characters of a string @@ -255,11 +271,12 @@ Some basic guidelines for editing this document: 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 small -selection of intrinsic procedures from the Fortran 2003 standard. Any -conflict between a description here and a description in either the -Fortran 95 standard or the Fortran 2003 standard is unintentional, and -the standard(s) should be considered authoritative. +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 @code{KIND} type parameter is processor defined in the Fortran 95 standard. GNU Fortran defines the default integer type and @@ -301,14 +318,16 @@ the applicable standard for each intrinsic procedure is noted. @table @asis @item @emph{Description}: @code{ABORT} causes immediate termination of the program. On operating -systems that support a core dump, @code{ABORT} will produce a core dump, -which is suitable for debugging purposes. +systems that support a core dump, @code{ABORT} will produce a core dump even if +the option @option{-fno-dump-core} is in effect, which is suitable for debugging +purposes. +@c TODO: Check if this (with -fno-dump-core) is correct. @item @emph{Standard}: GNU extension @item @emph{Class}: -Non-elemental subroutine +Subroutine @item @emph{Syntax}: @code{CALL ABORT} @@ -343,27 +362,27 @@ end program test_abort @table @asis @item @emph{Description}: -@code{ABS(X)} computes the absolute value of @code{X}. +@code{ABS(A)} computes the absolute value of @code{A}. @item @emph{Standard}: -F77 and later, has overloads that are GNU extensions +Fortran 77 and later, has overloads that are GNU extensions @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = ABS(X)} +@code{RESULT = ABS(A)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type of the argument shall be an @code{INTEGER(*)}, -@code{REAL(*)}, or @code{COMPLEX(*)}. +@item @var{A} @tab The type of the argument shall be an @code{INTEGER}, +@code{REAL}, or @code{COMPLEX}. @end multitable @item @emph{Return value}: The return value is of the same type and -kind as the argument except the return value is @code{REAL(*)} for a -@code{COMPLEX(*)} argument. +kind as the argument except the return value is @code{REAL} for a +@code{COMPLEX} argument. @item @emph{Example}: @smallexample @@ -380,11 +399,11 @@ end program test_abs @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Argument @tab Return type @tab Standard -@item @code{CABS(Z)} @tab @code{COMPLEX(4) Z} @tab @code{REAL(4)} @tab F77 and later -@item @code{DABS(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later -@item @code{IABS(I)} @tab @code{INTEGER(4) I} @tab @code{INTEGER(4)} @tab F77 and later -@item @code{ZABS(Z)} @tab @code{COMPLEX(8) Z} @tab @code{COMPLEX(8)} @tab GNU extension -@item @code{CDABS(Z)} @tab @code{COMPLEX(8) Z} @tab @code{COMPLEX(8)} @tab GNU extension +@item @code{CABS(A)} @tab @code{COMPLEX(4) Z} @tab @code{REAL(4)} @tab Fortran 77 and later +@item @code{DABS(A)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab Fortran 77 and later +@item @code{IABS(A)} @tab @code{INTEGER(4) I} @tab @code{INTEGER(4)} @tab Fortran 77 and later +@item @code{ZABS(A)} @tab @code{COMPLEX(8) Z} @tab @code{COMPLEX(8)} @tab GNU extension +@item @code{CDABS(A)} @tab @code{COMPLEX(8) Z} @tab @code{COMPLEX(8)} @tab GNU extension @end multitable @end table @@ -413,13 +432,14 @@ Inquiry function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{NAME} @tab Scalar @code{CHARACTER} with the file name. -Tailing blank are ignored unless the character @code{achar(0)} is -present, then all characters up to and excluding @code{achar(0)} are +@item @var{NAME} @tab Scalar @code{CHARACTER} of default kind with the +file name. Tailing blank are ignored unless the character @code{achar(0)} +is present, then all characters up to and excluding @code{achar(0)} are used as file name. -@item @var{MODE} @tab Scalar @code{CHARACTER} with the file access mode, -may be any concatenation of @code{"r"} (readable), @code{"w"} (writable) -and @code{"x"} (executable), or @code{" "} to check for existence. +@item @var{MODE} @tab Scalar @code{CHARACTER} of default kind with the +file access mode, may be any concatenation of @code{"r"} (readable), +@code{"w"} (writable) and @code{"x"} (executable), or @code{" "} to check +for existence. @end multitable @item @emph{Return value}: @@ -460,22 +480,25 @@ end program access_test in the @acronym{ASCII} collating sequence. @item @emph{Standard}: -F77 and later +Fortran 77 and later, with @var{KIND} argument Fortran 2003 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = ACHAR(I)} +@code{RESULT = ACHAR(I [, KIND])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{I} @tab The type shall be @code{INTEGER(*)}. +@item @var{I} @tab The type shall be @code{INTEGER}. +@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: -The return value is of type @code{CHARACTER} with a length of one. The -kind type parameter is the same as @code{KIND('A')}. +The return value is of type @code{CHARACTER} with a length of one. +If the @var{KIND} argument is present, the return value is of the +specified kind and of the default kind otherwise. @item @emph{Example}: @smallexample @@ -508,7 +531,7 @@ and formatted string representations. @code{ACOS(X)} computes the arccosine of @var{X} (inverse of @code{COS(X)}). @item @emph{Standard}: -F77 and later +Fortran 77 and later, for a complex argument Fortran 2008 or later @item @emph{Class}: Elemental function @@ -518,14 +541,14 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)} with a magnitude that is -less than one. +@item @var{X} @tab The type shall either be @code{REAL} with a magnitude that is +less than or equal to one - or the type shall be @code{COMPLEX}. @end multitable @item @emph{Return value}: -The return value is of type @code{REAL(*)} and it lies in the -range @math{ 0 \leq \acos(x) \leq \pi}. The kind type parameter -is the same as @var{X}. +The return value is of the same type and kind as @var{X}. +The real part of the result is in radians and lies in the range +@math{0 \leq \Re \acos(x) \leq \pi}. @item @emph{Example}: @smallexample @@ -538,7 +561,7 @@ end program test_acos @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Argument @tab Return type @tab Standard -@item @code{DACOS(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later +@item @code{DACOS(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab Fortran 77 and later @end multitable @item @emph{See also}: @@ -563,7 +586,7 @@ Inverse function: @ref{COS} @code{COSH(X)}). @item @emph{Standard}: -GNU extension +Fortran 2008 and later @item @emph{Class}: Elemental function @@ -573,13 +596,13 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)} with a magnitude that is -greater or equal to one. +@item @var{X} @tab The type shall be @code{REAL} or @code{COMPLEX}. @end multitable @item @emph{Return value}: -The return value is of type @code{REAL(*)} and it lies in the -range @math{0 \leq \acosh (x) \leq \infty}. +The return value has the same type and kind as @var{X}. If @var{X} is +complex, the imaginary part of the result is in radians and lies between +@math{ 0 \leq \Im \acosh(x) \leq \pi}. @item @emph{Example}: @smallexample @@ -609,27 +632,27 @@ Inverse function: @ref{COSH} @table @asis @item @emph{Description}: -@code{ADJUSTL(STR)} will left adjust a string by removing leading spaces. +@code{ADJUSTL(STRING)} will left adjust a string by removing leading spaces. Spaces are inserted at the end of the string as needed. @item @emph{Standard}: -F95 and later +Fortran 90 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = ADJUSTL(STR)} +@code{RESULT = ADJUSTL(STRING)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{STR} @tab The type shall be @code{CHARACTER}. +@item @var{STRING} @tab The type shall be @code{CHARACTER}. @end multitable @item @emph{Return value}: -The return value is of type @code{CHARACTER} where leading spaces -are removed and the same number of spaces are inserted on the end -of @var{STR}. +The return value is of type @code{CHARACTER} and of the same kind as +@var{STRING} where leading spaces are removed and the same number of +spaces are inserted on the end of @var{STRING}. @item @emph{Example}: @smallexample @@ -654,17 +677,17 @@ end program test_adjustl @table @asis @item @emph{Description}: -@code{ADJUSTR(STR)} will right adjust a string by removing trailing spaces. +@code{ADJUSTR(STRING)} will right adjust a string by removing trailing spaces. Spaces are inserted at the start of the string as needed. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = ADJUSTR(STR)} +@code{RESULT = ADJUSTR(STRING)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 @@ -672,9 +695,9 @@ Elemental function @end multitable @item @emph{Return value}: -The return value is of type @code{CHARACTER} where trailing spaces -are removed and the same number of spaces are inserted at the start -of @var{STR}. +The return value is of type @code{CHARACTER} and of the same kind as +@var{STRING} where trailing spaces are removed and the same number of +spaces are inserted at the start of @var{STRING}. @item @emph{Example}: @smallexample @@ -707,7 +730,7 @@ for compatibility with @command{g77}, and their use in new code is strongly discouraged. @item @emph{Standard}: -F77 and later, has overloads that are GNU extensions +Fortran 77 and later, has overloads that are GNU extensions @item @emph{Class}: Elemental function @@ -717,11 +740,11 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{Z} @tab The type of the argument shall be @code{COMPLEX(*)}. +@item @var{Z} @tab The type of the argument shall be @code{COMPLEX}. @end multitable @item @emph{Return value}: -The return value is of type real with the +The return value is of type @code{REAL} with the kind type parameter of the argument. @item @emph{Example}: @@ -739,8 +762,8 @@ end program test_aimag @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Argument @tab Return type @tab Standard @item @code{DIMAG(Z)} @tab @code{COMPLEX(8) Z} @tab @code{REAL(8)} @tab GNU extension -@item @code{IMAG(Z)} @tab @code{COMPLEX(*) Z} @tab @code{REAL(*)} @tab GNU extension -@item @code{IMAGPART(Z)} @tab @code{COMPLEX(*) Z} @tab @code{REAL(*)} @tab GNU extension +@item @code{IMAG(Z)} @tab @code{COMPLEX Z} @tab @code{REAL} @tab GNU extension +@item @code{IMAGPART(Z)} @tab @code{COMPLEX Z} @tab @code{REAL} @tab GNU extension @end multitable @end table @@ -755,31 +778,30 @@ end program test_aimag @table @asis @item @emph{Description}: -@code{AINT(X [, KIND])} truncates its argument to a whole number. +@code{AINT(A [, KIND])} truncates its argument to a whole number. @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = AINT(X [, KIND])} +@code{RESULT = AINT(A [, KIND])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type of the argument shall be @code{REAL(*)}. -@item @var{KIND} @tab (Optional) An @code{INTEGER(*)} initialization - expression indicating the kind parameter of - the result. +@item @var{A} @tab The type of the argument shall be @code{REAL}. +@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: -The return value is of type real with the kind type parameter of the +The return value is of type @code{REAL} with the kind type parameter of the argument if the optional @var{KIND} is absent; otherwise, the kind type parameter will be given by @var{KIND}. If the magnitude of -@var{X} is less than one, then @code{AINT(X)} returns zero. If the -magnitude is equal to or greater than one, then it returns the largest +@var{X} is less than one, @code{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 @var{X}. @@ -798,7 +820,7 @@ end program test_aint @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Argument @tab Return type @tab Standard -@item @code{DINT(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later +@item @code{DINT(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab Fortran 77 and later @end multitable @end table @@ -867,24 +889,24 @@ after 3 seconds. in the array along dimension @var{DIM}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: -transformational function +Transformational function @item @emph{Syntax}: @code{RESULT = ALL(MASK [, DIM])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{MASK} @tab The type of the argument shall be @code{LOGICAL(*)} and +@item @var{MASK} @tab The type of the argument shall be @code{LOGICAL} and it shall not be scalar. @item @var{DIM} @tab (Optional) @var{DIM} shall be a scalar integer with a value that lies between one and the rank of @var{MASK}. @end multitable @item @emph{Return value}: -@code{ALL(MASK)} returns a scalar value of type @code{LOGICAL(*)} where +@code{ALL(MASK)} returns a scalar value of type @code{LOGICAL} where the kind type parameter is the same as the kind type parameter of @var{MASK}. If @var{DIM} is present, then @code{ALL(MASK, DIM)} returns an array with the rank of @var{MASK} minus 1. The shape is determined from @@ -929,33 +951,33 @@ end program test_all @table @asis @item @emph{Description}: -@code{ALLOCATED(X)} checks the status of whether @var{X} is allocated. +@code{ALLOCATED(ARRAY)} checks the status of whether @var{X} is allocated. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Inquiry function @item @emph{Syntax}: -@code{RESULT = ALLOCATED(X)} +@code{RESULT = ALLOCATED(ARRAY)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The argument shall be an @code{ALLOCATABLE} array. +@item @var{ARRAY} @tab The argument shall be an @code{ALLOCATABLE} array. @end multitable @item @emph{Return value}: The return value is a scalar @code{LOGICAL} with the default logical -kind type parameter. If @var{X} is allocated, @code{ALLOCATED(X)} -is @code{.TRUE.}; otherwise, it returns the @code{.TRUE.} +kind type parameter. If @var{ARRAY} is allocated, @code{ALLOCATED(ARRAY)} +is @code{.TRUE.}; otherwise, it returns @code{.FALSE.} @item @emph{Example}: @smallexample program test_allocated integer :: i = 4 real(4), allocatable :: x(:) - if (allocated(x) .eqv. .false.) allocate(x(i)) + if (.not. allocated(x)) allocate(x(i)) end program test_allocated @end smallexample @end table @@ -980,20 +1002,23 @@ the use of the @ref{IAND} intrinsic defined by the Fortran standard. GNU extension @item @emph{Class}: -Non-elemental function +Function @item @emph{Syntax}: @code{RESULT = AND(I, J)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{I} @tab The type shall be either @code{INTEGER(*)} or @code{LOGICAL}. -@item @var{J} @tab The type shall be either @code{INTEGER(*)} or @code{LOGICAL}. +@item @var{I} @tab The type shall be either a scalar @code{INTEGER} +type or a scalar @code{LOGICAL} type. +@item @var{J} @tab The type shall be the same as the type of @var{I}. @end multitable @item @emph{Return value}: -The return type is either @code{INTEGER(*)} or @code{LOGICAL} after -cross-promotion of the arguments. +The return type is either a scalar @code{INTEGER} or a scalar +@code{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. @item @emph{Example}: @smallexample @@ -1008,7 +1033,7 @@ END PROGRAM @end smallexample @item @emph{See also}: -F95 elemental function: @ref{IAND} +Fortran 95 elemental function: @ref{IAND} @end table @@ -1022,31 +1047,30 @@ F95 elemental function: @ref{IAND} @table @asis @item @emph{Description}: -@code{ANINT(X [, KIND])} rounds its argument to the nearest whole number. +@code{ANINT(A [, KIND])} rounds its argument to the nearest whole number. @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = ANINT(X [, KIND])} +@code{RESULT = ANINT(A [, KIND])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type of the argument shall be @code{REAL(*)}. -@item @var{KIND} @tab (Optional) An @code{INTEGER(*)} initialization - expression indicating the kind parameter of - the result. +@item @var{A} @tab The type of the argument shall be @code{REAL}. +@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: The return value is of type real with the kind type parameter of the argument if the optional @var{KIND} is absent; otherwise, the kind -type parameter will be given by @var{KIND}. If @var{X} is greater than -zero, then @code{ANINT(X)} returns @code{AINT(X+0.5)}. If @var{X} is -less than or equal to zero, then it returns @code{AINT(X-0.5)}. +type parameter will be given by @var{KIND}. If @var{A} is greater than +zero, @code{ANINT(A)} returns @code{AINT(X+0.5)}. If @var{A} is +less than or equal to zero then it returns @code{AINT(X-0.5)}. @item @emph{Example}: @smallexample @@ -1063,7 +1087,7 @@ end program test_anint @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Argument @tab Return type @tab Standard -@item @code{DNINT(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later +@item @code{DNINT(A)} @tab @code{REAL(8) A} @tab @code{REAL(8)} @tab Fortran 77 and later @end multitable @end table @@ -1081,24 +1105,24 @@ end program test_anint @var{MASK} along dimension @var{DIM} are @code{.TRUE.}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: -transformational function +Transformational function @item @emph{Syntax}: @code{RESULT = ANY(MASK [, DIM])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{MASK} @tab The type of the argument shall be @code{LOGICAL(*)} and +@item @var{MASK} @tab The type of the argument shall be @code{LOGICAL} and it shall not be scalar. @item @var{DIM} @tab (Optional) @var{DIM} shall be a scalar integer with a value that lies between one and the rank of @var{MASK}. @end multitable @item @emph{Return value}: -@code{ANY(MASK)} returns a scalar value of type @code{LOGICAL(*)} where +@code{ANY(MASK)} returns a scalar value of type @code{LOGICAL} where the kind type parameter is the same as the kind type parameter of @var{MASK}. If @var{DIM} is present, then @code{ANY(MASK, DIM)} returns an array with the rank of @var{MASK} minus 1. The shape is determined from @@ -1148,7 +1172,7 @@ end program test_any @code{ASIN(X)} computes the arcsine of its @var{X} (inverse of @code{SIN(X)}). @item @emph{Standard}: -F77 and later +Fortran 77 and later, for a complex argument Fortran 2008 or later @item @emph{Class}: Elemental function @@ -1158,14 +1182,14 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)}, and a magnitude that is -less than one. +@item @var{X} @tab The type shall be either @code{REAL} and a magnitude that is +less than or equal to one - or be @code{COMPLEX}. @end multitable @item @emph{Return value}: -The return value is of type @code{REAL(*)} and it lies in the -range @math{-\pi / 2 \leq \asin (x) \leq \pi / 2}. The kind type -parameter is the same as @var{X}. +The return value is of the same type and kind as @var{X}. +The real part of the result is in radians and lies in the range +@math{-\pi/2 \leq \Re \asin(x) \leq \pi/2}. @item @emph{Example}: @smallexample @@ -1178,7 +1202,7 @@ end program test_asin @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Argument @tab Return type @tab Standard -@item @code{DASIN(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later +@item @code{DASIN(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab Fortran 77 and later @end multitable @item @emph{See also}: @@ -1202,7 +1226,7 @@ Inverse function: @ref{SIN} @code{ASINH(X)} computes the hyperbolic arcsine of @var{X} (inverse of @code{SINH(X)}). @item @emph{Standard}: -GNU extension +Fortran 2008 and later @item @emph{Class}: Elemental function @@ -1212,12 +1236,13 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)}, with @var{X} a real number. +@item @var{X} @tab The type shall be @code{REAL} or @code{COMPLEX}. @end multitable @item @emph{Return value}: -The return value is of type @code{REAL(*)} and it lies in the -range @math{-\infty \leq \asinh (x) \leq \infty}. +The return value is of the same type and kind as @var{X}. If @var{X} is +complex, the imaginary part of the result is in radians and lies between +@math{-\pi/2 \leq \Im \asinh(x) \leq \pi/2}. @item @emph{Example}: @smallexample @@ -1247,54 +1272,55 @@ Inverse function: @ref{SINH} @table @asis @item @emph{Description}: -@code{ASSOCIATED(PTR [, TGT])} determines the status of the pointer @var{PTR} -or if @var{PTR} is associated with the target @var{TGT}. +@code{ASSOCIATED(POINTER [, TARGET])} determines the status of the pointer +@var{POINTER} or if @var{POINTER} is associated with the target @var{TARGET}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Inquiry function @item @emph{Syntax}: -@code{RESULT = ASSOCIATED(PTR [, TGT])} +@code{RESULT = ASSOCIATED(POINTER [, TARGET])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{PTR} @tab @var{PTR} shall have the @code{POINTER} attribute and -it can be of any type. -@item @var{TGT} @tab (Optional) @var{TGT} shall be a @code{POINTER} or -a @code{TARGET}. It must have the same type, kind type parameter, and -array rank as @var{PTR}. +@item @var{POINTER} @tab @var{POINTER} shall have the @code{POINTER} attribute +and it can be of any type. +@item @var{TARGET} @tab (Optional) @var{TARGET} shall be a pointer or +a target. It must have the same type, kind type parameter, and +array rank as @var{POINTER}. @end multitable -The status of neither @var{PTR} nor @var{TGT} can be undefined. +The association status of neither @var{POINTER} nor @var{TARGET} shall be +undefined. @item @emph{Return value}: -@code{ASSOCIATED(PTR)} returns a scalar value of type @code{LOGICAL(4)}. +@code{ASSOCIATED(POINTER)} returns a scalar value of type @code{LOGICAL(4)}. There are several cases: @table @asis -@item (A) If the optional @var{TGT} is not present, then @code{ASSOCIATED(PTR)} -is true if @var{PTR} is associated with a target; otherwise, it returns false. -@item (B) If @var{TGT} is present and a scalar target, the result is true if -@var{TGT} -is not a 0 sized storage sequence and the target associated with @var{PTR} -occupies the same storage units. If @var{PTR} is disassociated, then the -result is false. -@item (C) If @var{TGT} is present and an array target, the result is true if -@var{TGT} and @var{PTR} have the same shape, are not 0 sized arrays, are -arrays whose elements are not 0 sized storage sequences, and @var{TGT} and -@var{PTR} occupy the same storage units in array element order. -As in case(B), the result is false, if @var{PTR} is disassociated. -@item (D) If @var{TGT} is present and an scalar pointer, the result is true if -target associated with @var{PTR} and the target associated with @var{TGT} -are not 0 sized storage sequences and occupy the same storage units. -The result is false, if either @var{TGT} or @var{PTR} is disassociated. -@item (E) If @var{TGT} is present and an array pointer, the result is true if -target associated with @var{PTR} and the target associated with @var{TGT} -have the same shape, are not 0 sized arrays, are arrays whose elements are -not 0 sized storage sequences, and @var{TGT} and @var{PTR} occupy the same -storage units in array element order. -The result is false, if either @var{TGT} or @var{PTR} is disassociated. +@item (A) When the optional @var{TARGET} is not present then +@code{ASSOCIATED(POINTER)} is true if @var{POINTER} is associated with a target; otherwise, it returns false. +@item (B) If @var{TARGET} is present and a scalar target, the result is true if +@var{TARGET} is not a zero-sized storage sequence and the target associated with @var{POINTER} occupies the same storage units. If @var{POINTER} is +disassociated, the result is false. +@item (C) If @var{TARGET} is present and an array target, the result is true if +@var{TARGET} and @var{POINTER} have the same shape, are not zero-sized arrays, +are arrays whose elements are not zero-sized storage sequences, and +@var{TARGET} and @var{POINTER} occupy the same storage units in array element +order. +As in case(B), the result is false, if @var{POINTER} is disassociated. +@item (D) If @var{TARGET} is present and an scalar pointer, the result is true +if @var{TARGET} is associated with @var{POINTER}, the target associated with +@var{TARGET} are not zero-sized storage sequences and occupy the same storage +units. +The result is false, if either @var{TARGET} or @var{POINTER} is disassociated. +@item (E) If @var{TARGET} is present and an array pointer, the result is true if +target associated with @var{POINTER} and the target associated with @var{TARGET} +have the same shape, are not zero-sized arrays, are arrays whose elements are +not zero-sized storage sequences, and @var{TARGET} and @var{POINTER} occupy +the same storage units in array element order. +The result is false, if either @var{TARGET} or @var{POINTER} is disassociated. @end table @item @emph{Example}: @@ -1327,22 +1353,29 @@ end program test_associated @code{ATAN(X)} computes the arctangent of @var{X}. @item @emph{Standard}: -F77 and later +Fortran 77 and later, for a complex argument and for two arguments +Fortran 2008 or later @item @emph{Class}: Elemental function @item @emph{Syntax}: @code{RESULT = ATAN(X)} +@code{RESULT = ATAN(Y, X)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)}. +@item @var{X} @tab The type shall be @code{REAL} or @code{COMPLEX}; +if @var{Y} is present, @var{X} shall be REAL. +@item @var{Y} shall be of the same type and kind as @var{X}. @end multitable @item @emph{Return value}: -The return value is of type @code{REAL(*)} and it lies in the -range @math{ - \pi / 2 \leq \atan (x) \leq \pi / 2}. +The return value is of the same type and kind as @var{X}. +If @var{Y} is present, the result is identical to @code{ATAN2(Y,X)}. +Otherwise, it the arcus tangent of @var{X}, where the real part of +the result is in radians and lies in the range +@math{-\pi/2 \leq \Re \atan(x) \leq \pi/2}. @item @emph{Example}: @smallexample @@ -1355,7 +1388,7 @@ end program test_atan @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Argument @tab Return type @tab Standard -@item @code{DATAN(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later +@item @code{DATAN(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab Fortran 77 and later @end multitable @item @emph{See also}: @@ -1374,21 +1407,23 @@ Inverse function: @ref{TAN} @table @asis @item @emph{Description}: -@code{ATAN2(Y,X)} computes the arctangent of the complex number -@math{X + i Y}. +@code{ATAN2(Y, X)} computes the principal value of the argument +function of the complex number @math{X + i Y}. This function can +be used to transform from carthesian into polar coordinates and +allows to determine the angle in the correct quadrant. @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = ATAN2(Y,X)} +@code{RESULT = ATAN2(Y, X)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{Y} @tab The type shall be @code{REAL(*)}. +@item @var{Y} @tab The type shall be @code{REAL}. @item @var{X} @tab The type and kind type parameter shall be the same as @var{Y}. If @var{Y} is zero, then @var{X} must be nonzero. @end multitable @@ -1413,7 +1448,7 @@ end program test_atan2 @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Argument @tab Return type @tab Standard -@item @code{DATAN2(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later +@item @code{DATAN2(X, Y)} @tab @code{REAL(8) X}, @code{REAL(8) Y} @tab @code{REAL(8)} @tab Fortran 77 and later @end multitable @end table @@ -1434,7 +1469,7 @@ end program test_atan2 of @code{TANH(X)}). @item @emph{Standard}: -GNU extension +Fortran 2008 and later @item @emph{Class}: Elemental function @@ -1444,13 +1479,13 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)} with a magnitude -that is less than or equal to one. +@item @var{X} @tab The type shall be @code{REAL} or @code{COMPLEX}. @end multitable @item @emph{Return value}: -The return value is of type @code{REAL(*)} and it lies in the -range @math{-\infty \leq \atanh(x) \leq \infty}. +The return value has same type and kind as @var{X}. If @var{X} is +complex, the imaginary part of the result is in radians and lies between +@math{-\pi/2 \leq \Im \atanh(x) \leq \pi/2}. @item @emph{Example}: @smallexample @@ -1472,40 +1507,43 @@ Inverse function: @ref{TANH} -@node BESJ0 -@section @code{BESJ0} --- Bessel function of the first kind of order 0 +@node BESSEL_J0 +@section @code{BESSEL_J0} --- Bessel function of the first kind of order 0 +@fnindex BESSEL_J0 @fnindex BESJ0 @fnindex DBESJ0 @cindex Bessel function, first kind @table @asis @item @emph{Description}: -@code{BESJ0(X)} computes the Bessel function of the first kind of order 0 -of @var{X}. +@code{BESSEL_J0(X)} computes the Bessel function of the first kind of +order 0 of @var{X}. This function is available under the name +@code{BESJ0} as a GNU extension. @item @emph{Standard}: -GNU extension +Fortran 2008 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = BESJ0(X)} +@code{RESULT = BESSEL_J0(X)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar. +@item @var{X} @tab The type shall be @code{REAL}, and it shall be scalar. @end multitable @item @emph{Return value}: -The return value is of type @code{REAL(*)} and it lies in the -range @math{ - 0.4027... \leq Bessel (0,x) \leq 1}. +The return value is of type @code{REAL} and lies in the +range @math{ - 0.4027... \leq Bessel (0,x) \leq 1}. It has the same +kind as @var{X}. @item @emph{Example}: @smallexample program test_besj0 real(8) :: x = 0.0_8 - x = besj0(x) + x = bessel_j0(x) end program test_besj0 @end smallexample @@ -1518,40 +1556,43 @@ end program test_besj0 -@node BESJ1 -@section @code{BESJ1} --- Bessel function of the first kind of order 1 +@node BESSEL_J1 +@section @code{BESSEL_J1} --- Bessel function of the first kind of order 1 +@fnindex BESSEL_J1 @fnindex BESJ1 @fnindex DBESJ1 @cindex Bessel function, first kind @table @asis @item @emph{Description}: -@code{BESJ1(X)} computes the Bessel function of the first kind of order 1 -of @var{X}. +@code{BESSEL_J1(X)} computes the Bessel function of the first kind of +order 1 of @var{X}. This function is available under the name +@code{BESJ1} as a GNU extension. @item @emph{Standard}: -GNU extension +Fortran 2008 @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = BESJ1(X)} +@code{RESULT = BESSEL_J1(X)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar. +@item @var{X} @tab The type shall be @code{REAL}, and it shall be scalar. @end multitable @item @emph{Return value}: -The return value is of type @code{REAL(*)} and it lies in the -range @math{ - 0.5818... \leq Bessel (0,x) \leq 0.5818 }. +The return value is of type @code{REAL} and it lies in the +range @math{ - 0.5818... \leq Bessel (0,x) \leq 0.5818 }. It has the same +kind as @var{X}. @item @emph{Example}: @smallexample program test_besj1 real(8) :: x = 1.0_8 - x = besj1(x) + x = bessel_j1(x) end program test_besj1 @end smallexample @@ -1564,86 +1605,94 @@ end program test_besj1 -@node BESJN -@section @code{BESJN} --- Bessel function of the first kind +@node BESSEL_JN +@section @code{BESSEL_JN} --- Bessel function of the first kind +@fnindex BESSEL_JN @fnindex BESJN @fnindex DBESJN @cindex Bessel function, first kind @table @asis @item @emph{Description}: -@code{BESJN(N, X)} computes the Bessel function of the first kind of order -@var{N} of @var{X}. +@code{BESSEL_JN(N, X)} computes the Bessel function of the first kind of +order @var{N} of @var{X}. This function is available under the name +@code{BESJN} as a GNU extension. + +If both arguments are arrays, their ranks and shapes shall conform. @item @emph{Standard}: -GNU extension +Fortran 2008 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = BESJN(N, X)} +@code{RESULT = BESSEL_JN(N, X)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{N} @tab The type shall be @code{INTEGER(*)}, and it shall be scalar. -@item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar. +@item @var{N} @tab Shall be a scalar or an array of type @code{INTEGER}. +@item @var{X} @tab Shall be a scalar or an array of type @code{REAL}. @end multitable @item @emph{Return value}: -The return value is a scalar of type @code{REAL(*)}. +The return value is a scalar of type @code{REAL}. It has the same +kind as @var{X}. @item @emph{Example}: @smallexample program test_besjn real(8) :: x = 1.0_8 - x = besjn(5,x) + x = bessel_jn(5,x) end program test_besjn @end smallexample @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 -@item Name @tab Argument @tab Return type @tab Standard -@item @code{DBESJN(X)} @tab @code{INTEGER(*) N} @tab @code{REAL(8)} @tab GNU extension -@item @tab @code{REAL(8) X} @tab @tab +@item Name @tab Argument @tab Return type @tab Standard +@item @code{DBESJN(N, X)} @tab @code{INTEGER N} @tab @code{REAL(8)} @tab GNU extension +@item @tab @code{REAL(8) X} @tab @tab @end multitable @end table -@node BESY0 -@section @code{BESY0} --- Bessel function of the second kind of order 0 +@node BESSEL_Y0 +@section @code{BESSEL_Y0} --- Bessel function of the second kind of order 0 +@fnindex BESSEL_Y0 @fnindex BESY0 @fnindex DBESY0 @cindex Bessel function, second kind @table @asis @item @emph{Description}: -@code{BESY0(X)} computes the Bessel function of the second kind of order 0 -of @var{X}. +@code{BESSEL_Y0(X)} computes the Bessel function of the second kind of +order 0 of @var{X}. This function is available under the name +@code{BESY0} as a GNU extension. @item @emph{Standard}: -GNU extension +Fortran 2008 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = BESY0(X)} +@code{RESULT = BESSEL_Y0(X)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar. +@item @var{X} @tab The type shall be @code{REAL}, and it shall be scalar. @end multitable @item @emph{Return value}: -The return value is a scalar of type @code{REAL(*)}. +The return value is a scalar of type @code{REAL}. It has the same +kind as @var{X}. @item @emph{Example}: @smallexample program test_besy0 real(8) :: x = 0.0_8 - x = besy0(x) + x = bessel_y0(x) end program test_besy0 @end smallexample @@ -1656,39 +1705,42 @@ end program test_besy0 -@node BESY1 -@section @code{BESY1} --- Bessel function of the second kind of order 1 +@node BESSEL_Y1 +@section @code{BESSEL_Y1} --- Bessel function of the second kind of order 1 +@fnindex BESSEL_Y1 @fnindex BESY1 @fnindex DBESY1 @cindex Bessel function, second kind @table @asis @item @emph{Description}: -@code{BESY1(X)} computes the Bessel function of the second kind of order 1 -of @var{X}. +@code{BESSEL_Y1(X)} computes the Bessel function of the second kind of +order 1 of @var{X}. This function is available under the name +@code{BESY1} as a GNU extension. @item @emph{Standard}: -GNU extension +Fortran 2008 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = BESY1(X)} +@code{RESULT = BESSEL_Y1(X)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar. +@item @var{X} @tab The type shall be @code{REAL}, and it shall be scalar. @end multitable @item @emph{Return value}: -The return value is a scalar of type @code{REAL(*)}. +The return value is a scalar of type @code{REAL}. It has the same +kind as @var{X}. @item @emph{Example}: @smallexample program test_besy1 real(8) :: x = 1.0_8 - x = besy1(x) + x = bessel_y1(x) end program test_besy1 @end smallexample @@ -1701,47 +1753,52 @@ end program test_besy1 -@node BESYN -@section @code{BESYN} --- Bessel function of the second kind +@node BESSEL_YN +@section @code{BESSEL_YN} --- Bessel function of the second kind +@fnindex BESSEL_YN @fnindex BESYN @fnindex DBESYN @cindex Bessel function, second kind @table @asis @item @emph{Description}: -@code{BESYN(N, X)} computes the Bessel function of the second kind of order -@var{N} of @var{X}. +@code{BESSEL_YN(N, X)} computes the Bessel function of the second kind of +order @var{N} of @var{X}. This function is available under the name +@code{BESYN} as a GNU extension. + +If both arguments are arrays, their ranks and shapes shall conform. @item @emph{Standard}: -GNU extension +Fortran 2008 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = BESYN(N, X)} +@code{RESULT = BESSEL_YN(N, X)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{N} @tab The type shall be @code{INTEGER(*)}, and it shall be scalar. -@item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar. +@item @var{N} @tab Shall be a scalar or an array of type @code{INTEGER}. +@item @var{X} @tab Shall be a scalar or an array of type @code{REAL}. @end multitable @item @emph{Return value}: -The return value is a scalar of type @code{REAL(*)}. +The return value is a scalar of type @code{REAL}. It has the same +kind as @var{X}. @item @emph{Example}: @smallexample program test_besyn real(8) :: x = 1.0_8 - x = besyn(5,x) + x = bessel_yn(5,x) end program test_besyn @end smallexample @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Argument @tab Return type @tab Standard -@item @code{DBESYN(N,X)} @tab @code{INTEGER(*) N} @tab @code{REAL(8)} @tab GNU extension +@item @code{DBESYN(N,X)} @tab @code{INTEGER N} @tab @code{REAL(8)} @tab GNU extension @item @tab @code{REAL(8) X} @tab @tab @end multitable @end table @@ -1757,10 +1814,11 @@ end program test_besyn @table @asis @item @emph{Description}: @code{BIT_SIZE(I)} returns the number of bits (integer precision plus sign bit) -represented by the type of @var{I}. +represented by the type of @var{I}. The result of @code{BIT_SIZE(I)} is +independent of the actual value of @var{I}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Inquiry function @@ -1770,11 +1828,11 @@ Inquiry function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{I} @tab The type shall be @code{INTEGER(*)}. +@item @var{I} @tab The type shall be @code{INTEGER}. @end multitable @item @emph{Return value}: -The return value is of type @code{INTEGER(*)} +The return value is of type @code{INTEGER} @item @emph{Example}: @smallexample @@ -1797,10 +1855,10 @@ end program test_bit_size @table @asis @item @emph{Description}: @code{BTEST(I,POS)} returns logical @code{.TRUE.} if the bit at @var{POS} -in @var{I} is set. +in @var{I} is set. The counting of the bits starts at 0. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @@ -1810,8 +1868,8 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{I} @tab The type shall be @code{INTEGER(*)}. -@item @var{POS} @tab The type shall be @code{INTEGER(*)}. +@item @var{I} @tab The type shall be @code{INTEGER}. +@item @var{POS} @tab The type shall be @code{INTEGER}. @end multitable @item @emph{Return value}: @@ -1832,6 +1890,320 @@ end program test_btest @end table +@node C_ASSOCIATED +@section @code{C_ASSOCIATED} --- Status of a C pointer +@fnindex C_ASSOCIATED +@cindex association status, C pointer +@cindex pointer, C association status + +@table @asis +@item @emph{Description}: +@code{C_ASSOCIATED(c_prt_1[, c_ptr_2])} determines the status of the C pointer +@var{c_ptr_1} or if @var{c_ptr_1} is associated with the target @var{c_ptr_2}. + +@item @emph{Standard}: +Fortran 2003 and later + +@item @emph{Class}: +Inquiry function + +@item @emph{Syntax}: +@code{RESULT = C_ASSOCIATED(c_prt_1[, c_ptr_2])} + +@item @emph{Arguments}: +@multitable @columnfractions .15 .70 +@item @var{c_ptr_1} @tab Scalar of the type @code{C_PTR} or @code{C_FUNPTR}. +@item @var{c_ptr_2} @tab (Optional) Scalar of the same type as @var{c_ptr_1}. +@end multitable + +@item @emph{Return value}: +The return value is of type @code{LOGICAL}; it is @code{.false.} if either +@var{c_ptr_1} is a C NULL pointer or if @var{c_ptr1} and @var{c_ptr_2} +point to different addresses. + +@item @emph{Example}: +@smallexample +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 +@end smallexample + +@item @emph{See also}: +@ref{C_LOC}, @ref{C_FUNLOC} +@end table + + +@node C_FUNLOC +@section @code{C_FUNLOC} --- Obtain the C address of a procedure +@fnindex C_FUNLOC +@cindex pointer, C address of procedures + +@table @asis +@item @emph{Description}: +@code{C_FUNLOC(x)} determines the C address of the argument. + +@item @emph{Standard}: +Fortran 2003 and later + +@item @emph{Class}: +Inquiry function + +@item @emph{Syntax}: +@code{RESULT = C_FUNLOC(x)} + +@item @emph{Arguments}: +@multitable @columnfractions .15 .70 +@item @var{x} @tab Interoperable function or pointer to such function. +@end multitable + +@item @emph{Return value}: +The return value is of type @code{C_FUNPTR} and contains the C address +of the argument. + +@item @emph{Example}: +@smallexample +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 +@end smallexample + +@item @emph{See also}: +@ref{C_ASSOCIATED}, @ref{C_LOC}, @ref{C_F_POINTER}, @ref{C_F_PROCPOINTER} +@end table + + +@node C_F_PROCPOINTER +@section @code{C_F_PROCPOINTER} --- Convert C into Fortran procedure pointer +@fnindex C_F_PROCPOINTER +@cindex pointer, C address of pointers + +@table @asis +@item @emph{Description}: +@code{C_F_PROCPOINTER(CPTR, FPTR)} Assign the target of the C function pointer +@var{CPTR} to the Fortran procedure pointer @var{FPTR}. + +Note: Due to the currently lacking support of procedure pointers in GNU Fortran +this function is not fully operable. + +@item @emph{Standard}: +Fortran 2003 and later + +@item @emph{Class}: +Subroutine + +@item @emph{Syntax}: +@code{CALL C_F_PROCPOINTER(cptr, fptr)} + +@item @emph{Arguments}: +@multitable @columnfractions .15 .70 +@item @var{CPTR} @tab scalar of the type @code{C_FUNPTR}. It is +@code{INTENT(IN)}. +@item @var{FPTR} @tab procedure pointer interoperable with @var{cptr}. It is +@code{INTENT(OUT)}. +@end multitable + +@item @emph{Example}: +@smallexample +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 +@end smallexample + +@item @emph{See also}: +@ref{C_LOC}, @ref{C_F_POINTER} +@end table + + +@node C_F_POINTER +@section @code{C_F_POINTER} --- Convert C into Fortran pointer +@fnindex C_F_POINTER +@cindex pointer, convert C to Fortran + +@table @asis +@item @emph{Description}: +@code{C_F_POINTER(CPTR, FPTR[, SHAPE])} Assign the target the C pointer +@var{CPTR} to the Fortran pointer @var{FPTR} and specify its +shape. + +@item @emph{Standard}: +Fortran 2003 and later + +@item @emph{Class}: +Subroutine + +@item @emph{Syntax}: +@code{CALL C_F_POINTER(CPTR, FPTR[, SHAPE])} + +@item @emph{Arguments}: +@multitable @columnfractions .15 .70 +@item @var{CPTR} @tab scalar of the type @code{C_PTR}. It is +@code{INTENT(IN)}. +@item @var{FPTR} @tab pointer interoperable with @var{cptr}. It is +@code{INTENT(OUT)}. +@item @var{SHAPE} @tab (Optional) Rank-one array of type @code{INTEGER} +with @code{INTENT(IN)}. It shall be present +if and only if @var{fptr} is an array. The size +must be equal to the rank of @var{fptr}. +@end multitable + +@item @emph{Example}: +@smallexample +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 +@end smallexample + +@item @emph{See also}: +@ref{C_LOC}, @ref{C_F_PROCPOINTER} +@end table + + +@node C_LOC +@section @code{C_LOC} --- Obtain the C address of an object +@fnindex C_LOC +@cindex procedure pointer, convert C to Fortran + +@table @asis +@item @emph{Description}: +@code{C_LOC(X)} determines the C address of the argument. + +@item @emph{Standard}: +Fortran 2003 and later + +@item @emph{Class}: +Inquiry function + +@item @emph{Syntax}: +@code{RESULT = C_LOC(X)} + +@item @emph{Arguments}: +@multitable @columnfractions .15 .70 +@item @var{X} @tab Associated scalar pointer or interoperable scalar +or allocated allocatable variable with @code{TARGET} attribute. +@end multitable + +@item @emph{Return value}: +The return value is of type @code{C_PTR} and contains the C address +of the argument. + +@item @emph{Example}: +@smallexample +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 +@end smallexample + +@item @emph{See also}: +@ref{C_ASSOCIATED}, @ref{C_FUNLOC}, @ref{C_F_POINTER}, @ref{C_F_PROCPOINTER} +@end table + + +@node C_SIZEOF +@section @code{C_SIZEOF} --- Size in bytes of an expression +@fnindex C_SIZEOF +@cindex expression size +@cindex size of an expression + +@table @asis +@item @emph{Description}: +@code{C_SIZEOF(X)} calculates the number of bytes of storage the +expression @code{X} occupies. + +@item @emph{Standard}: +Fortran 2008 + +@item @emph{Class}: +Intrinsic function + +@item @emph{Syntax}: +@code{N = C_SIZEOF(X)} + +@item @emph{Arguments}: +@multitable @columnfractions .15 .70 +@item @var{X} @tab The argument shall be of any type, rank or shape. +@end multitable + +@item @emph{Return value}: +The return value is of type integer and of the system-dependent kind +@var{C_SIZE_T} (from the @var{ISO_C_BINDING} module). Its value is the +number of bytes occupied by the argument. If the argument has the +@code{POINTER} attribute, the number of bytes of the storage area pointed +to is returned. If the argument is of a derived type with @code{POINTER} +or @code{ALLOCATABLE} components, the return value doesn't account for +the sizes of the data pointed to by these components. + +@item @emph{Example}: +@smallexample + use iso_c_binding + integer(c_int) :: i + real(c_float) :: r, s(5) + print *, (c_sizeof(s)/c_sizeof(r) == 5) + end +@end smallexample +The example will print @code{.TRUE.} unless you are using a platform +where default @code{REAL} variables are unusually padded. + +@item @emph{See also}: +@ref{SIZEOF} +@end table + @node CEILING @section @code{CEILING} --- Integer ceiling function @@ -1841,27 +2213,27 @@ end program test_btest @table @asis @item @emph{Description}: -@code{CEILING(X)} returns the least integer greater than or equal to @var{X}. +@code{CEILING(A)} returns the least integer greater than or equal to @var{A}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = CEILING(X [, KIND])} +@code{RESULT = CEILING(A [, KIND])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)}. -@item @var{KIND} @tab (Optional) An @code{INTEGER(*)} initialization - expression indicating the kind parameter of - the result. +@item @var{A} @tab The type shall be @code{REAL}. +@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: -The return value is of type @code{INTEGER(KIND)} +The return value is of type @code{INTEGER(KIND)} if @var{KIND} is present +and a default-kind @code{INTEGER} otherwise. @item @emph{Example}: @smallexample @@ -1890,7 +2262,7 @@ end program test_ceiling @code{CHAR(I [, KIND])} returns the character represented by the integer @var{I}. @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @@ -1900,10 +2272,9 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{I} @tab The type shall be @code{INTEGER(*)}. -@item @var{KIND} @tab (Optional) An @code{INTEGER(*)} initialization - expression indicating the kind parameter of - the result. +@item @var{I} @tab The type shall be @code{INTEGER}. +@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: @@ -1946,7 +2317,7 @@ only one form can be used in any given program unit. GNU extension @item @emph{Class}: -Subroutine, non-elemental function +Subroutine, function @item @emph{Syntax}: @multitable @columnfractions .80 @@ -1956,11 +2327,11 @@ Subroutine, non-elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{NAME} @tab The type shall be @code{CHARACTER(*)} and shall - specify a valid path within the file system. +@item @var{NAME} @tab The type shall be @code{CHARACTER} of default +kind and shall specify a valid path within the file system. @item @var{STATUS} @tab (Optional) @code{INTEGER} status flag of the default - kind. Returns 0 on success, and a system specific - and non-zero error code otherwise. +kind. Returns 0 on success, and a system specific and nonzero error code +otherwise. @end multitable @item @emph{Example}: @@ -1998,7 +2369,7 @@ only one form can be used in any given program unit. GNU extension @item @emph{Class}: -Subroutine, non-elemental function +Subroutine, function @item @emph{Syntax}: @multitable @columnfractions .80 @@ -2008,21 +2379,22 @@ Subroutine, non-elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{NAME} @tab Scalar @code{CHARACTER} with the file name. -Trailing blanks are ignored unless the character @code{achar(0)} is -present, then all characters up to and excluding @code{achar(0)} are -used as the file name. -@item @var{MODE} @tab Scalar @code{CHARACTER} giving the file permission. -@var{MODE} uses the same syntax as the @var{MODE} argument of -@code{/bin/chmod}. +@item @var{NAME} @tab Scalar @code{CHARACTER} of default kind with the +file name. Trailing blanks are ignored unless the character +@code{achar(0)} is present, then all characters up to and excluding +@code{achar(0)} are used as the file name. + +@item @var{MODE} @tab Scalar @code{CHARACTER} of default kind giving the +file permission. @var{MODE} uses the same syntax as the @var{MODE} +argument of @code{/bin/chmod}. @item @var{STATUS} @tab (optional) scalar @code{INTEGER}, which is -@code{0} on success and non-zero otherwise. +@code{0} on success and nonzero otherwise. @end multitable @item @emph{Return value}: -In either syntax, @var{STATUS} is set to @code{0} on success and non-zero +In either syntax, @var{STATUS} is set to @code{0} on success and nonzero otherwise. @item @emph{Example}: @@ -2035,7 +2407,7 @@ program chmod_test print *, 'Status: ', status end program chmod_test @end smallexample -@code{CHMOD} as non-elemental function: +@code{CHMOD} as function: @smallexample program chmod_test implicit none @@ -2063,7 +2435,7 @@ component. If @var{Y} is not present then the imaginary component is set to 0.0. If @var{X} is complex then @var{Y} must not be present. @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @@ -2073,14 +2445,12 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type may be @code{INTEGER(*)}, @code{REAL(*)}, - or @code{COMPLEX(*)}. +@item @var{X} @tab The type may be @code{INTEGER}, @code{REAL}, +or @code{COMPLEX}. @item @var{Y} @tab (Optional; only allowed if @var{X} is not - @code{COMPLEX(*)}.) May be @code{INTEGER(*)} - or @code{REAL(*)}. -@item @var{KIND} @tab (Optional) An @code{INTEGER(*)} initialization - expression indicating the kind parameter of - the result. +@code{COMPLEX}.) May be @code{INTEGER} or @code{REAL}. +@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: @@ -2119,7 +2489,7 @@ end program test_cmplx command line when the containing program was invoked. @item @emph{Standard}: -F2003 +Fortran 2003 and later @item @emph{Class}: Inquiry function @@ -2133,7 +2503,7 @@ Inquiry function @end multitable @item @emph{Return value}: -The return value is of type @code{INTEGER(4)} +The return value is an @code{INTEGER} of default kind. @item @emph{Example}: @smallexample @@ -2173,8 +2543,8 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type may be @code{INTEGER(*)} or @code{REAL(*)}. -@item @var{Y} @tab The type may be @code{INTEGER(*)} or @code{REAL(*)}. +@item @var{X} @tab The type may be @code{INTEGER} or @code{REAL}. +@item @var{Y} @tab The type may be @code{INTEGER} or @code{REAL}. @end multitable @item @emph{Return value}: @@ -2213,7 +2583,7 @@ end program test_complex then the result is @code{(x, -y)} @item @emph{Standard}: -F77 and later, has overloads that are GNU extensions +Fortran 77 and later, has overloads that are GNU extensions @item @emph{Class}: Elemental function @@ -2223,11 +2593,11 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{Z} @tab The type shall be @code{COMPLEX(*)}. +@item @var{Z} @tab The type shall be @code{COMPLEX}. @end multitable @item @emph{Return value}: -The return value is of type @code{COMPLEX(*)}. +The return value is of type @code{COMPLEX}. @item @emph{Example}: @smallexample @@ -2265,7 +2635,7 @@ end program test_conjg @code{COS(X)} computes the cosine of @var{X}. @item @emph{Standard}: -F77 and later, has overloads that are GNU extensions +Fortran 77 and later, has overloads that are GNU extensions @item @emph{Class}: Elemental function @@ -2275,14 +2645,14 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)} or -@code{COMPLEX(*)}. +@item @var{X} @tab The type shall be @code{REAL} or +@code{COMPLEX}. @end multitable @item @emph{Return value}: -The return value is of type @code{REAL(*)} and it lies in the -range @math{ -1 \leq \cos (x) \leq 1}. The kind type -parameter is the same as @var{X}. +The return value is of the same type and kind as @var{X}. The real part +of the result is in radians. If @var{X} is of the type @code{REAL}, +the return value lies in the range @math{ -1 \leq \cos (x) \leq 1}. @item @emph{Example}: @smallexample @@ -2295,8 +2665,8 @@ end program test_cos @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Argument @tab Return type @tab Standard -@item @code{DCOS(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later -@item @code{CCOS(X)} @tab @code{COMPLEX(4) X} @tab @code{COMPLEX(4)} @tab F77 and later +@item @code{DCOS(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab Fortran 77 and later +@item @code{CCOS(X)} @tab @code{COMPLEX(4) X} @tab @code{COMPLEX(4)} @tab Fortran 77 and later @item @code{ZCOS(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab GNU extension @item @code{CDCOS(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab GNU extension @end multitable @@ -2321,7 +2691,7 @@ Inverse function: @ref{ACOS} @code{COSH(X)} computes the hyperbolic cosine of @var{X}. @item @emph{Standard}: -F77 and later +Fortran 77 and later, for a complex argument Fortran 2008 or later @item @emph{Class}: Elemental function @@ -2331,12 +2701,14 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)}. +@item @var{X} @tab The type shall be @code{REAL} or @code{COMPLEX}. @end multitable @item @emph{Return value}: -The return value is of type @code{REAL(*)} and it is positive -(@math{ \cosh (x) \geq 0 }. +The return value has same type and kind as @var{X}. If @var{X} is +complex, the imaginary part of the result is in radians. If @var{X} +is @code{REAL}, the return value has a lower bound of one, +@math{\cosh (x) \geq 1}. @item @emph{Example}: @smallexample @@ -2349,7 +2721,7 @@ end program test_cosh @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Argument @tab Return type @tab Standard -@item @code{DCOSH(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later +@item @code{DCOSH(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab Fortran 77 and later @end multitable @item @emph{See also}: @@ -2368,29 +2740,34 @@ Inverse function: @ref{ACOSH} @table @asis @item @emph{Description}: -@code{COUNT(MASK [, DIM])} counts the number of @code{.TRUE.} elements of -@var{MASK} along the dimension of @var{DIM}. If @var{DIM} is omitted it is -taken to be @code{1}. @var{DIM} is a scaler of type @code{INTEGER} in the -range of @math{1 /leq DIM /leq n)} where @math{n} is the rank of @var{MASK}. + +@code{COUNT(MASK [, DIM [, KIND]])} counts the number of @code{.TRUE.} +elements of @var{MASK} along the dimension of @var{DIM}. If @var{DIM} is +omitted it is taken to be @code{1}. @var{DIM} is a scalar of type +@code{INTEGER} in the range of @math{1 \leq DIM \leq n)} where @math{n} +is the rank of @var{MASK}. @item @emph{Standard}: -F95 and later +Fortran 95 and later, with @var{KIND} argument Fortran 2003 and later @item @emph{Class}: -transformational function +Transformational function @item @emph{Syntax}: -@code{RESULT = COUNT(MASK [, DIM])} +@code{RESULT = COUNT(MASK [, DIM [, KIND]])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 @item @var{MASK} @tab The type shall be @code{LOGICAL}. -@item @var{DIM} @tab The type shall be @code{INTEGER}. +@item @var{DIM} @tab (Optional) The type shall be @code{INTEGER}. +@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: -The return value is of type @code{INTEGER} with rank equal to that of -@var{MASK}. +The return value is of type @code{INTEGER} and of kind @var{KIND}. If +@var{KIND} is absent, the return value is of default integer kind. +The result has a rank equal to that of @var{MASK}. @item @emph{Example}: @smallexample @@ -2427,12 +2804,22 @@ end program test_count @table @asis @item @emph{Description}: -Returns a @code{REAL(*)} value representing the elapsed CPU time in +Returns a @code{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, @var{TIME} is set to +@code{-1.0}. + +Note that @var{TIME} may contain a, system dependent, arbitrary offset +and may not start with @code{0.0}. For @code{CPU_TIME}, the absolute +value is meaningless, only differences between subsequent calls to +this subroutine, as shown in the example below, should be used. + + @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Subroutine @@ -2442,7 +2829,7 @@ Subroutine @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{TIME} @tab The type shall be @code{REAL(*)} with @code{INTENT(OUT)}. +@item @var{TIME} @tab The type shall be @code{REAL} with @code{INTENT(OUT)}. @end multitable @item @emph{Return value}: @@ -2476,25 +2863,25 @@ end program test_cpu_time @item @emph{Description}: @code{CSHIFT(ARRAY, SHIFT [, DIM])} performs a circular shift on elements of @var{ARRAY} along the dimension of @var{DIM}. If @var{DIM} is omitted it is -taken to be @code{1}. @var{DIM} is a scaler of type @code{INTEGER} in the -range of @math{1 /leq DIM /leq n)} where @math{n} is the rank of @var{ARRAY}. +taken to be @code{1}. @var{DIM} is a scalar of type @code{INTEGER} in the +range of @math{1 \leq DIM \leq n)} where @math{n} is the rank of @var{ARRAY}. If the rank of @var{ARRAY} is one, then all elements of @var{ARRAY} are shifted by @var{SHIFT} places. If rank is greater than one, then all complete rank one sections of @var{ARRAY} along the given dimension are shifted. Elements shifted out one end of each rank one section are shifted back in the other end. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: -transformational function +Transformational function @item @emph{Syntax}: -@code{RESULT = CSHIFT(A, SHIFT [, DIM])} +@code{RESULT = CSHIFT(ARRAY, SHIFT [, DIM])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{ARRAY} @tab May be any type, not scaler. +@item @var{ARRAY} @tab Shall be an array of any type. @item @var{SHIFT} @tab The type shall be @code{INTEGER}. @item @var{DIM} @tab The type shall be @code{INTEGER}. @end multitable @@ -2539,7 +2926,7 @@ only one form can be used in any given program unit. GNU extension @item @emph{Class}: -Subroutine +Subroutine, function @item @emph{Syntax}: @multitable @columnfractions .80 @@ -2550,7 +2937,8 @@ Subroutine @item @emph{Arguments}: @multitable @columnfractions .15 .70 @item @var{TIME} @tab The type shall be of type @code{INTEGER(KIND=8)}. -@item @var{RESULT} @tab The type shall be of type @code{CHARACTER}. +@item @var{RESULT} @tab The type shall be of type @code{CHARACTER} and +of default kind. @end multitable @item @emph{Return value}: @@ -2604,10 +2992,10 @@ Unavailable time and date parameters return blanks. @item @tab @code{VALUE(6)}: @tab The minutes of the hour @item @tab @code{VALUE(7)}: @tab The seconds of the minute @item @tab @code{VALUE(8)}: @tab The milliseconds of the second -@end multitable +@end multitable @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Subroutine @@ -2617,9 +3005,12 @@ Subroutine @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{DATE} @tab (Optional) The type shall be @code{CHARACTER(8)} or larger. -@item @var{TIME} @tab (Optional) The type shall be @code{CHARACTER(10)} or larger. -@item @var{ZONE} @tab (Optional) The type shall be @code{CHARACTER(5)} or larger. +@item @var{DATE} @tab (Optional) The type shall be @code{CHARACTER(LEN=8)} +or larger, and of default kind. +@item @var{TIME} @tab (Optional) The type shall be @code{CHARACTER(LEN=10)} +or larger, and of default kind. +@item @var{ZONE} @tab (Optional) The type shall be @code{CHARACTER(LEN=5)} +or larger, and of default kind. @item @var{VALUES}@tab (Optional) The type shall be @code{INTEGER(8)}. @end multitable @@ -2656,21 +3047,21 @@ end program test_time_and_date @table @asis @item @emph{Description}: -@code{DBLE(X)} Converts @var{X} to double precision real type. +@code{DBLE(A)} Converts @var{A} to double precision real type. @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = DBLE(X)} +@code{RESULT = DBLE(A)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{INTEGER(*)}, @code{REAL(*)}, - or @code{COMPLEX(*)}. +@item @var{A} @tab The type shall be @code{INTEGER}, @code{REAL}, +or @code{COMPLEX}. @end multitable @item @emph{Return value}: @@ -2716,10 +3107,10 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type may be @code{INTEGER(*)}, @code{REAL(*)}, - or @code{COMPLEX(*)}. -@item @var{Y} @tab (Optional if @var{X} is not @code{COMPLEX(*)}.) May be - @code{INTEGER(*)} or @code{REAL(*)}. +@item @var{X} @tab The type may be @code{INTEGER}, @code{REAL}, +or @code{COMPLEX}. +@item @var{Y} @tab (Optional if @var{X} is not @code{COMPLEX}.) May be +@code{INTEGER} or @code{REAL}. @end multitable @item @emph{Return value}: @@ -2749,7 +3140,7 @@ end program test_dcmplx @table @asis @item @emph{Description}: -@code{DFLOAT(X)} Converts @var{X} to double precision real type. +@code{DFLOAT(A)} Converts @var{A} to double precision real type. @item @emph{Standard}: GNU extension @@ -2758,11 +3149,11 @@ GNU extension Elemental function @item @emph{Syntax}: -@code{RESULT = DFLOAT(X)} +@code{RESULT = DFLOAT(A)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{INTEGER(*)}. +@item @var{A} @tab The type shall be @code{INTEGER}. @end multitable @item @emph{Return value}: @@ -2783,18 +3174,18 @@ end program test_dfloat @node DIGITS -@section @code{DIGITS} --- Significant digits function +@section @code{DIGITS} --- Significant binary digits function @fnindex DIGITS @cindex model representation, significant digits @table @asis @item @emph{Description}: -@code{DIGITS(X)} returns the number of significant digits of the internal model -representation of @var{X}. For example, on a system using a 32-bit +@code{DIGITS(X)} returns the number of significant binary digits of the internal +model representation of @var{X}. For example, on a system using a 32-bit floating point representation, a default real number would likely return 24. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Inquiry function @@ -2804,7 +3195,7 @@ Inquiry function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type may be @code{INTEGER(*)} or @code{REAL(*)}. +@item @var{X} @tab The type may be @code{INTEGER} or @code{REAL}. @end multitable @item @emph{Return value}: @@ -2838,7 +3229,7 @@ end program test_digits otherwise returns zero. @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @@ -2848,12 +3239,12 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{INTEGER(*)} or @code{REAL(*)} +@item @var{X} @tab The type shall be @code{INTEGER} or @code{REAL} @item @var{Y} @tab The type shall be the same type and kind as @var{X}. @end multitable @item @emph{Return value}: -The return value is of type @code{INTEGER(*)} or @code{REAL(*)}. +The return value is of type @code{INTEGER} or @code{REAL}. @item @emph{Example}: @smallexample @@ -2870,8 +3261,8 @@ end program test_dim @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Argument @tab Return type @tab Standard -@item @code{IDIM(X,Y)} @tab @code{INTEGER(4) X,Y} @tab @code{INTEGER(4)} @tab F77 and later -@item @code{DDIM(X,Y)} @tab @code{REAL(8) X,Y} @tab @code{REAL(8)} @tab F77 and later +@item @code{IDIM(X,Y)} @tab @code{INTEGER(4) X,Y} @tab @code{INTEGER(4)} @tab Fortran 77 and later +@item @code{DDIM(X,Y)} @tab @code{REAL(8) X,Y} @tab @code{REAL(8)} @tab Fortran 77 and later @end multitable @end table @@ -2886,31 +3277,32 @@ end program test_dim @table @asis @item @emph{Description}: -@code{DOT_PRODUCT(X,Y)} computes the dot product multiplication of two vectors -@var{X} and @var{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 -@code{INTEGER(*)} or @code{REAL(*)}, the result is @code{SUM(X*Y)}. If the -vectors are @code{COMPLEX(*)}, the result is @code{SUM(CONJG(X)*Y)}. If the -vectors are @code{LOGICAL}, the result is @code{ANY(X.AND.Y)}. +@code{DOT_PRODUCT(VECTOR_A, VECTOR_B)} computes the dot product multiplication +of two vectors @var{VECTOR_A} and @var{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 @code{INTEGER} or @code{REAL}, the result is +@code{SUM(VECTOR_A*VECTOR_B)}. If the vectors are @code{COMPLEX}, the result +is @code{SUM(CONJG(VECTOR_A)*VECTOR_B)}. If the vectors are @code{LOGICAL}, +the result is @code{ANY(VECTOR_A .AND. VECTOR_B)}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: -transformational function +Transformational function @item @emph{Syntax}: -@code{RESULT = DOT_PRODUCT(X, Y)} +@code{RESULT = DOT_PRODUCT(VECTOR_A, VECTOR_B)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be numeric or @code{LOGICAL}, rank 1. -@item @var{Y} @tab The type shall be numeric or @code{LOGICAL}, rank 1. +@item @var{VECTOR_A} @tab The type shall be numeric or @code{LOGICAL}, rank 1. +@item @var{VECTOR_B} @tab The type shall be numeric if @var{VECTOR_A} is of numeric type or @code{LOGICAL} if @var{VECTOR_A} is of type @code{LOGICAL}. @var{VECTOR_B} shall be a rank-one array. @end multitable @item @emph{Return value}: -If the arguments are numeric, the return value is a scaler of numeric type, -@code{INTEGER(*)}, @code{REAL(*)}, or @code{COMPLEX(*)}. If the arguments are +If the arguments are numeric, the return value is a scalar of numeric type, +@code{INTEGER}, @code{REAL}, or @code{COMPLEX}. If the arguments are @code{LOGICAL}, the return value is @code{.TRUE.} or @code{.FALSE.}. @item @emph{Example}: @@ -2940,7 +3332,7 @@ end program test_dot_prod @code{DPROD(X,Y)} returns the product @code{X*Y}. @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @@ -2987,11 +3379,11 @@ GNU extension Elemental function @item @emph{Syntax}: -@code{RESULT = DREAL(Z)} +@code{RESULT = DREAL(A)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{Z} @tab The type shall be @code{COMPLEX(8)}. +@item @var{A} @tab The type shall be @code{COMPLEX(8)}. @end multitable @item @emph{Return value}: @@ -3020,11 +3412,11 @@ end program test_dreal @table @asis @item @emph{Description}: -@code{DTIME(TARRAY, RESULT)} initially returns the number of seconds of runtime -since the start of the process's execution in @var{RESULT}. @var{TARRAY} -returns the user and system components of this time in @code{TARRAY(1)} and -@code{TARRAY(2)} respectively. @var{RESULT} is equal to @code{TARRAY(1) + -TARRAY(2)}. +@code{DTIME(VALUES, TIME)} initially returns the number of seconds of runtime +since the start of the process's execution in @var{TIME}. @var{VALUES} +returns the user and system components of this time in @code{VALUES(1)} and +@code{VALUES(2)} respectively. @var{TIME} is equal to @code{VALUES(1) + +VALUES(2)}. Subsequent invocations of @code{DTIME} return values accumulated since the previous invocation. @@ -3035,37 +3427,44 @@ sufficiently small limits that overflows (wrap around) are possible, such as become, negative, or numerically less than previous values, during a single run of the compiled program. -If @code{DTIME} is invoked as a function, it can not be invoked as a -subroutine, and vice versa. +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 @code{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 @code{CPU_TIME} instead. -@var{TARRAY} and @var{RESULT} are @code{INTENT(OUT)} and provide the following: +This intrinsic is provided in both subroutine and function forms; however, +only one form can be used in any given program unit. + +@var{VALUES} and @var{TIME} are @code{INTENT(OUT)} and provide the following: @multitable @columnfractions .15 .30 .40 -@item @tab @code{TARRAY(1)}: @tab User time in seconds. -@item @tab @code{TARRAY(2)}: @tab System time in seconds. -@item @tab @code{RESULT}: @tab Run time since start in seconds. +@item @tab @code{VALUES(1)}: @tab User time in seconds. +@item @tab @code{VALUES(2)}: @tab System time in seconds. +@item @tab @code{TIME}: @tab Run time since start in seconds. @end multitable @item @emph{Standard}: GNU extension @item @emph{Class}: -Subroutine +Subroutine, function @item @emph{Syntax}: @multitable @columnfractions .80 -@item @code{CALL DTIME(TARRAY, RESULT)}. -@item @code{RESULT = DTIME(TARRAY)}, (not recommended). +@item @code{CALL DTIME(VALUES, TIME)}. +@item @code{TIME = DTIME(VALUES)}, (not recommended). @end multitable @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{TARRAY}@tab The type shall be @code{REAL, DIMENSION(2)}. -@item @var{RESULT}@tab The type shall be @code{REAL}. +@item @var{VALUES}@tab The type shall be @code{REAL(4), DIMENSION(2)}. +@item @var{TIME}@tab The type shall be @code{REAL(4)}. @end multitable @item @emph{Return value}: -Elapsed time in seconds since the start of program execution. +Elapsed time in seconds since the last invocation or since the start of program +execution if not called before. @item @emph{Example}: @smallexample @@ -3086,6 +3485,10 @@ program test_dtime print *, tarray(2) end program test_dtime @end smallexample + +@item @emph{See also}: +@ref{CPU_TIME} + @end table @@ -3097,10 +3500,10 @@ end program test_dtime @table @asis @item @emph{Description}: -@code{EOSHIFT(ARRAY, SHIFT[,BOUNDARY, DIM])} performs an end-off shift on +@code{EOSHIFT(ARRAY, SHIFT[, BOUNDARY, DIM])} performs an end-off shift on elements of @var{ARRAY} along the dimension of @var{DIM}. If @var{DIM} is -omitted it is taken to be @code{1}. @var{DIM} is a scaler of type -@code{INTEGER} in the range of @math{1 /leq DIM /leq n)} where @math{n} is the +omitted it is taken to be @code{1}. @var{DIM} is a scalar of type +@code{INTEGER} in the range of @math{1 \leq DIM \leq n)} where @math{n} is the rank of @var{ARRAY}. If the rank of @var{ARRAY} is one, then all elements of @var{ARRAY} are shifted by @var{SHIFT} places. If rank is greater than one, then all complete rank one sections of @var{ARRAY} along the given dimension are @@ -3117,17 +3520,17 @@ following are copied in depending on the type of @var{ARRAY}. @end multitable @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: -transformational function +Transformational function @item @emph{Syntax}: -@code{RESULT = EOSHIFT(A, SHIFT [, BOUNDARY, DIM])} +@code{RESULT = EOSHIFT(ARRAY, SHIFT [, BOUNDARY, DIM])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{ARRAY} @tab May be any type, not scaler. +@item @var{ARRAY} @tab May be any type, not scalar. @item @var{SHIFT} @tab The type shall be @code{INTEGER}. @item @var{BOUNDARY} @tab Same type as @var{ARRAY}. @item @var{DIM} @tab The type shall be @code{INTEGER}. @@ -3162,10 +3565,11 @@ end program test_eoshift @table @asis @item @emph{Description}: -@code{EPSILON(X)} returns a nearly negligible number relative to @code{1}. +@code{EPSILON(X)} returns the smallest number @var{E} of the same kind +as @var{X} such that @math{1 + E > 1}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Inquiry function @@ -3175,7 +3579,7 @@ Inquiry function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)}. +@item @var{X} @tab The type shall be @code{REAL}. @end multitable @item @emph{Return value}: @@ -3204,7 +3608,7 @@ end program test_epsilon @code{ERF(X)} computes the error function of @var{X}. @item @emph{Standard}: -GNU Extension +Fortran 2008 and later @item @emph{Class}: Elemental function @@ -3214,12 +3618,12 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar. +@item @var{X} @tab The type shall be @code{REAL}. @end multitable @item @emph{Return value}: -The return value is a scalar of type @code{REAL(*)} and it is positive -(@math{ - 1 \leq erf (x) \leq 1 }. +The return value is of type @code{REAL}, of the same kind as +@var{X} and lies in the range @math{-1 \leq erf (x) \leq 1 }. @item @emph{Example}: @smallexample @@ -3248,7 +3652,7 @@ end program test_erf @code{ERFC(X)} computes the complementary error function of @var{X}. @item @emph{Standard}: -GNU extension +Fortran 2008 and later @item @emph{Class}: Elemental function @@ -3258,12 +3662,12 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar. +@item @var{X} @tab The type shall be @code{REAL}. @end multitable @item @emph{Return value}: -The return value is a scalar of type @code{REAL(*)} and it is positive -(@math{ 0 \leq erfc (x) \leq 2 }. +The return value is of type @code{REAL} and of the same kind as @var{X}. +It lies in the range @math{ 0 \leq erfc (x) \leq 2 }. @item @emph{Example}: @smallexample @@ -3282,6 +3686,44 @@ end program test_erfc +@node ERFC_SCALED +@section @code{ERFC_SCALED} --- Error function +@fnindex ERFC_SCALED +@cindex error function, complementary, exponentially-scaled + +@table @asis +@item @emph{Description}: +@code{ERFC_SCALED(X)} computes the exponentially-scaled complementary +error function of @var{X}. + +@item @emph{Standard}: +Fortran 2008 and later + +@item @emph{Class}: +Elemental function + +@item @emph{Syntax}: +@code{RESULT = ERFC_SCALED(X)} + +@item @emph{Arguments}: +@multitable @columnfractions .15 .70 +@item @var{X} @tab The type shall be @code{REAL}. +@end multitable + +@item @emph{Return value}: +The return value is of type @code{REAL} and of the same kind as @var{X}. + +@item @emph{Example}: +@smallexample +program test_erfc_scaled + real(8) :: x = 0.17_8 + x = erfc_scaled(x) +end program test_erfc_scaled +@end smallexample +@end table + + + @node ETIME @section @code{ETIME} --- Execution time subroutine (or function) @fnindex ETIME @@ -3289,10 +3731,10 @@ end program test_erfc @table @asis @item @emph{Description}: -@code{ETIME(TARRAY, RESULT)} returns the number of seconds of runtime -since the start of the process's execution in @var{RESULT}. @var{TARRAY} -returns the user and system components of this time in @code{TARRAY(1)} and -@code{TARRAY(2)} respectively. @var{RESULT} is equal to @code{TARRAY(1) + TARRAY(2)}. +@code{ETIME(VALUES, TIME)} returns the number of seconds of runtime +since the start of the process's execution in @var{TIME}. @var{VALUES} +returns the user and system components of this time in @code{VALUES(1)} and +@code{VALUES(2)} respectively. @var{TIME} is equal to @code{VALUES(1) + VALUES(2)}. On some systems, the underlying timings are represented using types with sufficiently small limits that overflows (wrap around) are possible, such as @@ -3300,33 +3742,33 @@ sufficiently small limits that overflows (wrap around) are possible, such as become, negative, or numerically less than previous values, during a single run of the compiled program. -If @code{ETIME} is invoked as a function, it can not be invoked as a -subroutine, and vice versa. +This intrinsic is provided in both subroutine and function forms; however, +only one form can be used in any given program unit. -@var{TARRAY} and @var{RESULT} are @code{INTENT(OUT)} and provide the following: +@var{VALUES} and @var{TIME} are @code{INTENT(OUT)} and provide the following: @multitable @columnfractions .15 .30 .60 -@item @tab @code{TARRAY(1)}: @tab User time in seconds. -@item @tab @code{TARRAY(2)}: @tab System time in seconds. -@item @tab @code{RESULT}: @tab Run time since start in seconds. +@item @tab @code{VALUES(1)}: @tab User time in seconds. +@item @tab @code{VALUES(2)}: @tab System time in seconds. +@item @tab @code{TIME}: @tab Run time since start in seconds. @end multitable @item @emph{Standard}: GNU extension @item @emph{Class}: -Subroutine +Subroutine, function @item @emph{Syntax}: @multitable @columnfractions .80 -@item @code{CALL ETIME(TARRAY, RESULT)}. -@item @code{RESULT = ETIME(TARRAY)}, (not recommended). +@item @code{CALL ETIME(VALUES, TIME)}. +@item @code{TIME = ETIME(VALUES)}, (not recommended). @end multitable @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{TARRAY}@tab The type shall be @code{REAL, DIMENSION(2)}. -@item @var{RESULT}@tab The type shall be @code{REAL}. +@item @var{VALUES}@tab The type shall be @code{REAL(4), DIMENSION(2)}. +@item @var{TIME}@tab The type shall be @code{REAL(4)}. @end multitable @item @emph{Return value}: @@ -3418,7 +3860,7 @@ end program test_exit @code{EXP(X)} computes the base @math{e} exponential of @var{X}. @item @emph{Standard}: -F77 and later, has overloads that are GNU extensions +Fortran 77 and later, has overloads that are GNU extensions @item @emph{Class}: Elemental function @@ -3428,8 +3870,8 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)} or -@code{COMPLEX(*)}. +@item @var{X} @tab The type shall be @code{REAL} or +@code{COMPLEX}. @end multitable @item @emph{Return value}: @@ -3446,8 +3888,8 @@ end program test_exp @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Argument @tab Return type @tab Standard -@item @code{DEXP(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later -@item @code{CEXP(X)} @tab @code{COMPLEX(4) X} @tab @code{COMPLEX(4)} @tab F77 and later +@item @code{DEXP(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab Fortran 77 and later +@item @code{CEXP(X)} @tab @code{COMPLEX(4) X} @tab @code{COMPLEX(4)} @tab Fortran 77 and later @item @code{ZEXP(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab GNU extension @item @code{CDEXP(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab GNU extension @end multitable @@ -3467,7 +3909,7 @@ end program test_exp is zero the value returned is zero. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @@ -3477,7 +3919,7 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)}. +@item @var{X} @tab The type shall be @code{REAL}. @end multitable @item @emph{Return value}: @@ -3511,16 +3953,17 @@ end program test_exponent @code{CTIME}) in @var{DATE}. It is equivalent to @code{CALL CTIME(DATE, TIME())}. -If @code{FDATE} is invoked as a function, it can not be invoked as a -subroutine, and vice versa. +This intrinsic is provided in both subroutine and function forms; however, +only one form can be used in any given program unit. -@var{DATE} is an @code{INTENT(OUT)} @code{CHARACTER} variable. +@var{DATE} is an @code{INTENT(OUT)} @code{CHARACTER} variable of the +default kind. @item @emph{Standard}: GNU extension @item @emph{Class}: -Subroutine +Subroutine, function @item @emph{Syntax}: @multitable @columnfractions .80 @@ -3530,7 +3973,8 @@ Subroutine @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{DATE}@tab The type shall be of type @code{CHARACTER}. +@item @var{DATE}@tab The type shall be of type @code{CHARACTER} of the +default kind @end multitable @item @emph{Return value}: @@ -3561,20 +4005,20 @@ end program test_fdate @table @asis @item @emph{Description}: -@code{FLOAT(I)} converts the integer @var{I} to a default real value. +@code{FLOAT(A)} converts the integer @var{A} to a default real value. @item @emph{Standard}: -GNU extension +Fortran 77 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = FLOAT(I)} +@code{RESULT = FLOAT(A)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{I} @tab The type shall be @code{INTEGER(*)}. +@item @var{A} @tab The type shall be @code{INTEGER}. @end multitable @item @emph{Return value}: @@ -3607,7 +4051,10 @@ 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 routine is provided for backwards compatibility with +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 @code{FGET} intrinsic is provided for backwards compatibility with @command{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 @ref{Fortran 2003 status}. @@ -3616,17 +4063,18 @@ for future portability. See also @ref{Fortran 2003 status}. GNU extension @item @emph{Class}: -Non-elemental subroutine +Subroutine, function @item @emph{Syntax}: @code{CALL FGET(C [, STATUS])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{C} @tab The type shall be @code{CHARACTER}. +@item @var{C} @tab The type shall be @code{CHARACTER} and of default +kind. @item @var{STATUS} @tab (Optional) status flag of type @code{INTEGER}. - Returns 0 on success, -1 on end-of-file, and a - system specific positive error code otherwise. +Returns 0 on success, -1 on end-of-file, and a system specific positive +error code otherwise. @end multitable @item @emph{Example}: @@ -3665,8 +4113,11 @@ 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 routine is provided for backwards compatibility with -@command{g77}. GNU Fortran provides the Fortran 2003 Stream facility. +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 @code{FGET} intrinsic is provided for backwards compatibility +with @command{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 @ref{Fortran 2003 status}. @@ -3674,7 +4125,7 @@ for future portability. See also @ref{Fortran 2003 status}. GNU extension @item @emph{Class}: -Non-elemental subroutine +Subroutine, function @item @emph{Syntax}: @code{CALL FGETC(UNIT, C [, STATUS])} @@ -3682,9 +4133,11 @@ Non-elemental subroutine @item @emph{Arguments}: @multitable @columnfractions .15 .70 @item @var{UNIT} @tab The type shall be @code{INTEGER}. -@item @var{C} @tab The type shall be @code{CHARACTER}. -@item @var{STATUS} @tab (Optional) status flag of type @code{INTEGER}. Returns 0 on success, - -1 on end-of-file and a system specific positive error code otherwise. +@item @var{C} @tab The type shall be @code{CHARACTER} and of default +kind. +@item @var{STATUS} @tab (Optional) status flag of type @code{INTEGER}. +Returns 0 on success, -1 on end-of-file and a system specific positive +error code otherwise. @end multitable @item @emph{Example}: @@ -3717,27 +4170,27 @@ END PROGRAM @table @asis @item @emph{Description}: -@code{FLOOR(X)} returns the greatest integer less than or equal to @var{X}. +@code{FLOOR(A)} returns the greatest integer less than or equal to @var{X}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = FLOOR(X [, KIND])} +@code{RESULT = FLOOR(A [, KIND])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)}. -@item @var{KIND} @tab (Optional) An @code{INTEGER(*)} initialization - expression indicating the kind parameter of - the result. +@item @var{A} @tab The type shall be @code{REAL}. +@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: -The return value is of type @code{INTEGER(KIND)} +The return value is of type @code{INTEGER(KIND)} if @var{KIND} is present +and of default-kind @code{INTEGER} otherwise. @item @emph{Example}: @smallexample @@ -3770,7 +4223,7 @@ argument, all units are flushed, otherwise just the unit specified. GNU extension @item @emph{Class}: -Non-elemental subroutine +Subroutine @item @emph{Syntax}: @code{CALL FLUSH(UNIT)} @@ -3802,7 +4255,7 @@ open Fortran I/O unit @code{UNIT}. GNU extension @item @emph{Class}: -Non-elemental function +Function @item @emph{Syntax}: @code{RESULT = FNUM(UNIT)} @@ -3842,7 +4295,10 @@ 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 routine is provided for backwards compatibility with +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 @code{FGET} intrinsic is provided for backwards compatibility with @command{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 @ref{Fortran 2003 status}. @@ -3851,16 +4307,18 @@ for future portability. See also @ref{Fortran 2003 status}. GNU extension @item @emph{Class}: -Non-elemental subroutine +Subroutine, function @item @emph{Syntax}: @code{CALL FPUT(C [, STATUS])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{C} @tab The type shall be @code{CHARACTER}. -@item @var{STATUS} @tab (Optional) status flag of type @code{INTEGER}. Returns 0 on success, - -1 on end-of-file and a system specific positive error code otherwise. +@item @var{C} @tab The type shall be @code{CHARACTER} and of default +kind. +@item @var{STATUS} @tab (Optional) status flag of type @code{INTEGER}. +Returns 0 on success, -1 on end-of-file and a system specific positive +error code otherwise. @end multitable @item @emph{Example}: @@ -3893,7 +4351,10 @@ 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 routine is provided for backwards compatibility with +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 @code{FGET} intrinsic is provided for backwards compatibility with @command{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 @ref{Fortran 2003 status}. @@ -3902,7 +4363,7 @@ for future portability. See also @ref{Fortran 2003 status}. GNU extension @item @emph{Class}: -Non-elemental subroutine +Subroutine, function @item @emph{Syntax}: @code{CALL FPUTC(UNIT, C [, STATUS])} @@ -3910,9 +4371,11 @@ Non-elemental subroutine @item @emph{Arguments}: @multitable @columnfractions .15 .70 @item @var{UNIT} @tab The type shall be @code{INTEGER}. -@item @var{C} @tab The type shall be @code{CHARACTER}. -@item @var{STATUS} @tab (Optional) status flag of type @code{INTEGER}. Returns 0 on success, - -1 on end-of-file and a system specific positive error code otherwise. +@item @var{C} @tab The type shall be @code{CHARACTER} and of default +kind. +@item @var{STATUS} @tab (Optional) status flag of type @code{INTEGER}. +Returns 0 on success, -1 on end-of-file and a system specific positive +error code otherwise. @end multitable @item @emph{Example}: @@ -3947,7 +4410,7 @@ END PROGRAM representation of @code{X}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @@ -4030,7 +4493,7 @@ Moves @var{UNIT} to the specified @var{OFFSET}. If @var{WHENCE} is set to 0, the @var{OFFSET} is taken as an absolute value @code{SEEK_SET}, if set to 1, @var{OFFSET} is taken to be relative to the current position @code{SEEK_CUR}, and if set to 2 relative to the end of the file @code{SEEK_END}. -On error, @var{STATUS} is set to a non-zero value. If @var{STATUS} the seek +On error, @var{STATUS} is set to a nonzero value. If @var{STATUS} the seek fails silently. This intrinsic routine is not fully backwards compatible with @command{g77}. @@ -4109,23 +4572,26 @@ END PROGRAM @code{FSTAT} is identical to @ref{STAT}, except that information about an already opened file is obtained. -The elements in @code{BUFF} are the same as described by @ref{STAT}. +The elements in @code{VALUES} are the same as described by @ref{STAT}. + +This intrinsic is provided in both subroutine and function forms; however, +only one form can be used in any given program unit. @item @emph{Standard}: GNU extension @item @emph{Class}: -Non-elemental subroutine +Subroutine, function @item @emph{Syntax}: -@code{CALL FSTAT(UNIT, BUFF [, STATUS])} +@code{CALL FSTAT(UNIT, VALUES [, STATUS])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 @item @var{UNIT} @tab An open I/O unit number of type @code{INTEGER}. -@item @var{BUFF} @tab The type shall be @code{INTEGER(4), DIMENSION(13)}. +@item @var{VALUES} @tab The type shall be @code{INTEGER(4), DIMENSION(13)}. @item @var{STATUS} @tab (Optional) status flag of type @code{INTEGER(4)}. Returns 0 - on success and a system specific error code otherwise. +on success and a system specific error code otherwise. @end multitable @item @emph{Example}: @@ -4187,6 +4653,65 @@ END PROGRAM +@node GAMMA +@section @code{GAMMA} --- Gamma function +@fnindex GAMMA +@fnindex DGAMMA +@cindex Gamma function +@cindex Factorial function + +@table @asis +@item @emph{Description}: +@code{GAMMA(X)} computes Gamma (@math{\Gamma}) of @var{X}. For positive, +integer values of @var{X} the Gamma function simplifies to the factorial +function @math{\Gamma(x)=(x-1)!}. + +@tex +$$ +\Gamma(x) = \int_0^\infty t^{x-1}{\rm e}^{-t}\,{\rm d}t +$$ +@end tex + +@item @emph{Standard}: +Fortran 2008 and later + +@item @emph{Class}: +Elemental function + +@item @emph{Syntax}: +@code{X = GAMMA(X)} + +@item @emph{Arguments}: +@multitable @columnfractions .15 .70 +@item @var{X} @tab Shall be of type @code{REAL} and neither zero +nor a negative integer. +@end multitable + +@item @emph{Return value}: +The return value is of type @code{REAL} of the same kind as @var{X}. + +@item @emph{Example}: +@smallexample +program test_gamma + real :: x = 1.0 + x = gamma(x) ! returns 1.0 +end program test_gamma +@end smallexample + +@item @emph{Specific names}: +@multitable @columnfractions .20 .20 .20 .25 +@item Name @tab Argument @tab Return type @tab Standard +@item @code{GAMMA(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab GNU Extension +@item @code{DGAMMA(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab GNU Extension +@end multitable + +@item @emph{See also}: +Logarithm of the Gamma function: @ref{LOG_GAMMA} + +@end table + + + @node GERROR @section @code{GERROR} --- Get last system error message @fnindex GERROR @@ -4208,7 +4733,7 @@ Subroutine @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{RESULT} @tab Shall of type @code{CHARACTER(*)}. +@item @var{RESULT} @tab Shall of type @code{CHARACTER} and of default @end multitable @item @emph{Example}: @@ -4234,7 +4759,7 @@ END PROGRAM @table @asis @item @emph{Description}: -Retrieve the @var{N}th argument that was passed on the +Retrieve the @var{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 @@ -4249,21 +4774,24 @@ GNU extension Subroutine @item @emph{Syntax}: -@code{CALL GETARG(N, ARG)} +@code{CALL GETARG(POS, VALUE)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{N} @tab Shall be of type @code{INTEGER(4)}, @math{@var{N} \geq 0} -@item @var{ARG} @tab Shall be of type @code{CHARACTER(*)}. +@item @var{POS} @tab Shall be of type @code{INTEGER} and not wider than +the default integer kind; @math{@var{POS} \geq 0} +@item @var{VALUE} @tab Shall be of type @code{CHARACTER} and of default +kind. +@item @var{VALUE} @tab Shall be of type @code{CHARACTER}. @end multitable @item @emph{Return value}: -After @code{GETARG} returns, the @var{ARG} argument holds the @var{N}th -command line argument. If @var{ARG} can not hold the argument, it is -truncated to fit the length of @var{ARG}. If there are less than @var{N} -arguments specified at the command line, @var{ARG} will be filled with blanks. -If @math{@var{N} = 0}, @var{ARG} is set to the name of the program (on systems -that support this feature). +After @code{GETARG} returns, the @var{VALUE} argument holds the +@var{POS}th command line argument. If @var{VALUE} can not hold the +argument, it is truncated to fit the length of @var{VALUE}. If there are +less than @var{POS} arguments specified at the command line, @var{VALUE} +will be filled with blanks. If @math{@var{POS} = 0}, @var{VALUE} is set +to the name of the program (on systems that support this feature). @item @emph{Example}: @smallexample @@ -4281,8 +4809,8 @@ END PROGRAM @item @emph{See also}: GNU Fortran 77 compatibility function: @ref{IARGC} -F2003 functions and subroutines: @ref{GET_COMMAND}, @ref{GET_COMMAND_ARGUMENT}, -@ref{COMMAND_ARGUMENT_COUNT} +Fortran 2003 functions and subroutines: @ref{GET_COMMAND}, +@ref{GET_COMMAND_ARGUMENT}, @ref{COMMAND_ARGUMENT_COUNT} @end table @@ -4298,22 +4826,30 @@ F2003 functions and subroutines: @ref{GET_COMMAND}, @ref{GET_COMMAND_ARGUMENT}, Retrieve the entire command line that was used to invoke the program. @item @emph{Standard}: -F2003 +Fortran 2003 and later @item @emph{Class}: Subroutine @item @emph{Syntax}: -@code{CALL GET_COMMAND(CMD)} +@code{CALL GET_COMMAND([COMMAND, LENGTH, STATUS])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{CMD} @tab Shall be of type @code{CHARACTER(*)}. +@item @var{COMMAND} @tab (Optional) shall be of type @code{CHARACTER} and +of default kind. +@item @var{LENGTH} @tab (Optional) Shall be of type @code{INTEGER} and of +default kind. +@item @var{STATUS} @tab (Optional) Shall be of type @code{INTEGER} and of +default kind. @end multitable @item @emph{Return value}: -Stores the entire command line that was used to invoke the program in @var{ARG}. -If @var{ARG} is not large enough, the command will be truncated. +If @var{COMMAND} is present, stores the entire command line that was used +to invoke the program in @var{COMMAND}. If @var{LENGTH} is present, it is +assigned the length of the command line. If @var{STATUS} is present, it +is assigned 0 upon success of the command, -1 if @var{COMMAND} is too +short to store the command line, or a positive value in case of an error. @item @emph{Example}: @smallexample @@ -4338,31 +4874,41 @@ END PROGRAM @table @asis @item @emph{Description}: -Retrieve the @var{N}th argument that was passed on the +Retrieve the @var{NUMBER}-th argument that was passed on the command line when the containing program was invoked. @item @emph{Standard}: -F2003 +Fortran 2003 and later @item @emph{Class}: Subroutine @item @emph{Syntax}: -@code{CALL GET_COMMAND_ARGUMENT(N, ARG)} +@code{CALL GET_COMMAND_ARGUMENT(NUMBER [, VALUE, LENGTH, STATUS])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{N} @tab Shall be of type @code{INTEGER(4)}, @math{@var{N} \geq 0} -@item @var{ARG} @tab Shall be of type @code{CHARACTER(*)}. +@item @var{NUMBER} @tab Shall be a scalar of type @code{INTEGER} and of +default kind, @math{@var{NUMBER} \geq 0} +@item @var{VALUE} @tab Shall be a scalar of type @code{CHARACTER} +and of default kind. +@item @var{LENGTH} @tab (Option) Shall be a scalar of type @code{INTEGER} +and of default kind. +@item @var{STATUS} @tab (Option) Shall be a scalar of type @code{INTEGER} +and of default kind. @end multitable @item @emph{Return value}: -After @code{GET_COMMAND_ARGUMENT} returns, the @var{ARG} argument holds the -@var{N}th command line argument. If @var{ARG} can not hold the argument, it is -truncated to fit the length of @var{ARG}. If there are less than @var{N} -arguments specified at the command line, @var{ARG} will be filled with blanks. -If @math{@var{N} = 0}, @var{ARG} is set to the name of the program (on systems -that support this feature). +After @code{GET_COMMAND_ARGUMENT} returns, the @var{VALUE} argument holds the +@var{NUMBER}-th command line argument. If @var{VALUE} can not hold the argument, it is +truncated to fit the length of @var{VALUE}. If there are less than @var{NUMBER} +arguments specified at the command line, @var{VALUE} will be filled with blanks. +If @math{@var{NUMBER} = 0}, @var{VALUE} is set to the name of the program (on +systems that support this feature). The @var{LENGTH} argument contains the +length of the @var{NUMBER}-th command line argument. If the argument retrieval +fails, @var{STATUS} is a positive number; if @var{VALUE} contains a truncated +command line argument, @var{STATUS} is -1; and otherwise the @var{STATUS} is +zero. @item @emph{Example}: @smallexample @@ -4396,20 +4942,23 @@ END PROGRAM @item @emph{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. + @item @emph{Standard}: GNU extension @item @emph{Class}: -Non-elemental subroutine. +Subroutine, function @item @emph{Syntax}: -@code{CALL GETCWD(CWD [, STATUS])} +@code{CALL GETCWD(C [, STATUS])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{CWD} @tab The type shall be @code{CHARACTER(*)}. +@item @var{C} @tab The type shall be @code{CHARACTER} and of default kind. @item @var{STATUS} @tab (Optional) status flag. Returns 0 on success, - a system specific and non-zero error code otherwise. +a system specific and nonzero error code otherwise. @end multitable @item @emph{Example}: @@ -4434,7 +4983,7 @@ END PROGRAM @table @asis @item @emph{Description}: -Get the @var{VALUE} of the environmental variable @var{ENVVAR}. +Get the @var{VALUE} of the environmental variable @var{NAME}. This intrinsic routine is provided for backwards compatibility with GNU Fortran 77. In new code, programmers should consider the use of @@ -4448,17 +4997,17 @@ GNU extension Subroutine @item @emph{Syntax}: -@code{CALL GETENV(ENVVAR, VALUE)} +@code{CALL GETENV(NAME, VALUE)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{ENVVAR} @tab Shall be of type @code{CHARACTER(*)}. -@item @var{VALUE} @tab Shall be of type @code{CHARACTER(*)}. +@item @var{NAME} @tab Shall be of type @code{CHARACTER} and of default kind. +@item @var{VALUE} @tab Shall be of type @code{CHARACTER} and of default kind. @end multitable @item @emph{Return value}: -Stores the value of @var{ENVVAR} in @var{VALUE}. If @var{VALUE} is -not large enough to hold the data, it is truncated. If @var{ENVVAR} +Stores the value of @var{NAME} in @var{VALUE}. If @var{VALUE} is +not large enough to hold the data, it is truncated. If @var{NAME} is not set, @var{VALUE} will be filled with blanks. @item @emph{Example}: @@ -4483,27 +5032,43 @@ END PROGRAM @table @asis @item @emph{Description}: -Get the @var{VALUE} of the environmental variable @var{ENVVAR}. +Get the @var{VALUE} of the environmental variable @var{NAME}. @item @emph{Standard}: -F2003 +Fortran 2003 and later @item @emph{Class}: Subroutine @item @emph{Syntax}: -@code{CALL GET_ENVIRONMENT_VARIABLE(ENVVAR, VALUE)} +@code{CALL GET_ENVIRONMENT_VARIABLE(NAME[, VALUE, LENGTH, STATUS, TRIM_NAME)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{ENVVAR} @tab Shall be of type @code{CHARACTER(*)}. -@item @var{VALUE} @tab Shall be of type @code{CHARACTER(*)}. +@item @var{NAME} @tab Shall be a scalar of type @code{CHARACTER} +and of default kind. +@item @var{VALUE} @tab Shall be a scalar of type @code{CHARACTER} +and of default kind. +@item @var{LENGTH} @tab Shall be a scalar of type @code{INTEGER} +and of default kind. +@item @var{STATUS} @tab Shall be a scalar of type @code{INTEGER} +and of default kind. +@item @var{TRIM_NAME} @tab Shall be a scalar of type @code{LOGICAL} +and of default kind. @end multitable @item @emph{Return value}: -Stores the value of @var{ENVVAR} in @var{VALUE}. If @var{VALUE} is -not large enough to hold the data, it is truncated. If @var{ENVVAR} -is not set, @var{VALUE} will be filled with blanks. +Stores the value of @var{NAME} in @var{VALUE}. If @var{VALUE} is +not large enough to hold the data, it is truncated. If @var{NAME} +is not set, @var{VALUE} will be filled with blanks. Argument @var{LENGTH} +contains the length needed for storing the environment variable @var{NAME} +or zero if it is not present. @var{STATUS} is -1 if @var{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 @var{STATUS} is zero. If @var{TRIM_NAME} is +present with the value @code{.FALSE.}, the trailing blanks in @var{NAME} +are significant; otherwise they are not part of the environment variable +name. @item @emph{Example}: @smallexample @@ -4530,7 +5095,7 @@ Returns the numerical group ID of the current process. GNU extension @item @emph{Class}: -function +Function @item @emph{Syntax}: @code{RESULT = GETGID()} @@ -4566,11 +5131,11 @@ GNU extension Subroutine @item @emph{Syntax}: -@code{CALL GETLOG(LOGIN)} +@code{CALL GETLOG(C)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{LOGIN} @tab Shall be of type @code{CHARACTER(*)}. +@item @var{C} @tab Shall be of type @code{CHARACTER} and of default kind. @end multitable @item @emph{Return value}: @@ -4608,7 +5173,7 @@ Returns the numerical process identifier of the current process. GNU extension @item @emph{Class}: -function +Function @item @emph{Syntax}: @code{RESULT = GETPID()} @@ -4647,7 +5212,7 @@ Returns the numerical user ID of the current process. GNU extension @item @emph{Class}: -function +Function @item @emph{Syntax}: @code{RESULT = GETUID()} @@ -4673,8 +5238,8 @@ See @code{GETPID} for an example. @table @asis @item @emph{Description}: -Given a system time value @var{STIME} (as provided by the @code{TIME8()} -intrinsic), fills @var{TARRAY} with values extracted from it appropriate +Given a system time value @var{TIME} (as provided by the @code{TIME8()} +intrinsic), fills @var{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 @code{gmtime(3)}. @@ -4685,22 +5250,21 @@ GNU extension Subroutine @item @emph{Syntax}: -@code{CALL GMTIME(STIME, TARRAY)} +@code{CALL GMTIME(TIME, VALUES)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{STIME} @tab An @code{INTEGER(*)} scalar expression - corresponding to a system time, with - @code{INTENT(IN)}. -@item @var{TARRAY} @tab A default @code{INTEGER} array with 9 elements, - with @code{INTENT(OUT)}. +@item @var{TIME} @tab An @code{INTEGER} scalar expression +corresponding to a system time, with @code{INTENT(IN)}. +@item @var{VALUES} @tab A default @code{INTEGER} array with 9 elements, +with @code{INTENT(OUT)}. @end multitable @item @emph{Return value}: -The elements of @var{TARRAY} are assigned as follows: +The elements of @var{VALUES} are assigned as follows: @enumerate @item Seconds after the minute, range 0--59 or 0--61 to allow for leap - seconds +seconds @item Minutes after the hour, range 0--59 @item Hours past midnight, range 0--23 @item Day of month, range 0--31 @@ -4709,8 +5273,7 @@ The elements of @var{TARRAY} are assigned as follows: @item Number of days since Sunday, range 0--6 @item Days since January 1 @item Daylight savings indicator: positive if daylight savings is in - effect, zero if not, and negative if the information is not - available. +effect, zero if not, and negative if the information is not available. @end enumerate @item @emph{See also}: @@ -4740,16 +5303,15 @@ Subroutine, function @item @emph{Syntax}: @multitable @columnfractions .80 -@item @code{CALL HOSTNM(NAME[, STATUS])} +@item @code{CALL HOSTNM(C [, STATUS])} @item @code{STATUS = HOSTNM(NAME)} @end multitable @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{NAME} @tab Shall of type @code{CHARACTER(*)}. +@item @var{C} @tab Shall of type @code{CHARACTER} and of default kind. @item @var{STATUS} @tab (Optional) status flag of type @code{INTEGER}. - Returns 0 on success, or a system specific error - code otherwise. +Returns 0 on success, or a system specific error code otherwise. @end multitable @item @emph{Return value}: @@ -4772,7 +5334,7 @@ be obtained, or to a blank string otherwise. the model of the type of @code{X}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Inquiry function @@ -4799,6 +5361,46 @@ end program test_huge_tiny +@node HYPOT +@section @code{HYPOT} --- Euclidean distance function +@fnindex HYPOT +@cindex Euclidean distance + +@table @asis +@item @emph{Description}: +@code{HYPOT(X,Y)} is the Euclidean distance function. It is equal to +@math{\sqrt{X^2 + Y^2}}, without undue underflow or overflow. + +@item @emph{Standard}: +Fortran 2008 and later + +@item @emph{Class}: +Elemental function + +@item @emph{Syntax}: +@code{RESULT = HYPOT(X, Y)} + +@item @emph{Arguments}: +@multitable @columnfractions .15 .70 +@item @var{X} @tab The type shall be @code{REAL}. +@item @var{Y} @tab The type and kind type parameter shall be the same as +@var{X}. +@end multitable + +@item @emph{Return value}: +The return value has the same type and kind type parameter as @var{X}. + +@item @emph{Example}: +@smallexample +program test_hypot + real(4) :: x = 1.e0_4, y = 0.5e0_4 + x = hypot(x,y) +end program test_hypot +@end smallexample +@end table + + + @node IACHAR @section @code{IACHAR} --- Code in @acronym{ASCII} collating sequence @fnindex IACHAR @@ -4812,22 +5414,24 @@ end program test_huge_tiny in the first character position of @code{C}. @item @emph{Standard}: -F95 and later +Fortran 95 and later, with @var{KIND} argument Fortran 2003 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = IACHAR(C)} +@code{RESULT = IACHAR(C [, KIND])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{C} @tab Shall be a scalar @code{CHARACTER}, with @code{INTENT(IN)} +@item @var{C} @tab Shall be a scalar @code{CHARACTER}, with @code{INTENT(IN)} +@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: -The return value is of type @code{INTEGER} and of the default integer -kind. +The return value is of type @code{INTEGER} and of kind @var{KIND}. If +@var{KIND} is absent, the return value is of default integer kind. @item @emph{Example}: @smallexample @@ -4859,7 +5463,7 @@ and formatted string representations. Bitwise logical @code{AND}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @@ -4869,14 +5473,14 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{I} @tab The type shall be @code{INTEGER(*)}. -@item @var{J} @tab The type shall be @code{INTEGER(*)}, of the same +@item @var{I} @tab The type shall be @code{INTEGER}. +@item @var{J} @tab The type shall be @code{INTEGER}, of the same kind as @var{I}. (As a GNU extension, different kinds are also permitted.) @end multitable @item @emph{Return value}: -The return type is @code{INTEGER(*)}, of the same kind as the +The return type is @code{INTEGER}, of the same kind as the arguments. (If the argument kinds differ, it is of the same kind as the larger argument.) @@ -4917,7 +5521,7 @@ standard. GNU extension @item @emph{Class}: -Non-elemental Function +Function @item @emph{Syntax}: @code{RESULT = IARGC()} @@ -4934,8 +5538,8 @@ See @ref{GETARG} @item @emph{See also}: GNU Fortran 77 compatibility subroutine: @ref{GETARG} -F2003 functions and subroutines: @ref{GET_COMMAND}, @ref{GET_COMMAND_ARGUMENT}, -@ref{COMMAND_ARGUMENT_COUNT} +Fortran 2003 functions and subroutines: @ref{GET_COMMAND}, +@ref{GET_COMMAND_ARGUMENT}, @ref{COMMAND_ARGUMENT_COUNT} @end table @@ -4952,7 +5556,7 @@ F2003 functions and subroutines: @ref{GET_COMMAND}, @ref{GET_COMMAND_ARGUMENT}, @var{POS} set to zero. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @@ -4962,12 +5566,12 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{I} @tab The type shall be @code{INTEGER(*)}. -@item @var{POS} @tab The type shall be @code{INTEGER(*)}. +@item @var{I} @tab The type shall be @code{INTEGER}. +@item @var{POS} @tab The type shall be @code{INTEGER}. @end multitable @item @emph{Return value}: -The return value is of type @code{INTEGER(*)} and of the same kind as +The return value is of type @code{INTEGER} and of the same kind as @var{I}. @item @emph{See also}: @@ -4992,7 +5596,7 @@ zeroed. The value of @code{POS+LEN} must be less than or equal to the value @code{BIT_SIZE(I)}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @@ -5002,13 +5606,13 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{I} @tab The type shall be @code{INTEGER(*)}. -@item @var{POS} @tab The type shall be @code{INTEGER(*)}. -@item @var{LEN} @tab The type shall be @code{INTEGER(*)}. +@item @var{I} @tab The type shall be @code{INTEGER}. +@item @var{POS} @tab The type shall be @code{INTEGER}. +@item @var{LEN} @tab The type shall be @code{INTEGER}. @end multitable @item @emph{Return value}: -The return value is of type @code{INTEGER(*)} and of the same kind as +The return value is of type @code{INTEGER} and of the same kind as @var{I}. @item @emph{See also}: @@ -5028,7 +5632,7 @@ The return value is of type @code{INTEGER(*)} and of the same kind as @var{POS} set to one. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @@ -5038,12 +5642,12 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{I} @tab The type shall be @code{INTEGER(*)}. -@item @var{POS} @tab The type shall be @code{INTEGER(*)}. +@item @var{I} @tab The type shall be @code{INTEGER}. +@item @var{POS} @tab The type shall be @code{INTEGER}. @end multitable @item @emph{Return value}: -The return value is of type @code{INTEGER(*)} and of the same kind as +The return value is of type @code{INTEGER} and of the same kind as @var{I}. @item @emph{See also}: @@ -5066,22 +5670,24 @@ The correspondence between characters and their codes is not necessarily the same across different GNU Fortran implementations. @item @emph{Standard}: -F95 and later +Fortan 95 and later, with @var{KIND} argument Fortran 2003 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = ICHAR(C)} +@code{RESULT = ICHAR(C [, KIND])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{C} @tab Shall be a scalar @code{CHARACTER}, with @code{INTENT(IN)} +@item @var{C} @tab Shall be a scalar @code{CHARACTER}, with @code{INTENT(IN)} +@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: -The return value is of type @code{INTEGER} and of the default integer -kind. +The return value is of type @code{INTEGER} and of kind @var{KIND}. If +@var{KIND} is absent, the return value is of default integer kind. @item @emph{Example}: @smallexample @@ -5129,9 +5735,9 @@ end program read_val @table @asis @item @emph{Description}: -@code{IDATE(TARRAY)} Fills @var{TARRAY} with the numerical values at the +@code{IDATE(VALUES)} Fills @var{VALUES} with the numerical values at the current local time. The day (in the range 1-31), month (in the range 1-12), -and year appear in elements 1, 2, and 3 of @var{TARRAY}, respectively. +and year appear in elements 1, 2, and 3 of @var{VALUES}, respectively. The year has four significant digits. @item @emph{Standard}: @@ -5141,16 +5747,16 @@ GNU extension Subroutine @item @emph{Syntax}: -@code{CALL IDATE(TARRAY)} +@code{CALL IDATE(VALUES)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{TARRAY} @tab The type shall be @code{INTEGER, DIMENSION(3)} and +@item @var{VALUES} @tab The type shall be @code{INTEGER, DIMENSION(3)} and the kind shall be the default integer kind. @end multitable @item @emph{Return value}: -Does not return. +Does not return anything. @item @emph{Example}: @smallexample @@ -5178,7 +5784,7 @@ end program test_idate @var{J}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @@ -5188,14 +5794,14 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{I} @tab The type shall be @code{INTEGER(*)}. -@item @var{J} @tab The type shall be @code{INTEGER(*)}, of the same +@item @var{I} @tab The type shall be @code{INTEGER}. +@item @var{J} @tab The type shall be @code{INTEGER}, of the same kind as @var{I}. (As a GNU extension, different kinds are also permitted.) @end multitable @item @emph{Return value}: -The return type is @code{INTEGER(*)}, of the same kind as the +The return type is @code{INTEGER}, of the same kind as the arguments. (If the argument kinds differ, it is of the same kind as the larger argument.) @@ -5219,7 +5825,7 @@ function. GNU extension @item @emph{Class}: -Non-elemental function +Function @item @emph{Syntax}: @code{RESULT = IERRNO()} @@ -5237,7 +5843,7 @@ kind. -@node INDEX +@node INDEX intrinsic @section @code{INDEX} --- Position of a substring within a string @fnindex INDEX @cindex substring position @@ -5252,27 +5858,29 @@ the @var{BACK} argument is present and true, the return value is the start of the last occurrence rather than the first. @item @emph{Standard}: -F77 and later +Fortran 77 and later, with @var{KIND} argument Fortran 2003 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = INDEX(STRING, SUBSTRING [, BACK])} +@code{RESULT = INDEX(STRING, SUBSTRING [, BACK [, KIND]])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{STRING} @tab Shall be a scalar @code{CHARACTER(*)}, with +@item @var{STRING} @tab Shall be a scalar @code{CHARACTER}, with @code{INTENT(IN)} -@item @var{SUBSTRING} @tab Shall be a scalar @code{CHARACTER(*)}, with +@item @var{SUBSTRING} @tab Shall be a scalar @code{CHARACTER}, with @code{INTENT(IN)} -@item @var{BACK} @tab (Optional) Shall be a scalar @code{LOGICAL(*)}, with +@item @var{BACK} @tab (Optional) Shall be a scalar @code{LOGICAL}, with @code{INTENT(IN)} +@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: -The return value is of type @code{INTEGER} and of the default integer -kind. +The return value is of type @code{INTEGER} and of kind @var{KIND}. If +@var{KIND} is absent, the return value is of default integer kind. @item @emph{See also}: @ref{SCAN}, @ref{VERIFY} @@ -5292,7 +5900,7 @@ kind. Convert to integer type @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @@ -5302,26 +5910,25 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{A} @tab Shall be of type @code{INTEGER(*)}, - @code{REAL(*)}, or @code{COMPLEX(*)}. -@item @var{KIND} @tab (Optional) An @code{INTEGER(*)} initialization - expression indicating the kind parameter of - the result. +@item @var{A} @tab Shall be of type @code{INTEGER}, +@code{REAL}, or @code{COMPLEX}. +@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: -These functions return a @code{INTEGER(*)} variable or array under +These functions return a @code{INTEGER} variable or array under the following rules: @table @asis @item (A) -If @var{A} is of type @code{INTEGER(*)}, @code{INT(A) = A} +If @var{A} is of type @code{INTEGER}, @code{INT(A) = A} @item (B) -If @var{A} is of type @code{REAL(*)} and @math{|A| < 1}, @code{INT(A)} equals @code{0}. +If @var{A} is of type @code{REAL} and @math{|A| < 1}, @code{INT(A)} equals @code{0}. If @math{|A| \geq 1}, then @code{INT(A)} equals the largest integer that does not exceed the range of @var{A} and whose sign is the same as the sign of @var{A}. @item (C) -If @var{A} is of type @code{COMPLEX(*)}, rule B is applied to the real part of @var{A}. +If @var{A} is of type @code{COMPLEX}, rule B is applied to the real part of @var{A}. @end table @item @emph{Example}: @@ -5337,8 +5944,8 @@ end program @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Argument @tab Return type @tab Standard -@item @code{IFIX(A)} @tab @code{REAL(4) A} @tab @code{INTEGER} @tab F77 and later -@item @code{IDINT(A)} @tab @code{REAL(8) A} @tab @code{INTEGER} @tab F77 and later +@item @code{IFIX(A)} @tab @code{REAL(4) A} @tab @code{INTEGER} @tab Fortran 77 and later +@item @code{IDINT(A)} @tab @code{REAL(8) A} @tab @code{INTEGER} @tab Fortran 77 and later @end multitable @end table @@ -5360,7 +5967,7 @@ standard @code{INT} intrinsic with an optional argument of The @code{SHORT} intrinsic is equivalent to @code{INT2}. @item @emph{Standard}: -GNU extension. +GNU extension @item @emph{Class}: Elemental function @@ -5370,8 +5977,8 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{A} @tab Shall be of type @code{INTEGER(*)}, - @code{REAL(*)}, or @code{COMPLEX(*)}. +@item @var{A} @tab Shall be of type @code{INTEGER}, +@code{REAL}, or @code{COMPLEX}. @end multitable @item @emph{Return value}: @@ -5395,7 +6002,7 @@ standard @code{INT} intrinsic with an optional argument of @code{KIND=8}, and is only included for backwards compatibility. @item @emph{Standard}: -GNU extension. +GNU extension @item @emph{Class}: Elemental function @@ -5405,8 +6012,8 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{A} @tab Shall be of type @code{INTEGER(*)}, - @code{REAL(*)}, or @code{COMPLEX(*)}. +@item @var{A} @tab Shall be of type @code{INTEGER}, +@code{REAL}, or @code{COMPLEX}. @end multitable @item @emph{Return value}: @@ -5426,28 +6033,28 @@ The return value is a @code{INTEGER(8)} variable. @table @asis @item @emph{Description}: -@code{IEOR} returns the bitwise boolean OR of @var{I} and +@code{IOR} returns the bitwise boolean inclusive-OR of @var{I} and @var{J}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = IEOR(I, J)} +@code{RESULT = IOR(I, J)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{I} @tab The type shall be @code{INTEGER(*)}. -@item @var{J} @tab The type shall be @code{INTEGER(*)}, of the same +@item @var{I} @tab The type shall be @code{INTEGER}. +@item @var{J} @tab The type shall be @code{INTEGER}, of the same kind as @var{I}. (As a GNU extension, different kinds are also permitted.) @end multitable @item @emph{Return value}: -The return type is @code{INTEGER(*)}, of the same kind as the +The return type is @code{INTEGER}, of the same kind as the arguments. (If the argument kinds differ, it is of the same kind as the larger argument.) @@ -5471,18 +6078,23 @@ in the current sequence is returned; if @var{FLAG} is 1, the generator is restarted by @code{CALL SRAND(0)}; if @var{FLAG} has any other value, it is used as a new seed with @code{SRAND}. +This intrinsic routine is provided for backwards compatibility with +GNU Fortran 77. It implements a simple modulo generator as provided +by @command{g77}. For new code, one should consider the use of +@ref{RANDOM_NUMBER} as it implements a superior algorithm. + @item @emph{Standard}: GNU extension @item @emph{Class}: -Non-elemental function +Function @item @emph{Syntax}: -@code{RESULT = IRAND(FLAG)} +@code{RESULT = IRAND(I)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{FLAG} @tab Shall be a scalar @code{INTEGER} of kind 4. +@item @var{I} @tab Shall be a scalar @code{INTEGER} of kind 4. @end multitable @item @emph{Return value}: @@ -5503,6 +6115,96 @@ end program test_irand +@node IS_IOSTAT_END +@section @code{IS_IOSTAT_END} --- Test for end-of-file value +@fnindex IS_IOSTAT_END +@cindex IOSTAT, end of file + +@table @asis +@item @emph{Description}: +@code{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 @code{IOSTAT_END} parameter of the intrinsic module +@code{ISO_FORTRAN_ENV}. + +@item @emph{Standard}: +Fortran 2003 and later + +@item @emph{Class}: +Elemental function + +@item @emph{Syntax}: +@code{RESULT = IS_IOSTAT_END(I)} + +@item @emph{Arguments}: +@multitable @columnfractions .15 .70 +@item @var{I} @tab Shall be of the type @code{INTEGER}. +@end multitable + +@item @emph{Return value}: +Returns a @code{LOGICAL} of the default kind, which @code{.TRUE.} if +@var{I} has the value which indicates an end of file condition for +IOSTAT= specifiers, and is @code{.FALSE.} otherwise. + +@item @emph{Example}: +@smallexample +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 +@end smallexample +@end table + + + +@node IS_IOSTAT_EOR +@section @code{IS_IOSTAT_EOR} --- Test for end-of-record value +@fnindex IS_IOSTAT_EOR +@cindex IOSTAT, end of record + +@table @asis +@item @emph{Description}: +@code{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 @code{IOSTAT_EOR} parameter of the intrinsic module +@code{ISO_FORTRAN_ENV}. + +@item @emph{Standard}: +Fortran 2003 and later + +@item @emph{Class}: +Elemental function + +@item @emph{Syntax}: +@code{RESULT = IS_IOSTAT_EOR(I)} + +@item @emph{Arguments}: +@multitable @columnfractions .15 .70 +@item @var{I} @tab Shall be of the type @code{INTEGER}. +@end multitable + +@item @emph{Return value}: +Returns a @code{LOGICAL} of the default kind, which @code{.TRUE.} if +@var{I} has the value which indicates an end of file condition for +IOSTAT= specifiers, and is @code{.FALSE.} otherwise. + +@item @emph{Example}: +@smallexample +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 +@end smallexample +@end table + + + @node ISATTY @section @code{ISATTY} --- Whether a unit is a terminal device. @fnindex ISATTY @@ -5513,17 +6215,17 @@ end program test_irand Determine whether a unit is connected to a terminal device. @item @emph{Standard}: -GNU extension. +GNU extension @item @emph{Class}: -Non-elemental function. +Function @item @emph{Syntax}: @code{RESULT = ISATTY(UNIT)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{UNIT} @tab Shall be a scalar @code{INTEGER(*)}. +@item @var{UNIT} @tab Shall be a scalar @code{INTEGER}. @end multitable @item @emph{Return value}: @@ -5561,7 +6263,7 @@ value is undefined. Bits shifted out from the left end or right end are lost; zeros are shifted in from the opposite end. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @@ -5571,12 +6273,12 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{I} @tab The type shall be @code{INTEGER(*)}. -@item @var{SHIFT} @tab The type shall be @code{INTEGER(*)}. +@item @var{I} @tab The type shall be @code{INTEGER}. +@item @var{SHIFT} @tab The type shall be @code{INTEGER}. @end multitable @item @emph{Return value}: -The return value is of type @code{INTEGER(*)} and of the same kind as +The return value is of type @code{INTEGER} and of the same kind as @var{I}. @item @emph{See also}: @@ -5602,29 +6304,71 @@ a right shift. The absolute value of @var{SHIFT} must be less than equivalent to @code{BIT_SIZE(I)}. @item @emph{Standard}: -F95 and later +Fortran 95 and later + +@item @emph{Class}: +Elemental function + +@item @emph{Syntax}: +@code{RESULT = ISHFTC(I, SHIFT [, SIZE])} + +@item @emph{Arguments}: +@multitable @columnfractions .15 .70 +@item @var{I} @tab The type shall be @code{INTEGER}. +@item @var{SHIFT} @tab The type shall be @code{INTEGER}. +@item @var{SIZE} @tab (Optional) The type shall be @code{INTEGER}; +the value must be greater than zero and less than or equal to +@code{BIT_SIZE(I)}. +@end multitable + +@item @emph{Return value}: +The return value is of type @code{INTEGER} and of the same kind as +@var{I}. + +@item @emph{See also}: +@ref{ISHFT} +@end table + + + +@node ISNAN +@section @code{ISNAN} --- Test for a NaN +@fnindex ISNAN +@cindex IEEE, ISNAN + +@table @asis +@item @emph{Description}: +@code{ISNAN} tests whether a floating-point value is an IEEE +Not-a-Number (NaN). +@item @emph{Standard}: +GNU extension @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = ISHFTC(I, SHIFT [, SIZE])} +@code{ISNAN(X)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{I} @tab The type shall be @code{INTEGER(*)}. -@item @var{SHIFT} @tab The type shall be @code{INTEGER(*)}. -@item @var{SIZE} @tab (Optional) The type shall be @code{INTEGER(*)}; -the value must be greater than zero and less than or equal to -@code{BIT_SIZE(I)}. +@item @var{X} @tab Variable of the type @code{REAL}. + @end multitable @item @emph{Return value}: -The return value is of type @code{INTEGER(*)} and of the same kind as -@var{I}. +Returns a default-kind @code{LOGICAL}. The returned value is @code{TRUE} +if @var{X} is a NaN and @code{FALSE} otherwise. -@item @emph{See also}: -@ref{ISHFT} +@item @emph{Example}: +@smallexample +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 +@end smallexample @end table @@ -5637,9 +6381,9 @@ The return value is of type @code{INTEGER(*)} and of the same kind as @table @asis @item @emph{Description}: -@code{IDATE(TARRAY)} Fills @var{TARRAY} with the numerical values at the +@code{IDATE(VALUES)} Fills @var{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 @var{TARRAY}, +and seconds (in the range 1-60) appear in elements 1, 2, and 3 of @var{VALUES}, respectively. @item @emph{Standard}: @@ -5649,16 +6393,16 @@ GNU extension Subroutine @item @emph{Syntax}: -@code{CALL ITIME(TARRAY)} +@code{CALL ITIME(VALUES)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{TARRAY} @tab The type shall be @code{INTEGER, DIMENSION(3)} +@item @var{VALUES} @tab The type shall be @code{INTEGER, DIMENSION(3)} and the kind shall be the default integer kind. @end multitable @item @emph{Return value}: -Does not return. +Does not return anything. @item @emph{Example}: @@ -5685,21 +6429,24 @@ end program test_itime Sends the signal specified by @var{SIGNAL} to the process @var{PID}. See @code{kill(2)}. +This intrinsic is provided in both subroutine and function forms; however, +only one form can be used in any given program unit. + @item @emph{Class}: -Subroutine +Subroutine, function @item @emph{Syntax}: -@code{CALL KILL(PID, SIGNAL [, STATUS])} +@code{CALL KILL(C, VALUE [, STATUS])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{PID} @tab Shall be a scalar @code{INTEGER}, with +@item @var{C} @tab Shall be a scalar @code{INTEGER}, with @code{INTENT(IN)} -@item @var{SIGNAL} @tab Shall be a scalar @code{INTEGER}, with +@item @var{VALUE} @tab Shall be a scalar @code{INTEGER}, with @code{INTENT(IN)} @item @var{STATUS} @tab (Optional) status flag of type @code{INTEGER(4)} or - @code{INTEGER(8)}. Returns 0 on success, or a - system-specific error code otherwise. +@code{INTEGER(8)}. Returns 0 on success, or a system-specific error code +otherwise. @end multitable @item @emph{See also}: @@ -5718,7 +6465,7 @@ Subroutine @code{KIND(X)} returns the kind value of the entity @var{X}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Inquiry function @@ -5761,21 +6508,25 @@ end program test_kind Returns the lower bounds of an array, or a single lower bound along the @var{DIM} dimension. @item @emph{Standard}: -F95 and later +Fortran 95 and later, with @var{KIND} argument Fortran 2003 and later @item @emph{Class}: Inquiry function @item @emph{Syntax}: -@code{RESULT = LBOUND(ARRAY [, DIM])} +@code{RESULT = LBOUND(ARRAY [, DIM [, KIND]])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 @item @var{ARRAY} @tab Shall be an array, of any type. -@item @var{DIM} @tab (Optional) Shall be a scalar @code{INTEGER(*)}. +@item @var{DIM} @tab (Optional) Shall be a scalar @code{INTEGER}. +@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: +The return value is of type @code{INTEGER} and of kind @var{KIND}. If +@var{KIND} is absent, the return value is of default integer kind. If @var{DIM} is absent, the result is an array of the lower bounds of @var{ARRAY}. If @var{DIM} is present, the result is a scalar corresponding to the lower bound of the array along that dimension. If @@ -5789,6 +6540,46 @@ dimension, the lower bound is taken to be 1. +@node LEADZ +@section @code{LEADZ} --- Number of leading zero bits of an integer +@fnindex LEADZ +@cindex zero bits + +@table @asis +@item @emph{Description}: +@code{LEADZ} returns the number of leading zero bits of an integer. + +@item @emph{Standard}: +Fortran 2008 and later + +@item @emph{Class}: +Elemental function + +@item @emph{Syntax}: +@code{RESULT = LEADZ(I)} + +@item @emph{Arguments}: +@multitable @columnfractions .15 .70 +@item @var{I} @tab Shall be of type @code{INTEGER}. +@end multitable + +@item @emph{Return value}: +The type of the return value is the default @code{INTEGER}. +If all the bits of @code{I} are zero, the result value is @code{BIT_SIZE(I)}. + +@item @emph{Example}: +@smallexample +PROGRAM test_leadz + WRITE (*,*) LEADZ(1) ! prints 8 if BITSIZE(I) has the value 32 +END PROGRAM +@end smallexample + +@item @emph{See also}: +@ref{BIT_SIZE}, @ref{TRAILZ} +@end table + + + @node LEN @section @code{LEN} --- Length of a character entity @fnindex LEN @@ -5802,22 +6593,25 @@ the length of an element of @var{STRING} is returned. Note that only the length, not the content, of @var{STRING} is needed. @item @emph{Standard}: -F77 and later +Fortran 77 and later, with @var{KIND} argument Fortran 2003 and later @item @emph{Class}: Inquiry function @item @emph{Syntax}: -@code{L = LEN(STRING)} +@code{L = LEN(STRING [, KIND])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 @item @var{STRING} @tab Shall be a scalar or array of type -@code{CHARACTER(*)}, with @code{INTENT(IN)} +@code{CHARACTER}, with @code{INTENT(IN)} +@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: -The return value is an @code{INTEGER} of the default kind. +The return value is of type @code{INTEGER} and of kind @var{KIND}. If +@var{KIND} is absent, the return value is of default integer kind. @item @emph{See also}: @ref{LEN_TRIM}, @ref{ADJUSTL}, @ref{ADJUSTR} @@ -5835,22 +6629,25 @@ The return value is an @code{INTEGER} of the default kind. Returns the length of a character string, ignoring any trailing blanks. @item @emph{Standard}: -F95 and later +Fortran 95 and later, with @var{KIND} argument Fortran 2003 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = LEN_TRIM(STRING)} +@code{RESULT = LEN_TRIM(STRING [, KIND])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{STRING} @tab Shall be a scalar of type @code{CHARACTER(*)}, +@item @var{STRING} @tab Shall be a scalar of type @code{CHARACTER}, with @code{INTENT(IN)} +@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: -The return value is an @code{INTEGER} of the default kind. +The return value is of type @code{INTEGER} and of kind @var{KIND}. If +@var{KIND} is absent, the return value is of default integer kind. @item @emph{See also}: @ref{LEN}, @ref{ADJUSTL}, @ref{ADJUSTR} @@ -5880,7 +6677,7 @@ ASCII on some targets), whereas the former always use the ASCII ordering. @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @@ -5926,7 +6723,7 @@ ASCII on some targets), whereas the former always use the ASCII ordering. @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @@ -5972,7 +6769,7 @@ however, only one form can be used in any given program unit. GNU extension @item @emph{Class}: -Subroutine, non-elemental function +Subroutine, function @item @emph{Syntax}: @multitable @columnfractions .80 @@ -6015,7 +6812,7 @@ ASCII on some targets), whereas the former always use the ASCII ordering. @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @@ -6061,7 +6858,7 @@ ASCII on some targets), whereas the former always use the ASCII ordering. @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @@ -6107,7 +6904,7 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{STRING} @tab Shall be a scalar of type @code{CHARACTER(*)}, +@item @var{STRING} @tab Shall be a scalar of type @code{CHARACTER}, with @code{INTENT(IN)} @end multitable @@ -6115,7 +6912,7 @@ with @code{INTENT(IN)} The return value is of @code{INTEGER(kind=4)} type. @item @emph{See also}: -@ref{INDEX}, @ref{LEN_TRIM} +@ref{INDEX intrinsic}, @ref{LEN_TRIM} @end table @@ -6177,7 +6974,7 @@ end program test_loc @code{LOG(X)} computes the logarithm of @var{X}. @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @@ -6187,13 +6984,15 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)} or -@code{COMPLEX(*)}. +@item @var{X} @tab The type shall be @code{REAL} or +@code{COMPLEX}. @end multitable @item @emph{Return value}: -The return value is of type @code{REAL(*)} or @code{COMPLEX(*)}. +The return value is of type @code{REAL} or @code{COMPLEX}. The kind type parameter is the same as @var{X}. +If @var{X} is @code{COMPLEX}, the imaginary part @math{\omega} is in the range +@math{-\pi \leq \omega \leq \pi}. @item @emph{Example}: @smallexample @@ -6231,7 +7030,7 @@ end program test_log @code{LOG10(X)} computes the base 10 logarithm of @var{X}. @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @@ -6241,11 +7040,11 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)}. +@item @var{X} @tab The type shall be @code{REAL}. @end multitable @item @emph{Return value}: -The return value is of type @code{REAL(*)} or @code{COMPLEX(*)}. +The return value is of type @code{REAL} or @code{COMPLEX}. The kind type parameter is the same as @var{X}. @item @emph{Example}: @@ -6259,9 +7058,63 @@ end program test_log10 @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Argument @tab Return type @tab Standard -@item @code{ALOG10(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab F95 and later -@item @code{DLOG10(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F95 and later +@item @code{ALOG10(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab Fortran 95 and later +@item @code{DLOG10(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab Fortran 95 and later +@end multitable +@end table + + + +@node LOG_GAMMA +@section @code{LOG_GAMMA} --- Logarithm of the Gamma function +@fnindex LOG_GAMMA +@fnindex LGAMMA +@fnindex ALGAMA +@fnindex DLGAMA +@cindex Gamma function, logarithm of + +@table @asis +@item @emph{Description}: +@code{LOG_GAMMA(X)} computes the natural logarithm of the absolute value +of the Gamma (@math{\Gamma}) function. + +@item @emph{Standard}: +Fortran 2008 and later + +@item @emph{Class}: +Elemental function + +@item @emph{Syntax}: +@code{X = LOG_GAMMA(X)} + +@item @emph{Arguments}: +@multitable @columnfractions .15 .70 +@item @var{X} @tab Shall be of type @code{REAL} and neither zero +nor a negative integer. +@end multitable + +@item @emph{Return value}: +The return value is of type @code{REAL} of the same kind as @var{X}. + +@item @emph{Example}: +@smallexample +program test_log_gamma + real :: x = 1.0 + x = lgamma(x) ! returns 0.0 +end program test_log_gamma +@end smallexample + +@item @emph{Specific names}: +@multitable @columnfractions .20 .20 .20 .25 +@item Name @tab Argument @tab Return type @tab Standard +@item @code{LGAMMA(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab GNU Extension +@item @code{ALGAMA(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab GNU Extension +@item @code{DLGAMA(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab GNU Extension @end multitable + +@item @emph{See also}: +Gamma function: @ref{GAMMA} + @end table @@ -6276,7 +7129,7 @@ end program test_log10 Converts one kind of @code{LOGICAL} variable to another. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @@ -6286,10 +7139,9 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{L} @tab The type shall be @code{LOGICAL(*)}. -@item @var{KIND} @tab (Optional) An @code{INTEGER(*)} initialization - expression indicating the kind parameter of - the result. +@item @var{L} @tab The type shall be @code{LOGICAL}. +@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: @@ -6316,7 +7168,7 @@ intrinsic with an optional argument of @code{KIND=4}, and is only included for backwards compatibility. @item @emph{Standard}: -GNU extension. +GNU extension @item @emph{Class}: Elemental function @@ -6326,8 +7178,8 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{A} @tab Shall be of type @code{INTEGER(*)}, - @code{REAL(*)}, or @code{COMPLEX(*)}. +@item @var{A} @tab Shall be of type @code{INTEGER}, +@code{REAL}, or @code{COMPLEX}. @end multitable @item @emph{Return value}: @@ -6366,12 +7218,12 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{I} @tab The type shall be @code{INTEGER(*)}. -@item @var{SHIFT} @tab The type shall be @code{INTEGER(*)}. +@item @var{I} @tab The type shall be @code{INTEGER}. +@item @var{SHIFT} @tab The type shall be @code{INTEGER}. @end multitable @item @emph{Return value}: -The return value is of type @code{INTEGER(*)} and of the same kind as +The return value is of type @code{INTEGER} and of the same kind as @var{I}. @item @emph{See also}: @@ -6388,26 +7240,31 @@ The return value is of type @code{INTEGER(*)} and of the same kind as @table @asis @item @emph{Description}: -@code{LSTAT} is identical to @ref{STAT}, except that if path is a symbolic link, -then the link itself is statted, not the file that it refers to. +@code{LSTAT} is identical to @ref{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 @code{VALUES} are the same as described by @ref{STAT}. -The elements in @code{BUFF} are the same as described by @ref{STAT}. +This intrinsic is provided in both subroutine and function forms; +however, only one form can be used in any given program unit. @item @emph{Standard}: GNU extension @item @emph{Class}: -Non-elemental subroutine +Subroutine, function @item @emph{Syntax}: -@code{CALL LSTAT(FILE, BUFF [, STATUS])} +@code{CALL LSTAT(NAME, VALUES [, STATUS])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{FILE} @tab The type shall be @code{CHARACTER(*)}, a valid path within the file system. -@item @var{BUFF} @tab The type shall be @code{INTEGER(4), DIMENSION(13)}. -@item @var{STATUS} @tab (Optional) status flag of type @code{INTEGER(4)}. Returns 0 - on success and a system specific error code otherwise. +@item @var{NAME} @tab The type shall be @code{CHARACTER} of the default +kind, a valid path within the file system. +@item @var{VALUES} @tab The type shall be @code{INTEGER(4), DIMENSION(13)}. +@item @var{STATUS} @tab (Optional) status flag of type @code{INTEGER(4)}. +Returns 0 on success and a system specific error code otherwise. @end multitable @item @emph{Example}: @@ -6422,12 +7279,12 @@ To stat an open file: @ref{FSTAT}, to stat a file: @ref{STAT} @node LTIME @section @code{LTIME} --- Convert time to local time info @fnindex LTIME -@cindex time, converstion to local time info +@cindex time, conversion to local time info @table @asis @item @emph{Description}: -Given a system time value @var{STIME} (as provided by the @code{TIME8()} -intrinsic), fills @var{TARRAY} with values extracted from it appropriate +Given a system time value @var{TIME} (as provided by the @code{TIME8()} +intrinsic), fills @var{VALUES} with values extracted from it appropriate to the local time zone using @code{localtime(3)}. @item @emph{Standard}: @@ -6437,22 +7294,21 @@ GNU extension Subroutine @item @emph{Syntax}: -@code{CALL LTIME(STIME, TARRAY)} +@code{CALL LTIME(TIME, VALUES)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{STIME} @tab An @code{INTEGER(*)} scalar expression - corresponding to a system time, with - @code{INTENT(IN)}. -@item @var{TARRAY} @tab A default @code{INTEGER} array with 9 elements, - with @code{INTENT(OUT)}. +@item @var{TIME} @tab An @code{INTEGER} scalar expression +corresponding to a system time, with @code{INTENT(IN)}. +@item @var{VALUES} @tab A default @code{INTEGER} array with 9 elements, +with @code{INTENT(OUT)}. @end multitable @item @emph{Return value}: -The elements of @var{TARRAY} are assigned as follows: +The elements of @var{VALUES} are assigned as follows: @enumerate @item Seconds after the minute, range 0--59 or 0--61 to allow for leap - seconds +seconds @item Minutes after the hour, range 0--59 @item Hours past midnight, range 0--23 @item Day of month, range 0--31 @@ -6461,8 +7317,7 @@ The elements of @var{TARRAY} are assigned as follows: @item Number of days since Sunday, range 0--6 @item Days since January 1 @item Daylight savings indicator: positive if daylight savings is in - effect, zero if not, and negative if the information is not - available. +effect, zero if not, and negative if the information is not available. @end enumerate @item @emph{See also}: @@ -6490,14 +7345,14 @@ using Fortran 95 pointers, the memory allocation intrinsic is GNU extension @item @emph{Class}: -Non-elemental function +Function @item @emph{Syntax}: @code{PTR = MALLOC(SIZE)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{SIZE} @tab The type shall be @code{INTEGER(*)}. +@item @var{SIZE} @tab The type shall be @code{INTEGER}. @end multitable @item @emph{Return value}: @@ -6507,15 +7362,12 @@ C pointers (@code{sizeof(void *)}). @item @emph{Example}: The following example demonstrates the use of @code{MALLOC} and -@code{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 -@code{integer(kind=8)}. +@code{FREE} with Cray pointers. @smallexample program test_malloc + implicit none integer i - integer ptr_x real*8 x(*), z pointer(ptr_x,x) @@ -6549,7 +7401,7 @@ end program test_malloc Performs a matrix multiplication on numeric or logical arguments. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Transformational function @@ -6559,18 +7411,14 @@ Transformational function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{MATRIX_A} @tab An array of @code{INTEGER(*)}, - @code{REAL(*)}, @code{COMPLEX(*)}, or - @code{LOGICAL(*)} type, with a rank of - one or two. -@item @var{MATRIX_B} @tab An array of @code{INTEGER(*)}, - @code{REAL(*)}, or @code{COMPLEX(*)} type if - @var{MATRIX_A} is of a numeric type; - otherwise, an array of @code{LOGICAL(*)} - type. The rank shall be one or two, and the - first (or only) dimension of @var{MATRIX_B} - shall be equal to the last (or only) - dimension of @var{MATRIX_A}. +@item @var{MATRIX_A} @tab An array of @code{INTEGER}, +@code{REAL}, @code{COMPLEX}, or @code{LOGICAL} type, with a rank of +one or two. +@item @var{MATRIX_B} @tab An array of @code{INTEGER}, +@code{REAL}, or @code{COMPLEX} type if @var{MATRIX_A} is of a numeric +type; otherwise, an array of @code{LOGICAL} type. The rank shall be one +or two, and the first (or only) dimension of @var{MATRIX_B} shall be +equal to the last (or only) dimension of @var{MATRIX_A}. @end multitable @item @emph{Return value}: @@ -6598,7 +7446,7 @@ for the @code{*} or @code{.AND.} operators. Returns the argument with the largest (most positive) value. @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @@ -6608,12 +7456,11 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{A1} @tab The type shall be @code{INTEGER(*)} or - @code{REAL(*)}. +@item @var{A1} @tab The type shall be @code{INTEGER} or +@code{REAL}. @item @var{A2}, @var{A3}, ... @tab An expression of the same type and kind - as @var{A1}. (As a GNU extension, - arguments of different kinds are - permitted.) +as @var{A1}. (As a GNU extension, arguments of different kinds are +permitted.) @end multitable @item @emph{Return value}: @@ -6623,11 +7470,11 @@ and has the same type and kind as the first argument. @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Argument @tab Return type @tab Standard -@item @code{MAX0(I)} @tab @code{INTEGER(4) I} @tab @code{INTEGER(4)} @tab F77 and later -@item @code{AMAX0(I)} @tab @code{INTEGER(4) I} @tab @code{REAL(MAX(X))} @tab F77 and later -@item @code{MAX1(X)} @tab @code{REAL(*) X} @tab @code{INT(MAX(X))} @tab F77 and later -@item @code{AMAX1(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab F77 and later -@item @code{DMAX1(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later +@item @code{MAX0(I)} @tab @code{INTEGER(4) I} @tab @code{INTEGER(4)} @tab Fortran 77 and later +@item @code{AMAX0(I)} @tab @code{INTEGER(4) I} @tab @code{REAL(MAX(X))} @tab Fortran 77 and later +@item @code{MAX1(X)} @tab @code{REAL X} @tab @code{INT(MAX(X))} @tab Fortran 77 and later +@item @code{AMAX1(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab Fortran 77 and later +@item @code{DMAX1(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab Fortran 77 and later @end multitable @item @emph{See also}: @@ -6648,7 +7495,7 @@ and has the same type and kind as the first argument. type of @code{X}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Inquiry function @@ -6699,7 +7546,7 @@ and all of the elements of @var{MASK} along a given row are zero, the result value for that row is zero. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Transformational function @@ -6712,14 +7559,13 @@ Transformational function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{ARRAY} @tab Shall be an array of type @code{INTEGER(*)}, - @code{REAL(*)}, or @code{CHARACTER(*)}. +@item @var{ARRAY} @tab Shall be an array of type @code{INTEGER}, +@code{REAL}, or @code{CHARACTER}. @item @var{DIM} @tab (Optional) Shall be a scalar of type - @code{INTEGER(*)}, with a value between one - and the rank of @var{ARRAY}, inclusive. It - may not be an optional dummy argument. -@item @var{MASK} @tab Shall be an array of type @code{LOGICAL(*)}, - and conformable with @var{ARRAY}. +@code{INTEGER}, with a value between one and the rank of @var{ARRAY}, +inclusive. It may not be an optional dummy argument. +@item @var{MASK} @tab Shall be an array of type @code{LOGICAL}, +and conformable with @var{ARRAY}. @end multitable @item @emph{Return value}: @@ -6751,12 +7597,12 @@ the @var{DIM} argument is supplied, determines the maximum value along each row of the array in the @var{DIM} direction. If @var{MASK} is present, only the elements for which @var{MASK} is @code{.TRUE.} are considered. If the array has zero size, or all of the elements of -@var{MASK} are @code{.FALSE.}, then the result is the most negative -number of the type and kind of @var{ARRAY} if @var{ARRAY} is numeric, or -a string of nulls if @var{ARRAY} is of character type. +@var{MASK} are @code{.FALSE.}, then the result is @code{-HUGE(ARRAY)} +if @var{ARRAY} is numeric, or a string of nulls if @var{ARRAY} is of character +type. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Transformational function @@ -6769,14 +7615,13 @@ Transformational function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{ARRAY} @tab Shall be an array of type @code{INTEGER(*)}, - @code{REAL(*)}, or @code{CHARACTER(*)}. +@item @var{ARRAY} @tab Shall be an array of type @code{INTEGER}, +@code{REAL}, or @code{CHARACTER}. @item @var{DIM} @tab (Optional) Shall be a scalar of type - @code{INTEGER(*)}, with a value between one - and the rank of @var{ARRAY}, inclusive. It - may not be an optional dummy argument. -@item @var{MASK} @tab Shall be an array of type @code{LOGICAL(*)}, - and conformable with @var{ARRAY}. +@code{INTEGER}, with a value between one and the rank of @var{ARRAY}, +inclusive. It may not be an optional dummy argument. +@item @var{MASK} @tab Shall be an array of type @code{LOGICAL}, +and conformable with @var{ARRAY}. @end multitable @item @emph{Return value}: @@ -6813,7 +7658,7 @@ compiled program. GNU extension @item @emph{Class}: -Non-elemental function +Function @item @emph{Syntax}: @code{RESULT = MCLOCK()} @@ -6853,7 +7698,7 @@ less than previous values during a single run of the compiled program. GNU extension @item @emph{Class}: -Non-elemental function +Function @item @emph{Syntax}: @code{RESULT = MCLOCK8()} @@ -6883,7 +7728,7 @@ is equal to @var{TSOURCE} if @var{MASK} is @code{.TRUE.}, or equal to @var{FSOURCE} if it is @code{.FALSE.}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @@ -6895,8 +7740,8 @@ Elemental function @multitable @columnfractions .15 .70 @item @var{TSOURCE} @tab May be of any type. @item @var{FSOURCE} @tab Shall be of the same type and type parameters - as @var{TSOURCE}. -@item @var{MASK} @tab Shall be of type @code{LOGICAL(*)}. +as @var{TSOURCE}. +@item @var{MASK} @tab Shall be of type @code{LOGICAL}. @end multitable @item @emph{Return value}: @@ -6921,7 +7766,7 @@ The result is of the same type and type parameters as @var{TSOURCE}. Returns the argument with the smallest (most negative) value. @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @@ -6931,12 +7776,11 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{A1} @tab The type shall be @code{INTEGER(*)} or - @code{REAL(*)}. +@item @var{A1} @tab The type shall be @code{INTEGER} or +@code{REAL}. @item @var{A2}, @var{A3}, ... @tab An expression of the same type and kind - as @var{A1}. (As a GNU extension, - arguments of different kinds are - permitted.) +as @var{A1}. (As a GNU extension, arguments of different kinds are +permitted.) @end multitable @item @emph{Return value}: @@ -6946,11 +7790,11 @@ and has the same type and kind as the first argument. @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Argument @tab Return type @tab Standard -@item @code{MIN0(I)} @tab @code{INTEGER(4) I} @tab @code{INTEGER(4)} @tab F77 and later -@item @code{AMIN0(I)} @tab @code{INTEGER(4) I} @tab @code{REAL(MIN(X))} @tab F77 and later -@item @code{MIN1(X)} @tab @code{REAL(*) X} @tab @code{INT(MIN(X))} @tab F77 and later -@item @code{AMIN1(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab F77 and later -@item @code{DMIN1(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F77 and later +@item @code{MIN0(I)} @tab @code{INTEGER(4) I} @tab @code{INTEGER(4)} @tab Fortran 77 and later +@item @code{AMIN0(I)} @tab @code{INTEGER(4) I} @tab @code{REAL(MIN(X))} @tab Fortran 77 and later +@item @code{MIN1(X)} @tab @code{REAL X} @tab @code{INT(MIN(X))} @tab Fortran 77 and later +@item @code{AMIN1(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab Fortran 77 and later +@item @code{DMIN1(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab Fortran 77 and later @end multitable @item @emph{See also}: @@ -6970,7 +7814,7 @@ and has the same type and kind as the first argument. type of @code{X}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Inquiry function @@ -7013,7 +7857,7 @@ and all of the elements of @var{MASK} along a given row are zero, the result value for that row is zero. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Transformational function @@ -7026,14 +7870,13 @@ Transformational function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{ARRAY} @tab Shall be an array of type @code{INTEGER(*)}, - @code{REAL(*)}, or @code{CHARACTER(*)}. +@item @var{ARRAY} @tab Shall be an array of type @code{INTEGER}, +@code{REAL}, or @code{CHARACTER}. @item @var{DIM} @tab (Optional) Shall be a scalar of type - @code{INTEGER(*)}, with a value between one - and the rank of @var{ARRAY}, inclusive. It - may not be an optional dummy argument. -@item @var{MASK} @tab Shall be an array of type @code{LOGICAL(*)}, - and conformable with @var{ARRAY}. +@code{INTEGER}, with a value between one and the rank of @var{ARRAY}, +inclusive. It may not be an optional dummy argument. +@item @var{MASK} @tab Shall be an array of type @code{LOGICAL}, +and conformable with @var{ARRAY}. @end multitable @item @emph{Return value}: @@ -7055,7 +7898,7 @@ of one, the result is a scalar. In all cases, the result is of default @node MINVAL @section @code{MINVAL} --- Minimum value of an array @fnindex MINVAL -@cindex array, minmum value +@cindex array, minimum value @cindex minimum value @table @asis @@ -7070,7 +7913,7 @@ considered. If the array has zero size, or all of the elements of @var{ARRAY} is of character type. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Transformational function @@ -7083,14 +7926,13 @@ Transformational function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{ARRAY} @tab Shall be an array of type @code{INTEGER(*)}, - @code{REAL(*)}, or @code{CHARACTER(*)}. +@item @var{ARRAY} @tab Shall be an array of type @code{INTEGER}, +@code{REAL}, or @code{CHARACTER}. @item @var{DIM} @tab (Optional) Shall be a scalar of type - @code{INTEGER(*)}, with a value between one - and the rank of @var{ARRAY}, inclusive. It - may not be an optional dummy argument. -@item @var{MASK} @tab Shall be an array of type @code{LOGICAL(*)}, - and conformable with @var{ARRAY}. +@code{INTEGER}, with a value between one and the rank of @var{ARRAY}, +inclusive. It may not be an optional dummy argument. +@item @var{MASK} @tab Shall be an array of type @code{LOGICAL}, +and conformable with @var{ARRAY}. @end multitable @item @emph{Return value}: @@ -7117,11 +7959,11 @@ cases, the result is of the same type and kind as @var{ARRAY}. @table @asis @item @emph{Description}: -@code{MOD(A,P)} computes the remainder of the division of A by P. It is +@code{MOD(A,P)} computes the remainder of the division of A by P@. It is calculated as @code{A - (INT(A/P) * P)}. @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @@ -7163,8 +8005,8 @@ end program test_mod @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Arguments @tab Return type @tab Standard -@item @code{AMOD(A,P)} @tab @code{REAL(4)} @tab @code{REAL(4)} @tab F95 and later -@item @code{DMOD(A,P)} @tab @code{REAL(8)} @tab @code{REAL(8)} @tab F95 and later +@item @code{AMOD(A,P)} @tab @code{REAL(4)} @tab @code{REAL(4)} @tab Fortran 95 and later +@item @code{DMOD(A,P)} @tab @code{REAL(8)} @tab @code{REAL(8)} @tab Fortran 95 and later @end multitable @end table @@ -7181,7 +8023,7 @@ end program test_mod @code{MODULO(A,P)} computes the @var{A} modulo @var{P}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @@ -7233,24 +8075,24 @@ end program @table @asis @item @emph{Description}: -@code{MOVE_ALLOC(SRC, DEST)} moves the allocation from @var{SRC} to -@var{DEST}. @var{SRC} will become deallocated in the process. +@code{MOVE_ALLOC(FROM, TO)} moves the allocation from @var{FROM} to +@var{TO}. @var{FROM} will become deallocated in the process. @item @emph{Standard}: -F2003 and later +Fortran 2003 and later @item @emph{Class}: Subroutine @item @emph{Syntax}: -@code{CALL MOVE_ALLOC(SRC, DEST)} +@code{CALL MOVE_ALLOC(FROM, TO)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{SRC} @tab @code{ALLOCATABLE}, @code{INTENT(INOUT)}, may be - of any type and kind. -@item @var{DEST} @tab @code{ALLOCATABLE}, @code{INTENT(OUT)}, shall be - of the same type, kind and rank as @var{SRC} +@item @var{FROM} @tab @code{ALLOCATABLE}, @code{INTENT(INOUT)}, may be +of any type and kind. +@item @var{TO} @tab @code{ALLOCATABLE}, @code{INTENT(OUT)}, shall be +of the same type, kind and rank as @var{FROM}. @end multitable @item @emph{Return value}: @@ -7287,7 +8129,7 @@ affected by the movement of bits is unchanged. The values of @code{BIT_SIZE(FROM)}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental subroutine @@ -7297,12 +8139,12 @@ Elemental subroutine @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{FROM} @tab The type shall be @code{INTEGER(*)}. -@item @var{FROMPOS} @tab The type shall be @code{INTEGER(*)}. -@item @var{LEN} @tab The type shall be @code{INTEGER(*)}. -@item @var{TO} @tab The type shall be @code{INTEGER(*)}, of the - same kind as @var{FROM}. -@item @var{TOPOS} @tab The type shall be @code{INTEGER(*)}. +@item @var{FROM} @tab The type shall be @code{INTEGER}. +@item @var{FROMPOS} @tab The type shall be @code{INTEGER}. +@item @var{LEN} @tab The type shall be @code{INTEGER}. +@item @var{TO} @tab The type shall be @code{INTEGER}, of the +same kind as @var{FROM}. +@item @var{TOPOS} @tab The type shall be @code{INTEGER}. @end multitable @item @emph{See also}: @@ -7323,7 +8165,7 @@ Elemental subroutine to @code{X} in the direction indicated by the sign of @code{S}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @@ -7369,7 +8211,7 @@ end program test_nearest @code{NEW_LINE(C)} returns the new-line character. @item @emph{Standard}: -F2003 and later +Fortran 2003 and later @item @emph{Class}: Inquiry function @@ -7380,7 +8222,7 @@ Inquiry function @item @emph{Arguments}: @multitable @columnfractions .15 .70 @item @var{C} @tab The argument shall be a scalar or array of the - type @code{CHARACTER}. +type @code{CHARACTER}. @end multitable @item @emph{Return value}: @@ -7406,20 +8248,22 @@ end program newline @table @asis @item @emph{Description}: -@code{NINT(X)} rounds its argument to the nearest whole number. +@code{NINT(A)} rounds its argument to the nearest whole number. @item @emph{Standard}: -F77 and later +Fortran 77 and later, with @var{KIND} argument Fortran 90 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = NINT(X)} +@code{RESULT = NINT(A [, KIND])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type of the argument shall be @code{REAL}. +@item @var{A} @tab The type of the argument shall be @code{REAL}. +@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: @@ -7441,7 +8285,7 @@ end program test_nint @item @emph{Specific names}: @multitable @columnfractions .25 .25 .25 @item Name @tab Argument @tab Standard -@item @code{IDNINT(X)} @tab @code{REAL(8)} @tab F95 and later +@item @code{IDNINT(X)} @tab @code{REAL(8)} @tab Fortran 95 and later @end multitable @item @emph{See also}: @@ -7463,7 +8307,7 @@ end program test_nint @code{NOT} returns the bitwise boolean inverse of @var{I}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @@ -7473,11 +8317,11 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{I} @tab The type shall be @code{INTEGER(*)}. +@item @var{I} @tab The type shall be @code{INTEGER}. @end multitable @item @emph{Return value}: -The return type is @code{INTEGER(*)}, of the same kind as the +The return type is @code{INTEGER}, of the same kind as the argument. @item @emph{See also}: @@ -7500,11 +8344,11 @@ Returns a disassociated pointer. If @var{MOLD} is present, a dissassociated pointer of the same type is returned, otherwise the type is determined by context. -In Fortran 95, @var{MOLD} is optional. Please note that F2003 includes -cases where it is required. +In Fortran 95, @var{MOLD} is optional. Please note that Fortran 2003 +includes cases where it is required. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Transformational function @@ -7550,20 +8394,23 @@ the use of the @ref{IOR} intrinsic defined by the Fortran standard. GNU extension @item @emph{Class}: -Non-elemental function +Function @item @emph{Syntax}: -@code{RESULT = OR(X, Y)} +@code{RESULT = OR(I, J)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be either @code{INTEGER(*)} or @code{LOGICAL}. -@item @var{Y} @tab The type shall be either @code{INTEGER(*)} or @code{LOGICAL}. +@item @var{I} @tab The type shall be either a scalar @code{INTEGER} +type or a scalar @code{LOGICAL} type. +@item @var{J} @tab The type shall be the same as the type of @var{J}. @end multitable @item @emph{Return value}: -The return type is either @code{INTEGER(*)} or @code{LOGICAL} -after cross-promotion of the arguments. +The return type is either a scalar @code{INTEGER} or a scalar +@code{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. @item @emph{Example}: @smallexample @@ -7578,7 +8425,7 @@ END PROGRAM @end smallexample @item @emph{See also}: -F95 elemental function: @ref{IOR} +Fortran 95 elemental function: @ref{IOR} @end table @@ -7599,7 +8446,7 @@ equals @code{TRUE}. Afterwards, positions are filled with elements taken from @var{VECTOR}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Transformational function @@ -7627,7 +8474,7 @@ If @var{VECTOR} is present, the result size is that of @var{VECTOR}, the number of @code{TRUE} values in @var{MASK} otherwise. @item @emph{Example}: -Gathering non-zero elements from an array: +Gathering nonzero elements from an array: @smallexample PROGRAM test_pack_1 INTEGER :: m(6) @@ -7636,7 +8483,7 @@ PROGRAM test_pack_1 END PROGRAM @end smallexample -Gathering non-zero elements from an array and appending elements from @var{VECTOR}: +Gathering nonzero elements from an array and appending elements from @var{VECTOR}: @smallexample PROGRAM test_pack_2 INTEGER :: m(4) @@ -7673,7 +8520,8 @@ Subroutine @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{STRING} @tab A scalar of default @code{CHARACTER} type. +@item @var{STRING} @tab A scalar of type @code{CHARACTER} and of the +default kind. @end multitable @item @emph{See also}: @@ -7693,7 +8541,7 @@ Subroutine type of @code{X}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Inquiry function @@ -7733,7 +8581,7 @@ end program prec_and_range Determines whether an optional dummy argument is present. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Inquiry function @@ -7781,19 +8629,21 @@ Multiplies the elements of @var{ARRAY} along dimension @var{DIM} if the corresponding element in @var{MASK} is @code{TRUE}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Transformational function @item @emph{Syntax}: -@code{RESULT = PRODUCT(ARRAY[, MASK])} -@code{RESULT = PRODUCT(ARRAY, DIM[, MASK])} +@multitable @columnfractions .80 +@item @code{RESULT = PRODUCT(ARRAY[, MASK])} +@item @code{RESULT = PRODUCT(ARRAY, DIM[, MASK])} +@end multitable @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{ARRAY} @tab Shall be an array of type @code{INTEGER(*)}, -@code{REAL(*)} or @code{COMPLEX(*)}. +@item @var{ARRAY} @tab Shall be an array of type @code{INTEGER}, +@code{REAL} or @code{COMPLEX}. @item @var{DIM} @tab (Optional) shall be a scalar of type @code{INTEGER} with a value in the range from 1 to n, where n equals the rank of @var{ARRAY}. @@ -7836,7 +8686,7 @@ END PROGRAM @code{RADIX(X)} returns the base of the model representing the entity @var{X}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Inquiry function @@ -7880,7 +8730,7 @@ documentation. GNU extension @item @emph{Class}: -Non-elemental function +Function @item @emph{See also}: @ref{RAND}, @ref{RANDOM_NUMBER} @@ -7901,18 +8751,23 @@ in the current sequence is returned; if @var{FLAG} is 1, the generator is restarted by @code{CALL SRAND(0)}; if @var{FLAG} has any other value, it is used as a new seed with @code{SRAND}. +This intrinsic routine is provided for backwards compatibility with +GNU Fortran 77. It implements a simple modulo generator as provided +by @command{g77}. For new code, one should consider the use of +@ref{RANDOM_NUMBER} as it implements a superior algorithm. + @item @emph{Standard}: GNU extension @item @emph{Class}: -Non-elemental function +Function @item @emph{Syntax}: -@code{RESULT = RAND(FLAG)} +@code{RESULT = RAND(I)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{FLAG} @tab Shall be a scalar @code{INTEGER} of kind 4. +@item @var{I} @tab Shall be a scalar @code{INTEGER} of kind 4. @end multitable @item @emph{Return value}: @@ -7946,8 +8801,26 @@ end program test_rand Returns a single pseudorandom number or an array of pseudorandom numbers from the uniform distribution over the range @math{ 0 \leq x < 1}. +The runtime-library implements George Marsaglia's KISS (Keep It Simple +Stupid) random number generator (RNG). This RNG combines: +@enumerate +@item The congruential generator @math{x(n) = 69069 \cdot x(n-1) + 1327217885} +with a period of @math{2^{32}}, +@item A 3-shift shift-register generator with a period of @math{2^{32} - 1}, +@item Two 16-bit multiply-with-carry generators with a period of +@math{597273182964842497 > 2^{59}}. +@end enumerate +The overall period exceeds @math{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. + @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Subroutine @@ -7957,7 +8830,7 @@ Subroutine @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{HARVEST} @tab Shall be a scalar or an array of type @code{REAL(*)}. +@item @var{HARVEST} @tab Shall be a scalar or an array of type @code{REAL}. @end multitable @item @emph{Example}: @@ -7969,15 +8842,6 @@ program test_random_number end program @end smallexample -@item @emph{Note}: -The implemented random number generator is thread safe if used within -OpenMP directives, i. e. its state will be consistent while called from -multiple threads. Please note that the currently implemented KISS generator -does not create random numbers in parallel from multiple sources, but in -sequence from a single source. If your OpenMP-enabled application heavily -relies on random numbers, you should consider employing a dedicated parallel -random number generator instead. - @item @emph{See also}: @ref{RANDOM_SEED} @end table @@ -8000,13 +8864,13 @@ a default state. The example below shows how to initialize the random seed based on the system's time. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Subroutine @item @emph{Syntax}: -@code{CALL RANDOM_SEED(SIZE, PUT, GET)} +@code{CALL RANDOM_SEED([SIZE, PUT, GET])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 @@ -8048,7 +8912,7 @@ END SUBROUTINE @node RANGE -@section @code{RANGE} --- Decimal exponent range of a real kind +@section @code{RANGE} --- Decimal exponent range @fnindex RANGE @cindex model representation, range @@ -8058,7 +8922,7 @@ END SUBROUTINE type of @code{X}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Inquiry function @@ -8068,7 +8932,8 @@ Inquiry function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab Shall be of type @code{REAL} or @code{COMPLEX}. +@item @var{X} @tab Shall be of type @code{INTEGER}, @code{REAL} +or @code{COMPLEX}. @end multitable @item @emph{Return value}: @@ -8090,45 +8955,44 @@ See @code{PRECISION} for an example. @table @asis @item @emph{Description}: -@code{REAL(X [, KIND])} converts its argument @var{X} to a real type. The -@code{REALPART(X)} function is provided for compatibility with @command{g77}, +@code{REAL(A [, KIND])} converts its argument @var{A} to a real type. The +@code{REALPART} function is provided for compatibility with @command{g77}, and its use is strongly discouraged. @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: @multitable @columnfractions .80 -@item @code{RESULT = REAL(X [, KIND])} +@item @code{RESULT = REAL(A [, KIND])} @item @code{RESULT = REALPART(Z)} @end multitable @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab Shall be @code{INTEGER(*)}, @code{REAL(*)}, or - @code{COMPLEX(*)}. -@item @var{KIND} @tab (Optional) An @code{INTEGER(*)} initialization - expression indicating the kind parameter of - the result. +@item @var{A} @tab Shall be @code{INTEGER}, @code{REAL}, or +@code{COMPLEX}. +@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: -These functions return a @code{REAL(*)} variable or array under +These functions return a @code{REAL} variable or array under the following rules: @table @asis @item (A) -@code{REAL(X)} is converted to a default real type if @var{X} is an +@code{REAL(A)} is converted to a default real type if @var{A} is an integer or real variable. @item (B) -@code{REAL(X)} is converted to a real type with the kind type parameter -of @var{X} if @var{X} is a complex variable. +@code{REAL(A)} is converted to a real type with the kind type parameter +of @var{A} if @var{A} is a complex variable. @item (C) -@code{REAL(X, KIND)} is converted to a real type with kind type -parameter @var{KIND} if @var{X} is a complex, integer, or real +@code{REAL(A, KIND)} is converted to a real type with kind type +parameter @var{KIND} if @var{A} is a complex, integer, or real variable. @end table @@ -8168,7 +9032,7 @@ however, only one form can be used in any given program unit. GNU extension @item @emph{Class}: -Subroutine, non-elemental function +Subroutine, function @item @emph{Syntax}: @multitable @columnfractions .80 @@ -8201,7 +9065,7 @@ Subroutine, non-elemental function Concatenates @var{NCOPIES} copies of a string. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Transformational function @@ -8211,8 +9075,8 @@ Transformational function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{STRING} @tab Shall be scalar and of type @code{CHARACTER(*)}. -@item @var{NCOPIES} @tab Shall be scalar and of type @code{INTEGER(*)}. +@item @var{STRING} @tab Shall be scalar and of type @code{CHARACTER}. +@item @var{NCOPIES} @tab Shall be scalar and of type @code{INTEGER}. @end multitable @item @emph{Return value}: @@ -8242,7 +9106,7 @@ the new array may be padded with elements from @var{PAD} or permuted as defined by @var{ORDER}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Transformational function @@ -8296,7 +9160,7 @@ END PROGRAM model numbers near @var{X}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @@ -8347,12 +9211,12 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{I} @tab The type shall be @code{INTEGER(*)}. -@item @var{SHIFT} @tab The type shall be @code{INTEGER(*)}. +@item @var{I} @tab The type shall be @code{INTEGER}. +@item @var{SHIFT} @tab The type shall be @code{INTEGER}. @end multitable @item @emph{Return value}: -The return value is of type @code{INTEGER(*)} and of the same kind as +The return value is of type @code{INTEGER} and of the same kind as @var{I}. @item @emph{See also}: @@ -8373,7 +9237,7 @@ The return value is of type @code{INTEGER(*)} and of the same kind as @code{SCALE(X,I)} returns @code{X * RADIX(X)**I}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @@ -8421,24 +9285,26 @@ is returned. If no character of @var{SET} is found in @var{STRING}, the result is zero. @item @emph{Standard}: -F95 and later +Fortran 95 and later, with @var{KIND} argument Fortran 2003 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = SCAN(STRING, SET[, BACK])} +@code{RESULT = SCAN(STRING, SET[, BACK [, KIND]])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{STRING} @tab Shall be of type @code{CHARACTER(*)}. -@item @var{SET} @tab Shall be of type @code{CHARACTER(*)}. +@item @var{STRING} @tab Shall be of type @code{CHARACTER}. +@item @var{SET} @tab Shall be of type @code{CHARACTER}. @item @var{BACK} @tab (Optional) shall be of type @code{LOGICAL}. +@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: -The return value is of type @code{INTEGER} and of the default -integer kind. +The return value is of type @code{INTEGER} and of kind @var{KIND}. If +@var{KIND} is absent, the return value is of default integer kind. @item @emph{Example}: @smallexample @@ -8450,7 +9316,7 @@ END PROGRAM @end smallexample @item @emph{See also}: -@ref{INDEX}, @ref{VERIFY} +@ref{INDEX intrinsic}, @ref{VERIFY} @end table @@ -8472,7 +9338,7 @@ use is discouraged. GNU extension @item @emph{Class}: -Non-elemental function +Function @item @emph{Syntax}: @code{RESULT = SECNDS (X)} @@ -8523,7 +9389,7 @@ however, only one form can be used in any given program unit. GNU extension @item @emph{Class}: -Subroutine, non-elemental function +Subroutine, function @item @emph{Syntax}: @multitable @columnfractions .80 @@ -8547,6 +9413,48 @@ seconds. +@node SELECTED_CHAR_KIND +@section @code{SELECTED_CHAR_KIND} --- Choose character kind +@fnindex SELECTED_CHAR_KIND +@cindex character kind +@cindex kind, character + +@table @asis +@item @emph{Description}: + +@code{SELECTED_CHAR_KIND(NAME)} returns the kind value for the character +set named @var{NAME}, if a character set with such a name is supported, +or @math{-1} otherwise. Currently, supported character sets include +``ASCII'' and ``DEFAULT'', which are equivalent. + +@item @emph{Standard}: +Fortran 2003 and later + +@item @emph{Class}: +Transformational function + +@item @emph{Syntax}: +@code{RESULT = SELECTED_CHAR_KIND(NAME)} + +@item @emph{Arguments}: +@multitable @columnfractions .15 .70 +@item @var{NAME} @tab Shall be a scalar and of the default character type. +@end multitable + +@item @emph{Example}: +@smallexample +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 +@end smallexample +@end table + + + @node SELECTED_INT_KIND @section @code{SELECTED_INT_KIND} --- Choose integer kind @fnindex SELECTED_INT_KIND @@ -8555,23 +9463,23 @@ seconds. @table @asis @item @emph{Description}: -@code{SELECTED_INT_KIND(I)} return the kind value of the smallest integer -type that can represent all values ranging from @math{-10^I} (exclusive) -to @math{10^I} (exclusive). If there is no integer kind that accommodates +@code{SELECTED_INT_KIND(R)} return the kind value of the smallest integer +type that can represent all values ranging from @math{-10^R} (exclusive) +to @math{10^R} (exclusive). If there is no integer kind that accommodates this range, @code{SELECTED_INT_KIND} returns @math{-1}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Transformational function @item @emph{Syntax}: -@code{RESULT = SELECTED_INT_KIND(I)} +@code{RESULT = SELECTED_INT_KIND(R)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{I} @tab Shall be a scalar and of type @code{INTEGER}. +@item @var{R} @tab Shall be a scalar and of type @code{INTEGER}. @end multitable @item @emph{Example}: @@ -8601,18 +9509,18 @@ end program large_integers @table @asis @item @emph{Description}: -@code{SELECTED_REAL_KIND(P,R)} return the kind value of a real data type -with decimal precision greater of at least @code{P} digits and exponent +@code{SELECTED_REAL_KIND(P,R)} returns the kind value of a real data type +with decimal precision of at least @code{P} digits and exponent range greater at least @code{R}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Transformational function @item @emph{Syntax}: -@code{RESULT = SELECTED_REAL_KIND(P, R)} +@code{RESULT = SELECTED_REAL_KIND([P, R])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 @@ -8668,7 +9576,7 @@ end program real_kinds is that that of @var{X} and whose exponent part is @var{I}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @@ -8711,7 +9619,7 @@ END PROGRAM Determines the shape of an array. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Inquiry function @@ -8759,7 +9667,7 @@ END PROGRAM @code{SIGN(A,B)} returns the value of @var{A} with the sign of @var{B}. @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @@ -8821,7 +9729,7 @@ is supplied, it is set to the value returned by @code{signal(2)}. GNU extension @item @emph{Class}: -Subroutine, non-elemental function +Subroutine, function @item @emph{Syntax}: @multitable @columnfractions .80 @@ -8838,6 +9746,7 @@ Subroutine, non-elemental function @item @var{STATUS} @tab (Optional) @var{STATUS} shall be a scalar integer. It has @code{INTENT(OUT)}. @end multitable +@c TODO: What should the interface of the handler be? Does it take arguments? @item @emph{Return value}: The @code{SIGNAL} function returns the value returned by @code{signal(2)}. @@ -8873,7 +9782,7 @@ end program test_signal @code{SIN(X)} computes the sine of @var{X}. @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @@ -8883,8 +9792,8 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)} or -@code{COMPLEX(*)}. +@item @var{X} @tab The type shall be @code{REAL} or +@code{COMPLEX}. @end multitable @item @emph{Return value}: @@ -8926,7 +9835,7 @@ end program test_sin @code{SINH(X)} computes the hyperbolic sine of @var{X}. @item @emph{Standard}: -F95 and later +Fortran 95 and later, for a complex argument Fortran 2008 or later @item @emph{Class}: Elemental function @@ -8936,11 +9845,11 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)}. +@item @var{X} @tab The type shall be @code{REAL} or @code{COMPLEX}. @end multitable @item @emph{Return value}: -The return value is of type @code{REAL(*)}. +The return value has same type and kind as @var{X}. @item @emph{Example}: @smallexample @@ -8953,7 +9862,7 @@ end program test_sinh @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Argument @tab Return type @tab Standard -@item @code{DSINH(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F95 and later +@item @code{DSINH(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab Fortran 95 and later @end multitable @item @emph{See also}: @@ -8975,13 +9884,13 @@ Determine the extent of @var{ARRAY} along a specified dimension @var{DIM}, or the total number of elements in @var{ARRAY} if @var{DIM} is absent. @item @emph{Standard}: -F95 and later +Fortran 95 and later, with @var{KIND} argument Fortran 2003 and later @item @emph{Class}: Inquiry function @item @emph{Syntax}: -@code{RESULT = SIZE(ARRAY[, DIM])} +@code{RESULT = SIZE(ARRAY[, DIM [, KIND]])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 @@ -8990,11 +9899,13 @@ a pointer it must be associated and allocatable arrays must be allocated. @item @var{DIM} @tab (Optional) shall be a scalar of type @code{INTEGER} and its value shall be in the range from 1 to n, where n equals the rank of @var{ARRAY}. +@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: -The return value is of type @code{INTEGER} and of the default -integer kind. +The return value is of type @code{INTEGER} and of kind @var{KIND}. If +@var{KIND} is absent, the return value is of default integer kind. @item @emph{Example}: @smallexample @@ -9008,6 +9919,54 @@ END PROGRAM @end table +@node SIZEOF +@section @code{SIZEOF} --- Size in bytes of an expression +@fnindex SIZEOF +@cindex expression size +@cindex size of an expression + +@table @asis +@item @emph{Description}: +@code{SIZEOF(X)} calculates the number of bytes of storage the +expression @code{X} occupies. + +@item @emph{Standard}: +GNU extension + +@item @emph{Class}: +Intrinsic function + +@item @emph{Syntax}: +@code{N = SIZEOF(X)} + +@item @emph{Arguments}: +@multitable @columnfractions .15 .70 +@item @var{X} @tab The argument shall be of any type, rank or shape. +@end multitable + +@item @emph{Return value}: +The return value is of type integer and of the system-dependent kind +@var{C_SIZE_T} (from the @var{ISO_C_BINDING} module). Its value is the +number of bytes occupied by the argument. If the argument has the +@code{POINTER} attribute, the number of bytes of the storage area pointed +to is returned. If the argument is of a derived type with @code{POINTER} +or @code{ALLOCATABLE} components, the return value doesn't account for +the sizes of the data pointed to by these components. + +@item @emph{Example}: +@smallexample + integer :: i + real :: r, s(5) + print *, (sizeof(s)/sizeof(r) == 5) + end +@end smallexample +The example will print @code{.TRUE.} unless you are using a platform +where default @code{REAL} variables are unusually padded. + +@item @emph{See also}: +@ref{C_SIZEOF} +@end table + @node SLEEP @section @code{SLEEP} --- Sleep for the specified number of seconds @@ -9054,7 +10013,7 @@ to a default real value. This is an archaic form of @code{REAL} that is specific to one type for @var{A}. @item @emph{Standard}: -GNU extension +Fortran 77 and later @item @emph{Class}: Elemental function @@ -9088,7 +10047,7 @@ Determines the distance between the argument @var{X} and the nearest adjacent number of the same type. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Elemental function @@ -9098,7 +10057,7 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab Shall be of type @code{REAL(*)}. +@item @var{X} @tab Shall be of type @code{REAL}. @end multitable @item @emph{Return value}: @@ -9125,7 +10084,7 @@ END PROGRAM @section @code{SPREAD} --- Add a dimension to an array @fnindex SPREAD @cindex array, increase dimension -@cindex array, duplicate elementes +@cindex array, duplicate elements @cindex array, duplicate dimensions @table @asis @@ -9134,7 +10093,7 @@ Replicates a @var{SOURCE} array @var{NCOPIES} times along a specified dimension @var{DIM}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Transformational function @@ -9185,7 +10144,7 @@ END PROGRAM @code{SQRT(X)} computes the square root of @var{X}. @item @emph{Standard}: -F77 and later +Fortran 77 and later @item @emph{Class}: Elemental function @@ -9195,12 +10154,12 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)} or -@code{COMPLEX(*)}. +@item @var{X} @tab The type shall be @code{REAL} or +@code{COMPLEX}. @end multitable @item @emph{Return value}: -The return value is of type @code{REAL(*)} or @code{COMPLEX(*)}. +The return value is of type @code{REAL} or @code{COMPLEX}. The kind type parameter is the same as @var{X}. @item @emph{Example}: @@ -9216,8 +10175,8 @@ end program test_sqrt @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Argument @tab Return type @tab Standard -@item @code{DSQRT(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F95 and later -@item @code{CSQRT(X)} @tab @code{COMPLEX(4) X} @tab @code{COMPLEX(4)} @tab F95 and later +@item @code{DSQRT(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab Fortran 95 and later +@item @code{CSQRT(X)} @tab @code{COMPLEX(4) X} @tab @code{COMPLEX(4)} @tab Fortran 95 and later @item @code{ZSQRT(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab GNU extension @item @code{CDSQRT(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab GNU extension @end multitable @@ -9241,7 +10200,7 @@ generator is specified by the required argument @var{SEED}. GNU extension @item @emph{Class}: -Non-elemental subroutine +Subroutine @item @emph{Syntax}: @code{CALL SRAND(SEED)} @@ -9252,7 +10211,7 @@ Non-elemental subroutine @end multitable @item @emph{Return value}: -Does not return. +Does not return anything. @item @emph{Example}: See @code{RAND} and @code{IRAND} for examples. @@ -9284,42 +10243,45 @@ 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 @code{BUFF}: +The elements that are obtained and stored in the array @code{VALUES}: @multitable @columnfractions .15 .70 -@item @code{buff(1)} @tab Device ID -@item @code{buff(2)} @tab Inode number -@item @code{buff(3)} @tab File mode -@item @code{buff(4)} @tab Number of links -@item @code{buff(5)} @tab Owner's uid -@item @code{buff(6)} @tab Owner's gid -@item @code{buff(7)} @tab ID of device containing directory entry for file (0 if not available) -@item @code{buff(8)} @tab File size (bytes) -@item @code{buff(9)} @tab Last access time -@item @code{buff(10)} @tab Last modification time -@item @code{buff(11)} @tab Last file status change time -@item @code{buff(12)} @tab Preferred I/O block size (-1 if not available) -@item @code{buff(13)} @tab Number of blocks allocated (-1 if not available) +@item @code{VALUES(1)} @tab Device ID +@item @code{VALUES(2)} @tab Inode number +@item @code{VALUES(3)} @tab File mode +@item @code{VALUES(4)} @tab Number of links +@item @code{VALUES(5)} @tab Owner's uid +@item @code{VALUES(6)} @tab Owner's gid +@item @code{VALUES(7)} @tab ID of device containing directory entry for file (0 if not available) +@item @code{VALUES(8)} @tab File size (bytes) +@item @code{VALUES(9)} @tab Last access time +@item @code{VALUES(10)} @tab Last modification time +@item @code{VALUES(11)} @tab Last file status change time +@item @code{VALUES(12)} @tab Preferred I/O block size (-1 if not available) +@item @code{VALUES(13)} @tab Number of blocks allocated (-1 if not available) @end multitable 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. @item @emph{Standard}: GNU extension @item @emph{Class}: -Non-elemental subroutine +Subroutine, function @item @emph{Syntax}: -@code{CALL STAT(FILE,BUFF[,STATUS])} +@code{CALL STAT(NAME, VALUES [, STATUS])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{FILE} @tab The type shall be @code{CHARACTER(*)}, a valid path within the file system. -@item @var{BUFF} @tab The type shall be @code{INTEGER(4), DIMENSION(13)}. +@item @var{NAME} @tab The type shall be @code{CHARACTER}, of the +default kind and a valid path within the file system. +@item @var{VALUES} @tab The type shall be @code{INTEGER(4), DIMENSION(13)}. @item @var{STATUS} @tab (Optional) status flag of type @code{INTEGER(4)}. Returns 0 - on success and a system specific error code otherwise. +on success and a system specific error code otherwise. @end multitable @item @emph{Example}: @@ -9368,19 +10330,21 @@ Adds the elements of @var{ARRAY} along dimension @var{DIM} if the corresponding element in @var{MASK} is @code{TRUE}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Transformational function @item @emph{Syntax}: -@code{RESULT = SUM(ARRAY[, MASK])} -@code{RESULT = SUM(ARRAY, DIM[, MASK])} +@multitable @columnfractions .80 +@item @code{RESULT = SUM(ARRAY[, MASK])} +@item @code{RESULT = SUM(ARRAY, DIM[, MASK])} +@end multitable @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{ARRAY} @tab Shall be an array of type @code{INTEGER(*)}, -@code{REAL(*)} or @code{COMPLEX(*)}. +@item @var{ARRAY} @tab Shall be an array of type @code{INTEGER}, +@code{REAL} or @code{COMPLEX}. @item @var{DIM} @tab (Optional) shall be a scalar of type @code{INTEGER} with a value in the range from 1 to n, where n equals the rank of @var{ARRAY}. @@ -9434,7 +10398,7 @@ however, only one form can be used in any given program unit. GNU extension @item @emph{Class}: -Subroutine, non-elemental function +Subroutine, function @item @emph{Syntax}: @multitable @columnfractions .80 @@ -9476,7 +10440,7 @@ however, only one form can be used in any given program unit. GNU extension @item @emph{Class}: -Subroutine, non-elemental function +Subroutine, function @item @emph{Syntax}: @multitable @columnfractions .80 @@ -9513,7 +10477,7 @@ If there is no clock, @var{COUNT} is set to @code{-HUGE(COUNT)}, and @var{COUNT_RATE} and @var{COUNT_MAX} are set to zero @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Subroutine @@ -9559,7 +10523,7 @@ END PROGRAM @code{TAN(X)} computes the tangent of @var{X}. @item @emph{Standard}: -F77 and later +Fortran 77 and later, for a complex argument Fortran 2008 or later @item @emph{Class}: Elemental function @@ -9569,12 +10533,11 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)}. +@item @var{X} @tab The type shall be @code{REAL} or @code{COMPLEX}. @end multitable @item @emph{Return value}: -The return value is of type @code{REAL(*)}. The kind type parameter is -the same as @var{X}. +The return value has same type and kind as @var{X}. @item @emph{Example}: @smallexample @@ -9587,7 +10550,7 @@ end program test_tan @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Argument @tab Return type @tab Standard -@item @code{DTAN(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F95 and later +@item @code{DTAN(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab Fortran 95 and later @end multitable @item @emph{See also}: @@ -9609,7 +10572,7 @@ end program test_tan @code{TANH(X)} computes the hyperbolic tangent of @var{X}. @item @emph{Standard}: -F77 and later +Fortran 77 and later, for a complex argument Fortran 2008 or later @item @emph{Class}: Elemental function @@ -9619,11 +10582,13 @@ Elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be @code{REAL(*)}. +@item @var{X} @tab The type shall be @code{REAL} or @code{COMPLEX}. @end multitable @item @emph{Return value}: -The return value is of type @code{REAL(*)} and lies in the range +The return value has same type and kind as @var{X}. If @var{X} is +complex, the imaginary part of the result is in radians. If @var{X} +is @code{REAL}, the return value lies in the range @math{ - 1 \leq tanh(x) \leq 1 }. @item @emph{Example}: @@ -9637,7 +10602,7 @@ end program test_tanh @item @emph{Specific names}: @multitable @columnfractions .20 .20 .20 .25 @item Name @tab Argument @tab Return type @tab Standard -@item @code{DTANH(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab F95 and later +@item @code{DTANH(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab Fortran 95 and later @end multitable @item @emph{See also}: @@ -9672,7 +10637,7 @@ compilers. GNU extension @item @emph{Class}: -Non-elemental function +Function @item @emph{Syntax}: @code{RESULT = TIME()} @@ -9711,7 +10676,7 @@ less than previous values during a single run of the compiled program. GNU extension @item @emph{Class}: -Non-elemental function +Function @item @emph{Syntax}: @code{RESULT = TIME8()} @@ -9738,7 +10703,7 @@ The return value is a scalar of type @code{INTEGER(8)}. in the model of the type of @code{X}. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Inquiry function @@ -9760,6 +10725,46 @@ See @code{HUGE} for an example. +@node TRAILZ +@section @code{TRAILZ} --- Number of trailing zero bits of an integer +@fnindex TRAILZ +@cindex zero bits + +@table @asis +@item @emph{Description}: +@code{TRAILZ} returns the number of trailing zero bits of an integer. + +@item @emph{Standard}: +Fortran 2008 and later + +@item @emph{Class}: +Elemental function + +@item @emph{Syntax}: +@code{RESULT = TRAILZ(I)} + +@item @emph{Arguments}: +@multitable @columnfractions .15 .70 +@item @var{I} @tab Shall be of type @code{INTEGER}. +@end multitable + +@item @emph{Return value}: +The type of the return value is the default @code{INTEGER}. +If all the bits of @code{I} are zero, the result value is @code{BIT_SIZE(I)}. + +@item @emph{Example}: +@smallexample +PROGRAM test_trailz + WRITE (*,*) TRAILZ(8) ! prints 3 +END PROGRAM +@end smallexample + +@item @emph{See also}: +@ref{BIT_SIZE}, @ref{LEADZ} +@end table + + + @node TRANSFER @section @code{TRANSFER} --- Transfer bit patterns @fnindex TRANSFER @@ -9776,7 +10781,7 @@ This is approximately equivalent to the C concept of @emph{casting} one type to another. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Transformational function @@ -9836,7 +10841,7 @@ Transpose an array of rank two. Element (i, j) of the result has the value @code{MATRIX(j, i)}, for all i, j. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Transformational function @@ -9850,7 +10855,7 @@ Transformational function @end multitable @item @emph{Return value}: -The result has the the same type as @var{MATRIX}, and has shape +The result has the same type as @var{MATRIX}, and has shape @code{(/ m, n /)} if @var{MATRIX} has shape @code{(/ n, m /)}. @end table @@ -9866,7 +10871,7 @@ The result has the the same type as @var{MATRIX}, and has shape Removes trailing blank characters of a string. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Transformational function @@ -9876,11 +10881,11 @@ Transformational function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{STRING} @tab Shall be a scalar of type @code{CHARACTER(*)}. +@item @var{STRING} @tab Shall be a scalar of type @code{CHARACTER}. @end multitable @item @emph{Return value}: -A scalar of type @code{CHARACTER(*)} which length is that of @var{STRING} +A scalar of type @code{CHARACTER} which length is that of @var{STRING} less the number of trailing blanks. @item @emph{Example}: @@ -9914,7 +10919,7 @@ however, only one form can be used in any given program unit. GNU extension @item @emph{Class}: -Subroutine, non-elemental function +Subroutine, function @item @emph{Syntax}: @multitable @columnfractions .80 @@ -9924,8 +10929,8 @@ Subroutine, non-elemental function @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{UNIT} @tab Shall be a scalar @code{INTEGER(*)}. -@item @var{NAME} @tab Shall be of type @code{CHARACTER(*)}. +@item @var{UNIT} @tab Shall be a scalar @code{INTEGER}. +@item @var{NAME} @tab Shall be of type @code{CHARACTER}. @end multitable @item @emph{Example}: @@ -9954,21 +10959,25 @@ END PROGRAM Returns the upper bounds of an array, or a single upper bound along the @var{DIM} dimension. @item @emph{Standard}: -F95 and later +Fortran 95 and later, with @var{KIND} argument Fortran 2003 and later @item @emph{Class}: Inquiry function @item @emph{Syntax}: -@code{RESULT = UBOUND(ARRAY [, DIM])} +@code{RESULT = UBOUND(ARRAY [, DIM [, KIND]])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 @item @var{ARRAY} @tab Shall be an array, of any type. -@item @var{DIM} @tab (Optional) Shall be a scalar @code{INTEGER(*)}. +@item @var{DIM} @tab (Optional) Shall be a scalar @code{INTEGER}. +@item @var{KIND}@tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: +The return value is of type @code{INTEGER} and of kind @var{KIND}. If +@var{KIND} is absent, the return value is of default integer kind. If @var{DIM} is absent, the result is an array of the upper bounds of @var{ARRAY}. If @var{DIM} is present, the result is a scalar corresponding to the upper bound of the array along that dimension. If @@ -9990,23 +10999,25 @@ the relevant dimension. @table @asis @item @emph{Description}: -Sets the file creation mask to @var{MASK} and returns the old value in -argument @var{OLD} if it is supplied. See @code{umask(2)}. +Sets the file creation mask to @var{MASK}. If called as a function, it +returns the old value. If called as a subroutine and argument @var{OLD} +if it is supplied, it is set to the old value. See @code{umask(2)}. @item @emph{Standard}: GNU extension @item @emph{Class}: -Subroutine +Subroutine, function @item @emph{Syntax}: @code{CALL UMASK(MASK [, OLD])} +@code{OLD = UMASK(MASK)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{MASK} @tab Shall be a scalar of type @code{INTEGER(*)}. -@item @var{MASK} @tab (Optional) Shall be a scalar of type - @code{INTEGER(*)}. +@item @var{MASK} @tab Shall be a scalar of type @code{INTEGER}. +@item @var{OLD} @tab (Optional) Shall be a scalar of type +@code{INTEGER}. @end multitable @end table @@ -10033,7 +11044,7 @@ however, only one form can be used in any given program unit. GNU extension @item @emph{Class}: -Subroutine, non-elemental function +Subroutine, function @item @emph{Syntax}: @multitable @columnfractions .80 @@ -10065,7 +11076,7 @@ Subroutine, non-elemental function Store the elements of @var{VECTOR} in an array of higher rank. @item @emph{Standard}: -F95 and later +Fortran 95 and later @item @emph{Class}: Transformational function @@ -10078,7 +11089,7 @@ Transformational function @item @var{VECTOR} @tab Shall be an array of any type and rank one. It shall have at least as many elements as @var{MASK} has @code{TRUE} values. @item @var{MASK} @tab Shall be an array of type @code{LOGICAL}. -@item @var{FIELD} @tab Shall be of the sam type as @var{VECTOR} and have +@item @var{FIELD} @tab Shall be of the same type as @var{VECTOR} and have the same shape as @var{MASK}. @end multitable @@ -10120,24 +11131,26 @@ is returned. If all characters of @var{SET} are found in @var{STRING}, the result is zero. @item @emph{Standard}: -F95 and later +Fortran 95 and later, with @var{KIND} argument Fortran 2003 and later @item @emph{Class}: Elemental function @item @emph{Syntax}: -@code{RESULT = VERFIY(STRING, SET[, BACK])} +@code{RESULT = VERIFY(STRING, SET[, BACK [, KIND]])} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{STRING} @tab Shall be of type @code{CHARACTER(*)}. -@item @var{SET} @tab Shall be of type @code{CHARACTER(*)}. +@item @var{STRING} @tab Shall be of type @code{CHARACTER}. +@item @var{SET} @tab Shall be of type @code{CHARACTER}. @item @var{BACK} @tab (Optional) shall be of type @code{LOGICAL}. +@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization +expression indicating the kind parameter of the result. @end multitable @item @emph{Return value}: -The return value is of type @code{INTEGER} and of the default -integer kind. +The return value is of type @code{INTEGER} and of kind @var{KIND}. If +@var{KIND} is absent, the return value is of default integer kind. @item @emph{Example}: @smallexample @@ -10151,7 +11164,7 @@ END PROGRAM @end smallexample @item @emph{See also}: -@ref{SCAN}, @ref{INDEX} +@ref{SCAN}, @ref{INDEX intrinsic} @end table @@ -10168,26 +11181,30 @@ 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 @ref{IEOR} intrinsic defined by the Fortran standard. +the use of the @ref{IEOR} intrinsic and for logical arguments the +@code{.NEQV.} operator, which are both defined by the Fortran standard. @item @emph{Standard}: GNU extension @item @emph{Class}: -Non-elemental function +Function @item @emph{Syntax}: -@code{RESULT = XOR(X, Y)} +@code{RESULT = XOR(I, J)} @item @emph{Arguments}: @multitable @columnfractions .15 .70 -@item @var{X} @tab The type shall be either @code{INTEGER(*)} or @code{LOGICAL}. -@item @var{Y} @tab The type shall be either @code{INTEGER(*)} or @code{LOGICAL}. +@item @var{I} @tab The type shall be either a scalar @code{INTEGER} +type or a scalar @code{LOGICAL} type. +@item @var{J} @tab The type shall be the same as the type of @var{I}. @end multitable @item @emph{Return value}: -The return type is either @code{INTEGER(*)} or @code{LOGICAL} -after cross-promotion of the arguments. +The return type is either a scalar @code{INTEGER} or a scalar +@code{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. @item @emph{Example}: @smallexample @@ -10202,7 +11219,180 @@ END PROGRAM @end smallexample @item @emph{See also}: -F95 elemental function: @ref{IEOR} +Fortran 95 elemental function: @ref{IEOR} +@end table + + + +@node Intrinsic Modules +@chapter Intrinsic Modules +@cindex intrinsic Modules + +@menu +* ISO_FORTRAN_ENV:: +* ISO_C_BINDING:: +* OpenMP Modules OMP_LIB and OMP_LIB_KINDS:: +@end menu + +@node ISO_FORTRAN_ENV +@section @code{ISO_FORTRAN_ENV} +@table @asis +@item @emph{Standard}: +Fortran 2003 and later; @code{INT8}, @code{INT16}, @code{INT32}, @code{INT64}, +@code{REAL32}, @code{REAL64}, @code{REAL128} are Fortran 2008 or later +@end table + +The @code{ISO_FORTRAN_ENV} module provides the following scalar default-integer +named constants: + +@table @asis +@item @code{CHARACTER_STORAGE_SIZE}: +Size in bits of the character storage unit. + +@item @code{ERROR_UNIT}: +Identifies the preconnected unit used for error reporting. + +@item @code{FILE_STORAGE_SIZE}: +Size in bits of the file-storage unit. + +@item @code{INPUT_UNIT}: +Identifies the preconnected unit identified by the asterisk +(@code{*}) in @code{READ} statement. + +@item @code{INT8}, @code{INT16}, @code{INT32}, @code{INT64} +Kind type parameters to specify an INTEGER type with a storage +size of 16, 32, and 64 bits. It is negative if a target platform +does not support the particular kind. + +@item @code{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. + +@item @code{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. + +@item @code{NUMERIC_STORAGE_SIZE}: +The size in bits of the numeric storage unit. + +@item @code{OUTPUT_UNIT}: +Identifies the preconnected unit identified by the asterisk +(@code{*}) in @code{WRITE} statement. + +@item @code{REAL32}, @code{REAL64}, @code{REAL128} +Kind type parameters to specify a REAL type with a storage +size of 32, 64, and 128 bits. It is negative if a target platform +does not support the particular kind. +@end table + + + +@node ISO_C_BINDING +@section @code{ISO_C_BINDING} +@table @asis +@item @emph{Standard}: +Fortran 2003 and later, GNU extensions +@end table + +The following intrinsic procedures are provided by the module; their +definition can be found in the section Intrinsic Procedures of this +manual. + +@table @asis +@item @code{C_ASSOCIATED} +@item @code{C_F_POINTER} +@item @code{C_F_PROCPOINTER} +@item @code{C_FUNLOC} +@item @code{C_LOC} +@end table +@c TODO: Vertical spacing between C_FUNLOC and C_LOC wrong in PDF, +@c don't really know why. + +The @code{ISO_C_BINDING} module provides the following named constants of +type default integer, which can be used as KIND type parameters. + +In addition to the integer named constants required by the Fortran 2003 +standard, GNU Fortran provides as an extension named constants for the +128-bit integer types supported by the C compiler: @code{C_INT128_T, +C_INT_LEAST128_T, C_INT_FAST128_T}. + +@multitable @columnfractions .15 .35 .35 .35 +@item Fortran Type @tab Named constant @tab C type @tab Extension +@item @code{INTEGER}@tab @code{C_INT} @tab @code{int} +@item @code{INTEGER}@tab @code{C_SHORT} @tab @code{short int} +@item @code{INTEGER}@tab @code{C_LONG} @tab @code{long int} +@item @code{INTEGER}@tab @code{C_LONG_LONG} @tab @code{long long int} +@item @code{INTEGER}@tab @code{C_SIGNED_CHAR} @tab @code{signed char}/@code{unsigned char} +@item @code{INTEGER}@tab @code{C_SIZE_T} @tab @code{size_t} +@item @code{INTEGER}@tab @code{C_INT8_T} @tab @code{int8_t} +@item @code{INTEGER}@tab @code{C_INT16_T} @tab @code{int16_t} +@item @code{INTEGER}@tab @code{C_INT32_T} @tab @code{int32_t} +@item @code{INTEGER}@tab @code{C_INT64_T} @tab @code{int64_t} +@item @code{INTEGER}@tab @code{C_INT128_T} @tab @code{int128_t} @tab Ext. +@item @code{INTEGER}@tab @code{C_INT_LEAST8_T} @tab @code{int_least8_t} +@item @code{INTEGER}@tab @code{C_INT_LEAST16_T} @tab @code{int_least16_t} +@item @code{INTEGER}@tab @code{C_INT_LEAST32_T} @tab @code{int_least32_t} +@item @code{INTEGER}@tab @code{C_INT_LEAST64_T} @tab @code{int_least64_t} +@item @code{INTEGER}@tab @code{C_INT_LEAST128_T}@tab @code{int_least128_t} @tab Ext. +@item @code{INTEGER}@tab @code{C_INT_FAST8_T} @tab @code{int_fast8_t} +@item @code{INTEGER}@tab @code{C_INT_FAST16_T} @tab @code{int_fast16_t} +@item @code{INTEGER}@tab @code{C_INT_FAST32_T} @tab @code{int_fast32_t} +@item @code{INTEGER}@tab @code{C_INT_FAST64_T} @tab @code{int_fast64_t} +@item @code{INTEGER}@tab @code{C_INT_FAST128_T} @tab @code{int_fast128_t} @tab Ext. +@item @code{INTEGER}@tab @code{C_INTMAX_T} @tab @code{intmax_t} +@item @code{INTEGER}@tab @code{C_INTPTR_T} @tab @code{intptr_t} +@item @code{REAL} @tab @code{C_FLOAT} @tab @code{float} +@item @code{REAL} @tab @code{C_DOUBLE} @tab @code{double} +@item @code{REAL} @tab @code{C_LONG_DOUBLE} @tab @code{long double} +@item @code{COMPLEX}@tab @code{C_FLOAT_COMPLEX} @tab @code{float _Complex} +@item @code{COMPLEX}@tab @code{C_DOUBLE_COMPLEX}@tab @code{double _Complex} +@item @code{COMPLEX}@tab @code{C_LONG_DOUBLE_COMPLEX}@tab @code{long double _Complex} +@item @code{LOGICAL}@tab @code{C_BOOL} @tab @code{_Bool} +@item @code{CHARACTER}@tab @code{C_CHAR} @tab @code{char} +@end multitable + +Additionally, the following @code{(CHARACTER(KIND=C_CHAR))} are +defined. + +@multitable @columnfractions .20 .45 .15 +@item Name @tab C definition @tab Value +@item @code{C_NULL_CHAR} @tab null character @tab @code{'\0'} +@item @code{C_ALERT} @tab alert @tab @code{'\a'} +@item @code{C_BACKSPACE} @tab backspace @tab @code{'\b'} +@item @code{C_FORM_FEED} @tab form feed @tab @code{'\f'} +@item @code{C_NEW_LINE} @tab new line @tab @code{'\n'} +@item @code{C_CARRIAGE_RETURN} @tab carriage return @tab @code{'\r'} +@item @code{C_HORIZONTAL_TAB} @tab horizontal tab @tab @code{'\t'} +@item @code{C_VERTICAL_TAB} @tab vertical tab @tab @code{'\v'} +@end multitable + +@node OpenMP Modules OMP_LIB and OMP_LIB_KINDS +@section OpenMP Modules @code{OMP_LIB} and @code{OMP_LIB_KINDS} +@table @asis +@item @emph{Standard}: +OpenMP Application Program Interface v3.0 @end table +The OpenMP Fortran runtime library routines are provided both in +a form of two Fortran 90 modules, named @code{OMP_LIB} and +@code{OMP_LIB_KINDS}, and in a form of a Fortran @code{include} file named +@file{omp_lib.h}. The procedures provided by @code{OMP_LIB} can be found +in the @ref{Top,,Introduction,libgomp,GNU OpenMP runtime library} manual, +the named constants defined in the @code{OMP_LIB_KINDS} module are listed +below. + +For details refer to the actual +@uref{http://www.openmp.org/mp-documents/spec30.pdf, +OpenMP Application Program Interface v3.0}. + +@code{OMP_LIB_KINDS} provides the following scalar default-integer +named constants: + +@table @asis +@item @code{omp_integer_kind} +@item @code{omp_logical_kind} +@item @code{omp_lock_kind} +@item @code{omp_nest_lock_kind} +@item @code{omp_sched_kind} +@end table