@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.
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:
* @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_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
* @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
* @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
* @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
* @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
* @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
* @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
* @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
* @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
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
@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
@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
@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
@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}:
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
@code{ACOS(X)} computes the arccosine of @var{X} (inverse of @code{COS(X)}).
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later
@item @emph{Class}:
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 be @code{REAL} with a magnitude that is
+less than or equal to one.
@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 type @code{REAL} and it lies in the
+range @math{ 0 \leq \acos(x) \leq \pi}. The return value if of the same
+kind as @var{X}.
@item @emph{Example}:
@smallexample
@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}:
@code{COSH(X)}).
@item @emph{Standard}:
-GNU extension
+Fortran 2008 and later
@item @emph{Class}:
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}
@item @emph{Example}:
@smallexample
@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
@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
@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
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
@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}:
@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
@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}.
@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
in the array along dimension @var{DIM}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Transformational function
@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
@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
@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
@end smallexample
@item @emph{See also}:
-F95 elemental function: @ref{IAND}
+Fortran 95 elemental function: @ref{IAND}
@end table
@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
@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
@var{MASK} along dimension @var{DIM} are @code{.TRUE.}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Transformational function
@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
@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
@item @emph{Class}:
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 @code{REAL}, and a magnitude that is
+less than or equal to one.
@end multitable
@item @emph{Return value}:
-The return value is of type @code{REAL(*)} and it lies in the
+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}.
@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}:
@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
@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}.
@item @emph{Example}:
@smallexample
@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}:
@code{ATAN(X)} computes the arctangent of @var{X}.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later
@item @emph{Class}:
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(*)} and it lies in the
+The return value is of type @code{REAL} and it lies in the
range @math{ - \pi / 2 \leq \atan (x) \leq \pi / 2}.
@item @emph{Example}:
@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}:
@table @asis
@item @emph{Description}:
-@code{ATAN2(Y,X)} computes the arctangent of the complex number
+@code{ATAN2(Y, X)} computes the arctangent of the complex number
@math{X + i Y}.
@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
@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
of @code{TANH(X)}).
@item @emph{Standard}:
-GNU extension
+Fortran 2008 and later
@item @emph{Class}:
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}.
@item @emph{Example}:
@smallexample
-@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
-@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
-@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 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(*)}.
+@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
-@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
-@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 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(*)}.
+@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
@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
@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
@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
@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}:
@table @asis
@item @emph{Description}:
-@code{C_ASSOICATED(c_prt1[, c_ptr2])} determines the status of the C pointer @var{c_ptr1}
-or if @var{c_ptr1} is associated with the target @var{c_ptr2}.
+@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}:
-F2003 and later
+Fortran 2003 and later
@item @emph{Class}:
Inquiry function
@item @emph{Syntax}:
-@code{RESULT = C_ASSOICATED(c_prt1[, c_ptr2])}
+@code{RESULT = C_ASSOCIATED(c_prt_1[, c_ptr_2])}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{c_ptr1} @tab Scalar of the type @code{C_PTR} or @code{C_FUNPTR}.
-@item @var{c_ptr2} @tab (Optional) Scalar of the same type as @var{c_ptr1}.
+@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_ptr1} is a C NULL pointer or if @var{c_ptr1} and @var{c_ptr2}
+@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}:
@code{C_FUNLOC(x)} determines the C address of the argument.
@item @emph{Standard}:
-F2003 and later
+Fortran 2003 and later
@item @emph{Class}:
Inquiry function
@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}.
+@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}:
-F2003 and later
+Fortran 2003 and later
@item @emph{Class}:
Subroutine
@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)}.
+@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}:
@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
+@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}:
-F2003 and later
+Fortran 2003 and later
@item @emph{Class}:
Subroutine
@item @emph{Syntax}:
-@code{CALL C_F_POINTER(cptr, fptr[, shape])}
+@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}.
+@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}:
@table @asis
@item @emph{Description}:
-@code{C_LOC(x)} determines the C address of the argument.
+@code{C_LOC(X)} determines the C address of the argument.
@item @emph{Standard}:
-F2003 and later
+Fortran 2003 and later
@item @emph{Class}:
Inquiry function
@item @emph{Syntax}:
-@code{RESULT = C_LOC(x)}
+@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.
+@item @var{X} @tab Associated scalar pointer or interoperable scalar
+or allocated allocatable variable with @code{TARGET} attribute.
@end multitable
@item @emph{Return value}:
@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
@fnindex CEILING
@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
@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
@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}:
@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 nonzero error code otherwise.
+kind. Returns 0 on success, and a system specific and nonzero error code
+otherwise.
@end multitable
@item @emph{Example}:
@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 nonzero otherwise.
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
@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}:
command line when the containing program was invoked.
@item @emph{Standard}:
-F2003
+Fortran 2003 and later
@item @emph{Class}:
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
@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}:
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
@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
@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
@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
+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}.
@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
@code{COSH(X)} computes the hyperbolic cosine of @var{X}.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later
@item @emph{Class}:
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(*)} and it is positive
-(@math{ \cosh (x) \geq 0 }.
+The return value is of type @code{REAL} and it is positive
+(@math{ \cosh (x) \geq 0 }). For a @code{REAL} argument @var{X},
+@math{ \cosh (x) \geq 1 }.
+The return value is of the same kind as @var{X}.
@item @emph{Example}:
@smallexample
@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}:
@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
@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
@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
@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}:
@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
+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
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
@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}:
@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
@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
@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}:
@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}:
@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
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}:
@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
@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}:
otherwise returns zero.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later
@item @emph{Class}:
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
@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
@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
@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}:
@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
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}:
@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.
become, negative, or numerically less than previous values, during a single
run of the compiled program.
+Please note, that this implementation is thread safe if used within OpenMP
+directives, i.e., its state will be consistent while called from multiple
+threads. However, if @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.
+
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 .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}:
@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, DIMENSION(2)}.
+@item @var{TIME}@tab The type shall be @code{REAL}.
@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
print *, tarray(2)
end program test_dtime
@end smallexample
+
+@item @emph{See also}:
+@ref{CPU_TIME}
+
@end table
@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
+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,
@end multitable
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Transformational function
@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}.
@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
@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}:
@code{ERF(X)} computes the error function of @var{X}.
@item @emph{Standard}:
-GNU Extension
+Fortran 2008 and later
@item @emph{Class}:
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
@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
@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
+@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
@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
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}:
@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, DIMENSION(2)}.
+@item @var{TIME}@tab The type shall be @code{REAL}.
@end multitable
@item @emph{Return value}:
@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
@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}:
@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
is zero the value returned is zero.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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}:
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{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}:
@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}:
@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}:
@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}:
@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
@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}:
@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}:
representation of @code{X}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Elemental function
@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.
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}:
+@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
@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}:
@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
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
@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
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
@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
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 nonzero error code otherwise.
+a system specific and nonzero error code otherwise.
@end multitable
@item @emph{Example}:
@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
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}:
@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
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}:
@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)}.
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
@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}:
@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}:
the model of the type of @code{X}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Inquiry function
+@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
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
Bitwise logical @code{AND}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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.)
@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
@var{POS} set to zero.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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}:
value @code{BIT_SIZE(I)}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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}:
@var{POS} set to one.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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}:
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
@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}:
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
@var{J}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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.)
-@node INDEX
+@node INDEX intrinsic
@section @code{INDEX} --- Position of a substring within a string
@fnindex INDEX
@cindex substring position
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}
Convert to integer type
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later
@item @emph{Class}:
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}:
@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
The @code{SHORT} intrinsic is equivalent to @code{INT2}.
@item @emph{Standard}:
-GNU extension.
+GNU extension
@item @emph{Class}:
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}:
@code{KIND=8}, and is only included for backwards compatibility.
@item @emph{Standard}:
-GNU extension.
+GNU extension
@item @emph{Class}:
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}:
@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.)
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
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}:
+@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
Determine whether a unit is connected to a terminal device.
@item @emph{Standard}:
-GNU extension.
+GNU extension
@item @emph{Class}:
Function
@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}:
lost; zeros are shifted in from the opposite end.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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}:
equivalent to @code{BIT_SIZE(I)}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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{SIZE} @tab (Optional) 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}.
+@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
+The return value is of type @code{INTEGER} and of the same kind as
@var{I}.
@item @emph{See also}:
+@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{ISNAN(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{X} @tab Variable of the type @code{REAL}.
+
+@end multitable
+
+@item @emph{Return value}:
+Returns a default-kind @code{LOGICAL}. The returned value is @code{TRUE}
+if @var{X} is a NaN and @code{FALSE} otherwise.
+
+@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
+
+
+
@node ITIME
@section @code{ITIME} --- Get current local time subroutine (hour/minutes/seconds)
@fnindex ITIME
@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}:
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}:
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}:
@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
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
+@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
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}
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}
ordering.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later
@item @emph{Class}:
Elemental function
ordering.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later
@item @emph{Class}:
Elemental function
ordering.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later
@item @emph{Class}:
Elemental function
ordering.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later
@item @emph{Class}:
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
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
@code{LOG(X)} computes the logarithm of @var{X}.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later
@item @emph{Class}:
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
@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
@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}:
@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
+
+
+
@node LOGICAL
@section @code{LOGICAL} --- Convert to logical type
@fnindex LOGICAL
Converts one kind of @code{LOGICAL} variable to another.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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}:
included for backwards compatibility.
@item @emph{Standard}:
-GNU extension.
+GNU extension
@item @emph{Class}:
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}:
@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}:
@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{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.
+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
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}:
@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}:
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
@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}:
@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}:
@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)
Performs a matrix multiplication on numeric or logical arguments.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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}:
Returns the argument with the largest (most positive) value.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later
@item @emph{Class}:
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}:
@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}:
type of @code{X}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Inquiry function
result value for that row is zero.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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}:
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
@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}:
@var{FSOURCE} if it is @code{.FALSE.}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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}:
Returns the argument with the smallest (most negative) value.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later
@item @emph{Class}:
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}:
@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}:
type of @code{X}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Inquiry function
result value for that row is zero.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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}:
@var{ARRAY} is of character type.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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}:
@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
@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
@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
@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}:
@code{BIT_SIZE(FROM)}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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}:
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
@code{NEW_LINE(C)} returns the new-line character.
@item @emph{Standard}:
-F2003 and later
+Fortran 2003 and later
@item @emph{Class}:
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}:
@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}:
@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}:
@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
@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}:
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
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
@end smallexample
@item @emph{See also}:
-F95 elemental function: @ref{IOR}
+Fortran 95 elemental function: @ref{IOR}
@end table
@var{VECTOR}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Transformational function
@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}:
type of @code{X}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Inquiry function
Determines whether an optional dummy argument is present.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Inquiry function
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}.
@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
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
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}:
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
@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}:
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
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
@node RANGE
-@section @code{RANGE} --- Decimal exponent range of a real kind
+@section @code{RANGE} --- Decimal exponent range
@fnindex RANGE
@cindex model representation, range
type of @code{X}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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}:
@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
Concatenates @var{NCOPIES} copies of a string.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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}:
as defined by @var{ORDER}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Transformational function
model numbers near @var{X}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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}:
@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
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
@end smallexample
@item @emph{See also}:
-@ref{INDEX}, @ref{VERIFY}
+@ref{INDEX intrinsic}, @ref{VERIFY}
@end table
+@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
@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}:
@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
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
Determines the shape of an array.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Inquiry function
@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
@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)}.
@code{SIN(X)} computes the sine of @var{X}.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later
@item @emph{Class}:
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}:
@code{SINH(X)} computes the hyperbolic sine of @var{X}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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(*)}.
+The return value is of type @code{REAL}.
@item @emph{Example}:
@smallexample
@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}:
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
@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
@end multitable
@item @emph{Return value}:
-The return value is of type integer. 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 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}:
@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
@fnindex SLEEP
that is specific to one type for @var{A}.
@item @emph{Standard}:
-GNU extension
+Fortran 77 and later
@item @emph{Class}:
Elemental function
adjacent number of the same type.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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}:
dimension @var{DIM}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Transformational function
@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
@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}:
@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
@end multitable
@item @emph{Return value}:
-Does not return.
+Does not return anything.
@item @emph{Example}:
See @code{RAND} and @code{IRAND} for examples.
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.
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}:
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}.
@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
@code{TAN(X)} computes the tangent of @var{X}.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later
@item @emph{Class}:
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(*)}. The kind type parameter is
+The return value is of type @code{REAL}. The kind type parameter is
the same as @var{X}.
@item @emph{Example}:
@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}:
@code{TANH(X)} computes the hyperbolic tangent of @var{X}.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later
@item @emph{Class}:
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(*)} and lies in the range
+The return value is of type @code{REAL} and lies in the range
@math{ - 1 \leq tanh(x) \leq 1 }.
@item @emph{Example}:
@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}:
in the model of the type of @code{X}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Inquiry function
+@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
type to another.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Transformational function
@code{MATRIX(j, i)}, for all i, j.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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
Removes trailing blank characters of a string.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
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}:
@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}:
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
@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
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
@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
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 = VERIFY(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
@end smallexample
@item @emph{See also}:
-@ref{SCAN}, @ref{INDEX}
+@ref{SCAN}, @ref{INDEX intrinsic}
@end table
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
@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
+@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
OSDN Git Service
