@ignore
-Copyright (C) 2005
+Copyright (C) 2005, 2006
Free Software Foundation, Inc.
-This is part of the GFORTRAN manual.
+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
@end ignore
+@tex
+\gdef\acos{\mathop{\rm acos}\nolimits}
+\gdef\asin{\mathop{\rm asin}\nolimits}
+\gdef\atan{\mathop{\rm atan}\nolimits}
+\gdef\acosh{\mathop{\rm acosh}\nolimits}
+\gdef\asinh{\mathop{\rm asinh}\nolimits}
+\gdef\atanh{\mathop{\rm atanh}\nolimits}
+@end tex
+
+
@node Intrinsic Procedures
@chapter Intrinsic Procedures
@cindex Intrinsic Procedures
This portion of the document is incomplete and undergoing massive expansion
and editing. All contributions and corrections are strongly encouraged.
+Implemented intrinsics are fully functional and available to the user to apply.
+Some intrinsics have documentation yet to be completed as indicated by 'documentation pending'.
+
+@comment Missing intrinsics (double check with #19292)
+@comment - MClock
+@comment - Short
+
@menu
-* Introduction: Introduction
-* @code{ABORT}: ABORT, Abort the program
-* @code{ABS}: ABS, Absolute value
-* @code{ACHAR}: ACHAR, Character in @acronym{ASCII} collating sequence
-* @code{ACOS}: ACOS, Arccosine function
-* @code{ADJUSTL}: ADJUSTL, Left adjust a string
-* @code{ADJUSTR}: ADJUSTR, Right adjust a string
+* Introduction: Introduction
+* @code{ABORT}: ABORT, Abort the program
+* @code{ABS}: ABS, Absolute value
+* @code{ACCESS}: ACCESS, Checks file access method
+* @code{ACHAR}: ACHAR, Character in @acronym{ASCII} collating sequence
+* @code{ACOS}: ACOS, Arccosine function
+* @code{ACOSH}: ACOSH, Hyperbolic arccosine function
+* @code{ADJUSTL}: ADJUSTL, Left adjust a string
+* @code{ADJUSTR}: ADJUSTR, Right adjust a string
+* @code{AIMAG}: AIMAG, Imaginary part of complex number
+* @code{AINT}: AINT, Truncate to a whole number
+* @code{ALARM}: ALARM, Set an alarm clock
+* @code{ALL}: ALL, Determine if all values are true
+* @code{ALLOCATED}: ALLOCATED, Status of allocatable entity
+* @code{AND}: AND, Bitwise logical AND
+* @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{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{BIT_SIZE}: BIT_SIZE, Bit size inquiry function
+* @code{BTEST}: BTEST, Bit test function
+* @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{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{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{DOT_PRODUCT}: DOT_PRODUCT, Dot product function
+* @code{DPROD}: DPROD, Double product function
+* @code{DREAL}: DREAL, Double real part function
+* @code{DTIME}: DTIME, Execution time subroutine (or function)
+* @code{EOSHIFT}: EOSHIFT, End-off shift function
+* @code{EPSILON}: EPSILON, Epsilon function
+* @code{ERF}: ERF, Error function
+* @code{ERFC}: ERFC, Complementary error function
+* @code{ETIME}: ETIME, Execution time subroutine (or function)
+* @code{EXIT}: EXIT, Exit the program with status.
+* @code{EXP}: EXP, Exponential function
+* @code{EXPONENT}: EXPONENT, Exponent function
+* @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{FPUT}: FPUT, Write a single character in stream mode to stdout
+* @code{FPUTC}: FPUTC, Write a single character in stream mode
+* @code{FRACTION}: FRACTION, Fractional part of the model representation
+* @code{FREE}: FREE, Memory de-allocation subroutine
+* @code{FSEEK}: FSEEK, Low level file positioning subroutine
+* @code{FSTAT}: FSTAT, Get file status
+* @code{FTELL}: FTELL, Current stream position
+* @code{GETARG}: GETARG, Get command line arguments
+* @code{GET_COMMAND}: GET_COMMAND, Get the entire command line
+* @code{GET_COMMAND_ARGUMENT}: GET_COMMAND_ARGUMENT, Get command line arguments
+* @code{GETCWD}: GETCWD, Get current working directory
+* @code{GETENV}: GETENV, Get an environmental variable
+* @code{GET_ENVIRONMENT_VARIABLE}: GET_ENVIRONMENT_VARIABLE, Get an environmental variable
+* @code{GETGID}: GETGID, Group ID function
+* @code{GETLOG}: GETLOG, Get login name
+* @code{GETPID}: GETPID, Process ID function
+* @code{GETUID}: GETUID, User ID function
+* @code{GMTIME}: GMTIME, Convert time to GMT info
+* @code{HOSTNM}: HOSTNM, Get system host name
+* @code{HUGE}: HUGE, Largest number of a kind
+* @code{IACHAR}: IACHAR, Code in @acronym{ASCII} collating sequence
+* @code{IAND}: IAND, Bitwise logical and
+* @code{IARGC}: IARGC, Get the number of command line arguments
+* @code{IBCLR}: IBCLR, Clear bit
+* @code{IBITS}: IBITS, Bit extraction
+* @code{IBSET}: IBSET, Set bit
+* @code{ICHAR}: ICHAR, Character-to-integer conversion function
+* @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{INT}: INT, Convert to integer type
+* @code{IOR}: IOR, Bitwise logical or
+* @code{IRAND}: IRAND, Integer pseudo-random number
+* @code{ISHFT}: ISHFT, Shift bits
+* @code{ISHFTC}: ISHFTC, Shift bits circularly
+* @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{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{LGT}: LGT, Lexical greater than
+* @code{LINK}: LINK, Create a hard link
+* @code{LLE}: LLE, Lexical less than or equal
+* @code{LLT}: LLT, Lexical less than
+* @code{LNBLNK}: LNBLNK, Index of the last non-blank character in a string
+* @code{LOC}: LOC, Returns the address of a variable
+* @code{LOG}: LOG, Logarithm function
+* @code{LOG10}: LOG10, Base 10 logarithm function
+* @code{LOGICAL}: LOGICAL, Convert to logical 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{MATMUL}: MATMUL, matrix multiplication
+* @code{MAX}: MAX, Maximum value of an argument list
+* @code{MAXEXPONENT}: MAXEXPONENT, Maximum exponent of a real kind
+* @code{MAXLOC}: MAXLOC, Location of the maximum value within an array
+* @code{MAXVAL}: MAXVAL, Maximum value of an array
+* @code{MERGE}: MERGE, Merge arrays
+* @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{MINVAL}: MINVAL, Minimum value of an array
+* @code{MOD}: MOD, Remainder function
+* @code{MODULO}: MODULO, Modulo function
+* @code{MOVE_ALLOC}: MOVE_ALLOC, Move allocation from one object to another
+* @code{MVBITS}: MVBITS, Move bits from one integer to another
+* @code{NEAREST}: NEAREST, Nearest representable number
+* @code{NEW_LINE}: NEW_LINE, New line character
+* @code{NINT}: NINT, Nearest whole number
+* @code{NOT}: NOT, Logical negation
+* @code{NULL}: NULL, Function that returns an disassociated pointer
+* @code{OR}: OR, Bitwise logical OR
+* @code{PACK}: PACK, Pack an array into an array of rank one
+* @code{PERROR}: PERROR, Print system error message
+* @code{PRECISION}: PRECISION, Decimal precision of a real kind
+* @code{PRESENT}: PRESENT, Determine whether an optional 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{RAN}: RAN, Real pseudo-random number
+* @code{REAL}: REAL, Convert to real type
+* @code{RENAME}: RENAME, Rename a file
+* @code{REPEAT}: REPEAT, Repeated string concatenation
+* @code{RESHAPE}: RESHAPE, Function to reshape an array
+* @code{RRSPACING}: RRSPACING, Reciprocal of the relative spacing
+* @code{RSHIFT}: RSHIFT, Right shift bits
+* @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
+@comment * @code{SECOND}: SECOND, (?)
+@comment * @code{SECONDS}: SECONDS, (?)
+* @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{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{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{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{TIME}: TIME, Time function
+* @code{TINY}: TINY, Smallest positive number of a real kind
+* @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{UBOUND}: UBOUND, Upper dimension bounds of an array
+* @code{UMASK}: UMASK, Set the file creation mask
+* @code{UNLINK}: UNLINK, Remove a file from the file system
+* @code{UNMASK}: UNMASK, (?)
+* @code{UNPACK}: UNPACK, Unpack an array of rank one into an array
+* @code{VERIFY}: VERIFY, Scan a string for the absence of a set of characters
+* @code{XOR}: XOR, Bitwise logical exclusive or
@end menu
@node Introduction
@section Introduction to intrinsic procedures
-Gfortran provides a rich set of intrinsic procedures that includes all
+GNU Fortran provides a rich set of intrinsic procedures that includes all
the intrinsic procedures required by the Fortran 95 standard, a set of
intrinsic procedures for backwards compatibility with Gnu Fortran 77
(i.e., @command{g77}), and a small selection of intrinsic procedures
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. Gfortran defines the default integer type and
+the Fortran 95 standard. GNU Fortran defines the default integer type and
default real type by @code{INTEGER(KIND=4)} and @code{REAL(KIND=4)},
respectively. The standard mandates that both data types shall have
another kind, which have more precision. On typical target architectures
-supports by @command{gfortran}, this kind type parameter is @code{KIND=8}.
+supported by @command{gfortran}, this kind type parameter is @code{KIND=8}.
Hence, @code{REAL(KIND=8)} and @code{DOUBLE PRECISION} are equivalent.
In the description of generic intrinsic procedures, the kind type parameter
will be specified by @code{KIND=*}, and in the description of specific
This document follows the convention used in the Fortran 95 standard,
and denotes such arguments by square brackets.
-@command{Gfortran} offers the @option{-std=f95} and @option{-std=gnu} options,
+GNU Fortran offers the @option{-std=f95} and @option{-std=gnu} options,
which can be used to restrict the set of intrinsic procedures to a
given standard. By default, @command{gfortran} sets the @option{-std=gnu}
-option, and so all intrinsic procedures describe here are accepted. There
+option, and so all intrinsic procedures described here are accepted. There
is one caveat. For a select group of intrinsic procedures, @command{g77}
implemented both a function and a subroutine. Both classes
have been implemented in @command{gfortran} for backwards compatibility
@node ABORT
@section @code{ABORT} --- Abort the program
-@findex @code{ABORT}
+@findex @code{ABORT} intrinsic
@cindex abort
@table @asis
systems that support a core dump, @code{ABORT} will produce a core dump,
which is suitable for debugging purposes.
-@item @emph{Option}:
-gnu
+@item @emph{Standard}:
+GNU extension
-@item @emph{Type}:
+@item @emph{Class}:
non-elemental subroutine
@item @emph{Syntax}:
if (i /= j) call abort
end program test_abort
@end smallexample
+
+@item @emph{See also}:
+@ref{EXIT}, @ref{KILL}
+
@end table
@item @emph{Description}:
@code{ABS(X)} computes the absolute value of @code{X}.
-@item @emph{Option}:
-f95, gnu
+@item @emph{Standard}:
+F77 and later, has overloads that are GNU extensions
-@item @emph{Type}:
-elemental function
+@item @emph{Class}:
+Elemental function
@item @emph{Syntax}:
@code{X = ABS(X)}
@item @emph{Example}:
@smallexample
-program test_abort
+program test_abs
integer :: i = -1
real :: x = -1.e0
complex :: z = (-1.e0,0.e0)
i = abs(i)
x = abs(x)
x = abs(z)
-end program test_abort
+end program test_abs
@end smallexample
@item @emph{Specific names}:
-@multitable @columnfractions .24 .24 .24 .24
-@item Name @tab Argument @tab Return type @tab Option
-@item @code{CABS(Z)} @tab @code{COMPLEX(4) Z} @tab @code{REAL(4)} @tab f95, gnu
-@item @code{DABS(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab f95, gnu
-@item @code{IABS(I)} @tab @code{INTEGER(4) I} @tab @code{INTEGER(4)} @tab f95, gnu
-@item @code{ZABS(Z)} @tab @code{COMPLEX(8) Z} @tab @code{COMPLEX(8)} @tab gnu
-@item @code{CDABS(Z)} @tab @code{COMPLEX(8) Z} @tab @code{COMPLEX(8)} @tab gnu
+@multitable @columnfractions .20 .20 .20 .40
+@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
@end multitable
@end table
+@node ACCESS
+@section @code{ACCESS} --- Checks file access method
+@findex @code{ACCESS}
+@cindex file system functions
+
+Not yet implemented in GNU Fortran.
+
+@table @asis
+@item @emph{Description}:
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+@item @emph{See also}:
+
+@end table
+
@node ACHAR
@section @code{ACHAR} --- Character in @acronym{ASCII} collating sequence
@code{ACHAR(I)} returns the character located at position @code{I}
in the @acronym{ASCII} collating sequence.
-@item @emph{Option}:
-f95, gnu
+@item @emph{Standard}:
+F77 and later
-@item @emph{Type}:
-elemental function
+@item @emph{Class}:
+Elemental function
@item @emph{Syntax}:
@code{C = ACHAR(I)}
@item @emph{Arguments}:
@multitable @columnfractions .15 .80
-@item @var{I} @tab The type shall be an @code{INTEGER(*)}.
+@item @var{I} @tab The type shall be @code{INTEGER(*)}.
@end multitable
@item @emph{Return value}:
program test_achar
character c
c = achar(32)
-end program test_abort
+end program test_achar
@end smallexample
@end table
@section @code{ACOS} --- Arccosine function
@findex @code{ACOS} intrinsic
@findex @code{DACOS} intrinsic
-@cindex arccosine
+@cindex trigonometric functions (inverse)
@table @asis
@item @emph{Description}:
-@code{ACOS(X)} computes the arccosine of its @var{X}.
+@code{ACOS(X)} computes the arccosine of @var{X} (inverse of @code{COS(X)}).
-@item @emph{Option}:
-f95, gnu
+@item @emph{Standard}:
+F77 and later
-@item @emph{Type}:
-elemental function
+@item @emph{Class}:
+Elemental function
@item @emph{Syntax}:
@code{X = ACOS(X)}
@item @emph{Arguments}:
@multitable @columnfractions .15 .80
-@item @var{X} @tab The type shall be an @code{REAL(*)}.
+@item @var{X} @tab The type shall be @code{REAL(*)} with a magnitude that is
+less than one.
@end multitable
@item @emph{Return value}:
The return value is of type @code{REAL(*)} and it lies in the
-range @math{ 0 \leq \arccos (x) \leq \pi}.
+range @math{ 0 \leq \acos(x) \leq \pi}. The kind type parameter
+is the same as @var{X}.
@item @emph{Example}:
@smallexample
program test_acos
real(8) :: x = 0.866_8
- x = achar(x)
+ x = acos(x)
end program test_acos
@end smallexample
@item @emph{Specific names}:
-@multitable @columnfractions .24 .24 .24 .24
-@item Name @tab Argument @tab Return type @tab Option
-@item @code{DACOS(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab f95, gnu
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@end multitable
+
+@item @emph{See also}:
+Inverse function: @ref{COS}
+
+@end table
+
+
+@node ACOSH
+@section @code{ACOSH} --- Hyperbolic arccosine function
+@findex @code{ACOSH} intrinsic
+@cindex hyperbolic arccosine
+@cindex hyperbolic cosine (inverse)
+
+@table @asis
+@item @emph{Description}:
+@code{ACOSH(X)} computes the area hyperbolic cosine of @var{X} (inverse of @code{COSH(X)}).
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = ACOSH(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type shall be @code{REAL(*)} with a magnitude that is
+greater or equal to one.
@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{REAL(*)} and it lies in the
+range @math{0 \leq \acosh (x) \leq \infty}.
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_acosh
+ REAL(8), DIMENSION(3) :: x = (/ 1.0, 2.0, 3.0 /)
+ WRITE (*,*) ACOSH(x)
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+Inverse function: @ref{COSH}
@end table
@code{ADJUSTL(STR)} will left adjust a string by removing leading spaces.
Spaces are inserted at the end of the string as needed.
-@item @emph{Option}:
-f95, gnu
+@item @emph{Standard}:
+F95 and later
-@item @emph{Type}:
-elemental function
+@item @emph{Class}:
+Elemental function
@item @emph{Syntax}:
@code{STR = ADJUSTL(STR)}
@end table
+
@node ADJUSTR
@section @code{ADJUSTR} --- Right adjust a string
@findex @code{ADJUSTR} intrinsic
@code{ADJUSTR(STR)} will right adjust a string by removing trailing spaces.
Spaces are inserted at the start of the string as needed.
-@item @emph{Option}:
-f95, gnu
+@item @emph{Standard}:
+F95 and later
-@item @emph{Type}:
-elemental function
+@item @emph{Class}:
+Elemental function
@item @emph{Syntax}:
@code{STR = ADJUSTR(STR)}
-@comment gen aimag
-@comment dimag
-@comment
-@comment gen aint
-@comment dint
-@comment
-@comment gen all
-@comment
-@comment gen allocated
-@comment
-@comment gen anint
-@comment dnint
-@comment
-@comment gen any
-@comment
-@comment gen asin
-@comment dasin
-@comment
-@comment gen associated
-@comment
-@comment gen atan
-@comment datan
-@comment
-@comment gen atan2
-@comment datan2
-@comment
-@comment gen besj0
-@comment dbesj0
-@comment
-@comment gen besj1
-@comment dbesj1
-@comment
-@comment gen besjn
-@comment dbesjn
-@comment
-@comment gen besy0
-@comment dbesy0
-@comment
-@comment gen besy1
-@comment dbesy1
-@comment
-@comment gen besyn
-@comment dbesyn
-@comment
-@comment gen bit_size
-@comment
-@comment gen btest
-@comment
-@comment gen ceiling
-@comment
-@comment gen char
-@comment
-@comment gen cmplx
-@comment
-@comment gen command_argument_count
-@comment
-@comment gen conjg
-@comment dconjg
-@comment
-@comment gen cos
-@comment dcos
-@comment ccos
-@comment zcos,cdcos
-@comment
-@comment gen cosh
-@comment dcosh
-@comment
-@comment gen count
-@comment
-@comment sub cpu_time
-@comment
-@comment gen cshift
-@comment
-@comment sub date_and_time
-@comment
-@comment gen dble
-@comment dfloat
-@comment
-@comment gen dcmplx
-@comment
-@comment gen digits
-@comment
-@comment gen dim
-@comment idim
-@comment ddim
-@comment
-@comment gen dot_product
-@comment
-@comment gen dprod
-@comment
-@comment gen dreal
-@comment
-@comment sub dtime
-@comment
-@comment gen eoshift
-@comment
-@comment gen epsilon
-@comment
-@comment gen erf
-@comment derf
-@comment
-@comment gen erfc
-@comment derfc
-@comment
-@comment gen etime
-@comment sub etime
-@comment
-@comment sub exit
-@comment
-@comment gen exp
-@comment dexp
-@comment cexp
-@comment zexp,cdexp
-@comment
-@comment gen exponent
-@comment
-@comment gen floor
-@comment
-@comment sub flush
-@comment
-@comment gen fnum
-@comment
-@comment gen fraction
-@comment
-@comment gen fstat
-@comment sub fstat
-@comment
-@comment sub getarg
-@comment
-@comment gen getcwd
-@comment sub getcwd
-@comment
-@comment sub getenv
-@comment
-@comment gen getgid
-@comment
-@comment gen getpid
-@comment
-@comment gen getuid
-@comment
-@comment sub get_command
-@comment
-@comment sub get_command_argument
-@comment
-@comment sub get_environment_variable
-@comment
-@comment gen huge
-@comment
-@comment gen iachar
-@comment
-@comment gen iand
-@comment
-@comment gen iargc
-@comment
-@comment gen ibclr
-@comment
-@comment gen ibits
-@comment
-@comment gen ibset
-@comment
-@comment gen ichar
-@comment
-@comment gen ieor
-@comment
-@comment gen index
-@comment
-@comment gen int
-@comment ifix
-@comment idint
-@comment
-@comment gen ior
-@comment
-@comment gen irand
-@comment
-@comment gen ishft
-@comment
-@comment gen ishftc
-@comment
-@comment gen kind
-@comment
-@comment gen lbound
-@comment
-@comment gen len
-@comment
-@comment gen len_trim
-@comment
-@comment gen lge
-@comment
-@comment gen lgt
-@comment
-@comment gen lle
-@comment
-@comment gen llt
-@comment
-@comment gen log
-@comment alog
-@comment dlog
-@comment clog
-@comment zlog, cdlog
-@comment
-@comment gen log10
-@comment alog10
-@comment dlog10
-@comment
-@comment gen logical
-@comment
-@comment gen matmul
-@comment
-@comment gen max
-@comment max0
-@comment amax0
-@comment amax1
-@comment max1
-@comment dmax1
-@comment
-@comment gen maxexponent
-@comment
-@comment gen maxloc
-@comment
-@comment gen maxval
-@comment
-@comment gen merge
-@comment
-@comment gen min
-@comment min0
-@comment amin0
-@comment amin1
-@comment min1
-@comment dmin1
-@comment
-@comment gen minexponent
-@comment
-@comment gen minloc
-@comment
-@comment gen minval
-@comment
-@comment gen mod
-@comment amod
-@comment dmod
-@comment
-@comment gen modulo
-@comment
-@comment sub mvbits
-@comment
-@comment gen nearest
-@comment
-@comment gen nint
-@comment idnint
-@comment
-@comment gen not
-@comment
-@comment gen null
-@comment
-@comment gen pack
-@comment
-@comment gen precision
-@comment
-@comment gen present
-@comment
-@comment gen product
-@comment
-@comment gen radix
-@comment
-@comment gen rand
-@comment ran
-@comment
-@comment sub random_number
-@comment
-@comment sub random_seed
-@comment
-@comment gen range
-@comment
-@comment gen real
-@comment float
-@comment sngl
-@comment
-@comment gen repeat
-@comment
-@comment gen reshape
-@comment
-@comment gen rrspacing
-@comment
-@comment gen scale
-@comment
-@comment gen scan
-@comment
-@comment gen second
-@comment sub second
-@comment
-@comment gen selected_int_kind
-@comment
-@comment gen selected_real_kind
-@comment
-@comment gen set_exponent
-@comment
-@comment gen shape
-@comment
-@comment gen sign
-@comment isign
-@comment dsign
-@comment
-@comment gen sin
-@comment dsin
-@comment csin
-@comment zsin,cdsin
-@comment
-@comment gen sinh
-@comment dsinh
-@comment
-@comment gen size
-@comment
-@comment gen spacing
-@comment
-@comment gen spread
-@comment
-@comment gen sqrt
-@comment dsqrt
-@comment csqrt
-@comment zsqrt,cdsqrt
-@comment
-@comment sub srand
-@comment
-@comment gen stat
-@comment sub stat
-@comment
-@comment gen sum
-@comment
-@comment gen system
-@comment sub system
-@comment
-@comment sub system_clock
-@comment
-@comment gen tan
-@comment dtan
-@comment
-@comment gen tanh
-@comment dtanh
-@comment
-@comment gen tiny
-@comment
-@comment gen transfer
-@comment
-@comment gen transpose
-@comment
-@comment gen trim
-@comment
-@comment gen ubound
-@comment
-@comment gen umask
-@comment sub umask
-@comment
-@comment gen unlink
-@comment sub unlink
-@comment
-@comment gen unpack
-@comment
-@comment gen verify
-
-
+@node AIMAG
+@section @code{AIMAG} --- Imaginary part of complex number
+@findex @code{AIMAG} intrinsic
+@findex @code{DIMAG} intrinsic
+@findex @code{IMAG} intrinsic
+@findex @code{IMAGPART} intrinsic
+@cindex Imaginary part
+
+@table @asis
+@item @emph{Description}:
+@code{AIMAG(Z)} yields the imaginary part of complex argument @code{Z}.
+The @code{IMAG(Z)} and @code{IMAGPART(Z)} intrinsic functions are provided
+for compatibility with @command{g77}, and their use in new code is
+strongly discouraged.
+
+@item @emph{Standard}:
+F77 and later, has overloads that are GNU extensions
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = AIMAG(Z)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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
+kind type parameter of the argument.
+
+@item @emph{Example}:
+@smallexample
+program test_aimag
+ complex(4) z4
+ complex(8) z8
+ z4 = cmplx(1.e0_4, 0.e0_4)
+ z8 = cmplx(0.e0_8, 1.e0_8)
+ print *, aimag(z4), dimag(z8)
+end program test_aimag
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@end multitable
+@end table
+
+
+
+@node AINT
+@section @code{AINT} --- Truncate to a whole number
+@findex @code{AINT} intrinsic
+@findex @code{DINT} intrinsic
+@cindex whole number
+
+@table @asis
+@item @emph{Description}:
+@code{AINT(X [, KIND])} truncates its argument to a whole number.
+
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = AINT(X)}
+@code{X = AINT(X, KIND)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type of the argument shall be @code{REAL(*)}.
+@item @var{KIND} @tab (Optional) @var{KIND} shall be a scalar integer
+initialization expression.
+@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 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
+whole number that does not exceed its magnitude. The sign is the same
+as the sign of @var{X}.
+
+@item @emph{Example}:
+@smallexample
+program test_aint
+ real(4) x4
+ real(8) x8
+ x4 = 1.234E0_4
+ x8 = 4.321_8
+ print *, aint(x4), dint(x8)
+ x8 = aint(x4,8)
+end program test_aint
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@end multitable
+@end table
+
+
+
+@node ALARM
+@section @code{ALARM} --- Execute a routine after a given delay
+@findex @code{ALARM} intrinsic
+
+@table @asis
+@item @emph{Description}:
+@code{ALARM(SECONDS, HANDLER [, STATUS])} causes external subroutine @var{HANDLER}
+to be executed after a delay of @var{SECONDS} by using @code{alarm(1)} to
+set up a signal and @code{signal(2)} to catch it. If @var{STATUS} is
+supplied, it will be returned with the number of seconds remaining until
+any previously scheduled alarm was due to be delivered, or zero if there
+was no previously scheduled alarm.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@code{CALL ALARM(SECONDS, HANDLER)}
+@code{CALL ALARM(SECONDS, HANDLER, STATUS)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{SECONDS} @tab The type of the argument shall be a scalar
+@code{INTEGER}. It is @code{INTENT(IN)}.
+@item @var{HANDLER} @tab Signal handler (@code{INTEGER FUNCTION} or
+@code{SUBROUTINE}) or dummy/global @code{INTEGER} scalar.
+@code{INTEGER}. It is @code{INTENT(IN)}.
+@item @var{STATUS} @tab (Optional) @var{STATUS} shall be a scalar
+@code{INTEGER} variable. It is @code{INTENT(OUT)}.
+@end multitable
+
+@item @emph{Example}:
+@smallexample
+program test_alarm
+ external handler_print
+ integer i
+ call alarm (3, handler_print, i)
+ print *, i
+ call sleep(10)
+end program test_alarm
+@end smallexample
+This will cause the external routine @var{handler_print} to be called
+after 3 seconds.
+@end table
+
+
+
+@node ALL
+@section @code{ALL} --- All values in @var{MASK} along @var{DIM} are true
+@findex @code{ALL} intrinsic
+@cindex true values
+
+@table @asis
+@item @emph{Description}:
+@code{ALL(MASK [, DIM])} determines if all the values are true in @var{MASK}
+in the array along dimension @var{DIM}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+transformational function
+
+@item @emph{Syntax}:
+@code{L = ALL(MASK)}
+@code{L = ALL(MASK, DIM)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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
+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
+the shape of @var{MASK} where the @var{DIM} dimension is elided.
+
+@table @asis
+@item (A)
+@code{ALL(MASK)} is true if all elements of @var{MASK} are true.
+It also is true if @var{MASK} has zero size; otherwise, it is false.
+@item (B)
+If the rank of @var{MASK} is one, then @code{ALL(MASK,DIM)} is equivalent
+to @code{ALL(MASK)}. If the rank is greater than one, then @code{ALL(MASK,DIM)}
+is determined by applying @code{ALL} to the array sections.
+@end table
+
+@item @emph{Example}:
+@smallexample
+program test_all
+ logical l
+ l = all((/.true., .true., .true./))
+ print *, l
+ call section
+ contains
+ subroutine section
+ integer a(2,3), b(2,3)
+ a = 1
+ b = 1
+ b(2,2) = 2
+ print *, all(a .eq. b, 1)
+ print *, all(a .eq. b, 2)
+ end subroutine section
+end program test_all
+@end smallexample
+@end table
+
+
+
+@node ALLOCATED
+@section @code{ALLOCATED} --- Status of an allocatable entity
+@findex @code{ALLOCATED} intrinsic
+@cindex allocation status
+
+@table @asis
+@item @emph{Description}:
+@code{ALLOCATED(X)} checks the status of whether @var{X} is allocated.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@code{L = ALLOCATED(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The argument shall be an @code{ALLOCATABLE} array.
+@end multitable
+
+@item @emph{Return value}:
+The return value is a scalar @code{LOGICAL} with the default logical
+kind type parameter. If @var{X} is allocated, @code{ALLOCATED(X)}
+is @code{.TRUE.}; otherwise, it returns the @code{.TRUE.}
+
+@item @emph{Example}:
+@smallexample
+program test_allocated
+ integer :: i = 4
+ real(4), allocatable :: x(:)
+ if (allocated(x) .eqv. .false.) allocate(x(i))
+end program test_allocated
+@end smallexample
+@end table
+
+
+@node AND
+@section @code{AND} --- Bitwise logical AND
+@findex @code{AND} intrinsic
+@cindex bit operations
+
+@table @asis
+@item @emph{Description}:
+Bitwise logical @code{AND}.
+
+This intrinsic routine is provided for backwards compatibility with
+GNU Fortran 77. For integer arguments, programmers should consider
+the use of the @ref{IAND} intrinsic defined by the Fortran standard.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Non-elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = AND(X, Y)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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}.
+@end multitable
+
+@item @emph{Return value}:
+The return type is either @code{INTEGER(*)} or @code{LOGICAL} after
+cross-promotion of the arguments.
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_and
+ LOGICAL :: T = .TRUE., F = ..FALSE.
+ INTEGER :: a, b
+ DATA a / Z'F' /, b / Z'3' /
+
+ WRITE (*,*) AND(T, T), AND(T, F), AND(F, T), AND(F, F)
+ WRITE (*,*) AND(a, b)
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+F95 elemental function: @ref{IAND}
+@end table
+
+
+
+@node ANINT
+@section @code{ANINT} --- Nearest whole number
+@findex @code{ANINT} intrinsic
+@findex @code{DNINT} intrinsic
+@cindex whole number
+
+@table @asis
+@item @emph{Description}:
+@code{ANINT(X [, KIND])} rounds its argument to the nearest whole number.
+
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = ANINT(X)}
+@code{X = ANINT(X, KIND)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type of the argument shall be @code{REAL(*)}.
+@item @var{KIND} @tab (Optional) @var{KIND} shall be a scalar integer
+initialization expression.
+@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)}.
+
+@item @emph{Example}:
+@smallexample
+program test_anint
+ real(4) x4
+ real(8) x8
+ x4 = 1.234E0_4
+ x8 = 4.321_8
+ print *, anint(x4), dnint(x8)
+ x8 = anint(x4,8)
+end program test_anint
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@end multitable
+@end table
+
+
+
+@node ANY
+@section @code{ANY} --- Any value in @var{MASK} along @var{DIM} is true
+@findex @code{ANY} intrinsic
+@cindex true values
+
+@table @asis
+@item @emph{Description}:
+@code{ANY(MASK [, DIM])} determines if any of the values in the logical array
+@var{MASK} along dimension @var{DIM} are @code{.TRUE.}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+transformational function
+
+@item @emph{Syntax}:
+@code{L = ANY(MASK)}
+@code{L = ANY(MASK, DIM)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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
+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
+the shape of @var{MASK} where the @var{DIM} dimension is elided.
+
+@table @asis
+@item (A)
+@code{ANY(MASK)} is true if any element of @var{MASK} is true;
+otherwise, it is false. It also is false if @var{MASK} has zero size.
+@item (B)
+If the rank of @var{MASK} is one, then @code{ANY(MASK,DIM)} is equivalent
+to @code{ANY(MASK)}. If the rank is greater than one, then @code{ANY(MASK,DIM)}
+is determined by applying @code{ANY} to the array sections.
+@end table
+
+@item @emph{Example}:
+@smallexample
+program test_any
+ logical l
+ l = any((/.true., .true., .true./))
+ print *, l
+ call section
+ contains
+ subroutine section
+ integer a(2,3), b(2,3)
+ a = 1
+ b = 1
+ b(2,2) = 2
+ print *, any(a .eq. b, 1)
+ print *, any(a .eq. b, 2)
+ end subroutine section
+end program test_any
+@end smallexample
+@end table
+
+
+
+@node ASIN
+@section @code{ASIN} --- Arcsine function
+@findex @code{ASIN} intrinsic
+@findex @code{DASIN} intrinsic
+@cindex trigonometric functions (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
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = ASIN(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type shall be @code{REAL(*)}, and a magnitude that is
+less than one.
+@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}.
+
+@item @emph{Example}:
+@smallexample
+program test_asin
+ real(8) :: x = 0.866_8
+ x = asin(x)
+end program test_asin
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@end multitable
+
+@item @emph{See also}:
+Inverse function: @ref{SIN}
+
+@end table
+
+
+@node ASINH
+@section @code{ASINH} --- Hyperbolic arcsine function
+@findex @code{ASINH} intrinsic
+@cindex hyperbolic arcsine
+@cindex hyperbolic sine (inverse)
+
+@table @asis
+@item @emph{Description}:
+@code{ASINH(X)} computes the area hyperbolic sine of @var{X} (inverse of @code{SINH(X)}).
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = ASINH(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type shall be @code{REAL(*)}, with @var{X} a real number.
+@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}.
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_asinh
+ REAL(8), DIMENSION(3) :: x = (/ -1.0, 0.0, 1.0 /)
+ WRITE (*,*) ASINH(x)
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+Inverse function: @ref{SINH}
+@end table
+
+
+
+@node ASSOCIATED
+@section @code{ASSOCIATED} --- Status of a pointer or pointer/target pair
+@findex @code{ASSOCIATED} intrinsic
+@cindex pointer 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}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@code{L = ASSOCIATED(PTR)}
+@code{L = ASSOCIATED(PTR [, TGT])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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}.
+@end multitable
+The status of neither @var{PTR} nor @var{TGT} can be undefined.
+
+@item @emph{Return value}:
+@code{ASSOCIATED(PTR)} 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.
+@end table
+
+@item @emph{Example}:
+@smallexample
+program test_associated
+ implicit none
+ real, target :: tgt(2) = (/1., 2./)
+ real, pointer :: ptr(:)
+ ptr => tgt
+ if (associated(ptr) .eqv. .false.) call abort
+ if (associated(ptr,tgt) .eqv. .false.) call abort
+end program test_associated
+@end smallexample
+
+@item @emph{See also}:
+@ref{NULL}
+@end table
+
+
+
+@node ATAN
+@section @code{ATAN} --- Arctangent function
+@findex @code{ATAN} intrinsic
+@findex @code{DATAN} intrinsic
+@cindex trigonometric functions (inverse)
+
+@table @asis
+@item @emph{Description}:
+@code{ATAN(X)} computes the arctangent of @var{X}.
+
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = ATAN(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type shall be @code{REAL(*)}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{REAL(*)} and it lies in the
+range @math{ - \pi / 2 \leq \atan (x) \leq \pi / 2}.
+
+@item @emph{Example}:
+@smallexample
+program test_atan
+ real(8) :: x = 2.866_8
+ x = atan(x)
+end program test_atan
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@end multitable
+
+@item @emph{See also}:
+Inverse function: @ref{TAN}
+
+@end table
+
+
+
+@node ATAN2
+@section @code{ATAN2} --- Arctangent function
+@findex @code{ATAN2} intrinsic
+@findex @code{DATAN2} intrinsic
+@cindex trigonometric functions (inverse)
+
+@table @asis
+@item @emph{Description}:
+@code{ATAN2(Y,X)} computes the arctangent of the complex number @math{X + i Y}.
+
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = ATAN2(Y,X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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{Return value}:
+The return value has the same type and kind type parameter as @var{Y}.
+It is the principal value of the complex number @math{X + i Y}. If
+@var{X} is nonzero, then it lies in the range @math{-\pi \le \atan (x) \leq \pi}.
+The sign is positive if @var{Y} is positive. If @var{Y} is zero, then
+the return value is zero if @var{X} is positive and @math{\pi} if @var{X}
+is negative. Finally, if @var{X} is zero, then the magnitude of the result
+is @math{\pi/2}.
+
+@item @emph{Example}:
+@smallexample
+program test_atan2
+ real(4) :: x = 1.e0_4, y = 0.5e0_4
+ x = atan2(y,x)
+end program test_atan2
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@end multitable
+@end table
+
+
+
+@node ATANH
+@section @code{ATANH} --- Hyperbolic arctangent function
+@findex @code{ASINH} intrinsic
+@cindex hyperbolic arctangent
+@cindex hyperbolic tangent (inverse)
+
+@table @asis
+@item @emph{Description}:
+@code{ATANH(X)} computes the area hyperbolic sine of @var{X} (inverse of @code{TANH(X)}).
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = ATANH(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type shall be @code{REAL(*)} with a magnitude that is less than or equal to one.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{REAL(*)} and it lies in the
+range @math{-\infty \leq \atanh(x) \leq \infty}.
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_atanh
+ REAL, DIMENSION(3) :: x = (/ -1.0, 0.0, 1.0 /)
+ WRITE (*,*) ATANH(x)
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+Inverse function: @ref{TANH}
+@end table
+
+
+
+
+@node BESJ0
+@section @code{BESJ0} --- Bessel function of the first kind of order 0
+@findex @code{BESJ0} intrinsic
+@findex @code{DBESJ0} intrinsic
+@cindex Bessel
+
+@table @asis
+@item @emph{Description}:
+@code{BESJ0(X)} computes the Bessel function of the first kind of order 0
+of @var{X}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = BESJ0(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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}.
+
+@item @emph{Example}:
+@smallexample
+program test_besj0
+ real(8) :: x = 0.0_8
+ x = besj0(x)
+end program test_besj0
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@item Name @tab Argument @tab Return type @tab Standard
+@item @code{DBESJ0(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab GNU extension
+@end multitable
+@end table
+
+
+
+@node BESJ1
+@section @code{BESJ1} --- Bessel function of the first kind of order 1
+@findex @code{BESJ1} intrinsic
+@findex @code{DBESJ1} intrinsic
+@cindex Bessel
+
+@table @asis
+@item @emph{Description}:
+@code{BESJ1(X)} computes the Bessel function of the first kind of order 1
+of @var{X}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = BESJ1(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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 }.
+
+@item @emph{Example}:
+@smallexample
+program test_besj1
+ real(8) :: x = 1.0_8
+ x = besj1(x)
+end program test_besj1
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@findex @code{BESJN} intrinsic
+@findex @code{DBESJN} intrinsic
+@cindex Bessel
+
+@table @asis
+@item @emph{Description}:
+@code{BESJN(N, X)} computes the Bessel function of the first kind of order
+@var{N} of @var{X}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{Y = BESJN(N, X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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.
+@end multitable
+
+@item @emph{Return value}:
+The return value is a scalar of type @code{REAL(*)}.
+
+@item @emph{Example}:
+@smallexample
+program test_besjn
+ real(8) :: x = 1.0_8
+ x = besjn(5,x)
+end program test_besjn
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@end multitable
+@end table
+
+
+
+@node BESY0
+@section @code{BESY0} --- Bessel function of the second kind of order 0
+@findex @code{BESY0} intrinsic
+@findex @code{DBESY0} intrinsic
+@cindex Bessel
+
+@table @asis
+@item @emph{Description}:
+@code{BESY0(X)} computes the Bessel function of the second kind of order 0
+of @var{X}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = BESY0(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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(*)}.
+
+@item @emph{Example}:
+@smallexample
+program test_besy0
+ real(8) :: x = 0.0_8
+ x = besy0(x)
+end program test_besy0
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@item Name @tab Argument @tab Return type @tab Standard
+@item @code{DBESY0(X)}@tab @code{REAL(8) X} @tab @code{REAL(8)} @tab GNU extension
+@end multitable
+@end table
+
+
+
+@node BESY1
+@section @code{BESY1} --- Bessel function of the second kind of order 1
+@findex @code{BESY1} intrinsic
+@findex @code{DBESY1} intrinsic
+@cindex Bessel
+
+@table @asis
+@item @emph{Description}:
+@code{BESY1(X)} computes the Bessel function of the second kind of order 1
+of @var{X}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = BESY1(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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(*)}.
+
+@item @emph{Example}:
+@smallexample
+program test_besy1
+ real(8) :: x = 1.0_8
+ x = besy1(x)
+end program test_besy1
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@item Name @tab Argument @tab Return type @tab Standard
+@item @code{DBESY1(X)}@tab @code{REAL(8) X} @tab @code{REAL(8)} @tab GNU extension
+@end multitable
+@end table
+
+
+
+@node BESYN
+@section @code{BESYN} --- Bessel function of the second kind
+@findex @code{BESYN} intrinsic
+@findex @code{DBESYN} intrinsic
+@cindex Bessel
+
+@table @asis
+@item @emph{Description}:
+@code{BESYN(N, X)} computes the Bessel function of the second kind of order
+@var{N} of @var{X}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{Y = BESYN(N, X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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.
+@end multitable
+
+@item @emph{Return value}:
+The return value is a scalar of type @code{REAL(*)}.
+
+@item @emph{Example}:
+@smallexample
+program test_besyn
+ real(8) :: x = 1.0_8
+ x = besyn(5,x)
+end program test_besyn
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@end multitable
+@end table
+
+
+
+@node BIT_SIZE
+@section @code{BIT_SIZE} --- Bit size inquiry function
+@findex @code{BIT_SIZE} intrinsic
+@cindex bit_size
+
+@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}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@code{I = BIT_SIZE(I)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{I} @tab The type shall be @code{INTEGER(*)}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{INTEGER(*)}
+
+@item @emph{Example}:
+@smallexample
+program test_bit_size
+ integer :: i = 123
+ integer :: size
+ size = bit_size(i)
+ print *, size
+end program test_bit_size
+@end smallexample
+@end table
+
+
+
+@node BTEST
+@section @code{BTEST} --- Bit test function
+@findex @code{BTEST} intrinsic
+@cindex bit operations
+
+@table @asis
+@item @emph{Description}:
+@code{BTEST(I,POS)} returns logical @code{.TRUE.} if the bit at @var{POS}
+in @var{I} is set.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{I = BTEST(I,POS)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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{LOGICAL}
+
+@item @emph{Example}:
+@smallexample
+program test_btest
+ integer :: i = 32768 + 1024 + 64
+ integer :: pos
+ logical :: bool
+ do pos=0,16
+ bool = btest(i, pos)
+ print *, pos, bool
+ end do
+end program test_btest
+@end smallexample
+@end table
+
+
+
+@node CEILING
+@section @code{CEILING} --- Integer ceiling function
+@findex @code{CEILING} intrinsic
+@cindex CEILING
+
+@table @asis
+@item @emph{Description}:
+@code{CEILING(X)} returns the least integer greater than or equal to @var{X}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{I = CEILING(X[,KIND])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type shall be @code{REAL(*)}.
+@item @var{KIND} @tab (Optional) scalar integer initialization expression.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{INTEGER(KIND)}
+
+@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
+@findex @code{CHAR} intrinsic
+@cindex conversion function (character)
+
+@table @asis
+@item @emph{Description}:
+@code{CHAR(I,[KIND])} returns the character represented by the integer @var{I}.
+
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{C = CHAR(I[,KIND])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{I} @tab The type shall be @code{INTEGER(*)}.
+@item @var{KIND} @tab Optional scaler integer initialization expression.
+@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{See also}:
+@ref{ACHAR}, @ref{ICHAR}, @ref{IACHAR}
+
+@end table
+
+
+@node CHDIR
+@section @code{CHDIR} --- Change working directory
+@findex @code{CHDIR} intrinsic
+@cindex file system functions
+
+@table @asis
+@item @emph{Description}:
+Change current working directory to a specified @var{PATH}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Non-elemental subroutine
+
+@item @emph{Syntax}:
+@code{CALL chdir(PATH[,STATUS])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{PATH} @tab The type shall be @code{CHARACTER(*)} and shall specify a valid path within the file system.
+@item @var{STATUS} @tab (Optional) status flag. Returns 0 on success,
+ a system specific and non-zero 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
+@findex @code{CHMOD}
+@cindex file system functions
+
+Not yet implemented in GNU Fortran.
+
+@table @asis
+@item @emph{Description}:
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+@item @emph{See also}:
+
+@end table
+
+
+@node CMPLX
+@section @code{CMPLX} --- Complex conversion function
+@findex @code{CMPLX} intrinsic
+@cindex CMPLX
+
+@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}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{C = CMPLX(X[,Y[,KIND]])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type may be @code{INTEGER(*)}, @code{REAL(*)}, or @code{COMPLEX(*)}.
+@item @var{Y} @tab Optional, allowed if @var{X} is not @code{COMPLEX(*)}. May be @code{INTEGER(*)} or @code{REAL(*)}.
+@item @var{KIND} @tab Optional scaler integer initialization expression.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{COMPLEX(*)}
+
+@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
+@end table
+
+
+
+@node COMMAND_ARGUMENT_COUNT
+@section @code{COMMAND_ARGUMENT_COUNT} --- Get number of command line arguments
+@findex @code{COMMAND_ARGUMENT_COUNT} intrinsic
+@cindex command line arguments
+@cindex getopt
+
+@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}:
+F2003
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@code{I = COMMAND_ARGUMENT_COUNT()}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item None
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{INTEGER(4)}
+
+@item @emph{Example}:
+@smallexample
+program test_command_argument_count
+ integer :: count
+ count = command_argument_count()
+ print *, count
+end program test_command_argument_count
+@end smallexample
+
+@item @emph{See also}:
+@ref{GET_COMMAND}, @ref{GET_COMMAND_ARGUMENT}
+@end table
+
+@node CONJG
+@section @code{CONJG} --- Complex conjugate function
+@findex @code{CONJG} intrinsic
+@findex @code{DCONJG} intrinsic
+@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
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{Z = CONJG(Z)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{Z} @tab The type shall be @code{COMPLEX(*)}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{COMPLEX(*)}.
+
+@item @emph{Example}:
+@smallexample
+program test_conjg
+ complex :: z = (2.0, 3.0)
+ complex(8) :: dz = (2.71_8, -3.14_8)
+ z= conjg(z)
+ print *, z
+ dz = dconjg(dz)
+ print *, dz
+end program test_conjg
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@end multitable
+@end table
+
+
+
+@node COS
+@section @code{COS} --- Cosine function
+@findex @code{COS} intrinsic
+@findex @code{DCOS} intrinsic
+@findex @code{ZCOS} intrinsic
+@findex @code{CDCOS} intrinsic
+@cindex trigonometric functions
+
+@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
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = COS(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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}.
+
+@item @emph{Example}:
+@smallexample
+program test_cos
+ real :: x = 0.0
+ x = cos(x)
+end program test_cos
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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{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
+
+@item @emph{See also}:
+Inverse function: @ref{ACOS}
+
+@end table
+
+
+
+@node COSH
+@section @code{COSH} --- Hyperbolic cosine function
+@findex @code{COSH} intrinsic
+@findex @code{DCOSH} intrinsic
+@cindex hyperbolic cosine
+
+@table @asis
+@item @emph{Description}:
+@code{COSH(X)} computes the hyperbolic cosine of @var{X}.
+
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = COSH(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type shall be @code{REAL(*)}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{REAL(*)} and it is positive
+(@math{ \cosh (x) \geq 0 }.
+
+@item @emph{Example}:
+@smallexample
+program test_cosh
+ real(8) :: x = 1.0_8
+ x = cosh(x)
+end program test_cosh
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@end multitable
+
+@item @emph{See also}:
+Inverse function: @ref{ACOSH}
+
+@end table
+
+
+
+@node COUNT
+@section @code{COUNT} --- Count function
+@findex @code{COUNT} intrinsic
+@cindex count
+
+@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}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+transformational function
+
+@item @emph{Syntax}:
+@code{I = COUNT(MASK[,DIM])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{MASK} @tab The type shall be @code{LOGICAL}.
+@item @var{DIM} @tab The type shall be @code{INTEGER}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{INTEGER} with rank equal to that of
+@var{MASK}.
+
+@item @emph{Example}:
+@smallexample
+program test_count
+ integer, dimension(2,3) :: a, b
+ logical, dimension(2,3) :: mask
+ a = reshape( (/ 1, 2, 3, 4, 5, 6 /), (/ 2, 3 /))
+ b = reshape( (/ 0, 7, 3, 4, 5, 8 /), (/ 2, 3 /))
+ print '(3i3)', a(1,:)
+ print '(3i3)', a(2,:)
+ print *
+ print '(3i3)', b(1,:)
+ print '(3i3)', b(2,:)
+ print *
+ mask = a.ne.b
+ print '(3l3)', mask(1,:)
+ print '(3l3)', mask(2,:)
+ print *
+ print '(3i3)', count(mask)
+ print *
+ print '(3i3)', count(mask, 1)
+ print *
+ print '(3i3)', count(mask, 2)
+end program test_count
+@end smallexample
+@end table
+
+
+
+@node CPU_TIME
+@section @code{CPU_TIME} --- CPU elapsed time in seconds
+@findex @code{CPU_TIME} intrinsic
+@cindex CPU_TIME
+
+@table @asis
+@item @emph{Description}:
+Returns a @code{REAL} value representing the elapsed CPU time in seconds. This
+is useful for testing segments of code to determine execution time.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@code{CPU_TIME(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type shall be @code{REAL} with @code{INTENT(OUT)}.
+@end multitable
+
+@item @emph{Return value}:
+None
+
+@item @emph{Example}:
+@smallexample
+program test_cpu_time
+ real :: start, finish
+ call cpu_time(start)
+ ! put code to test here
+ call cpu_time(finish)
+ print '("Time = ",f6.3," seconds.")',finish-start
+end program test_cpu_time
+@end smallexample
+@end table
+
+
+
+@node CSHIFT
+@section @code{CSHIFT} --- Circular shift function
+@findex @code{CSHIFT} intrinsic
+@cindex bit manipulation
+
+@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}.
+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
+
+@item @emph{Class}:
+transformational function
+
+@item @emph{Syntax}:
+@code{A = CSHIFT(A, SHIFT[,DIM])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{ARRAY} @tab May be any type, not scaler.
+@item @var{SHIFT} @tab The type shall be @code{INTEGER}.
+@item @var{DIM} @tab The type shall be @code{INTEGER}.
+@end multitable
+
+@item @emph{Return value}:
+Returns an array of same type and rank as the @var{ARRAY} argument.
+
+@item @emph{Example}:
+@smallexample
+program test_cshift
+ integer, dimension(3,3) :: a
+ a = reshape( (/ 1, 2, 3, 4, 5, 6, 7, 8, 9 /), (/ 3, 3 /))
+ print '(3i3)', a(1,:)
+ print '(3i3)', a(2,:)
+ print '(3i3)', a(3,:)
+ a = cshift(a, SHIFT=(/1, 2, -1/), DIM=2)
+ print *
+ print '(3i3)', a(1,:)
+ print '(3i3)', a(2,:)
+ print '(3i3)', a(3,:)
+end program test_cshift
+@end smallexample
+@end table
+
+
+@node CTIME
+@section @code{CTIME} --- Convert a time into a string
+@findex @code{CTIME} intrinsic
+@cindex ctime subroutine
+
+@table @asis
+@item @emph{Description}:
+@code{CTIME(T,S)} converts @var{T}, a system time value, such as returned
+by @code{TIME8()}, to a string of the form @samp{Sat Aug 19 18:13:14
+1995}, and returns that string into @var{S}.
+
+If @code{CTIME} is invoked as a function, it can not be invoked as a
+subroutine, and vice versa.
+
+@var{T} is an @code{INTENT(IN)} @code{INTEGER(KIND=8)} variable.
+@var{S} is an @code{INTENT(OUT)} @code{CHARACTER} variable.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@multitable @columnfractions .80
+@item @code{CALL CTIME(T,S)}.
+@item @code{S = CTIME(T)}, (not recommended).
+@end multitable
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{S}@tab The type shall be of type @code{CHARACTER}.
+@item @var{T}@tab The type shall be of type @code{INTEGER(KIND=8)}.
+@end multitable
+
+@item @emph{Return value}:
+The converted date and time as a string.
+
+@item @emph{Example}:
+@smallexample
+program test_ctime
+ integer(8) :: i
+ character(len=30) :: date
+ i = time8()
+
+ ! Do something, main part of the program
+
+ call ctime(i,date)
+ print *, 'Program was started on ', date
+end program test_ctime
+@end smallexample
+@end table
+
+@node DATE_AND_TIME
+@section @code{DATE_AND_TIME} --- Date and time subroutine
+@findex @code{DATE_AND_TIME} intrinsic
+@cindex DATE_AND_TIME
+
+@table @asis
+@item @emph{Description}:
+@code{DATE_AND_TIME(DATE, TIME, ZONE, VALUES)} gets the corresponding date and
+time information from the real-time system clock. @var{DATE} is
+@code{INTENT(OUT)} and has form ccyymmdd. @var{TIME} is @code{INTENT(OUT)} and
+has form hhmmss.sss. @var{ZONE} is @code{INTENT(OUT)} and has form (+-)hhmm,
+representing the difference with respect to Coordinated Universal Time (UTC).
+Unavailable time and date parameters return blanks.
+
+@var{VALUES} is @code{INTENT(OUT)} and provides the following:
+
+@multitable @columnfractions .15 .30 .60
+@item @tab @code{VALUE(1)}: @tab The year
+@item @tab @code{VALUE(2)}: @tab The month
+@item @tab @code{VALUE(3)}: @tab The day of the month
+@item @tab @code{VALUE(4)}: @tab Time difference with UTC in minutes
+@item @tab @code{VALUE(5)}: @tab The hour of the day
+@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
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@code{CALL DATE_AND_TIME([DATE, TIME, ZONE, VALUES])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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{VALUES}@tab (Optional) The type shall be @code{INTEGER(8)}.
+@end multitable
+
+@item @emph{Return value}:
+None
+
+@item @emph{Example}:
+@smallexample
+program test_time_and_date
+ character(8) :: date
+ character(10) :: time
+ character(5) :: zone
+ integer,dimension(8) :: values
+ ! using keyword arguments
+ call date_and_time(date,time,zone,values)
+ call date_and_time(DATE=date,ZONE=zone)
+ call date_and_time(TIME=time)
+ call date_and_time(VALUES=values)
+ print '(a,2x,a,2x,a)', date, time, zone
+ print '(8i5))', values
+end program test_time_and_date
+@end smallexample
+@end table
+
+
+
+@node DBLE
+@section @code{DBLE} --- Double conversion function
+@findex @code{DBLE} intrinsic
+@cindex double conversion
+
+@table @asis
+@item @emph{Description}:
+@code{DBLE(X)} Converts @var{X} to double precision real type.
+
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = DBLE(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type shall be @code{INTEGER(*)}, @code{REAL(*)}, or @code{COMPLEX(*)}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type double precision real.
+
+@item @emph{Example}:
+@smallexample
+program test_dble
+ real :: x = 2.18
+ integer :: i = 5
+ complex :: z = (2.3,1.14)
+ print *, dble(x), dble(i), dble(z)
+end program test_dble
+@end smallexample
+
+@item @emph{See also}:
+@ref{DFLOAT}, @ref{FLOAT}, @ref{REAL}
+@end table
+
+
+
+@node DCMPLX
+@section @code{DCMPLX} --- Double complex conversion function
+@findex @code{DCMPLX} intrinsic
+@cindex DCMPLX
+
+@table @asis
+@item @emph{Description}:
+@code{DCMPLX(X [,Y])} returns a double 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}:
+GNU extension
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{C = DCMPLX(X)}
+@code{C = DCMPLX(X,Y)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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}:
+The return value is of type @code{COMPLEX(8)}
+
+@item @emph{Example}:
+@smallexample
+program test_dcmplx
+ integer :: i = 42
+ real :: x = 3.14
+ complex :: z
+ z = cmplx(i, x)
+ print *, dcmplx(i)
+ print *, dcmplx(x)
+ print *, dcmplx(z)
+ print *, dcmplx(x,i)
+end program test_dcmplx
+@end smallexample
+@end table
+
+
+
+@node DFLOAT
+@section @code{DFLOAT} --- Double conversion function
+@findex @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{X = DFLOAT(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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
+@findex @code{DIGITS} intrinsic
+@cindex digits, significant
+
+@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
+floating point representation, a default real number would likely return 24.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@code{C = DIGITS(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type may be @code{INTEGER(*)} or @code{REAL(*)}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{INTEGER}.
+
+@item @emph{Example}:
+@smallexample
+program test_digits
+ integer :: i = 12345
+ real :: x = 3.143
+ real(8) :: y = 2.33
+ print *, digits(i)
+ print *, digits(x)
+ print *, digits(y)
+end program test_digits
+@end smallexample
+@end table
+
+
+
+@node DIM
+@section @code{DIM} --- Dim function
+@findex @code{DIM} intrinsic
+@findex @code{IDIM} intrinsic
+@findex @code{DDIM} intrinsic
+@cindex dim
+
+@table @asis
+@item @emph{Description}:
+@code{DIM(X,Y)} returns the difference @code{X-Y} if the result is positive;
+otherwise returns zero.
+
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = DIM(X,Y)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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(*)}.
+
+@item @emph{Example}:
+@smallexample
+program test_dim
+ integer :: i
+ real(8) :: x
+ i = dim(4, 15)
+ x = dim(4.345_8, 2.111_8)
+ print *, i
+ print *, x
+end program test_dim
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@end multitable
+@end table
+
+
+
+@node DOT_PRODUCT
+@section @code{DOT_PRODUCT} --- Dot product function
+@findex @code{DOT_PRODUCT} intrinsic
+@cindex Dot product
+
+@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)}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+transformational function
+
+@item @emph{Syntax}:
+@code{S = DOT_PRODUCT(X,Y)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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.
+@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
+@code{LOGICAL}, the return value is @code{.TRUE.} or @code{.FALSE.}.
+
+@item @emph{Example}:
+@smallexample
+program test_dot_prod
+ integer, dimension(3) :: a, b
+ a = (/ 1, 2, 3 /)
+ b = (/ 4, 5, 6 /)
+ print '(3i3)', a
+ print *
+ print '(3i3)', b
+ print *
+ print *, dot_product(a,b)
+end program test_dot_prod
+@end smallexample
+@end table
+
+
+
+@node DPROD
+@section @code{DPROD} --- Double product function
+@findex @code{DPROD} intrinsic
+@cindex Double product
+
+@table @asis
+@item @emph{Description}:
+@code{DPROD(X,Y)} returns the product @code{X*Y}.
+
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{D = DPROD(X,Y)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type shall be @code{REAL}.
+@item @var{Y} @tab The type shall be @code{REAL}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{REAL(8)}.
+
+@item @emph{Example}:
+@smallexample
+program test_dprod
+ integer :: i
+ real :: x = 5.2
+ real :: y = 2.3
+ real(8) :: d
+ d = dprod(x,y)
+ print *, d
+end program test_dprod
+@end smallexample
+@end table
+
+
+
+@node DREAL
+@section @code{DREAL} --- Double real part function
+@findex @code{DREAL} intrinsic
+@cindex Double real part
+
+@table @asis
+@item @emph{Description}:
+@code{DREAL(Z)} returns the real part of complex variable @var{Z}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{D = DREAL(Z)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{Z} @tab The type shall be @code{COMPLEX(8)}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{REAL(8)}.
+
+@item @emph{Example}:
+@smallexample
+program test_dreal
+ complex(8) :: z = (1.3_8,7.2_8)
+ print *, dreal(z)
+end program test_dreal
+@end smallexample
+
+@item @emph{See also}:
+@ref{AIMAG}
+
+@end table
+
+
+
+@node DTIME
+@section @code{DTIME} --- Execution time subroutine (or function)
+@findex @code{DTIME} intrinsic
+@cindex dtime subroutine
+
+@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)}.
+
+Subsequent invocations of @code{DTIME} return values accumulated since the
+previous invocation.
+
+On some systems, the underlying timings are represented using types with
+sufficiently small limits that overflows (wrap around) are possible, such as
+32-bit types. Therefore, the values returned by this intrinsic might be, or
+become, negative, or numerically less than previous values, during a single
+run of the compiled program.
+
+If @code{DTIME} is invoked as a function, it can not be invoked as a
+subroutine, and vice versa.
+
+@var{TARRAY} and @var{RESULT} 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.
+@end multitable
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@multitable @columnfractions .80
+@item @code{CALL DTIME(TARRAY, RESULT)}.
+@item @code{RESULT = DTIME(TARRAY)}, (not recommended).
+@end multitable
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{TARRAY}@tab The type shall be @code{REAL, DIMENSION(2)}.
+@item @var{RESULT}@tab The type shall be @code{REAL}.
+@end multitable
+
+@item @emph{Return value}:
+Elapsed time in seconds since the start of program execution.
+
+@item @emph{Example}:
+@smallexample
+program test_dtime
+ integer(8) :: i, j
+ real, dimension(2) :: tarray
+ real :: result
+ call dtime(tarray, result)
+ print *, result
+ print *, tarray(1)
+ print *, tarray(2)
+ do i=1,100000000 ! Just a delay
+ j = i * i - i
+ end do
+ call dtime(tarray, result)
+ print *, result
+ print *, tarray(1)
+ print *, tarray(2)
+end program test_dtime
+@end smallexample
+@end table
+
+
+
+@node EOSHIFT
+@section @code{EOSHIFT} --- End-off shift function
+@findex @code{EOSHIFT} intrinsic
+@cindex bit manipulation
+
+@table @asis
+@item @emph{Description}:
+@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
+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 dropped. If
+@var{BOUNDARY} is present then the corresponding value of from @var{BOUNDARY}
+is copied back in the other end. If @var{BOUNDARY} is not present then the
+following are copied in depending on the type of @var{ARRAY}.
+
+@multitable @columnfractions .15 .80
+@item @emph{Array Type} @tab @emph{Boundary Value}
+@item Numeric @tab 0 of the type and kind of @var{ARRAY}.
+@item Logical @tab @code{.FALSE.}.
+@item Character(@var{len}) @tab @var{len} blanks.
+@end multitable
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+transformational function
+
+@item @emph{Syntax}:
+@code{A = EOSHIFT(A, SHIFT[,BOUNDARY, DIM])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{ARRAY} @tab May be any type, not scaler.
+@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}.
+@end multitable
+
+@item @emph{Return value}:
+Returns an array of same type and rank as the @var{ARRAY} argument.
+
+@item @emph{Example}:
+@smallexample
+program test_eoshift
+ integer, dimension(3,3) :: a
+ a = reshape( (/ 1, 2, 3, 4, 5, 6, 7, 8, 9 /), (/ 3, 3 /))
+ print '(3i3)', a(1,:)
+ print '(3i3)', a(2,:)
+ print '(3i3)', a(3,:)
+ a = EOSHIFT(a, SHIFT=(/1, 2, 1/), BOUNDARY=-5, DIM=2)
+ print *
+ print '(3i3)', a(1,:)
+ print '(3i3)', a(2,:)
+ print '(3i3)', a(3,:)
+end program test_eoshift
+@end smallexample
+@end table
+
+
+
+@node EPSILON
+@section @code{EPSILON} --- Epsilon function
+@findex @code{EPSILON} intrinsic
+@cindex epsilon, significant
+
+@table @asis
+@item @emph{Description}:
+@code{EPSILON(X)} returns a nearly negligible number relative to @code{1}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@code{C = EPSILON(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type shall be @code{REAL(*)}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of same type as the argument.
+
+@item @emph{Example}:
+@smallexample
+program test_epsilon
+ real :: x = 3.143
+ real(8) :: y = 2.33
+ print *, EPSILON(x)
+ print *, EPSILON(y)
+end program test_epsilon
+@end smallexample
+@end table
+
+
+
+@node ERF
+@section @code{ERF} --- Error function
+@findex @code{ERF} intrinsic
+@cindex error function
+
+@table @asis
+@item @emph{Description}:
+@code{ERF(X)} computes the error function of @var{X}.
+
+@item @emph{Standard}:
+GNU Extension
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = ERF(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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(*)} and it is positive
+(@math{ - 1 \leq erf (x) \leq 1 }.
+
+@item @emph{Example}:
+@smallexample
+program test_erf
+ real(8) :: x = 0.17_8
+ x = erf(x)
+end program test_erf
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@item Name @tab Argument @tab Return type @tab Standard
+@item @code{DERF(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab GNU extension
+@end multitable
+@end table
+
+
+
+@node ERFC
+@section @code{ERFC} --- Error function
+@findex @code{ERFC} intrinsic
+@cindex error function
+
+@table @asis
+@item @emph{Description}:
+@code{ERFC(X)} computes the complementary error function of @var{X}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = ERFC(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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(*)} and it is positive
+(@math{ 0 \leq erfc (x) \leq 2 }.
+
+@item @emph{Example}:
+@smallexample
+program test_erfc
+ real(8) :: x = 0.17_8
+ x = erfc(x)
+end program test_erfc
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@item Name @tab Argument @tab Return type @tab Standard
+@item @code{DERFC(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab GNU extension
+@end multitable
+@end table
+
+
+
+@node ETIME
+@section @code{ETIME} --- Execution time subroutine (or function)
+@findex @code{ETIME} intrinsic
+@cindex time functions
+
+@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)}.
+
+On some systems, the underlying timings are represented using types with
+sufficiently small limits that overflows (wrap around) are possible, such as
+32-bit types. Therefore, the values returned by this intrinsic might be, or
+become, negative, or numerically less than previous values, during a single
+run of the compiled program.
+
+If @code{ETIME} is invoked as a function, it can not be invoked as a
+subroutine, and vice versa.
+
+@var{TARRAY} and @var{RESULT} 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.
+@end multitable
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@multitable @columnfractions .8
+@item @code{CALL ETIME(TARRAY, RESULT)}.
+@item @code{RESULT = ETIME(TARRAY)}, (not recommended).
+@end multitable
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{TARRAY}@tab The type shall be @code{REAL, DIMENSION(2)}.
+@item @var{RESULT}@tab The type shall be @code{REAL}.
+@end multitable
+
+@item @emph{Return value}:
+Elapsed time in seconds since the start of program execution.
+
+@item @emph{Example}:
+@smallexample
+program test_etime
+ integer(8) :: i, j
+ real, dimension(2) :: tarray
+ real :: result
+ call ETIME(tarray, result)
+ print *, result
+ print *, tarray(1)
+ print *, tarray(2)
+ do i=1,100000000 ! Just a delay
+ j = i * i - i
+ end do
+ call ETIME(tarray, result)
+ print *, result
+ print *, tarray(1)
+ print *, tarray(2)
+end program test_etime
+@end smallexample
+
+@item @emph{See also}:
+@ref{CPU_TIME}
+
+@end table
+
+
+
+@node EXIT
+@section @code{EXIT} --- Exit the program with status.
+@findex @code{EXIT}
+@cindex exit
+
+@table @asis
+@item @emph{Description}:
+@code{EXIT} causes immediate termination of the program with status. If status
+is omitted it returns the canonical @emph{success} for the system. All Fortran
+I/O units are closed.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@code{CALL EXIT([STATUS])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{STATUS} @tab The type of the argument shall be @code{INTEGER(*)}.
+@end multitable
+
+@item @emph{Return value}:
+@code{STATUS} is passed to the parent process on exit.
+
+@item @emph{Example}:
+@smallexample
+program test_exit
+ integer :: STATUS = 0
+ print *, 'This program is going to exit.'
+ call EXIT(STATUS)
+end program test_exit
+@end smallexample
+
+@item @emph{See also}:
+@ref{ABORT}, @ref{KILL}
+@end table
+
+
+
+@node EXP
+@section @code{EXP} --- Exponential function
+@findex @code{EXP} intrinsic
+@findex @code{DEXP} intrinsic
+@findex @code{ZEXP} intrinsic
+@findex @code{CDEXP} intrinsic
+@cindex exponential
+
+@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
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = EXP(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type shall be @code{REAL(*)} or
+@code{COMPLEX(*)}.
+@end multitable
+
+@item @emph{Return value}:
+The return value has same type and kind as @var{X}.
+
+@item @emph{Example}:
+@smallexample
+program test_exp
+ real :: x = 1.0
+ x = exp(x)
+end program test_exp
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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{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
+@end table
+
+
+
+@node EXPONENT
+@section @code{EXPONENT} --- Exponent function
+@findex @code{EXPONENT} intrinsic
+@cindex exponent function
+
+@table @asis
+@item @emph{Description}:
+@code{EXPONENT(X)} returns the value of the exponent part of @var{X}. If @var{X}
+is zero the value returned is zero.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{I = EXPONENT(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type shall be @code{REAL(*)}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type default @code{INTEGER}.
+
+@item @emph{Example}:
+@smallexample
+program test_exponent
+ real :: x = 1.0
+ integer :: i
+ i = exponent(x)
+ print *, i
+ print *, exponent(0.0)
+end program test_exponent
+@end smallexample
+@end table
+
+
+@node FDATE
+@section @code{FDATE} --- Get the current time as a string
+@findex @code{FDATE} intrinsic
+@cindex fdate subroutine
+
+@table @asis
+@item @emph{Description}:
+@code{FDATE(DATE)} returns the current date (using the same format as
+@code{CTIME}) in @var{DATE}. It is equivalent to @code{CALL CTIME(DATE,
+TIME8())}.
+
+If @code{FDATE} is invoked as a function, it can not be invoked as a
+subroutine, and vice versa.
+
+@var{DATE} is an @code{INTENT(OUT)} @code{CHARACTER} variable.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@multitable @columnfractions .80
+@item @code{CALL FDATE(DATE)}.
+@item @code{DATE = FDATE()}, (not recommended).
+@end multitable
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{DATE}@tab The type shall be of type @code{CHARACTER}.
+@end multitable
+
+@item @emph{Return value}:
+The current date and time as a string.
+
+@item @emph{Example}:
+@smallexample
+program test_fdate
+ integer(8) :: i, j
+ character(len=30) :: date
+ call fdate(date)
+ print *, 'Program started on ', date
+ do i = 1, 100000000 ! Just a delay
+ j = i * i - i
+ end do
+ call fdate(date)
+ print *, 'Program ended on ', date
+end program test_fdate
+@end smallexample
+@end table
+
+@node FLOAT
+
+@section @code{FLOAT} --- Convert integer to default real
+@findex @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{X = FLOAT(I)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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
+@findex @code{FGET} intrinsic
+@cindex file operations
+@cindex stream operations
+
+@table @asis
+@item @emph{Description}:
+Read a single character in stream mode from stdin by bypassing normal
+formatted output. Stream I/O should not be mixed with normal record-oriented
+(formatted or unformatted) I/O on the same unit; the results are unpredictable.
+
+This intrinsic routine 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}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Non-elemental subroutine
+
+@item @emph{Syntax}:
+@code{CALL fget(C[,STATUS])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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.
+@end multitable
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_fget
+ INTEGER, PARAMETER :: strlen = 100
+ INTEGER :: status, i = 1
+ CHARACTER(len=strlen) :: str = ""
+
+ WRITE (*,*) 'Enter text:'
+ DO
+ CALL fget(str(i:i), status)
+ if (status /= 0 .OR. i > strlen) exit
+ i = i + 1
+ END DO
+ WRITE (*,*) TRIM(str)
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+@ref{FGETC}, @ref{FPUT}, @ref{FPUTC}
+@end table
+
+
+@node FGETC
+@section @code{FGETC} --- Read a single character in stream mode
+@findex @code{FGETC} intrinsic
+@cindex file operations
+@cindex stream operations
+
+@table @asis
+@item @emph{Description}:
+Read a single character in stream mode by bypassing normal formatted output.
+Stream I/O should not be mixed with normal record-oriented (formatted or
+unformatted) I/O on the same unit; the results are unpredictable.
+
+This intrinsic routine 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}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Non-elemental subroutine
+
+@item @emph{Syntax}:
+@code{CALL fgetc(UNIT,C[,STATUS])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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.
+@end multitable
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_fgetc
+ INTEGER :: fd = 42, status
+ CHARACTER :: c
+
+ OPEN(UNIT=fd, FILE="/etc/passwd", ACTION="READ", STATUS = "OLD")
+ DO
+ CALL fgetc(fd, c, status)
+ IF (status /= 0) EXIT
+ call fput(c)
+ END DO
+ CLOSE(UNIT=fd)
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+@ref{FGET}, @ref{FPUT}, @ref{FPUTC}
+@end table
+
+
+
+@node FLOOR
+@section @code{FLOOR} --- Integer floor function
+@findex @code{FLOOR} intrinsic
+@cindex floor
+
+@table @asis
+@item @emph{Description}:
+@code{FLOOR(X)} returns the greatest integer less than or equal to @var{X}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{I = FLOOR(X[,KIND])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type shall be @code{REAL(*)}.
+@item @var{KIND} @tab Optional scaler integer initialization expression.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{INTEGER(KIND)}
+
+@item @emph{Example}:
+@smallexample
+program test_floor
+ real :: x = 63.29
+ real :: y = -63.59
+ print *, floor(x) ! returns 63
+ print *, floor(y) ! returns -64
+end program test_floor
+@end smallexample
+
+@item @emph{See also}:
+@ref{CEILING}, @ref{NINT}
+
+@end table
+
+
+
+@node FLUSH
+@section @code{FLUSH} --- Flush I/O unit(s)
+@findex @code{FLUSH}
+@cindex flush
+
+@table @asis
+@item @emph{Description}:
+Flushes Fortran unit(s) currently open for output. Without the optional
+argument, all units are flushed, otherwise just the unit specified.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+non-elemental subroutine
+
+@item @emph{Syntax}:
+@code{CALL FLUSH(UNIT)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{UNIT} @tab (Optional) The type shall be @code{INTEGER}.
+@end multitable
+
+@item @emph{Note}:
+Beginning with the Fortran 2003 standard, there is a @code{FLUSH}
+statement that should be preferred over the @code{FLUSH} intrinsic.
+
+@end table
+
+
+
+@node FNUM
+@section @code{FNUM} --- File number function
+@findex @code{FNUM} intrinsic
+@cindex fnum
+
+@table @asis
+@item @emph{Description}:
+@code{FNUM(UNIT)} returns the POSIX file descriptor number corresponding to the
+open Fortran I/O unit @code{UNIT}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+non-elemental function
+
+@item @emph{Syntax}:
+@code{I = FNUM(UNIT)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{UNIT} @tab The type shall be @code{INTEGER}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{INTEGER}
+
+@item @emph{Example}:
+@smallexample
+program test_fnum
+ integer :: i
+ open (unit=10, status = "scratch")
+ i = fnum(10)
+ print *, i
+ close (10)
+end program test_fnum
+@end smallexample
+@end table
+
+
+
+@node FPUT
+@section @code{FPUT} --- Write a single character in stream mode to stdout
+@findex @code{FPUT} intrinsic
+@cindex file operations
+@cindex stream operations
+
+@table @asis
+@item @emph{Description}:
+Write a single character in stream mode to stdout by bypassing normal
+formatted output. Stream I/O should not be mixed with normal record-oriented
+(formatted or unformatted) I/O on the same unit; the results are unpredictable.
+
+This intrinsic routine 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}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Non-elemental subroutine
+
+@item @emph{Syntax}:
+@code{CALL fput(C[,STATUS])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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.
+@end multitable
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_fput
+ CHARACTER(len=*) :: str = "gfortran"
+ INTEGER :: i
+ DO i = 1, len_trim(str)
+ CALL fput(str(i:i))
+ END DO
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+@ref{FPUTC}, @ref{FGET}, @ref{FGETC}
+@end table
+
+
+
+@node FPUTC
+@section @code{FPUTC} --- Write a single character in stream mode
+@findex @code{FPUTC} intrinsic
+@cindex file operations
+@cindex stream operations
+
+@table @asis
+@item @emph{Description}:
+Write a single character in stream mode by bypassing normal formatted
+output. Stream I/O should not be mixed with normal record-oriented
+(formatted or unformatted) I/O on the same unit; the results are unpredictable.
+
+This intrinsic routine 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}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Non-elemental subroutine
+
+@item @emph{Syntax}:
+@code{CALL fputc(UNIT,C[,STATUS])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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.
+@end multitable
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_fputc
+ CHARACTER(len=*) :: str = "gfortran"
+ INTEGER :: fd = 42, i
+
+ OPEN(UNIT = fd, FILE = "out", ACTION = "WRITE", STATUS="NEW")
+ DO i = 1, len_trim(str)
+ CALL fputc(fd, str(i:i))
+ END DO
+ CLOSE(fd)
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+@ref{FPUT}, @ref{FGET}, @ref{FGETC}
+@end table
+
+
+
+@node FRACTION
+@section @code{FRACTION} --- Fractional part of the model representation
+@findex @code{FRACTION} intrinsic
+@cindex fractional part
+
+@table @asis
+@item @emph{Description}:
+@code{FRACTION(X)} returns the fractional part of the model
+representation of @code{X}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{Y = FRACTION(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type of the argument shall be a @code{REAL}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of the same type and kind as the argument.
+The fractional part of the model representation of @code{X} is returned;
+it is @code{X * RADIX(X)**(-EXPONENT(X))}.
+
+@item @emph{Example}:
+@smallexample
+program test_fraction
+ real :: x
+ x = 178.1387e-4
+ print *, fraction(x), x * radix(x)**(-exponent(x))
+end program test_fraction
+@end smallexample
+
+@end table
+
+
+
+@node FREE
+@section @code{FREE} --- Frees memory
+@findex @code{FREE} intrinsic
+@cindex FREE
+
+@table @asis
+@item @emph{Description}:
+Frees memory previously allocated by @code{MALLOC()}. The @code{FREE}
+intrinsic is an extension intended to be used with Cray pointers, and is
+provided in GNU Fortran to allow user to compile legacy code. For
+new code using Fortran 95 pointers, the memory de-allocation intrinsic is
+@code{DEALLOCATE}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@code{FREE(PTR)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{PTR} @tab The type shall be @code{INTEGER}. It represents the
+location of the memory that should be de-allocated.
+@end multitable
+
+@item @emph{Return value}:
+None
+
+@item @emph{Example}:
+See @code{MALLOC} for an example.
+
+@item @emph{See also}:
+@ref{MALLOC}
+@end table
+
+
+
+
+@node FSTAT
+@section @code{FSTAT} --- Get file status
+@findex @code{FSTAT} intrinsic
+@cindex file system operations
+
+@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}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Non-elemental subroutine
+
+@item @emph{Syntax}:
+@code{CALL fstat(UNIT,BUFF[,STATUS])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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{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}:
+See @ref{STAT} for an example.
+
+@item @emph{See also}:
+To stat a link: @ref{LSTAT}, to stat a file: @ref{STAT}
+@end table
+
+
+
+@node FSEEK
+@section @code{FSEEK} --- Low level file positioning subroutine
+@findex @code{FSEEK}
+@cindex file system functions
+
+Not yet implemented in GNU Fortran.
+
+@table @asis
+@item @emph{Description}:
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@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}
+
+@end table
+
+
+
+@node FTELL
+@section @code{FTELL} --- Current stream position
+@findex @code{FTELL} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+
+@item @emph{See also}:
+@ref{FSEEK}
+@end table
+
+
+
+@node GETARG
+@section @code{GETARG} --- Get command line arguments
+@findex @code{GETARG} intrinsic
+@cindex command line arguments
+@cindex getopt
+
+@table @asis
+@item @emph{Description}:
+Retrieve the @var{N}th argument that was passed on the
+command line when the containing program was invoked.
+
+This intrinsic routine is provided for backwards compatibility with
+GNU Fortran 77. In new code, programmers should consider the use of
+the @ref{GET_COMMAND_ARGUMENT} intrinsic defined by the Fortran 2003
+standard.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@code{CALL GETARG(N,ARG)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{N} @tab Shall of type @code{INTEGER(4)}, @math{@var{N} \geq 0}
+@item @var{ARG} @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).
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_getarg
+ INTEGER :: i
+ CHARACTER(len=32) :: arg
+
+ DO i = 1, iargc()
+ CALL getarg(i, arg)
+ WRITE (*,*) arg
+ END DO
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+GNU Fortran 77 compability function: @ref{IARGC}
+
+F2003 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
+@findex @code{GET_COMMAND} intrinsic
+@cindex command line arguments
+@cindex getopt
+
+@table @asis
+@item @emph{Description}:
+Retrieve the entire command line that was used to invoke the program.
+
+@item @emph{Standard}:
+F2003
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@code{CALL GET_COMMAND(CMD)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{CMD} @tab Shall be of type @code{CHARACTER(*)}.
+@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.
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_get_command
+ CHARACTER(len=255) :: cmd
+ CALL get_command(cmd)
+ WRITE (*,*) TRIM(cmd)
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+@ref{GET_COMMAND_ARGUMENT}, @ref{COMMAND_ARGUMENT_COUNT}
+@end table
+
+
+
+@node GET_COMMAND_ARGUMENT
+@section @code{GET_COMMAND_ARGUMENT} --- Get command line arguments
+@findex @code{GET_COMMAND_ARGUMENT} intrinsic
+@cindex command line arguments
+@cindex getopt
+
+@table @asis
+@item @emph{Description}:
+Retrieve the @var{N}th argument that was passed on the
+command line when the containing program was invoked.
+
+@item @emph{Standard}:
+F2003
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@code{CALL GET_COMMAND_ARGUMENT(N,ARG)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{N} @tab Shall of type @code{INTEGER(4)}, @math{@var{N} \geq 0}
+@item @var{ARG} @tab Shall be of type @code{CHARACTER(*)}.
+@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).
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_get_command_argument
+ INTEGER :: i
+ CHARACTER(len=32) :: arg
+
+ i = 0
+ DO
+ CALL get_command_argument(i, arg)
+ IF (LEN_TRIM(arg) == 0) EXIT
+
+ WRITE (*,*) TRIM(arg)
+ i = i+1
+ END DO
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+@ref{GET_COMMAND}, @ref{COMMAND_ARGUMENT_COUNT}
+@end table
+
+
+
+@node GETCWD
+@section @code{GETCWD} --- Get current working directory
+@findex @code{GETCWD} intrinsic
+@cindex file system functions
+
+@table @asis
+@item @emph{Description}:
+Get current working directory.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Non-elemental subroutine.
+
+@item @emph{Syntax}:
+@code{CALL getcwd(CWD[,STATUS])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{CWD} @tab The type shall be @code{CHARACTER(*)}.
+@item @var{STATUS} @tab (Optional) status flag. Returns 0 on success,
+ a system specific and non-zero error code otherwise.
+@end multitable
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_getcwd
+ CHARACTER(len=255) :: cwd
+ CALL getcwd(cwd)
+ WRITE(*,*) TRIM(cwd)
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+@ref{CHDIR}
+@end table
+
+
+
+@node GETENV
+@section @code{GETENV} --- Get an environmental variable
+@findex @code{GETENV} intrinsic
+@cindex environment variable
+
+@table @asis
+@item @emph{Description}:
+Get the @var{VALUE} of the environmental variable @var{ENVVAR}.
+
+This intrinsic routine is provided for backwards compatibility with
+GNU Fortran 77. In new code, programmers should consider the use of
+the @ref{GET_ENVIRONMENT_VARIABLE} intrinsic defined by the Fortran
+2003 standard.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@code{CALL GETENV(ENVVAR,VALUE)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{ENVVAR} @tab Shall be of type @code{CHARACTER(*)}.
+@item @var{VALUE} @tab Shall be of type @code{CHARACTER(*)}.
+@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.
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_getenv
+ CHARACTER(len=255) :: homedir
+ CALL getenv("HOME", homedir)
+ WRITE (*,*) TRIM(homedir)
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+@ref{GET_ENVIRONMENT_VARIABLE}
+@end table
+
+
+
+@node GET_ENVIRONMENT_VARIABLE
+@section @code{GET_ENVIRONMENT_VARIABLE} --- Get an environmental variable
+@findex @code{GET_ENVIRONMENT_VARIABLE} intrinsic
+@cindex environment variable
+
+@table @asis
+@item @emph{Description}:
+Get the @var{VALUE} of the environmental variable @var{ENVVAR}.
+
+@item @emph{Standard}:
+F2003
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@code{CALL GET_ENVIRONMENT_VARIABLE(ENVVAR,VALUE)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{ENVVAR} @tab Shall be of type @code{CHARACTER(*)}.
+@item @var{VALUE} @tab Shall be of type @code{CHARACTER(*)}.
+@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.
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_getenv
+ CHARACTER(len=255) :: homedir
+ CALL get_environment_variable("HOME", homedir)
+ WRITE (*,*) TRIM(homedir)
+END PROGRAM
+@end smallexample
+@end table
+
+
+
+@node GETGID
+@section @code{GETGID} --- Group ID function
+@findex @code{GETGID} intrinsic
+@cindex GETGID
+
+@table @asis
+@item @emph{Description}:
+Returns the numerical group ID of the current process.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+function
+
+@item @emph{Syntax}:
+@code{I = GETGID()}
+
+@item @emph{Return value}:
+The return value of @code{GETGID} is an @code{INTEGER} of the default
+kind.
+
+
+@item @emph{Example}:
+See @code{GETPID} for an example.
+
+@item @emph{See also}:
+@ref{GETPID}
+@end table
+
+
+
+@node GETLOG
+@section @code{GETLOG} --- Get login name
+@findex @code{GETLOG} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+@item @emph{See also}:
+@end table
+
+
+
+
+@node GETPID
+@section @code{GETPID} --- Process ID function
+@findex @code{GETPID} intrinsic
+@cindex GETPID
+
+@table @asis
+@item @emph{Description}:
+Returns the numerical process identifier of the current process.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+function
+
+@item @emph{Syntax}:
+@code{I = GETPID()}
+
+@item @emph{Return value}:
+The return value of @code{GETPID} is an @code{INTEGER} of the default
+kind.
+
+
+@item @emph{Example}:
+@smallexample
+program info
+ print *, "The current process ID is ", getpid()
+ print *, "Your numerical user ID is ", getuid()
+ print *, "Your numerical group ID is ", getgid()
+end program info
+@end smallexample
+
+@end table
+
+
+
+@node GETUID
+@section @code{GETUID} --- User ID function
+@findex @code{GETUID} intrinsic
+@cindex GETUID
+
+@table @asis
+@item @emph{Description}:
+Returns the numerical user ID of the current process.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+function
+
+@item @emph{Syntax}:
+@code{GETUID()}
+
+@item @emph{Return value}:
+The return value of @code{GETUID} is an @code{INTEGER} of the default
+kind.
+
+
+@item @emph{Example}:
+See @code{GETPID} for an example.
+
+@item @emph{See also}:
+@ref{GETPID}
+@end table
+
+
+
+@node GMTIME
+@section @code{GMTIME} --- Convert time to GMT info
+@findex @code{GMTIME}
+@cindex time function
+
+Not yet implemented in GNU Fortran.
+
+@table @asis
+@item @emph{Description}:
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+@item @emph{See also}:
+
+@end table
+
+
+
+@node HOSTNM
+@section @code{HOSTNM} --- Get system host name
+@findex @code{HOSTNM} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+@item @emph{See also}:
+@end table
+
+
+
+@node HUGE
+@section @code{HUGE} --- Largest number of a kind
+@findex @code{HUGE} intrinsic
+@cindex huge
+
+@table @asis
+@item @emph{Description}:
+@code{HUGE(X)} returns the largest number that is not an infinity in
+the model of the type of @code{X}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{Y = HUGE(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab shall be of type @code{REAL} or @code{INTEGER}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of the same type and kind as @var{X}
+
+@item @emph{Example}:
+@smallexample
+program test_huge_tiny
+ print *, huge(0), huge(0.0), huge(0.0d0)
+ print *, tiny(0.0), tiny(0.0d0)
+end program test_huge_tiny
+@end smallexample
+@end table
+
+
+
+@node IACHAR
+@section @code{IACHAR} --- Code in @acronym{ASCII} collating sequence
+@findex @code{IACHAR} intrinsic
+@cindex @acronym{ASCII} collating sequence
+@cindex conversion function (character)
+
+@table @asis
+@item @emph{Description}:
+@code{IACHAR(C)} returns the code for the @acronym{ASCII} character
+in the first character position of @code{C}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{I = IACHAR(C)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{C} @tab Shall be a scalar @code{CHARACTER}, with @code{INTENT(IN)}
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{INTEGER} and of the default integer
+kind.
+
+@item @emph{Example}:
+@smallexample
+program test_iachar
+ integer i
+ i = iachar(' ')
+end program test_iachar
+@end smallexample
+
+@item @emph{See also}:
+@ref{CHAR},@ref{ICHAR}
+
+@end table
+
+
+@node IAND
+@section @code{IAND} --- Bitwise logical and
+@findex @code{IAND} intrinsic
+@cindex bit operations
+
+@table @asis
+@item @emph{Description}:
+Bitwise logical @code{AND}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = IAND(X, Y)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type shall be @code{INTEGER(*)}.
+@item @var{Y} @tab The type shall be @code{INTEGER(*)}.
+@end multitable
+
+@item @emph{Return value}:
+The return type is @code{INTEGER(*)} after cross-promotion of the arguments.
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_iand
+ INTEGER :: a, b
+ DATA a / Z'F' /, b / Z'3' /
+ WRITE (*,*) IAND(a, b)
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+@ref{IOR}, @ref{IEOR}, @ref{IBITS}, @ref{IBSET}, @ref{IBCLR},
+@end table
+
+
+
+@node IARGC
+@section @code{IARGC} --- Get the number of command line arguments
+@findex @code{IARGC} intrinsic
+@cindex command line arguments
+@cindex getopt
+
+@table @asis
+@item @emph{Description}:
+@code{IARGC()} returns the number of arguments passed on the
+command line when the containing program was invoked.
+
+This intrinsic routine is provided for backwards compatibility with
+GNU Fortran 77. In new code, programmers should consider the use of
+the @ref{COMMAND_ARGUMENT_COUNT} intrinsic defined by the Fortran 2003
+standard.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Non-elemental Function
+
+@item @emph{Syntax}:
+@code{I = IARGC()}
+
+@item @emph{Arguments}:
+None.
+
+@item @emph{Return value}:
+The number of command line arguments, type @code{INTEGER(4)}.
+
+@item @emph{Example}:
+See @ref{GETARG}
+
+@item @emph{See also}:
+GNU Fortran 77 compability subroutine: @ref{GETARG}
+
+F2003 functions and subroutines: @ref{GET_COMMAND}, @ref{GET_COMMAND_ARGUMENT}, @ref{COMMAND_ARGUMENT_COUNT}
+@end table
+
+
+
+@node IBCLR
+@section @code{IBCLR} --- Clear bit
+@findex @code{IBCLR} intrinsic
+@cindex bit operations
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+
+@item @emph{See also}:
+@ref{IBITS}, @ref{IBSET}, @ref{IAND}, @ref{IOR}, @ref{IEOR}
+@end table
+
+
+
+
+@node IBITS
+@section @code{IBITS} --- Bit extraction
+@findex @code{IBITS} intrinsic
+@cindex bit operations
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+@item @emph{See also}:
+@ref{IBCLR}, @ref{IBSET}, @ref{IAND}, @ref{IOR}, @ref{IEOR}
+
+@end table
+
+
+
+
+@node IBSET
+@section @code{IBSET} --- Set bit
+@findex @code{IBSET} intrinsic
+@cindex bit operations
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+
+@item @emph{See also}:
+@ref{IBCLR}, @ref{IBITS}, @ref{IAND}, @ref{IOR}, @ref{IEOR}
+
+@end table
+
+
+
+@node ICHAR
+@section @code{ICHAR} --- Character-to-integer conversion function
+@findex @code{ICHAR} intrinsic
+@cindex conversion function (character)
+
+@table @asis
+@item @emph{Description}:
+@code{ICHAR(C)} returns the code for the character in the first character
+position of @code{C} in the system's native character set.
+The correspondence between characters and their codes is not necessarily
+the same across different GNU Fortran implementations.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{I = ICHAR(C)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{C} @tab Shall be a scalar @code{CHARACTER}, with @code{INTENT(IN)}
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{INTEGER} and of the default integer
+kind.
+
+@item @emph{Example}:
+@smallexample
+program test_ichar
+ integer i
+ i = ichar(' ')
+end program test_ichar
+@end smallexample
+
+@item @emph{Note}:
+No intrinsic exists to convert a printable character string to a numerical
+value. For example, there is no intrinsic that, given the @code{CHARACTER}
+value 154, returns an @code{INTEGER} or @code{REAL} value with the
+value 154.
+
+Instead, you can use internal-file I/O to do this kind of conversion. For
+example:
+@smallexample
+program read_val
+ integer value
+ character(len=10) string
+
+ string = '154'
+ read (string,'(I10)') value
+ print *, value
+end program read_val
+@end smallexample
+@end table
+
+@node IDATE
+@section @code{IDATE} --- Get current local time subroutine (day/month/year)
+@findex @code{IDATE} intrinsic
+
+@table @asis
+@item @emph{Description}:
+@code{IDATE(TARRAY)} Fills @var{TARRAY} with the numerical values at the
+current local time. The day (in the range 1-31), month (in the range 1-12),
+and year appear in elements 1, 2, and 3 of @var{TARRAY}, respectively.
+The year has four significant digits.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@code{CALL IDATE(TARRAY)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{TARRAY} @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.
+
+@item @emph{Example}:
+@smallexample
+program test_idate
+ integer, dimension(3) :: tarray
+ call idate(tarray)
+ print *, tarray(1)
+ print *, tarray(2)
+ print *, tarray(3)
+end program test_idate
+@end smallexample
+@end table
+
+
+
+@node IEOR
+@section @code{IEOR} --- Bitwise logical exclusive or
+@findex @code{IEOR} intrinsic
+@cindex bit operations
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+
+@item @emph{See also}:
+@ref{IOR}, @ref{IAND}, @ref{IBITS}, @ref{IBSET}, @ref{IBCLR},
+@end table
+
+
+
+
+@node IERRNO
+@section @code{IERRNO} --- Get the last system error number
+@findex @code{IERRNO} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+
+@item @emph{See also}:
+@ref{PERROR}
+@end table
+
+
+
+
+@node INDEX
+@section @code{INDEX} --- Position of a substring within a string
+@findex @code{INDEX} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+@item @emph{See also}:
+@end table
+
+
+
+
+@node INT
+@section @code{INT} --- Convert to integer type
+@findex @code{INT} intrinsic
+@findex @code{IFIX} intrinsic
+@findex @code{IDINT} intrinsic
+@cindex conversion function (integer)
+
+@table @asis
+@item @emph{Description}:
+Convert to integer type
+
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@multitable @columnfractions .30 .80
+@item @code{X = INT(X)}
+@item @code{X = INT(X, KIND)}
+@end multitable
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab shall be of type @code{INTEGER(*)}, @code{REAL(*)} or @code{COMPLEX(*)}
+@item @var{KIND} @tab (Optional) @var{KIND} shall be a scalar integer.
+@end multitable
+
+@item @emph{Return value}:
+These functions return a @code{INTEGER(*)} variable or array under
+the following rules:
+
+@table @asis
+@item (A)
+If @var{X} is of type @code{INTEGER(*)}, @code{INT(X) = X}
+@item (B)
+If @var{X} is of type @code{REAL(*)} and @math{|X| < 1} @code{INT(X)} equals @var{0}.
+If @math{|X| \geq 1}, then @code{INT(X)} equals the largest integer that does not exceed
+the range of @var{X} and whose sign is the same as the sign of @var{X}.
+@item (C)
+If @var{X} is of type @code{COMPLEX(*)}, rule B is applied to the real part of X.
+@end table
+
+@item @emph{Example}:
+@smallexample
+program test_int
+ integer :: i = 42
+ complex :: z = (-3.7, 1.0)
+ print *, int(i)
+ print *, int(z), int(z,8)
+end program
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@item Name @tab Argument @tab Return type @tab Standard
+@item @code{IFIX(X)} @tab @code{REAL(4) X} @tab @code{INTEGER} @tab F77 and later
+@item @code{IDINT(X)} @tab @code{REAL(8) X} @tab @code{INTEGER} @tab F77 and later
+@end multitable
+
+@comment @item @emph{See also}:
+@end table
+
+
+
+
+@node IOR
+@section @code{IOR} --- Bitwise logical or
+@findex @code{IOR} intrinsic
+@cindex bit operations
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+
+@item @emph{See also}:
+@ref{IEOR}, @ref{IAND}, @ref{IBITS}, @ref{IBSET}, @ref{IBCLR},
+@end table
+
+
+
+
+@node IRAND
+@section @code{IRAND} --- Integer pseudo-random number
+@findex @code{IRAND} intrinsic
+@cindex random number
+
+@table @asis
+@item @emph{Description}:
+@code{IRAND(FLAG)} returns a pseudo-random number from a uniform
+distribution between 0 and a system-dependent limit (which is in most
+cases 2147483647). If @var{FLAG} is 0, the next number
+in the current sequence is returned; if @var{FLAG} is 1, the generator
+is restarted by @code{CALL SRAND(0)}; if @var{FLAG} has any other value,
+it is used as a new seed with @code{SRAND}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+non-elemental function
+
+@item @emph{Syntax}:
+@code{I = IRAND(FLAG)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{FLAG} @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 ISHFT
+@section @code{ISHFT} --- Shift bits
+@findex @code{ISHFT} intrinsic
+@cindex bit manipulation
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+
+@item @emph{See also}:
+@ref{ISHFTC}
+@end table
+
+
+
+
+@node ISHFTC
+@section @code{ISHFTC} --- Shift bits circularly
+@findex @code{ISHFTC} intrinsic
+@cindex bit manipulation
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+
+@item @emph{See also}:
+@ref{ISHFT}
+@end table
+
+
+
+@node ITIME
+@section @code{ITIME} --- Get current local time subroutine (hour/minutes/seconds)
+@findex @code{ITIME} intrinsic
+
+@table @asis
+@item @emph{Description}:
+@code{IDATE(TARRAY)} Fills @var{TARRAY} 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},
+respectively.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@code{CALL ITIME(TARRAY)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{TARRAY} @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.
+
+
+@item @emph{Example}:
+@smallexample
+program test_itime
+ integer, dimension(3) :: tarray
+ call itime(tarray)
+ print *, tarray(1)
+ print *, tarray(2)
+ print *, tarray(3)
+end program test_itime
+@end smallexample
+@end table
+
+
+
+@node KILL
+@section @code{KILL} --- Send a signal to a process
+@findex @code{KILL} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+
+@item @emph{See also}:
+@ref{ABORT}, @ref{EXIT}
+@end table
+
+
+
+@node KIND
+@section @code{KIND} --- Kind of an entity
+@findex @code{KIND} intrinsic
+
+@table @asis
+@item @emph{Description}:
+@code{KIND(X)} returns the kind value of the entity @var{X}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@code{K = KIND(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab Shall be of type @code{LOGICAL}, @code{INTEGER},
+@code{REAL}, @code{COMPLEX} or @code{CHARACTER}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is a scalar of type @code{INTEGER} and of the default
+integer kind.
+
+@item @emph{Example}:
+@smallexample
+program test_kind
+ integer,parameter :: kc = kind(' ')
+ integer,parameter :: kl = kind(.true.)
+
+ print *, "The default character kind is ", kc
+ print *, "The default logical kind is ", kl
+end program test_kind
+@end smallexample
+
+@end table
+
+
+
+@node LBOUND
+@section @code{LBOUND} --- Lower dimension bounds of an array
+@findex @code{LBOUND} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@ref{UBOUND}
+@end table
+
+
+
+
+@node LEN
+@section @code{LEN} --- Length of a character entity
+@findex @code{LEN} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+
+@item @emph{See also}:
+@ref{LEN_TRIM}, @ref{ADJUSTL}, @ref{ADJUSTR}
+@end table
+
+
+
+
+@node LEN_TRIM
+@section @code{LEN_TRIM} --- Length of a character entity without trailing blank characters
+@findex @code{LEN_TRIM} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+
+@item @emph{See also}:
+@ref{LEN}, @ref{ADJUSTL}, @ref{ADJUSTR}
+@end table
+
+
+
+
+@node LGE
+@section @code{LGE} --- Lexical greater than or equal
+@findex @code{LGE} intrinsic
+@cindex comparison (lexical)
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+
+@item @emph{See also}:
+@ref{LGT}, @ref{LLE}, @ref{LLT}
+@end table
+
+
+
+
+@node LGT
+@section @code{LGT} --- Lexical greater than
+@findex @code{LGT} intrinsic
+@cindex comparison (lexical)
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+
+@item @emph{See also}:
+@ref{LGE}, @ref{LLE}, @ref{LLT}
+@end table
+
+
+
+
+@node LINK
+@section @code{LINK} --- Create a hard link
+@findex @code{LINK} intrinsic
+@cindex file system operations
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+
+@item @emph{See also}:
+@ref{UNLINK}
+@end table
+
+
+
+
+@node LLE
+@section @code{LLE} --- Lexical less than or equal
+@findex @code{LLE} intrinsic
+@cindex comparison (lexical)
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+
+@item @emph{See also}:
+@ref{LGE}, @ref{LGT}, @ref{LLT}
+@end table
+
+
+
+
+@node LLT
+@section @code{LLT} --- Lexical less than
+@findex @code{LLT} intrinsic
+@cindex comparison (lexical)
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+
+@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
+@findex @code{LNBLNK} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+
+@item @emph{See also}:
+@ref{INDEX}
+@end table
+
+
+
+
+@node LOC
+@section @code{LOC} --- Returns the address of a variable
+@findex @code{LOC} intrinsic
+@cindex loc
+
+@table @asis
+@item @emph{Description}:
+@code{LOC(X)} returns the address of @var{X} as an integer.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@code{I = LOC(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab Variable of any type.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{INTEGER(n)}, where @code{n} is the
+size (in bytes) of a memory address on the target machine.
+
+@item @emph{Example}:
+@smallexample
+program test_loc
+ integer :: i
+ real :: r
+ i = loc(r)
+ print *, i
+end program test_loc
+@end smallexample
+@end table
+
+@node LOG
+@section @code{LOG} --- Logarithm function
+@findex @code{LOG} intrinsic
+@findex @code{ALOG} intrinsic
+@findex @code{DLOG} intrinsic
+@findex @code{CLOG} intrinsic
+@findex @code{ZLOG} intrinsic
+@findex @code{CDLOG} intrinsic
+@cindex logarithm
+
+@table @asis
+@item @emph{Description}:
+@code{LOG(X)} computes the logarithm of @var{X}.
+
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = LOG(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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 kind type parameter is the same as @var{X}.
+
+@item @emph{Example}:
+@smallexample
+program test_log
+ real(8) :: x = 1.0_8
+ complex :: z = (1.0, 2.0)
+ x = log(x)
+ z = log(z)
+end program test_log
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@item Name @tab Argument @tab Return type @tab Standard
+@item @code{ALOG(X)} @tab @code{REAL(4) X} @tab @code{REAL(4)} @tab f95, gnu
+@item @code{DLOG(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab f95, gnu
+@item @code{CLOG(X)} @tab @code{COMPLEX(4) X} @tab @code{COMPLEX(4)} @tab f95, gnu
+@item @code{ZLOG(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab f95, gnu
+@item @code{CDLOG(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab f95, gnu
+@end multitable
+@end table
+
+
+
+@node LOG10
+@section @code{LOG10} --- Base 10 logarithm function
+@findex @code{LOG10} intrinsic
+@findex @code{ALOG10} intrinsic
+@findex @code{DLOG10} intrinsic
+@cindex logarithm
+
+@table @asis
+@item @emph{Description}:
+@code{LOG10(X)} computes the base 10 logarithm of @var{X}.
+
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = LOG10(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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 kind type parameter is the same as @var{X}.
+
+@item @emph{Example}:
+@smallexample
+program test_log10
+ real(8) :: x = 10.0_8
+ x = log10(x)
+end program test_log10
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@end multitable
+@end table
+
+
+@node LOGICAL
+@section @code{LOGICAL} --- Convert to logical type
+@findex @code{LOGICAL} intrinsic
+@cindex conversion function (logical)
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+@item @emph{See also}:
+@end table
+
+
+
+
+@node LSHIFT
+@section @code{LSHIFT} --- Left shift bits
+@findex @code{LSHIFT}
+@cindex bit manipulation
+
+Not yet implemented in GNU Fortran.
+
+@table @asis
+@item @emph{Description}:
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+@item @emph{See also}:
+
+@end table
+
+
+@node LSTAT
+@section @code{LSTAT} --- Get file status
+@findex @code{LSTAT} intrinsic
+@cindex file system operations
+
+@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.
+
+The elements in @code{BUFF} are the same as described by @ref{STAT}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Non-elemental subroutine
+
+@item @emph{Syntax}:
+@code{CALL LSTAT(FILE,BUFF[,STATUS])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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.
+@end multitable
+
+@item @emph{Example}:
+See @ref{STAT} for an example.
+
+@item @emph{See also}:
+To stat an open file: @ref{FSTAT}, to stat a file: @ref{STAT}
+@end table
+
+
+
+@node LTIME
+@section @code{LTIME} --- Convert time to local time info
+@findex @code{LTIME}
+@cindex time function
+
+Not yet implemented in GNU Fortran.
+
+@table @asis
+@item @emph{Description}:
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+@item @emph{See also}:
+
+@end table
+
+
+
+@node MALLOC
+@section @code{MALLOC} --- Allocate dynamic memory
+@findex @code{MALLOC} intrinsic
+@cindex MALLOC
+
+@table @asis
+@item @emph{Description}:
+@code{MALLOC(SIZE)} allocates @var{SIZE} bytes of dynamic memory and
+returns the address of the allocated memory. The @code{MALLOC} intrinsic
+is an extension intended to be used with Cray pointers, and is provided
+in GNU Fortran to allow the user to compile legacy code. For new code
+using Fortran 95 pointers, the memory allocation intrinsic is
+@code{ALLOCATE}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+non-elemental function
+
+@item @emph{Syntax}:
+@code{PTR = MALLOC(SIZE)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{SIZE} @tab The type shall be @code{INTEGER(*)}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{INTEGER(K)}, with @var{K} such that
+variables of type @code{INTEGER(K)} have the same size as
+C pointers (@code{sizeof(void *)}).
+
+@item @emph{Example}:
+The following example demonstrates the use of @code{MALLOC} and
+@code{FREE} with Cray pointers. This example is intended to run on
+32-bit systems, where the default integer kind is suitable to store
+pointers; on 64-bit systems, ptr_x would need to be declared as
+@code{integer(kind=8)}.
+
+@smallexample
+program test_malloc
+ integer i
+ integer ptr_x
+ real*8 x(*), z
+ pointer(ptr_x,x)
+
+ ptr_x = malloc(20*8)
+ do i = 1, 20
+ x(i) = sqrt(1.0d0 / i)
+ end do
+ z = 0
+ do i = 1, 20
+ z = z + x(i)
+ print *, z
+ end do
+ call free(ptr_x)
+end program test_malloc
+@end smallexample
+
+@item @emph{See also}:
+@ref{FREE}
+@end table
+
+
+@node MATMUL
+@section @code{MATMUL} --- matrix multiplication
+@findex @code{MATMUL} intrinsic
+@cindex matrix operations
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@end table
+
+
+@node MAX
+@section @code{MAX} --- Maximum value of an argument list
+@findex @code{MAX} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@end multitable
+
+@item @emph{See also}:
+@ref{MAXLOC} @ref{MAXVAL}
+@end table
+
+
+@node MAXEXPONENT
+@section @code{MAXEXPONENT} --- Maximum exponent of a real kind
+@findex @code{MAXEXPONENT} intrinsic
+@cindex MAXEXPONENT
+
+@table @asis
+@item @emph{Description}:
+@code{MAXEXPONENT(X)} returns the maximum exponent in the model of the
+type of @code{X}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@code{I = MAXEXPONENT(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab shall be of type @code{REAL}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{INTEGER} and of the default integer
+kind.
+
+@item @emph{Example}:
+@smallexample
+program exponents
+ real(kind=4) :: x
+ real(kind=8) :: y
+
+ print *, minexponent(x), maxexponent(x)
+ print *, minexponent(y), maxexponent(y)
+end program exponents
+@end smallexample
+@end table
+
+
+@node MAXLOC
+@section @code{MAXLOC} --- Location of the maximum value within an array
+@findex @code{MAXLOC} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@ref{MAX}, @ref{MAXVAL}
+@end table
+
+
+
+@node MAXVAL
+@section @code{MAXVAL} --- Maximum value of an array
+@findex @code{MAXVAL} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+
+@item @emph{See also}:
+@ref{MAX}, @ref{MAXLOC}
+@end table
+
+
+
+
+@node MERGE
+@section @code{MERGE} --- Merge arrays
+@findex @code{MERGE} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+@item @emph{See also}:
+@end table
+
+
+@node MIN
+@section @code{MIN} --- Minimum value of an argument list
+@findex @code{MIN} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@end multitable
+
+@item @emph{See also}:
+@ref{MINLOC}, @ref{MINVAL}
+@end table
+
+@node MINEXPONENT
+@section @code{MINEXPONENT} --- Minimum exponent of a real kind
+@findex @code{MINEXPONENT} intrinsic
+@cindex MINEXPONENT
+
+@table @asis
+@item @emph{Description}:
+@code{MINEXPONENT(X)} returns the minimum exponent in the model of the
+type of @code{X}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@code{I = MINEXPONENT(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab shall be of type @code{REAL}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{INTEGER} and of the default integer
+kind.
+
+@item @emph{Example}:
+See @code{MAXEXPONENT} for an example.
+@end table
+
+
+@node MINLOC
+@section @code{MINLOC} --- Location of the minimum value within an array
+@findex @code{MINLOC} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+
+@item @emph{See also}:
+@ref{MIN}, @ref{MINVAL}
+
+@end table
+
+
+@node MINVAL
+@section @code{MINVAL} --- Minimum value of an array
+@findex @code{MINVAL} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+
+@item @emph{See also}:
+@ref{MIN}, @ref{MINLOC}
+@end table
+
+
+
+
+@node MOD
+@section @code{MOD} --- Remainder function
+@findex @code{MOD} intrinsic
+@findex @code{AMOD} intrinsic
+@findex @code{DMOD} intrinsic
+@cindex remainder
+
+@table @asis
+@item @emph{Description}:
+@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
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = MOD(A,P)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{A} @tab shall be a scalar of type @code{INTEGER} or @code{REAL}
+@item @var{P} @tab shall be a scalar of the same type as @var{A} and not
+equal to zero
+@end multitable
+
+@item @emph{Return value}:
+The kind of the return value is the result of cross-promoting
+the kinds of the arguments.
+
+@item @emph{Example}:
+@smallexample
+program test_mod
+ print *, mod(17,3)
+ print *, mod(17.5,5.5)
+ print *, mod(17.5d0,5.5)
+ print *, mod(17.5,5.5d0)
+
+ print *, mod(-17,3)
+ print *, mod(-17.5,5.5)
+ print *, mod(-17.5d0,5.5)
+ print *, mod(-17.5,5.5d0)
+
+ print *, mod(17,-3)
+ print *, mod(17.5,-5.5)
+ print *, mod(17.5d0,-5.5)
+ print *, mod(17.5,-5.5d0)
+end program test_mod
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@end multitable
+@end table
+
+
+
+@node MODULO
+@section @code{MODULO} --- Modulo function
+@findex @code{MODULO} intrinsic
+@cindex modulo
+
+@table @asis
+@item @emph{Description}:
+@code{MODULO(A,P)} computes the @var{A} modulo @var{P}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = MODULO(A,P)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{A} @tab shall be a scalar of type @code{INTEGER} or @code{REAL}
+@item @var{P} @tab shall be a scalar of the same type and kind as @var{A}
+@end multitable
+
+@item @emph{Return value}:
+The type and kind of the result are those of the arguments.
+@table @asis
+@item If @var{A} and @var{P} are of type @code{INTEGER}:
+@code{MODULO(A,P)} has the value @var{R} such that @code{A=Q*P+R}, where
+@var{Q} is an integer and @var{R} is between 0 (inclusive) and @var{P}
+(exclusive).
+@item If @var{A} and @var{P} are of type @code{REAL}:
+@code{MODULO(A,P)} has the value of @code{A - FLOOR (A / P) * P}.
+@end table
+In all cases, if @var{P} is zero the result is processor-dependent.
+
+@item @emph{Example}:
+@smallexample
+program test_modulo
+ print *, modulo(17,3)
+ print *, modulo(17.5,5.5)
+
+ print *, modulo(-17,3)
+ print *, modulo(-17.5,5.5)
+
+ print *, modulo(17,-3)
+ print *, modulo(17.5,-5.5)
+end program test_mod
+@end smallexample
+
+@end table
+
+
+
+@node MVBITS
+@section @code{MVBITS} --- Move bits from one integer to another
+@findex @code{MVBITS} intrinsic
+@cindex bit operations
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental subroutine
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@end table
+
+
+
+
+@node MOVE_ALLOC
+@section @code{MOVE_ALLOC} --- Move allocation from one object to another
+@findex @code{MOVE_ALLOC} intrinsic
+@cindex MOVE_ALLOC
+
+@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.
+
+@item @emph{Standard}:
+F2003 and later
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@code{CALL MOVE_ALLOC(SRC, DEST)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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}
+@end multitable
+
+@item @emph{Return value}:
+None
+
+@item @emph{Example}:
+@smallexample
+program test_move_alloc
+ integer, allocatable :: a(:), b(:)
+
+ allocate(a(3))
+ a = [ 1, 2, 3 ]
+ call move_alloc(a, b)
+ print *, allocated(a), allocated(b)
+ print *, b
+end program test_move_alloc
+@end smallexample
+@end table
+
+
+
+@node NEAREST
+@section @code{NEAREST} --- Nearest representable number
+@findex @code{NEAREST} intrinsic
+@cindex processor-representable number
+
+@table @asis
+@item @emph{Description}:
+@code{NEAREST(X, S)} returns the processor-representable number nearest
+to @code{X} in the direction indicated by the sign of @code{S}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{Y = NEAREST(X, S)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab shall be of type @code{REAL}.
+@item @var{S} @tab (Optional) shall be of type @code{REAL} and
+not equal to zero.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of the same type as @code{X}. If @code{S} is
+positive, @code{NEAREST} returns the processor-representable number
+greater than @code{X} and nearest to it. If @code{S} is negative,
+@code{NEAREST} returns the processor-representable number smaller than
+@code{X} and nearest to it.
+
+@item @emph{Example}:
+@smallexample
+program test_nearest
+ real :: x, y
+ x = nearest(42.0, 1.0)
+ y = nearest(42.0, -1.0)
+ write (*,"(3(G20.15))") x, y, x - y
+end program test_nearest
+@end smallexample
+@end table
+
+
+
+@node NEW_LINE
+@section @code{NEW_LINE} --- New line character
+@findex @code{NEW_LINE} intrinsic
+@findex @code{NEW_LINE} intrinsic
+
+@table @asis
+@item @emph{Description}:
+@code{NEW_LINE(C)} returns the new-line character
+
+@item @emph{Standard}:
+F2003 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{C = NEW_LINE(C)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{C} @tab The argument shall be a scalar or array of the
+ type @code{CHARACTER}.
+@end multitable
+
+@item @emph{Return value}:
+Returns a @var{CHARACTER} scalar of length one with the new-line character of
+the same kind as parameter @var{C}.
+
+@item @emph{Example}:
+@smallexample
+program newline
+ implicit none
+ write(*,'(A)') 'This is record 1.'//NEW_LINE('A')//'This is record 2.'
+end program newline
+@end smallexample
+@end table
+
+
+
+@node NINT
+@section @code{NINT} --- Nearest whole number
+@findex @code{NINT} intrinsic
+@findex @code{IDNINT} intrinsic
+@cindex whole number
+
+@table @asis
+@item @emph{Description}:
+@code{NINT(X)} rounds its argument to the nearest whole number.
+
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = NINT(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type of the argument shall be @code{REAL}.
+@end multitable
+
+@item @emph{Return value}:
+Returns @var{A} with the fractional portion of its magnitude eliminated by
+rounding to the nearest whole number and with its sign preserved,
+converted to an @code{INTEGER} of the default kind.
+
+@item @emph{Example}:
+@smallexample
+program test_nint
+ real(4) x4
+ real(8) x8
+ x4 = 1.234E0_4
+ x8 = 4.321_8
+ print *, nint(x4), idnint(x8)
+end program test_nint
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .33 .33 .33
+@item Name @tab Argument @tab Standard
+@item @code{IDNINT(X)} @tab @code{REAL(8)} @tab F95 and later
+@end multitable
+
+@item @emph{See also}:
+@ref{CEILING}, @ref{FLOOR}
+
+@end table
+
+
+@node NOT
+@section @code{NOT} --- Logical negation
+@findex @code{NOT} intrinsic
+@cindex logical operations
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@end table
+
+
+
+
+@node NULL
+@section @code{NULL} --- Function that returns an disassociated pointer
+@findex @code{NULL} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@ref{ASSOCIATED}
+@end table
+
+
+
+
+@node OR
+@section @code{OR} --- Bitwise logical OR
+@findex @code{OR} intrinsic
+@cindex bit operations
+
+@table @asis
+@item @emph{Description}:
+Bitwise logical @code{OR}.
+
+This intrinsic routine is provided for backwards compatibility with
+GNU Fortran 77. For integer arguments, programmers should consider
+the use of the @ref{IOR} intrinsic defined by the Fortran standard.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Non-elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = OR(X, Y)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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}.
+@end multitable
+
+@item @emph{Return value}:
+The return type is either @code{INTEGER(*)} or @code{LOGICAL}
+after cross-promotion of the arguments.
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_or
+ LOGICAL :: T = .TRUE., F = ..FALSE.
+ INTEGER :: a, b
+ DATA a / Z'F' /, b / Z'3' /
+
+ WRITE (*,*) OR(T, T), OR(T, F), OR(F, T), OR(F, F)
+ WRITE (*,*) OR(a, b)
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+F95 elemental function: @ref{IOR}
+@end table
+
+
+
+
+@node PACK
+@section @code{PACK} --- Pack an array into an array of rank one
+@findex @code{PACK} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+@item @emph{See also}:
+@ref{UNPACK}
+@end table
+
+
+
+
+@node PERROR
+@section @code{PERROR} --- Print system error message
+@findex @code{PERROR} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+@item @emph{See also}:
+@ref{IERRNO}
+@end table
+
+
+
+
+@node PRECISION
+@section @code{PRECISION} --- Decimal precision of a real kind
+@findex @code{PRECISION} intrinsic
+@cindex PRECISION
+
+@table @asis
+@item @emph{Description}:
+@code{PRECISION(X)} returns the decimal precision in the model of the
+type of @code{X}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@code{I = PRECISION(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab shall be of type @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{Example}:
+@smallexample
+program prec_and_range
+ real(kind=4) :: x(2)
+ complex(kind=8) :: y
+
+ print *, precision(x), range(x)
+ print *, precision(y), range(y)
+end program prec_and_range
+@end smallexample
+@end table
+
+
+
+@node PRESENT
+@section @code{PRESENT} --- Determine whether an optional argument is specified
+@findex @code{PRESENT} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@end table
+
+
+
+
+@node PRODUCT
+@section @code{PRODUCT} --- Product of array elements
+@findex @code{PRODUCT} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+@item @emph{See also}:
+@ref{SUM}
+@end table
+
+
+
+
+@node RADIX
+@section @code{RADIX} --- Base of a model number
+@findex @code{RADIX} intrinsic
+@cindex base
+
+@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
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@code{R = RADIX(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab Shall be of type @code{INTEGER} or @code{REAL}
+@end multitable
+
+@item @emph{Return value}:
+The return value is a scalar of type @code{INTEGER} and of the default
+integer kind.
+
+@item @emph{Example}:
+@smallexample
+program test_radix
+ print *, "The radix for the default integer kind is", radix(0)
+ print *, "The radix for the default real kind is", radix(0.0)
+end program test_radix
+@end smallexample
+
+@end table
+
+
+
+@node RANDOM_NUMBER
+@section @code{RANDOM_NUMBER} --- Pseudo-random number
+@findex @code{RANDOM_NUMBER} intrinsic
+@cindex random numbers
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental subroutine
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@ref{RANDOM_SEED}
+@end table
+
+
+
+
+@node RANDOM_SEED
+@section @code{RANDOM_SEED} --- Initialize a pseudo-random number sequence
+@findex @code{RANDOM_SEED} intrinsic
+@cindex random numbers
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@ref{RANDOM_NUMBER}
+@end table
+
+
+
+
+@node RAND
+@section @code{RAND} --- Real pseudo-random number
+@findex @code{RAND} intrinsic
+@findex @code{RAN} intrinsic
+@cindex random number
+
+@table @asis
+@item @emph{Description}:
+@code{RAND(FLAG)} returns a pseudo-random number from a uniform
+distribution between 0 and 1. If @var{FLAG} is 0, the next number
+in the current sequence is returned; if @var{FLAG} is 1, the generator
+is restarted by @code{CALL SRAND(0)}; if @var{FLAG} has any other value,
+it is used as a new seed with @code{SRAND}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+non-elemental function
+
+@item @emph{Syntax}:
+@code{X = RAND(FLAG)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{FLAG} @tab shall be a scalar @code{INTEGER} of kind 4.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of @code{REAL} type and the default kind.
+
+@item @emph{Example}:
+@smallexample
+program test_rand
+ integer,parameter :: seed = 86456
+
+ call srand(seed)
+ print *, rand(), rand(), rand(), rand()
+ print *, rand(seed), rand(), rand(), rand()
+end program test_rand
+@end smallexample
+
+@item @emph{Note}:
+For compatibility with HP FORTRAN 77/iX, the @code{RAN} intrinsic is
+provided as an alias for @code{RAND}.
+
+@item @emph{See also}:
+@ref{SRAND}, @ref{RANDOM_NUMBER}
+
+@end table
+
+
+
+@node RANGE
+@section @code{RANGE} --- Decimal exponent range of a real kind
+@findex @code{RANGE} intrinsic
+@cindex RANGE
+
+@table @asis
+@item @emph{Description}:
+@code{RANGE(X)} returns the decimal exponent range in the model of the
+type of @code{X}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@code{I = RANGE(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab shall be of type @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{Example}:
+See @code{PRECISION} for an example.
+@end table
+
+
+
+@node RAN
+@section @code{RAN} --- Real pseudo-random number
+@findex @code{RAN} intrinsic
+@cindex random number
+
+@table @asis
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{See also}:
+@ref{RAND}, @ref{RANDOM_NUMBER}
+@end table
+
+
+
+@node REAL
+@section @code{REAL} --- Convert to real type
+@findex @code{REAL} intrinsic
+@findex @code{REALPART} intrinsic
+@cindex true values
+
+@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},
+and its use is strongly discouraged.
+
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@multitable @columnfractions .30 .80
+@item @code{X = REAL(X)}
+@item @code{X = REAL(X, KIND)}
+@item @code{X = REALPART(Z)}
+@end multitable
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab shall be @code{INTEGER(*)}, @code{REAL(*)}, or
+@code{COMPLEX(*)}.
+@item @var{KIND} @tab (Optional) @var{KIND} shall be a scalar integer.
+@end multitable
+
+@item @emph{Return value}:
+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
+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.
+@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
+variable.
+@end table
+
+@item @emph{Example}:
+@smallexample
+program test_real
+ complex :: x = (1.0, 2.0)
+ print *, real(x), real(x,8), realpart(x)
+end program test_real
+@end smallexample
+
+@item @emph{See also}:
+@ref{DBLE}, @ref{DFLOAT}, @ref{FLOAT}
+
+@end table
+
+
+@node RENAME
+@section @code{RENAME} --- Rename a file
+@findex @code{RENAME} intrinsic
+@cindex file system operations
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@end table
+
+
+
+
+@node REPEAT
+@section @code{REPEAT} --- Repeated string concatenation
+@findex @code{REPEAT} intrinsic
+@cindex string manipulation
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@end table
+
+
+
+
+@node RESHAPE
+@section @code{RESHAPE} --- Function to reshape an array
+@findex @code{RESHAPE} intrinsic
+@cindex array manipulation
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@ref{SHAPE}
+@end table
+
+
+
+@node RRSPACING
+@section @code{RRSPACING} --- Reciprocal of the relative spacing
+@findex @code{RRSPACING} intrinsic
+
+@table @asis
+@item @emph{Description}:
+@code{RRSPACING(X)} returns the reciprocal of the relative spacing of
+model numbers near @var{X}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{Y = RRSPACING(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab shall be of type @code{REAL}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of the same type and kind as @var{X}.
+The value returned is equal to
+@code{ABS(FRACTION(X)) * FLOAT(RADIX(X))**DIGITS(X)}.
+
+@end table
+
+
+
+@node RSHIFT
+@section @code{RSHIFT} --- Right shift bits
+@findex @code{RSHIFT}
+@cindex bit manipulation
+
+Not yet implemented in GNU Fortran.
+
+@table @asis
+@item @emph{Description}:
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+
+@end table
+
+
+
+@node SCALE
+@section @code{SCALE} --- Scale a real value
+@findex @code{SCALE} intrinsic
+
+@table @asis
+@item @emph{Description}:
+@code{SCALE(X,I)} returns @code{X * RADIX(X)**I}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{Y = SCALE(X, I)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type of the argument shall be a @code{REAL}.
+@item @var{I} @tab The type of the argument shall be a @code{INTEGER}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of the same type and kind as @var{X}.
+Its value is @code{X * RADIX(X)**I}.
+
+@item @emph{Example}:
+@smallexample
+program test_scale
+ real :: x = 178.1387e-4
+ integer :: i = 5
+ print *, scale(x,i), x*radix(x)**i
+end program test_scale
+@end smallexample
+
+@end table
+
+
+@node SCAN
+@section @code{SCAN} --- Scan a string for the presence of a set of characters
+@findex @code{SCAN} intrinsic
+@cindex string manipulation
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@end table
+
+
+
+
+@node SECNDS
+@section @code{SECNDS} --- Time function
+@findex @code{SECNDS} intrinsic
+@cindex SECNDS
+
+@table @asis
+@item @emph{Description}:
+@code{SECNDS(X)} gets the time in seconds from the real-time system clock.
+@var{X} is a reference time, also in seconds. If this is zero, the time in
+seconds from midnight is returned. This function is non-standard and its
+use is discouraged.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+function
+
+@item @emph{Syntax}:
+@code{T = SECNDS (X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item Name @tab Type
+@item @var{T} @tab REAL(4)
+@item @var{X} @tab REAL(4)
+@end multitable
+
+@item @emph{Return value}:
+None
+
+@item @emph{Example}:
+@smallexample
+program test_secnds
+ real(4) :: t1, t2
+ print *, secnds (0.0) ! seconds since midnight
+ t1 = secnds (0.0) ! reference time
+ do i = 1, 10000000 ! do something
+ end do
+ t2 = secnds (t1) ! elapsed time
+ print *, "Something took ", t2, " seconds."
+end program test_secnds
+@end smallexample
+@end table
+
+
+
+@node SELECTED_INT_KIND
+@section @code{SELECTED_INT_KIND} --- Choose integer kind
+@findex @code{SELECTED_INT_KIND} intrinsic
+@cindex integer kind
+
+@table @asis
+@item @emph{Description}:
+@code{SELECTED_INT_KIND(I)} return the kind value of the smallest integer
+type that can represent all values ranging from @math{-10^I} (exclusive)
+to @math{10^I} (exclusive). If there is no integer kind that accommodates
+this range, @code{SELECTED_INT_KIND} returns @math{-1}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@multitable @columnfractions .30 .80
+@item @code{J = SELECTED_INT_KIND(I)}
+@end multitable
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{I} @tab shall be a scalar and of type @code{INTEGER}.
+@end multitable
+
+@item @emph{Example}:
+@smallexample
+program large_integers
+ integer,parameter :: k5 = selected_int_kind(5)
+ integer,parameter :: k15 = selected_int_kind(15)
+ integer(kind=k5) :: i5
+ integer(kind=k15) :: i15
+
+ print *, huge(i5), huge(i15)
+
+ ! The following inequalities are always true
+ print *, huge(i5) >= 10_k5**5-1
+ print *, huge(i15) >= 10_k15**15-1
+end program large_integers
+@end smallexample
+@end table
+
+
+
+@node SELECTED_REAL_KIND
+@section @code{SELECTED_REAL_KIND} --- Choose real kind
+@findex @code{SELECTED_REAL_KIND} intrinsic
+@cindex real kind
+
+@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}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@multitable @columnfractions .30 .80
+@item @code{I = SELECTED_REAL_KIND(P,R)}
+@end multitable
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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}.
+@end multitable
+At least one argument shall be present.
+
+@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
+@table @asis
+@item -1 if the processor does not support a real data type with a
+precision greater than or equal to @code{P}
+@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.
+@end table
+
+@item @emph{Example}:
+@smallexample
+program real_kinds
+ integer,parameter :: p6 = selected_real_kind(6)
+ integer,parameter :: p10r100 = selected_real_kind(10,100)
+ integer,parameter :: r400 = selected_real_kind(r=400)
+ real(kind=p6) :: x
+ real(kind=p10r100) :: y
+ real(kind=r400) :: z
+
+ print *, precision(x), range(x)
+ print *, precision(y), range(y)
+ print *, precision(z), range(z)
+end program real_kinds
+@end smallexample
+@end table
+
+
+
+@node SET_EXPONENT
+@section @code{SET_EXPONENT} --- Set the exponent of the model
+@findex @code{SET_EXPONENT} intrinsic
+@cindex exponent
+
+@table @asis
+@item @emph{Description}:
+@code{SET_EXPONENT(X, I)} returns the real number whose fractional part
+is that that of @var{X} and whose exponent part if @var{I}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{Y = SET_EXPONENT(X, I)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab shall be of type @code{REAL}.
+@item @var{I} @tab shall be of type @code{INTEGER}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of the same type and kind as @var{X}.
+The real number whose fractional part
+is that that of @var{X} and whose exponent part if @var{I} is returned;
+it is @code{FRACTION(X) * RADIX(X)**I}.
+
+@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
+@end smallexample
+
+@end table
+
+
+
+@node SHAPE
+@section @code{SHAPE} --- Determine the shape of an array
+@findex @code{SHAPE} intrinsic
+@cindex array manipulation
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@ref{RESHAPE}
+@end table
+
+
+
+
+@node SIGN
+@section @code{SIGN} --- Sign copying function
+@findex @code{SIGN} intrinsic
+@findex @code{ISIGN} intrinsic
+@findex @code{DSIGN} intrinsic
+@cindex sign copying
+
+@table @asis
+@item @emph{Description}:
+@code{SIGN(A,B)} returns the value of @var{A} with the sign of @var{B}.
+
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = SIGN(A,B)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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}
+@end multitable
+
+@item @emph{Return value}:
+The kind of the return value is that of @var{A} and @var{B}.
+If @math{B\ge 0} then the result is @code{ABS(A)}, else
+it is @code{-ABS(A)}.
+
+@item @emph{Example}:
+@smallexample
+program test_sign
+ print *, sign(-12,1)
+ print *, sign(-12,0)
+ print *, sign(-12,-1)
+
+ print *, sign(-12.,1.)
+ print *, sign(-12.,0.)
+ print *, sign(-12.,-1.)
+end program test_sign
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@end multitable
+@end table
+
+
+
+@node SIGNAL
+@section @code{SIGNAL} --- Signal handling subroutine (or function)
+@findex @code{SIGNAL} intrinsic
+@cindex SIGNAL subroutine
+
+@table @asis
+@item @emph{Description}:
+@code{SIGNAL(NUMBER, HANDLER [, STATUS])} causes external subroutine
+@var{HANDLER} to be executed with a single integer argument when signal
+@var{NUMBER} occurs. If @var{HANDLER} is an integer, it can be used to
+turn off handling of signal @var{NUMBER} or revert to its default
+action. See @code{signal(2)}.
+
+If @code{SIGNAL} is called as a subroutine and the @var{STATUS} argument
+is supplied, it is set to the value returned by @code{signal(2)}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+subroutine, non-elemental function
+
+@item @emph{Syntax}:
+@multitable @columnfractions .30 .80
+@item @code{CALL ALARM(NUMBER, HANDLER)}
+@item @code{CALL ALARM(NUMBER, HANDLER, STATUS)}
+@item @code{STATUS = ALARM(NUMBER, HANDLER)}
+@end multitable
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{NUMBER} @tab shall be a scalar integer, with @code{INTENT(IN)}
+@item @var{HANDLER}@tab Signal handler (@code{INTEGER FUNCTION} or
+@code{SUBROUTINE}) or dummy/global @code{INTEGER} scalar.
+@code{INTEGER}. It is @code{INTENT(IN)}.
+@item @var{STATUS} @tab (Optional) @var{STATUS} shall be a scalar
+integer. It has @code{INTENT(OUT)}.
+@end multitable
+
+@item @emph{Return value}:
+The @code{SIGNAL} functions returns the value returned by @code{signal(2)}.
+
+@item @emph{Example}:
+@smallexample
+program test_signal
+ intrinsic signal
+ external handler_print
+
+ call signal (12, handler_print)
+ call signal (10, 1)
+
+ call sleep (30)
+end program test_signal
+@end smallexample
+@end table
+
+
+
+
+@node SIN
+@section @code{SIN} --- Sine function
+@findex @code{SIN} intrinsic
+@findex @code{DSIN} intrinsic
+@findex @code{ZSIN} intrinsic
+@findex @code{CDSIN} intrinsic
+@cindex trigonometric functions
+
+@table @asis
+@item @emph{Description}:
+@code{SIN(X)} computes the sine of @var{X}.
+
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = SIN(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type shall be @code{REAL(*)} or
+@code{COMPLEX(*)}.
+@end multitable
+
+@item @emph{Return value}:
+The return value has same type and kind as @var{X}.
+
+@item @emph{Example}:
+@smallexample
+program test_sin
+ real :: x = 0.0
+ x = sin(x)
+end program test_sin
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@end multitable
+
+@item @emph{See also}:
+@ref{ASIN}
+@end table
+
+
+
+@node SINH
+@section @code{SINH} --- Hyperbolic sine function
+@findex @code{SINH} intrinsic
+@findex @code{DSINH} intrinsic
+@cindex hyperbolic sine
+
+@table @asis
+@item @emph{Description}:
+@code{SINH(X)} computes the hyperbolic sine of @var{X}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = SINH(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type shall be @code{REAL(*)}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{REAL(*)}.
+
+@item @emph{Example}:
+@smallexample
+program test_sinh
+ real(8) :: x = - 1.0_8
+ x = sinh(x)
+end program test_sinh
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@end multitable
+
+@item @emph{See also}:
+@ref{ASINH}
+@end table
+
+
+
+@node SIZE
+@section @code{SIZE} --- Determine the size of an array
+@findex @code{SIZE} intrinsic
+@cindex array manipulation
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@end table
+
+
+
+@node SNGL
+@section @code{SNGL} --- Convert double precision real to default real
+@findex @code{SNGL} intrinsic
+@cindex conversion function (real)
+
+@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}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+function
+
+@item @emph{Syntax}:
+@code{X = SNGL(A)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{A} @tab The type shall be a double precision @code{REAL}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type default @code{REAL}.
+
+@item @emph{See also}:
+@ref{DBLE}
+@end table
+
+
+
+@node SPACING
+@section @code{SPACING} --- Smallest distance between two numbers of a given type
+@findex @code{SPACING} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@end table
+
+
+
+
+@node SPREAD
+@section @code{SPREAD} --- Add a dimension to an array
+@findex @code{SPREAD} intrinsic
+@cindex array manipulation
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@end table
+
+
+
+
+@node SQRT
+@section @code{SQRT} --- Square-root function
+@findex @code{SQRT} intrinsic
+@findex @code{DSQRT} intrinsic
+@findex @code{CSQRT} intrinsic
+@findex @code{ZSQRT} intrinsic
+@findex @code{CDSQRT} intrinsic
+@cindex square-root
+
+@table @asis
+@item @emph{Description}:
+@code{SQRT(X)} computes the square root of @var{X}.
+
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = SQRT(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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 kind type parameter is the same as @var{X}.
+
+@item @emph{Example}:
+@smallexample
+program test_sqrt
+ real(8) :: x = 2.0_8
+ complex :: z = (1.0, 2.0)
+ x = sqrt(x)
+ z = sqrt(z)
+end program test_sqrt
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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{ZSQRT(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab GNU extension
+@item @code{CDSQRT(X)} @tab @code{COMPLEX(8) X} @tab @code{COMPLEX(8)} @tab GNU extension
+@end multitable
+@end table
+
+
+
+@node SRAND
+@section @code{SRAND} --- Reinitialize the random number generator
+@findex @code{SRAND} intrinsic
+@cindex random number
+
+@table @asis
+@item @emph{Description}:
+@code{SRAND} reinitializes the pseudo-random number generator
+called by @code{RAND} and @code{IRAND}. The new seed used by the
+generator is specified by the required argument @var{SEED}.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+non-elemental subroutine
+
+@item @emph{Syntax}:
+@code{CALL SRAND(SEED)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{SEED} @tab shall be a scalar @code{INTEGER(kind=4)}.
+@end multitable
+
+@item @emph{Return value}:
+Does not return.
+
+@item @emph{Example}:
+See @code{RAND} and @code{IRAND} for examples.
+
+@item @emph{Notes}:
+The Fortran 2003 standard specifies the intrinsic @code{RANDOM_SEED} to
+initialize the pseudo-random numbers generator and @code{RANDOM_NUMBER}
+to generate pseudo-random numbers. Please note that in
+GNU Fortran, these two sets of intrinsics (@code{RAND},
+@code{IRAND} and @code{SRAND} on the one hand, @code{RANDOM_NUMBER} and
+@code{RANDOM_SEED} on the other hand) access two independent
+pseudo-random number generators.
+
+@item @emph{See also}:
+@ref{RAND}, @ref{RANDOM_SEED}, @ref{RANDOM_NUMBER}
+
+@end table
+
+
+@node STAT
+@section @code{STAT} --- Get file status
+@findex @code{STAT} intrinsic
+@cindex file system operations
+
+@table @asis
+@item @emph{Description}:
+This function returns information about a file. No permissions are required on
+the file itself, but execute (search) permission is required on all of the
+directories in path that lead to the file.
+
+The elements that are obtained and stored in the array @code{BUFF}:
+@multitable @columnfractions .15 .80
+@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)
+@end multitable
+
+Not all these elements are relevant on all systems.
+If an element is not relevant, it is returned as 0.
+
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Non-elemental subroutine
+
+@item @emph{Syntax}:
+@code{CALL STAT(FILE,BUFF[,STATUS])}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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.
+@end multitable
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_stat
+ INTEGER, DIMENSION(13) :: buff
+ INTEGER :: status
+
+ CALL STAT("/etc/passwd", buff, status)
+
+ IF (status == 0) THEN
+ WRITE (*, FMT="('Device ID:', T30, I19)") buff(1)
+ WRITE (*, FMT="('Inode number:', T30, I19)") buff(2)
+ WRITE (*, FMT="('File mode (octal):', T30, O19)") buff(3)
+ WRITE (*, FMT="('Number of links:', T30, I19)") buff(4)
+ WRITE (*, FMT="('Owner''s uid:', T30, I19)") buff(5)
+ WRITE (*, FMT="('Owner''s gid:', T30, I19)") buff(6)
+ WRITE (*, FMT="('Device where located:', T30, I19)") buff(7)
+ WRITE (*, FMT="('File size:', T30, I19)") buff(8)
+ WRITE (*, FMT="('Last access time:', T30, A19)") CTIME(buff(9))
+ WRITE (*, FMT="('Last modification time', T30, A19)") CTIME(buff(10))
+ WRITE (*, FMT="('Last status change time:', T30, A19)") CTIME(buff(11))
+ WRITE (*, FMT="('Preferred block size:', T30, I19)") buff(12)
+ WRITE (*, FMT="('No. of blocks allocated:', T30, I19)") buff(13)
+ END IF
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+To stat an open file: @ref{FSTAT}, to stat a link: @ref{LSTAT}
+@end table
+
+
+
+@node SUM
+@section @code{SUM} --- Sum of array elements
+@findex @code{SUM} intrinsic
+@cindex array manipulation
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@ref{PRODUCT}
+@end table
+
+
+
+
+@node SYMLNK
+@section @code{SYMLNK} --- Create a symbolic link
+@findex @code{SYMLNK} intrinsic
+@cindex file system operations
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+@item @emph{Class}:
+GNU extension
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@end table
+
+
+
+
+@node SYSTEM
+@section @code{SYSTEM} --- Execute a shell command
+@findex @code{SYSTEM} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@end table
+
+
+
+
+@node SYSTEM_CLOCK
+@section @code{SYSTEM_CLOCK} --- Time function
+@findex @code{SYSTEM_CLOCK} intrinsic
+@cindex time functions
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@end table
+
+
+
+@node TAN
+@section @code{TAN} --- Tangent function
+@findex @code{TAN} intrinsic
+@findex @code{DTAN} intrinsic
+@cindex trigonometric functions
+
+@table @asis
+@item @emph{Description}:
+@code{TAN(X)} computes the tangent of @var{X}.
+
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = TAN(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type shall be @code{REAL(*)}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{REAL(*)}. The kind type parameter is
+the same as @var{X}.
+
+@item @emph{Example}:
+@smallexample
+program test_tan
+ real(8) :: x = 0.165_8
+ x = tan(x)
+end program test_tan
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@end multitable
+
+@item @emph{See also}:
+@ref{ATAN}
+@end table
+
+
+
+@node TANH
+@section @code{TANH} --- Hyperbolic tangent function
+@findex @code{TANH} intrinsic
+@findex @code{DTANH} intrinsic
+@cindex hyperbolic tangent
+
+@table @asis
+@item @emph{Description}:
+@code{TANH(X)} computes the hyperbolic tangent of @var{X}.
+
+@item @emph{Standard}:
+F77 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{X = TANH(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab The type shall be @code{REAL(*)}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of type @code{REAL(*)} and lies in the range
+@math{ - 1 \leq tanh(x) \leq 1 }.
+
+@item @emph{Example}:
+@smallexample
+program test_tanh
+ real(8) :: x = 2.1_8
+ x = tanh(x)
+end program test_tanh
+@end smallexample
+
+@item @emph{Specific names}:
+@multitable @columnfractions .20 .20 .20 .40
+@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
+@end multitable
+
+@item @emph{See also}:
+@ref{ATANH}
+@end table
+
+
+
+@node TIME
+@section @code{TIME} --- Time function
+@findex @code{TIME} intrinsic
+@cindex time functions
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Non-elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@end table
+
+
+
+@node TINY
+@section @code{TINY} --- Smallest positive number of a real kind
+@findex @code{TINY} intrinsic
+@cindex tiny
+
+@table @asis
+@item @emph{Description}:
+@code{TINY(X)} returns the smallest positive (non zero) number
+in the model of the type of @code{X}.
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@code{Y = TINY(X)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@item @var{X} @tab shall be of type @code{REAL}.
+@end multitable
+
+@item @emph{Return value}:
+The return value is of the same type and kind as @var{X}
+
+@item @emph{Example}:
+See @code{HUGE} for an example.
+@end table
+
+
+
+@node TRANSFER
+@section @code{TRANSFER} --- Transfer bit patterns
+@findex @code{TRANSFER} intrinsic
+@cindex bit manipulation
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@end table
+
+
+
+
+@node TRANSPOSE
+@section @code{TRANSPOSE} --- Transpose an array of rank two
+@findex @code{TRANSPOSE} intrinsic
+@cindex matrix manipulation
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@end table
+
+
+
+
+@node TRIM
+@section @code{TRIM} --- Function to remove trailing blank characters of a string
+@findex @code{TRIM} intrinsic
+@cindex string manipulation
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{See also}:
+@end table
+
+
+
+
+@node UBOUND
+@section @code{UBOUND} --- Upper dimension bounds of an array
+@findex @code{UBOUND} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Inquiry function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+
+@item @emph{See also}:
+@ref{LBOUND}
+@end table
+
+
+
+
+@node UMASK
+@section @code{UMASK} --- Set the file creation mask
+@findex @code{UMASK} intrinsic
+@cindex file system operations
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+@item @emph{See also}:
+@end table
+
+
+
+
+@node UNLINK
+@section @code{UNLINK} --- Remove a file from the file system
+@findex @code{UNLINK} intrinsic
+@cindex file system operations
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Subroutine
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+
+@item @emph{See also}:
+@ref{LINK}
+@end table
+
+
+
+
+@node UNMASK
+@section @code{UNMASK} --- (?)
+@findex @code{UNMASK} intrinsic
+@cindex undocumented intrinsic
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+@item @emph{Class}:
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+@item @emph{See also}:
+@end table
+
+
+
+
+@node UNPACK
+@section @code{UNPACK} --- Unpack an array of rank one into an array
+@findex @code{UNPACK} intrinsic
+@cindex array manipulation
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Transformational function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+
+@item @emph{See also}:
+@ref{PACK}
+@end table
+
+
+
+
+@node VERIFY
+@section @code{VERIFY} --- Scan a string for the absence of a set of characters
+@findex @code{VERIFY} intrinsic
+@cindex string manipulation
+
+Intrinsic implemented, documentation pending.
+
+@table @asis
+@item @emph{Description}:
+@item @emph{Standard}:
+F95 and later
+
+@item @emph{Class}:
+Elemental function
+
+@item @emph{Syntax}:
+@item @emph{Arguments}:
+@item @emph{Return value}:
+@item @emph{Example}:
+@item @emph{Specific names}:
+@item @emph{See also}:
+@end table
+
+
+@node XOR
+@section @code{XOR} --- Bitwise logical exclusive OR
+@findex @code{XOR} intrinsic
+@cindex bit operations
+
+@table @asis
+@item @emph{Description}:
+Bitwise logical exclusive or.
+
+This intrinsic routine is provided for backwards compatibility with
+GNU Fortran 77. For integer arguments, programmers should consider
+the use of the @ref{IEOR} intrinsic defined by the Fortran standard.
+
+@item @emph{Standard}:
+GNU extension
+
+@item @emph{Class}:
+Non-elemental function
+
+@item @emph{Syntax}:
+@code{RESULT = XOR(X, Y)}
+
+@item @emph{Arguments}:
+@multitable @columnfractions .15 .80
+@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}.
+@end multitable
+
+@item @emph{Return value}:
+The return type is either @code{INTEGER(*)} or @code{LOGICAL}
+after cross-promotion of the arguments.
+
+@item @emph{Example}:
+@smallexample
+PROGRAM test_xor
+ LOGICAL :: T = .TRUE., F = .FALSE.
+ INTEGER :: a, b
+ DATA a / Z,'F' /, b / Z'3' /
+
+ WRITE (*,*) XOR(T, T), XOR(T, F), XOR(F, T), XOR(F, F)
+ WRITE (*,*) XOR(a, b)
+END PROGRAM
+@end smallexample
+
+@item @emph{See also}:
+F95 elemental function: @ref{IEOR}
+@end table
+
OSDN Git Service
