@ignore
Copyright (C) 2005
Free Software Foundation, Inc.
This is part of the GFORTRAN manual.   
For copying conditions, see the file gfortran.texi.

Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.2 or
any later version published by the Free Software Foundation; with the
Invariant Sections being ``GNU General Public License'' and ``Funding
Free Software'', the Front-Cover texts being (a) (see below), and with
the Back-Cover Texts being (b) (see below).  A copy of the license is
included in the gfdl(7) man page.


Some basic guidelines for editing this document:

  (1) The intrinsic procedures are to be listed in alphabetical order.
  (2) The generic name is to be use.
  (3) The specific names are included in the function index and in a
      table at the end of the node (See ABS entry).
  (4) Try to maintain the same style for each entry.


@end ignore

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

@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,      Arc cosine function
* @code{ADJUSTL}:       ADJUSTL,   Left adjust a string
* @code{ADJUSTR}:       ADJUSTR,   Right adjust a string
* @code{AIMAG}:         AIMAG,     Imaginary part of complex number
* @code{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{ANINT}:         ANINT,     Nearest whole number
* @code{ANY}:           ANY,       Determine if any values are true
* @code{ASIN}:          ASIN,      Arcsine function
* @code{ASSOCIATED}:    ASSOCIATED, Status of a pointer or pointer/target pair
* @code{ATAN}:          ATAN,      Arctangent function
* @code{ATAN2}:         ATAN2,     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,      Character conversion function
* @code{CMPLX}:         CMPLX,     Complex conversion function
* @code{COMMAND_ARGUMENT_COUNT}: COMMAND_ARGUMENT_COUNT,  Command line argument count
* @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{FLOAT}:         FLOAT,     Convert integer to default real
* @code{FLOOR}:         FLOOR,     Integer floor function
* @code{FNUM}:          FNUM,      File number function
* @code{FREE}:          FREE,      Memory de-allocation subroutine
* @code{LOC}:           LOC,       Returns the address of a variable
* @code{LOG}:           LOG,       Logarithm function
* @code{LOG10}:         LOG10,     Base 10 logarithm function 
* @code{MALLOC}:        MALLOC,    Dynamic memory allocation function
* @code{REAL}:          REAL,      Convert to real type 
* @code{SECNDS}:        SECNDS,    Time function
* @code{SIGNAL}:        SIGNAL,    Signal handling subroutine (or function)
* @code{SIN}:           SIN,       Sine function
* @code{SINH}:          SINH,      Hyperbolic sine function
* @code{SQRT}:          SQRT,      Square-root function
* @code{TAN}:           TAN,       Tangent function
* @code{TANH}:          TANH,      Hyperbolic tangent function
@end menu

@node Introduction
@section Introduction to intrinsic procedures

Gfortran provides a rich set of intrinsic procedures that includes all
the intrinsic procedures required by the Fortran 95 standard, a set of
intrinsic procedures for backwards compatibility with Gnu Fortran 77
(i.e., @command{g77}), and a small selection of intrinsic procedures
from the Fortran 2003 standard.  Any description here, which conflicts with a 
description in either the Fortran 95 standard or the Fortran 2003 standard,
is unintentional and the standard(s) should be considered authoritative.

The enumeration of the @code{KIND} type parameter is processor defined in
the Fortran 95 standard.  Gfortran 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
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
names for an intrinsic procedure the kind type parameter will be explicitly
given (e.g., @code{REAL(KIND=4)} or @code{REAL(KIND=8)}).  Finally, for
brevity the optional @code{KIND=} syntax will be omitted.

Many of the intrinsics procedures take one or more optional arguments.
This document follows the convention used in the Fortran 95 standard,
and denotes such arguments by square brackets.

@command{Gfortran} 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 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
with @command{g77}.  It is noted here that these functions and subroutines
cannot be intermixed in a given subprogram.  In the descriptions that follow,
the applicable option(s) is noted.



@node ABORT
@section @code{ABORT} --- Abort the program  
@findex @code{ABORT}
@cindex abort

@table @asis
@item @emph{Description}:
@code{ABORT} causes immediate termination of the program.  On operating
systems that support a core dump, @code{ABORT} will produce a core dump,
which is suitable for debugging purposes.

@item @emph{Option}:
gnu

@item @emph{Class}:
non-elemental subroutine

@item @emph{Syntax}:
@code{CALL ABORT}

@item @emph{Return value}:
Does not return.

@item @emph{Example}:
@smallexample
program test_abort
  integer :: i = 1, j = 2
  if (i /= j) call abort
end program test_abort
@end smallexample
@end table



@node ABS
@section @code{ABS} --- Absolute value  
@findex @code{ABS} intrinsic
@findex @code{CABS} intrinsic
@findex @code{DABS} intrinsic
@findex @code{IABS} intrinsic
@findex @code{ZABS} intrinsic
@findex @code{CDABS} intrinsic
@cindex absolute value

@table @asis
@item @emph{Description}:
@code{ABS(X)} computes the absolute value of @code{X}.

@item @emph{Option}:
f95, gnu

@item @emph{Class}:
elemental function

@item @emph{Syntax}:
@code{X = ABS(X)}

@item @emph{Arguments}:
@multitable @columnfractions .15 .80
@item @var{X} @tab The type of the argument shall be an @code{INTEGER(*)},
@code{REAL(*)}, or @code{COMPLEX(*)}.
@end multitable

@item @emph{Return value}:
The return value is of the same type and
kind as the argument except the return value is @code{REAL(*)} for a
@code{COMPLEX(*)} argument.

@item @emph{Example}:
@smallexample
program test_abs
  integer :: i = -1
  real :: x = -1.e0
  complex :: z = (-1.e0,0.e0)
  i = abs(i)
  x = abs(x)
  x = abs(z)
end program test_abs
@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
@end multitable
@end table



@node ACHAR
@section @code{ACHAR} --- Character in @acronym{ASCII} collating sequence 
@findex @code{ACHAR} intrinsic
@cindex @acronym{ASCII} collating sequence

@table @asis
@item @emph{Description}:
@code{ACHAR(I)} returns the character located at position @code{I}
in the @acronym{ASCII} collating sequence.

@item @emph{Option}:
f95, gnu

@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 @code{INTEGER(*)}.
@end multitable

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

@item @emph{Example}:
@smallexample
program test_achar
  character c
  c = achar(32)
end program test_achar
@end smallexample
@end table



@node ACOS
@section @code{ACOS} --- Arc cosine function 
@findex @code{ACOS} intrinsic
@findex @code{DACOS} intrinsic
@cindex arc cosine

@table @asis
@item @emph{Description}:
@code{ACOS(X)} computes the arc cosine of @var{X}.

@item @emph{Option}:
f95, gnu

@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 @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}.  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)
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
@end multitable
@end table



@node ADJUSTL
@section @code{ADJUSTL} --- Left adjust a string 
@findex @code{ADJUSTL} intrinsic
@cindex adjust string

@table @asis
@item @emph{Description}:
@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{Class}:
elemental function

@item @emph{Syntax}:
@code{STR = ADJUSTL(STR)}

@item @emph{Arguments}:
@multitable @columnfractions .15 .80
@item @var{STR} @tab The type shall be @code{CHARACTER}.
@end multitable

@item @emph{Return value}:
The return value is of type @code{CHARACTER} where leading spaces 
are removed and the same number of spaces are inserted on the end
of @var{STR}.

@item @emph{Example}:
@smallexample
program test_adjustl
  character(len=20) :: str = '   gfortran'
  str = adjustl(str)
  print *, str
end program test_adjustl
@end smallexample
@end table



@node ADJUSTR
@section @code{ADJUSTR} --- Right adjust a string 
@findex @code{ADJUSTR} intrinsic
@cindex adjust string

@table @asis
@item @emph{Description}:
@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{Class}:
elemental function

@item @emph{Syntax}:
@code{STR = ADJUSTR(STR)}

@item @emph{Arguments}:
@multitable @columnfractions .15 .80
@item @var{STR} @tab The type shall be @code{CHARACTER}.
@end multitable

@item @emph{Return value}:
The return value is of type @code{CHARACTER} where trailing spaces 
are removed and the same number of spaces are inserted at the start
of @var{STR}.

@item @emph{Example}:
@smallexample
program test_adjustr
  character(len=20) :: str = 'gfortran'
  str = adjustr(str)
  print *, str
end program test_adjustr
@end smallexample
@end table



@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{Option}:
f95, gnu

@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 .24 .24 .24 .24
@item Name            @tab Argument            @tab Return type       @tab Option
@item @code{DIMAG(Z)} @tab @code{COMPLEX(8) Z} @tab @code{REAL(8)}    @tab f95, gnu
@item @code{IMAG(Z)}  @tab @code{COMPLEX(*) Z} @tab @code{REAL(*)}    @tab gnu
@item @code{IMAGPART(Z)} @tab @code{COMPLEX(*) Z} @tab @code{REAL(*)} @tab gnu
@end multitable
@end table



@node AINT
@section @code{AINT} --- Imaginary part of complex 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{Option}:
f95, gnu

@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 .24 .24 .24 .24
@item Name           @tab Argument         @tab Return type      @tab Option
@item @code{DINT(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)}   @tab f95, gnu
@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 [, 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{Option}:
gnu

@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{Option}:
f95, gnu

@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{Option}:
f95, gnu

@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 ANINT
@section @code{ANINT} --- Imaginary part of complex 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{Option}:
f95, gnu

@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 return @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 .24 .24 .24 .24
@item Name            @tab Argument         @tab Return type      @tab Option
@item @code{DNINT(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)}   @tab f95, gnu
@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{Option}:
f95, gnu

@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 arcsine

@table @asis
@item @emph{Description}:
@code{ASIN(X)} computes the arcsine of its @var{X}.

@item @emph{Option}:
f95, gnu

@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 \arccos (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 .24 .24 .24 .24
@item Name            @tab Argument          @tab Return type       @tab Option
@item @code{DASIN(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
@end multitable
@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{Option}:
f95, gnu

@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
@end table



@node ATAN
@section @code{ATAN} --- Arctangent function 
@findex @code{ATAN} intrinsic
@findex @code{DATAN} intrinsic
@cindex arctangent

@table @asis
@item @emph{Description}:
@code{ATAN(X)} computes the arctangent of @var{X}.

@item @emph{Option}:
f95, gnu

@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 \arcsin (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 .24 .24 .24 .24
@item Name            @tab Argument          @tab Return type       @tab Option
@item @code{DATAN(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
@end multitable
@end table



@node ATAN2
@section @code{ATAN2} --- Arctangent function 
@findex @code{ATAN2} intrinsic
@findex @code{DATAN2} intrinsic
@cindex arctangent

@table @asis
@item @emph{Description}:
@code{ATAN2(Y,X)} computes the arctangent of the complex number @math{X + i Y}.

@item @emph{Option}:
f95, gnu

@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 principle value of the complex number @math{X + i Y}.  If
@var{X} is nonzero, then it lies in the range @math{-\pi \le \arccos (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 .24 .24 .24 .24
@item Name            @tab Argument          @tab Return type    @tab Option
@item @code{DATAN2(X)} @tab @code{REAL(8) X} @tab @code{REAL(8)} @tab f95, gnu
@end multitable
@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{Option}:
gnu

@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 .24 .24 .24 .24
@item Name            @tab Argument          @tab Return type       @tab Option
@item @code{DBESJ0(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab gnu
@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{Option}:
gnu

@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 .24 .24 .24 .24
@item Name            @tab Argument          @tab Return type       @tab Option
@item @code{DBESJ1(X)}@tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab gnu
@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{Option}:
gnu

@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 .24 .24 .24 .24
@item Name             @tab Argument            @tab Return type       @tab Option
@item @code{DBESJN(X)} @tab @code{INTEGER(*) N} @tab @code{REAL(8)}    @tab gnu
@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{Option}:
gnu

@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 .24 .24 .24 .24
@item Name            @tab Argument          @tab Return type       @tab Option
@item @code{DBESY0(X)}@tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab gnu
@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{Option}:
gnu

@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 .24 .24 .24 .24
@item Name            @tab Argument          @tab Return type       @tab Option
@item @code{DBESY1(X)}@tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab gnu
@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{Option}:
gnu

@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 .24 .24 .24 .24
@item Name               @tab Argument            @tab Return type     @tab Option
@item @code{DBESYN(N,X)} @tab @code{INTEGER(*) N} @tab @code{REAL(8)}  @tab gnu
@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{Option}:
f95, gnu

@item @emph{Class}:
elemental 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 BTEST

@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{Option}:
f95, gnu

@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{Option}:
f95, gnu

@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 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_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
@end table



@node CHAR
@section @code{CHAR} --- Character conversion function
@findex @code{CHAR} intrinsic
@cindex CHAR

@table @asis
@item @emph{Description}:
@code{CHAR(I,[KIND])} returns the character represented by the integer @var{I}.

@item @emph{Option}:
f95, gnu

@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
@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{Option}:
f95, gnu

@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} --- Argument count function 
@findex @code{COMMAND_ARGUMENT_COUNT} intrinsic
@cindex command argument count

@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{Option}:
f2003, gnu

@item @emph{Class}:
non-elemental 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
@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{Option}:
f95, gnu

@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 .24 .24 .24 .24
@item Name             @tab Argument             @tab Return type          @tab Option
@item @code{DCONJG(Z)} @tab @code{COMPLEX(8) Z}  @tab @code{COMPLEX(8)}    @tab gnu
@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 cosine

@table @asis
@item @emph{Description}:
@code{COS(X)} computes the cosine of @var{X}.

@item @emph{Option}:
f95, gnu

@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 has the same type and kind 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 .24 .24 .24 .24
@item Name            @tab Argument          @tab Return type     @tab Option
@item @code{DCOS(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}  @tab f95, gnu
@item @code{CCOS(X)}@tab @code{COMPLEX(4) X}@tab @code{COMPLEX(4)}@tab f95, gnu
@item @code{ZCOS(X)}@tab @code{COMPLEX(8) X}@tab @code{COMPLEX(8)}@tab f95, gnu
@item @code{CDCOS(X)}@tab @code{COMPLEX(8) X}@tab @code{COMPLEX(8)}@tab f95, gnu
@end multitable
@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{Option}:
f95, gnu

@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 .24 .24 .24 .24
@item Name            @tab Argument          @tab Return type       @tab Option
@item @code{DCOSH(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
@end multitable
@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{Option}:
f95, gnu

@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{Option}:
f95, gnu

@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 cshift intrinsic

@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{Option}:
f95, gnu

@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{Option}:
gnu

@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{Option}:
f95, gnu

@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.
@code{DFLOAT} is an alias for @code{DBLE}

@item @emph{Option}:
f95, gnu

@item @emph{Class}:
elemental function

@item @emph{Syntax}:
@code{X = DBLE(X)}
@code{X = DFLOAT(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), dfloat(z)
end program test_dble
@end smallexample
@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{Option}:
f95, gnu

@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.
@code{DFLOAT} is an alias for @code{DBLE}.  See @code{DBLE}.
@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{Option}:
f95, gnu

@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{Option}:
f95, gnu

@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 .24 .24 .24 .24
@item Name            @tab Argument          @tab Return type       @tab Option
@item @code{IDIM(X,Y)} @tab @code{INTEGER(4) X,Y} @tab @code{INTEGER(4)} @tab gnu
@item @code{DDIM(X,Y)} @tab @code{REAL(8) X,Y}  @tab @code{REAL(8)} @tab gnu
@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{Option}:
f95

@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{Option}:
f95, gnu

@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{Option}:
gnu

@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
@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 (wraparounds) are possible, such as
32-bit types. Therefore, the values returned by this intrinsic might be, or
become, negative, or numerically less than previous values, during a single
run of the compiled program.

If @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{Option}:
gnu

@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 eoshift intrinsic

@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{Option}:
f95, gnu

@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{Option}:
f95, gnu

@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{Option}:
gnu

@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 .24 .24 .24 .24
@item Name            @tab Argument          @tab Return type       @tab Option
@item @code{DERF(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab gnu
@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{Option}:
gnu

@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 .24 .24 .24 .24
@item Name            @tab Argument          @tab Return type       @tab Option
@item @code{DERFC(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab gnu
@end multitable
@end table



@node ETIME
@section @code{ETIME} --- Execution time subroutine (or function)
@findex @code{ETIME} intrinsic
@cindex ETIME subroutine 

@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 (wraparounds) are possible, such as
32-bit types. Therefore, the values returned by this intrinsic might be, or
become, negative, or numerically less than previous values, during a single
run of the compiled program.

If @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{Option}:
gnu

@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
@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{Option}:
gnu

@item @emph{Class}:
non-elemental 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
@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{Option}:
f95, gnu

@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 .24 .24 .24 .24
@item Name            @tab Argument          @tab Return type       @tab Option
@item @code{DEXP(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
@item @code{CEXP(X)}  @tab @code{COMPLEX(4) X}  @tab @code{COMPLEX(4)}    @tab f95, gnu
@item @code{ZEXP(X)}  @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
@item @code{CDEXP(X)} @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
@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{Option}:
f95, gnu

@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 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 @command{gfortran} to allow user to compile legacy code. For
new code using Fortran 95 pointers, the memory de-allocation intrinsic is
@code{DEALLOCATE}.

@item @emph{Option}:
gnu

@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.
@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{Option}:
gnu

@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 float

@table @asis
@item @emph{Description}:
@code{FLOAT(I)} converts the integer @var{I} to a default real value.

@item @emph{Option}:
gnu

@item @emph{Class}:
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
@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{Option}:
f95, gnu

@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
@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{Option}:
gnu

@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 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{Option}:
gnu

@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{Option}:
f95, gnu

@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 .24 .24 .24 .24
@item Name            @tab Argument          @tab Return type       @tab Option
@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{Option}:
f95, gnu

@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 .24 .24 .24 .24
@item Name            @tab Argument          @tab Return type       @tab Option
@item @code{ALOG10(X)}  @tab @code{REAL(4) X}  @tab @code{REAL(4)}    @tab f95, gnu
@item @code{DLOG10(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
@end multitable
@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 @command{gfortran} to allow user to compile legacy code. For new code
using Fortran 95 pointers, the memory allocation intrinsic is
@code{ALLOCATE}.

@item @emph{Option}:
gnu

@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
@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{Option}:
f95, gnu

@item @emph{Class}:
transformational 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 the 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
@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{Option}:
gnu

@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 SECNDS
@section @code{SECNDS} --- Time subroutine
@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{Option}:
gnu

@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 SIN
@section @code{SIN} --- Sine function 
@findex @code{SIN} intrinsic
@findex @code{DSIN} intrinsic
@findex @code{ZSIN} intrinsic
@findex @code{CDSIN} intrinsic
@cindex sine

@table @asis
@item @emph{Description}:
@code{SIN(X)} computes the sine of @var{X}.

@item @emph{Option}:
f95, gnu

@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 king than @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 .24 .24 .24 .24
@item Name            @tab Argument          @tab Return type       @tab Option
@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
@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{Option}:
f95, gnu

@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 .24 .24 .24 .24
@item Name            @tab Argument          @tab Return type       @tab Option
@item @code{DSINH(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
@end multitable
@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{Option}:
f95, gnu

@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 .24 .24 .24 .24
@item Name            @tab Argument          @tab Return type       @tab Option
@item @code{DSQRT(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
@item @code{CSQRT(X)}  @tab @code{COMPLEX(4) X}  @tab @code{COMPLEX(4)}    @tab f95, gnu
@item @code{ZSQRT(X)}  @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
@item @code{CDSQRT(X)} @tab @code{COMPLEX(8) X}  @tab @code{COMPLEX(8)}    @tab f95, gnu
@end multitable
@end table



@node TAN
@section @code{TAN} --- Tangent function
@findex @code{TAN} intrinsic
@findex @code{DTAN} intrinsic
@cindex tangent

@table @asis
@item @emph{Description}:
@code{TAN(X)} computes the tangent of @var{X}.

@item @emph{Option}:
f95, gnu

@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 .24 .24 .24 .24
@item Name            @tab Argument          @tab Return type       @tab Option
@item @code{DTAN(X)}  @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
@end multitable
@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{Option}:
f95, gnu

@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 .24 .24 .24 .24
@item Name            @tab Argument          @tab Return type       @tab Option
@item @code{DTANH(X)} @tab @code{REAL(8) X}  @tab @code{REAL(8)}    @tab f95, gnu
@end multitable
@end table



@comment sub   flush
@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   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   size
@comment 
@comment gen   spacing
@comment 
@comment gen   spread
@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   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

