| @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, Arccosine function |
| * @code{ADJUSTL}: ADJUSTL, Left adjust a string |
| * @code{ADJUSTR}: ADJUSTR, Right adjust a string |
| * @code{AIMAG}: AIMAG, Imaginary part of complex number |
| * @code{AINT}: AINT, Truncate to a whole number |
| * @code{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{COS}: COS, Cosine function |
| * @code{COSH}: COSH, Hyperbolic cosine function |
| * @code{ERF}: ERF, Error function |
| * @code{ERFC}: ERFC, Complementary error function |
| * @code{EXP}: EXP, Cosine function |
| * @code{LOG}: LOG, Logarithm function |
| * @code{LOG10}: LOG10, Base 10 logarithm function |
| * @code{SQRT}: SQRT, Square-root function |
| * @code{SIN}: SIN, Sine function |
| * @code{SINH}: SINH, Hyperbolic sine 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 |
| supports 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 describe 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} --- Arccosine function |
| @findex @code{ACOS} intrinsic |
| @findex @code{DACOS} intrinsic |
| @cindex arccosine |
| |
| @table @asis |
| @item @emph{Description}: |
| @code{ACOS(X)} computes the arccosine of its @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(*)}, 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{ 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 |
| @cindex Imaginary part |
| |
| @table @asis |
| @item @emph{Description}: |
| @code{AIMAG(Z)} yields the imaginary part of complex argument @code{Z}. |
| |
| @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 |
| @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 absence; 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 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 wether @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 absence; 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 is 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 = 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 .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,[KIND])} 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{X = CEILING(X)} |
| |
| @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)} |
| |
| @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)} |
| @code{C = CMPLX(X,Y)} |
| @code{C = CMPLX(X,Y,KIND)} |
| |
| @item @emph{Arguments}: |
| @multitable @columnfractions .15 .80 |
| @item @var{X} @tab The type may be @code{INTEGER(*)} or @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 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 same type and kind than @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 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 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 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 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 gen command_argument_count |
| @comment |
| @comment gen conjg |
| @comment dconjg |
| @comment |
| @comment gen count |
| @comment |
| @comment sub cpu_time |
| @comment |
| @comment gen cshift |
| @comment |
| @comment sub date_and_time |
| @comment |
| @comment gen dble |
| @comment dfloat |
| @comment |
| @comment gen dcmplx |
| @comment |
| @comment gen digits |
| @comment |
| @comment gen dim |
| @comment idim |
| @comment ddim |
| @comment |
| @comment gen dot_product |
| @comment |
| @comment gen dprod |
| @comment |
| @comment gen dreal |
| @comment |
| @comment sub dtime |
| @comment |
| @comment gen eoshift |
| @comment |
| @comment gen epsilon |
| @comment |
| @comment gen etime |
| @comment sub etime |
| @comment |
| @comment sub exit |
| @comment |
| @comment gen exponent |
| @comment |
| @comment gen floor |
| @comment |
| @comment sub flush |
| @comment |
| @comment gen fnum |
| @comment |
| @comment gen fraction |
| @comment |
| @comment gen fstat |
| @comment sub fstat |
| @comment |
| @comment sub getarg |
| @comment |
| @comment gen getcwd |
| @comment sub getcwd |
| @comment |
| @comment sub getenv |
| @comment |
| @comment gen getgid |
| @comment |
| @comment gen getpid |
| @comment |
| @comment gen getuid |
| @comment |
| @comment sub get_command |
| @comment |
| @comment sub get_command_argument |
| @comment |
| @comment sub get_environment_variable |
| @comment |
| @comment gen huge |
| @comment |
| @comment gen iachar |
| @comment |
| @comment gen iand |
| @comment |
| @comment gen iargc |
| @comment |
| @comment gen ibclr |
| @comment |
| @comment gen ibits |
| @comment |
| @comment gen ibset |
| @comment |
| @comment gen ichar |
| @comment |
| @comment gen ieor |
| @comment |
| @comment gen index |
| @comment |
| @comment gen int |
| @comment ifix |
| @comment idint |
| @comment |
| @comment gen ior |
| @comment |
| @comment gen irand |
| @comment |
| @comment gen ishft |
| @comment |
| @comment gen ishftc |
| @comment |
| @comment gen kind |
| @comment |
| @comment gen lbound |
| @comment |
| @comment gen len |
| @comment |
| @comment gen len_trim |
| @comment |
| @comment gen lge |
| @comment |
| @comment gen lgt |
| @comment |
| @comment gen lle |
| @comment |
| @comment gen llt |
| @comment |
| @comment gen 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 |
| |
