@ignore
-Copyright (C) 2005, 2006, 2007
+Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010
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
+under the terms of the GNU Free Documentation License, Version 1.3 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{ACCESS}: ACCESS, Checks file access modes
* @code{ACHAR}: ACHAR, Character in @acronym{ASCII} collating sequence
* @code{ACOS}: ACOS, Arccosine function
-* @code{ACOSH}: ACOSH, Hyperbolic arccosine function
+* @code{ACOSH}: ACOSH, Inverse hyperbolic cosine function
* @code{ADJUSTL}: ADJUSTL, Left adjust a string
* @code{ADJUSTR}: ADJUSTR, Right adjust a string
* @code{AIMAG}: AIMAG, Imaginary part of complex number
* @code{ANINT}: ANINT, Nearest whole number
* @code{ANY}: ANY, Determine if any values are true
* @code{ASIN}: ASIN, Arcsine function
-* @code{ASINH}: ASINH, Hyperbolic arcsine function
+* @code{ASINH}: ASINH, Inverse hyperbolic sine function
* @code{ASSOCIATED}: ASSOCIATED, Status of a pointer or pointer/target pair
* @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{ATANH}: ATANH, Inverse hyperbolic tangent function
+* @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{BGE}: BGE, Bitwise greater than or equal to
+* @code{BGT}: BGT, Bitwise greater than
* @code{BIT_SIZE}: BIT_SIZE, Bit size inquiry function
+* @code{BLE}: BLE, Bitwise less than or equal to
+* @code{BLT}: BLT, Bitwise less than
* @code{BTEST}: BTEST, Bit test function
+* @code{C_ASSOCIATED}: C_ASSOCIATED, Status of a C pointer
+* @code{C_F_POINTER}: C_F_POINTER, Convert C into Fortran pointer
+* @code{C_F_PROCPOINTER}: C_F_PROCPOINTER, Convert C into Fortran procedure pointer
+* @code{C_FUNLOC}: C_FUNLOC, Obtain the C address of a procedure
+* @code{C_LOC}: C_LOC, Obtain the C address of an object
+* @code{C_SIZEOF}: C_SIZEOF, Size in bytes of an expression
* @code{CEILING}: CEILING, Integer ceiling function
* @code{CHAR}: CHAR, Integer-to-character conversion function
* @code{CHDIR}: CHDIR, Change working directory
* @code{CHMOD}: CHMOD, Change access permissions of files
* @code{CMPLX}: CMPLX, Complex conversion function
* @code{COMMAND_ARGUMENT_COUNT}: COMMAND_ARGUMENT_COUNT, Get number of command line arguments
+* @code{COMPLEX}: COMPLEX, Complex conversion function
+* @code{COMPILER_VERSION}: COMPILER_VERSION, Compiler version string
+* @code{COMPILER_OPTIONS}: COMPILER_OPTIONS, Options passed to the compiler
* @code{CONJG}: CONJG, Complex conjugate function
* @code{COS}: COS, Cosine function
* @code{COSH}: COSH, Hyperbolic cosine function
* @code{COUNT}: COUNT, Count occurrences of TRUE in an array
* @code{CPU_TIME}: CPU_TIME, CPU time subroutine
-* @code{CSHIFT}: CSHIFT, Circular array shift function
+* @code{CSHIFT}: CSHIFT, Circular shift elements of an array
* @code{CTIME}: CTIME, Subroutine (or function) to convert a time into a string
* @code{DATE_AND_TIME}: DATE_AND_TIME, Date and time subroutine
* @code{DBLE}: DBLE, Double precision conversion function
* @code{DCMPLX}: DCMPLX, Double complex conversion function
-* @code{DFLOAT}: DFLOAT, Double precision conversion function
* @code{DIGITS}: DIGITS, Significant digits function
-* @code{DIM}: DIM, Dim function
+* @code{DIM}: DIM, Positive difference
* @code{DOT_PRODUCT}: DOT_PRODUCT, Dot product function
* @code{DPROD}: DPROD, Double product function
* @code{DREAL}: DREAL, Double real part function
+* @code{DSHIFTL}: DSHIFTL, Combined left shift
+* @code{DSHIFTR}: DSHIFTR, Combined right shift
* @code{DTIME}: DTIME, Execution time subroutine (or function)
-* @code{EOSHIFT}: EOSHIFT, End-off shift function
+* @code{EOSHIFT}: EOSHIFT, End-off shift elements of an array
* @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{EXECUTE_COMMAND_LINE}: EXECUTE_COMMAND_LINE, Execute a shell command
* @code{EXIT}: EXIT, Exit the program with status.
* @code{EXP}: EXP, Exponential function
* @code{EXPONENT}: EXPONENT, Exponent function
+* @code{EXTENDS_TYPE_OF}: EXTENDS_TYPE_OF, Query dynamic type for extension
* @code{FDATE}: FDATE, Subroutine (or function) to get the current time as a string
* @code{FGET}: FGET, Read a single character in stream mode from stdin
* @code{FGETC}: FGETC, Read a single character in stream mode
-* @code{FLOAT}: FLOAT, Convert integer to default real
* @code{FLOOR}: FLOOR, Integer floor function
* @code{FLUSH}: FLUSH, Flush I/O unit(s)
* @code{FNUM}: FNUM, File number 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, Euclidean distance function
* @code{IACHAR}: IACHAR, Code in @acronym{ASCII} collating sequence
+* @code{IALL}: IALL, Bitwise AND of array elements
* @code{IAND}: IAND, Bitwise logical and
+* @code{IANY}: IANY, Bitwise OR of array elements
* @code{IARGC}: IARGC, Get the number of command line arguments
* @code{IBCLR}: IBCLR, Clear bit
* @code{IBITS}: IBITS, Bit extraction
* @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{IMAGE_INDEX}: IMAGE_INDEX, Cosubscript to image index conversion
+* @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{IPARITY}: IPARITY, Bitwise XOR of array elements
* @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{LCOBOUND}: LCOBOUND, Lower codimension 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{LSTAT}: LSTAT, Get file status
* @code{LTIME}: LTIME, Convert time to local time info
* @code{MALLOC}: MALLOC, Dynamic memory allocation function
+* @code{MASKL}: MASKL, Left justified mask
+* @code{MASKR}: MASKR, Right justified mask
* @code{MATMUL}: MATMUL, matrix multiplication
* @code{MAX}: MAX, Maximum value of an argument list
* @code{MAXEXPONENT}: MAXEXPONENT, Maximum exponent of a real kind
* @code{MCLOCK}: MCLOCK, Time function
* @code{MCLOCK8}: MCLOCK8, Time function (64-bit)
* @code{MERGE}: MERGE, Merge arrays
+* @code{MERGE_BITS}: MERGE_BITS, Merge of bits under mask
* @code{MIN}: MIN, Minimum value of an argument list
* @code{MINEXPONENT}: MINEXPONENT, Minimum exponent of a real kind
* @code{MINLOC}: MINLOC, Location of the minimum value within an array
* @code{NEAREST}: NEAREST, Nearest representable number
* @code{NEW_LINE}: NEW_LINE, New line character
* @code{NINT}: NINT, Nearest whole number
+* @code{NORM2}: NORM2, Euclidean vector norm
* @code{NOT}: NOT, Logical negation
* @code{NULL}: NULL, Function that returns an disassociated pointer
+* @code{NUM_IMAGES}: NUM_IMAGES, Number of images
* @code{OR}: OR, Bitwise logical OR
* @code{PACK}: PACK, Pack an array into an array of rank one
+* @code{PARITY}: PARITY, Reduction with exclusive OR
* @code{PERROR}: PERROR, Print system error message
+* @code{POPCNT}: POPCNT, Number of bits set
+* @code{POPPAR}: POPPAR, Parity of the number of bits set
* @code{PRECISION}: PRECISION, Decimal precision of a real kind
-* @code{PRESENT}: PRESENT, Determine whether an optional argument is specified
+* @code{PRESENT}: PRESENT, Determine whether an optional dummy argument is specified
* @code{PRODUCT}: PRODUCT, Product of array elements
* @code{RADIX}: RADIX, Base of a data model
* @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{RESHAPE}: RESHAPE, Function to reshape an array
* @code{RRSPACING}: RRSPACING, Reciprocal of the relative spacing
* @code{RSHIFT}: RSHIFT, Right shift bits
+* @code{SAME_TYPE_AS}: SAME_TYPE_AS, Query dynamic types for equality
* @code{SCALE}: SCALE, Scale a real value
* @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{SHAPE}: SHAPE, Determine the shape of an array
+* @code{SHIFTA}: SHIFTA, Right shift with fill
+* @code{SHIFTL}: SHIFTL, Left shift
+* @code{SHIFTR}: SHIFTR, Right shift
* @code{SIGN}: SIGN, Sign copying function
* @code{SIGNAL}: SIGNAL, Signal handling subroutine (or function)
* @code{SIN}: SIN, Sine function
* @code{SINH}: SINH, Hyperbolic sine function
* @code{SIZE}: SIZE, Function to determine the size of an array
+* @code{SIZEOF}: SIZEOF, Determine the size in bytes of an expression
* @code{SLEEP}: SLEEP, Sleep for the specified number of seconds
-* @code{SNGL}: SNGL, Convert double precision real to default real
* @code{SPACING}: SPACING, Smallest distance between two numbers of a given type
* @code{SPREAD}: SPREAD, Add a dimension to an array
* @code{SQRT}: SQRT, Square-root function
* @code{SRAND}: SRAND, Reinitialize the random number generator
* @code{STAT}: STAT, Get file status
+* @code{STORAGE_SIZE}: STORAGE_SIZE, Storage size in bits
* @code{SUM}: SUM, Sum of array elements
* @code{SYMLNK}: SYMLNK, Create a symbolic link
* @code{SYSTEM}: SYSTEM, Execute a shell command
* @code{SYSTEM_CLOCK}: SYSTEM_CLOCK, Time function
* @code{TAN}: TAN, Tangent function
* @code{TANH}: TANH, Hyperbolic tangent function
+* @code{THIS_IMAGE}: THIS_IMAGE, Cosubscript index of this image
* @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, Function to remove trailing blank characters of a string
+* @code{TRIM}: TRIM, Remove trailing blank characters of a string
* @code{TTYNAM}: TTYNAM, Get the name of a terminal device.
* @code{UBOUND}: UBOUND, Upper dimension bounds of an array
+* @code{UCOBOUND}: UCOBOUND, Upper codimension bounds of an array
* @code{UMASK}: UMASK, Set the file creation mask
* @code{UNLINK}: UNLINK, Remove a file from the file system
* @code{UNPACK}: UNPACK, Unpack an array of rank one into an array
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
@node ABORT
-@section @code{ABORT} --- Abort the program
-@cindex @code{ABORT} intrinsic
-@cindex abort
+@section @code{ABORT} --- Abort the program
+@fnindex ABORT
+@cindex program termination, with core dump
+@cindex terminate program, with core dump
+@cindex core, dump
@table @asis
@item @emph{Description}:
@code{ABORT} causes immediate termination of the program. On operating
-systems that support a core dump, @code{ABORT} will produce a core dump,
-which is suitable for debugging purposes.
+systems that support a core dump, @code{ABORT} will produce a core dump even if
+the option @option{-fno-dump-core} is in effect, which is suitable for debugging
+purposes.
+@c TODO: Check if this (with -fno-dump-core) is correct.
@item @emph{Standard}:
GNU extension
@item @emph{Class}:
-Non-elemental subroutine
+Subroutine
@item @emph{Syntax}:
@code{CALL ABORT}
@node ABS
-@section @code{ABS} --- Absolute value
-@cindex @code{ABS} intrinsic
-@cindex @code{CABS} intrinsic
-@cindex @code{DABS} intrinsic
-@cindex @code{IABS} intrinsic
-@cindex @code{ZABS} intrinsic
-@cindex @code{CDABS} intrinsic
+@section @code{ABS} --- Absolute value
+@fnindex ABS
+@fnindex CABS
+@fnindex DABS
+@fnindex IABS
+@fnindex ZABS
+@fnindex CDABS
@cindex absolute value
@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{ABS(A)} @tab @code{REAL(4) A} @tab @code{REAL(4)} @tab Fortran 77 and later
+@item @code{CABS(A)} @tab @code{COMPLEX(4) A} @tab @code{REAL(4)} @tab Fortran 77 and later
+@item @code{DABS(A)} @tab @code{REAL(8) A} @tab @code{REAL(8)} @tab Fortran 77 and later
+@item @code{IABS(A)} @tab @code{INTEGER(4) A} @tab @code{INTEGER(4)} @tab Fortran 77 and later
+@item @code{ZABS(A)} @tab @code{COMPLEX(8) A} @tab @code{COMPLEX(8)} @tab GNU extension
+@item @code{CDABS(A)} @tab @code{COMPLEX(8) A} @tab @code{COMPLEX(8)} @tab GNU extension
@end multitable
@end table
@node ACCESS
@section @code{ACCESS} --- Checks file access modes
-@cindex @code{ACCESS}
-@cindex file system operations
+@fnindex ACCESS
+@cindex file system, access mode
@table @asis
@item @emph{Description}:
@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}:
@node ACHAR
@section @code{ACHAR} --- Character in @acronym{ASCII} collating sequence
-@cindex @code{ACHAR} intrinsic
+@fnindex ACHAR
@cindex @acronym{ASCII} collating sequence
+@cindex collating sequence, @acronym{ASCII}
@table @asis
@item @emph{Description}:
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
@node ACOS
@section @code{ACOS} --- Arccosine function
-@cindex @code{ACOS} intrinsic
-@cindex @code{DACOS} intrinsic
-@cindex trigonometric functions (inverse)
+@fnindex ACOS
+@fnindex DACOS
+@cindex trigonometric function, cosine, inverse
+@cindex cosine, inverse
@table @asis
@item @emph{Description}:
@code{ACOS(X)} computes the arccosine of @var{X} (inverse of @code{COS(X)}).
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later, for a complex argument Fortran 2008 or later
@item @emph{Class}:
Elemental function
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{X} @tab The type shall be @code{REAL(*)} with a magnitude that is
-less than one.
+@item @var{X} @tab The type shall either be @code{REAL} with a magnitude that is
+less than or equal to one - or the type shall be @code{COMPLEX}.
@end multitable
@item @emph{Return value}:
-The return value is of type @code{REAL(*)} and it lies in the
-range @math{ 0 \leq \acos(x) \leq \pi}. The kind type parameter
-is the same as @var{X}.
+The return value is of the same type and kind as @var{X}.
+The real part of the result is in radians and lies in the range
+@math{0 \leq \Re \acos(x) \leq \pi}.
@item @emph{Example}:
@smallexample
@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 Name @tab Argument @tab Return type @tab Standard
+@item @code{ACOS(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab Fortran 77 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}:
@node ACOSH
-@section @code{ACOSH} --- Hyperbolic arccosine function
-@cindex @code{ACOSH} intrinsic
-@cindex @code{DACOSH} intrinsic
-@cindex hyperbolic arccosine
-@cindex hyperbolic cosine (inverse)
+@section @code{ACOSH} --- Inverse hyperbolic cosine function
+@fnindex ACOSH
+@fnindex DACOSH
+@cindex area hyperbolic cosine
+@cindex inverse hyperbolic cosine
+@cindex hyperbolic function, cosine, inverse
+@cindex cosine, hyperbolic, inverse
@table @asis
@item @emph{Description}:
-@code{ACOSH(X)} computes the hyperbolic arccosine of @var{X} (inverse of
-@code{COSH(X)}).
+@code{ACOSH(X)} computes the inverse hyperbolic cosine 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(*)} with a magnitude that is
-greater or equal to one.
+@item @var{X} @tab The type shall be @code{REAL} or @code{COMPLEX}.
@end multitable
@item @emph{Return value}:
-The return value is of type @code{REAL(*)} and it lies in the
-range @math{0 \leq \acosh (x) \leq \infty}.
+The return value has the same type and kind as @var{X}. If @var{X} is
+complex, the imaginary part of the result is in radians and lies between
+@math{ 0 \leq \Im \acosh(x) \leq \pi}.
@item @emph{Example}:
@smallexample
@node ADJUSTL
@section @code{ADJUSTL} --- Left adjust a string
-@cindex @code{ADJUSTL} intrinsic
+@fnindex ADJUSTL
+@cindex string, adjust left
@cindex adjust string
@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
print *, str
end program test_adjustl
@end smallexample
+
+@item @emph{See also}:
+@ref{ADJUSTR}, @ref{TRIM}
@end table
@node ADJUSTR
@section @code{ADJUSTR} --- Right adjust a string
-@cindex @code{ADJUSTR} intrinsic
+@fnindex ADJUSTR
+@cindex string, adjust right
@cindex adjust string
@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
print *, str
end program test_adjustr
@end smallexample
+
+@item @emph{See also}:
+@ref{ADJUSTL}, @ref{TRIM}
@end table
@node AIMAG
@section @code{AIMAG} --- Imaginary part of complex number
-@cindex @code{AIMAG} intrinsic
-@cindex @code{DIMAG} intrinsic
-@cindex @code{IMAG} intrinsic
-@cindex @code{IMAGPART} intrinsic
-@cindex imaginary part of a complex number
+@fnindex AIMAG
+@fnindex DIMAG
+@fnindex IMAG
+@fnindex IMAGPART
+@cindex complex numbers, imaginary part
@table @asis
@item @emph{Description}:
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}:
@item @emph{Specific names}:
@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 Name @tab Argument @tab Return type @tab Standard
+@item @code{AIMAG(Z)} @tab @code{COMPLEX Z} @tab @code{REAL} @tab GNU extension
+@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
@end multitable
@end table
@node AINT
@section @code{AINT} --- Truncate to a whole number
-@cindex @code{AINT} intrinsic
-@cindex @code{DINT} intrinsic
-@cindex whole number
+@fnindex AINT
+@fnindex DINT
+@cindex floor
+@cindex rounding, floor
@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{AINT(A)} @tab @code{REAL(4) A} @tab @code{REAL(4)} @tab Fortran 77 and later
+@item @code{DINT(A)} @tab @code{REAL(8) A} @tab @code{REAL(8)} @tab Fortran 77 and later
@end multitable
@end table
@node ALARM
@section @code{ALARM} --- Execute a routine after a given delay
-@cindex @code{ALARM} intrinsic
+@fnindex ALARM
+@cindex delayed execution
@table @asis
@item @emph{Description}:
@node ALL
@section @code{ALL} --- All values in @var{MASK} along @var{DIM} are true
-@cindex @code{ALL} intrinsic
-@cindex true values
+@fnindex ALL
+@cindex array, apply condition
+@cindex array, condition testing
@table @asis
@item @emph{Description}:
in the array along dimension @var{DIM}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
-transformational function
+Transformational function
@item @emph{Syntax}:
@code{RESULT = ALL(MASK [, DIM])}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{MASK} @tab The type of the argument shall be @code{LOGICAL(*)} and
+@item @var{MASK} @tab The type of the argument shall be @code{LOGICAL} and
it shall not be scalar.
@item @var{DIM} @tab (Optional) @var{DIM} shall be a scalar integer
with a value that lies between one and the rank of @var{MASK}.
@end multitable
@item @emph{Return value}:
-@code{ALL(MASK)} returns a scalar value of type @code{LOGICAL(*)} where
+@code{ALL(MASK)} returns a scalar value of type @code{LOGICAL} where
the kind type parameter is the same as the kind type parameter of
@var{MASK}. If @var{DIM} is present, then @code{ALL(MASK, DIM)} returns
an array with the rank of @var{MASK} minus 1. The shape is determined from
@node ALLOCATED
@section @code{ALLOCATED} --- Status of an allocatable entity
-@cindex @code{ALLOCATED} intrinsic
-@cindex allocation status
+@fnindex ALLOCATED
+@cindex allocation, status
@table @asis
@item @emph{Description}:
-@code{ALLOCATED(X)} checks the status of whether @var{X} is allocated.
+@code{ALLOCATED(ARRAY)} and @code{ALLOCATED(SCALAR)} check the allocation
+status of @var{ARRAY} and @var{SCALAR}, respectively.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later. Note, the @code{SCALAR=} keyword and allocatable
+scalar entities are available in Fortran 2003 and later.
@item @emph{Class}:
Inquiry function
@item @emph{Syntax}:
-@code{RESULT = ALLOCATED(X)}
+@code{RESULT = ALLOCATED(ARRAY)} or @code{RESULT = ALLOCATED(SCALAR)}
@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.
+@item @var{SCALAR} @tab The argument shall be an @code{ALLOCATABLE} scalar.
@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 the argument is allocated, then the result 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
@node AND
@section @code{AND} --- Bitwise logical AND
-@cindex @code{AND} intrinsic
-@cindex bit operations
+@fnindex AND
+@cindex bitwise logical and
+@cindex logical and, bitwise
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-Non-elemental function
+Function
@item @emph{Syntax}:
@code{RESULT = AND(I, J)}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{I} @tab The type shall be either @code{INTEGER(*)} or @code{LOGICAL}.
-@item @var{J} @tab The type shall be either @code{INTEGER(*)} or @code{LOGICAL}.
+@item @var{I} @tab The type shall be either a scalar @code{INTEGER}
+type or a scalar @code{LOGICAL} type.
+@item @var{J} @tab The type shall be the same as the type of @var{I}.
@end multitable
@item @emph{Return value}:
-The return type is either @code{INTEGER(*)} or @code{LOGICAL} after
-cross-promotion of the arguments.
+The return type is either a scalar @code{INTEGER} or a scalar
+@code{LOGICAL}. If the kind type parameters differ, then the
+smaller kind type is implicitly converted to larger kind, and the
+return has the larger kind.
@item @emph{Example}:
@smallexample
PROGRAM test_and
- LOGICAL :: T = .TRUE., F = ..FALSE.
+ LOGICAL :: T = .TRUE., F = .FALSE.
INTEGER :: a, b
DATA a / Z'F' /, b / Z'3' /
@end smallexample
@item @emph{See also}:
-F95 elemental function: @ref{IAND}
+Fortran 95 elemental function: @ref{IAND}
@end table
@node ANINT
@section @code{ANINT} --- Nearest whole number
-@cindex @code{ANINT} intrinsic
-@cindex @code{DNINT} intrinsic
-@cindex whole number
+@fnindex ANINT
+@fnindex DNINT
+@cindex ceiling
+@cindex rounding, ceiling
@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{AINT(A)} @tab @code{REAL(4) A} @tab @code{REAL(4)} @tab Fortran 77 and later
+@item @code{DNINT(A)} @tab @code{REAL(8) A} @tab @code{REAL(8)} @tab Fortran 77 and later
@end multitable
@end table
@node ANY
@section @code{ANY} --- Any value in @var{MASK} along @var{DIM} is true
-@cindex @code{ANY} intrinsic
-@cindex true values
+@fnindex ANY
+@cindex array, apply condition
+@cindex array, condition testing
@table @asis
@item @emph{Description}:
@var{MASK} along dimension @var{DIM} are @code{.TRUE.}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
-transformational function
+Transformational function
@item @emph{Syntax}:
@code{RESULT = ANY(MASK [, DIM])}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{MASK} @tab The type of the argument shall be @code{LOGICAL(*)} and
+@item @var{MASK} @tab The type of the argument shall be @code{LOGICAL} and
it shall not be scalar.
@item @var{DIM} @tab (Optional) @var{DIM} shall be a scalar integer
with a value that lies between one and the rank of @var{MASK}.
@end multitable
@item @emph{Return value}:
-@code{ANY(MASK)} returns a scalar value of type @code{LOGICAL(*)} where
+@code{ANY(MASK)} returns a scalar value of type @code{LOGICAL} where
the kind type parameter is the same as the kind type parameter of
@var{MASK}. If @var{DIM} is present, then @code{ANY(MASK, DIM)} returns
an array with the rank of @var{MASK} minus 1. The shape is determined from
@node ASIN
@section @code{ASIN} --- Arcsine function
-@cindex @code{ASIN} intrinsic
-@cindex @code{DASIN} intrinsic
-@cindex trigonometric functions (inverse)
+@fnindex ASIN
+@fnindex DASIN
+@cindex trigonometric function, sine, inverse
+@cindex sine, inverse
@table @asis
@item @emph{Description}:
@code{ASIN(X)} computes the arcsine of its @var{X} (inverse of @code{SIN(X)}).
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later, for a complex argument Fortran 2008 or later
@item @emph{Class}:
Elemental function
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{X} @tab The type shall be @code{REAL(*)}, and a magnitude that is
-less than one.
+@item @var{X} @tab The type shall be either @code{REAL} and a magnitude that is
+less than or equal to one - or be @code{COMPLEX}.
@end multitable
@item @emph{Return value}:
-The return value is of type @code{REAL(*)} and it lies in the
-range @math{-\pi / 2 \leq \asin (x) \leq \pi / 2}. The kind type
-parameter is the same as @var{X}.
+The return value is of the same type and kind as @var{X}.
+The real part of the result is in radians and lies in the range
+@math{-\pi/2 \leq \Re \asin(x) \leq \pi/2}.
@item @emph{Example}:
@smallexample
@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{ASIN(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab Fortran 77 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}:
@node ASINH
-@section @code{ASINH} --- Hyperbolic arcsine function
-@cindex @code{ASINH} intrinsic
-@cindex @code{DASINH} intrinsic
-@cindex hyperbolic arcsine
-@cindex hyperbolic sine (inverse)
+@section @code{ASINH} --- Inverse hyperbolic sine function
+@fnindex ASINH
+@fnindex DASINH
+@cindex area hyperbolic sine
+@cindex inverse hyperbolic sine
+@cindex hyperbolic function, sine, inverse
+@cindex sine, hyperbolic, inverse
@table @asis
@item @emph{Description}:
-@code{ASINH(X)} computes the hyperbolic arcsine of @var{X} (inverse of @code{SINH(X)}).
+@code{ASINH(X)} computes the inverse hyperbolic sine 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(*)}, with @var{X} a real number.
+@item @var{X} @tab The type shall be @code{REAL} or @code{COMPLEX}.
@end multitable
@item @emph{Return value}:
-The return value is of type @code{REAL(*)} and it lies in the
-range @math{-\infty \leq \asinh (x) \leq \infty}.
+The return value is of the same type and kind as @var{X}. If @var{X} is
+complex, the imaginary part of the result is in radians and lies between
+@math{-\pi/2 \leq \Im \asinh(x) \leq \pi/2}.
@item @emph{Example}:
@smallexample
@node ASSOCIATED
@section @code{ASSOCIATED} --- Status of a pointer or pointer/target pair
-@cindex @code{ASSOCIATED} intrinsic
-@cindex pointer status
+@fnindex ASSOCIATED
+@cindex pointer, status
+@cindex association status
@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}:
@node ATAN
@section @code{ATAN} --- Arctangent function
-@cindex @code{ATAN} intrinsic
-@cindex @code{DATAN} intrinsic
-@cindex trigonometric functions (inverse)
+@fnindex ATAN
+@fnindex DATAN
+@cindex trigonometric function, tangent, inverse
+@cindex tangent, inverse
@table @asis
@item @emph{Description}:
@code{ATAN(X)} computes the arctangent of @var{X}.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later, for a complex argument and for two arguments
+Fortran 2008 or later
@item @emph{Class}:
Elemental function
@item @emph{Syntax}:
@code{RESULT = ATAN(X)}
+@code{RESULT = ATAN(Y, X)}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{X} @tab The type shall be @code{REAL(*)}.
+@item @var{X} @tab The type shall be @code{REAL} or @code{COMPLEX};
+if @var{Y} is present, @var{X} shall be REAL.
+@item @var{Y} shall be of the same type and kind as @var{X}.
@end multitable
@item @emph{Return value}:
-The return value is of type @code{REAL(*)} and it lies in the
-range @math{ - \pi / 2 \leq \atan (x) \leq \pi / 2}.
+The return value is of the same type and kind as @var{X}.
+If @var{Y} is present, the result is identical to @code{ATAN2(Y,X)}.
+Otherwise, it the arcus tangent of @var{X}, where the real part of
+the result is in radians and lies in the range
+@math{-\pi/2 \leq \Re \atan(x) \leq \pi/2}.
@item @emph{Example}:
@smallexample
@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{ATAN(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab Fortran 77 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}:
@node ATAN2
@section @code{ATAN2} --- Arctangent function
-@cindex @code{ATAN2} intrinsic
-@cindex @code{DATAN2} intrinsic
-@cindex trigonometric functions (inverse)
+@fnindex ATAN2
+@fnindex DATAN2
+@cindex trigonometric function, tangent, inverse
+@cindex tangent, inverse
@table @asis
@item @emph{Description}:
-@code{ATAN2(Y,X)} computes the arctangent of the complex number
-@math{X + i Y}.
+@code{ATAN2(Y, X)} computes the principal value of the argument
+function of the complex number @math{X + i Y}. This function can
+be used to transform from Cartesian into polar coordinates and
+allows to determine the angle in the correct quadrant.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later
@item @emph{Class}:
Elemental function
@item @emph{Syntax}:
-@code{RESULT = ATAN2(Y,X)}
+@code{RESULT = ATAN2(Y, X)}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{Y} @tab The type shall be @code{REAL(*)}.
+@item @var{Y} @tab The type shall be @code{REAL}.
@item @var{X} @tab The type and kind type parameter shall be the same as @var{Y}.
If @var{Y} is zero, then @var{X} must be nonzero.
@end multitable
@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 Name @tab Argument @tab Return type @tab Standard
+@item @code{ATAN2(X, Y)} @tab @code{REAL(4) X, Y} @tab @code{REAL(4)} @tab Fortran 77 and later
+@item @code{DATAN2(X, Y)} @tab @code{REAL(8) X, Y} @tab @code{REAL(8)} @tab Fortran 77 and later
@end multitable
@end table
@node ATANH
-@section @code{ATANH} --- Hyperbolic arctangent function
-@cindex @code{ASINH} intrinsic
-@cindex @code{DASINH} intrinsic
-@cindex hyperbolic arctangent
-@cindex hyperbolic tangent (inverse)
+@section @code{ATANH} --- Inverse hyperbolic tangent function
+@fnindex ATANH
+@fnindex DATANH
+@cindex area hyperbolic tangent
+@cindex inverse hyperbolic tangent
+@cindex hyperbolic function, tangent, inverse
+@cindex tangent, hyperbolic, inverse
@table @asis
@item @emph{Description}:
-@code{ATANH(X)} computes the hyperbolic arctangent of @var{X} (inverse
-of @code{TANH(X)}).
+@code{ATANH(X)} computes the inverse hyperbolic tangent 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(*)} with a magnitude
-that is less than or equal to one.
+@item @var{X} @tab The type shall be @code{REAL} or @code{COMPLEX}.
@end multitable
@item @emph{Return value}:
-The return value is of type @code{REAL(*)} and it lies in the
-range @math{-\infty \leq \atanh(x) \leq \infty}.
+The return value has same type and kind as @var{X}. If @var{X} is
+complex, the imaginary part of the result is in radians and lies between
+@math{-\pi/2 \leq \Im \atanh(x) \leq \pi/2}.
@item @emph{Example}:
@smallexample
-@node BESJ0
-@section @code{BESJ0} --- Bessel function of the first kind of order 0
-@cindex @code{BESJ0} intrinsic
-@cindex @code{DBESJ0} intrinsic
-@cindex Bessel
+@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
-@cindex @code{BESJ1} intrinsic
-@cindex @code{DBESJ1} intrinsic
-@cindex Bessel
+@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
@item @emph{Specific names}:
@multitable @columnfractions .20 .20 .20 .25
-@item Name @tab Argument @tab Return type @tab Standard
-@item @code{DBESJ1(X)}@tab @code{REAL(8) X} @tab @code{REAL(8)} @tab GNU extension
+@item Name @tab Argument @tab Return type @tab Standard
+@item @code{DBESJ1(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab GNU extension
@end multitable
@end table
-@node BESJN
-@section @code{BESJN} --- Bessel function of the first kind
-@cindex @code{BESJN} intrinsic
-@cindex @code{DBESJN} intrinsic
-@cindex Bessel
+@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 @var{N} and @var{X} are arrays,
+their ranks and shapes shall conform.
+
+@code{BESSEL_JN(N1, N2, X)} returns an array with the Bessel functions
+of the first kind of the orders @var{N1} to @var{N2}.
@item @emph{Standard}:
-GNU extension
+Fortran 2008 and later, negative @var{N} is allowed as GNU extension
@item @emph{Class}:
-Elemental function
+Elemental function, except for the transformational function
+@code{BESSEL_JN(N1, N2, X)}
@item @emph{Syntax}:
-@code{RESULT = BESJN(N, X)}
+@code{RESULT = BESSEL_JN(N, X)}
+@code{RESULT = BESSEL_JN(N1, N2, X)}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{N} @tab The type shall be @code{INTEGER(*)}, and it shall be scalar.
-@item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar.
+@item @var{N} @tab Shall be a scalar or an array of type @code{INTEGER}.
+@item @var{N1} @tab Shall be a non-negative scalar of type @code{INTEGER}.
+@item @var{N2} @tab Shall be a non-negative scalar of type @code{INTEGER}.
+@item @var{X} @tab Shall be a scalar or an array of type @code{REAL};
+for @code{BESSEL_JN(N1, N2, X)} 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{Note}:
+The transformational function uses a recurrence algorithm which might,
+for some values of @var{X}, lead to different results than calls to
+the elemental function.
@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
-@cindex @code{BESY0} intrinsic
-@cindex @code{DBESY0} intrinsic
-@cindex Bessel
+@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
-@cindex @code{BESY1} intrinsic
-@cindex @code{DBESY1} intrinsic
-@cindex Bessel
+@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
-@cindex @code{BESYN} intrinsic
-@cindex @code{DBESYN} intrinsic
-@cindex Bessel
+@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 @var{N} and @var{X} are arrays,
+their ranks and shapes shall conform.
+
+@code{BESSEL_YN(N1, N2, X)} returns an array with the Bessel functions
+of the first kind of the orders @var{N1} to @var{N2}.
@item @emph{Standard}:
-GNU extension
+Fortran 2008 and later, negative @var{N} is allowed as GNU extension
@item @emph{Class}:
-Elemental function
+Elemental function, except for the transformational function
+@code{BESSEL_YN(N1, N2, X)}
@item @emph{Syntax}:
-@code{RESULT = BESYN(N, X)}
+@code{RESULT = BESSEL_YN(N, X)}
+@code{RESULT = BESSEL_YN(N1, N2, X)}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{N} @tab The type shall be @code{INTEGER(*)}, and it shall be scalar.
-@item @var{X} @tab The type shall be @code{REAL(*)}, and it shall be scalar.
+@item @var{N} @tab Shall be a scalar or an array of type @code{INTEGER} .
+@item @var{N1} @tab Shall be a non-negative scalar of type @code{INTEGER}.
+@item @var{N2} @tab Shall be a non-negative scalar of type @code{INTEGER}.
+@item @var{X} @tab Shall be a scalar or an array of type @code{REAL};
+for @code{BESSEL_YN(N1, N2, X)} 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{Note}:
+The transformational function uses a recurrence algorithm which might,
+for some values of @var{X}, lead to different results than calls to
+the elemental function.
@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 @tab @code{REAL(8) X} @tab @tab
+@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
+
+
+
+@node BGE
+@section @code{BGE} --- Bitwise greater than or equal to
+@fnindex BGE
+@cindex bitwise comparison
+
+@table @asis
+@item @emph{Description}:
+Determines whether an integral is a bitwise greater than or equal to
+another.
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = BGE(I, J)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{I} @tab Shall be of @code{INTEGER} type.
+@item @var{J} @tab Shall be of @code{INTEGER} type, and of the same kind
+as @var{I}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{LOGICAL} and of the default kind.
+
+@item @emph{See also}:
+@ref{BGT}, @ref{BLE}, @ref{BLT}
+@end table
+
+
+
+@node BGT
+@section @code{BGT} --- Bitwise greater than
+@fnindex BGT
+@cindex bitwise comparison
+
+@table @asis
+@item @emph{Description}:
+Determines whether an integral is a bitwise greater than another.
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = BGT(I, J)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{I} @tab Shall be of @code{INTEGER} type.
+@item @var{J} @tab Shall be of @code{INTEGER} type, and of the same kind
+as @var{I}.
@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{LOGICAL} and of the default kind.
+
+@item @emph{See also}:
+@ref{BGE}, @ref{BLE}, @ref{BLT}
@end table
@node BIT_SIZE
@section @code{BIT_SIZE} --- Bit size inquiry function
-@cindex @code{BIT_SIZE} intrinsic
-@cindex bit size of a variable
+@fnindex BIT_SIZE
+@cindex bits, number of
@cindex size of a variable, in bits
@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
+@node BLE
+@section @code{BLE} --- Bitwise less than or equal to
+@fnindex BLE
+@cindex bitwise comparison
+
+@table @asis
+@item @emph{Description}:
+Determines whether an integral is a bitwise less than or equal to
+another.
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = BLE(I, J)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{I} @tab Shall be of @code{INTEGER} type.
+@item @var{J} @tab Shall be of @code{INTEGER} type, and of the same kind
+as @var{I}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{LOGICAL} and of the default kind.
+
+@item @emph{See also}:
+@ref{BGT}, @ref{BGE}, @ref{BLT}
+@end table
+
+
+
+@node BLT
+@section @code{BLT} --- Bitwise less than
+@fnindex BLT
+@cindex bitwise comparison
+
+@table @asis
+@item @emph{Description}:
+Determines whether an integral is a bitwise less than another.
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = BLT(I, J)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{I} @tab Shall be of @code{INTEGER} type.
+@item @var{J} @tab Shall be of @code{INTEGER} type, and of the same kind
+as @var{I}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{LOGICAL} and of the default kind.
+
+@item @emph{See also}:
+@ref{BGE}, @ref{BGT}, @ref{BLE}
+@end table
+
+
+
@node BTEST
@section @code{BTEST} --- Bit test function
-@cindex @code{BTEST} intrinsic
-@cindex bit operations
+@fnindex BTEST
+@cindex bits, testing
@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}:
@end table
-
-@node CEILING
-@section @code{CEILING} --- Integer ceiling function
-@cindex @code{CEILING} intrinsic
-@cindex ceiling
+@node C_ASSOCIATED
+@section @code{C_ASSOCIATED} --- Status of a C pointer
+@fnindex C_ASSOCIATED
+@cindex association status, C pointer
+@cindex pointer, C association status
@table @asis
@item @emph{Description}:
-@code{CEILING(X)} returns the least integer greater than or equal to @var{X}.
+@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}:
-F95 and later
+Fortran 2003 and later
@item @emph{Class}:
-Elemental function
+Inquiry function
@item @emph{Syntax}:
-@code{RESULT = CEILING(X [, KIND])}
+@code{RESULT = C_ASSOCIATED(c_prt_1[, c_ptr_2])}
@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{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{INTEGER(KIND)}
+The return value is of type @code{LOGICAL}; it is @code{.false.} if either
+@var{c_ptr_1} is a C NULL pointer or if @var{c_ptr1} and @var{c_ptr_2}
+point to different addresses.
@item @emph{Example}:
@smallexample
-program test_ceiling
- real :: x = 63.29
- real :: y = -63.59
- print *, ceiling(x) ! returns 64
- print *, ceiling(y) ! returns -63
-end program test_ceiling
+subroutine association_test(a,b)
+ use iso_c_binding, only: c_associated, c_loc, c_ptr
+ implicit none
+ real, pointer :: a
+ type(c_ptr) :: b
+ if(c_associated(b, c_loc(a))) &
+ stop 'b and a do not point to same target'
+end subroutine association_test
@end smallexample
@item @emph{See also}:
-@ref{FLOOR}, @ref{NINT}
-
+@ref{C_LOC}, @ref{C_FUNLOC}
@end table
-
-@node CHAR
-@section @code{CHAR} --- Character conversion function
-@cindex @code{CHAR} intrinsic
-@cindex conversion function (character)
+@node C_FUNLOC
+@section @code{C_FUNLOC} --- Obtain the C address of a procedure
+@fnindex C_FUNLOC
+@cindex pointer, C address of procedures
@table @asis
@item @emph{Description}:
-@code{CHAR(I [, KIND])} returns the character represented by the integer @var{I}.
+@code{C_FUNLOC(x)} determines the C address of the argument.
@item @emph{Standard}:
-F77 and later
+Fortran 2003 and later
@item @emph{Class}:
-Elemental function
+Inquiry function
@item @emph{Syntax}:
-@code{RESULT = CHAR(I [, KIND])}
+@code{RESULT = C_FUNLOC(x)}
@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{x} @tab Interoperable function or pointer to such function.
@end multitable
@item @emph{Return value}:
-The return value is of type @code{CHARACTER(1)}
+The return value is of type @code{C_FUNPTR} and contains the C address
+of the argument.
@item @emph{Example}:
@smallexample
-program test_char
- integer :: i = 74
- character(1) :: c
- c = char(i)
- print *, i, c ! returns 'J'
-end program test_char
+module x
+ use iso_c_binding
+ implicit none
+contains
+ subroutine sub(a) bind(c)
+ real(c_float) :: a
+ a = sqrt(a)+5.0
+ end subroutine sub
+end module x
+program main
+ use iso_c_binding
+ use x
+ implicit none
+ interface
+ subroutine my_routine(p) bind(c,name='myC_func')
+ import :: c_funptr
+ type(c_funptr), intent(in) :: p
+ end subroutine
+ end interface
+ call my_routine(c_funloc(sub))
+end program main
@end smallexample
-@item @emph{Note}:
-See @ref{ICHAR} for a discussion of converting between numerical values
-and formatted string representations.
-
@item @emph{See also}:
-@ref{ACHAR}, @ref{IACHAR}, @ref{ICHAR}
-
+@ref{C_ASSOCIATED}, @ref{C_LOC}, @ref{C_F_POINTER}, @ref{C_F_PROCPOINTER}
@end table
-
-@node CHDIR
-@section @code{CHDIR} --- Change working directory
-@cindex @code{CHDIR} intrinsic
-@cindex file system operations
+@node C_F_PROCPOINTER
+@section @code{C_F_PROCPOINTER} --- Convert C into Fortran procedure pointer
+@fnindex C_F_PROCPOINTER
+@cindex pointer, C address of pointers
@table @asis
@item @emph{Description}:
-Change current working directory to a specified path.
-
-This intrinsic is provided in both subroutine and function forms; however,
-only one form can be used in any given program unit.
+@code{C_F_PROCPOINTER(CPTR, FPTR)} Assign the target of the C function pointer
+@var{CPTR} to the Fortran procedure pointer @var{FPTR}.
@item @emph{Standard}:
-GNU extension
+Fortran 2003 and later
@item @emph{Class}:
-Subroutine, non-elemental function
+Subroutine
@item @emph{Syntax}:
-@multitable @columnfractions .80
-@item @code{CALL CHDIR(NAME [, STATUS])}
-@item @code{STATUS = CHDIR(NAME)}
-@end multitable
+@code{CALL C_F_PROCPOINTER(cptr, fptr)}
@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{STATUS} @tab (Optional) @code{INTEGER} status flag of the default
- kind. Returns 0 on success, and a system specific
- and non-zero error code otherwise.
+@item @var{CPTR} @tab scalar of the type @code{C_FUNPTR}. It is
+@code{INTENT(IN)}.
+@item @var{FPTR} @tab procedure pointer interoperable with @var{cptr}. It is
+@code{INTENT(OUT)}.
@end multitable
@item @emph{Example}:
@smallexample
-PROGRAM test_chdir
- CHARACTER(len=255) :: path
- CALL getcwd(path)
- WRITE(*,*) TRIM(path)
- CALL chdir("/tmp")
- CALL getcwd(path)
- WRITE(*,*) TRIM(path)
-END PROGRAM
+program main
+ use iso_c_binding
+ implicit none
+ abstract interface
+ function func(a)
+ import :: c_float
+ real(c_float), intent(in) :: a
+ real(c_float) :: func
+ end function
+ end interface
+ interface
+ function getIterFunc() bind(c,name="getIterFunc")
+ import :: c_funptr
+ type(c_funptr) :: getIterFunc
+ end function
+ end interface
+ type(c_funptr) :: cfunptr
+ procedure(func), pointer :: myFunc
+ cfunptr = getIterFunc()
+ call c_f_procpointer(cfunptr, myFunc)
+end program main
@end smallexample
@item @emph{See also}:
-@ref{GETCWD}
+@ref{C_LOC}, @ref{C_F_POINTER}
@end table
-
-@node CHMOD
-@section @code{CHMOD} --- Change access permissions of files
-@cindex @code{CHMOD} intrinsic
-@cindex file system operations
+@node C_F_POINTER
+@section @code{C_F_POINTER} --- Convert C into Fortran pointer
+@fnindex C_F_POINTER
+@cindex pointer, convert C to Fortran
@table @asis
@item @emph{Description}:
-@code{CHMOD} changes the permissions of a file. This function invokes
-@code{/bin/chmod} and might therefore not work on all platforms.
-
-This intrinsic is provided in both subroutine and function forms; however,
-only one form can be used in any given program unit.
+@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}:
-GNU extension
+Fortran 2003 and later
@item @emph{Class}:
-Subroutine, non-elemental function
+Subroutine
@item @emph{Syntax}:
-@multitable @columnfractions .80
-@item @code{CALL CHMOD(NAME, MODE[, STATUS])}
-@item @code{STATUS = CHMOD(NAME, MODE)}
-@end multitable
+@code{CALL C_F_POINTER(CPTR, FPTR[, SHAPE])}
@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{STATUS} @tab (optional) scalar @code{INTEGER}, which is
-@code{0} on success and non-zero otherwise.
+@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{Return value}:
-In either syntax, @var{STATUS} is set to @code{0} on success and non-zero
-otherwise.
-
@item @emph{Example}:
-@code{CHMOD} as subroutine
-@smallexample
-program chmod_test
- implicit none
- integer :: status
- call chmod('test.dat','u+x',status)
- print *, 'Status: ', status
-end program chmod_test
-@end smallexample
-@code{CHMOD} as non-elemental function:
@smallexample
-program chmod_test
+program main
+ use iso_c_binding
implicit none
- integer :: status
- status = chmod('test.dat','u+x')
- print *, 'Status: ', status
-end program chmod_test
+ interface
+ subroutine my_routine(p) bind(c,name='myC_func')
+ import :: c_ptr
+ type(c_ptr), intent(out) :: p
+ end subroutine
+ end interface
+ type(c_ptr) :: cptr
+ real,pointer :: a(:)
+ call my_routine(cptr)
+ call c_f_pointer(cptr, a, [12])
+end program main
@end smallexample
+@item @emph{See also}:
+@ref{C_LOC}, @ref{C_F_PROCPOINTER}
@end table
-
-@node CMPLX
-@section @code{CMPLX} --- Complex conversion function
-@cindex @code{CMPLX} intrinsic
-@cindex complex numbers, conversion to
+@node C_LOC
+@section @code{C_LOC} --- Obtain the C address of an object
+@fnindex C_LOC
+@cindex procedure pointer, convert C to Fortran
@table @asis
@item @emph{Description}:
-@code{CMPLX(X [, Y [, KIND]])} returns a complex number where @var{X} is converted to
-the real component. If @var{Y} is present it is converted to the imaginary
-component. If @var{Y} is not present then the imaginary component is set to
-0.0. If @var{X} is complex then @var{Y} must not be present.
+@code{C_LOC(X)} determines the C address of the argument.
@item @emph{Standard}:
-F77 and later
+Fortran 2003 and later
@item @emph{Class}:
-Elemental function
+Inquiry function
@item @emph{Syntax}:
-@code{RESULT = CMPLX(X [, Y [, KIND]])}
+@code{RESULT = C_LOC(X)}
@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; 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.
+@multitable @columnfractions .10 .75
+@item @var{X} @tab Shall have either the POINTER or TARGET attribute. It shall not be a coindexed object. It shall either be a variable with interoperable type and kind type parameters, or be a scalar, nonpolymorphic variable with no length type parameters.
+
@end multitable
@item @emph{Return value}:
-The return value is of type @code{COMPLEX(*)}
+The return value is of type @code{C_PTR} and contains the C address
+of the argument.
@item @emph{Example}:
@smallexample
-program test_cmplx
- integer :: i = 42
- real :: x = 3.14
- complex :: z
- z = cmplx(i, x)
- print *, z, cmplx(x)
-end program test_cmplx
+subroutine association_test(a,b)
+ use iso_c_binding, only: c_associated, c_loc, c_ptr
+ implicit none
+ real, pointer :: a
+ type(c_ptr) :: b
+ if(c_associated(b, c_loc(a))) &
+ stop 'b and a do not point to same target'
+end subroutine association_test
@end smallexample
-@end table
+@item @emph{See also}:
+@ref{C_ASSOCIATED}, @ref{C_FUNLOC}, @ref{C_F_POINTER}, @ref{C_F_PROCPOINTER}
+@end table
-@node COMMAND_ARGUMENT_COUNT
-@section @code{COMMAND_ARGUMENT_COUNT} --- Get number of command line arguments
-@cindex @code{COMMAND_ARGUMENT_COUNT} intrinsic
-@cindex command-line arguments, to program
+@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{COMMAND_ARGUMENT_COUNT()} returns the number of arguments passed on the
-command line when the containing program was invoked.
+@code{C_SIZEOF(X)} calculates the number of bytes of storage the
+expression @code{X} occupies.
@item @emph{Standard}:
-F2003
+Fortran 2008
@item @emph{Class}:
-Inquiry function
+Inquiry function of the module @code{ISO_C_BINDING}
@item @emph{Syntax}:
-@code{RESULT = COMMAND_ARGUMENT_COUNT()}
+@code{N = C_SIZEOF(X)}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item None
+@item @var{X} @tab The argument shall be an interoperable data entity.
@end multitable
@item @emph{Return value}:
-The return value is of type @code{INTEGER(4)}
+The return value is of type integer and of the system-dependent kind
+@code{C_SIZE_T} (from the @code{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
-program test_command_argument_count
+ 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}, @ref{STORAGE_SIZE}
+@end table
+
+
+@node CEILING
+@section @code{CEILING} --- Integer ceiling function
+@fnindex CEILING
+@cindex ceiling
+@cindex rounding, ceiling
+
+@table @asis
+@item @emph{Description}:
+@code{CEILING(A)} returns the least integer greater than or equal to @var{A}.
+
+@item @emph{Standard}:
+Fortran 95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = CEILING(A [, KIND])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@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)} if @var{KIND} is present
+and a default-kind @code{INTEGER} otherwise.
+
+@item @emph{Example}:
+@smallexample
+program test_ceiling
+ real :: x = 63.29
+ real :: y = -63.59
+ print *, ceiling(x) ! returns 64
+ print *, ceiling(y) ! returns -63
+end program test_ceiling
+@end smallexample
+
+@item @emph{See also}:
+@ref{FLOOR}, @ref{NINT}
+
+@end table
+
+
+
+@node CHAR
+@section @code{CHAR} --- Character conversion function
+@fnindex CHAR
+@cindex conversion, to character
+
+@table @asis
+@item @emph{Description}:
+@code{CHAR(I [, KIND])} returns the character represented by the integer @var{I}.
+
+@item @emph{Standard}:
+Fortran 77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = CHAR(I [, KIND])}
+
+@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.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{CHARACTER(1)}
+
+@item @emph{Example}:
+@smallexample
+program test_char
+ integer :: i = 74
+ character(1) :: c
+ c = char(i)
+ print *, i, c ! returns 'J'
+end program test_char
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .25
+@item Name @tab Argument @tab Return type @tab Standard
+@item @code{CHAR(I)} @tab @code{INTEGER I} @tab @code{CHARACTER(LEN=1)} @tab F77 and later
+@end multitable
+
+@item @emph{Note}:
+See @ref{ICHAR} for a discussion of converting between numerical values
+and formatted string representations.
+
+@item @emph{See also}:
+@ref{ACHAR}, @ref{IACHAR}, @ref{ICHAR}
+
+@end table
+
+
+
+@node CHDIR
+@section @code{CHDIR} --- Change working directory
+@fnindex CHDIR
+@cindex system, working directory
+
+@table @asis
+@item @emph{Description}:
+Change current working directory to a specified path.
+
+This intrinsic is provided in both subroutine and function forms; however,
+only one form can be used in any given program unit.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine, function
+
+@item @emph{Syntax}:
+@multitable @columnfractions .80
+@item @code{CALL CHDIR(NAME [, STATUS])}
+@item @code{STATUS = CHDIR(NAME)}
+@end multitable
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@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.
+@end multitable
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_chdir
+ CHARACTER(len=255) :: path
+ CALL getcwd(path)
+ WRITE(*,*) TRIM(path)
+ CALL chdir("/tmp")
+ CALL getcwd(path)
+ WRITE(*,*) TRIM(path)
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+@ref{GETCWD}
+@end table
+
+
+
+@node CHMOD
+@section @code{CHMOD} --- Change access permissions of files
+@fnindex CHMOD
+@cindex file system, change access mode
+
+@table @asis
+@item @emph{Description}:
+@code{CHMOD} changes the permissions of a file. This function invokes
+@code{/bin/chmod} and might therefore not work on all platforms.
+
+This intrinsic is provided in both subroutine and function forms; however,
+only one form can be used in any given program unit.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine, function
+
+@item @emph{Syntax}:
+@multitable @columnfractions .80
+@item @code{CALL CHMOD(NAME, MODE[, STATUS])}
+@item @code{STATUS = CHMOD(NAME, MODE)}
+@end multitable
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+
+@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.
+@end multitable
+
+@item @emph{Return value}:
+In either syntax, @var{STATUS} is set to @code{0} on success and nonzero
+otherwise.
+
+@item @emph{Example}:
+@code{CHMOD} as subroutine
+@smallexample
+program chmod_test
+ implicit none
+ integer :: status
+ call chmod('test.dat','u+x',status)
+ print *, 'Status: ', status
+end program chmod_test
+@end smallexample
+@code{CHMOD} as function:
+@smallexample
+program chmod_test
+ implicit none
+ integer :: status
+ status = chmod('test.dat','u+x')
+ print *, 'Status: ', status
+end program chmod_test
+@end smallexample
+
+@end table
+
+
+
+@node CMPLX
+@section @code{CMPLX} --- Complex conversion function
+@fnindex CMPLX
+@cindex complex numbers, conversion to
+@cindex conversion, to complex
+
+@table @asis
+@item @emph{Description}:
+@code{CMPLX(X [, Y [, KIND]])} returns a complex number where @var{X} is converted to
+the real component. If @var{Y} is present it is converted to the imaginary
+component. If @var{Y} is not present then the imaginary component is set to
+0.0. If @var{X} is complex then @var{Y} must not be present.
+
+@item @emph{Standard}:
+Fortran 77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = CMPLX(X [, Y [, KIND]])}
+
+@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; 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.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of @code{COMPLEX} type, with a kind equal to
+@var{KIND} if it is specified. If @var{KIND} is not specified, the
+result is of the default @code{COMPLEX} kind, regardless of the kinds of
+@var{X} and @var{Y}.
+
+@item @emph{Example}:
+@smallexample
+program test_cmplx
+ integer :: i = 42
+ real :: x = 3.14
+ complex :: z
+ z = cmplx(i, x)
+ print *, z, cmplx(x)
+end program test_cmplx
+@end smallexample
+
+@item @emph{See also}:
+@ref{COMPLEX}
+@end table
+
+
+
+@node COMMAND_ARGUMENT_COUNT
+@section @code{COMMAND_ARGUMENT_COUNT} --- Get number of command line arguments
+@fnindex COMMAND_ARGUMENT_COUNT
+@cindex command-line arguments
+@cindex command-line arguments, number of
+@cindex arguments, to program
+
+@table @asis
+@item @emph{Description}:
+@code{COMMAND_ARGUMENT_COUNT()} returns the number of arguments passed on the
+command line when the containing program was invoked.
+
+@item @emph{Standard}:
+Fortran 2003 and later
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@code{RESULT = COMMAND_ARGUMENT_COUNT()}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item None
+@end multitable
+
+@item @emph{Return value}:
+The return value is an @code{INTEGER} of default kind.
+
+@item @emph{Example}:
+@smallexample
+program test_command_argument_count
integer :: count
count = command_argument_count()
print *, count
+@node COMPILER_OPTIONS
+@section @code{COMPILER_OPTIONS} --- Options passed to the compiler
+@fnindex COMPILER_OPTIONS
+@cindex flags inquiry function
+@cindex options inquiry function
+@cindex compiler flags inquiry function
+
+@table @asis
+@item @emph{Description}:
+@code{COMPILER_OPTIONS()} returns a string with the options used for
+compiling.
+
+@item @emph{Standard}:
+Fortran 2008
+
+@item @emph{Class}:
+Inquiry function of the module @code{ISO_FORTRAN_ENV}
+
+@item @emph{Syntax}:
+@code{STR = COMPILER_OPTIONS()}
+
+@item @emph{Arguments}:
+None.
+
+@item @emph{Return value}:
+The return value is a default-kind string with system-dependent length.
+It contains the compiler flags used to compile the file, which called
+the @code{COMPILER_OPTIONS} intrinsic.
+
+@item @emph{Example}:
+@smallexample
+ use iso_fortran_env
+ print '(4a)', 'This file was compiled by ', &
+ compiler_version(), ' using the the options ', &
+ compiler_options()
+ end
+@end smallexample
+
+@item @emph{See also}:
+@ref{COMPILER_VERSION}, @ref{ISO_FORTRAN_ENV}
+@end table
+
+
+
+@node COMPILER_VERSION
+@section @code{COMPILER_VERSION} --- Compiler version string
+@fnindex COMPILER_VERSION
+@cindex compiler, name and version
+@cindex version of the compiler
+
+@table @asis
+@item @emph{Description}:
+@code{COMPILER_VERSION()} returns a string with the name and the
+version of the compiler.
+
+@item @emph{Standard}:
+Fortran 2008
+
+@item @emph{Class}:
+Inquiry function of the module @code{ISO_FORTRAN_ENV}
+
+@item @emph{Syntax}:
+@code{STR = COMPILER_VERSION()}
+
+@item @emph{Arguments}:
+None.
+
+@item @emph{Return value}:
+The return value is a default-kind string with system-dependent length.
+It contains the name of the compiler and its version number.
+
+@item @emph{Example}:
+@smallexample
+ use iso_fortran_env
+ print '(4a)', 'This file was compiled by ', &
+ compiler_version(), ' using the the options ', &
+ compiler_options()
+ end
+@end smallexample
+
+@item @emph{See also}:
+@ref{COMPILER_OPTIONS}, @ref{ISO_FORTRAN_ENV}
+@end table
+
+
+
+@node COMPLEX
+@section @code{COMPLEX} --- Complex conversion function
+@fnindex COMPLEX
+@cindex complex numbers, conversion to
+@cindex conversion, to complex
+
+@table @asis
+@item @emph{Description}:
+@code{COMPLEX(X, Y)} returns a complex number where @var{X} is converted
+to the real component and @var{Y} is converted to the imaginary
+component.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = COMPLEX(X, Y)}
+
+@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}.
+@end multitable
+
+@item @emph{Return value}:
+If @var{X} and @var{Y} are both of @code{INTEGER} type, then the return
+value is of default @code{COMPLEX} type.
+
+If @var{X} and @var{Y} are of @code{REAL} type, or one is of @code{REAL}
+type and one is of @code{INTEGER} type, then the return value is of
+@code{COMPLEX} type with a kind equal to that of the @code{REAL}
+argument with the highest precision.
+
+@item @emph{Example}:
+@smallexample
+program test_complex
+ integer :: i = 42
+ real :: x = 3.14
+ print *, complex(i, x)
+end program test_complex
+@end smallexample
+
+@item @emph{See also}:
+@ref{CMPLX}
+@end table
+
+
+
@node CONJG
@section @code{CONJG} --- Complex conjugate function
-@cindex @code{CONJG} intrinsic
-@cindex @code{DCONJG} intrinsic
+@fnindex CONJG
+@fnindex DCONJG
@cindex complex conjugate
+
@table @asis
@item @emph{Description}:
@code{CONJG(Z)} returns the conjugate of @var{Z}. If @var{Z} is @code{(x, y)}
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
@item @emph{Specific names}:
@multitable @columnfractions .20 .20 .20 .25
-@item Name @tab Argument @tab Return type @tab Standard
-@item @code{DCONJG(Z)} @tab @code{COMPLEX(8) Z} @tab @code{COMPLEX(8)} @tab GNU extension
+@item Name @tab Argument @tab Return type @tab Standard
+@item @code{CONJG(Z)} @tab @code{COMPLEX Z} @tab @code{COMPLEX} @tab GNU extension
+@item @code{DCONJG(Z)} @tab @code{COMPLEX(8) Z} @tab @code{COMPLEX(8)} @tab GNU extension
@end multitable
@end table
@node COS
@section @code{COS} --- Cosine function
-@cindex @code{COS} intrinsic
-@cindex @code{DCOS} intrinsic
-@cindex @code{CCOS} intrinsic
-@cindex @code{ZCOS} intrinsic
-@cindex @code{CDCOS} intrinsic
-@cindex trigonometric functions
+@fnindex COS
+@fnindex DCOS
+@fnindex CCOS
+@fnindex ZCOS
+@fnindex CDCOS
+@cindex trigonometric function, cosine
+@cindex cosine
@table @asis
@item @emph{Description}:
@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
-range @math{ -1 \leq \cos (x) \leq 1}. The kind type
-parameter is the same as @var{X}.
+The return value is of the same type and kind as @var{X}. The real part
+of the result is in radians. If @var{X} is of the type @code{REAL},
+the return value lies in the range @math{ -1 \leq \cos (x) \leq 1}.
@item @emph{Example}:
@smallexample
@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{COS(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab Fortran 77 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
@node COSH
@section @code{COSH} --- Hyperbolic cosine function
-@cindex @code{COSH} intrinsic
-@cindex @code{DCOSH} intrinsic
+@fnindex COSH
+@fnindex DCOSH
@cindex hyperbolic cosine
+@cindex hyperbolic function, cosine
+@cindex cosine, hyperbolic
@table @asis
@item @emph{Description}:
@code{COSH(X)} computes the hyperbolic cosine of @var{X}.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later, for a complex argument Fortran 2008 or later
@item @emph{Class}:
Elemental function
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{X} @tab The type shall be @code{REAL(*)}.
+@item @var{X} @tab The type shall be @code{REAL} or @code{COMPLEX}.
@end multitable
@item @emph{Return value}:
-The return value is of type @code{REAL(*)} and it is positive
-(@math{ \cosh (x) \geq 0 }.
+The return value has same type and kind as @var{X}. If @var{X} is
+complex, the imaginary part of the result is in radians. If @var{X}
+is @code{REAL}, the return value has a lower bound of one,
+@math{\cosh (x) \geq 1}.
@item @emph{Example}:
@smallexample
@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{COSH(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab Fortran 77 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}:
@node COUNT
@section @code{COUNT} --- Count function
-@cindex @code{COUNT} intrinsic
-@cindex count
+@fnindex COUNT
+@cindex array, conditionally count elements
+@cindex array, element counting
+@cindex array, number of elements
@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}.
+
+Counts the number of @code{.TRUE.} elements in a logical @var{MASK},
+or, if the @var{DIM} argument is supplied, counts the number of
+elements along each row of the array in the @var{DIM} direction.
+If the array has zero size, or all of the elements of @var{MASK} are
+@code{.FALSE.}, then the result is @code{0}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later, with @var{KIND} argument Fortran 2003 and later
@item @emph{Class}:
-transformational function
+Transformational function
@item @emph{Syntax}:
-@code{RESULT = COUNT(MASK [, DIM])}
+@code{RESULT = COUNT(MASK [, DIM, KIND])}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
@item @var{MASK} @tab The type shall be @code{LOGICAL}.
-@item @var{DIM} @tab The type shall be @code{INTEGER}.
+@item @var{DIM} @tab (Optional) The type shall be @code{INTEGER}.
+@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization
+expression indicating the kind parameter of the result.
@end multitable
@item @emph{Return value}:
-The return value is of type @code{INTEGER} with rank equal to that of
-@var{MASK}.
+The return value is of type @code{INTEGER} and of kind @var{KIND}. If
+@var{KIND} is absent, the return value is of default integer kind.
+If @var{DIM} is present, the result is an array with a rank one less
+than the rank of @var{ARRAY}, and a size corresponding to the shape
+of @var{ARRAY} with the @var{DIM} dimension removed.
@item @emph{Example}:
@smallexample
@node CPU_TIME
@section @code{CPU_TIME} --- CPU elapsed time in seconds
-@cindex @code{CPU_TIME} intrinsic
+@fnindex CPU_TIME
@cindex time, elapsed
-@cindex elapsed time
@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}:
print '("Time = ",f6.3," seconds.")',finish-start
end program test_cpu_time
@end smallexample
+
+@item @emph{See also}:
+@ref{SYSTEM_CLOCK}, @ref{DATE_AND_TIME}
@end table
@node CSHIFT
-@section @code{CSHIFT} --- Circular shift function
-@cindex @code{CSHIFT} intrinsic
-@cindex bit operations
+@section @code{CSHIFT} --- Circular shift elements of an array
+@fnindex CSHIFT
+@cindex array, shift circularly
+@cindex array, permutation
+@cindex array, rotate
@table @asis
@item @emph{Description}:
@code{CSHIFT(ARRAY, SHIFT [, DIM])} performs a circular shift on elements of
@var{ARRAY} along the dimension of @var{DIM}. If @var{DIM} is omitted it is
-taken to be @code{1}. @var{DIM} is a scaler of type @code{INTEGER} in the
-range of @math{1 /leq DIM /leq n)} where @math{n} is the rank of @var{ARRAY}.
+taken to be @code{1}. @var{DIM} is a scalar of type @code{INTEGER} in the
+range of @math{1 \leq DIM \leq n)} where @math{n} is the rank of @var{ARRAY}.
If the rank of @var{ARRAY} is one, then all elements of @var{ARRAY} are shifted
by @var{SHIFT} places. If rank is greater than one, then all complete rank one
sections of @var{ARRAY} along the given dimension are shifted. Elements
shifted out one end of each rank one section are shifted back in the other end.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
-transformational function
+Transformational function
@item @emph{Syntax}:
-@code{RESULT = CSHIFT(A, SHIFT [, DIM])}
+@code{RESULT = CSHIFT(ARRAY, SHIFT [, DIM])}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{ARRAY} @tab May be any type, not scaler.
+@item @var{ARRAY} @tab Shall be an array of any type.
@item @var{SHIFT} @tab The type shall be @code{INTEGER}.
@item @var{DIM} @tab The type shall be @code{INTEGER}.
@end multitable
@node CTIME
@section @code{CTIME} --- Convert a time into a string
-@cindex @code{CTIME} intrinsic
-@cindex time, conversion function
+@fnindex CTIME
+@cindex time, conversion to string
+@cindex conversion, to string
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-Subroutine
+Subroutine, function
@item @emph{Syntax}:
@multitable @columnfractions .80
@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 @emph{See Also}:
@ref{GMTIME}, @ref{LTIME}, @ref{TIME}, @ref{TIME8}
-
@end table
@node DATE_AND_TIME
@section @code{DATE_AND_TIME} --- Date and time subroutine
-@cindex @code{DATE_AND_TIME} intrinsic
+@fnindex DATE_AND_TIME
@cindex date, current
@cindex current date
@cindex time, current
@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
print '(8i5))', values
end program test_time_and_date
@end smallexample
+
+@item @emph{See also}:
+@ref{CPU_TIME}, @ref{SYSTEM_CLOCK}
@end table
@node DBLE
@section @code{DBLE} --- Double conversion function
-@cindex @code{DBLE} intrinsic
-@cindex double conversion
+@fnindex DBLE
+@cindex conversion, to real
@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}:
@end smallexample
@item @emph{See also}:
-@ref{DFLOAT}, @ref{FLOAT}, @ref{REAL}
+@ref{REAL}
@end table
@node DCMPLX
@section @code{DCMPLX} --- Double complex conversion function
-@cindex @code{DCMPLX} intrinsic
+@fnindex DCMPLX
@cindex complex numbers, conversion to
+@cindex conversion, to complex
@table @asis
@item @emph{Description}:
@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}:
@end table
-
-@node DFLOAT
-@section @code{DFLOAT} --- Double conversion function
-@cindex @code{DFLOAT} intrinsic
-@cindex double float conversion
-
-@table @asis
-@item @emph{Description}:
-@code{DFLOAT(X)} Converts @var{X} to double precision real type.
-
-@item @emph{Standard}:
-GNU extension
-
-@item @emph{Class}:
-Elemental function
-
-@item @emph{Syntax}:
-@code{RESULT = DFLOAT(X)}
-
-@item @emph{Arguments}:
-@multitable @columnfractions .15 .70
-@item @var{X} @tab The type shall be @code{INTEGER(*)}.
-@end multitable
-
-@item @emph{Return value}:
-The return value is of type double precision real.
-
-@item @emph{Example}:
-@smallexample
-program test_dfloat
- integer :: i = 5
- print *, dfloat(i)
-end program test_dfloat
-@end smallexample
-
-@item @emph{See also}:
-@ref{DBLE}, @ref{FLOAT}, @ref{REAL}
-@end table
-
-
-
@node DIGITS
-@section @code{DIGITS} --- Significant digits function
-@cindex @code{DIGITS} intrinsic
-@cindex digits, significant
+@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}:
@node DIM
-@section @code{DIM} --- Dim function
-@cindex @code{DIM} intrinsic
-@cindex @code{IDIM} intrinsic
-@cindex @code{DDIM} intrinsic
-@cindex dim
+@section @code{DIM} --- Positive difference
+@fnindex DIM
+@fnindex IDIM
+@fnindex DDIM
+@cindex positive difference
@table @asis
@item @emph{Description}:
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 Name @tab Argument @tab Return type @tab Standard
+@item @code{DIM(X,Y)} @tab @code{REAL(4) X, Y} @tab @code{REAL(4)} @tab Fortran 77 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
@node DOT_PRODUCT
@section @code{DOT_PRODUCT} --- Dot product function
-@cindex @code{DOT_PRODUCT} intrinsic
+@fnindex DOT_PRODUCT
@cindex dot product
+@cindex vector product
+@cindex product, vector
@table @asis
@item @emph{Description}:
-@code{DOT_PRODUCT(X,Y)} computes the dot product multiplication of two vectors
-@var{X} and @var{Y}. The two vectors may be either numeric or logical
-and must be arrays of rank one and of equal size. If the vectors are
-@code{INTEGER(*)} or @code{REAL(*)}, the result is @code{SUM(X*Y)}. If the
-vectors are @code{COMPLEX(*)}, the result is @code{SUM(CONJG(X)*Y)}. If the
-vectors are @code{LOGICAL}, the result is @code{ANY(X.AND.Y)}.
+@code{DOT_PRODUCT(VECTOR_A, VECTOR_B)} computes the dot product multiplication
+of two vectors @var{VECTOR_A} and @var{VECTOR_B}. The two vectors may be
+either numeric or logical and must be arrays of rank one and of equal size. If
+the vectors are @code{INTEGER} or @code{REAL}, the result is
+@code{SUM(VECTOR_A*VECTOR_B)}. If the vectors are @code{COMPLEX}, the result
+is @code{SUM(CONJG(VECTOR_A)*VECTOR_B)}. If the vectors are @code{LOGICAL},
+the result is @code{ANY(VECTOR_A .AND. VECTOR_B)}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
-transformational function
+Transformational function
@item @emph{Syntax}:
-@code{RESULT = DOT_PRODUCT(X, Y)}
+@code{RESULT = DOT_PRODUCT(VECTOR_A, VECTOR_B)}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{X} @tab The type shall be numeric or @code{LOGICAL}, rank 1.
-@item @var{Y} @tab The type shall be numeric or @code{LOGICAL}, rank 1.
+@item @var{VECTOR_A} @tab The type shall be numeric or @code{LOGICAL}, rank 1.
+@item @var{VECTOR_B} @tab The type shall be numeric if @var{VECTOR_A} is of numeric type or @code{LOGICAL} if @var{VECTOR_A} is of type @code{LOGICAL}. @var{VECTOR_B} shall be a rank-one array.
@end multitable
@item @emph{Return value}:
-If the arguments are numeric, the return value is a scaler of numeric type,
-@code{INTEGER(*)}, @code{REAL(*)}, or @code{COMPLEX(*)}. If the arguments are
+If the arguments are numeric, the return value is a scalar of numeric type,
+@code{INTEGER}, @code{REAL}, or @code{COMPLEX}. If the arguments are
@code{LOGICAL}, the return value is @code{.TRUE.} or @code{.FALSE.}.
@item @emph{Example}:
@node DPROD
@section @code{DPROD} --- Double product function
-@cindex @code{DPROD} intrinsic
-@cindex double-precision product
+@fnindex DPROD
+@cindex product, double-precision
@table @asis
@item @emph{Description}:
@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
@item @emph{Example}:
@smallexample
program test_dprod
- integer :: i
real :: x = 5.2
real :: y = 2.3
real(8) :: d
print *, d
end program test_dprod
@end smallexample
-@end table
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .25
+@item Name @tab Argument @tab Return type @tab Standard
+@item @code{DPROD(X,Y)} @tab @code{REAL(4) X, Y} @tab @code{REAL(4)} @tab Fortran 77 and later
+@end multitable
+
+@end table
@node DREAL
@section @code{DREAL} --- Double real part function
-@cindex @code{DREAL} intrinsic
-@cindex double-precision real part
+@fnindex DREAL
+@cindex complex numbers, real part
@table @asis
@item @emph{Description}:
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}:
@end smallexample
@item @emph{See also}:
-@ref{AIMAG}
+@ref{AIMAG}
+
+@end table
+
+
+
+@node DSHIFTL
+@section @code{DSHIFTL} --- Combined left shift
+@fnindex DSHIFTL
+@cindex left shift, combined
+@cindex shift, left
+
+@table @asis
+@item @emph{Description}:
+@code{DSHIFTL(I, J, SHIFT)} combines bits of @var{I} and @var{J}. The
+rightmost @var{SHIFT} bits of the result are the leftmost @var{SHIFT}
+bits of @var{J}, and the remaining bits are the rightmost bits of
+@var{I}.
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = DSHIFTL(I, J, SHIFT)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{I} @tab Shall be of type @code{INTEGER}.
+@item @var{J} @tab Shall be of type @code{INTEGER}, and of the same kind
+as @var{I}.
+@item @var{SHIFT} @tab Shall be of type @code{INTEGER}.
+@end multitable
+
+@item @emph{Return value}:
+The return value has same type and kind as @var{I}.
+
+@item @emph{See also}:
+@ref{DSHIFTR}
+
+@end table
+
+
+
+@node DSHIFTR
+@section @code{DSHIFTR} --- Combined right shift
+@fnindex DSHIFTR
+@cindex right shift, combined
+@cindex shift, right
+
+@table @asis
+@item @emph{Description}:
+@code{DSHIFTR(I, J, SHIFT)} combines bits of @var{I} and @var{J}. The
+leftmost @var{SHIFT} bits of the result are the rightmost @var{SHIFT}
+bits of @var{I}, and the remaining bits are the leftmost bits of
+@var{J}.
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = DSHIFTR(I, J, SHIFT)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{I} @tab Shall be of type @code{INTEGER}.
+@item @var{J} @tab Shall be of type @code{INTEGER}, and of the same kind
+as @var{I}.
+@item @var{SHIFT} @tab Shall be of type @code{INTEGER}.
+@end multitable
+
+@item @emph{Return value}:
+The return value has same type and kind as @var{I}.
+
+@item @emph{See also}:
+@ref{DSHIFTL}
@end table
@node DTIME
@section @code{DTIME} --- Execution time subroutine (or function)
-@cindex @code{DTIME} intrinsic
+@fnindex DTIME
@cindex time, elapsed
@cindex elapsed time
@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.
-If @code{DTIME} is invoked as a function, it can not be invoked as a
-subroutine, and vice versa.
+Please note, that this implementation is thread safe if used within OpenMP
+directives, i.e., its state will be consistent while called from multiple
+threads. However, if @code{DTIME} is called from multiple threads, the result
+is still the time since the last invocation. This may not give the intended
+results. If possible, use @code{CPU_TIME} instead.
-@var{TARRAY} and @var{RESULT} are @code{INTENT(OUT)} and provide the following:
+This intrinsic is provided in both subroutine and function forms; however,
+only one form can be used in any given program unit.
+
+@var{VALUES} and @var{TIME} are @code{INTENT(OUT)} and provide the following:
@multitable @columnfractions .15 .30 .40
-@item @tab @code{TARRAY(1)}: @tab User time in seconds.
-@item @tab @code{TARRAY(2)}: @tab System time in seconds.
-@item @tab @code{RESULT}: @tab Run time since start in seconds.
+@item @tab @code{VALUES(1)}: @tab User time in seconds.
+@item @tab @code{VALUES(2)}: @tab System time in seconds.
+@item @tab @code{TIME}: @tab Run time since start in seconds.
@end multitable
@item @emph{Standard}:
GNU extension
@item @emph{Class}:
-Subroutine
+Subroutine, function
@item @emph{Syntax}:
@multitable @columnfractions .80
-@item @code{CALL DTIME(TARRAY, RESULT)}.
-@item @code{RESULT = DTIME(TARRAY)}, (not recommended).
+@item @code{CALL DTIME(VALUES, TIME)}.
+@item @code{TIME = DTIME(VALUES)}, (not recommended).
@end multitable
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{TARRAY}@tab The type shall be @code{REAL, DIMENSION(2)}.
-@item @var{RESULT}@tab The type shall be @code{REAL}.
+@item @var{VALUES}@tab The type shall be @code{REAL(4), DIMENSION(2)}.
+@item @var{TIME}@tab The type shall be @code{REAL(4)}.
@end multitable
@item @emph{Return value}:
-Elapsed time in seconds since the start of program execution.
+Elapsed time in seconds since the last invocation or since the start of program
+execution if not called before.
@item @emph{Example}:
@smallexample
print *, tarray(2)
end program test_dtime
@end smallexample
+
+@item @emph{See also}:
+@ref{CPU_TIME}
+
@end table
@node EOSHIFT
-@section @code{EOSHIFT} --- End-off shift function
-@cindex @code{EOSHIFT} intrinsic
-@cindex bit operations
+@section @code{EOSHIFT} --- End-off shift elements of an array
+@fnindex EOSHIFT
+@cindex array, shift
@table @asis
@item @emph{Description}:
-@code{EOSHIFT(ARRAY, SHIFT[,BOUNDARY, DIM])} performs an end-off shift on
+@code{EOSHIFT(ARRAY, SHIFT[, BOUNDARY, DIM])} performs an end-off shift on
elements of @var{ARRAY} along the dimension of @var{DIM}. If @var{DIM} is
-omitted it is taken to be @code{1}. @var{DIM} is a scaler of type
-@code{INTEGER} in the range of @math{1 /leq DIM /leq n)} where @math{n} is the
+omitted it is taken to be @code{1}. @var{DIM} is a scalar of type
+@code{INTEGER} in the range of @math{1 \leq DIM \leq n)} where @math{n} is the
rank of @var{ARRAY}. If the rank of @var{ARRAY} is one, then all elements of
@var{ARRAY} are shifted by @var{SHIFT} places. If rank is greater than one,
then all complete rank one sections of @var{ARRAY} along the given dimension are
@end multitable
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
-transformational function
+Transformational function
@item @emph{Syntax}:
-@code{RESULT = EOSHIFT(A, SHIFT [, BOUNDARY, DIM])}
+@code{RESULT = EOSHIFT(ARRAY, SHIFT [, BOUNDARY, DIM])}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{ARRAY} @tab May be any type, not scaler.
+@item @var{ARRAY} @tab May be any type, not scalar.
@item @var{SHIFT} @tab The type shall be @code{INTEGER}.
@item @var{BOUNDARY} @tab Same type as @var{ARRAY}.
@item @var{DIM} @tab The type shall be @code{INTEGER}.
@node EPSILON
@section @code{EPSILON} --- Epsilon function
-@cindex @code{EPSILON} intrinsic
-@cindex epsilon, significant
+@fnindex EPSILON
+@cindex model representation, epsilon
@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}:
@node ERF
@section @code{ERF} --- Error function
-@cindex @code{ERF} intrinsic
+@fnindex ERF
@cindex error function
@table @asis
@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
@node ERFC
@section @code{ERFC} --- Error function
-@cindex @code{ERFC} intrinsic
-@cindex error function
+@fnindex ERFC
+@cindex error function, complementary
@table @asis
@item @emph{Description}:
@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)
-@cindex @code{ETIME} intrinsic
+@fnindex ETIME
@cindex time, elapsed
@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
become, negative, or numerically less than previous values, during a single
run of the compiled program.
-If @code{ETIME} is invoked as a function, it can not be invoked as a
-subroutine, and vice versa.
+This intrinsic is provided in both subroutine and function forms; however,
+only one form can be used in any given program unit.
-@var{TARRAY} and @var{RESULT} are @code{INTENT(OUT)} and provide the following:
+@var{VALUES} and @var{TIME} are @code{INTENT(OUT)} and provide the following:
@multitable @columnfractions .15 .30 .60
-@item @tab @code{TARRAY(1)}: @tab User time in seconds.
-@item @tab @code{TARRAY(2)}: @tab System time in seconds.
-@item @tab @code{RESULT}: @tab Run time since start in seconds.
+@item @tab @code{VALUES(1)}: @tab User time in seconds.
+@item @tab @code{VALUES(2)}: @tab System time in seconds.
+@item @tab @code{TIME}: @tab Run time since start in seconds.
@end multitable
@item @emph{Standard}:
GNU extension
@item @emph{Class}:
-Subroutine
+Subroutine, function
@item @emph{Syntax}:
@multitable @columnfractions .80
-@item @code{CALL ETIME(TARRAY, RESULT)}.
-@item @code{RESULT = ETIME(TARRAY)}, (not recommended).
+@item @code{CALL ETIME(VALUES, TIME)}.
+@item @code{TIME = ETIME(VALUES)}, (not recommended).
@end multitable
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{TARRAY}@tab The type shall be @code{REAL, DIMENSION(2)}.
-@item @var{RESULT}@tab The type shall be @code{REAL}.
+@item @var{VALUES}@tab The type shall be @code{REAL(4), DIMENSION(2)}.
+@item @var{TIME}@tab The type shall be @code{REAL(4)}.
@end multitable
@item @emph{Return value}:
+@node EXECUTE_COMMAND_LINE
+@section @code{EXECUTE_COMMAND_LINE} --- Execute a shell command
+@fnindex EXECUTE_COMMAND_LINE
+@cindex system, system call
+@cindex command line
+
+@table @asis
+@item @emph{Description}:
+@code{EXECUTE_COMMAND_LINE} runs a shell command, synchronously or
+asynchronously.
+
+The @code{COMMAND} argument is passed to the shell and executed, using
+the C library's @code{system()} call. (The shell is @code{sh} on Unix
+systems, and @code{cmd.exe} on Windows.) If @code{WAIT} is present and
+has the value false, the execution of the command is asynchronous if the
+system supports it; otherwise, the command is executed synchronously.
+
+The three last arguments allow the user to get status information. After
+synchronous execution, @code{EXITSTAT} contains the integer exit code of
+the command, as returned by @code{system}. @code{CMDSTAT} is set to zero
+if the command line was executed (whatever its exit status was).
+@code{CMDMSG} is assigned an error message if an error has occurred.
+
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@code{CALL EXECUTE_COMMAND_LINE(COMMAND [, WAIT, EXITSTAT, CMDSTAT, CMDMSG ])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{COMMAND} @tab Shall be a default @code{CHARACTER} scalar.
+@item @var{WAIT} @tab (Optional) Shall be a default @code{LOGICAL} scalar.
+@item @var{EXITSTAT} @tab (Optional) Shall be an @code{INTEGER} of the
+default kind.
+@item @var{CMDSTAT} @tab (Optional) Shall be an @code{INTEGER} of the
+default kind.
+@item @var{CMDMSG} @tab (Optional) Shall be an @code{CHARACTER} scalar of the
+default kind.
+@end multitable
+
+@item @emph{Example}:
+@smallexample
+program test_exec
+ integer :: i
+
+ call execute_command_line ("external_prog.exe", exitstat=i)
+ print *, "Exit status of external_prog.exe was ", i
+
+ call execute_command_line ("reindex_files.exe", wait=.false.)
+ print *, "Now reindexing files in the background"
+
+end program test_exec
+@end smallexample
+
+
+@item @emph{Note}:
+
+Because this intrinsic is implemented in terms of the @code{system()}
+function call, its behavior with respect to signaling is processor
+dependent. In particular, on POSIX-compliant systems, the SIGINT and
+SIGQUIT signals will be ignored, and the SIGCHLD will be blocked. As
+such, if the parent process is terminated, the child process might not be
+terminated alongside.
+
+
+@item @emph{See also}:
+@ref{SYSTEM}
+@end table
+
+
+
@node EXIT
@section @code{EXIT} --- Exit the program with status.
-@cindex @code{EXIT} intrinsic
-@cindex exit program
+@fnindex EXIT
+@cindex program termination
+@cindex terminate program
@table @asis
@item @emph{Description}:
@node EXP
@section @code{EXP} --- Exponential function
-@cindex @code{EXP} intrinsic
-@cindex @code{DEXP} intrinsic
-@cindex @code{CEXP} intrinsic
-@cindex @code{ZEXP} intrinsic
-@cindex @code{CDEXP} intrinsic
-@cindex exponential
+@fnindex EXP
+@fnindex DEXP
+@fnindex CEXP
+@fnindex ZEXP
+@fnindex CDEXP
+@cindex exponential function
+@cindex logarithmic function, inverse
@table @asis
@item @emph{Description}:
@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{EXP(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab Fortran 77 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
@node EXPONENT
@section @code{EXPONENT} --- Exponent function
-@cindex @code{EXPONENT} intrinsic
-@cindex exponent part of a real number
+@fnindex EXPONENT
+@cindex real number, exponent
+@cindex floating point, exponent
@table @asis
@item @emph{Description}:
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}:
+@node EXTENDS_TYPE_OF
+@section @code{EXTENDS_TYPE_OF} --- Query dynamic type for extension
+@fnindex EXTENDS_TYPE_OF
+
+@table @asis
+@item @emph{Description}:
+Query dynamic type for extension.
+
+@item @emph{Standard}:
+Fortran 2003 and later
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@code{RESULT = EXTENDS_TYPE_OF(A, MOLD)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{A} @tab Shall be an object of extensible declared type or
+unlimited polymorphic.
+@item @var{MOLD} @tab Shall be an object of extensible declared type or
+unlimited polymorphic.
+@end multitable
+
+@item @emph{Return value}:
+The return value is a scalar of type default logical. It is true if and only if
+the dynamic type of A is an extension type of the dynamic type of MOLD.
+
+
+@item @emph{See also}:
+@ref{SAME_TYPE_AS}
+@end table
+
+
+
@node FDATE
@section @code{FDATE} --- Get the current time as a string
-@cindex @code{FDATE} intrinsic
+@fnindex FDATE
@cindex time, current
@cindex current time
@cindex date, current
@code{CTIME}) in @var{DATE}. It is equivalent to @code{CALL CTIME(DATE,
TIME())}.
-If @code{FDATE} is invoked as a function, it can not be invoked as a
-subroutine, and vice versa.
+This intrinsic is provided in both subroutine and function forms; however,
+only one form can be used in any given program unit.
-@var{DATE} is an @code{INTENT(OUT)} @code{CHARACTER} variable.
+@var{DATE} is an @code{INTENT(OUT)} @code{CHARACTER} variable of the
+default kind.
@item @emph{Standard}:
GNU extension
@item @emph{Class}:
-Subroutine
+Subroutine, function
@item @emph{Syntax}:
@multitable @columnfractions .80
@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}:
-@node FLOAT
-
-@section @code{FLOAT} --- Convert integer to default real
-@cindex @code{FLOAT} intrinsic
-@cindex conversion function (float)
-
-@table @asis
-@item @emph{Description}:
-@code{FLOAT(I)} converts the integer @var{I} to a default real value.
-
-@item @emph{Standard}:
-GNU extension
-
-@item @emph{Class}:
-Elemental function
-
-@item @emph{Syntax}:
-@code{RESULT = FLOAT(I)}
-
-@item @emph{Arguments}:
-@multitable @columnfractions .15 .70
-@item @var{I} @tab The type shall be @code{INTEGER(*)}.
-@end multitable
-
-@item @emph{Return value}:
-The return value is of type default @code{REAL}.
-
-@item @emph{Example}:
-@smallexample
-program test_float
- integer :: i = 1
- if (float(i) /= 1.) call abort
-end program test_float
-@end smallexample
-
-@item @emph{See also}:
-@ref{DBLE}, @ref{DFLOAT}, @ref{REAL}
-@end table
-
-
-
@node FGET
@section @code{FGET} --- Read a single character in stream mode from stdin
-@cindex @code{FGET} intrinsic
-@cindex file operations
-@cindex stream operations
+@fnindex FGET
+@cindex read character, stream mode
+@cindex stream mode, read character
+@cindex file operation, read character
@table @asis
@item @emph{Description}:
formatted output. Stream I/O should not be mixed with normal record-oriented
(formatted or unformatted) I/O on the same unit; the results are unpredictable.
-This intrinsic routine is provided for backwards compatibility with
+This intrinsic is provided in both subroutine and function forms; however,
+only one form can be used in any given program unit.
+
+Note that the @code{FGET} intrinsic is provided for backwards compatibility with
@command{g77}. GNU Fortran provides the Fortran 2003 Stream facility.
Programmers should consider the use of new stream IO feature in new code
for future portability. See also @ref{Fortran 2003 status}.
GNU extension
@item @emph{Class}:
-Non-elemental subroutine
+Subroutine, function
@item @emph{Syntax}:
-@code{CALL FGET(C [, STATUS])}
+@multitable @columnfractions .80
+@item @code{CALL FGET(C [, STATUS])}
+@item @code{STATUS = FGET(C)}
+@end multitable
@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}:
@node FGETC
@section @code{FGETC} --- Read a single character in stream mode
-@cindex @code{FGETC} intrinsic
-@cindex file operations
-@cindex stream operations
+@fnindex FGETC
+@cindex read character, stream mode
+@cindex stream mode, read character
+@cindex file operation, read character
@table @asis
@item @emph{Description}:
Stream I/O should not be mixed with normal record-oriented (formatted or
unformatted) I/O on the same unit; the results are unpredictable.
-This intrinsic routine is provided for backwards compatibility with
-@command{g77}. GNU Fortran provides the Fortran 2003 Stream facility.
+This intrinsic is provided in both subroutine and function forms; however,
+only one form can be used in any given program unit.
+
+Note that the @code{FGET} intrinsic is provided for backwards compatibility
+with @command{g77}. GNU Fortran provides the Fortran 2003 Stream facility.
Programmers should consider the use of new stream IO feature in new code
for future portability. See also @ref{Fortran 2003 status}.
GNU extension
@item @emph{Class}:
-Non-elemental subroutine
+Subroutine, function
@item @emph{Syntax}:
-@code{CALL FGETC(UNIT, C [, STATUS])}
+@multitable @columnfractions .80
+@item @code{CALL FGETC(UNIT, C [, STATUS])}
+@item @code{STATUS = FGETC(UNIT, C)}
+@end multitable
@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}:
@node FLOOR
@section @code{FLOOR} --- Integer floor function
-@cindex @code{FLOOR} intrinsic
+@fnindex FLOOR
@cindex floor
+@cindex rounding, floor
@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
@node FLUSH
@section @code{FLUSH} --- Flush I/O unit(s)
-@cindex @code{FLUSH} intrinsic
-@cindex flush output files
+@fnindex FLUSH
+@cindex file operation, flush
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-Non-elemental subroutine
+Subroutine
@item @emph{Syntax}:
@code{CALL FLUSH(UNIT)}
Beginning with the Fortran 2003 standard, there is a @code{FLUSH}
statement that should be preferred over the @code{FLUSH} intrinsic.
+The @code{FLUSH} intrinsic and the Fortran 2003 @code{FLUSH} statement
+have identical effect: they flush the runtime library's I/O buffer so
+that the data becomes visible to other processes. This does not guarantee
+that the data is committed to disk.
+
+On POSIX systems, you can request that all data is transferred to the
+storage device by calling the @code{fsync} function, with the POSIX file
+descriptor of the I/O unit as argument (retrieved with GNU intrinsic
+@code{FNUM}). The following example shows how:
+
+@smallexample
+ ! Declare the interface for POSIX fsync function
+ interface
+ function fsync (fd) bind(c,name="fsync")
+ use iso_c_binding, only: c_int
+ integer(c_int), value :: fd
+ integer(c_int) :: fsync
+ end function fsync
+ end interface
+
+ ! Variable declaration
+ integer :: ret
+
+ ! Opening unit 10
+ open (10,file="foo")
+
+ ! ...
+ ! Perform I/O on unit 10
+ ! ...
+
+ ! Flush and sync
+ flush(10)
+ ret = fsync(fnum(10))
+
+ ! Handle possible error
+ if (ret /= 0) stop "Error calling FSYNC"
+@end smallexample
+
@end table
@node FNUM
@section @code{FNUM} --- File number function
-@cindex @code{FNUM} intrinsic
-@cindex fnum
+@fnindex FNUM
+@cindex file operation, file number
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-Non-elemental function
+Function
@item @emph{Syntax}:
@code{RESULT = FNUM(UNIT)}
@node FPUT
@section @code{FPUT} --- Write a single character in stream mode to stdout
-@cindex @code{FPUT} intrinsic
-@cindex file operations
-@cindex stream operations
+@fnindex FPUT
+@cindex write character, stream mode
+@cindex stream mode, write character
+@cindex file operation, write character
@table @asis
@item @emph{Description}:
formatted output. Stream I/O should not be mixed with normal record-oriented
(formatted or unformatted) I/O on the same unit; the results are unpredictable.
-This intrinsic routine is provided for backwards compatibility with
+This intrinsic is provided in both subroutine and function forms; however,
+only one form can be used in any given program unit.
+
+Note that the @code{FGET} intrinsic is provided for backwards compatibility with
@command{g77}. GNU Fortran provides the Fortran 2003 Stream facility.
Programmers should consider the use of new stream IO feature in new code
for future portability. See also @ref{Fortran 2003 status}.
GNU extension
@item @emph{Class}:
-Non-elemental subroutine
+Subroutine, function
@item @emph{Syntax}:
-@code{CALL FPUT(C [, STATUS])}
+@multitable @columnfractions .80
+@item @code{CALL FPUT(C [, STATUS])}
+@item @code{STATUS = FPUT(C)}
+@end multitable
@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}:
@smallexample
PROGRAM test_fput
- CHARACTER(len=*) :: str = "gfortran"
+ CHARACTER(len=10) :: str = "gfortran"
INTEGER :: i
DO i = 1, len_trim(str)
CALL fput(str(i:i))
@node FPUTC
@section @code{FPUTC} --- Write a single character in stream mode
-@cindex @code{FPUTC} intrinsic
-@cindex file operations
-@cindex stream operations
+@fnindex FPUTC
+@cindex write character, stream mode
+@cindex stream mode, write character
+@cindex file operation, write character
@table @asis
@item @emph{Description}:
output. Stream I/O should not be mixed with normal record-oriented
(formatted or unformatted) I/O on the same unit; the results are unpredictable.
-This intrinsic routine is provided for backwards compatibility with
+This intrinsic is provided in both subroutine and function forms; however,
+only one form can be used in any given program unit.
+
+Note that the @code{FGET} intrinsic is provided for backwards compatibility with
@command{g77}. GNU Fortran provides the Fortran 2003 Stream facility.
Programmers should consider the use of new stream IO feature in new code
for future portability. See also @ref{Fortran 2003 status}.
GNU extension
@item @emph{Class}:
-Non-elemental subroutine
+Subroutine, function
@item @emph{Syntax}:
-@code{CALL FPUTC(UNIT, C [, STATUS])}
+@multitable @columnfractions .80
+@item @code{CALL FPUTC(UNIT, C [, STATUS])}
+@item @code{STATUS = FPUTC(UNIT, C)}
+@end multitable
@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}:
@smallexample
PROGRAM test_fputc
- CHARACTER(len=*) :: str = "gfortran"
+ CHARACTER(len=10) :: str = "gfortran"
INTEGER :: fd = 42, i
OPEN(UNIT = fd, FILE = "out", ACTION = "WRITE", STATUS="NEW")
@node FRACTION
@section @code{FRACTION} --- Fractional part of the model representation
-@cindex @code{FRACTION} intrinsic
-@cindex fractional part
+@fnindex FRACTION
+@cindex real number, fraction
+@cindex floating point, fraction
@table @asis
@item @emph{Description}:
representation of @code{X}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Elemental function
@node FREE
@section @code{FREE} --- Frees memory
-@cindex @code{FREE} intrinsic
-@cindex Cray pointers
+@fnindex FREE
+@cindex pointer, cray
@table @asis
@item @emph{Description}:
@node FSEEK
@section @code{FSEEK} --- Low level file positioning subroutine
-@cindex @code{FSEEK} intrinsic
-@cindex file system operations
-
-Not yet implemented in GNU Fortran.
+@fnindex FSEEK
+@cindex file operation, seek
+@cindex file operation, position
@table @asis
@item @emph{Description}:
+Moves @var{UNIT} to the specified @var{OFFSET}. If @var{WHENCE}
+is set to 0, the @var{OFFSET} is taken as an absolute value @code{SEEK_SET},
+if set to 1, @var{OFFSET} is taken to be relative to the current position
+@code{SEEK_CUR}, and if set to 2 relative to the end of the file @code{SEEK_END}.
+On error, @var{STATUS} is set to a nonzero value. If @var{STATUS} the seek
+fails silently.
+
+This intrinsic routine is not fully backwards compatible with @command{g77}.
+In @command{g77}, the @code{FSEEK} takes a statement label instead of a
+@var{STATUS} variable. If FSEEK is used in old code, change
+@smallexample
+ CALL FSEEK(UNIT, OFFSET, WHENCE, *label)
+@end smallexample
+to
+@smallexample
+ INTEGER :: status
+ CALL FSEEK(UNIT, OFFSET, WHENCE, status)
+ IF (status /= 0) GOTO label
+@end smallexample
+
+Please note that GNU Fortran provides the Fortran 2003 Stream facility.
+Programmers should consider the use of new stream IO feature in new code
+for future portability. See also @ref{Fortran 2003 status}.
@item @emph{Standard}:
GNU extension
Subroutine
@item @emph{Syntax}:
+@code{CALL FSEEK(UNIT, OFFSET, WHENCE[, STATUS])}
+
@item @emph{Arguments}:
-@item @emph{Return value}:
+@multitable @columnfractions .15 .70
+@item @var{UNIT} @tab Shall be a scalar of type @code{INTEGER}.
+@item @var{OFFSET} @tab Shall be a scalar of type @code{INTEGER}.
+@item @var{WHENCE} @tab Shall be a scalar of type @code{INTEGER}.
+Its value shall be either 0, 1 or 2.
+@item @var{STATUS} @tab (Optional) shall be a scalar of type
+@code{INTEGER(4)}.
+@end multitable
+
@item @emph{Example}:
-@item @emph{Specific names}:
-@item @emph{See also}:
-@uref{http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19292, g77 features lacking in gfortran}
+@smallexample
+PROGRAM test_fseek
+ INTEGER, PARAMETER :: SEEK_SET = 0, SEEK_CUR = 1, SEEK_END = 2
+ INTEGER :: fd, offset, ierr
+
+ ierr = 0
+ offset = 5
+ fd = 10
+
+ OPEN(UNIT=fd, FILE="fseek.test")
+ CALL FSEEK(fd, offset, SEEK_SET, ierr) ! move to OFFSET
+ print *, FTELL(fd), ierr
+
+ CALL FSEEK(fd, 0, SEEK_END, ierr) ! move to end
+ print *, FTELL(fd), ierr
+
+ CALL FSEEK(fd, 0, SEEK_SET, ierr) ! move to beginning
+ print *, FTELL(fd), ierr
+ CLOSE(UNIT=fd)
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+@ref{FTELL}
@end table
@node FSTAT
@section @code{FSTAT} --- Get file status
-@cindex @code{FSTAT} intrinsic
-@cindex file system operations
+@fnindex FSTAT
+@cindex file system, file status
@table @asis
@item @emph{Description}:
@code{FSTAT} is identical to @ref{STAT}, except that information about an
already opened file is obtained.
-The elements in @code{BUFF} are the same as described by @ref{STAT}.
+The elements in @code{VALUES} are the same as described by @ref{STAT}.
+
+This intrinsic is provided in both subroutine and function forms; however,
+only one form can be used in any given program unit.
@item @emph{Standard}:
GNU extension
@item @emph{Class}:
-Non-elemental subroutine
+Subroutine, function
@item @emph{Syntax}:
-@code{CALL FSTAT(UNIT, BUFF [, STATUS])}
+@multitable @columnfractions .80
+@item @code{CALL FSTAT(UNIT, VALUES [, STATUS])}
+@item @code{STATUS = FSTAT(UNIT, VALUES)}
+@end multitable
@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 FTELL
@section @code{FTELL} --- Current stream position
-@cindex @code{FTELL} intrinsic
+@fnindex FTELL
+@cindex file operation, position
@table @asis
@item @emph{Description}:
@end multitable
@item @emph{Return value}:
-In either syntax, @var{OFFSET} is set to the current offset of unit
-number @var{UNIT}, or to @math{-1} if the unit is not currently open.
+In either syntax, @var{OFFSET} is set to the current offset of unit
+number @var{UNIT}, or to @math{-1} if the unit is not currently open.
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_ftell
+ INTEGER :: i
+ OPEN(10, FILE="temp.dat")
+ CALL ftell(10,i)
+ WRITE(*,*) i
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+@ref{FSEEK}
+@end table
+
+
+
+@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_ftell
- INTEGER :: i
- OPEN(10, FILE="temp.dat")
- CALL ftell(10,i)
- WRITE(*,*) i
-END PROGRAM
+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}:
-@ref{FSEEK}
+Logarithm of the Gamma function: @ref{LOG_GAMMA}
+
@end table
@node GERROR
@section @code{GERROR} --- Get last system error message
-@cindex @code{GERROR} intrinsic
+@fnindex GERROR
+@cindex system, error handling
@table @asis
@item @emph{Description}:
@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}:
@node GETARG
@section @code{GETARG} --- Get command line arguments
-@cindex @code{GETARG} intrinsic
-@cindex command-line arguments, to program
+@fnindex GETARG
+@cindex command-line arguments
+@cindex arguments, to program
@table @asis
@item @emph{Description}:
-Retrieve the @var{N}th argument that was passed on the
+Retrieve the @var{POS}-th argument that was passed on the
command line when the containing program was invoked.
This intrinsic routine is provided for backwards compatibility with
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
@node GET_COMMAND
@section @code{GET_COMMAND} --- Get the entire command line
-@cindex @code{GET_COMMAND} intrinsic
-@cindex command-line arguments, to program
+@fnindex GET_COMMAND
+@cindex command-line arguments
+@cindex arguments, to program
@table @asis
@item @emph{Description}:
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
@node GET_COMMAND_ARGUMENT
@section @code{GET_COMMAND_ARGUMENT} --- Get command line arguments
-@cindex @code{GET_COMMAND_ARGUMENT} intrinsic
-@cindex command-line arguments, to program
+@fnindex GET_COMMAND_ARGUMENT
+@cindex command-line arguments
+@cindex arguments, to program
@table @asis
@item @emph{Description}:
-Retrieve the @var{N}th argument that was passed on the
+Retrieve the @var{NUMBER}-th argument that was passed on the
command line when the containing program was invoked.
@item @emph{Standard}:
-F2003
+Fortran 2003 and later
@item @emph{Class}:
Subroutine
@item @emph{Syntax}:
-@code{CALL GET_COMMAND_ARGUMENT(N, ARG)}
+@code{CALL GET_COMMAND_ARGUMENT(NUMBER [, VALUE, LENGTH, STATUS])}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{N} @tab Shall be of type @code{INTEGER(4)}, @math{@var{N} \geq 0}
-@item @var{ARG} @tab Shall be of type @code{CHARACTER(*)}.
+@item @var{NUMBER} @tab Shall be a scalar of type @code{INTEGER} and of
+default kind, @math{@var{NUMBER} \geq 0}
+@item @var{VALUE} @tab (Optional) Shall be a scalar of type @code{CHARACTER}
+and of default kind.
+@item @var{LENGTH} @tab (Optional) Shall be a scalar of type @code{INTEGER}
+and of default kind.
+@item @var{STATUS} @tab (Optional) 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
@node GETCWD
@section @code{GETCWD} --- Get current working directory
-@cindex @code{GETCWD} intrinsic
-@cindex file system operations
+@fnindex GETCWD
+@cindex system, working directory
@table @asis
@item @emph{Description}:
Get current working directory.
+This intrinsic is provided in both subroutine and function forms; however,
+only one form can be used in any given program unit.
+
@item @emph{Standard}:
GNU extension
@item @emph{Class}:
-Non-elemental subroutine.
+Subroutine, function
@item @emph{Syntax}:
-@code{CALL GETCWD(CWD [, STATUS])}
+@multitable @columnfractions .80
+@item @code{CALL GETCWD(C [, STATUS])}
+@item @code{STATUS = GETCWD(C)}
+@end multitable
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{CWD} @tab The type shall be @code{CHARACTER(*)}.
+@item @var{C} @tab The type shall be @code{CHARACTER} and of default kind.
@item @var{STATUS} @tab (Optional) status flag. Returns 0 on success,
- a system specific and non-zero error code otherwise.
+a system specific and nonzero error code otherwise.
@end multitable
@item @emph{Example}:
@node GETENV
@section @code{GETENV} --- Get an environmental variable
-@cindex @code{GETENV} intrinsic
+@fnindex GETENV
@cindex environment variable
@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}:
@node GET_ENVIRONMENT_VARIABLE
@section @code{GET_ENVIRONMENT_VARIABLE} --- Get an environmental variable
-@cindex @code{GET_ENVIRONMENT_VARIABLE} intrinsic
+@fnindex GET_ENVIRONMENT_VARIABLE
@cindex environment variable
@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 (Optional) Shall be a scalar of type @code{CHARACTER}
+and of default kind.
+@item @var{LENGTH} @tab (Optional) Shall be a scalar of type @code{INTEGER}
+and of default kind.
+@item @var{STATUS} @tab (Optional) Shall be a scalar of type @code{INTEGER}
+and of default kind.
+@item @var{TRIM_NAME} @tab (Optional) 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
@node GETGID
@section @code{GETGID} --- Group ID function
-@cindex @code{GETGID} intrinsic
-@cindex file system operations
+@fnindex GETGID
+@cindex system, group ID
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-function
+Function
@item @emph{Syntax}:
@code{RESULT = GETGID()}
@node GETLOG
@section @code{GETLOG} --- Get login name
-@cindex @code{GETLOG} intrinsic
+@fnindex GETLOG
+@cindex system, login name
+@cindex login name
@table @asis
@item @emph{Description}:
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}:
@node GETPID
@section @code{GETPID} --- Process ID function
-@cindex @code{GETPID} intrinsic
-@cindex process ID, current
+@fnindex GETPID
+@cindex system, process ID
+@cindex process ID
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-function
+Function
@item @emph{Syntax}:
@code{RESULT = GETPID()}
@node GETUID
@section @code{GETUID} --- User ID function
-@cindex @code{GETUID} intrinsic
-@cindex user ID, current
+@fnindex GETUID
+@cindex system, user ID
+@cindex user id
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-function
+Function
@item @emph{Syntax}:
@code{RESULT = GETUID()}
@node GMTIME
@section @code{GMTIME} --- Convert time to GMT info
-@cindex @code{GMTIME} intrinsic
-@cindex time, conversion function
+@fnindex GMTIME
+@cindex time, conversion to GMT info
@table @asis
@item @emph{Description}:
-Given a system time value @var{STIME} (as provided by the @code{TIME8()}
-intrinsic), fills @var{TARRAY} with values extracted from it appropriate
+Given a system time value @var{TIME} (as provided by the @code{TIME8()}
+intrinsic), fills @var{VALUES} with values extracted from it appropriate
to the 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}:
@node HOSTNM
@section @code{HOSTNM} --- Get system host name
-@cindex @code{HOSTNM} intrinsic
+@fnindex HOSTNM
+@cindex system, host name
@table @asis
@item @emph{Description}:
@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}:
@node HUGE
@section @code{HUGE} --- Largest number of a kind
-@cindex @code{HUGE} intrinsic
-@cindex huge
+@fnindex HUGE
+@cindex limits, largest number
+@cindex model representation, largest number
@table @asis
@item @emph{Description}:
the model of the type of @code{X}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
-Elemental function
+Inquiry function
@item @emph{Syntax}:
@code{RESULT = HUGE(X)}
+@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
-@cindex @code{IACHAR} intrinsic
+@fnindex IACHAR
@cindex @acronym{ASCII} collating sequence
-@cindex conversion function (character)
+@cindex collating sequence, @acronym{ASCII}
+@cindex conversion, to integer
@table @asis
@item @emph{Description}:
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
+@node IALL
+@section @code{IALL} --- Bitwise AND of array elements
+@fnindex IALL
+@cindex array, AND
+@cindex bits, AND of array elements
+
+@table @asis
+@item @emph{Description}:
+Reduces with bitwise AND the elements of @var{ARRAY} along dimension @var{DIM}
+if the corresponding element in @var{MASK} is @code{TRUE}.
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@multitable @columnfractions .80
+@item @code{RESULT = IALL(ARRAY[, MASK])}
+@item @code{RESULT = IALL(ARRAY, DIM[, MASK])}
+@end multitable
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{ARRAY} @tab Shall be an array of type @code{INTEGER}
+@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}.
+@item @var{MASK} @tab (Optional) shall be of type @code{LOGICAL}
+and either be a scalar or an array of the same shape as @var{ARRAY}.
+@end multitable
+
+@item @emph{Return value}:
+The result is of the same type as @var{ARRAY}.
+
+If @var{DIM} is absent, a scalar with the bitwise ALL of all elements in
+@var{ARRAY} is returned. Otherwise, an array of rank n-1, where n equals
+the rank of @var{ARRAY}, and a shape similar to that of @var{ARRAY} with
+dimension @var{DIM} dropped is returned.
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_iall
+ INTEGER(1) :: a(2)
+
+ a(1) = b'00100100'
+ a(2) = b'01101010'
+
+ ! prints 00100000
+ PRINT '(b8.8)', IALL(a)
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+@ref{IANY}, @ref{IPARITY}, @ref{IAND}
+@end table
+
+
+
@node IAND
@section @code{IAND} --- Bitwise logical and
-@cindex @code{IAND} intrinsic
-@cindex bit operations
+@fnindex IAND
+@cindex bitwise logical and
+@cindex logical and, bitwise
@table @asis
@item @emph{Description}:
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.)
+@node IANY
+@section @code{IANY} --- Bitwise OR of array elements
+@fnindex IANY
+@cindex array, OR
+@cindex bits, OR of array elements
+
+@table @asis
+@item @emph{Description}:
+Reduces with bitwise OR (inclusive or) the elements of @var{ARRAY} along
+dimension @var{DIM} if the corresponding element in @var{MASK} is @code{TRUE}.
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@multitable @columnfractions .80
+@item @code{RESULT = IANY(ARRAY[, MASK])}
+@item @code{RESULT = IANY(ARRAY, DIM[, MASK])}
+@end multitable
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{ARRAY} @tab Shall be an array of type @code{INTEGER}
+@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}.
+@item @var{MASK} @tab (Optional) shall be of type @code{LOGICAL}
+and either be a scalar or an array of the same shape as @var{ARRAY}.
+@end multitable
+
+@item @emph{Return value}:
+The result is of the same type as @var{ARRAY}.
+
+If @var{DIM} is absent, a scalar with the bitwise OR of all elements in
+@var{ARRAY} is returned. Otherwise, an array of rank n-1, where n equals
+the rank of @var{ARRAY}, and a shape similar to that of @var{ARRAY} with
+dimension @var{DIM} dropped is returned.
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_iany
+ INTEGER(1) :: a(2)
+
+ a(1) = b'00100100'
+ a(2) = b'01101010'
+
+ ! prints 01101110
+ PRINT '(b8.8)', IANY(a)
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+@ref{IPARITY}, @ref{IALL}, @ref{IOR}
+@end table
+
+
+
@node IARGC
@section @code{IARGC} --- Get the number of command line arguments
-@cindex @code{IARGC} intrinsic
-@cindex command-line arguments, to program
+@fnindex IARGC
+@cindex command-line arguments
+@cindex command-line arguments, number of
+@cindex arguments, to program
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-Non-elemental Function
+Function
@item @emph{Syntax}:
@code{RESULT = IARGC()}
@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
@node IBCLR
@section @code{IBCLR} --- Clear bit
-@cindex @code{IBCLR} intrinsic
-@cindex bit operations
+@fnindex IBCLR
+@cindex bits, unset
+@cindex bits, clear
@table @asis
@item @emph{Description}:
@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}:
@node IBITS
@section @code{IBITS} --- Bit extraction
-@cindex @code{IBITS} intrinsic
-@cindex bit operations
+@fnindex IBITS
+@cindex bits, get
+@cindex bits, extract
@table @asis
@item @emph{Description}:
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}:
@node IBSET
@section @code{IBSET} --- Set bit
-@cindex @code{IBSET} intrinsic
-@cindex bit operations
+@fnindex IBSET
+@cindex bits, set
@table @asis
@item @emph{Description}:
@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}:
@node ICHAR
@section @code{ICHAR} --- Character-to-integer conversion function
-@cindex @code{ICHAR} intrinsic
-@cindex conversion function (character)
+@fnindex ICHAR
+@cindex conversion, to integer
@table @asis
@item @emph{Description}:
the same across different GNU Fortran implementations.
@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 = 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
end program test_ichar
@end smallexample
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .25
+@item Name @tab Argument @tab Return type @tab Standard
+@item @code{ICHAR(C)} @tab @code{CHARACTER C} @tab @code{INTEGER(4)} @tab Fortran 77 and later
+@end multitable
+
@item @emph{Note}:
No intrinsic exists to convert between a numeric value and a formatted
character string representation -- for instance, given the
@node IDATE
@section @code{IDATE} --- Get current local time subroutine (day/month/year)
-@cindex @code{IDATE} intrinsic
+@fnindex IDATE
+@cindex date, current
+@cindex current date
@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
@node IEOR
@section @code{IEOR} --- Bitwise logical exclusive or
-@cindex @code{IEOR} intrinsic
-@cindex bit operations
+@fnindex IEOR
+@cindex bitwise logical exclusive or
+@cindex logical exclusive or, bitwise
@table @asis
@item @emph{Description}:
-@code{IEOR} returns the bitwise boolean exclusive-OR of @var{I} and
+@code{IEOR} returns the bitwise Boolean exclusive-OR of @var{I} and
@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 IERRNO
@section @code{IERRNO} --- Get the last system error number
-@cindex @code{IERRNO} intrinsic
+@fnindex IERRNO
+@cindex system, error handling
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-Elemental function
+Function
@item @emph{Syntax}:
@code{RESULT = IERRNO()}
-@node INDEX
+@node IMAGE_INDEX
+@section @code{IMAGE_INDEX} --- Function that converts a cosubscript to an image index
+@fnindex IMAGE_INDEX
+@cindex coarray, @code{IMAGE_INDEX}
+@cindex images, cosubscript to image index conversion
+
+@table @asis
+@item @emph{Description}:
+Returns the image index belonging to a cosubscript.
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Inquiry function.
+
+@item @emph{Syntax}:
+@code{RESULT = IMAGE_INDEX(COARRAY, SUB)}
+
+@item @emph{Arguments}: None.
+@multitable @columnfractions .15 .70
+@item @var{COARRAY} @tab Coarray of any type.
+@item @var{SUB} @tab default integer rank-1 array of a size equal to
+the corank of @var{COARRAY}.
+@end multitable
+
+
+@item @emph{Return value}:
+Scalar default integer with the value of the image index which corresponds
+to the cosubscripts. For invalid cosubscripts the result is zero.
+
+@item @emph{Example}:
+@smallexample
+INTEGER :: array[2,-1:4,8,*]
+! Writes 28 (or 0 if there are fewer than 28 images)
+WRITE (*,*) IMAGE_INDEX (array, [2,0,3,1])
+@end smallexample
+
+@item @emph{See also}:
+@ref{THIS_IMAGE}, @ref{NUM_IMAGES}
+@end table
+
+
+
+@node INDEX intrinsic
@section @code{INDEX} --- Position of a substring within a string
-@cindex @code{INDEX} intrinsic
+@fnindex INDEX
+@cindex substring position
+@cindex string, find substring
@table @asis
@item @emph{Description}:
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{Specific names}:
+@multitable @columnfractions .20 .20 .20 .25
+@item Name @tab Argument @tab Return type @tab Standard
+@item @code{INDEX(STRING, SUBSTRING)} @tab @code{CHARACTER} @tab @code{INTEGER(4)} @tab Fortran 77 and later
+@end multitable
@item @emph{See also}:
+@ref{SCAN}, @ref{VERIFY}
@end table
@node INT
@section @code{INT} --- Convert to integer type
-@cindex @code{INT} intrinsic
-@cindex @code{IFIX} intrinsic
-@cindex @code{IDINT} intrinsic
-@cindex conversion function (integer)
+@fnindex INT
+@fnindex IFIX
+@fnindex IDINT
+@cindex conversion, to integer
@table @asis
@item @emph{Description}:
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 Name @tab Argument @tab Return type @tab Standard
+@item @code{INT(A)} @tab @code{REAL(4) A} @tab @code{INTEGER} @tab Fortran 77 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
-@comment @item @emph{See also}:
@end table
-
@node INT2
@section @code{INT2} --- Convert to 16-bit integer type
-@cindex @code{INT2} intrinsic
-@cindex @code{SHORT} intrinsic
-@cindex conversion function (integer)
+@fnindex INT2
+@fnindex SHORT
+@cindex conversion, to integer
@table @asis
@item @emph{Description}:
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}:
The return value is a @code{INTEGER(2)} variable.
-@comment @item @emph{See also}:
+@item @emph{See also}:
@ref{INT}, @ref{INT8}, @ref{LONG}
@end table
@node INT8
@section @code{INT8} --- Convert to 64-bit integer type
-@cindex @code{INT8} intrinsic
-@cindex conversion function (integer)
+@fnindex INT8
+@cindex conversion, to integer
@table @asis
@item @emph{Description}:
@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}:
The return value is a @code{INTEGER(8)} variable.
-@comment @item @emph{See also}:
+@item @emph{See also}:
@ref{INT}, @ref{INT2}, @ref{LONG}
@end table
@node IOR
@section @code{IOR} --- Bitwise logical or
-@cindex @code{IOR} intrinsic
-@cindex bit operations
+@fnindex IOR
+@cindex bitwise logical or
+@cindex logical or, bitwise
@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.)
+@node IPARITY
+@section @code{IPARITY} --- Bitwise XOR of array elements
+@fnindex IPARITY
+@cindex array, parity
+@cindex array, XOR
+@cindex bits, XOR of array elements
+
+@table @asis
+@item @emph{Description}:
+Reduces with bitwise XOR (exclusive or) the elements of @var{ARRAY} along
+dimension @var{DIM} if the corresponding element in @var{MASK} is @code{TRUE}.
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@multitable @columnfractions .80
+@item @code{RESULT = IPARITY(ARRAY[, MASK])}
+@item @code{RESULT = IPARITY(ARRAY, DIM[, MASK])}
+@end multitable
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{ARRAY} @tab Shall be an array of type @code{INTEGER}
+@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}.
+@item @var{MASK} @tab (Optional) shall be of type @code{LOGICAL}
+and either be a scalar or an array of the same shape as @var{ARRAY}.
+@end multitable
+
+@item @emph{Return value}:
+The result is of the same type as @var{ARRAY}.
+
+If @var{DIM} is absent, a scalar with the bitwise XOR of all elements in
+@var{ARRAY} is returned. Otherwise, an array of rank n-1, where n equals
+the rank of @var{ARRAY}, and a shape similar to that of @var{ARRAY} with
+dimension @var{DIM} dropped is returned.
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_iparity
+ INTEGER(1) :: a(2)
+
+ a(1) = b'00100100'
+ a(2) = b'01101010'
+
+ ! prints 01001110
+ PRINT '(b8.8)', IPARITY(a)
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+@ref{IANY}, @ref{IALL}, @ref{IEOR}, @ref{PARITY}
+@end table
+
+
+
@node IRAND
@section @code{IRAND} --- Integer pseudo-random number
-@cindex @code{IRAND} intrinsic
-@cindex random numbers
+@fnindex IRAND
+@cindex random number generation
@table @asis
@item @emph{Description}:
is restarted by @code{CALL SRAND(0)}; if @var{FLAG} has any other value,
it is used as a new seed with @code{SRAND}.
+This intrinsic routine is provided for backwards compatibility with
+GNU Fortran 77. It implements a simple modulo generator as provided
+by @command{g77}. For new code, one should consider the use of
+@ref{RANDOM_NUMBER} as it implements a superior algorithm.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Function
+
+@item @emph{Syntax}:
+@code{RESULT = IRAND(I)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{I} @tab Shall be a scalar @code{INTEGER} of kind 4.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of @code{INTEGER(kind=4)} type.
+
+@item @emph{Example}:
+@smallexample
+program test_irand
+ integer,parameter :: seed = 86456
+
+ call srand(seed)
+ print *, irand(), irand(), irand(), irand()
+ print *, irand(seed), irand(), irand(), irand()
+end program test_irand
+@end smallexample
+
+@end table
+
+
+
+@node IS_IOSTAT_END
+@section @code{IS_IOSTAT_END} --- Test for end-of-file value
+@fnindex IS_IOSTAT_END
+@cindex @code{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
+@code{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 @code{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}:
-GNU extension
+Fortran 2003 and later
@item @emph{Class}:
-Non-elemental function
+Elemental function
@item @emph{Syntax}:
-@code{RESULT = IRAND(FLAG)}
+@code{RESULT = IS_IOSTAT_EOR(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 of the type @code{INTEGER}.
@end multitable
@item @emph{Return value}:
-The return value is of @code{INTEGER(kind=4)} type.
+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
+@code{IOSTAT=} specifiers, and is @code{.FALSE.} otherwise.
@item @emph{Example}:
@smallexample
-program test_irand
- integer,parameter :: seed = 86456
-
- call srand(seed)
- print *, irand(), irand(), irand(), irand()
- print *, irand(seed), irand(), irand(), irand()
-end program test_irand
+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.
-@cindex @code{ISATTY} intrinsic
+@fnindex ISATTY
+@cindex system, terminal
@table @asis
@item @emph{Description}:
Determine whether a unit is connected to a terminal device.
@item @emph{Standard}:
-GNU extension.
+GNU extension
@item @emph{Class}:
-Non-elemental function.
+Function
@item @emph{Syntax}:
@code{RESULT = ISATTY(UNIT)}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{UNIT} @tab Shall be a scalar @code{INTEGER(*)}.
+@item @var{UNIT} @tab Shall be a scalar @code{INTEGER}.
@end multitable
@item @emph{Return value}:
@node ISHFT
@section @code{ISHFT} --- Shift bits
-@cindex @code{ISHFT} intrinsic
-@cindex bit operations
+@fnindex ISHFT
+@cindex bits, shift
@table @asis
@item @emph{Description}:
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}:
@node ISHFTC
@section @code{ISHFTC} --- Shift bits circularly
-@cindex @code{ISHFTC} intrinsic
-@cindex bit operations
+@fnindex ISHFTC
+@cindex bits, shift circular
@table @asis
@item @emph{Description}:
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)
-@cindex @code{ITIME} intrinsic
+@fnindex ITIME
+@cindex time, current
+@cindex current time
@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}:
@node KILL
@section @code{KILL} --- Send a signal to a process
-@cindex @code{KILL} intrinsic
+@fnindex KILL
@table @asis
@item @emph{Description}:
Sends the signal specified by @var{SIGNAL} to the process @var{PID}.
See @code{kill(2)}.
+This intrinsic is provided in both subroutine and function forms; however,
+only one form can be used in any given program unit.
+
@item @emph{Class}:
-Subroutine
+Subroutine, function
@item @emph{Syntax}:
-@code{CALL KILL(PID, SIGNAL [, STATUS])}
+@multitable @columnfractions .80
+@item @code{CALL KILL(C, VALUE [, STATUS])}
+@item @code{STATUS = KILL(C, VALUE)}
+@end multitable
@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}:
@node KIND
@section @code{KIND} --- Kind of an entity
-@cindex @code{KIND} intrinsic
+@fnindex KIND
+@cindex kind
@table @asis
@item @emph{Description}:
@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
@node LBOUND
@section @code{LBOUND} --- Lower dimension bounds of an array
-@cindex @code{LBOUND} intrinsic
+@fnindex LBOUND
+@cindex array, lower bound
@table @asis
@item @emph{Description}:
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
dimension, the lower bound is taken to be 1.
@item @emph{See also}:
-@ref{UBOUND}
+@ref{UBOUND}, @ref{LCOBOUND}
+@end table
+
+
+
+@node LCOBOUND
+@section @code{LCOBOUND} --- Lower codimension bounds of an array
+@fnindex LCOBOUND
+@cindex coarray, lower bound
+
+@table @asis
+@item @emph{Description}:
+Returns the lower bounds of a coarray, or a single lower cobound
+along the @var{DIM} codimension.
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@code{RESULT = LCOBOUND(COARRAY [, DIM [, KIND]])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{ARRAY} @tab Shall be an coarray, of any type.
+@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 cobounds of
+@var{COARRAY}. If @var{DIM} is present, the result is a scalar
+corresponding to the lower cobound of the array along that codimension.
+
+@item @emph{See also}:
+@ref{UCOBOUND}, @ref{LBOUND}
+@end table
+
+
+
+@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 (*,*) BIT_SIZE(1) ! prints 32
+ WRITE (*,*) LEADZ(1) ! prints 31
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+@ref{BIT_SIZE}, @ref{TRAILZ}, @ref{POPCNT}, @ref{POPPAR}
@end table
@node LEN
@section @code{LEN} --- Length of a character entity
-@cindex @code{LEN} intrinsic
+@fnindex LEN
+@cindex string, length
@table @asis
@item @emph{Description}:
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{Specific names}:
+@multitable @columnfractions .20 .20 .20 .25
+@item Name @tab Argument @tab Return type @tab Standard
+@item @code{LEN(STRING)} @tab @code{CHARACTER} @tab @code{INTEGER} @tab Fortran 77 and later
+@end multitable
+
@item @emph{See also}:
@ref{LEN_TRIM}, @ref{ADJUSTL}, @ref{ADJUSTR}
@node LEN_TRIM
@section @code{LEN_TRIM} --- Length of a character entity without trailing blank characters
-@cindex @code{LEN_TRIM} intrinsic
+@fnindex LEN_TRIM
+@cindex string, length, without trailing whitespace
@table @asis
@item @emph{Description}:
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}
@node LGE
@section @code{LGE} --- Lexical greater than or equal
-@cindex @code{LGE} intrinsic
-@cindex comparison (lexical)
-@cindex lexical comparison
+@fnindex LGE
+@cindex lexical comparison of strings
+@cindex string, comparison
@table @asis
@item @emph{Description}:
ordering.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later
@item @emph{Class}:
Elemental function
Returns @code{.TRUE.} if @code{STRING_A >= STRING_B}, and @code{.FALSE.}
otherwise, based on the ASCII ordering.
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .25
+@item Name @tab Argument @tab Return type @tab Standard
+@item @code{LGE(STRING_A, STRING_B)} @tab @code{CHARACTER} @tab @code{LOGICAL} @tab Fortran 77 and later
+@end multitable
+
@item @emph{See also}:
@ref{LGT}, @ref{LLE}, @ref{LLT}
@end table
@node LGT
@section @code{LGT} --- Lexical greater than
-@cindex @code{LGT} intrinsic
-@cindex comparison (lexical)
-@cindex lexical comparison
+@fnindex LGT
+@cindex lexical comparison of strings
+@cindex string, comparison
@table @asis
@item @emph{Description}:
ordering.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later
@item @emph{Class}:
Elemental function
Returns @code{.TRUE.} if @code{STRING_A > STRING_B}, and @code{.FALSE.}
otherwise, based on the ASCII ordering.
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .25
+@item Name @tab Argument @tab Return type @tab Standard
+@item @code{LGT(STRING_A, STRING_B)} @tab @code{CHARACTER} @tab @code{LOGICAL} @tab Fortran 77 and later
+@end multitable
+
@item @emph{See also}:
@ref{LGE}, @ref{LLE}, @ref{LLT}
@end table
@node LINK
@section @code{LINK} --- Create a hard link
-@cindex @code{LINK} intrinsic
-@cindex file system operations
+@fnindex LINK
+@cindex file system, create link
+@cindex file system, hard link
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-Subroutine, non-elemental function
+Subroutine, function
@item @emph{Syntax}:
@multitable @columnfractions .80
@node LLE
@section @code{LLE} --- Lexical less than or equal
-@cindex @code{LLE} intrinsic
-@cindex comparison (lexical)
-@cindex lexical comparison
+@fnindex LLE
+@cindex lexical comparison of strings
+@cindex string, comparison
@table @asis
@item @emph{Description}:
ordering.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later
@item @emph{Class}:
Elemental function
Returns @code{.TRUE.} if @code{STRING_A <= STRING_B}, and @code{.FALSE.}
otherwise, based on the ASCII ordering.
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .25
+@item Name @tab Argument @tab Return type @tab Standard
+@item @code{LLE(STRING_A, STRING_B)} @tab @code{CHARACTER} @tab @code{LOGICAL} @tab Fortran 77 and later
+@end multitable
+
@item @emph{See also}:
@ref{LGE}, @ref{LGT}, @ref{LLT}
@end table
@node LLT
@section @code{LLT} --- Lexical less than
-@cindex @code{LLT} intrinsic
-@cindex comparison (lexical)
-@cindex lexical comparison
+@fnindex LLT
+@cindex lexical comparison of strings
+@cindex string, comparison
@table @asis
@item @emph{Description}:
ordering.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later
@item @emph{Class}:
Elemental function
Returns @code{.TRUE.} if @code{STRING_A < STRING_B}, and @code{.FALSE.}
otherwise, based on the ASCII ordering.
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .25
+@item Name @tab Argument @tab Return type @tab Standard
+@item @code{LLT(STRING_A, STRING_B)} @tab @code{CHARACTER} @tab @code{LOGICAL} @tab Fortran 77 and later
+@end multitable
+
@item @emph{See also}:
@ref{LGE}, @ref{LGT}, @ref{LLE}
@end table
@node LNBLNK
@section @code{LNBLNK} --- Index of the last non-blank character in a string
-@cindex @code{LNBLNK} intrinsic
+@fnindex LNBLNK
+@cindex string, find non-blank character
@table @asis
@item @emph{Description}:
@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
@node LOC
@section @code{LOC} --- Returns the address of a variable
-@cindex @code{LOC} intrinsic
+@fnindex LOC
@cindex location of a variable in memory
@table @asis
@node LOG
@section @code{LOG} --- Logarithm function
-@cindex @code{LOG} intrinsic
-@cindex @code{ALOG} intrinsic
-@cindex @code{DLOG} intrinsic
-@cindex @code{CLOG} intrinsic
-@cindex @code{ZLOG} intrinsic
-@cindex @code{CDLOG} intrinsic
-@cindex logarithm
+@fnindex LOG
+@fnindex ALOG
+@fnindex DLOG
+@fnindex CLOG
+@fnindex ZLOG
+@fnindex CDLOG
+@cindex exponential function, inverse
+@cindex logarithmic function
@table @asis
@item @emph{Description}:
@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
@node LOG10
@section @code{LOG10} --- Base 10 logarithm function
-@cindex @code{LOG10} intrinsic
-@cindex @code{ALOG10} intrinsic
-@cindex @code{DLOG10} intrinsic
-@cindex logarithm
+@fnindex LOG10
+@fnindex ALOG10
+@fnindex DLOG10
+@cindex exponential function, inverse
+@cindex logarithmic function
@table @asis
@item @emph{Description}:
@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(*)} or
-@code{COMPLEX(*)}.
+@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
-@cindex @code{LOGICAL} intrinsic
-@cindex conversion function (logical)
+@fnindex LOGICAL
+@cindex conversion, to logical
@table @asis
@item @emph{Description}:
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}:
@node LONG
@section @code{LONG} --- Convert to integer type
-@cindex @code{LONG} intrinsic
-@cindex conversion function (integer)
+@fnindex LONG
+@cindex conversion, to integer
@table @asis
@item @emph{Description}:
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}:
The return value is a @code{INTEGER(4)} variable.
-@comment @item @emph{See also}:
+@item @emph{See also}:
@ref{INT}, @ref{INT2}, @ref{INT8}
@end table
@node LSHIFT
@section @code{LSHIFT} --- Left shift bits
-@cindex @code{LSHIFT} intrinsic
-@cindex bit operations
+@fnindex LSHIFT
+@cindex bits, shift left
@table @asis
@item @emph{Description}:
the opposite end.
This function has been superseded by the @code{ISHFT} intrinsic, which
-is standard in Fortran 95 and later.
+is standard in Fortran 95 and later, and the @code{SHIFTL} intrinsic,
+which is standard in Fortran 2008 and later.
@item @emph{Standard}:
GNU extension
@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}:
-@ref{ISHFT}, @ref{ISHFTC}, @ref{RSHIFT}
+@ref{ISHFT}, @ref{ISHFTC}, @ref{RSHIFT}, @ref{SHIFTA}, @ref{SHIFTL},
+@ref{SHIFTR}
@end table
@node LSTAT
@section @code{LSTAT} --- Get file status
-@cindex @code{LSTAT} intrinsic
-@cindex file system operations
+@fnindex LSTAT
+@cindex file system, file status
@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.
@item @emph{Standard}:
GNU extension
@item @emph{Class}:
-Non-elemental subroutine
+Subroutine, function
@item @emph{Syntax}:
-@code{CALL LSTAT(FILE, BUFF [, STATUS])}
+@multitable @columnfractions .80
+@item @code{CALL LSTAT(NAME, VALUES [, STATUS])}
+@item @code{STATUS = LSTAT(NAME, VALUES)}
+@end multitable
@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}:
@node LTIME
@section @code{LTIME} --- Convert time to local time info
-@cindex @code{LTIME} intrinsic
-@cindex time, conversion function
+@fnindex LTIME
+@cindex time, conversion to local time info
@table @asis
@item @emph{Description}:
-Given a system time value @var{STIME} (as provided by the @code{TIME8()}
-intrinsic), fills @var{TARRAY} with values extracted from it appropriate
+Given a system time value @var{TIME} (as provided by the @code{TIME8()}
+intrinsic), fills @var{VALUES} with values extracted from it appropriate
to the local time zone using @code{localtime(3)}.
@item @emph{Standard}:
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}:
@node MALLOC
@section @code{MALLOC} --- Allocate dynamic memory
-@cindex @code{MALLOC} intrinsic
-@cindex Cray pointers
+@fnindex MALLOC
+@cindex pointer, cray
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-Non-elemental function
+Function
@item @emph{Syntax}:
@code{PTR = MALLOC(SIZE)}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{SIZE} @tab The type shall be @code{INTEGER(*)}.
+@item @var{SIZE} @tab The type shall be @code{INTEGER}.
@end multitable
@item @emph{Return value}:
@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)
+@node MASKL
+@section @code{MASKL} --- Left justified mask
+@fnindex MASKL
+@cindex mask, left justified
+
+@table @asis
+@item @emph{Description}:
+@code{MASKL(I[, KIND])} has its leftmost @var{I} bits set to 1, and the
+remaining bits set to 0.
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = MASKL(I[, KIND])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{I} @tab Shall be of type @code{INTEGER}.
+@item @var{KIND} @tab Shall be a scalar constant expression of type
+@code{INTEGER}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{INTEGER}. If @var{KIND} is present, it
+specifies the kind value of the return type; otherwise, it is of the
+default integer kind.
+
+@item @emph{See also}:
+@ref{MASKR}
+@end table
+
+
+
+@node MASKR
+@section @code{MASKR} --- Right justified mask
+@fnindex MASKR
+@cindex mask, right justified
+
+@table @asis
+@item @emph{Description}:
+@code{MASKL(I[, KIND])} has its rightmost @var{I} bits set to 1, and the
+remaining bits set to 0.
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = MASKR(I[, KIND])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{I} @tab Shall be of type @code{INTEGER}.
+@item @var{KIND} @tab Shall be a scalar constant expression of type
+@code{INTEGER}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{INTEGER}. If @var{KIND} is present, it
+specifies the kind value of the return type; otherwise, it is of the
+default integer kind.
+
+@item @emph{See also}:
+@ref{MASKL}
+@end table
+
+
+
@node MATMUL
@section @code{MATMUL} --- matrix multiplication
-@cindex @code{MATMUL} intrinsic
-@cindex matrix operations
+@fnindex MATMUL
+@cindex matrix multiplication
+@cindex product, matrix
@table @asis
@item @emph{Description}:
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}:
@node MAX
@section @code{MAX} --- Maximum value of an argument list
-@cindex @code{MAX} intrinsic
-@cindex @code{MAX0} intrinsic
-@cindex @code{AMAX0} intrinsic
-@cindex @code{MAX1} intrinsic
-@cindex @code{AMAX1} intrinsic
-@cindex @code{DMAX1} intrinsic
+@fnindex MAX
+@fnindex MAX0
+@fnindex AMAX0
+@fnindex MAX1
+@fnindex AMAX1
+@fnindex DMAX1
+@cindex maximum value
@table @asis
@item @emph{Description}:
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 Name @tab Argument @tab Return type @tab Standard
+@item @code{MAX0(A1)} @tab @code{INTEGER(4) A1} @tab @code{INTEGER(4)} @tab Fortran 77 and later
+@item @code{AMAX0(A1)} @tab @code{INTEGER(4) A1} @tab @code{REAL(MAX(X))} @tab Fortran 77 and later
+@item @code{MAX1(A1)} @tab @code{REAL A1} @tab @code{INT(MAX(X))} @tab Fortran 77 and later
+@item @code{AMAX1(A1)} @tab @code{REAL(4) A1} @tab @code{REAL(4)} @tab Fortran 77 and later
+@item @code{DMAX1(A1)} @tab @code{REAL(8) A1} @tab @code{REAL(8)} @tab Fortran 77 and later
@end multitable
@item @emph{See also}:
@node MAXEXPONENT
@section @code{MAXEXPONENT} --- Maximum exponent of a real kind
-@cindex @code{MAXEXPONENT} intrinsic
-@cindex maximum exponent
-@cindex exponent, maximum
+@fnindex MAXEXPONENT
+@cindex model representation, maximum exponent
@table @asis
@item @emph{Description}:
type of @code{X}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Inquiry function
@node MAXLOC
@section @code{MAXLOC} --- Location of the maximum value within an array
-@cindex @code{MAXLOC} intrinsic
+@fnindex MAXLOC
+@cindex array, location of maximum element
@table @asis
@item @emph{Description}:
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} or
+@code{REAL}.
@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}:
@node MAXVAL
@section @code{MAXVAL} --- Maximum value of an array
-@cindex @code{MAXVAL} intrinsic
+@fnindex MAXVAL
+@cindex array, maximum value
+@cindex maximum value
@table @asis
@item @emph{Description}:
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} or
+@code{REAL}.
@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}:
@node MCLOCK
@section @code{MCLOCK} --- Time function
-@cindex @code{MCLOCK} intrinsic
+@fnindex MCLOCK
@cindex time, clock ticks
@cindex clock ticks
GNU extension
@item @emph{Class}:
-Non-elemental function
+Function
@item @emph{Syntax}:
@code{RESULT = MCLOCK()}
@node MCLOCK8
@section @code{MCLOCK8} --- Time function (64-bit)
-@cindex @code{MCLOCK8} intrinsic
-@cindex time, current
-@cindex current time
+@fnindex MCLOCK8
+@cindex time, clock ticks
+@cindex clock ticks
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-Non-elemental function
+Function
@item @emph{Syntax}:
@code{RESULT = MCLOCK8()}
@item @emph{Return value}:
-The return value is a scalar of type @code{INTEGER(8)}, equal to the
-number of clock ticks since the start of the process, or @code{-1} if
-the system does not support @code{clock(3)}.
-
-@item @emph{See also}:
-@ref{CTIME}, @ref{GMTIME}, @ref{LTIME}, @ref{MCLOCK}, @ref{TIME8}
+The return value is a scalar of type @code{INTEGER(8)}, equal to the
+number of clock ticks since the start of the process, or @code{-1} if
+the system does not support @code{clock(3)}.
+
+@item @emph{See also}:
+@ref{CTIME}, @ref{GMTIME}, @ref{LTIME}, @ref{MCLOCK}, @ref{TIME8}
+
+@end table
+
+
+
+@node MERGE
+@section @code{MERGE} --- Merge variables
+@fnindex MERGE
+@cindex array, merge arrays
+@cindex array, combine arrays
+
+@table @asis
+@item @emph{Description}:
+Select values from two arrays according to a logical mask. The result
+is equal to @var{TSOURCE} if @var{MASK} is @code{.TRUE.}, or equal to
+@var{FSOURCE} if it is @code{.FALSE.}.
+
+@item @emph{Standard}:
+Fortran 95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = MERGE(TSOURCE, FSOURCE, MASK)}
+
+@item @emph{Arguments}:
+@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}.
+@end multitable
+
+@item @emph{Return value}:
+The result is of the same type and type parameters as @var{TSOURCE}.
@end table
-@node MERGE
-@section @code{MERGE} --- Merge variables
-@cindex @code{MERGE} intrinsic
+@node MERGE_BITS
+@section @code{MERGE_BITS} --- Merge of bits under mask
+@fnindex MERGE_BITS
+@cindex bits, merge
@table @asis
@item @emph{Description}:
-Select values from two arrays according to a logical mask. The result
-is equal to @var{TSOURCE} if @var{MASK} is @code{.TRUE.}, or equal to
-@var{FSOURCE} if it is @code{.FALSE.}.
+@code{MERGE_BITS(I, J, MASK)} merges the bits of @var{I} and @var{J}
+as determined by the mask. The i-th bit of the result is equal to the
+i-th bit of @var{I} if the i-th bit of @var{MASK} is 1; it is equal to
+the i-th bit of @var{J} otherwise.
@item @emph{Standard}:
-F95 and later
+Fortran 2008 and later
@item @emph{Class}:
Elemental function
@item @emph{Syntax}:
-@code{RESULT = MERGE(TSOURCE, FSOURCE, MASK)}
+@code{RESULT = MERGE_BITS(I, J, MASK)}
@item @emph{Arguments}:
@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(*)}.
+@item @var{I} @tab Shall be of type @code{INTEGER}.
+@item @var{J} @tab Shall be of type @code{INTEGER} and of the same
+kind as @var{I}.
+@item @var{MASK} @tab Shall be of type @code{INTEGER} and of the same
+kind as @var{I}.
@end multitable
@item @emph{Return value}:
-The result is of the same type and type parameters as @var{TSOURCE}.
+The result is of the same type and kind as @var{I}.
@end table
@node MIN
@section @code{MIN} --- Minimum value of an argument list
-@cindex @code{MIN} intrinsic
-@cindex @code{MIN0} intrinsic
-@cindex @code{AMIN0} intrinsic
-@cindex @code{MIN1} intrinsic
-@cindex @code{AMIN1} intrinsic
-@cindex @code{DMIN1} intrinsic
+@fnindex MIN
+@fnindex MIN0
+@fnindex AMIN0
+@fnindex MIN1
+@fnindex AMIN1
+@fnindex DMIN1
+@cindex minimum value
@table @asis
@item @emph{Description}:
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 Name @tab Argument @tab Return type @tab Standard
+@item @code{MIN0(A1)} @tab @code{INTEGER(4) A1} @tab @code{INTEGER(4)} @tab Fortran 77 and later
+@item @code{AMIN0(A1)} @tab @code{INTEGER(4) A1} @tab @code{REAL(4)} @tab Fortran 77 and later
+@item @code{MIN1(A1)} @tab @code{REAL A1} @tab @code{INTEGER(4)} @tab Fortran 77 and later
+@item @code{AMIN1(A1)} @tab @code{REAL(4) A1} @tab @code{REAL(4)} @tab Fortran 77 and later
+@item @code{DMIN1(A1)} @tab @code{REAL(8) A1} @tab @code{REAL(8)} @tab Fortran 77 and later
@end multitable
@item @emph{See also}:
@node MINEXPONENT
@section @code{MINEXPONENT} --- Minimum exponent of a real kind
-@cindex @code{MINEXPONENT} intrinsic
-@cindex minimum exponent
-@cindex exponent, minimum
+@fnindex MINEXPONENT
+@cindex model representation, minimum exponent
@table @asis
@item @emph{Description}:
type of @code{X}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Inquiry function
@node MINLOC
@section @code{MINLOC} --- Location of the minimum value within an array
-@cindex @code{MINLOC} intrinsic
+@fnindex MINLOC
+@cindex array, location of minimum element
@table @asis
@item @emph{Description}:
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} or
+@code{REAL}.
@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}:
@node MINVAL
@section @code{MINVAL} --- Minimum value of an array
-@cindex @code{MINVAL} intrinsic
+@fnindex MINVAL
+@cindex array, minimum value
+@cindex minimum value
@table @asis
@item @emph{Description}:
@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} or
+@code{REAL}.
@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}:
@node MOD
@section @code{MOD} --- Remainder function
-@cindex @code{MOD} intrinsic
-@cindex @code{AMOD} intrinsic
-@cindex @code{DMOD} intrinsic
+@fnindex MOD
+@fnindex AMOD
+@fnindex DMOD
@cindex remainder
+@cindex division, remainder
@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 Name @tab Arguments @tab Return type @tab Standard
+@item @code{MOD(A,P)} @tab @code{INTEGER A,P} @tab @code{INTEGER} @tab Fortran 95 and later
+@item @code{AMOD(A,P)} @tab @code{REAL(4) A,P} @tab @code{REAL(4)} @tab Fortran 95 and later
+@item @code{DMOD(A,P)} @tab @code{REAL(8) A,P} @tab @code{REAL(8)} @tab Fortran 95 and later
@end multitable
@end table
@node MODULO
@section @code{MODULO} --- Modulo function
-@cindex @code{MODULO} intrinsic
+@fnindex MODULO
@cindex modulo
+@cindex division, modulo
@table @asis
@item @emph{Description}:
@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
print *, modulo(17,-3)
print *, modulo(17.5,-5.5)
-end program test_mod
+end program
@end smallexample
@end table
@node MOVE_ALLOC
@section @code{MOVE_ALLOC} --- Move allocation from one object to another
-@cindex @code{MOVE_ALLOC} intrinsic
+@fnindex MOVE_ALLOC
@cindex moving allocation
@cindex allocation, moving
@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
+Pure 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}:
@node MVBITS
@section @code{MVBITS} --- Move bits from one integer to another
-@cindex @code{MVBITS} intrinsic
-@cindex bit operations
+@fnindex MVBITS
+@cindex bits, move
@table @asis
@item @emph{Description}:
@code{BIT_SIZE(FROM)}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
-Elemental function
+Elemental subroutine
@item @emph{Syntax}:
-@code{RESULT = MVBITS(FROM, FROMPOS, LEN, TO, TOPOS)}
+@code{CALL MVBITS(FROM, FROMPOS, LEN, TO, TOPOS)}
@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{Return value}:
-The return value is of type @code{INTEGER(*)} and of the same kind as
-@var{FROM}.
-
@item @emph{See also}:
@ref{IBCLR}, @ref{IBSET}, @ref{IBITS}, @ref{IAND}, @ref{IOR}, @ref{IEOR}
-
@end table
@node NEAREST
@section @code{NEAREST} --- Nearest representable number
-@cindex @code{NEAREST} intrinsic
-@cindex processor-representable number
+@fnindex NEAREST
+@cindex real number, nearest different
+@cindex floating point, nearest different
@table @asis
@item @emph{Description}:
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
@node NEW_LINE
@section @code{NEW_LINE} --- New line character
-@cindex @code{NEW_LINE} intrinsic
-@cindex @code{NEW_LINE} intrinsic
+@fnindex NEW_LINE
+@cindex newline
+@cindex output, newline
@table @asis
@item @emph{Description}:
@code{NEW_LINE(C)} returns the new-line character.
@item @emph{Standard}:
-F2003 and later
+Fortran 2003 and later
@item @emph{Class}:
-Elemental function
+Inquiry function
@item @emph{Syntax}:
@code{RESULT = NEW_LINE(C)}
@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}:
@node NINT
@section @code{NINT} --- Nearest whole number
-@cindex @code{NINT} intrinsic
-@cindex @code{IDNINT} intrinsic
-@cindex whole number
+@fnindex NINT
+@fnindex IDNINT
+@cindex rounding, nearest whole number
@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}:
@end smallexample
@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
+@multitable @columnfractions .20 .20 .20 .25
+@item Name @tab Argument @tab Return Type @tab Standard
+@item @code{NINT(A)} @tab @code{REAL(4) A} @tab @code{INTEGER} @tab Fortran 95 and later
+@item @code{IDNINT(A)} @tab @code{REAL(8) A} @tab @code{INTEGER} @tab Fortran 95 and later
@end multitable
@item @emph{See also}:
+@node NORM2
+@section @code{NORM2} --- Euclidean vector norms
+@fnindex NORM2
+@cindex Euclidean vector norm
+@cindex L2 vector norm
+@cindex norm, Euclidean
+
+@table @asis
+@item @emph{Description}:
+Calculates the Euclidean vector norm (@math{L_2} norm) of
+of @var{ARRAY} along dimension @var{DIM}.
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@multitable @columnfractions .80
+@item @code{RESULT = NORM2(ARRAY[, DIM])}
+@end multitable
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{ARRAY} @tab Shall be an array of type @code{REAL}
+@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}.
+@end multitable
+
+@item @emph{Return value}:
+The result is of the same type as @var{ARRAY}.
+
+If @var{DIM} is absent, a scalar with the square root of the sum of all
+elements in @var{ARRAY} squared is returned. Otherwise, an array of
+rank @math{n-1}, where @math{n} equals the rank of @var{ARRAY}, and a
+shape similar to that of @var{ARRAY} with dimension @var{DIM} dropped
+is returned.
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_sum
+ REAL :: x(5) = [ real :: 1, 2, 3, 4, 5 ]
+ print *, NORM2(x) ! = sqrt(55.) ~ 7.416
+END PROGRAM
+@end smallexample
+@end table
+
+
+
@node NOT
@section @code{NOT} --- Logical negation
-@cindex @code{NOT} intrinsic
-@cindex bit operations
+@fnindex NOT
+@cindex bits, negate
+@cindex bitwise logical not
+@cindex logical not, bitwise
@table @asis
@item @emph{Description}:
-@code{NOT} returns the bitwise boolean inverse of @var{I}.
+@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}:
@node NULL
@section @code{NULL} --- Function that returns an disassociated pointer
-@cindex @code{NULL} intrinsic
-@cindex undocumented intrinsic
-
-Intrinsic implemented, documentation pending.
+@fnindex NULL
+@cindex pointer, status
+@cindex pointer, disassociated
@table @asis
@item @emph{Description}:
+Returns a disassociated pointer.
+
+If @var{MOLD} is present, a disassociated pointer of the same type is
+returned, otherwise the type is determined by context.
+
+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
@item @emph{Syntax}:
+@code{PTR => NULL([MOLD])}
+
@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{MOLD} @tab (Optional) shall be a pointer of any association
+status and of any type.
+@end multitable
+
@item @emph{Return value}:
+A disassociated pointer.
+
@item @emph{Example}:
+@smallexample
+REAL, POINTER, DIMENSION(:) :: VEC => NULL ()
+@end smallexample
+
@item @emph{See also}:
@ref{ASSOCIATED}
@end table
+@node NUM_IMAGES
+@section @code{NUM_IMAGES} --- Function that returns the number of images
+@fnindex NUM_IMAGES
+@cindex coarray, @code{NUM_IMAGES}
+@cindex images, number of
+
+@table @asis
+@item @emph{Description}:
+Returns the number of images.
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@code{RESULT = NUM_IMAGES()}
+
+@item @emph{Arguments}: None.
+
+@item @emph{Return value}:
+Scalar default-kind integer.
+
+@item @emph{Example}:
+@smallexample
+INTEGER :: value[*]
+INTEGER :: i
+value = THIS_IMAGE()
+SYNC ALL
+IF (THIS_IMAGE() == 1) THEN
+ DO i = 1, NUM_IMAGES()
+ WRITE(*,'(2(a,i0))') 'value[', i, '] is ', value[i]
+ END DO
+END IF
+@end smallexample
+
+@item @emph{See also}:
+@ref{THIS_IMAGE}, @ref{IMAGE_INDEX}
+@end table
+
+
+
@node OR
@section @code{OR} --- Bitwise logical OR
-@cindex @code{OR} intrinsic
-@cindex bit operations
+@fnindex OR
+@cindex bitwise logical or
+@cindex logical or, bitwise
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-Non-elemental function
+Function
@item @emph{Syntax}:
-@code{RESULT = OR(X, Y)}
+@code{RESULT = OR(I, J)}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{X} @tab The type shall be either @code{INTEGER(*)} or @code{LOGICAL}.
-@item @var{Y} @tab The type shall be either @code{INTEGER(*)} or @code{LOGICAL}.
+@item @var{I} @tab The type shall be either a scalar @code{INTEGER}
+type or a scalar @code{LOGICAL} type.
+@item @var{J} @tab The type shall be the same as the type of @var{J}.
@end multitable
@item @emph{Return value}:
-The return type is either @code{INTEGER(*)} or @code{LOGICAL}
-after cross-promotion of the arguments.
+The return type is either a scalar @code{INTEGER} or a scalar
+@code{LOGICAL}. If the kind type parameters differ, then the
+smaller kind type is implicitly converted to larger kind, and the
+return has the larger kind.
@item @emph{Example}:
@smallexample
PROGRAM test_or
- LOGICAL :: T = .TRUE., F = ..FALSE.
+ LOGICAL :: T = .TRUE., F = .FALSE.
INTEGER :: a, b
DATA a / Z'F' /, b / Z'3' /
@end smallexample
@item @emph{See also}:
-F95 elemental function: @ref{IOR}
+Fortran 95 elemental function: @ref{IOR}
@end table
@node PACK
@section @code{PACK} --- Pack an array into an array of rank one
-@cindex @code{PACK} intrinsic
-@cindex undocumented intrinsic
-
-Intrinsic implemented, documentation pending.
+@fnindex PACK
+@cindex array, packing
+@cindex array, reduce dimension
+@cindex array, gather elements
@table @asis
@item @emph{Description}:
+Stores the elements of @var{ARRAY} in an array of rank one.
+
+The beginning of the resulting array is made up of elements whose @var{MASK}
+equals @code{TRUE}. Afterwards, positions are filled with elements taken from
+@var{VECTOR}.
+
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Transformational function
@item @emph{Syntax}:
+@code{RESULT = PACK(ARRAY, MASK[,VECTOR]}
+
@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{ARRAY} @tab Shall be an array of any type.
+@item @var{MASK} @tab Shall be an array of type @code{LOGICAL} and
+of the same size as @var{ARRAY}. Alternatively, it may be a @code{LOGICAL}
+scalar.
+@item @var{VECTOR} @tab (Optional) shall be an array of the same type
+as @var{ARRAY} and of rank one. If present, the number of elements in
+@var{VECTOR} shall be equal to or greater than the number of true elements
+in @var{MASK}. If @var{MASK} is scalar, the number of elements in
+@var{VECTOR} shall be equal to or greater than the number of elements in
+@var{ARRAY}.
+@end multitable
+
@item @emph{Return value}:
+The result is an array of rank one and the same type as that of @var{ARRAY}.
+If @var{VECTOR} is present, the result size is that of @var{VECTOR}, the
+number of @code{TRUE} values in @var{MASK} otherwise.
+
@item @emph{Example}:
-@item @emph{Specific names}:
+Gathering nonzero elements from an array:
+@smallexample
+PROGRAM test_pack_1
+ INTEGER :: m(6)
+ m = (/ 1, 0, 0, 0, 5, 0 /)
+ WRITE(*, FMT="(6(I0, ' '))") pack(m, m /= 0) ! "1 5"
+END PROGRAM
+@end smallexample
+
+Gathering nonzero elements from an array and appending elements from @var{VECTOR}:
+@smallexample
+PROGRAM test_pack_2
+ INTEGER :: m(4)
+ m = (/ 1, 0, 0, 2 /)
+ WRITE(*, FMT="(4(I0, ' '))") pack(m, m /= 0, (/ 0, 0, 3, 4 /)) ! "1 2 3 4"
+END PROGRAM
+@end smallexample
+
@item @emph{See also}:
@ref{UNPACK}
@end table
+@node PARITY
+@section @code{PARITY} --- Reduction with exclusive OR
+@fnindex PARITY
+@cindex Parity
+@cindex Reduction, XOR
+@cindex XOR reduction
+
+@table @asis
+@item @emph{Description}:
+Calculates the parity, i.e. the reduction using @code{.XOR.},
+of @var{MASK} along dimension @var{DIM}.
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@multitable @columnfractions .80
+@item @code{RESULT = PARITY(MASK[, DIM])}
+@end multitable
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{LOGICAL} @tab Shall be an array of type @code{LOGICAL}
+@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{MASK}.
+@end multitable
+
+@item @emph{Return value}:
+The result is of the same type as @var{MASK}.
+
+If @var{DIM} is absent, a scalar with the parity of all elements in
+@var{MASK} is returned, i.e. true if an odd number of elements is
+@code{.true.} and false otherwise. If @var{DIM} is present, an array
+of rank @math{n-1}, where @math{n} equals the rank of @var{ARRAY},
+and a shape similar to that of @var{MASK} with dimension @var{DIM}
+dropped is returned.
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_sum
+ LOGICAL :: x(2) = [ .true., .false. ]
+ print *, PARITY(x) ! prints "T" (true).
+END PROGRAM
+@end smallexample
+@end table
+
+
+
@node PERROR
@section @code{PERROR} --- Print system error message
-@cindex @code{PERROR} intrinsic
+@fnindex PERROR
+@cindex system, error handling
@table @asis
@item @emph{Description}:
@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}:
@node PRECISION
@section @code{PRECISION} --- Decimal precision of a real kind
-@cindex @code{PRECISION} intrinsic
-@cindex precision of a real variable
+@fnindex PRECISION
+@cindex model representation, precision
@table @asis
@item @emph{Description}:
type of @code{X}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Inquiry function
The return value is of type @code{INTEGER} and of the default integer
kind.
+@item @emph{See also}:
+@ref{SELECTED_REAL_KIND}, @ref{RANGE}
+
@item @emph{Example}:
@smallexample
program prec_and_range
-@node PRESENT
-@section @code{PRESENT} --- Determine whether an optional argument is specified
-@cindex @code{PRESENT} intrinsic
-@cindex undocumented intrinsic
+@node POPCNT
+@section @code{POPCNT} --- Number of bits set
+@fnindex POPCNT
+@cindex binary representation
+@cindex bits set
+
+@table @asis
+@item @emph{Description}:
+@code{POPCNT(I)} returns the number of bits set ('1' bits) in the binary
+representation of @code{I}.
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = POPCNT(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 return value is of type @code{INTEGER} and of the default integer
+kind.
+
+@item @emph{See also}:
+@ref{POPPAR}, @ref{LEADZ}, @ref{TRAILZ}
+
+@item @emph{Example}:
+@smallexample
+program test_population
+ print *, popcnt(127), poppar(127)
+ print *, popcnt(huge(0_4)), poppar(huge(0_4))
+ print *, popcnt(huge(0_8)), poppar(huge(0_8))
+end program test_population
+@end smallexample
+@end table
+
+
+@node POPPAR
+@section @code{POPPAR} --- Parity of the number of bits set
+@fnindex POPPAR
+@cindex binary representation
+@cindex parity
+
+@table @asis
+@item @emph{Description}:
+@code{POPPAR(I)} returns parity of the integer @code{I}, i.e. the parity
+of the number of bits set ('1' bits) in the binary representation of
+@code{I}. It is equal to 0 if @code{I} has an even number of bits set,
+and 1 for an odd number of '1' bits.
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = POPPAR(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 return value is of type @code{INTEGER} and of the default integer
+kind.
+
+@item @emph{See also}:
+@ref{POPCNT}, @ref{LEADZ}, @ref{TRAILZ}
+
+@item @emph{Example}:
+@smallexample
+program test_population
+ print *, popcnt(127), poppar(127)
+ print *, popcnt(huge(0_4)), poppar(huge(0_4))
+ print *, popcnt(huge(0_8)), poppar(huge(0_8))
+end program test_population
+@end smallexample
+@end table
+
-Intrinsic implemented, documentation pending.
+
+@node PRESENT
+@section @code{PRESENT} --- Determine whether an optional dummy argument is specified
+@fnindex PRESENT
@table @asis
@item @emph{Description}:
+Determines whether an optional dummy argument is present.
+
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Inquiry function
@item @emph{Syntax}:
+@code{RESULT = PRESENT(A)}
+
@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{A} @tab May be of any type and may be a pointer, scalar or array
+value, or a dummy procedure. It shall be the name of an optional dummy argument
+accessible within the current subroutine or function.
+@end multitable
+
@item @emph{Return value}:
+Returns either @code{TRUE} if the optional argument @var{A} is present, or
+@code{FALSE} otherwise.
+
@item @emph{Example}:
-@item @emph{See also}:
+@smallexample
+PROGRAM test_present
+ WRITE(*,*) f(), f(42) ! "F T"
+CONTAINS
+ LOGICAL FUNCTION f(x)
+ INTEGER, INTENT(IN), OPTIONAL :: x
+ f = PRESENT(x)
+ END FUNCTION
+END PROGRAM
+@end smallexample
@end table
@node PRODUCT
@section @code{PRODUCT} --- Product of array elements
-@cindex @code{PRODUCT} intrinsic
-@cindex undocumented intrinsic
-
-Intrinsic implemented, documentation pending.
+@fnindex PRODUCT
+@cindex array, product
+@cindex array, multiply elements
+@cindex array, conditionally multiply elements
+@cindex multiply array elements
@table @asis
@item @emph{Description}:
+Multiplies the elements of @var{ARRAY} along dimension @var{DIM} if
+the corresponding element in @var{MASK} is @code{TRUE}.
+
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Transformational function
@item @emph{Syntax}:
+@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{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}.
+@item @var{MASK} @tab (Optional) shall be of type @code{LOGICAL}
+and either be a scalar or an array of the same shape as @var{ARRAY}.
+@end multitable
+
@item @emph{Return value}:
+The result is of the same type as @var{ARRAY}.
+
+If @var{DIM} is absent, a scalar with the product of all elements in
+@var{ARRAY} is returned. Otherwise, an array of rank n-1, where n equals
+the rank of @var{ARRAY}, and a shape similar to that of @var{ARRAY} with
+dimension @var{DIM} dropped is returned.
+
+
@item @emph{Example}:
-@item @emph{Specific names}:
+@smallexample
+PROGRAM test_product
+ INTEGER :: x(5) = (/ 1, 2, 3, 4 ,5 /)
+ print *, PRODUCT(x) ! all elements, product = 120
+ print *, PRODUCT(x, MASK=MOD(x, 2)==1) ! odd elements, product = 15
+END PROGRAM
+@end smallexample
+
@item @emph{See also}:
@ref{SUM}
@end table
@node RADIX
@section @code{RADIX} --- Base of a model number
-@cindex @code{RADIX} intrinsic
-@cindex base
+@fnindex RADIX
+@cindex model representation, base
+@cindex model representation, radix
@table @asis
@item @emph{Description}:
@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
The return value is a scalar of type @code{INTEGER} and of the default
integer kind.
+@item @emph{See also}:
+@ref{SELECTED_REAL_KIND}
+
@item @emph{Example}:
@smallexample
program test_radix
@node RAN
@section @code{RAN} --- Real pseudo-random number
-@cindex @code{RAN} intrinsic
-@cindex random numbers
+@fnindex RAN
+@cindex random number generation
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-Non-elemental function
+Function
@item @emph{See also}:
@ref{RAND}, @ref{RANDOM_NUMBER}
@node RAND
@section @code{RAND} --- Real pseudo-random number
-@cindex @code{RAND} intrinsic
-@cindex random numbers
+@fnindex RAND
+@cindex random number generation
@table @asis
@item @emph{Description}:
is restarted by @code{CALL SRAND(0)}; if @var{FLAG} has any other value,
it is used as a new seed with @code{SRAND}.
+This intrinsic routine is provided for backwards compatibility with
+GNU Fortran 77. It implements a simple modulo generator as provided
+by @command{g77}. For new code, one should consider the use of
+@ref{RANDOM_NUMBER} as it implements a superior algorithm.
+
@item @emph{Standard}:
GNU extension
@item @emph{Class}:
-Non-elemental function
+Function
@item @emph{Syntax}:
-@code{RESULT = RAND(FLAG)}
+@code{RESULT = RAND(I)}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{FLAG} @tab Shall be a scalar @code{INTEGER} of kind 4.
+@item @var{I} @tab Shall be a scalar @code{INTEGER} of kind 4.
@end multitable
@item @emph{Return value}:
@node RANDOM_NUMBER
@section @code{RANDOM_NUMBER} --- Pseudo-random number
-@cindex @code{RANDOM_NUMBER} intrinsic
-@cindex random numbers
+@fnindex RANDOM_NUMBER
+@cindex random number generation
@table @asis
@item @emph{Description}:
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}:
-Elemental subroutine
+Subroutine
@item @emph{Syntax}:
@code{RANDOM_NUMBER(HARVEST)}
@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
@node RANDOM_SEED
@section @code{RANDOM_SEED} --- Initialize a pseudo-random number sequence
-@cindex @code{RANDOM_SEED} intrinsic
-@cindex random numbers
+@fnindex RANDOM_SEED
+@cindex random number generation, seeding
+@cindex seeding a random number generator
@table @asis
@item @emph{Description}:
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
-@cindex @code{RANGE} intrinsic
-@cindex range of a real variable
+@section @code{RANGE} --- Decimal exponent range
+@fnindex RANGE
+@cindex model representation, range
@table @asis
@item @emph{Description}:
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}:
The return value is of type @code{INTEGER} and of the default integer
kind.
+@item @emph{See also}:
+@ref{SELECTED_REAL_KIND}, @ref{PRECISION}
+
@item @emph{Example}:
See @code{PRECISION} for an example.
@end table
@node REAL
@section @code{REAL} --- Convert to real type
-@cindex @code{REAL} intrinsic
-@cindex @code{REALPART} intrinsic
-@cindex true values
+@fnindex REAL
+@fnindex REALPART
+@fnindex FLOAT
+@fnindex DFLOAT
+@fnindex SNGL
+@cindex conversion, to real
+@cindex complex numbers, real part
@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
end program test_real
@end smallexample
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .25
+@item Name @tab Argument @tab Return type @tab Standard
+@item @code{FLOAT(A)} @tab @code{INTEGER(4)} @tab @code{REAL(4)} @tab Fortran 77 and later
+@item @code{DFLOAT(A)} @tab @code{INTEGER(4)} @tab @code{REAL(8)} @tab GNU extension
+@item @code{SNGL(A)} @tab @code{INTEGER(8)} @tab @code{REAL(4)} @tab Fortran 77 and later
+@end multitable
+
+
@item @emph{See also}:
-@ref{DBLE}, @ref{DFLOAT}, @ref{FLOAT}
+@ref{DBLE}
@end table
@node RENAME
@section @code{RENAME} --- Rename a file
-@cindex @code{RENAME} intrinsic
-@cindex file system operations
+@fnindex RENAME
+@cindex file system, rename file
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-Subroutine, non-elemental function
+Subroutine, function
@item @emph{Syntax}:
@multitable @columnfractions .80
@node REPEAT
@section @code{REPEAT} --- Repeated string concatenation
-@cindex @code{REPEAT} intrinsic
-@cindex string manipulation
-
-Intrinsic implemented, documentation pending.
+@fnindex REPEAT
+@cindex string, repeat
+@cindex string, concatenate
@table @asis
@item @emph{Description}:
+Concatenates @var{NCOPIES} copies of a string.
+
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Transformational function
@item @emph{Syntax}:
+@code{RESULT = REPEAT(STRING, NCOPIES)}
+
@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}.
+@end multitable
+
@item @emph{Return value}:
+A new scalar of type @code{CHARACTER} built up from @var{NCOPIES} copies
+of @var{STRING}.
+
@item @emph{Example}:
-@item @emph{See also}:
+@smallexample
+program test_repeat
+ write(*,*) repeat("x", 5) ! "xxxxx"
+end program
+@end smallexample
@end table
@node RESHAPE
@section @code{RESHAPE} --- Function to reshape an array
-@cindex @code{RESHAPE} intrinsic
-@cindex array manipulation
-
-Intrinsic implemented, documentation pending.
+@fnindex RESHAPE
+@cindex array, change dimensions
+@cindex array, transmogrify
@table @asis
@item @emph{Description}:
+Reshapes @var{SOURCE} to correspond to @var{SHAPE}. If necessary,
+the new array may be padded with elements from @var{PAD} or permuted
+as defined by @var{ORDER}.
+
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Transformational function
@item @emph{Syntax}:
+@code{RESULT = RESHAPE(SOURCE, SHAPE[, PAD, ORDER])}
+
@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{SOURCE} @tab Shall be an array of any type.
+@item @var{SHAPE} @tab Shall be of type @code{INTEGER} and an
+array of rank one. Its values must be positive or zero.
+@item @var{PAD} @tab (Optional) shall be an array of the same
+type as @var{SOURCE}.
+@item @var{ORDER} @tab (Optional) shall be of type @code{INTEGER}
+and an array of the same shape as @var{SHAPE}. Its values shall
+be a permutation of the numbers from 1 to n, where n is the size of
+@var{SHAPE}. If @var{ORDER} is absent, the natural ordering shall
+be assumed.
+@end multitable
+
@item @emph{Return value}:
+The result is an array of shape @var{SHAPE} with the same type as
+@var{SOURCE}.
+
@item @emph{Example}:
+@smallexample
+PROGRAM test_reshape
+ INTEGER, DIMENSION(4) :: x
+ WRITE(*,*) SHAPE(x) ! prints "4"
+ WRITE(*,*) SHAPE(RESHAPE(x, (/2, 2/))) ! prints "2 2"
+END PROGRAM
+@end smallexample
+
@item @emph{See also}:
@ref{SHAPE}
@end table
@node RRSPACING
@section @code{RRSPACING} --- Reciprocal of the relative spacing
-@cindex @code{RRSPACING} intrinsic
+@fnindex RRSPACING
+@cindex real number, relative spacing
+@cindex floating point, relative spacing
+
@table @asis
@item @emph{Description}:
model numbers near @var{X}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Elemental function
The value returned is equal to
@code{ABS(FRACTION(X)) * FLOAT(RADIX(X))**DIGITS(X)}.
+@item @emph{See also}:
+@ref{SPACING}
@end table
@node RSHIFT
@section @code{RSHIFT} --- Right shift bits
-@cindex @code{RSHIFT} intrinsic
-@cindex bit operations
+@fnindex RSHIFT
+@cindex bits, shift right
@table @asis
@item @emph{Description}:
@code{RSHIFT} returns a value corresponding to @var{I} with all of the
bits shifted right by @var{SHIFT} places. If the absolute value of
-@var{SHIFT} is greater than @code{BIT_SIZE(I)}, the value is undefined.
-Bits shifted out from the left end are lost; zeros are shifted in from
-the opposite end.
+@var{SHIFT} is greater than @code{BIT_SIZE(I)}, the value is undefined.
+Bits shifted out from the right end are lost. The fill is arithmetic: the
+bits shifted in from the left end are equal to the leftmost bit, which in
+two's complement representation is the sign bit.
-This function has been superseded by the @code{ISHFT} intrinsic, which
-is standard in Fortran 95 and later.
+This function has been superseded by the @code{SHIFTA} intrinsic, which
+is standard in Fortran 2008 and later.
@item @emph{Standard}:
GNU extension
@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}:
-@ref{ISHFT}, @ref{ISHFTC}, @ref{LSHIFT}
+@ref{ISHFT}, @ref{ISHFTC}, @ref{LSHIFT}, @ref{SHIFTA}, @ref{SHIFTR},
+@ref{SHIFTL}
+
+@end table
+
+
+
+@node SAME_TYPE_AS
+@section @code{SAME_TYPE_AS} --- Query dynamic types for equality
+@fnindex SAME_TYPE_AS
+
+@table @asis
+@item @emph{Description}:
+Query dynamic types for equality.
+
+@item @emph{Standard}:
+Fortran 2003 and later
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@code{RESULT = SAME_TYPE_AS(A, B)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{A} @tab Shall be an object of extensible declared type or
+unlimited polymorphic.
+@item @var{B} @tab Shall be an object of extensible declared type or
+unlimited polymorphic.
+@end multitable
+
+@item @emph{Return value}:
+The return value is a scalar of type default logical. It is true if and
+only if the dynamic type of A is the same as the dynamic type of B.
+
+@item @emph{See also}:
+@ref{EXTENDS_TYPE_OF}
@end table
@node SCALE
@section @code{SCALE} --- Scale a real value
-@cindex @code{SCALE} intrinsic
+@fnindex SCALE
+@cindex real number, scale
+@cindex floating point, scale
@table @asis
@item @emph{Description}:
@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
@node SCAN
@section @code{SCAN} --- Scan a string for the presence of a set of characters
-@cindex @code{SCAN} intrinsic
-@cindex string manipulation
-
-Intrinsic implemented, documentation pending.
+@fnindex SCAN
+@cindex string, find subset
@table @asis
@item @emph{Description}:
+Scans a @var{STRING} for any of the characters in a @var{SET}
+of characters.
+
+If @var{BACK} is either absent or equals @code{FALSE}, this function
+returns the position of the leftmost character of @var{STRING} that is
+in @var{SET}. If @var{BACK} equals @code{TRUE}, the rightmost position
+is returned. If no character of @var{SET} is found in @var{STRING}, the
+result is zero.
+
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later, with @var{KIND} argument Fortran 2003 and later
@item @emph{Class}:
Elemental function
@item @emph{Syntax}:
+@code{RESULT = SCAN(STRING, SET[, BACK [, 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{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 kind @var{KIND}. If
+@var{KIND} is absent, the return value is of default integer kind.
+
@item @emph{Example}:
+@smallexample
+PROGRAM test_scan
+ WRITE(*,*) SCAN("FORTRAN", "AO") ! 2, found 'O'
+ WRITE(*,*) SCAN("FORTRAN", "AO", .TRUE.) ! 6, found 'A'
+ WRITE(*,*) SCAN("FORTRAN", "C++") ! 0, found none
+END PROGRAM
+@end smallexample
+
@item @emph{See also}:
+@ref{INDEX intrinsic}, @ref{VERIFY}
@end table
@node SECNDS
@section @code{SECNDS} --- Time function
-@cindex @code{SECNDS} intrinsic
-@cindex time, current
-@cindex current time
+@fnindex SECNDS
+@cindex time, elapsed
+@cindex elapsed time
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-Non-elemental function
+Function
@item @emph{Syntax}:
@code{RESULT = SECNDS (X)}
@item @emph{Example}:
@smallexample
program test_secnds
+ integer :: i
real(4) :: t1, t2
print *, secnds (0.0) ! seconds since midnight
t1 = secnds (0.0) ! reference time
@node SECOND
@section @code{SECOND} --- CPU time function
-@cindex @code{SECOND} intrinsic
+@fnindex SECOND
@cindex time, elapsed
@cindex elapsed time
GNU extension
@item @emph{Class}:
-Subroutine, non-elemental function
+Subroutine, function
@item @emph{Syntax}:
@multitable @columnfractions .80
+@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, and ``ISO_10646''
+(Universal Character Set, UCS-4) which is commonly known as Unicode.
+
+@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 character_kind
+ use iso_fortran_env
+ implicit none
+ integer, parameter :: ascii = selected_char_kind ("ascii")
+ integer, parameter :: ucs4 = selected_char_kind ('ISO_10646')
+
+ character(kind=ascii, len=26) :: alphabet
+ character(kind=ucs4, len=30) :: hello_world
+
+ alphabet = ascii_"abcdefghijklmnopqrstuvwxyz"
+ hello_world = ucs4_'Hello World and Ni Hao -- ' &
+ // char (int (z'4F60'), ucs4) &
+ // char (int (z'597D'), ucs4)
+
+ write (*,*) alphabet
+
+ open (output_unit, encoding='UTF-8')
+ write (*,*) trim (hello_world)
+end program character_kind
+@end smallexample
+@end table
+
+
+
@node SELECTED_INT_KIND
@section @code{SELECTED_INT_KIND} --- Choose integer kind
-@cindex @code{SELECTED_INT_KIND} intrinsic
+@fnindex SELECTED_INT_KIND
@cindex integer kind
+@cindex kind, integer
@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}:
@node SELECTED_REAL_KIND
@section @code{SELECTED_REAL_KIND} --- Choose real kind
-@cindex @code{SELECTED_REAL_KIND} intrinsic
+@fnindex SELECTED_REAL_KIND
@cindex real kind
+@cindex kind, real
+@cindex radix, real
@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
-range greater at least @code{R}.
+@code{SELECTED_REAL_KIND(P,R)} returns the kind value of a real data type
+with decimal precision of at least @code{P} digits, exponent range of
+at least @code{R}, and with a radix of @code{RADIX}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later, with @code{RADIX} Fortran 2008 or later
@item @emph{Class}:
Transformational function
@item @emph{Syntax}:
-@code{RESULT = SELECTED_REAL_KIND(P, R)}
+@code{RESULT = SELECTED_REAL_KIND([P, R, RADIX])}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
@item @var{P} @tab (Optional) shall be a scalar and of type @code{INTEGER}.
@item @var{R} @tab (Optional) shall be a scalar and of type @code{INTEGER}.
+@item @var{RADIX} @tab (Optional) shall be a scalar and of type @code{INTEGER}.
@end multitable
-At least one argument shall be present.
+Before Fortran 2008, at least one of the arguments @var{R} or @var{P} shall
+be present; since Fortran 2008, they are assumed to be zero if absent.
@item @emph{Return value}:
@code{SELECTED_REAL_KIND} returns the value of the kind type parameter of
-a real data type with decimal precision of at least @code{P} digits and a
-decimal exponent range of at least @code{R}. If more than one real data
-type meet the criteria, the kind of the data type with the smallest
-decimal precision is returned. If no real data type matches the criteria,
-the result is
+a real data type with decimal precision of at least @code{P} digits, a
+decimal exponent range of at least @code{R}, and with the requested
+@code{RADIX}. If the @code{RADIX} parameter is absent, real kinds with
+any radix can be returned. If more than one real data type meet the
+criteria, the kind of the data type with the smallest decimal precision
+is returned. If no real data type matches the criteria, the result is
@table @asis
@item -1 if the processor does not support a real data type with a
-precision greater than or equal to @code{P}
+precision greater than or equal to @code{P}, but the @code{R} and
+@code{RADIX} requirements can be fulfilled
@item -2 if the processor does not support a real type with an exponent
-range greater than or equal to @code{R}
-@item -3 if neither is supported.
+range greater than or equal to @code{R}, but @code{P} and @code{RADIX}
+are fulfillable
+@item -3 if @code{RADIX} but not @code{P} and @code{R} requirements
+are fulfillable
+@item -4 if @code{RADIX} and either @code{P} or @code{R} requirements
+are fulfillable
+@item -5 if there is no real type with the given @code{RADIX}
@end table
+@item @emph{See also}:
+@ref{PRECISION}, @ref{RANGE}, @ref{RADIX}
+
@item @emph{Example}:
@smallexample
program real_kinds
@node SET_EXPONENT
@section @code{SET_EXPONENT} --- Set the exponent of the model
-@cindex @code{SET_EXPONENT} intrinsic
-@cindex exponent part of a real number
+@fnindex SET_EXPONENT
+@cindex real number, set exponent
+@cindex floating point, set exponent
@table @asis
@item @emph{Description}:
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
@item @emph{Example}:
@smallexample
-program test_setexp
- real :: x = 178.1387e-4
- integer :: i = 17
- print *, set_exponent(x), fraction(x) * radix(x)**i
-end program test_setexp
+PROGRAM test_setexp
+ REAL :: x = 178.1387e-4
+ INTEGER :: i = 17
+ PRINT *, SET_EXPONENT(x, i), FRACTION(x) * RADIX(x)**i
+END PROGRAM
@end smallexample
@end table
@node SHAPE
@section @code{SHAPE} --- Determine the shape of an array
-@cindex @code{SHAPE} intrinsic
-@cindex array manipulation
-
-Intrinsic implemented, documentation pending.
+@fnindex SHAPE
+@cindex array, shape
@table @asis
@item @emph{Description}:
+Determines the shape of an array.
+
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Inquiry function
@item @emph{Syntax}:
+@code{RESULT = SHAPE(SOURCE)}
+
@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{SOURCE} @tab Shall be an array or scalar of any type.
+If @var{SOURCE} is a pointer it must be associated and allocatable
+arrays must be allocated.
+@end multitable
+
@item @emph{Return value}:
+An @code{INTEGER} array of rank one with as many elements as @var{SOURCE}
+has dimensions. The elements of the resulting array correspond to the extend
+of @var{SOURCE} along the respective dimensions. If @var{SOURCE} is a scalar,
+the result is the rank one array of size zero.
+
@item @emph{Example}:
+@smallexample
+PROGRAM test_shape
+ INTEGER, DIMENSION(-1:1, -1:2) :: A
+ WRITE(*,*) SHAPE(A) ! (/ 3, 4 /)
+ WRITE(*,*) SIZE(SHAPE(42)) ! (/ /)
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+@ref{RESHAPE}, @ref{SIZE}
+@end table
+
+
+
+@node SHIFTA
+@section @code{SHIFTA} --- Right shift with fill
+@fnindex SHIFTA
+@cindex bits, shift right
+@cindex shift, right with fill
+
+@table @asis
+@item @emph{Description}:
+@code{SHIFTA} returns a value corresponding to @var{I} with all of the
+bits shifted right by @var{SHIFT} places. If the absolute value of
+@var{SHIFT} is greater than @code{BIT_SIZE(I)}, the value is undefined.
+Bits shifted out from the right end are lost. The fill is arithmetic: the
+bits shifted in from the left end are equal to the leftmost bit, which in
+two's complement representation is the sign bit.
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = SHIFTA(I, SHIFT)}
+
+@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}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{INTEGER} and of the same kind as
+@var{I}.
+
+@item @emph{See also}:
+@ref{SHIFTL}, @ref{SHIFTR}
+@end table
+
+
+
+@node SHIFTL
+@section @code{SHIFTL} --- Left shift
+@fnindex SHIFTL
+@cindex bits, shift left
+@cindex shift, left
+
+@table @asis
+@item @emph{Description}:
+@code{SHIFTL} returns a value corresponding to @var{I} with all of the
+bits shifted left by @var{SHIFT} places. If the absolute value of
+@var{SHIFT} is greater than @code{BIT_SIZE(I)}, the value is undefined.
+Bits shifted out from the left end are lost, and bits shifted in from
+the right end are set to 0.
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = SHIFTL(I, SHIFT)}
+
+@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}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{INTEGER} and of the same kind as
+@var{I}.
+
+@item @emph{See also}:
+@ref{SHIFTA}, @ref{SHIFTR}
+@end table
+
+
+
+@node SHIFTR
+@section @code{SHIFTR} --- Right shift
+@fnindex SHIFTR
+@cindex bits, shift right
+@cindex shift, right
+
+@table @asis
+@item @emph{Description}:
+@code{SHIFTR} returns a value corresponding to @var{I} with all of the
+bits shifted right by @var{SHIFT} places. If the absolute value of
+@var{SHIFT} is greater than @code{BIT_SIZE(I)}, the value is undefined.
+Bits shifted out from the right end are lost, and bits shifted in from
+the left end are set to 0.
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = SHIFTR(I, SHIFT)}
+
+@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}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{INTEGER} and of the same kind as
+@var{I}.
+
@item @emph{See also}:
-@ref{RESHAPE}
+@ref{SHIFTA}, @ref{SHIFTL}
@end table
@node SIGN
@section @code{SIGN} --- Sign copying function
-@cindex @code{SIGN} intrinsic
-@cindex @code{ISIGN} intrinsic
-@cindex @code{DSIGN} intrinsic
+@fnindex SIGN
+@fnindex ISIGN
+@fnindex DSIGN
@cindex sign copying
@table @asis
@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 @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{A} @tab Shall be a scalar of type @code{INTEGER} or @code{REAL}
-@item @var{B} @tab Shall be a scalar of the same type and kind as @var{A}
+@item @var{A} @tab Shall be of type @code{INTEGER} or @code{REAL}
+@item @var{B} @tab Shall be of the same type and kind as @var{A}
@end multitable
@item @emph{Return value}:
@item @emph{Specific names}:
@multitable @columnfractions .20 .20 .20 .25
-@item Name @tab Arguments @tab Return type @tab Standard
-@item @code{ISIGN(A,P)} @tab @code{INTEGER(4)} @tab @code{INTEGER(4)} @tab f95, gnu
-@item @code{DSIGN(A,P)} @tab @code{REAL(8)} @tab @code{REAL(8)} @tab f95, gnu
+@item Name @tab Arguments @tab Return type @tab Standard
+@item @code{SIGN(A,B)} @tab @code{REAL(4) A, B} @tab @code{REAL(4)} @tab f77, gnu
+@item @code{ISIGN(A,B)} @tab @code{INTEGER(4) A, B} @tab @code{INTEGER(4)} @tab f77, gnu
+@item @code{DSIGN(A,B)} @tab @code{REAL(8) A, B} @tab @code{REAL(8)} @tab f77, gnu
@end multitable
@end table
@node SIGNAL
@section @code{SIGNAL} --- Signal handling subroutine (or function)
-@cindex @code{SIGNAL} intrinsic
-@cindex signal handling
+@fnindex SIGNAL
+@cindex system, signal handling
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-Subroutine, non-elemental function
+Subroutine, function
@item @emph{Syntax}:
@multitable @columnfractions .80
@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)}.
@node SIN
@section @code{SIN} --- Sine function
-@cindex @code{SIN} intrinsic
-@cindex @code{DSIN} intrinsic
-@cindex @code{CSIN} intrinsic
-@cindex @code{ZSIN} intrinsic
-@cindex @code{CDSIN} intrinsic
-@cindex trigonometric functions
+@fnindex SIN
+@fnindex DSIN
+@fnindex CSIN
+@fnindex ZSIN
+@fnindex CDSIN
+@cindex trigonometric function, sine
+@cindex sine
@table @asis
@item @emph{Description}:
@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}:
@item @emph{Specific names}:
@multitable @columnfractions .20 .20 .20 .25
-@item Name @tab Argument @tab Return type @tab Standard
-@item @code{DSIN(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab f95, gnu
-@item @code{CSIN(X)} @tab @code{COMPLEX(4) X} @tab @code{COMPLEX(4)} @tab f95, gnu
-@item @code{ZSIN(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab f95, gnu
-@item @code{CDSIN(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab f95, gnu
+@item Name @tab Argument @tab Return type @tab Standard
+@item @code{SIN(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab f77, gnu
+@item @code{DSIN(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab f95, gnu
+@item @code{CSIN(X)} @tab @code{COMPLEX(4) X} @tab @code{COMPLEX(4)} @tab f95, gnu
+@item @code{ZSIN(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab f95, gnu
+@item @code{CDSIN(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab f95, gnu
@end multitable
@item @emph{See also}:
@node SINH
@section @code{SINH} --- Hyperbolic sine function
-@cindex @code{SINH} intrinsic
-@cindex @code{DSINH} intrinsic
+@fnindex SINH
+@fnindex DSINH
@cindex hyperbolic sine
+@cindex hyperbolic function, sine
+@cindex sine, hyperbolic
@table @asis
@item @emph{Description}:
@code{SINH(X)} computes the hyperbolic sine of @var{X}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later, for a complex argument Fortran 2008 or later
@item @emph{Class}:
Elemental function
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{X} @tab The type shall be @code{REAL(*)}.
+@item @var{X} @tab The type shall be @code{REAL} or @code{COMPLEX}.
@end multitable
@item @emph{Return value}:
-The return value is of type @code{REAL(*)}.
+The return value has same type and kind as @var{X}.
@item @emph{Example}:
@smallexample
@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{SINH(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab Fortran 95 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}:
@node SIZE
@section @code{SIZE} --- Determine the size of an array
-@cindex @code{SIZE} intrinsic
-@cindex array manipulation
-
-Intrinsic implemented, documentation pending.
+@fnindex SIZE
+@cindex array, size
+@cindex array, number of elements
+@cindex array, count elements
@table @asis
@item @emph{Description}:
+Determine the extent of @var{ARRAY} along a specified dimension @var{DIM},
+or the total number of elements in @var{ARRAY} if @var{DIM} is absent.
+
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later, with @var{KIND} argument Fortran 2003 and later
@item @emph{Class}:
Inquiry function
@item @emph{Syntax}:
+@code{RESULT = SIZE(ARRAY[, DIM [, KIND]])}
+
@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{ARRAY} @tab Shall be an array of any type. If @var{ARRAY} is
+a pointer it must be associated and allocatable arrays must be allocated.
+@item @var{DIM} @tab (Optional) shall be a scalar of type @code{INTEGER}
+and its value shall be in the range from 1 to n, where n equals the rank
+of @var{ARRAY}.
+@item @var{KIND} @tab (Optional) An @code{INTEGER} initialization
+expression indicating the kind parameter of the result.
+@end multitable
+
@item @emph{Return value}:
+The return value is of type @code{INTEGER} and of kind @var{KIND}. If
+@var{KIND} is absent, the return value is of default integer kind.
+
@item @emph{Example}:
+@smallexample
+PROGRAM test_size
+ WRITE(*,*) SIZE((/ 1, 2 /)) ! 2
+END PROGRAM
+@end smallexample
+
@item @emph{See also}:
+@ref{SHAPE}, @ref{RESHAPE}
@end table
-
-@node SLEEP
-@section @code{SLEEP} --- Sleep for the specified number of seconds
-@cindex @code{SLEEP} intrinsic
+@node SIZEOF
+@section @code{SIZEOF} --- Size in bytes of an expression
+@fnindex SIZEOF
+@cindex expression size
+@cindex size of an expression
@table @asis
@item @emph{Description}:
-Calling this subroutine causes the process to pause for @var{SECONDS} seconds.
+@code{SIZEOF(X)} calculates the number of bytes of storage the
+expression @code{X} occupies.
@item @emph{Standard}:
GNU extension
@item @emph{Class}:
-Subroutine
+Intrinsic function
@item @emph{Syntax}:
-@code{CALL SLEEP(SECONDS)}
+@code{N = SIZEOF(X)}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{SECONDS} @tab The type shall be of default @code{INTEGER}.
+@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. If the argument is
+polymorphic, the size according to the declared type is returned.
+
@item @emph{Example}:
@smallexample
-program test_sleep
- call sleep(5)
-end
+ integer :: i
+ real :: r, s(5)
+ print *, (sizeof(s)/sizeof(r) == 5)
+ end
@end smallexample
-@end table
+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}, @ref{STORAGE_SIZE}
+@end table
-@node SNGL
-@section @code{SNGL} --- Convert double precision real to default real
-@cindex @code{SNGL} intrinsic
-@cindex conversion function (real)
+@node SLEEP
+@section @code{SLEEP} --- Sleep for the specified number of seconds
+@fnindex SLEEP
+@cindex delayed execution
@table @asis
@item @emph{Description}:
-@code{SNGL(A)} converts the double precision real @var{A}
-to a default real value. This is an archaic form of @code{REAL}
-that is specific to one type for @var{A}.
+Calling this subroutine causes the process to pause for @var{SECONDS} seconds.
@item @emph{Standard}:
GNU extension
@item @emph{Class}:
-function
+Subroutine
@item @emph{Syntax}:
-@code{RESULT = SNGL(A)}
+@code{CALL SLEEP(SECONDS)}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{A} @tab The type shall be a double precision @code{REAL}.
+@item @var{SECONDS} @tab The type shall be of default @code{INTEGER}.
@end multitable
-@item @emph{Return value}:
-The return value is of type default @code{REAL}.
-
-@item @emph{See also}:
-@ref{DBLE}
+@item @emph{Example}:
+@smallexample
+program test_sleep
+ call sleep(5)
+end
+@end smallexample
@end table
@node SPACING
@section @code{SPACING} --- Smallest distance between two numbers of a given type
-@cindex @code{SPACING} intrinsic
-@cindex undocumented intrinsic
-
-Intrinsic implemented, documentation pending.
+@fnindex SPACING
+@cindex real number, relative spacing
+@cindex floating point, relative spacing
@table @asis
@item @emph{Description}:
+Determines the distance between the argument @var{X} and the nearest
+adjacent number of the same type.
+
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Elemental function
@item @emph{Syntax}:
+@code{RESULT = SPACING(X)}
+
@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{X} @tab Shall be of type @code{REAL}.
+@end multitable
+
@item @emph{Return value}:
+The result is of the same type as the input argument @var{X}.
+
@item @emph{Example}:
+@smallexample
+PROGRAM test_spacing
+ INTEGER, PARAMETER :: SGL = SELECTED_REAL_KIND(p=6, r=37)
+ INTEGER, PARAMETER :: DBL = SELECTED_REAL_KIND(p=13, r=200)
+
+ WRITE(*,*) spacing(1.0_SGL) ! "1.1920929E-07" on i686
+ WRITE(*,*) spacing(1.0_DBL) ! "2.220446049250313E-016" on i686
+END PROGRAM
+@end smallexample
+
@item @emph{See also}:
+@ref{RRSPACING}
@end table
@node SPREAD
@section @code{SPREAD} --- Add a dimension to an array
-@cindex @code{SPREAD} intrinsic
-@cindex array manipulation
-
-Intrinsic implemented, documentation pending.
+@fnindex SPREAD
+@cindex array, increase dimension
+@cindex array, duplicate elements
+@cindex array, duplicate dimensions
@table @asis
@item @emph{Description}:
+Replicates a @var{SOURCE} array @var{NCOPIES} times along a specified
+dimension @var{DIM}.
+
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Transformational function
@item @emph{Syntax}:
+@code{RESULT = SPREAD(SOURCE, DIM, NCOPIES)}
+
@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{SOURCE} @tab Shall be a scalar or an array of any type and
+a rank less than seven.
+@item @var{DIM} @tab Shall be a scalar of type @code{INTEGER} with a
+value in the range from 1 to n+1, where n equals the rank of @var{SOURCE}.
+@item @var{NCOPIES} @tab Shall be a scalar of type @code{INTEGER}.
+@end multitable
+
@item @emph{Return value}:
+The result is an array of the same type as @var{SOURCE} and has rank n+1
+where n equals the rank of @var{SOURCE}.
+
@item @emph{Example}:
+@smallexample
+PROGRAM test_spread
+ INTEGER :: a = 1, b(2) = (/ 1, 2 /)
+ WRITE(*,*) SPREAD(A, 1, 2) ! "1 1"
+ WRITE(*,*) SPREAD(B, 1, 2) ! "1 1 2 2"
+END PROGRAM
+@end smallexample
+
@item @emph{See also}:
+@ref{UNPACK}
@end table
@node SQRT
@section @code{SQRT} --- Square-root function
-@cindex @code{SQRT} intrinsic
-@cindex @code{DSQRT} intrinsic
-@cindex @code{CSQRT} intrinsic
-@cindex @code{ZSQRT} intrinsic
-@cindex @code{CDSQRT} intrinsic
+@fnindex SQRT
+@fnindex DSQRT
+@fnindex CSQRT
+@fnindex ZSQRT
+@fnindex CDSQRT
+@cindex root
@cindex square-root
@table @asis
@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{SQRT(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab Fortran 95 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
@node SRAND
@section @code{SRAND} --- Reinitialize the random number generator
-@cindex @code{SRAND} intrinsic
-@cindex random numbers
+@fnindex SRAND
+@cindex random number generation, seeding
+@cindex seeding a random number generator
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-Non-elemental subroutine
+Subroutine
@item @emph{Syntax}:
@code{CALL SRAND(SEED)}
@end multitable
@item @emph{Return value}:
-Does not return.
+Does not return anything.
@item @emph{Example}:
See @code{RAND} and @code{IRAND} for examples.
@node STAT
@section @code{STAT} --- Get file status
-@cindex @code{STAT} intrinsic
-@cindex file system operations
+@fnindex STAT
+@cindex file system, file status
@table @asis
@item @emph{Description}:
the file itself, but execute (search) permission is required on all of the
directories in path that lead to the file.
-The elements that are obtained and stored in the array @code{BUFF}:
+The elements that are obtained and stored in the array @code{VALUES}:
@multitable @columnfractions .15 .70
-@item @code{buff(1)} @tab Device ID
-@item @code{buff(2)} @tab Inode number
-@item @code{buff(3)} @tab File mode
-@item @code{buff(4)} @tab Number of links
-@item @code{buff(5)} @tab Owner's uid
-@item @code{buff(6)} @tab Owner's gid
-@item @code{buff(7)} @tab ID of device containing directory entry for file (0 if not available)
-@item @code{buff(8)} @tab File size (bytes)
-@item @code{buff(9)} @tab Last access time
-@item @code{buff(10)} @tab Last modification time
-@item @code{buff(11)} @tab Last file status change time
-@item @code{buff(12)} @tab Preferred I/O block size (-1 if not available)
-@item @code{buff(13)} @tab Number of blocks allocated (-1 if not available)
+@item @code{VALUES(1)} @tab Device ID
+@item @code{VALUES(2)} @tab Inode number
+@item @code{VALUES(3)} @tab File mode
+@item @code{VALUES(4)} @tab Number of links
+@item @code{VALUES(5)} @tab Owner's uid
+@item @code{VALUES(6)} @tab Owner's gid
+@item @code{VALUES(7)} @tab ID of device containing directory entry for file (0 if not available)
+@item @code{VALUES(8)} @tab File size (bytes)
+@item @code{VALUES(9)} @tab Last access time
+@item @code{VALUES(10)} @tab Last modification time
+@item @code{VALUES(11)} @tab Last file status change time
+@item @code{VALUES(12)} @tab Preferred I/O block size (-1 if not available)
+@item @code{VALUES(13)} @tab Number of blocks allocated (-1 if not available)
@end multitable
Not all these elements are relevant on all systems.
If an element is not relevant, it is returned as 0.
+This intrinsic is provided in both subroutine and function forms; however,
+only one form can be used in any given program unit.
@item @emph{Standard}:
GNU extension
@item @emph{Class}:
-Non-elemental subroutine
+Subroutine, function
@item @emph{Syntax}:
-@code{CALL STAT(FILE,BUFF[,STATUS])}
+@multitable @columnfractions .80
+@item @code{CALL STAT(NAME, VALUES [, STATUS])}
+@item @code{STATUS = STAT(NAME, VALUES)}
+@end multitable
@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}:
@end smallexample
@item @emph{See also}:
-To stat an open file: @ref{FSTAT}, to stat a link: @ref{LSTAT}
+To stat an open file: @ref{FSTAT}, to stat a link: @ref{LSTAT}
+@end table
+
+
+
+@node STORAGE_SIZE
+@section @code{STORAGE_SIZE} --- Storage size in bits
+@fnindex STORAGE_SIZE
+@cindex storage size
+
+@table @asis
+@item @emph{Description}:
+Returns the storage size of argument @var{A} in bits.
+@item @emph{Standard}:
+Fortran 2008 and later
+@item @emph{Class}:
+Inquiry function
+@item @emph{Syntax}:
+@code{RESULT = STORAGE_SIZE(A [, KIND])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{A} @tab Shall be a scalar or array of any type.
+@item @var{KIND} @tab (Optional) shall be a scalar integer constant expression.
+@end multitable
+
+@item @emph{Return Value}:
+The result is a scalar integer with the kind type parameter specified by KIND (or default integer type if KIND is missing). The result value is the size expressed in bits for an element of an array that
+has the dynamic type and type parameters of A.
+
+@item @emph{See also}:
+@ref{C_SIZEOF}, @ref{SIZEOF}
@end table
@node SUM
@section @code{SUM} --- Sum of array elements
-@cindex @code{SUM} intrinsic
-@cindex array manipulation
-
-Intrinsic implemented, documentation pending.
+@fnindex SUM
+@cindex array, sum
+@cindex array, add elements
+@cindex array, conditionally add elements
+@cindex sum array elements
@table @asis
@item @emph{Description}:
+Adds the elements of @var{ARRAY} along dimension @var{DIM} if
+the corresponding element in @var{MASK} is @code{TRUE}.
+
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Transformational function
@item @emph{Syntax}:
+@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{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}.
+@item @var{MASK} @tab (Optional) shall be of type @code{LOGICAL}
+and either be a scalar or an array of the same shape as @var{ARRAY}.
+@end multitable
+
@item @emph{Return value}:
+The result is of the same type as @var{ARRAY}.
+
+If @var{DIM} is absent, a scalar with the sum of all elements in @var{ARRAY}
+is returned. Otherwise, an array of rank n-1, where n equals the rank of
+@var{ARRAY}, and a shape similar to that of @var{ARRAY} with dimension @var{DIM}
+dropped is returned.
+
@item @emph{Example}:
+@smallexample
+PROGRAM test_sum
+ INTEGER :: x(5) = (/ 1, 2, 3, 4 ,5 /)
+ print *, SUM(x) ! all elements, sum = 15
+ print *, SUM(x, MASK=MOD(x, 2)==1) ! odd elements, sum = 9
+END PROGRAM
+@end smallexample
+
@item @emph{See also}:
@ref{PRODUCT}
@end table
@node SYMLNK
@section @code{SYMLNK} --- Create a symbolic link
-@cindex @code{SYMLNK} intrinsic
-@cindex file system operations
+@fnindex SYMLNK
+@cindex file system, create link
+@cindex file system, soft link
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-Subroutine, non-elemental function
+Subroutine, function
@item @emph{Syntax}:
@multitable @columnfractions .80
@node SYSTEM
@section @code{SYSTEM} --- Execute a shell command
-@cindex @code{SYSTEM} intrinsic
+@fnindex SYSTEM
+@cindex system, system call
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-Subroutine, non-elemental function
+Subroutine, function
@item @emph{Syntax}:
@multitable @columnfractions .80
@end multitable
@item @emph{See also}:
+@ref{EXECUTE_COMMAND_LINE}, which is part of the Fortran 2008 standard
+and should considered in new code for future portability.
@end table
@node SYSTEM_CLOCK
@section @code{SYSTEM_CLOCK} --- Time function
-@cindex @code{SYSTEM_CLOCK} intrinsic
-@cindex time, current
-@cindex current time
-
-Intrinsic implemented, documentation pending.
+@fnindex SYSTEM_CLOCK
+@cindex time, clock ticks
+@cindex clock ticks
@table @asis
@item @emph{Description}:
+Determines the @var{COUNT} of milliseconds of wall clock time since
+the Epoch (00:00:00 UTC, January 1, 1970) modulo @var{COUNT_MAX},
+@var{COUNT_RATE} determines the number of clock ticks per second.
+@var{COUNT_RATE} and @var{COUNT_MAX} are constant and specific to
+@command{gfortran}.
+
+If there is no clock, @var{COUNT} is set to @code{-HUGE(COUNT)}, and
+@var{COUNT_RATE} and @var{COUNT_MAX} are set to zero
+
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Subroutine
@item @emph{Syntax}:
+@code{CALL SYSTEM_CLOCK([COUNT, COUNT_RATE, COUNT_MAX])}
+
@item @emph{Arguments}:
-@item @emph{Return value}:
+@multitable @columnfractions .15 .70
+@item @var{COUNT} @tab (Optional) shall be a scalar of type default
+@code{INTEGER} with @code{INTENT(OUT)}.
+@item @var{COUNT_RATE} @tab (Optional) shall be a scalar of type default
+@code{INTEGER} with @code{INTENT(OUT)}.
+@item @var{COUNT_MAX} @tab (Optional) shall be a scalar of type default
+@code{INTEGER} with @code{INTENT(OUT)}.
+@end multitable
+
@item @emph{Example}:
+@smallexample
+PROGRAM test_system_clock
+ INTEGER :: count, count_rate, count_max
+ CALL SYSTEM_CLOCK(count, count_rate, count_max)
+ WRITE(*,*) count, count_rate, count_max
+END PROGRAM
+@end smallexample
+
@item @emph{See also}:
+@ref{DATE_AND_TIME}, @ref{CPU_TIME}
@end table
@node TAN
@section @code{TAN} --- Tangent function
-@cindex @code{TAN} intrinsic
-@cindex @code{DTAN} intrinsic
-@cindex trigonometric functions
+@fnindex TAN
+@fnindex DTAN
+@cindex trigonometric function, tangent
+@cindex tangent
@table @asis
@item @emph{Description}:
@code{TAN(X)} computes the tangent of @var{X}.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later, for a complex argument Fortran 2008 or later
@item @emph{Class}:
Elemental function
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{X} @tab The type shall be @code{REAL(*)}.
+@item @var{X} @tab The type shall be @code{REAL} or @code{COMPLEX}.
@end multitable
@item @emph{Return value}:
-The return value is of type @code{REAL(*)}. The kind type parameter is
-the same as @var{X}.
+The return value has same type and kind as @var{X}.
@item @emph{Example}:
@smallexample
@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 Name @tab Argument @tab Return type @tab Standard
+@item @code{TAN(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab Fortran 95 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}:
@node TANH
@section @code{TANH} --- Hyperbolic tangent function
-@cindex @code{TANH} intrinsic
-@cindex @code{DTANH} intrinsic
+@fnindex TANH
+@fnindex DTANH
@cindex hyperbolic tangent
+@cindex hyperbolic function, tangent
+@cindex tangent, hyperbolic
@table @asis
@item @emph{Description}:
@code{TANH(X)} computes the hyperbolic tangent of @var{X}.
@item @emph{Standard}:
-F77 and later
+Fortran 77 and later, for a complex argument Fortran 2008 or later
@item @emph{Class}:
Elemental function
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{X} @tab The type shall be @code{REAL(*)}.
+@item @var{X} @tab The type shall be @code{REAL} or @code{COMPLEX}.
@end multitable
@item @emph{Return value}:
-The return value is of type @code{REAL(*)} and lies in the range
+The return value has same type and kind as @var{X}. If @var{X} is
+complex, the imaginary part of the result is in radians. If @var{X}
+is @code{REAL}, the return value lies in the range
@math{ - 1 \leq tanh(x) \leq 1 }.
@item @emph{Example}:
@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{TANH(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab Fortran 95 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}:
+@node THIS_IMAGE
+@section @code{THIS_IMAGE} --- Function that returns the cosubscript index of this image
+@fnindex THIS_IMAGE
+@cindex coarray, @code{THIS_IMAGE}
+@cindex images, index of this image
+
+@table @asis
+@item @emph{Description}:
+Returns the cosubscript for this image.
+
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@multitable @columnfractions .80
+@item @code{RESULT = THIS_IMAGE()}
+@item @code{RESULT = THIS_IMAGE(COARRAY [, DIM])}
+@end multitable
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{COARRAY} @tab Coarray of any type (optional; if @var{DIM}
+present, required).
+@item @var{DIM} @tab default integer scalar (optional). If present,
+@var{DIM} shall be between one and the corank of @var{COARRAY}.
+@end multitable
+
+
+@item @emph{Return value}:
+Default integer. If @var{COARRAY} is not present, it is scalar and its value
+is the index of the invoking image. Otherwise, if @var{DIM} is not present,
+a rank-1 array with corank elements is returned, containing the cosubscripts
+for @var{COARRAY} specifying the invoking image. If @var{DIM} is present,
+a scalar is returned, with the value of the @var{DIM} element of
+@code{THIS_IMAGE(COARRAY)}.
+
+@item @emph{Example}:
+@smallexample
+INTEGER :: value[*]
+INTEGER :: i
+value = THIS_IMAGE()
+SYNC ALL
+IF (THIS_IMAGE() == 1) THEN
+ DO i = 1, NUM_IMAGES()
+ WRITE(*,'(2(a,i0))') 'value[', i, '] is ', value[i]
+ END DO
+END IF
+@end smallexample
+
+@item @emph{See also}:
+@ref{NUM_IMAGES}, @ref{IMAGE_INDEX}
+@end table
+
+
+
@node TIME
@section @code{TIME} --- Time function
-@cindex @code{TIME} intrinsic
+@fnindex TIME
@cindex time, current
@cindex current time
GNU extension
@item @emph{Class}:
-Non-elemental function
+Function
@item @emph{Syntax}:
@code{RESULT = TIME()}
@node TIME8
@section @code{TIME8} --- Time function (64-bit)
-@cindex @code{TIME8} intrinsic
+@fnindex TIME8
@cindex time, current
@cindex current time
GNU extension
@item @emph{Class}:
-Non-elemental function
+Function
@item @emph{Syntax}:
@code{RESULT = TIME8()}
@node TINY
@section @code{TINY} --- Smallest positive number of a real kind
-@cindex @code{TINY} intrinsic
-@cindex tiny
+@fnindex TINY
+@cindex limits, smallest number
+@cindex model representation, smallest number
@table @asis
@item @emph{Description}:
in the model of the type of @code{X}.
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
-Elemental function
+Inquiry function
@item @emph{Syntax}:
@code{RESULT = TINY(X)}
+@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}, @ref{POPPAR}, @ref{POPCNT}
+@end table
+
+
+
@node TRANSFER
@section @code{TRANSFER} --- Transfer bit patterns
-@cindex @code{TRANSFER} intrinsic
-@cindex bit operations
-
-Intrinsic implemented, documentation pending.
+@fnindex TRANSFER
+@cindex bits, move
+@cindex type cast
@table @asis
@item @emph{Description}:
+Interprets the bitwise representation of @var{SOURCE} in memory as if it
+is the representation of a variable or array of the same type and type
+parameters as @var{MOLD}.
+
+This is approximately equivalent to the C concept of @emph{casting} one
+type to another.
+
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Transformational function
@item @emph{Syntax}:
+@code{RESULT = TRANSFER(SOURCE, MOLD[, SIZE])}
+
@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{SOURCE} @tab Shall be a scalar or an array of any type.
+@item @var{MOLD} @tab Shall be a scalar or an array of any type.
+@item @var{SIZE} @tab (Optional) shall be a scalar of type
+@code{INTEGER}.
+@end multitable
+
@item @emph{Return value}:
+The result has the same type as @var{MOLD}, with the bit level
+representation of @var{SOURCE}. If @var{SIZE} is present, the result is
+a one-dimensional array of length @var{SIZE}. If @var{SIZE} is absent
+but @var{MOLD} is an array (of any size or shape), the result is a one-
+dimensional array of the minimum length needed to contain the entirety
+of the bitwise representation of @var{SOURCE}. If @var{SIZE} is absent
+and @var{MOLD} is a scalar, the result is a scalar.
+
+If the bitwise representation of the result is longer than that of
+@var{SOURCE}, then the leading bits of the result correspond to those of
+@var{SOURCE} and any trailing bits are filled arbitrarily.
+
+When the resulting bit representation does not correspond to a valid
+representation of a variable of the same type as @var{MOLD}, the results
+are undefined, and subsequent operations on the result cannot be
+guaranteed to produce sensible behavior. For example, it is possible to
+create @code{LOGICAL} variables for which @code{@var{VAR}} and
+@code{.NOT.@var{VAR}} both appear to be true.
+
@item @emph{Example}:
-@item @emph{See also}:
+@smallexample
+PROGRAM test_transfer
+ integer :: x = 2143289344
+ print *, transfer(x, 1.0) ! prints "NaN" on i686
+END PROGRAM
+@end smallexample
@end table
@node TRANSPOSE
@section @code{TRANSPOSE} --- Transpose an array of rank two
-@cindex @code{TRANSPOSE} intrinsic
-@cindex matrix manipulation
-
-Intrinsic implemented, documentation pending.
+@fnindex TRANSPOSE
+@cindex array, transpose
+@cindex matrix, transpose
+@cindex transpose
@table @asis
@item @emph{Description}:
+Transpose an array of rank two. Element (i, j) of the result has the value
+@code{MATRIX(j, i)}, for all i, j.
+
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Transformational function
@item @emph{Syntax}:
+@code{RESULT = TRANSPOSE(MATRIX)}
+
@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{MATRIX} @tab Shall be an array of any type and have a rank of two.
+@end multitable
+
@item @emph{Return value}:
-@item @emph{Example}:
-@item @emph{See also}:
+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
@node TRIM
-@section @code{TRIM} --- Function to remove trailing blank characters of a string
-@cindex @code{TRIM} intrinsic
-@cindex string manipulation
-
-Intrinsic implemented, documentation pending.
+@section @code{TRIM} --- Remove trailing blank characters of a string
+@fnindex TRIM
+@cindex string, remove trailing whitespace
@table @asis
@item @emph{Description}:
+Removes trailing blank characters of a string.
+
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later
@item @emph{Class}:
Transformational function
@item @emph{Syntax}:
+@code{RESULT = TRIM(STRING)}
+
@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@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}
+less the number of trailing blanks.
+
@item @emph{Example}:
+@smallexample
+PROGRAM test_trim
+ CHARACTER(len=10), PARAMETER :: s = "GFORTRAN "
+ WRITE(*,*) LEN(s), LEN(TRIM(s)) ! "10 8", with/without trailing blanks
+END PROGRAM
+@end smallexample
+
@item @emph{See also}:
+@ref{ADJUSTL}, @ref{ADJUSTR}
@end table
@node TTYNAM
@section @code{TTYNAM} --- Get the name of a terminal device.
-@cindex @code{TTYNAM} intrinsic
+@fnindex TTYNAM
+@cindex system, terminal
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-Subroutine, non-elemental function
+Subroutine, function
@item @emph{Syntax}:
@multitable @columnfractions .80
@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}:
@node UBOUND
@section @code{UBOUND} --- Upper dimension bounds of an array
-@cindex @code{UBOUND} intrinsic
+@fnindex UBOUND
+@cindex array, upper bound
@table @asis
@item @emph{Description}:
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
the relevant dimension.
@item @emph{See also}:
-@ref{LBOUND}
+@ref{LBOUND}, @ref{LCOBOUND}
+@end table
+
+
+
+@node UCOBOUND
+@section @code{UCOBOUND} --- Upper codimension bounds of an array
+@fnindex UCOBOUND
+@cindex coarray, upper bound
+
+@table @asis
+@item @emph{Description}:
+Returns the upper cobounds of a coarray, or a single upper cobound
+along the @var{DIM} codimension.
+@item @emph{Standard}:
+Fortran 2008 and later
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@code{RESULT = UCOBOUND(COARRAY [, DIM [, KIND]])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@item @var{ARRAY} @tab Shall be an coarray, of any type.
+@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 cobounds of
+@var{COARRAY}. If @var{DIM} is present, the result is a scalar
+corresponding to the lower cobound of the array along that codimension.
+
+@item @emph{See also}:
+@ref{LCOBOUND}, @ref{LBOUND}
@end table
@node UMASK
@section @code{UMASK} --- Set the file creation mask
-@cindex @code{UMASK} intrinsic
-@cindex file system operations
+@fnindex UMASK
+@cindex file system, file creation mask
@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])}
+@multitable @columnfractions .80
+@item @code{CALL UMASK(MASK [, OLD])}
+@item @code{OLD = UMASK(MASK)}
+@end multitable
@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
@node UNLINK
@section @code{UNLINK} --- Remove a file from the file system
-@cindex @code{UNLINK} intrinsic
-@cindex file system operations
+@fnindex UNLINK
+@cindex file system, remove file
@table @asis
@item @emph{Description}:
GNU extension
@item @emph{Class}:
-Subroutine, non-elemental function
+Subroutine, function
@item @emph{Syntax}:
@multitable @columnfractions .80
@node UNPACK
@section @code{UNPACK} --- Unpack an array of rank one into an array
-@cindex @code{UNPACK} intrinsic
-@cindex array manipulation
-
-Intrinsic implemented, documentation pending.
+@fnindex UNPACK
+@cindex array, unpacking
+@cindex array, increase dimension
+@cindex array, scatter elements
@table @asis
@item @emph{Description}:
+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 @emph{Syntax}:
+@code{RESULT = UNPACK(VECTOR, MASK, FIELD)}
+
@item @emph{Arguments}:
+@multitable @columnfractions .15 .70
+@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 same type as @var{VECTOR} and have
+the same shape as @var{MASK}.
+@end multitable
+
@item @emph{Return value}:
+The resulting array corresponds to @var{FIELD} with @code{TRUE} elements
+of @var{MASK} replaced by values from @var{VECTOR} in array element order.
+
@item @emph{Example}:
+@smallexample
+PROGRAM test_unpack
+ integer :: vector(2) = (/1,1/)
+ logical :: mask(4) = (/ .TRUE., .FALSE., .FALSE., .TRUE. /)
+ integer :: field(2,2) = 0, unity(2,2)
+
+ ! result: unity matrix
+ unity = unpack(vector, reshape(mask, (/2,2/)), field)
+END PROGRAM
+@end smallexample
@item @emph{See also}:
-@ref{PACK}
+@ref{PACK}, @ref{SPREAD}
@end table
@node VERIFY
@section @code{VERIFY} --- Scan a string for the absence of a set of characters
-@cindex @code{VERIFY} intrinsic
-@cindex string manipulation
-
-Intrinsic implemented, documentation pending.
+@fnindex VERIFY
+@cindex string, find missing set
@table @asis
@item @emph{Description}:
+Verifies that all the characters in a @var{SET} are present in a @var{STRING}.
+
+If @var{BACK} is either absent or equals @code{FALSE}, this function
+returns the position of the leftmost character of @var{STRING} that is
+not in @var{SET}. If @var{BACK} equals @code{TRUE}, the rightmost position
+is returned. If all characters of @var{SET} are found in @var{STRING}, the
+result is zero.
+
@item @emph{Standard}:
-F95 and later
+Fortran 95 and later, with @var{KIND} argument Fortran 2003 and later
@item @emph{Class}:
Elemental function
@item @emph{Syntax}:
+@code{RESULT = 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{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 kind @var{KIND}. If
+@var{KIND} is absent, the return value is of default integer kind.
+
@item @emph{Example}:
-@item @emph{Specific names}:
+@smallexample
+PROGRAM test_verify
+ WRITE(*,*) VERIFY("FORTRAN", "AO") ! 1, found 'F'
+ WRITE(*,*) VERIFY("FORTRAN", "FOO") ! 3, found 'R'
+ WRITE(*,*) VERIFY("FORTRAN", "C++") ! 1, found 'F'
+ WRITE(*,*) VERIFY("FORTRAN", "C++", .TRUE.) ! 7, found 'N'
+ WRITE(*,*) VERIFY("FORTRAN", "FORTRAN") ! 0' found none
+END PROGRAM
+@end smallexample
+
@item @emph{See also}:
+@ref{SCAN}, @ref{INDEX intrinsic}
@end table
@node XOR
@section @code{XOR} --- Bitwise logical exclusive OR
-@cindex @code{XOR} intrinsic
-@cindex bit operations
+@fnindex XOR
+@cindex bitwise logical exclusive or
+@cindex logical exclusive or, bitwise
@table @asis
@item @emph{Description}:
This intrinsic routine is provided for backwards compatibility with
GNU Fortran 77. For integer arguments, programmers should consider
-the use of the @ref{IEOR} intrinsic defined by the Fortran standard.
+the use of the @ref{IEOR} intrinsic and for logical arguments the
+@code{.NEQV.} operator, which are both defined by the Fortran standard.
@item @emph{Standard}:
GNU extension
@item @emph{Class}:
-Non-elemental function
+Function
@item @emph{Syntax}:
-@code{RESULT = XOR(X, Y)}
+@code{RESULT = XOR(I, J)}
@item @emph{Arguments}:
@multitable @columnfractions .15 .70
-@item @var{X} @tab The type shall be either @code{INTEGER(*)} or @code{LOGICAL}.
-@item @var{Y} @tab The type shall be either @code{INTEGER(*)} or @code{LOGICAL}.
+@item @var{I} @tab The type shall be either a scalar @code{INTEGER}
+type or a scalar @code{LOGICAL} type.
+@item @var{J} @tab The type shall be the same as the type of @var{I}.
@end multitable
@item @emph{Return value}:
-The return type is either @code{INTEGER(*)} or @code{LOGICAL}
-after cross-promotion of the arguments.
+The return type is either a scalar @code{INTEGER} or a scalar
+@code{LOGICAL}. If the kind type parameters differ, then the
+smaller kind type is implicitly converted to larger kind, and the
+return has the larger kind.
@item @emph{Example}:
@smallexample
PROGRAM test_xor
LOGICAL :: T = .TRUE., F = .FALSE.
INTEGER :: a, b
- DATA a / Z,'F' /, b / Z'3' /
+ DATA a / Z'F' /, b / Z'3' /
WRITE (*,*) XOR(T, T), XOR(T, F), XOR(F, T), XOR(F, F)
WRITE (*,*) XOR(a, b)
@end 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, except when otherwise noted
+@end table
+
+The @code{ISO_FORTRAN_ENV} module provides the following scalar default-integer
+named constants:
+
+@table @asis
+@item @code{ATOMIC_INT_KIND}:
+Default-kind integer constant to be used as kind parameter when defining
+integer variables used in atomic operations. (Fortran 2008 or later.)
+
+@item @code{ATOMIC_LOGICAL_KIND}:
+Default-kind integer constant to be used as kind parameter when defining
+logical variables used in atomic operations. (Fortran 2008 or later.)
+
+@item @code{CHARACTER_KINDS}:
+Default-kind integer constant array of rank one containing the supported kind
+parameters of the @code{CHARACTER} type. (Fortran 2008 or later.)
+
+@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. (Fortran 2008 or later.)
+
+@item @code{INTEGER_KINDS}:
+Default-kind integer constant array of rank one containing the supported kind
+parameters of the @code{INTEGER} type. (Fortran 2008 or later.)
+
+@item @code{IOSTAT_END}:
+The value assigned to the variable passed to the @code{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 @code{IOSTAT=} specifier of
+an input/output statement if an end-of-record condition occurred.
+
+@item @code{IOSTAT_INQUIRE_INTERNAL_UNIT}:
+Scalar default-integer constant, used by @code{INQUIRE} for the
+@code{IOSTAT=} specifier to denote an that a unit number identifies an
+internal unit. (Fortran 2008 or later.)
+
+@item @code{NUMERIC_STORAGE_SIZE}:
+The size in bits of the numeric storage unit.
+
+@item @code{LOGICAL_KINDS}:
+Default-kind integer constant array of rank one containing the supported kind
+parameters of the @code{LOGICAL} type. (Fortran 2008 or later.)
+
+@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. (Fortran 2008 or later.)
+
+@item @code{REAL_KINDS}:
+Default-kind integer constant array of rank one containing the supported kind
+parameters of the @code{REAL} type. (Fortran 2008 or later.)
+
+@item @code{STAT_LOCKED}:
+Scalar default-integer constant used as STAT= return value by @code{LOCK} to
+denote that the lock variable is locked by the executing image. (Fortran 2008
+or later.)
+
+@item @code{STAT_LOCKED_OTHER_IMAGE}:
+Scalar default-integer constant used as STAT= return value by @code{UNLOCK} to
+denote that the lock variable is locked by another image. (Fortran 2008 or
+later.)
+
+@item @code{STAT_STOPPED_IMAGE}:
+Positive, scalar default-integer constant used as STAT= return value if the
+argument in the statement requires synchronisation with an image, which has
+initiated the termination of the execution. (Fortran 2008 or later.)
+
+@item @code{STAT_UNLOCKED}:
+Scalar default-integer constant used as STAT= return value by @code{UNLOCK} to
+denote that the lock variable is unlocked. (Fortran 2008 or later.)
+@end table
+
+The module also provides the following intrinsic procedures:
+@ref{COMPILER_OPTIONS} and @ref{COMPILER_VERSION}.
+
+
+
+@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}
+@item @code{C_SIZEOF}
+@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 parameters of type @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
+
+Moreover, the following two named constants are defined:
+
+@multitable @columnfractions .20 .80
+@item Name @tab Type
+@item @code{C_NULL_PTR} @tab @code{C_PTR}
+@item @code{C_NULL_FUNPTR} @tab @code{C_FUNPTR}
+@end multitable
+
+Both are equivalent to the value @code{NULL} in C.
+
+@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 modules 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
+
+@code{OMP_LIB} provides the scalar default-integer
+named constant @code{openmp_version} with a value of the form
+@var{yyyymm}, where @code{yyyy} is the year and @var{mm} the month
+of the OpenMP version; for OpenMP v3.0 the value is @code{200805}.
+
+And the following scalar integer named constants of the
+kind @code{omp_sched_kind}:
+
+@table @asis
+@item @code{omp_sched_static}
+@item @code{omp_sched_dynamic}
+@item @code{omp_sched_guided}
+@item @code{omp_sched_auto}
+@end table
OSDN Git Service
