MichaelAgarkov/CodeBlocksPortable
MichaelAgarkov/CodeBlocksPortable
Archived
1
1
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity
This repository has been archived on 2024-12-16. You can view files and clone it, but cannot push or open issues or pull requests.
CodeBlocksPortable/share/CodeBlocks/images/fortranproject/fortran_procedures.f90

3453 lines
144 KiB
Fortran
Raw Permalink Normal View History

My portable distribution of Code::Blocks
2024-07-04 16:52:56 +00:00
!**************************************************************************************
!
! This file is part of FortranProject plugin for Code::Blocks IDE.
! It contains list of keywords and intrinsic procedures which are included in code-completion list.
!
! Description of procedures is based on GNU Fortran user manual.
!
! The file is licensed under the GNU General Public License, version 3
! http://www.gnu.org/licenses/gpl-3.0.html
!
! Author: Darius Markauskas
!
!**************************************************************************************
function list_of_other_fortran_keywords()
! This pseudo function contains fortran keywords, which should be included in code-completion list, but
! they are not functions or subroutines. The keywords are defined as variables of the type 'other'.
type(other) :: access, action, advance, allocatable, allocate, &
apostrophe, assign, assignment, associate, asynchronous, backspace, &
bind, blank, blockdata, call, case, character, class, close, common, &
complex, contains, continue, cycle, data, deallocate, decimal, delim, &
default, dimension, direct, do, double, doubleprecision, else, &
elseif, elsewhere, encoding, end, endassociate, endblockdata, enddo, &
endfile, endforall, endfunction, endif, endinterface, endmodule, endprocedure, endprogram, &
endselect, endsubroutine, endtype, endwhere, entry, eor, equivalence, &
err, errmsg, exist, exit, external, final, file, flush, fmt, forall, form, format, &
formatted, function, go, goto, if, implicit, in, include, inout, &
integer, inquire, intent, interface, intrinsic, iomsg, iolength, &
iostat, kind, len, logical, module, named, namelist, nextrec, nml, &
none, nopass, nullify, number, only, open, opened, operator, optional, out, pad, &
parameter, pass, pending, pointer, pos, position, precision, &
print, private, program, protected, public, quote, read, readwrite, &
real, rec, recl, recursive, result, return, rewind, save, select, &
selectcase, selecttype, sequential, stat, status, stop, stream, &
subroutine, target, then, to, type, unformatted, unit, use, value, &
volatile, wait, where, while, write, procedure, elemental, pure, sequence, &
import, is, &
null, new_line, block, abstract, delegate, static, reference, round, &
decorate, extends, generic, non_overridable, enum, endenum, enumerator, typealias, &
submodule, endsubmodule, concurrent, contiguous, endblock, non_intrinsic, codimension, &
impure, critical, endcritical, lock, unlock, error, sync, all, memory, images, deferred, &
fail, image, event, post, wait, change, team, endteam, non_recursive
end function
!**************************************************************************************
!
! List of intrinsic procedures
!
!**************************************************************************************
function ABS(A)
! Computes the absolute value of A.
! Arguments:
! A -The type of the argument shall be an INTEGER, REAL, or COMPLEX.
integer, real, complex :: A
end function
character function ACHAR(I [, KIND])
! Returns the character located at position 'i' in the ASCII collating sequence.
! Syntax: RESULT = ACHAR(I [, KIND])
! Arguments:
! i -The type shall be INTEGER.
! KIND (Optional) An INTEGER initialization expression indicating the kind parameter of the result.
! Return value:
! The return value is of type CHARACTER with a length of one.
! If the KIND argument is present, the return value is of the specified kind and of the default kind otherwise.
! Standard: Fortran 77 and later, with KIND argument Fortran 2003 and later.
integer :: I, KIND
end function
function ACOS(X)
! Computes the arccosine of X (inverse of COS(X)).
! Arguments: X -The type shall either be REAL with a magnitude that is less than or equal to one - or the type shall be COMPLEX.
! Return value:
! The return value is of the same type and kind as X. The real part of the result
! is in radians and lies in the range 0 <= acos(x) <= pi.
! Standard: Fortran 77 and later, for a complex argument Fortran 2008 or later
real, complex :: ACOS, X
end function
double precision function DACOS(X)
! This is specific procedure name of ACOS function.
! Computes the arccosine of X (inverse of COS(X)).
! Arguments: X -The type shall be DOUBLEPRECISION.
! Return value:
! The return value is of the same type and kind as X. The real part of the result
! is in radians and lies in the range 0 <= acos(x) <= pi.
! Standard: Fortran 77 and later
double precision :: X
end function
function ACOSH(X)
! Computes the hyperbolic arccosine of X (inverse of COSH(X)).
! Syntax: RESULT = ACOSH(X)
! Arguments: X -The type shall be REAL or COMPLEX.
! Return value:
! The return value has the same type and kind as X. If X is complex, the imaginary part of the result is in radians
! and lies between 0 <= acosh(x) <= pi.
! Standard: Fortran 2008 and later.
real, complex :: ACOSH, X
end function
character(len=*) function ADJUSTL(STRING)
! ADJUSTL(STRING) will left adjust a string by removing leading spaces.
! Spaces are inserted at the end of the string as needed.
! Arguments: STRING -The type shall be CHARACTER.
! Standard: Fortran 90 and later.
character(len=*) :: STRING
end function
character(len=*) function ADJUSTR(STRING)
! ADJUSTR(STRING) will right adjust a string by removing trailing spaces. Spaces are inserted at the start
! of the string as needed.
! Arguments: STRING -The type shall be CHARACTER.
! Standard: Fortran 95 and later.
character(len=*) :: STRING
end function
real(kind as Z) function AIMAG(Z)
! AIMAG(Z) yields the imaginary part of complex argument Z.
! Arguments: Z -The type of the argument shall be COMPLEX.
! Return value: The return value is of type REAL with the kind type parameter of the argument.
! Standard: Fortran 77 and later
complex :: Z
end function
real function AINT(A [, KIND])
! Real value truncated to a whole number.
! Return the largest whole number whose magnitude is less than or equal to |A|
! and whose sign is the same as A.
real :: A
integer :: KIND
end function
double precision function DINT(A)
! Real value truncated to a whole number.
! Return the largest whole number whose magnitude is less than or equal to |A|
! and whose sign is the same as A.
double precision :: A
end function
logical function ALL(MASK [, DIM])
! Determines if all the values are true in MASK in the array along dimension DIM.
! Arguments:
! MASK -The type of the argument shall be LOGICAL and it shall not be scalar.
! DIM -(Optional) DIM shall be a scalar integer with a value that lies between one and the rank of MASK.
! Return value:
! ALL(MASK) returns a scalar value of type LOGICAL where the kind type parameter is the same as the kind type
! parameter of MASK. If DIM is present, then ALL(MASK, DIM) returns an array with the rank of
! MASK minus 1. The shape is determined from the shape of MASK where the DIM dimension is elided.
! (A)
! ALL(MASK) is true if all elements of MASK are true. It also is true if MASK has zero size; otherwise, it is false.
! (B)
! If the rank of MASK is one, then ALL(MASK,DIM) is equivalent to ALL(MASK). If the rank is greater than one,
! then ALL(MASK,DIM) is determined by applying ALL to the array sections.
! Standard: Fortran 95 and later.
logical :: MASK(:[,...])
integer :: DIM
end function
logical function ALLOCATED(ARRAY)
! Checks the status of whether X is allocated.
! Arguments:
! ARRAY -The argument shall be an ALLOCATABLE array.
! Return value:
! The return value is a scalar LOGICAL with the default logical kind type parameter.
! If ARRAY is allocated, ALLOCATED(ARRAY) is .TRUE.; otherwise, it returns .FALSE.
! Standard: Fortran 95 and later.
type(any_allocatable_array) :: ARRAY
end function
real function ANINT(A [, KIND])
! Rounds its argument to the nearest whole number.
! Arguments:
! A -The type of the argument shall be REAL.
! KIND -(Optional) An INTEGER initialization expression indicating the kind parameter of the result.
! Return value:
! The return value is of type real with the kind type parameter of the argument if the optional KIND is absent;
! otherwise, the kind type parameter will be given by KIND. If A is greater than zero, ANINT(A) returns AINT(X+0.5).
! If A is less than or equal to zero then it returns AINT(X-0.5).
! Standard: Fortran 77 and later.
real :: A
integer :: KIND
end function
double precision function DNINT(A)
! Rounds its argument to the nearest whole number.
! Arguments:
! A -The type of the argument shall be DOUBLE PRECISION.
! Return value:
! The return value is of type real with the kind type parameter of the argument if the optional KIND is absent;
! otherwise, the kind type parameter will be given by KIND. If A is greater than zero, ANINT(A) returns AINT(X+0.5).
! If A is less than or equal to zero then it returns AINT(X-0.5).
! Standard: Fortran 77 and later.
double precision :: A
end function
logical function ANY(MASK [, DIM])
! Determines if any of the values in the logical array MASK along dimension DIM are .TRUE..
! Arguments:
! MASK -The type of the argument shall be LOGICAL and it shall not be scalar.
! DIM -(Optional) DIM shall be a scalar integer with a value that lies between one and the rank of MASK.
! Return value:
! ANY(MASK) returns a scalar value of type LOGICAL where the kind type parameter is the same as the kind type
! parameter of MASK. If DIM is present, then ANY(MASK, DIM) returns an array with the rank of MASK minus 1.
! The shape is determined from the shape of MASK where the DIM dimension is elided.
! (A)
! ANY(MASK) is true if any element of MASK is true; otherwise, it is false. It also is false if MASK has zero size.
! (B)
! If the rank of MASK is one, then ANY(MASK,DIM) is equivalent to ANY(MASK). If the rank is greater than one,
! then ANY(MASK,DIM) is determined by applying ANY to the array sections.
! Standard: Fortran 95 and later.
logical :: MASK(:[,...])
integer :: DIM
end function
function ASIN(X)
! Computes the arcsine of its X (inverse of SIN(X)).
! Arguments:
! X -The type shall be either REAL and a magnitude that is less than or equal to one - or be COMPLEX.
! Return value:
! The return value is of the same type and kind as X. The real part of the result is in radians and
! lies in the range -pi/2 <= asin(x) <= pi/2.
! Standard: Fortran 77 and later, for a complex argument Fortran 2008 or later.
real, complex :: ASIN, X
end function
function DASIN(X)
! This is specific name of ASIN function.
! Computes the arcsine of its X (inverse of SIN(X)).
! Arguments:
! X -The type shall be DOUBLE PRECISION and a magnitude that is less than or equal to one.
! Return value:
! The return value is of the same type and kind as X. The real part of the result is in radians and
! lies in the range -pi/2 <= asin(x) <= pi/2.
! Standard: Fortran 77 and later
double precision :: DASIN, X
end function
function ASINH(X)
! Computes the hyperbolic arcsine of X (inverse of SINH(X)).
! Arguments:
! X -The type shall be REAL or COMPLEX.
! Return value:
! The return value is of the same type and kind as X. If X is complex, the imaginary part of the result
! is in radians and lies between -pi/2 <= asinh(x) <= pi/2.
! Standard: Fortran 2008 and later
real, complex :: ASINH, X
end function
logical function ASSOCIATED(POINTER [, TARGET])
! Determines the status of the pointer POINTER or if POINTER is associated with the target TARGET.
! Arguments:
! POINTER -POINTER shall have the POINTER attribute and it can be of any type.
! TARGET -(Optional) TARGET shall be a pointer or a target. It must have the same type,
! kind type parameter, and array rank as POINTER.
! The association status of neither POINTER nor TARGET shall be undefined.
! Return value:
! ASSOCIATED(POINTER) returns a scalar value of type LOGICAL(4). There are several cases:
! (A) When the optional TARGET is not present then
! ASSOCIATED(POINTER) is true if POINTER is associated with a target; otherwise, it returns false.
! (B) If TARGET is present and a scalar target, the result is true if
! TARGET is not a zero-sized storage sequence and the target associated with POINTER occupies
! the same storage units. If POINTER is disassociated, the result is false.
!(C) If TARGET is present and an array target, the result is true if
! TARGET and POINTER have the same shape, are not zero-sized arrays, are arrays whose elements
! are not zero-sized storage sequences, and TARGET and POINTER occupy the same storage units
! in array element order. As in case(B), the result is false, if POINTER is disassociated.
!(D) If TARGET is present and an scalar pointer, the result is true
! if TARGET is associated with POINTER, the target associated with TARGET are not zero-sized storage
! sequences and occupy the same storage units. The result is false, if either TARGET or POINTER is disassociated.
!(E) If TARGET is present and an array pointer, the result is true if
! target associated with POINTER and the target associated with TARGET have the same shape,
! are not zero-sized arrays, are arrays whose elements are not zero-sized storage sequences, and TARGET
! and POINTER occupy the same storage units in array element order. The result is false, if either TARGET
! or POINTER is disassociated.
! Standard: Fortran 95 and later
type(any_pointer) :: POINTER, TARGET
end function
function ATAN(X)
! Computes the arctangent of X.
! Syntax:
! RESULT = ATAN(X) RESULT = ATAN(Y, X)
! Arguments:
! X -The type shall be REAL or COMPLEX; if Y is present, X shall be REAL.
! Y -shall be of the same type and kind as X.
! Return value:
! The return value is of the same type and kind as X. If Y is present, the result is identical to ATAN2(Y,X).
! Otherwise, it the arcus tangent of X, where the real part of the result is in radians and lies
! in the range -pi/2 <= atan(x) <= pi/2.
! Standard: Fortran 77 and later, for a complex argument and for two arguments Fortran 2008 or later.
real, complex :: ATAN, X
end function
function DATAN(X)
! This is specific name of function ATAN.
! Computes the arctangent of X.
! Arguments:
! X -The type shall be DOUBLE PRECISION
! Return value:
! The return value is of the same type and kind as X. If Y is present, the result is identical to ATAN2(Y,X).
! Otherwise, it the arcus tangent of X, where the real part of the result is in radians and lies
! in the range -pi/2 <= atan(x) <= pi/2.
! Standard: Fortran 77 and later
double precision :: DATAN, X
end function
real function ATAN2(Y, X)
! Computes the principal value of the argument function of the complex number X + i Y.
! This function can be used to transform from carthesian into polar coordinates and allows to determine
! the angle in the correct quadrant.
! Arguments:
! Y -The type shall be REAL.
! X -The type and kind type parameter shall be the same as Y. If Y is zero, then X must be nonzero.
! Return value:
! The return value has the same type and kind type parameter as Y. It is the principal value of the complex
! number X + i Y. If X is nonzero, then it lies in the range -pi <= atan(x) <= pi. The sign is positive
! if Y is positive. If Y is zero, then the return value is zero if X is positive and \pi if X is negative.
! Finally, if X is zero, then the magnitude of the result is pi/2.
! Standard: Fortran 77 and later.
real :: Y, X
end function
double precision function DATAN2(Y, X)
! This is specific name of ATAN2 function.
! Computes the principal value of the argument function of the complex number X + i Y.
! This function can be used to transform from carthesian into polar coordinates and allows to determine
! the angle in the correct quadrant.
! Arguments:
! Y -The type shall be DOUBLE PRECISION.
! X -The type and kind type parameter shall be the same as Y. If Y is zero, then X must be nonzero.
! Return value:
! The return value has the same type and kind type parameter as Y. It is the principal value of the complex
! number X + i Y. If X is nonzero, then it lies in the range -pi <= atan(x) <= pi. The sign is positive
! if Y is positive. If Y is zero, then the return value is zero if X is positive and \pi if X is negative.
! Finally, if X is zero, then the magnitude of the result is pi/2.
! Standard: Fortran 77 and later.
DOUBLE PRECISION :: Y, X
end function
function ATANH(X)
! Computes the hyperbolic arctangent of X (inverse of TANH(X)).
! Arguments:
! X -The type shall be REAL or COMPLEX.
! Return value:
! The return value has same type and kind as X. If X is complex, the imaginary part of the result is
! in radians and lies between -pi/2 <= atanh(x) <= pi/2.
! Standard: Fortran 2008 and later.
real, complex :: ATANH, X
end function
real function BESSEL_J0(X)
! Computes the Bessel function of the first kind of order 0 of X.
! Arguments:
! X -The type shall be REAL, and it shall be scalar.
! Return value:
! The return value is of type REAL and lies in the range - 0.4027... <= Bessel(0,x) <= 1.
! It has the same kind as X.
! Standard: Fortran 2008 and later.
real :: X
end function
real function BESSEL_J1(X)
! Computes the Bessel function of the first kind of order 1 of X.
! Arguments:
! X -The type shall be REAL, and it shall be scalar.
! Return value:
! The return value is of type REAL and it lies in the range -0.5818... <= Bessel(0,x) <= 0.5818 .
! It has the same kind as X.
! Standard: Fortran 2008 and later.
real :: X
end function
real function BESSEL_JN(N, X)
! Computes the Bessel function of the first kind of order N of X.
! Arguments:
! N -Shall be a scalar or an array of type INTEGER.
! X -Shall be a scalar or an array of type REAL.
! Return value:
! The return value is a scalar of type REAL. It has the same kind as X.
! Standard: Fortran 2008 and later.
integer :: N
real :: X
end function
real function BESSEL_Y0(X)
! Computes the Bessel function of the second kind of order 0 of X.
! Arguments:
! X -The type shall be REAL, and it shall be scalar.
! Return value:
! The return value is a scalar of type REAL. It has the same kind as X.
! Standard: Fortran 2008 and later.
real :: X
end function
real function BESSEL_Y1(X)
! Computes the Bessel function of the second kind of order 1 of X.
! Arguments:
! X -The type shall be REAL, and it shall be scalar.
! Return value:
! The return value is a scalar of type REAL. It has the same kind as X.
! Standard: Fortran 2008 and later.
real :: X
end function
real function BESSEL_YN(N, X)
! Computes the Bessel function of the second kind of order N of X.
! Arguments:
! N -Shall be a scalar or an array of type INTEGER.
! X -Shall be a scalar or an array of type REAL.
! If both arguments are arrays, their ranks and shapes shall conform.
! Return value:
! The return value is a scalar of type REAL. It has the same kind as X.
integer :: N
real :: X
end function
integer function BIT_SIZE(I)
! Returns the number of bits (integer precision plus sign bit) represented by the type of I.
! The result of BIT_SIZE(I) is independent of the actual value of I.
! Arguments:
! I -The type shall be INTEGER.
! Return value:
! The return value is of type INTEGER.
! Standard: Fortran 95 and later.
integer :: I
end function
logical function BTEST(I, POS)
! Returns logical .TRUE. if the bit at POS in I is set. The counting of the bits starts at 0.
! Arguments:
! I -The type shall be INTEGER.
! POS -The type shall be INTEGER.
! Return value:
! The return value is of type LOGICAL
! Standard: Fortran 95 and later.
integer :: I, POS
end function
complex function CABS(A)
! It is specific name of ABS procedure.
! Computes the absolute value of A.
! Arguments:
! A -The type of the argument shall be an default COMPLEX.
complex :: A
end function
integer function CEILING(A [, KIND])
! Returns the least integer greater than or equal to A
! Arguments:
! A -The type shall be REAL.
! KIND -(Optional) An INTEGER initialization expression indicating the kind parameter of the result.
! Return value:
! The return value is of type INTEGER(KIND) if KIND is present and a default-kind INTEGER otherwise.
! Standard: Fortran 95 and later
real :: A
integer, optional :: KIND
end function
CHARACTER(1) function CHAR(I [, KIND])
! Returns the character represented by the integer I
! Arguments:
! I -The type shall be INTEGER.
! KIND -(Optional) An INTEGER initialization expression indicating the kind parameter of the result.
! Return value:
! The return value is of type CHARACTER(1)
! Standard: Fortran 77 and later
integer :: I
integer, optional :: KIND
end function
complex function CMPLX(X [, Y [, KIND]])
! Returns a complex number where X is converted to the real component
! If Y is present it is converted to the imaginary component. If Y is not present then the imaginary
! component is set to 0.0. If X is complex then Y must not be present.
! Arguments:
! X -The type may be INTEGER, REAL, or COMPLEX.
! Y -(Optional; only allowed if X is not COMPLEX.) May be INTEGER or REAL.
! KIND -(Optional) An INTEGER initialization expression indicating the kind parameter of the result.
! Return value:
! The return value is of COMPLEX type, with a kind equal to KIND if it is specified. If KIND is not specified,
! the result is of the default COMPLEX kind, regardless of the kinds of X and Y.
! Standard: Fortran 77 and later
integer, real, complex :: X
integer, real :: Y
integer, optional :: KIND
end function
integer function COMMAND_ARGUMENT_COUNT()
! Returns the number of arguments passed on the command line when the containing program was invoked
! Return value:
! The return value is an INTEGER of default kind.
! Standard: Fortran 2003 and later
end function
function CONJG(Z)
! Returns the conjugate of Z. If Z is (x, y) then the result is (x, -y)
! Arguments:
! Z -The type shall be COMPLEX.
! Return value:
! The return value is of type COMPLEX.
! Standard: Fortran 77 and later
complex :: Z, CONJG
end function
function COS(X)
! Computes the cosine of X.
! Arguments:
! X -The type shall be REAL or COMPLEX.
! Return value:
! The return value is of the same type and kind as X. The real part of the result is in radians.
! If X is of the type REAL, the return value lies in the range -1 <= cos(x) <= 1.
! Standard: Fortran 77 and later
real, complex :: X, COS
end function
function CCOS(X)
! This is specific name of COS function.
! Computes the cosine of X.
! Arguments:
! X -The type shall be COMPLEX.
! Return value:
! The return value is of the same type and kind as X. The real part of the result is in radians.
! If X is of the type REAL, the return value lies in the range -1 <= cos(x) <= 1.
! Standard: Fortran 77 and later
COMPLEX :: CCOS, X
end function
function DCOS(X)
! This is specific name of COS function.
! Computes the cosine of X.
! Arguments:
! X -The type shall be Doubleprecision.
! Return value:
! The return value is of the same type and kind as X. The real part of the result is in radians.
! If X is of the type REAL, the return value lies in the range -1 <= cos(x) <= 1.
! Standard: Fortran 77 and later
doubleprecision :: DCOS, X
end function
function COSH(X)
! Computes the hyperbolic cosine of X.
! Arguments:
! X -The type shall be REAL or COMPLEX.
! Return value:
! The return value has same type and kind as X. If X is complex, the imaginary part of the result
! is in radians. If X is REAL, the return value has a lower bound of one, cosh(x) >= 1.
! Standard: Fortran 77 and later, for a complex argument Fortran 2008 or later
real, complex :: X, COSH
end function
function DCOSH(X)
! This is specific name of COSH function.
! Computes the hyperbolic cosine of X.
! Arguments:
! X -The type shall be DOUBLE PRECISION.
! Return value:
! The return value has same type and kind as X. If X is complex, the imaginary part of the result
! is in radians. If X is REAL, the return value has a lower bound of one, cosh(x) >= 1.
! Standard: Fortran 77 and later.
doubleprecision :: DCOSH, X
end function
function COUNT(MASK [, DIM, KIND])
! Counts the number of .TRUE. elements in a logical MASK, or, if the DIM argument is supplied,
! counts the number of elements along each row of the array in the DIM direction. If the array
! has zero size, or all of the elements of MASK are .FALSE., then the result is 0.
! Arguments:
! MASK -The type shall be LOGICAL.
! DIM -(Optional) The type shall be INTEGER.
! KIND -(Optional) An INTEGER initialization expression indicating the kind parameter of the result.
! Return value:
! The return value is of type INTEGER and of kind KIND. If KIND is absent, the return value is
! of default integer kind. If DIM is present, the result is an array with a rank one less than
! the rank of ARRAY, and a size corresponding to the shape of ARRAY with the DIM dimension removed.
! Standard: Fortran 95 and later, with KIND argument Fortran 2003 and later
logical :: MASK(:[,...])
integer, optional :: DIM, KIND
end function
subroutine CPU_TIME(TIME)
! Returns a REAL value representing the elapsed CPU time in seconds. This is useful for testing
! segments of code to determine execution time.
! If a time source is available, time will be reported with microsecond resolution. If no time
! source is available, TIME is set to -1.0.
! Note that TIME may contain a system dependent, arbitrary offset and may not start with 0.0.
! For CPU_TIME, the absolute value is meaningless, only differences between subsequent calls
! to this subroutine, as shown in the example below, should be used.
! Arguments:
! TIME -The type shall be REAL with INTENT(OUT).
! Standard: Fortran 95 and later
real, intent(out) :: TIME
end subroutine
function CSHIFT(ARRAY, SHIFT [, DIM])
! Performs a circular shift on elements of ARRAY along the dimension of DIM. If DIM is omitted it is
! taken to be 1. DIM is a scalar of type INTEGER in the range of 1 \leq DIM \leq n) where n is the
! rank of ARRAY. If the rank of ARRAY is one, then all elements of ARRAY are shifted by SHIFT places.
! If rank is greater than one, then all complete rank one sections of ARRAY along the given dimension
! are shifted. Elements shifted out one end of each rank one section are shifted back in the other end.
! Arguments:
! ARRAY -Shall be an array of any type.
! SHIFT -The type shall be INTEGER.
! DIM -The type shall be INTEGER.
! Return value:
! Returns an array of same type and rank as the ARRAY argument.
! Standard: Fortran 95 and later
type(any_type) :: ARRAY(:[,...])
integer :: SHIFT
integer, optional :: DIM
end function
function DABS(A)
! It is specific name of ABS procedure.
! Computes the absolute value of A.
! Arguments:
! A -The type of the argument shall be an default DOUBLEPRECISION.
double precision :: DABS, A
end function
subroutine DATE_AND_TIME([DATE, TIME, ZONE, VALUES])
! Gets the corresponding date and time information from the real-time system clock. DATE is INTENT(OUT)
! and has form ccyymmdd. TIME is INTENT(OUT) and has form hhmmss.sss. ZONE is INTENT(OUT) and has
! form (+-)hhmm, representing the difference with respect to Coordinated Universal Time (UTC).
! Unavailable time and date parameters return blanks.
! VALUES is INTENT(OUT) and provides the following:
! VALUE(1): The year
! VALUE(2): The month
! VALUE(3): The day of the month
! VALUE(4): Time difference with UTC in minutes
! VALUE(5): The hour of the day
! VALUE(6): The minutes of the hour
! VALUE(7): The seconds of the minute
! VALUE(8): The milliseconds of the second
! Arguments:
! DATE -(Optional) The type shall be CHARACTER(LEN=8) or larger, and of default kind.
! TIME -(Optional) The type shall be CHARACTER(LEN=10) or larger, and of default kind.
! ZONE -(Optional) The type shall be CHARACTER(LEN=5) or larger, and of default kind.
! VALUES -(Optional) The type shall be INTEGER(8).
! Standard: Fortran 95 and later
character(len=8 or larger), optional :: DATE
character(len=10 or larger), optional :: TIME
character(len=5 or larger), optional :: ZONE
integer, dimension(8), optional :: VALUES
end subroutine
function DBLE(A)
! Converts A to double precision real type.
! Arguments:
! A -The type shall be INTEGER, REAL, or COMPLEX.
! Return value:
! The return value is of type double precision real.
! Standard: Fortran 77 and later
integer, real, complex :: A
doubleprecision :: DBLE
end function
function DIGITS(X)
! Returns the number of significant binary digits of the internal model representation of X.
! For example, on a system using a 32-bit floating point representation, a default real number
! would likely return 24.
! Arguments:
! X -The type may be INTEGER or REAL.
! Return value:
! The return value is of type INTEGER.
! Standard: Fortran 95 and later
integer :: DIGITS
integer, real :: X
end function
function DIM(X,Y)
! Returns the difference X-Y if the result is positive; otherwise returns zero.
! Arguments:
! X -The type shall be INTEGER or REAL
! Y -The type shall be the same type and kind as X.
! Return value:
! The return value is of type INTEGER or REAL.
! Standard: Fortran 77 and later
integer, real :: X, Y, DIM
end function
function IDIM(X,Y)
! This is specific name of DIM function.
! Returns the difference X-Y if the result is positive; otherwise returns zero.
! Arguments:
! X -The type shall be INTEGER.
! Y -The type shall be the same type and kind as X.
! Return value:
! The return value is of type INTEGER.
! Standard: Fortran 77 and later
integer :: IDIM, X, Y
end function
function DDIM(X,Y)
! This is specific name of DIM function.
! Returns the difference X-Y if the result is positive; otherwise returns zero.
! Arguments:
! X -The type shall be DOUBLE PRECISION.
! Y -The type shall be the same type and kind as X.
! Return value:
! The return value is of type DOUBLE PRECISION.
! Standard: Fortran 77 and later
DOUBLE PRECISION :: DDIM, X, Y
end function
function DOT_PRODUCT(VECTOR_A, VECTOR_B)
! Computes the dot product multiplication of two vectors VECTOR_A and VECTOR_B.
! The two vectors may be either numeric or logical and must be arrays of rank one
! and of equal size. If the vectors are INTEGER or REAL, the result is SUM(VECTOR_A*VECTOR_B).
! If the vectors are COMPLEX, the result is SUM(CONJG(VECTOR_A)*VECTOR_B). If the vectors
! are LOGICAL, the result is ANY(VECTOR_A .AND. VECTOR_B).
! Arguments:
! VECTOR_A -The type shall be numeric or LOGICAL, rank 1.
! VECTOR_B -The type shall be numeric if VECTOR_A is of numeric type or LOGICAL if VECTOR_A
! is of type LOGICAL. VECTOR_B shall be a rank-one array.
! Return value:
! If the arguments are numeric, the return value is a scalar of numeric type, INTEGER, REAL,
! or COMPLEX. If the arguments are LOGICAL, the return value is .TRUE. or .FALSE..
! Standard: Fortran 95 and later
type(any_numerical_or_logical) :: VECTOR_A(:), VECTOR_B(:)
type(same_as_argument) :: DOT_PRODUCT
end function
function DPROD(X,Y)
! Returns the product X*Y.
! Arguments:
! X -The type shall be REAL.
! Y -The type shall be REAL.
! Return value:
! The return value is of type REAL(8).
! Standard: Fortran 77 and later
real(8) :: DPROD
real :: X, Y
end function
function EOSHIFT(ARRAY, SHIFT [, BOUNDARY, DIM])
! Performs an end-off shift on elements of ARRAY along the dimension of DIM. If DIM is omitted it is
! taken to be 1. DIM is a scalar of type INTEGER in the range of 1 \leq DIM \leq n) where n is the
! rank of ARRAY. If the rank of ARRAY is one, then all elements of ARRAY are shifted by SHIFT places.
! If rank is greater than one, then all complete rank one sections of ARRAY along the given dimension
! are shifted. Elements shifted out one end of each rank one section are dropped. If BOUNDARY is present
! then the corresponding value of from BOUNDARY is copied back in the other end. If BOUNDARY is not
! present then the following are copied in depending on the type of ARRAY.
! "Array Type" "Boundary Value"
! Numeric 0 of the type and kind of ARRAY.
! Logical .FALSE..
! Character(len) len blanks.
! Arguments:
! ARRAY May be any type, not scalar.
! SHIFT The type shall be INTEGER.
! BOUNDARY Same type as ARRAY.
! DIM The type shall be INTEGER.
! Return value:
! Returns an array of same type and rank as the ARRAY argument.
! Standard: Fortran 95 and later
type(any_type) :: ARRAY(:[,...])
integer :: SHIFT
type(same_as_ARRAY), optional :: BOUNDARY[(:[,...])]
type(same_as_ARRAY) :: EOSHIFT(:[,...])
end function
function EPSILON(X)
! Returns the smallest number E of the same kind as X such that 1 + E > 1.
! Arguments:
! X -The type shall be REAL.
! Return value:
! The return value is of same type as the argument.
! Standard: Fortran 95 and later
real :: X, EPSILON
end function
function ERF(X)
! Computes the error function of X.
! Arguments:
! X -The type shall be REAL.
! Return value:
! The return value is of type REAL, of the same kind as X and lies in the range -1 <= erf(x) <= 1 .
! Standard: Fortran 2008 and later
real :: X, ERF
end function
function ERFC(X)
! Computes the complementary error function of X.
! Arguments:
! X -The type shall be REAL.
! Return value:
! The return value is of type REAL and of the same kind as X. It lies in the range 0 <= erfc(x) <= 2 .
! Standard: Fortran 2008 and later
real :: X, ERFC
end function
function ERFC_SCALED(X)
! Computes the exponentially-scaled complementary error function of X.
! Arguments:
! X -The type shall be REAL.
! Return value:
! The return value is of type REAL and of the same kind as X.
! Standard: Fortran 2008 and later
real :: X, ERFC_SCALED
end function
function EXP(X)
! Computes the base e exponential of X.
! Arguments:
! X -The type shall be REAL or COMPLEX.
! Return value:
! The return value has same type and kind as X.
! Standard: Fortran 77 and later
real, complex :: X, EXP
end function
function CEXP(X)
! This is specific name of EXP function.
! Computes the base e exponential of X.
! Arguments:
! X -The type shall be COMPLEX.
! Return value:
! The return value has same type and kind as X.
! Standard: Fortran 77 and later
COMPLEX :: CEXP, X
end function
function DEXP(X)
! This is specific name of EXP function.
! Computes the base e exponential of X.
! Arguments:
! X -The type shall be DOUBLE PRECISION.
! Return value:
! The return value has same type and kind as X.
! Standard: Fortran 77 and later
DOUBLE PRECISION :: DEXP, X
end function
function EXPONENT(X)
! Returns the value of the exponent part of X. If X is zero the value returned is zero.
! Arguments:
! X -The type shall be REAL.
! Return value:
! The return value is of type default INTEGER.
! Standard: Fortran 95 and later
real :: X
integer :: EXPONENT
end function
function FLOAT(A)
! Converts the integer A to a default real value.
! Arguments:
! A -The type shall be INTEGER.
! Return value:
! The return value is of type default REAL.
! Standard: Fortran 77 and later
integer :: A
real :: FLOAT
end function
function FLOOR(A [, KIND])
! Returns the greatest integer less than or equal to X.
! Arguments:
! A -The type shall be REAL.
! KIND -(Optional) An INTEGER initialization expression indicating the kind parameter of the result.
! Return value:
! The return value is of type INTEGER(KIND) if KIND is present and of default-kind INTEGER otherwise.
! Standard: Fortran 95 and later
real :: A
integer, optional :: KIND
integer(KIND) :: FLOOR
end function
function FRACTION(X)
! Returns the fractional part of the model representation of X.
! Arguments:
! X -The type of the argument shall be a REAL.
! Return value:
! The return value is of the same type and kind as the argument. The fractional part of the model
! representation of X is returned; it is X * RADIX(X)**(-EXPONENT(X)).
! Standard: Fortran 95 and later
real :: X, FRACTION
end function
function GAMMA(X)
! Computes Gamma of X. For positive, integer values of X the Gamma function simplifies to the factorial
! function \Gamma(x)=(x-1)!.
! Arguments:
! X -Shall be of type REAL and neither zero nor a negative integer.
! Return value:
! The return value is of type REAL of the same kind as X.
! Standard: Fortran 2008 and later
real :: X, GAMMA
end function
subroutine GET_COMMAND([COMMAND, LENGTH, STATUS])
! Retrieve the entire command line that was used to invoke the program.
! Arguments:
! COMMAND -(Optional) shall be of type CHARACTER and of default kind.
! LENGTH -(Optional) Shall be of type INTEGER and of default kind.
! STATUS -(Optional) Shall be of type INTEGER and of default kind.
!
! Return value:
! If COMMAND is present, stores the entire command line that was used to invoke the program in COMMAND.
! If LENGTH is present, it is assigned the length of the command line.
! If STATUS is present, it is assigned 0 upon success of the command, -1 if COMMAND is too short
! to store the command line, or a positive value in case of an error.
! Standard: Fortran 2003 and later
character(len=*), optional :: COMMAND
integer, optional :: LENGTH
integer, optional :: STATUS
end subroutine
subroutine GET_COMMAND_ARGUMENT(NUMBER[, VALUE, LENGTH, STATUS])
! Retrieve the NUMBER-th argument that was passed on the command line when the containing program was invoked.
! Arguments:
! NUMBER Shall be a scalar of type INTEGER and of default kind, NUMBER >= 0
! VALUE (Optional) Shall be a scalar of type CHARACTER and of default kind.
! LENGTH (Optional) Shall be a scalar of type INTEGER and of default kind.
! STATUS (Optional) Shall be a scalar of type INTEGER and of default kind.
!Return value:
! After GET_COMMAND_ARGUMENT returns, the VALUE argument holds the NUMBER-th command line argument.
! If VALUE can not hold the argument, it is truncated to fit the length of VALUE.
! If there are less than NUMBER arguments specified at the command line, VALUE will be filled with blanks.
! If NUMBER = 0, VALUE is set to the name of the program (on systems that support this feature).
! The LENGTH argument contains the length of the NUMBER-th command line argument.
! If the argument retrieval fails, STATUS is a positive number; if VALUE contains a truncated
! command line argument, STATUS is -1; and otherwise the STATUS is zero.
! Standard: Fortran 2003 and later
integer :: NUMBER
character(len=*), optional :: VALUE
integer, optional :: LENGTH
integer, optional :: STATUS
end subroutine
subroutine GET_ENVIRONMENT_VARIABLE(NAME[, VALUE, LENGTH, STATUS, TRIM_NAME])
! Get the VALUE of the environmental variable NAME.
! Arguments:
! NAME -Shall be a scalar of type CHARACTER and of default kind.
! VALUE -Shall be a scalar of type CHARACTER and of default kind.
! LENGTH -Shall be a scalar of type INTEGER and of default kind.
! STATUS -Shall be a scalar of type INTEGER and of default kind.
! TRIM_NAME -Shall be a scalar of type LOGICAL and of default kind.
! Return value:
! Stores the value of NAME in VALUE. If VALUE is not large enough to hold the data, it is truncated.
! If NAME is not set, VALUE will be filled with blanks. Argument LENGTH contains the length needed
! for storing the environment variable NAME or zero if it is not present. STATUS is -1 if VALUE is
! present but too short for the environment variable; it is 1 if the environment variable does not exist
! and 2 if the processor does not support environment variables; in all other cases STATUS is zero.
! If TRIM_NAME is present with the value .FALSE., the trailing blanks in NAME are significant; otherwise
! they are not part of the environment variable name.
! Standard: Fortran 2003 and later
character(len=*) :: NAME
character(len=*), optional :: VALUE
integer, optional :: LENGTH
integer, optional :: STATUS
logical, optional :: TRIM_NAME
end subroutine
function HUGE(X)
! Returns the largest number that is not an infinity in the model of the type of X.
! Arguments:
! X -Shall be of type REAL or INTEGER.
! Return value:
! The return value is of the same type and kind as X
! Standard: Fortran 95 and later
real, integer :: X, HUGE
end function
function HYPOT(X, Y)
! HYPOT(X,Y) is the Euclidean distance function. It is equal to sqrt(X^2 + Y^2), without undue underflow or overflow.
! Arguments:
! X -The type shall be REAL.
! Y -The type and kind type parameter shall be the same as X.
! Return value:
! The return value has the same type and kind type parameter as X.
! Standard: Fortran 2008 and later
real :: X, Y, HYPOT
end function
function IABS(A)
! It is specific name of ABS procedure.
! Computes the absolute value of A.
! Arguments:
! A -The type of the argument shall be an default INTEGER.
integer :: IABS, A
end function
function IACHAR(C [, KIND])
! Returns the code for the ASCII character in the first character position of C.
! Arguments:
! C -Shall be a scalar CHARACTER, with INTENT(IN)
! KIND -(Optional) An INTEGER initialization expression indicating the kind parameter of the result.
! Return value:
! The return value is of type INTEGER and of kind KIND. If KIND is absent, the return value is of default integer kind.
! Standard: Fortran 95 and later, with KIND argument Fortran 2003 and later
character, intent(in) :: C
integer, optional :: KIND
integer(KIND) :: IACHAR
end function
function IAND(I, J)
! Bitwise logical AND.
! Arguments:
! I -The type shall be INTEGER.
! J -The type shall be INTEGER, of the same kind as I.
! Return value:
! The return type is INTEGER, of the same kind as the arguments.
! Standard: Fortran 95 and later
integer :: I, J, IAND
end function
function IBCLR(I, POS)
!returns the value of I with the bit at position POS set to zero.
! Arguments:
! I -The type shall be INTEGER.
! POS -The type shall be INTEGER.
! Return value:
! The return value is of type INTEGER and of the same kind as I.
! Standard: Fortran 95 and later
integer :: IBCLR, I, POS
end function
function IBITS(I, POS, LEN)
! IBITS extracts a field of length LEN from I, starting from bit position POS and extending left for LEN bits.
! The result is right-justified and the remaining bits are zeroed. The value of POS+LEN must be less
! than or equal to the value BIT_SIZE(I).
! Arguments:
! I -The type shall be INTEGER.
! POS -The type shall be INTEGER.
! LEN -The type shall be INTEGER.
! Return value:
! The return value is of type INTEGER and of the same kind as I.
! Standard: Fortran 95 and later
integer :: IBITS, I, POS, LEN
end function
function IBSET(I, POS)
! IBSET returns the value of I with the bit at position POS set to one.
! Arguments:
! I -The type shall be INTEGER.
! POS -The type shall be INTEGER.
! Return value:
! The return value is of type INTEGER and of the same kind as I.
! Standard: Fortran 95 and later
integer :: IBSET, I, POS
end function
function ICHAR(C [, KIND])
! Returns the code for the character in the first character position of C in the system's
! native character set.
! Arguments:
! C -Shall be a scalar CHARACTER, with INTENT(IN)
! KIND -(Optional) An INTEGER initialization expression indicating the kind parameter of the result.
! Return value:
! The return value is of type INTEGER and of kind KIND. If KIND is absent,
! the return value is of default integer kind.
! Standard: Fortan 95 and later, with KIND argument Fortran 2003 and later
character, intent(in) :: C
integer, optional :: KIND
integer(KIND) :: ICHAR
end function
function IEOR(I, J)
! Returns the bitwise boolean exclusive-OR of I and J.
! Arguments:
! I -The type shall be INTEGER.
! J -The type shall be INTEGER, of the same kind as I.
! Return value:
! The return type is INTEGER, of the same kind as the arguments.
! Standard: Fortran 95 and later
integer :: IEOR, I, J
end function
function INDEX(STRING, SUBSTRING [, BACK [, KIND]])
! Returns the position of the start of the first occurrence of string SUBSTRING as a substring in STRING,
! counting from one. If SUBSTRING is not present in STRING, zero is returned. If the BACK argument is
! present and true, the return value is the start of the last occurrence rather than the first.
! Standard: Fortran 77 and later, with KIND argument Fortran 2003 and later
! Arguments:
! STRING -Shall be a scalar CHARACTER, with INTENT(IN)
! SUBSTRING -Shall be a scalar CHARACTER, with INTENT(IN)
! BACK -(Optional) Shall be a scalar LOGICAL, with INTENT(IN)
! KIND -(Optional) An INTEGER initialization expression indicating the kind parameter of the result.
! Return value:
! The return value is of type INTEGER and of kind KIND. If KIND is absent,
! the return value is of default integer kind.
integer :: INDEX
character(len=*) :: STRING, SUBSTRING
logical, optional :: BACK
integer, optional :: KIND
end function
function INT(A [, KIND))
! Convert to integer type
! Arguments:
! A -Shall be of type INTEGER, REAL, or COMPLEX.
! KIND -(Optional) An INTEGER initialization expression indicating the kind parameter of the result.
! Return value:
! These functions return a INTEGER variable or array under the following rules:
! (A)
! If A is of type INTEGER, INT(A) = A
!(B)
! If A is of type REAL and |A| < 1, INT(A) equals 0. If |A| >= 1, then INT(A) equals the largest
! integer that does not exceed the range of A and whose sign is the same as the sign of A.
! (C)
! If A is of type COMPLEX, rule B is applied to the real part of A.
! Standard: Fortran 77 and later
integer, real, complex :: A
integer, optional :: KIND
integer(KIND) :: INT
end function
function IFIX(A)
! This is specific name of INT function.
! Convert to integer type
! Standard: Fortran 77 and later
real :: A
integer :: IFIX
end function
function IDINT(A)
! This is specific name of INT function.
! Convert to integer type
! Standard: Fortran 77 and later
double precision :: A
integer :: IDINT
end function
function IOR(I, J)
! IOR returns the bitwise boolean inclusive-OR of I and J.
! Arguments:
! I -The type shall be INTEGER.
! J -The type shall be INTEGER, of the same kind as I.
! Return value:
! The return type is INTEGER, of the same kind as the arguments.
! Standard: Fortran 95 and later
integer :: IOR, I, J
end function
function IS_IOSTAT_END(I)
! Tests whether an variable has the value of the I/O status 'end of file'. The function is
! equivalent to comparing the variable with the IOSTAT_END parameter of the intrinsic module ISO_FORTRAN_ENV.
! Arguments:
! I -Shall be of the type INTEGER.
! Return value:
! Returns a LOGICAL of the default kind, which .TRUE. if I has the value which indicates an end of file
! condition for IOSTAT= specifiers, and is .FALSE. otherwise.
! Standard: Fortran 2003 and later
integer :: I
logical :: IS_IOSTAT_END
end function
function IS_IOSTAT_EOR(I)
! Tests whether an variable has the value of the I/O status 'end of record'. The function is equivalent
! to comparing the variable with the IOSTAT_EOR parameter of the intrinsic module ISO_FORTRAN_ENV.
! Arguments:
! I -Shall be of the type INTEGER.
! Return value:
! Returns a LOGICAL of the default kind, which .TRUE. if I has the value which indicates an end of file
! condition for IOSTAT= specifiers, and is .FALSE. otherwise.
! Standard: Fortran 2003 and later
logical :: IS_IOSTAT_EOR
integer :: I
end function
function ISHFT(I, SHIFT)
! Returns a value corresponding to I with all of the bits shifted SHIFT places. A value of SHIFT
! greater than zero corresponds to a left shift, a value of zero corresponds to no shift, and a value
! less than zero corresponds to a right shift. If the absolute value of SHIFT is greater than BIT_SIZE(I),
! the value is undefined. Bits shifted out from the left end or right end are lost; zeros are shifted
! in from the opposite end.
! Arguments:
! I -The type shall be INTEGER.
! SHIFT -The type shall be INTEGER.
! Return value:
! The return value is of type INTEGER and of the same kind as I.
! Standard: Fortran 95 and later
integer :: I, SHIFT, ISHFT
end function
function ISHFTC(I, SHIFT [, SIZE])
! Returns a value corresponding to I with the rightmost SIZE bits shifted circularly SHIFT places;
! that is, bits shifted out one end are shifted into the opposite end. A value of SHIFT greater than
! zero corresponds to a left shift, a value of zero corresponds to no shift, and a value less than
! zero corresponds to a right shift. The absolute value of SHIFT must be less than SIZE. If the SIZE
! argument is omitted, it is taken to be equivalent to BIT_SIZE(I).
! Arguments:
! I -The type shall be INTEGER.
! SHIFT -The type shall be INTEGER.
! SIZE -(Optional) The type shall be INTEGER; the value must be greater than zero and less than or equal to BIT_SIZE(I).
! Return value:
! The return value is of type INTEGER and of the same kind as I.
! Standard: Fortran 95 and later
integer :: I, SHIFT, ISHFTC
integer, optional :: SIZE
end function
function KIND(X)
! Returns the kind value of the entity X.
! Arguments:
! X -Shall be of type LOGICAL, INTEGER, REAL, COMPLEX or CHARACTER.
! Return value:
! The return value is a scalar of type INTEGER and of the default integer kind.
! Standard: Fortran 95 and later
LOGICAL, INTEGER, REAL, COMPLEX, CHARACTER :: X
INTEGER :: KIND
end function
function LBOUND(ARRAY [, DIM [, KIND]])
! Returns the lower bounds of an array, or a single lower bound along the DIM dimension.
! Arguments:
! ARRAY -Shall be an array, of any type.
! DIM -(Optional) Shall be a scalar INTEGER.
! KIND -(Optional) An INTEGER initialization expression indicating the kind parameter of the result.
! Return value:
! The return value is of type INTEGER and of kind KIND. If KIND is absent, the return value is of default
! integer kind. If DIM is absent, the result is an array of the lower bounds of ARRAY. If DIM is present,
! the result is a scalar corresponding to the lower bound of the array along that dimension. If ARRAY is
! an expression rather than a whole array or array structure component, or if it has a zero extent along
! the relevant dimension, the lower bound is taken to be 1.
! Standard: Fortran 95 and later, with KIND argument Fortran 2003 and later
type(any_type) :: ARRAY(:[,...])
integer, optional :: DIM, KIND
integer(KIND) :: LBOUND
end function
function LEADZ(I)
! Returns the number of leading zero bits of an integer.
! Arguments:
! I -Shall be of type INTEGER.
! Return value:
! The type of the return value is the default INTEGER. If all the bits of I are zero, the result value is BIT_SIZE(I).
! Standard: Fortran 2008 and later
integer :: I, LEADZ
end function
function LEN(STRING [, KIND])
! Returns the length of a character string. If STRING is an array, the length of an element of STRING
! is returned. Note that STRING need not be defined when this intrinsic is invoked, since only the length,
! not the content, of STRING is needed.
! Arguments:
! STRING -Shall be a scalar or array of type CHARACTER, with INTENT(IN)
! KIND -(Optional) An INTEGER initialization expression indicating the kind parameter of the result.
! Return value:
! The return value is of type INTEGER and of kind KIND. If KIND is absent,
! the return value is of default integer kind.
! Standard: Fortran 77 and later, with KIND argument Fortran 2003 and later
character(len=*), intent(in) :: STRING
integer, optional :: KIND
integer(KIND) :: LEN
end function
function LEN_TRIM(STRING [, KIND])
! Returns the length of a character string, ignoring any trailing blanks.
! Arguments:
! STRING -Shall be a scalar of type CHARACTER, with INTENT(IN)
! KIND -(Optional) An INTEGER initialization expression indicating the kind parameter of the result.
! Return value:
! The return value is of type INTEGER and of kind KIND. If KIND is absent,
! the return value is of default integer kind.
! Standard: Fortran 95 and later, with KIND argument Fortran 2003 and later
character(len=*), intent(in) :: STRING
integer, optional :: KIND
integer(KIND) :: LEN_TRIM
end function
function LGE(STRING_A, STRING_B)
! Determines whether one string is lexically greater than or equal to another string,
! where the two strings are interpreted as containing ASCII character codes.
! If the String A and String B are not the same length, the shorter is compared as if spaces
! were appended to it to form a value that has the same length as the longer.
!
! In general, the lexical comparison intrinsics LGE, LGT, LLE, and LLT differ from
! the corresponding intrinsic operators .GE., .GT., .LE., and .LT., in that the latter use the
! processor's character ordering (which is not ASCII on some targets), whereas the former
! always use the ASCII ordering.
! Arguments:
! STRING_A -Shall be of default CHARACTER type.
! STRING_B -Shall be of default CHARACTER type.
! Return value:
! Returns .TRUE. if STRING_A >= STRING_B, and .FALSE. otherwise, based on the ASCII ordering.
! Standard: Fortran 77 and later
character(len=*) :: STRING_A, STRING_B
logical :: LGE
end function
function LGT(STRING_A, STRING_B)
! Determines whether one string is lexically greater than another string, where the two strings
! are interpreted as containing ASCII character codes. If the String A and String B are not the
! same length, the shorter is compared as if spaces were appended to it to form a value that has
! the same length as the longer.
! In general, the lexical comparison intrinsics LGE, LGT, LLE, and LLT differ from the corresponding
! intrinsic operators .GE., .GT., .LE., and .LT., in that the latter use the processor's character
! ordering (which is not ASCII on some targets), whereas the former always use the ASCII ordering.
! Arguments:
! STRING_A -Shall be of default CHARACTER type.
! STRING_B -Shall be of default CHARACTER type.
! Return value:
! Returns .TRUE. if STRING_A > STRING_B, and .FALSE. otherwise, based on the ASCII ordering.
! Standard: Fortran 77 and later
character(len=*) :: STRING_A, STRING_B
logical :: LGT
end function
function LLE(STRING_A, STRING_B)
! Determines whether one string is lexically less than or equal to another string, where the
! two strings are interpreted as containing ASCII character codes. If the String A and String B
! are not the same length, the shorter is compared as if spaces were appended to it to form
! a value that has the same length as the longer.
! In general, the lexical comparison intrinsics LGE, LGT, LLE, and LLT differ from the
! corresponding intrinsic operators .GE., .GT., .LE., and .LT., in that the latter use the
! processor's character ordering (which is not ASCII on some targets), whereas the former
! always use the ASCII ordering.
! Arguments:
! STRING_A -Shall be of default CHARACTER type.
! STRING_B -Shall be of default CHARACTER type.
! Return value:
! Returns .TRUE. if STRING_A <= STRING_B, and .FALSE. otherwise, based on the ASCII ordering.
! Standard: Fortran 77 and later
character(len=*) :: STRING_A, STRING_B
logical :: LLE
end function
function LLT(STRING_A, STRING_B)
! Determines whether one string is lexically less than another string, where the two strings
! are interpreted as containing ASCII character codes. If the String A and String B are not
! the same length, the shorter is compared as if spaces were appended to it to form a value
! that has the same length as the longer.
! In general, the lexical comparison intrinsics LGE, LGT, LLE, and LLT differ from the
! corresponding intrinsic operators .GE., .GT., .LE., and .LT., in that the latter use
! the processor's character ordering (which is not ASCII on some targets), whereas the
! former always use the ASCII ordering.
! Arguments:
! STRING_A Shall be of default CHARACTER type.
! STRING_B Shall be of default CHARACTER type.
! Return value:
! Returns .TRUE. if STRING_A < STRING_B, and .FALSE. otherwise, based on the ASCII ordering.
! Standard: Fortran 77 and later
character(len=*) :: STRING_A, STRING_B
logical :: LLT
end function
function LOG(X)
! Computes the natural logarithm of X.
! Arguments:
! X -The type shall be REAL or COMPLEX.
! Return value:
! The return value is of type REAL or COMPLEX. The kind type parameter is the same as X.
! If X is COMPLEX, the imaginary part \omega is in the range -pi <= \omega <= pi.
! Standard: Fortran 77 and later
real, complex :: X, LOG
end function
function ALOG(X)
! This is specific name of LOG function.
! Computes the logarithm of X.
! Arguments:
! X -The type shall be REAL.
! Standard: Fortran 77 and later
real :: ALOG, X
end function
function CLOG(X)
! This is specific name of LOG function.
! Computes the logarithm of X.
! Arguments:
! X -The type shall be COMLEX.
! Standard:
! Fortran 77 and later
complex :: CLOG, X
end function
function DLOG(X)
! This is specific name of LOG function.
! Computes the logarithm of X.
! Arguments:
! X -The type shall be DOUBLE PRECISION.
! Standard:
! Fortran 77 and later
real :: DLOG, X
end function
function LOG10(X)
! Computes the base 10 logarithm of X.
! Arguments:
! X -The type shall be REAL.
! Return value:
! The return value is of type REAL or COMPLEX. The kind type parameter is the same as X.
! Standard:
! Fortran 77 and later
real :: X, LOG10
end function
function ALOG10(X)
! This is specific name of LOG10 function.
! Computes the base 10 logarithm of X.
! Arguments:
! X -The type shall be REAL.
! Return value:
! The return value is of type REAL.
! Standard:
! Fortran 77 and later
real :: ALOG10, X
end function
function DLOG10(X)
! This is specific name of LOG10 function.
! Computes the base 10 logarithm of X.
! Arguments:
! X -The type shall be DOUBLE PRECISION.
! Return value:
! The return value is of type DOUBLE PRECISION.
! Standard:
! Fortran 77 and later
double precision :: DLOG10, X
end function
function LOG_GAMMA(X)
! Computes the natural logarithm of the absolute value of the Gamma function.
! Arguments:
! X -Shall be of type REAL and neither zero nor a negative integer.
! Return value:
! The return value is of type REAL of the same kind as X.
! Standard:
! Fortran 2008 and later
real :: X, LOG_GAMMA
end function
function LOGICAL(L [, KIND])
! Converts one kind of LOGICAL variable to another.
! Arguments:
! L -The type shall be LOGICAL.
! KIND -(Optional) An INTEGER initialization expression indicating the kind parameter of the result.
! Return value:
! The return value is a LOGICAL value equal to L, with a kind corresponding to KIND, or of the
! default logical kind if KIND is not given.
! Standard:
! Fortran 95 and later
logical :: L
integer, optional :: KIND
logical(KIND) :: LOGICAL
end function
function MATMUL(MATRIX_A, MATRIX_B)
! Performs a matrix multiplication on numeric or logical arguments.
! Arguments:
! MATRIX_A -An array of INTEGER, REAL, COMPLEX, or LOGICAL type, with a rank of one or two.
! MATRIX_B -An array of INTEGER, REAL, or COMPLEX type if MATRIX_A is of a numeric type; otherwise,
! an array of LOGICAL type. The rank shall be one or two, and the first (or only) dimension
! of MATRIX_B shall be equal to the last (or only) dimension of MATRIX_A.
! Return value:
! The matrix product of MATRIX_A and MATRIX_B. The type and kind of the result follow the usual type
! and kind promotion rules, as for the * or .AND. operators.
! The rank and shape of the result depends on the rank and shapes of the arguments, as follows:
! If MATRIX_A has shape (n, m) and MATRIX_B has shape (m, k), the result is a rank-two array with shape (n, k).
! If MATRIX_A has shape (m) and MATRIX_B has shape (m, k), the result is a rank-one array with shape (k).
! If MATRIX_A has shape (n, m) and MATRIX_B has shape (m), the result is a rank-one array with shape (n).
!
! If the arguments are of numeric type, element (i, j) of the result has the value
! SUM ((row i of MATRIX_A) * (column j of MATRIX_B)). If the arguments are of logical type, element (i, j)
! of the result has the value ANY ((row i of MATRIX_A) .AND. (column j of MATRIX_B)).
!
! Standard:
! Fortran 95 and later
integer, real, complex or logical :: MATRIX_A(:[,:]), MATRIX_B(:[,:])
end function
function MAX(A1, A2[, A3, A4, A5, ...])
! Returns the argument with the largest (most positive) value.
! Syntax:
! RESULT = MAX(A1, A2 [, A3 [, ...]])
! Arguments:
! A1 -The type shall be INTEGER or REAL.
! A2, A3, ... -An expression of the same type and kind as A1.
! Return value:
! The return value corresponds to the maximum value among the arguments, and has the same
! type and kind as the argument.
! Standard:
! Fortran 77 and later
integer or real :: A1, A2, A3, A4, A5, MAX
end function
function MAX0(A1, A2)
! This is specific name of MAX function.
! Returns the argument with the largest (most positive) value.
! Syntax:
! RESULT = MAX(A1, A2 [, A3 [, ...]])
! Arguments:
! A1 -The type shall be INTEGER.
! A2, A3, ... -An expression of the same type and kind as A1.
! Return value:
! The return value corresponds to the maximum value among the arguments, and has the same
! type and kind as the argument.
! Standard:
! Fortran 77 and later
integer :: MAX0, A1, A2
end function
function AMAX1(A1, A2)
! This is specific name of MAX function.
! Returns the argument with the largest (most positive) value.
! Syntax:
! RESULT = MAX(A1, A2 [, A3 [, ...]])
! Arguments:
! A1 -The type shall be REAL.
! A2, A3, ... -An expression of the same type and kind as A1.
! Return value:
! The return value corresponds to the maximum value among the arguments, and has the same
! type and kind as the argument.
! Standard:
! Fortran 77 and later
real :: AMAX1, A1, A2
end function
function DMAX1(A1, A2)
! This is specific name of MAX function.
! Returns the argument with the largest (most positive) value.
! Syntax:
! RESULT = MAX(A1, A2 [, A3 [, ...]])
! Arguments:
! A1 -The type shall be DOUBLE PRECISION.
! A2, A3, ... -An expression of the same type and kind as A1.
! Return value:
! The return value corresponds to the maximum value among the arguments, and has the same
! type and kind as the argument.
! Standard:
! Fortran 77 and later
double precision :: DMAX1, A1, A2
end function
function MAX1(A1, A2)
! This is specific name of MAX function.
! MAX1 is equivalent to INT ( MAX ( . . .) )
! Returns the argument with the largest (most positive) value.
! Syntax:
! RESULT = MAX(A1, A2 [, A3 [, ...]])
! Arguments:
! A1 -The type shall be REAL.
! A2, A3, ... -An expression of the same type and kind as A1.
! Return value:
! The return value corresponds to the maximum value among the arguments, and has the same
! type and kind as the argument.
! Standard:
! Fortran 77 and later
integer :: MAX1
real :: A1, A2
end function
function AMAX0(A1, A2)
! This is specific name of MAX function.
! AMAX0 is equivalent to REAL ( MAX ( . . . ) )
! Returns the argument with the largest (most positive) value.
! Syntax:
! RESULT = MAX(A1, A2 [, A3 [, ...]])
! Arguments:
! A1 -The type shall be INTEGER.
! A2, A3, ... -An expression of the same type and kind as A1.
! Return value:
! The return value corresponds to the maximum value among the arguments, and has the same
! type and kind as the argument.
! Standard:
! Fortran 77 and later
real :: AMAX0
integer :: A1, A2
end function
function MAXEXPONENT(X)
! Returns the maximum exponent in the model of the type of X.
! Arguments:
! X -Shall be of type REAL.
! Return value:
! The return value is of type INTEGER and of the default integer kind.
! Standard:
! Fortran 95 and later
real :: X
integer :: MAXEXPONENT
end function
function MAXLOC(ARRAY [, DIM] [, MASK] [, KIND] [, BACK])
! Determines the location of the element in the array with the maximum value, or, if the DIM
! argument is supplied, determines the locations of the maximum element along each row of the
! array in the DIM direction. If MASK is present, only the elements for which MASK is .TRUE.
! are considered. If more than one element in the array has the maximum value, the location
! returned is that of the first such element in array element order. If the array has zero size,
! or all of the elements of MASK are .FALSE., then the result is an array of zeroes. Similarly,
! if DIM is supplied and all of the elements of MASK along a given row are zero, the result value
! for that row is zero.
! Syntax:
! RESULT = MAXLOC(ARRAY, DIM [, MASK])
! RESULT = MAXLOC(ARRAY [, MASK])
! Arguments:
! ARRAY -Shall be an array of type INTEGER or REAL.
! DIM -(Optional) Shall be a scalar of type INTEGER, with a value between one and the rank
! of ARRAY, inclusive. It may not be an optional dummy argument.
! MASK -Shall be an array of type LOGICAL, and conformable with ARRAY.
! BACK -LOGICAL
! Return value:
! If DIM is absent, the result is a rank-one array with a length equal to the rank of ARRAY.
! If DIM is present, the result is an array with a rank one less than the rank of ARRAY, and
! a size corresponding to the size of ARRAY with the DIM dimension removed. If DIM is present
! and ARRAY has a rank of one, the result is a scalar. In all cases, the result is of default INTEGER type.
! Standard:
! Fortran 95 and later
integer or real :: ARRAY(:[,:,...])
integer, optional :: DIM
logical, optional :: MASK(:[,:,...])
integer, optional :: KIND
logical, optional :: BACK
integer :: MAXLOC(:[,:,...])
end function
function MAXVAL(ARRAY [, DIM] [, MASK])
! Determines the maximum value of the elements in an array value, or, if the DIM argument is supplied,
! determines the maximum value along each row of the array in the DIM direction. If MASK is present,
! only the elements for which MASK is .TRUE. are considered. If the array has zero size, or all of the
! elements of MASK are .FALSE., then the result is -HUGE(ARRAY) if ARRAY is numeric, or a string of nulls
! if ARRAY is of character type.
! Syntax:
! RESULT = MAXVAL(ARRAY, DIM [, MASK])
! RESULT = MAXVAL(ARRAY [, MASK])
! Arguments:
! ARRAY -Shall be an array of type INTEGER or REAL.
! DIM -(Optional) Shall be a scalar of type INTEGER, with a value between one and the rank of
! ARRAY, inclusive. It may not be an optional dummy argument.
! MASK -Shall be an array of type LOGICAL, and conformable with ARRAY.
! Return value:
! If DIM is absent, or if ARRAY has a rank of one, the result is a scalar. If DIM is present,
! the result is an array with a rank one less than the rank of ARRAY, and a size corresponding
! to the size of ARRAY with the DIM dimension removed. In all cases, the result is of the same
! type and kind as ARRAY.
! Standard: Fortran 95 and later
integer or real :: ARRAY(:[,:,...])
integer, optional :: DIM
logical, optional :: MASK(:[,:,...])
integer :: MAXVAL[(:,...)]
end function
function MERGE(TSOURCE, FSOURCE, MASK)
! Select values from two arrays according to a logical mask. The result is equal to TSOURCE if MASK
! is .TRUE., or equal to FSOURCE if it is .FALSE..
! Arguments:
! TSOURCE -May be of any type.
! FSOURCE -Shall be of the same type and type parameters as TSOURCE.
! MASK -Shall be of type LOGICAL.
! Return value:
! The result is of the same type and type parameters as TSOURCE.
! Standard:
! Fortran 95 and later
type(any_type) :: TSOURCE(:[,:,...]), FSOURCE(:[,:,...])
logical :: MASK(:[,:,...])
end function
function MIN(A1, A2[, A3, A4, A5, ...])
! Returns the argument with the smallest (most negative) value.
! Syntax:
! RESULT = MIN(A1, A2 [, A3, ...])
! Arguments:
! A1 -The type shall be INTEGER or REAL.
! A2, A3, ... -An expression of the same type and kind as A1.
! Return value:
! The return value corresponds to the maximum value among the arguments, and has the same type
! and kind as the first argument.
! Standard:
! Fortran 77 and later
integer or real :: A1, A2, A3, A4, A5, MIN
end function
function MIN0(A1, A2)
! This is specific name of MIN function.
! Returns the argument with the smallest (most negative) value.
! Syntax:
! RESULT = MIN(A1, A2 [, A3, ...])
! Arguments:
! A1 -The type shall be INTEGER.
! A2, A3, ... -An expression of the same type and kind as A1.
! Return value:
! The return value corresponds to the maximum value among the arguments, and has the same type
! and kind as the first argument.
! Standard:
! Fortran 77 and later
integer :: MIN0, A1, A2
end function
function AMIN0(A1, A2)
! This is specific name of MIN function.
! AMIN0 is equivalent to REAL ( MIN ( . . . ) )
! Returns the argument with the smallest (most negative) value.
! Syntax:
! RESULT = MIN(A1, A2 [, A3, ...])
! Arguments:
! A1 -The type shall be INTEGER.
! A2, A3, ... -An expression of the same type and kind as A1.
! Return value:
! The return value corresponds to the maximum value among the arguments, and has the same type
! and kind as the first argument.
! Standard:
! Fortran 77 and later
real :: AMIN0
integer :: A1, A2
end function
function AMIN1(A1, A2)
! This is specific name of MIN function.
! Returns the argument with the smallest (most negative) value.
! Syntax:
! RESULT = MIN(A1, A2 [, A3, ...])
! Arguments:
! A1 -The type shall be REAL.
! A2, A3, ... -An expression of the same type and kind as A1.
! Return value:
! The return value corresponds to the maximum value among the arguments, and has the same type
! and kind as the first argument.
! Standard:
! Fortran 77 and later
real :: AMIN1, A1, A2
end function
function MIN1(A1, A2)
! This is specific name of MIN function.
! MIN1 is equivalent to INT ( MIN ( . . . ) )
! Returns the argument with the smallest (most negative) value.
! Syntax:
! RESULT = MIN(A1, A2 [, A3, ...])
! Arguments:
! A1 -The type shall be REAL.
! A2, A3, ... -An expression of the same type and kind as A1.
! Return value:
! The return value corresponds to the maximum value among the arguments, and has the same type
! and kind as the first argument.
! Standard:
! Fortran 77 and later
integer :: MIN1
real :: A1, A2
end function
function DMIN1(A1, A2)
! This is specific name of MIN function.
! Returns the argument with the smallest (most negative) value.
! Syntax:
! RESULT = MIN(A1, A2 [, A3, ...])
! Arguments:
! A1 -The type shall be DOUBLE PRECISION.
! A2, A3, ... -An expression of the same type and kind as A1.
! Return value:
! The return value corresponds to the maximum value among the arguments, and has the same type
! and kind as the first argument.
! Standard:
! Fortran 77 and later
double precision :: DMIN1, A1, A2
end function
function MINEXPONENT(X)
! Returns the minimum exponent in the model of the type of X.
! Arguments:
! X -Shall be of type REAL.
! Return value:
! The return value is of type INTEGER and of the default integer kind.
! Standard:
! Fortran 95 and later
real :: X
integer :: MINEXPONENT
end function
function MINLOC(ARRAY [, DIM] [, MASK] [, KIND] [, BACK])
! Determines the location of the element in the array with the minimum value, or, if the DIM
! argument is supplied, determines the locations of the minimum element along each row of the
! array in the DIM direction. If MASK is present, only the elements for which MASK is .TRUE. are
! considered. If more than one element in the array has the minimum value, the location returned is
! that of the first such element in array element order. If the array has zero size, or all of the
! elements of MASK are .FALSE., then the result is an array of zeroes. Similarly, if DIM is supplied
! and all of the elements of MASK along a given row are zero, the result value for that row is zero.
! Syntax:
! RESULT = MINLOC(ARRAY, DIM [, MASK])
! RESULT = MINLOC(ARRAY [, MASK])
! Arguments:
! ARRAY -Shall be an array of type INTEGER or REAL.
! DIM -(Optional) Shall be a scalar of type INTEGER, with a value between one and the rank
! of ARRAY, inclusive. It may not be an optional dummy argument.
! MASK -Shall be an array of type LOGICAL, and conformable with ARRAY.
! BACK -LOGICAL
! Return value:
! If DIM is absent, the result is a rank-one array with a length equal to the rank of ARRAY.
! If DIM is present, the result is an array with a rank one less than the rank of ARRAY, and
! a size corresponding to the size of ARRAY with the DIM dimension removed. If DIM is present
! and ARRAY has a rank of one, the result is a scalar. In all cases, the result is of default INTEGER type.
! Standard:
! Fortran 95 and later
integer or real :: ARRAY(:[,:,...])
integer, optional :: DIM
logical, optional :: MASK(:[,:,...])
integer, optional :: KIND
logical, optional :: BACK
integer :: MINLOC(:[,:,...])
end function
function MINVAL(ARRAY, DIM [, MASK])
! Determines the minimum value of the elements in an array value, or, if the DIM argument is
! supplied, determines the minimum value along each row of the array in the DIM direction.
! If MASK is present, only the elements for which MASK is .TRUE. are considered. If the array
! has zero size, or all of the elements of MASK are .FALSE., then the result is HUGE(ARRAY) if
! ARRAY is numeric, or a string of CHAR(255) characters if ARRAY is of character type.
! Syntax:
! RESULT = MINVAL(ARRAY, DIM [, MASK])
! RESULT = MINVAL(ARRAY [, MASK])
! Arguments:
! ARRAY -Shall be an array of type INTEGER or REAL.
! DIM -(Optional) Shall be a scalar of type INTEGER, with a value between one and the rank of
! ARRAY, inclusive. It may not be an optional dummy argument.
! MASK -Shall be an array of type LOGICAL, and conformable with ARRAY.
!
! Return value:
! If DIM is absent, or if ARRAY has a rank of one, the result is a scalar. If DIM is present,
! the result is an array with a rank one less than the rank of ARRAY, and a size corresponding
! to the size of ARRAY with the DIM dimension removed. In all cases, the result is of the same
! type and kind as ARRAY.
! Standard:
! Fortran 95 and later
integer or real :: ARRAY(:[,:,...])
integer, optional :: DIM
logical, optional :: MASK(:[,:,...])
integer :: MINVAL(:[,:,...])
end function
function MOD(A, P)
! Computes the remainder of the division of A by P. It is calculated as A - (INT(A/P) * P).
! Arguments:
! A -Shall be a scalar of type INTEGER or REAL
! P -Shall be a scalar of the same type as A and not equal to zero
! Return value:
! The kind of the return value is the result of cross-promoting the kinds of the arguments.
! Standard:
! Fortran 77 and later
integer or real :: A, P, MOD
end function
function AMOD(A, P)
! This is specific name of MOD function.
! Computes the remainder of the division of A by P. It is calculated as A - (INT(A/P) * P).
! Arguments:
! A -Shall be a scalar of type default REAL
! P -Shall be a scalar of the same type as A and not equal to zero
! Return value:
! The kind of the return value is the result of cross-promoting the kinds of the arguments.
! Standard:
! Fortran 77 and later
real :: AMOD, A, P
end function
function DMOD(A, P)
! This is specific name of MOD function.
! Computes the remainder of the division of A by P. It is calculated as A - (INT(A/P) * P).
! Standard:
! Fortran 77 and later
! Arguments:
! A -Shall be a scalar of type default DOUBLE PRECISION
! P -Shall be a scalar of the same type as A and not equal to zero
! Return value:
! The kind of the return value is the result of cross-promoting the kinds of the arguments.
double precision :: DMOD, A, P
end function
function MODULO(A, P)
! Computes the A modulo P.
! Arguments:
! A -Shall be a scalar of type INTEGER or REAL
! P -Shall be a scalar of the same type and kind as A
! Return value:
! The type and kind of the result are those of the arguments.
! If A and P are of type INTEGER:
! MODULO(A,P) has the value R such that A=Q*P+R, where Q is an integer and R is between
! 0 (inclusive) and P (exclusive).
! If A and P are of type REAL:
! MODULO(A,P) has the value of A - FLOOR (A / P) * P.
! In all cases, if P is zero the result is processor-dependent.
! Standard:
! Fortran 95 and later
integer or real :: A, P, MODULO
end function
subroutine MOVE_ALLOC(FROM, TO[, STAT, ERRMSG])
! Moves the allocation from FROM to TO. FROM will become deallocated in the process.
! Arguments:
! FROM -ALLOCATABLE, INTENT(INOUT), may be of any type and kind.
! TO -ALLOCATABLE, INTENT(OUT), shall be of the same type, kind and rank as FROM.
! Standard:
! Fortran 2003 and later
type(any_type), allocatable :: FROM(:[,:,...]), TO(:[,:,...])
integer, optional, intent(out) :: STAT
character(len=*), optional, intent(inout) :: ERRMSG
end subroutine
subroutine MVBITS(FROM, FROMPOS, LEN, TO, TOPOS)
! Moves LEN bits from positions FROMPOS through FROMPOS+LEN-1 of FROM to positions TOPOS
! through TOPOS+LEN-1 of TO. The portion of argument TO not affected by the movement of bits
! is unchanged. The values of FROMPOS+LEN-1 and TOPOS+LEN-1 must be less than BIT_SIZE(FROM).
! Arguments:
! FROM -The type shall be INTEGER.
! FROMPOS -The type shall be INTEGER.
! LEN -The type shall be INTEGER.
! TO -The type shall be INTEGER, of the same kind as FROM.
! TOPOS -The type shall be INTEGER.
! Standard:
! Fortran 95 and later
integer :: FROM, FROMPOS, LEN, TO, TOPOS
end subroutine
function NEAREST(X, S)
! Returns the processor-representable number nearest to X in the direction indicated by the sign of S.
! Standard:
! Fortran 95 and later
! Arguments:
! X -Shall be of type REAL.
! S -(Optional) shall be of type REAL and not equal to zero.
! Return value:
! The return value is of the same type as X. If S is positive, NEAREST returns the
! processor-representable number greater than X and nearest to it. If S is negative, NEAREST
! returns the processor-representable number smaller than X and nearest to it.
real :: X, NEAREST
real, optional :: S
end function
function NEW_LINE(C)
! Returns the new-line character.
! Arguments:
! C -The argument shall be a scalar or array of the type CHARACTER.
! Return value:
! Returns a CHARACTER scalar of length one with the new-line character of the same kind as parameter C.
! Standard:
! Fortran 2003 and later
character(len=*) :: C
character(len=1) :: NEW_LINE
end function
function NINT(A [, KIND])
! Rounds its argument to the nearest whole number.
! Arguments:
! A -The type of the argument shall be REAL.
! KIND -(Optional) An INTEGER initialization expression indicating the kind parameter of the result.
! Return value:
! Returns A with the fractional portion of its magnitude eliminated by rounding to the nearest whole
! number and with its sign preserved, converted to an INTEGER of the default kind.
! Standard:
! Fortran 77 and later, with KIND argument Fortran 90 and later
real :: A
integer, optional :: KIND
integer :: NINT
end function
function IDNINT(A)
! This is specific name of NINT function.
! Rounds its argument to the nearest whole number.
! Arguments:
! A -The type of the argument shall be DOUBLE PRECISION.
! KIND -(Optional) An INTEGER initialization expression indicating the kind parameter of the result.
! Return value:
! Returns A with the fractional portion of its magnitude eliminated by rounding to the nearest whole
! number and with its sign preserved, converted to an INTEGER of the default kind.
! Standard:
! Fortran 77 and later, with KIND argument Fortran 90 and later
integer :: IDNINT
double precision :: A
integer, optional :: KIND
end function
function NOT(I)
! Returns the bitwise boolean inverse of I.
! Arguments:
! I -The type shall be INTEGER.
! Return value:
! The return type is INTEGER, of the same kind as the argument.
! Standard:
! Fortran 95 and later
integer :: I, NOT
end function
function NULL([MOLD])
! Returns a disassociated pointer.
! If MOLD is present, a dissassociated pointer of the same type is returned,
! otherwise the type is determined by context.
! In Fortran 95, MOLD is optional. Please note that Fortran 2003 includes cases
! where it is required.
! Syntax:
! PTR => NULL([MOLD])
! Arguments:
! MOLD -(Optional) shall be a pointer of any association status and of any type.
! Return value:
! A disassociated pointer.
! Standard:
! Fortran 95 and later
type(any_type), pointer, optional :: MOLD
end function
function PACK(ARRAY, MASK [, VECTOR])
! Stores the elements of ARRAY in an array of rank one.
! The beginning of the resulting array is made up of elements whose MASK equals TRUE.
! Afterwards, positions are filled with elements taken from VECTOR.
! Arguments:
! ARRAY -Shall be an array of any type.
! MASK -Shall be an array of type LOGICAL and of the same size as ARRAY. Alternatively,
! it may be a LOGICAL scalar.
! VECTOR -(Optional) shall be an array of the same type as ARRAY and of rank one. If present,
! the number of elements in VECTOR shall be equal to or greater than the number of
! true elements in MASK. If MASK is scalar, the number of elements in VECTOR shall be
! equal to or greater than the number of elements in ARRAY.
! Return value:
! The result is an array of rank one and the same type as that of ARRAY. If VECTOR is present,
! the result size is that of VECTOR, the number of TRUE values in MASK otherwise.
! Standard:
! Fortran 95 and later
type(any_type) :: ARRAY(:[,:,...])
logical :: MASK[(:,...)]
type(same as ARRAY), optional :: VECTOR(:)
type(same as ARRAY) :: PACK(:)
end function
function PRECISION(X)
! Returns the decimal precision in the model of the type of X.
! Arguments:
! X -Shall be of type REAL or COMPLEX.
! Return value:
! The return value is of type INTEGER and of the default integer kind.
! Standard:
! Fortran 95 and later
real or complex :: X
integer :: PRECISION
end function
function PRESENT(A)
! Determines whether an optional dummy argument is present.
! Arguments:
! A -May be of any type and may be a pointer, scalar or array value, or a dummy procedure.
! It shall be the name of an optional dummy argument accessible within the current subroutine or function.
! Return value:
! Returns either TRUE if the optional argument A is present, or FALSE otherwise.
! Standard:
! Fortran 95 and later
type(any_type) :: A
logical :: PRESENT
end function
function PRODUCT(ARRAY [, DIM] [, MASK])
! Multiplies the elements of ARRAY along dimension DIM if the corresponding element in MASK is TRUE.
! Syntax:
! RESULT = PRODUCT(ARRAY[, MASK])
! RESULT = PRODUCT(ARRAY, DIM[, MASK])
! Arguments:
! ARRAY -Shall be an array of type INTEGER, REAL or COMPLEX.
! DIM -(Optional) shall be a scalar of type INTEGER with a value in the range from 1 to n,
! where n equals the rank of ARRAY.
! MASK -(Optional) shall be of type LOGICAL and either be a scalar or an array of the same shape as ARRAY.
! Return value:
! The result is of the same type as ARRAY.
! If DIM is absent, a scalar with the product of all elements in ARRAY is returned. Otherwise,
! an array of rank n-1, where n equals the rank of ARRAY, and a shape similar to that of ARRAY
! with dimension DIM dropped is returned.
! Standard:
! Fortran 95 and later
integer, real or complex :: ARRAY(:[,:,...])
integer :: DIM
end function
function RADIX(X)
! Returns the base of the model representing the entity X.
! Arguments:
! X -Shall be of type INTEGER or REAL
! Return value:
! The return value is a scalar of type INTEGER and of the default integer kind.
! Standard:
! Fortran 95 and later
integer or real :: X
integer :: RADIX
end function
subroutine RANDOM_NUMBER(HARVEST)
! Returns a single pseudorandom number or an array of pseudorandom numbers from the uniform distribution
! over the range 0 <= x < 1.
! Arguments:
! HARVEST -Shall be a scalar or an array of type REAL.
! Standard:
! Fortran 95 and later
real :: HARVEST[(:,...)]
end subroutine
subroutine RANDOM_SEED([SIZE, PUT, GET])
! Restarts or queries the state of the pseudorandom number generator used by RANDOM_NUMBER.
! If RANDOM_SEED is called without arguments, it is initialized to a default state.
! Arguments:
! SIZE -(Optional) Shall be a scalar and of type default INTEGER, with INTENT(OUT).
! It specifies the minimum size of the arrays used with the PUT and GET arguments.
! PUT -(Optional) Shall be an array of type default INTEGER and rank one. It is
! INTENT(IN) and the size of the array must be larger than or equal to the number
! returned by the SIZE argument.
! GET -(Optional) Shall be an array of type default INTEGER and rank one. It is INTENT(OUT)
! and the size of the array must be larger than or equal to the number returned by the SIZE argument.
! Standard:
! Fortran 95 and later
integer, optional, intent(out) :: SIZE
integer, optional, intent(in) :: PUT(:)
integer, optional, intent(out) :: GET(:)
end subroutine
subroutine RANDOM_INIT(REPEATABLE, IMAGE_DISTINCT)
! Initialize the pseudorandom number generator.
! If REPEATABLE is .true., the seed accessed by the pseudorandom number generator is set
! to a processor-dependent value that is the same each time RANDOM_INIT is called
! from the same image. If it has the value .false., the seed is set to a processor-
! dependent, unpredictably different value on each call.
! If IMAGE_DISTINCT has the value .true., the seed accessed by the pseudorandom
! number generator is set to a processor-dependent value that is distinct from the
! value that would be set by a call to RANDOM_INIT by another image. If it has the
! value .false., the value to which the seed is set does not depend on which image calls.
logical, intent(in) :: REPEATABLE
logical, intent(in) :: IMAGE_DISTINCT
end subroutine
function RANGE(X)
! Returns the decimal exponent range in the model of the type of X.
! Arguments:
! X -Shall be of type INTEGER, REAL or COMPLEX.
! Return value:
! The return value is of type INTEGER and of the default integer kind.
! Standard:
! Fortran 95 and later
INTEGER, REAL or COMPLEX :: X
INTEGER :: RANGE
end function
function REAL(A [, KIND])
! Converts its argument A to a real type.
! Arguments:
! A -Shall be INTEGER, REAL, or COMPLEX.
! KIND -(Optional) An INTEGER initialization expression indicating the kind parameter of the result.
! Return value:
! These functions return a REAL variable or array under the following rules:
! (A)
! REAL(A) is converted to a default real type if A is an integer or real variable.
! (B)
! REAL(A) is converted to a real type with the kind type parameter of A if A is a complex variable.
! (C)
! REAL(A, KIND) is converted to a real type with kind type parameter KIND if A is a complex,
! integer, or real variable.
! Standard:
! Fortran 77 and later
integer, real or complex :: A
integer, optional :: KIND
real[(KIND)] :: REAL
end function
function FLOAT(A)
! This is specific name of REAL function.
! Converts its argument A to a real type.
! Arguments:
! A -Shall be default INTEGER.
! Standard:
! Fortran 77 and later
real :: FLOAT
integer :: A
end function
function SAME_TYPE_AS(A,B)
! Inquires whether the dynamic type of A is the same as the dynamic type of B.
! Function returns true if the dynamic type of A is the same as the dynamic type of B.
! Arguments:
! A -must be an object of extensible type. If it is a pointer, it must not have an undefined association status.
! B -must be an object of extensible type. If it is a pointer, it must not have an undefined association status.
! Return value:
! Default LOGICAL scalar
! Standard:
! Fortran 2003 and later
logical :: SAME_TYPE_AS
end function
function SNGL(A)
! This is specific name of REAL function.
! Converts its argument A to a real type.
! Arguments:
! A -Shall be default DOUBLE PRECISION.
! Standard:
! Fortran 77 and later
real :: SNGL
double precision :: A
end function
function REPEAT(STRING, NCOPIES)
! Concatenates NCOPIES copies of a string.
! Arguments:
! STRING -Shall be scalar and of type CHARACTER.
! NCOPIES -Shall be scalar and of type INTEGER.
! Return value:
! A new scalar of type CHARACTER built up from NCOPIES copies of STRING.
! Standard:
! Fortran 95 and later
character(len=*) :: REPEAT, STRING
integer :: NCOPIES
end function
function RESHAPE(SOURCE, SHAPE[, PAD, ORDER])
! Reshapes SOURCE to correspond to SHAPE. If necessary, the new array may be padded with
! elements from PAD or permuted as defined by ORDER.
! Arguments:
! SOURCE -Shall be an array of any type.
! SHAPE -Shall be of type INTEGER and an array of rank one. Its values must be positive or zero.
! PAD -(Optional) shall be an array of the same type as SOURCE.
! ORDER -(Optional) shall be of type INTEGER and an array of the same shape as SHAPE. Its values
! shall be a permutation of the numbers from 1 to n, where n is the size of SHAPE. If
! ORDER is absent, the natural ordering shall be assumed.
! Return value:
! The result is an array of shape SHAPE with the same type as SOURCE.
! Standard:
! Fortran 95 and later
type(any_type) :: SOURCE(:[,:,...])
integer :: SHAPE(:)
type(any_type), optional :: PAD(:[,:,...])
integer, optional :: ORDER(:)
end function
function RRSPACING(X)
! Returns the reciprocal of the relative spacing of model numbers near X.
! Arguments:
! X -Shall be of type REAL.
! Return value:
! The return value is of the same type and kind as X. The value returned is equal
! to ABS(FRACTION(X)) * FLOAT(RADIX(X))**DIGITS(X).
! Standard:
! Fortran 95 and later
real :: X, RRSPACING
end function
function SCALE(X, I)
! Returns X * RADIX(X)**I.
! Arguments:
! X -The type of the argument shall be a REAL.
! I -The type of the argument shall be a INTEGER.
! Return value:
! The return value is of the same type and kind as X. Its value is X * RADIX(X)**I.
! Standard:
! Fortran 95 and later
real :: X, SCALE
integer :: I
end function
function SCAN(STRING, SET[, BACK [, KIND]])
! Scans a STRING for any of the characters in a SET of characters.
! If BACK is either absent or equals FALSE, this function returns the position of the leftmost
! character of STRING that is in SET. If BACK equals TRUE, the rightmost position is returned.
! If no character of SET is found in STRING, the result is zero.
! Arguments:
! STRING -Shall be of type CHARACTER.
! SET -Shall be of type CHARACTER.
! BACK -(Optional) shall be of type LOGICAL.
! KIND -(Optional) An INTEGER initialization expression indicating the kind parameter of the result.
! Return value:
! The return value is of type INTEGER and of kind KIND. If KIND is absent, the return value
! is of default integer kind.
! Standard:
! Fortran 95 and later, with KIND argument Fortran 2003 and later
character(len=*) :: STRING, SET
logical, optional :: BACK
integer, optional :: KIND
end function
function SELECTED_CHAR_KIND(NAME)
! Returns the kind value for the character set named NAME, if a character set with such a name
! is supported, or -1 otherwise.
! Arguments:
! NAME Shall be a scalar and of the default character type.
! Standard:
! Fortran 2003 and later
character(len=*) :: NAME
integer :: SELECTED_CHAR_KIND
end function
function SELECTED_INT_KIND(R)
! Return the kind value of the smallest integer type that can represent all values ranging
! from -10^R (exclusive) to 10^R (exclusive). If there is no integer kind that accommodates
! this range, SELECTED_INT_KIND returns -1.
! Arguments:
! R -Shall be a scalar and of type INTEGER.
! Standard:
! Fortran 95 and later
integer :: R
integer :: SELECTED_INT_KIND
end function
function SELECTED_REAL_KIND([P, R, RADIX])
! Returns the kind value of a real data type with decimal precision of at least P digits and
! exponent range greater at least R.
! Arguments:
! P -(Optional) shall be a scalar and of type INTEGER.
! R -(Optional) shall be a scalar and of type INTEGER.
! RADIX -(Optional) shall be a scalar and of type INTEGER.
! Return value:
! SELECTED_REAL_KIND returns the value of the kind type parameter of a real data type with
! decimal precision of at least P digits and a decimal exponent range of at least R.
! If more than one real data type meet the criteria, the kind of the data type with the smallest
! decimal precision is returned. If no real data type matches the criteria, the result is
!
! -1 if the processor does not support a real data type with a
! precision greater than or equal to P
! -2 if the processor does not support a real type with an exponent
! range greater than or equal to R
! -3 if neither is supported.
! Standard:
! Fortran 95 and later
integer, optional :: P, R, RADIX
integer :: SELECTED_REAL_KIND
end function
function SET_EXPONENT(X, I)
! Returns the real number whose fractional part is that of X and whose exponent part is I.
! Arguments:
! X -Shall be of type REAL.
! I -Shall be of type INTEGER.
! Return value:
! The return value is of the same type and kind as X. The real number whose fractional part
! is that that of X and whose exponent part if I is returned; it is FRACTION(X) * RADIX(X)**I.
! Standard:
! Fortran 95 and later
real :: X
integer :: I
end function
function SHAPE(SOURCE [, KIND])
! Determines the shape of an array.
! Arguments:
! SOURCE -Shall be an array or scalar of any type. If SOURCE is a pointer it must be
! associated and allocatable arrays must be allocated.
! Return value:
! An INTEGER array of rank one with as many elements as SOURCE has dimensions. The elements
! of the resulting array correspond to the extend of SOURCE along the respective dimensions.
! If SOURCE is a scalar, the result is the rank one array of size zero.
! Standard:
! Fortran 95 and later
type(any_type) :: SOURCE[(:,...)]
integer :: KIND
integer :: SHAPE(:)
end function
function SIGN(A, B)
! Returns the value of A with the sign of B.
! Arguments:
! A -Shall be of type INTEGER or REAL
! B -Shall be of the same type and kind as A
! Return value:
! The kind of the return value is that of A and B. If B >= 0 then the result is ABS(A),
! else it is -ABS(A).
! Standard:
! Fortran 77 and later
integer or real :: A, B
end function
function DSIGN(A, B)
! This is specific name of SIGN function.
! Returns the value of A with the sign of B.
! Arguments:
! A -Shall be of type DOUBLE PRECISION
! B -Shall be of the same type and kind as A
! Return value:
! The kind of the return value is that of A and B. If B >= 0 then the result is ABS(A),
! else it is -ABS(A).
! Standard:
! Fortran 77 and later
double precision :: DSIGN, A, B
end function
function ISIGN(A, B)
! This is specific name of SIGN function.
! Returns the value of A with the sign of B.
! Arguments:
! A -Shall be of type default INTEGER
! B -Shall be of the same type and kind as A
! Return value:
! The kind of the return value is that of A and B. If B >= 0 then the result is ABS(A),
! else it is -ABS(A).
! Standard:
! Fortran 77 and later
integer :: ISIGN, A, B
end function
function SIN(X)
! Computes the sine of X.
! Arguments:
! X -The type shall be REAL or COMPLEX.
! Return value:
! The return value has same type and kind as X.
! Standard:
! Fortran 77 and later
real or complex :: X, SIN
end function
function CSIN(X)
! This is specific name of SIN function.
! Computes the sine of X.
! Arguments:
! X -The type shall be COMPLEX.
! Return value:
! The return value has same type and kind as X.
! Standard:
! Fortran 77 and later
complex :: CSIN, X
end function
function DSIN(X)
! This is specific name of SIN function.
! Computes the sine of X.
! Arguments:
! X -The type shall be DOUBLE PRECISION.
! Return value:
! The return value has same type and kind as X.
! Standard:
! Fortran 77 and later
double precision :: DSIN, X
end function
function SINH(X)
! Computes the hyperbolic sine of X.
! Arguments:
! X -The type shall be REAL or COMPLEX.
! Return value:
! The return value has same type and kind as X.
! Standard:
! Fortran 95 and later, for a complex argument Fortran 2008 or later
real or complex :: X, SINH
end function
function DSINH(X)
! Computes the hyperbolic sine of X.
! Arguments:
! X -The type shall be DOUBLE PRECISION.
! Return value:
! The return value has same type and kind as X.
! Standard:
! Fortran 95 and later
double precision :: DSINH, X
end function
function SIZE(ARRAY[, DIM [, KIND]])
! Determine the extent of ARRAY along a specified dimension DIM, or the total number of elements
! in ARRAY if DIM is absent.
! Arguments:
! ARRAY -Shall be an array of any type. If ARRAY is a pointer it must be associated and
! allocatable arrays must be allocated.
! DIM -(Optional) shall be a scalar of type INTEGER and its value shall be in the range
! from 1 to n, where n equals the rank of ARRAY.
! KIND -(Optional) An INTEGER initialization expression indicating the kind parameter
! of the result.
! Return value:
! The return value is of type INTEGER and of kind KIND. If KIND is absent, the return value
! is of default integer kind.
! Standard:
! Fortran 95 and later, with KIND argument Fortran 2003 and later
type(any_type) :: ARRAY[(:,...)] ! array of any type
integer, optional :: DIM, KIND
integer :: SIZE
end function
function SNGL(A)
! Converts the double precision real A to a default real value. This is an archaic form of REAL
! that is specific to one type for A.
! Arguments:
! A The type shall be a double precision REAL.
! Return value:
! The return value is of type default REAL.
! Standard:
! Fortran 77 and later
double precision :: A
real :: SNGL
end function
function SPACING(X)
! Determines the distance between the argument X and the nearest adjacent number of the same type.
! Arguments:
! X Shall be of type REAL.
! Return value:
! The result is of the same type as the input argument X.
! Standard:
! Fortran 95 and later
real :: X, SPACING
end function
function SPREAD(SOURCE, DIM, NCOPIES)
! Replicates a SOURCE array NCOPIES times along a specified dimension DIM.
! Arguments:
! SOURCE -Shall be a scalar or an array of any type and a rank less than seven.
! DIM -Shall be a scalar of type INTEGER with a value in the range from 1 to n+1,
! where n equals the rank of SOURCE.
! NCOPIES -Shall be a scalar of type INTEGER.
! Return value:
! The result is an array of the same type as SOURCE and has rank n+1 where n equals the rank of SOURCE.
! Standard:
! Fortran 95 and later
type(any_type) :: SOURCE[(:,...)]
integer :: DIM, NCOPIES
type(same_as_SOURCE) :: SPREAD(:[,:,...])
end function
function SQRT(X)
! Computes the square root of X.
! Arguments:
! X -The type shall be REAL or COMPLEX.
! Return value:
! The return value is of type REAL or COMPLEX. The kind type parameter is the same as X.
! Standard:
! Fortran 77 and later
real or complex :: X, SQRT
end function
function CSQRT(X)
! This is specific name of SQRT function.
! Computes the square root of X.
! Arguments:
! X -The type shall be COMPLEX.
! Return value:
! The return value is of type COMPLEX.
! Standard:
! Fortran 77 and later
complex :: CSQRT, X
end function
function DSQRT(X)
! This is specific name of SQRT function.
! Computes the square root of X.
! Arguments:
! X -The type shall be DOUBLE PRECISION.
! Return value:
! The return value is of type DOUBLE PRECISION.
! Standard:
! Fortran 77 and later
double precision :: DSQRT, X
end function
function SUM(ARRAY[, DIM] [, MASK])
! Adds the elements of ARRAY along dimension DIM if the corresponding element in MASK is TRUE.
! Syntax:
! RESULT = SUM(ARRAY[, MASK])
! RESULT = SUM(ARRAY, DIM[, MASK])
! Arguments:
! ARRAY -Shall be an array of type INTEGER, REAL or COMPLEX.
! DIM -(Optional) shall be a scalar of type INTEGER with a value in the range from 1 to n,
! where n equals the rank of ARRAY.
! MASK -(Optional) shall be of type LOGICAL and either be a scalar or an array of the same shape as ARRAY.
! Return value:
! The result is of the same type as ARRAY.
! If DIM is absent, a scalar with the sum of all elements in ARRAY is returned. Otherwise,
! an array of rank n-1, where n equals the rank of ARRAY,and a shape similar to that of ARRAY with
! dimension DIM dropped is returned.
! Standard:
! Fortran 95 and later
integer, real or complex :: ARRAY(:[,:,...])
integer, optional :: DIM
logical :: MASK(:[,:,...])
end function
subroutine SYSTEM_CLOCK([COUNT, COUNT_RATE, COUNT_MAX])
! Determines the COUNT of milliseconds of wall clock time. COUNT_RATE determines the number of clock
! ticks per second or zero if there is no processor clock. COUNT_MAX is assigned the maximum value of COUNT,
! if a processor clock is available, or otherwise, zero.
!Arguments:
! COUNT -(Optional) shall be a scalar of type default INTEGER with INTENT(OUT).
! COUNT_RATE -(Optional) shall be a scalar of type default INTEGER with INTENT(OUT).
! COUNT_MAX -(Optional) shall be a scalar of type default INTEGER with INTENT(OUT).
! Standard:
! Fortran 95 and later
integer, optional, intent(out) :: COUNT, COUNT_RATE, COUNT_MAX
end subroutine
function TAN(X)
! Computes the tangent of X.
! Arguments:
! X -The type shall be REAL or COMPLEX.
! Return value:
! The return value has same type and kind as X.
! Standard:
! Fortran 77 and later, for a complex argument Fortran 2008 or later
real or complex :: X, TAN
end function
function DTAN(X)
! This is specific name of TAN function.
! Computes the tangent of X.
! Arguments:
! X -The type shall be DOUBLE PRECISION.
! Return value:
! The return value has same type and kind as X.
! Standard:
! Fortran 77 and later
double precision :: DTAN, X
end function
function TANH(X)
! Computes the hyperbolic tangent of X.
! Arguments:
! X The type shall be REAL or COMPLEX.
! Return value:
! The return value has same type and kind as X. If X is complex, the imaginary part of the result
! is in radians. If X is REAL, the return value lies in the range - 1 <= tanh(x) <= 1 .
! Standard:
! Fortran 77 and later, for a complex argument Fortran 2008 or later
real or complex :: X, TANH
end function
function DTANH(X)
! This is specific name of TANH function.
! Computes the hyperbolic tangent of X.
! Arguments:
! X The type shall be DOUBLE PRECISION.
! Return value:
! The return value has same type and kind as X.
! If X is REAL, the return value lies in the range - 1 <= tanh(x) <= 1 .
! Standard:
! Fortran 77 and later
double precision :: DTANH, X
end function
function TINY(X)
! Returns the smallest positive (non zero) number in the model of the type of X.
! Arguments:
! X -Shall be of type REAL.
! Return value:
! The return value is of the same type and kind as X
! Standard:
! Fortran 95 and later
real :: X, TINY
end function
function TRAILZ(I)
! Returns the number of trailing zero bits of an integer.
! Arguments:
! I -Shall be of type INTEGER.
! Return value:
! The type of the return value is the default INTEGER. If all the bits of I are zero,
! the result value is BIT_SIZE(I).
! Standard:
! Fortran 2008 and later
integer :: I, TRAILZ
end function
function TRANSFER(SOURCE, MOLD[, SIZE])
! Interprets the bitwise representation of SOURCE in memory as if it is the representation of a variable
! or array of the same type and type parameters as MOLD.
! This is approximately equivalent to the C concept of casting one type to another.
! Arguments:
! SOURCE -Shall be a scalar or an array of any type.
! MOLD -Shall be a scalar or an array of any type.
! SIZE -(Optional) shall be a scalar of type INTEGER.
! Return value:
! The result has the same type as MOLD, with the bit level representation of SOURCE. If SIZE is present,
! the result is a one-dimensional array of length SIZE. If SIZE is absent but MOLD is an array
! (of any size or shape), the result is a one- dimensional array of the minimum length needed to contain the
! entirety of the bitwise representation of SOURCE. If SIZE is absent and MOLD is a scalar, the result is a scalar.
!
! If the bitwise representation of the result is longer than that of SOURCE, then the leading bits of the result
! correspond to those of SOURCE and any trailing bits are filled arbitrarily.
!
! When the resulting bit representation does not correspond to a valid representation of a variable of the same
! type as MOLD, the results are undefined, and subsequent operations on the result cannot be guaranteed to produce
! sensible behavior. For example, it is possible to create LOGICAL variables for which VAR and .NOT.VAR both
! appear to be true.
! Standard:
! Fortran 95 and later
type(any_type) :: SOURCE[(:,...)], MOLD[(:,...)]
integer :: SIZE
end function
function TRANSPOSE(MATRIX)
! Transpose an array of rank two. Element (i, j) of the result has the value MATRIX(j, i), for all i, j.
! Arguments:
! MATRIX -Shall be an array of any type and have a rank of two.
! Return value:
! The result has the same type as MATRIX, and has shape (/ m, n /) if MATRIX has shape (/ n, m /).
! Standard:
! Fortran 95 and later
type(any_type) :: MATRIX(:,:), TRANSPOSE(:,:)
end function
function TRIM(STRING)
! Removes trailing blank characters of a string.
! Arguments:
! STRING -Shall be a scalar of type CHARACTER.
! Return value:
! A scalar of type CHARACTER which length is that of STRING less the number of trailing blanks.
! Standard:
! Fortran 95 and later
character(len=*) :: TRIM, STRING
end function
function UBOUND(ARRAY [, DIM [, KIND]])
! Returns the upper bounds of an array, or a single upper bound along the DIM dimension.
! Arguments:
! ARRAY -Shall be an array, of any type.
! DIM -(Optional) Shall be a scalar INTEGER.
! KIND -(Optional) An INTEGER initialization expression indicating the kind parameter of the result.
! Return value:
! The return value is of type INTEGER and of kind KIND. If KIND is absent, the return value is of
! default integer kind. If DIM is absent, the result is an array of the upper bounds of ARRAY.
! If DIM is present, the result is a scalar corresponding to the upper bound of the array along that
! dimension. If ARRAY is an expression rather than a whole array or array structure component, or if
! it has a zero extent along the relevant dimension, the upper bound is taken to be the number of
! elements along the relevant dimension.
! Standard:
! Fortran 95 and later, with KIND argument Fortran 2003 and later
type(any_type) :: ARRAY(:[,...])
integer, optional :: DIM, KIND
integer(KIND) :: UBOUND
end function
function UNPACK(VECTOR, MASK, FIELD)
! Store the elements of VECTOR in an array of higher rank.
! Arguments:
! VECTOR -Shall be an array of any type and rank one. It shall have at least as many
! elements as MASK has TRUE values.
! MASK -Shall be an array of type LOGICAL.
! FIELD -Shall be of the same type as VECTOR and have the same shape as MASK.
! Return value:
! The resulting array corresponds to FIELD with TRUE elements of MASK replaced by values
! from VECTOR in array element order.
! Standard:
! Fortran 95 and later
type(any_type) :: VECTOR(:)
logical :: MASK(:[,:,...])
type(same_as_VECTOR) :: FIELD(:[,:,...])
type(same_as_VECTOR) :: UNPACK(:[,:,...])
end function
function VERIFY(STRING, SET[, BACK [, KIND]])
! Verifies that all the characters in a SET are present in a STRING.
! If BACK is either absent or equals FALSE, this function returns the position of the leftmost character
! of STRING that is not in SET. If BACK equals TRUE, the rightmost position is returned. If all
! characters of SET are found in STRING, the result is zero.
! Arguments:
! STRING -Shall be of type CHARACTER.
! SET -Shall be of type CHARACTER.
! BACK -(Optional) shall be of type LOGICAL.
! KIND -(Optional) An INTEGER initialization expression indicating the kind parameter of the result.
! Return value:
! The return value is of type INTEGER and of kind KIND. If KIND is absent, the return value is of
! default integer kind.
! Standard:
! Fortran 95 and later, with KIND argument Fortran 2003 and later
integer(KIND=KIND) :: VERIFY
character(len=*) :: STRING, SET
logical, optional :: BACK
integer, optional :: KIND
end function
function EXTENDS_TYPE_OF (A, MOLD)
! Inquires whether the dynamic type of A is an extension type of the dynamic type of MOLD.
! If MOLD is unlimited polymorphic and is a disassociated pointer or unallocated allocatable, the result is true.
! If A is unlimited polymorphic and is either a disassociated pointer or unallocated allocatable, the result is false.
! If the dynamic type of A is an extension type of the dynamic type of MOLD, the result is true.
! In other cases, the result is false.
! Arguments:
! A -object of extensible type. If A is a pointer, A must not have an undefined association status.
! MOLD -object of extensible type. If MOLD is a pointer, MOLD must not have an undefined association status.
! Return value:
! The return value is default logical
! Standard:
! Fortran 2003 and later
logical :: EXTENDS_TYPE_OF
type(any_extensible_type) :: A, MOLD
end function
function BGE (I, J)
! Determines whether an integral is a bitwise greater than or equal to another.
! Arguments:
! I Shall be of INTEGER type.
! J Shall be of INTEGER type, and of the same kind as I.
! Return value:
! The return value is default logical
! Standard:
! Fortran 2008 and later
integer :: I, J
end function
function BGT (I, J)
! Determines whether an integral is a bitwise greater than another.
! Arguments:
! I Shall be of INTEGER type.
! J Shall be of INTEGER type, and of the same kind as I.
! Return value:
! The return value is default logical
! Standard:
! Fortran 2008 and later
integer :: I, J
end function
function BLE (I, J)
! Determines whether an integral is a bitwise less than or equal to another.
! Arguments:
! I Shall be of INTEGER type.
! J Shall be of INTEGER type, and of the same kind as I.
! Return value:
! The return value is default logical
! Standard:
! Fortran 2008 and later
integer :: I, J
end function
function BLT (I, J)
! Determines whether an integral is a bitwise less than another.
! Arguments:
! I Shall be of INTEGER type.
! J Shall be of INTEGER type, and of the same kind as I.
! Return value:
! The return value is default logical
! Standard:
! Fortran 2008 and later
integer :: I, J
end function
function DSHIFTL (I, J, SHIFT)
! Combines bits of I and J. The rightmost SHIFT bits of the result are the leftmost SHIFT bits of J,
! and the remaining bits are the rightmost bits of I.
! Arguments:
! I Shall be of type INTEGER or a BOZ constant.
! J Shall be of type INTEGER or a BOZ constant. If both I and J have integer type,
! then they shall have the same kind type parameter. I and J shall not both be BOZ constants.
! SHIFT Shall be of type INTEGER. It shall be nonnegative. If I is not a BOZ constant,
! then SHIFT shall be less than or equal to BIT_SIZE(I); otherwise, SHIFT shall be less than or equal to BIT_SIZE(J).
! Return value:
! If either I or J is a BOZ constant, it is first converted as if by the intrinsic function INT
! to an integer type with the kind type parameter of the other.
! Standard:
! Fortran 2008 and later
integer :: I, J, SHIFT
end function
function DSHIFTR (I, J, SHIFT)
! Combines bits of I and J. The leftmost SHIFT bits of the result are the rightmost SHIFT bits of I,
! and the remaining bits are the leftmost bits of J.
! Arguments:
! I Shall be of type INTEGER or a BOZ constant.
! J Shall be of type INTEGER or a BOZ constant. If both I and J have integer type, then they shall
! have the same kind type parameter. I and J shall not both be BOZ constants.
! SHIFT Shall be of type INTEGER. It shall be nonnegative. If I is not a BOZ constant,
! then SHIFT shall be less than or equal to BIT_SIZE(I); otherwise, SHIFT shall be less than or equal to BIT_SIZE(J).
! Return value:
! If either I or J is a BOZ constant, it is first converted as if by the intrinsic function INT
! to an integer type with the kind type parameter of the other.
! Standard:
! Fortran 2008 and later
integer :: I, J, SHIFT
end function
function POPCNT (I)
! Returns the number of bits set ('1' bits) in the binary representation of I.
! Arguments:
! I Shall be of type INTEGER.
! Return value:
! The return value is of type INTEGER and of the default integer kind.
! Standard:
! Fortran 2008 and later
integer :: I
end function
function POPPAR (I)
! Returns parity of the integer I, i.e. the parity of the number of bits set ('1' bits) in the binary
! representation of I. It is equal to 0 if I has an even number of bits set, and 1 for an odd number
! of '1' bits.
! Arguments:
! I Shall be of type INTEGER.
! Return value:
! The return value is of type INTEGER and of the default integer kind.
! Standard:
! Fortran 2008 and later
integer :: I
end function
function MASKL(I[, KIND])
! Sets its leftmost I bits to 1, and the remaining bits sets to 0.
! Arguments:
! I Shall be of type INTEGER.
! KIND Shall be a scalar constant expression of type INTEGER.
! Return value:
! The return value is of type INTEGER. If KIND is present, it specifies the kind value
! of the return type; otherwise, it is of the default integer kind.
! Standard:
! Fortran 2008 and later
integer :: I
integer, optional :: KIND
end function
function MASKR(I[, KIND])
! Sets its rightmost I bits to 1, and the remaining bits sets to 0.
! Arguments:
! I Shall be of type INTEGER.
! KIND Shall be a scalar constant expression of type INTEGER.
! Return value:
! The return value is of type INTEGER. If KIND is present, it specifies the kind value
! of the return type; otherwise, it is of the default integer kind.
! Standard:
! Fortran 2008 and later
integer :: I
integer, optional :: KIND
end function
function SHIFTA(I, SHIFT)
! Returns a value corresponding to I with all of the bits shifted right by SHIFT places.
! If the absolute value of SHIFT is greater than BIT_SIZE(I), the value is undefined.
! Bits shifted out from the right end are lost. The fill is arithmetic:
! the bits shifted in from the left end are equal to the leftmost bit, which in two's
! complement representation is the sign bit.
! Arguments:
! I The type shall be INTEGER.
! SHIFT The type shall be INTEGER.
! Return value:
! The return value is of type INTEGER and of the same kind as I.
! Standard:
! Fortran 2008 and later
integer :: I, SHIFT
end function
function SHIFTL(I, SHIFT)
! Returns a value corresponding to I with all of the bits shifted left by SHIFT places.
! If the absolute value of SHIFT is greater than BIT_SIZE(I), the value is undefined.
! Bits shifted out from the left end are lost, and bits shifted in from the right end are set to 0.
! Arguments:
! I The type shall be INTEGER.
! SHIFT The type shall be INTEGER.
! Return value:
! The return value is of type INTEGER and of the same kind as I.
! Standard:
! Fortran 2008 and later
integer :: I, SHIFT
end function
function SHIFTR(I, SHIFT)
! Returns a value corresponding to I with all of the bits shifted right by SHIFT places.
! If the absolute value of SHIFT is greater than BIT_SIZE(I), the value is undefined.
! Bits shifted out from the right end are lost, and bits shifted in from the left end are set to 0.
! Arguments:
! I The type shall be INTEGER.
! SHIFT The type shall be INTEGER.
! Return value:
! The return value is of type INTEGER and of the same kind as I.
! Standard:
! Fortran 2008 and later
integer :: I, SHIFT
end function
function MERGE_BITS(I, J, MASK)
! Merges the bits of I and J as determined by the mask. The i-th bit of the result is equal to
! the i-th bit of I if the i-th bit of MASK is 1; it is equal to the i-th bit of J otherwise.
! Arguments:
! I Shall be of type INTEGER.
! J Shall be of type INTEGER and of the same kind as I.
! MASK Shall be of type INTEGER and of the same kind as I.
! Return value:
! The result is of the same type and kind as I.
! Standard:
! Fortran 2008 and later
integer :: I, J, MASK
end function
function IALL(ARRAY[, DIM] [, MASK])
! Reduces with bitwise AND the elements of ARRAY along dimension DIM if the corresponding element
! in MASK is TRUE.
! Arguments:
! ARRAY Shall be an array of type INTEGER
! DIM (Optional) shall be a scalar of type INTEGER with a value in the range from 1 to n, where n equals the rank of ARRAY.
! MASK (Optional) shall be of type LOGICAL and either be a scalar or an array of the same shape as ARRAY.
! Return value:
! The result is of the same type as ARRAY.
! If DIM is absent, a scalar with the bitwise ALL of all elements in ARRAY is returned. Otherwise,
! an array of rank n-1, where n equals the rank of ARRAY, and a shape similar to that of ARRAY with
! dimension DIM dropped is returned.
! Standard:
! Fortran 2008 and later
integer :: ARRAY(:[,:,...])
integer, optional :: DIM
logical, optional :: MASK([:...])
end function
function IANY(ARRAY[, DIM] [, MASK])
! Reduces with bitwise OR (inclusive or) the elements of ARRAY along dimension DIM if the corresponding
! element in MASK is TRUE.
! Arguments:
! ARRAY Shall be an array of type INTEGER
! DIM (Optional) shall be a scalar of type INTEGER with a value in the range from 1 to n, where n equals the rank of ARRAY.
! MASK (Optional) shall be of type LOGICAL and either be a scalar or an array of the same shape as ARRAY.
! Return value:
! The result is of the same type as ARRAY.
! If DIM is absent, a scalar with the bitwise OR of all elements in ARRAY is returned.
! Otherwise, an array of rank n-1, where n equals the rank of ARRAY, and a shape similar to that
! of ARRAY with dimension DIM dropped is returned.
! Standard:
! Fortran 2008 and later
integer :: ARRAY(:[,:,...])
integer, optional :: DIM
logical, optional :: MASK([:...])
end function
function IPARITY(ARRAY[, DIM] [, MASK])
! Reduces with bitwise XOR (exclusive or) the elements of ARRAY along dimension DIM if the corresponding
! element in MASK is TRUE.
! Arguments:
! ARRAY Shall be an array of type INTEGER
! DIM (Optional) shall be a scalar of type INTEGER with a value in the range from 1 to n, where n equals the rank of ARRAY.
! MASK (Optional) shall be of type LOGICAL and either be a scalar or an array of the same shape as ARRAY.
! Return value:
! The result is of the same type as ARRAY.
! If DIM is absent, a scalar with the bitwise XOR of all elements in ARRAY is returned.
! Otherwise, an array of rank n-1, where n equals the rank of ARRAY, and a shape similar
! to that of ARRAY with dimension DIM dropped is returned.
! Standard:
! Fortran 2008 and later
integer :: ARRAY(:[,:,...])
integer, optional :: DIM
logical, optional :: MASK([:...])
end function
function STORAGE_SIZE(A [, KIND])
! Returns the storage size of argument A in bits.
! Arguments:
! A Shall be a scalar or array of any type.
! KIND (Optional) shall be a scalar integer constant expression.
! Return value:
! The result is a scalar integer with the kind type parameter specified by KIND (or default integer type
! if KIND is missing). The result value is the size expressed in bits for an element of an array that
! has the dynamic type and type parameters of A.
! Standard:
! Fortran 2008 and later
type(any_type) :: ARRAY(:[,:,...])
integer, optional :: KIND
end function
function PARITY(MASK[, DIM])
! Calculates the parity, i.e. the reduction using .XOR., of MASK along dimension DIM.
! Arguments:
! MASK Shall be an array of type LOGICAL
! DIM (Optional) shall be a scalar of type INTEGER with a value in the range from 1 to n, where n equals the rank of MASK.
! Return value:
! The result is of the same type as MASK.
! If DIM is absent, a scalar with the parity of all elements in MASK is returned, i.e. true if
! an odd number of elements is .true. and false otherwise. If DIM is present, an array of rank n-1,
! where n equals the rank of ARRAY, and a shape similar to that of MASK with dimension DIM dropped is returned.
! Standard:
! Fortran 2008 and later
logical :: MASK(:[,:,...])
integer :: DIM
end function
function NORM2(ARRAY[, DIM])
! Calculates the Euclidean vector norm (L_2 norm) of of ARRAY along dimension DIM.
! Arguments:
! ARRAY Shall be an array of type REAL.
! DIM (Optional) shall be a scalar of type INTEGER with a value in the range from 1 to n,
! where n equals the rank of ARRAY.
! Return value:
! The result is of the same type as ARRAY.
! If DIM is absent, a scalar with the square root of the sum of all elements in ARRAY squared is
! returned. Otherwise, an array of rank n-1, where n equals the rank of ARRAY, and a shape similar
! to that of ARRAY with dimension DIM dropped is returned.
! Standard:
! Fortran 2008 and later
real :: ARRAY(:[,:,...])
integer, optional :: DIM
end function
subroutine EXECUTE_COMMAND_LINE(COMMAND [, WAIT, EXITSTAT, CMDSTAT, CMDMSG ])
! Runs a shell command, synchronously or asynchronously.
! If WAIT is present and has the value false, the execution of the command is asynchronous
! if the system supports it; otherwise, the command is executed synchronously.
! The three last arguments allow the user to get status information.
! After synchronous execution, EXITSTAT contains the integer exit code of the command, as returned by system.
! CMDSTAT is set to zero if the command line was executed (whatever its exit status was).
! CMDMSG is assigned an error message if an error has occurred.
! Standard:
! Fortran 2008 and later
character(len=*), intent(in) :: COMMAND ! command line to be executed.
logical, intent(in), optional :: WAIT ! Do perform execution synchronously?
integer, intent(inout), optional :: EXITSTAT ! Exit status if synchronous execution is performed.
integer, intent(out), optional :: CMDSTAT
character(len=*), intent(inout), optional :: CMDMSG
end subroutine
function FINDLOC (ARRAY, VALUE [, DIM, MASK, KIND, BACK])
! Returns location(s) of a specified value.
! Standard:
! Fortran 2008 and later
type(intrinsic-type) :: ARRAY(..) ! Shall be an array of intrinsic type.
type(same-as-array) :: VALUE ! Shall be scalar in type conformance with ARRAY.
integer, optional :: DIM ! Shall be an integer scalar with a value in the range 1<=DIM<=n.
logical, optional :: MASK ! (Optional) shall be of type logical and shall be conformance with ARRAY.
integer, optional :: KIND ! (Optional) shall be a scalar integer constant.
logical, optional :: BACK ! (Optional) shall be a logical scalar.
end function
integer function NUM_IMAGES ([TEAM] [TEAM_NUMBER])
! Retuns the number of images.
! Return value:
! Scalar default-kind integer.
! Standard:
! Fortran 2008 and later
end function
function THIS_IMAGE ([COARRAY] [, DIM][, TEAM])
! Returns the cosubscript for this image.
! Standard:
! Fortan 2008 and later.
type(*), optional :: COARRAY
integer, optional :: DIM ! Shall be an integer scalar with a value in the range 1<=DIM<=n.
type(team_type), optional :: TEAM
end function
function UCOBOUND (COARRAY [, DIM, KIND])
! Returns the upper cobounds of a coarray, or a single upper cobound along the DIM codimension.
! Standard:
! Fortan 2008 and later.
type(*), optional :: COARRAY
integer, optional :: DIM
integer, optional :: KIND
end function
function LCOBOUND (COARRAY [, DIM, KIND])
! Returns the lower bounds of a coarray, or a single lower cobound along the DIM codimension.
! Standard:
! Fortan 2008 and later.
type(*), optional :: COARRAY
integer, optional :: DIM
integer, optional :: KIND
end function
integer function IMAGE_INDEX (COARRAY, SUB [, TEAM] [, TEAM_NUMBER])
! Returns the image index belonging to a cosubscript.
! Standard:
! Fortan 2008 and later.
type(*) :: COARRAY
integer :: SUB
type(team_type), optional :: TEAM
integer, optional :: TEAM_NUMBER
end function
subroutine ATOMIC_DEFINE (ATOM, VALUE)
! Defines the variable ATOM with the value VALUE atomically.
! Standard:
! Fortan 2008 and later.
! Arguments:
! ATOM Scalar coarray or coindexed variable of either integer type with ATOMIC_INT_KIND kind or logical type with ATOMIC_LOGICAL_KIND kind.
! VALUE Scalar and of the same type as ATOM. If the kind is different, the value is converted to the kind of ATOM.
end subroutine
subroutine ATOMIC_REF (ATOM, VALUE)
! Atomically assigns the value of the variable ATOM to VALUE.
! Standard:
! Fortan 2008 and later.
! Arguments:
! ATOM Scalar coarray or coindexed variable of either integer type with ATOMIC_INT_KIND kind or logical type with ATOMIC_LOGICAL_KIND kind.
! VALUE Scalar and of the same type as ATOM. If the kind is different, the value is converted to the kind of ATOM.
end subroutine
subroutine ATOMIC_ADD(ATOM, VALUE [, STAT])
! Atomic addition.
! Arguments:
! ATOM Scalar coarray or coindexed variable.
! VALUE Integer scalar.
! STAT (optional) Noncoindexed integer scalar.
! Standard:
! Fortran 2018 and later.
end subroutine
subroutine ATOMIC_AND(ATOM, VALUE [, STAT])
! Atomic bitwise AND.
! Arguments:
! ATOM Scalar coarray or coindexed variable.
! VALUE Integer scalar.
! STAT (optional) Noncoindexed integer scalar.
! Standard:
! Fortran 2018 and later.
end subroutine
subroutine ATOMIC_CAS(ATOM, OLD, COMPARE, NEW [, STAT])
! Atomic compare and swap.
! Arguments:
! ATOM Scalar coarray or coindexed variable.
! OLD Scalar of the same type and kind as ATOM.
! COMPARE Scalar of the same type and kind as ATOM.
! NEW Scalar of the same type and kind as ATOM.
! STAT (optional) Noncoindexed integer scalar.
! Standard:
! Fortran 2018 and later.
end subroutine
subroutine ATOMIC_OR(ATOM, VALUE [, STAT])
! Atomic bitwise OR.
! Arguments:
! ATOM Scalar coarray or coindexed variable.
! VALUE Integer scalar.
! STAT (optional) Noncoindexed integer scalar.
! Standard:
! Fortran 2018 and later.
end subroutine
subroutine ATOMIC_XOR(ATOM, VALUE [, STAT])
! Atomic bitwise exclusive OR.
! Arguments:
! ATOM Scalar coarray or coindexed variable.
! VALUE Integer scalar.
! STAT (optional) Noncoindexed integer scalar.
! Standard:
! Fortran 2018 and later.
end subroutine
subroutine ATOMIC_FETCH_ADD(ATOM, VALUE, OLD, [, STAT])
! Atomic fetch and add.
! Arguments:
! ATOM Scalar coarray or coindexed variable.
! VALUE Integer scalar.
! OLD Scalar of the same type and kind as ATOM.
! STAT (optional) Noncoindexed integer scalar.
! Standard:
! Fortran 2018 and later.
end subroutine
subroutine ATOMIC_FETCH_AND(ATOM, VALUE, OLD, [, STAT])
! Atomic fetch and bitwise AND.
! Arguments:
! ATOM Scalar coarray or coindexed variable.
! VALUE Integer scalar.
! OLD Scalar of the same type and kind as ATOM.
! STAT (optional) Noncoindexed integer scalar.
! Standard:
! Fortran 2018 and later.
end subroutine
subroutine ATOMIC_FETCH_OR(ATOM, VALUE, OLD, [, STAT])
! Atomic fetch and bitwise OR.
! Arguments:
! ATOM Scalar coarray or coindexed variable.
! VALUE Integer scalar.
! OLD Scalar of the same type and kind as ATOM.
! STAT (optional) Noncoindexed integer scalar.
! Standard:
! Fortran 2018 and later.
end subroutine
subroutine ATOMIC_FETCH_XOR(ATOM, VALUE, OLD, [, STAT])
! Atomic fetch and bitwise exclusive OR.
! Arguments:
! ATOM Scalar coarray or coindexed variable.
! VALUE Integer scalar.
! OLD Scalar of the same type and kind as ATOM.
! STAT (optional) Noncoindexed integer scalar.
! Standard:
! Fortran 2018 and later.
end subroutine
subroutine CO_BROADCAST(A, SOURCE_IMAGE [, STAT, ERRMSG])
! Braodcast value to images.
! Arguments:
! A Becomes defined with the same values on all images in the current team.
! SOURCE_IMAGE Integer scalar with value the same in all team.
! STAT (optional) Noncoindexed integer scalar.
! ERRMSG Default character scalar.
! Standard:
! Fortran 2018 and later.
end subroutine
subroutine CO_MAX(A [, RESULT_IMAGE, STAT, ERRMSG])
! Compute maximum value across images.
! Arguments:
! A Integer, real or character variable.
! RESULT_IMAGE (optional) Integer scalar with value the same in all team.
! STAT (optional) Noncoindexed integer scalar.
! ERRMSG Default character scalar.
! Standard:
! Fortran 2018 and later.
end subroutine
subroutine CO_MIN(A [, RESULT_IMAGE, STAT, ERRMSG])
! Compute minimum value across images.
! Arguments:
! A Integer, real or character variable.
! RESULT_IMAGE (optional) Integer scalar with value the same in all team.
! STAT (optional) Noncoindexed integer scalar.
! ERRMSG Default character scalar.
! Standard:
! Fortran 2018 and later.
end subroutine
subroutine CO_REDUCE(A, OPERATION [, RESULT_IMAGE, STAT, ERRMSG])
! Reduction across images.
! Arguments:
! A Non polimorphic scalar or array variable.
! OPERATION Pure function with two arguments.
! RESULT_IMAGE (optional) Integer scalar with value the same in all team.
! STAT (optional) Noncoindexed integer scalar.
! ERRMSG Default character scalar.
! Standard:
! Fortran 2018 and later.
end subroutine
subroutine CO_SUM(A [, RESULT_IMAGE, STAT, ERRMSG])
! Compute sum across images.
! Arguments:
! A Integer, real or character variable.
! RESULT_IMAGE (optional) Integer scalar with value the same in all team.
! STAT (optional) Noncoindexed integer scalar.
! ERRMSG (optional) Default character scalar.
! Standard:
! Fortran 2018 and later.
end subroutine
subroutine EVENT_QUERY(EVENT, COUNT [, STAT])
! Query event count.
! Arguments:
! EVENT (intent(in)) An event variable.
! COUNT (intent(out)) Integer scalar
! STAT (optional) Noncoindexed integer scalar.
! Standard:
! Fortran 2018 and later.
end subroutine
function FAILED_IMAGES([TEAM, KIND])
! Returns indices of failed images in an array of rank one.
! Arguments:
! TEAM (optional) Scalar of type TEAM_TYPE with value of the current or an ancestor team.
! KIND (optional) Integer scalar.
! Standard:
! Fortran 2018 and later.
end function
function IMAGE_STATUS(IMAGE [, TEAM])
! Returns image execution state.
! Arguments:
! IMAGE Integer with an image index.
! TEAM (optional) Scalar of type TEAM_TYPE with value of the current or an ancestor team.
! Standard:
! Fortran 2018 and later.
end function
function STOPPED_IMAGES([TEAM, KIND])
! Returns indices of stopped images in an array of rank one.
! Arguments:
! TEAM (optional) Scalar of type TEAM_TYPE with value of the current or an ancestor team.
! KIND (optional) Integer scalar.
! Standard:
! Fortran 2018 and later.
end function
function TEAM_NUMBER([TEAM])
! Returns default integer with value that identifies the specified team within its parent team.
! Arguments:
! TEAM (optional) Scalar of type TEAM_TYPE with value of the current or an ancestor team.
! Standard:
! Fortran 2018 and later.
end function
function GET_TEAM([LEVEL])
! Returns scalar of type TEAM_TYPE with value that identifies the team.
! Arguments:
! LEVEL (optional) Scalar integer with value INITIAL_TEAM, PARENT_TEAM, or CURRENT_TEAM.
! Standard:
! Fortran 2018 and later.
end function
integer function COSHAPE(COARRAY[, KIND])
! Return sizes of codimensions of a coarray.
! Arguments:
! COARRAY shall be coarray of any type.
! KIND (optional) shall be a scalar integer constant expression.
! Return value:
! The result has a value whose i_th element is equal to the size of the i_th codimension of COARRAY,
! as given by UCOBOUND (COARRAY, i) − LCOBOUND (COARRAY, i) +1.
end function
function RANK(A)
! Determine the rank of a data object.
integer :: RANK
type(any_type) :: A ! data object
end function
logical function OUT_OF_RANGE(X, MOLD [, ROUND])
! Returns .true. if X value cannot be converterd safely.
integer or real :: X
integer or real :: MOLD
logical, optional :: ROUND
end function
function REDUCE(ARRAY, OPERATION[, DIM][, MASK, IDENTITY, ORDERED])
! General reduction of array.
type(any_type), dimension(..) :: ARRAY
interface
pure function OPERATION(A, B)
end function
end interface
integer, optional :: DIM
logical, (conformable with ARRAY), optional :: MASK
type(same as ARRAY, scalar), optional :: IDENTITY
logical, optional :: ORDERED
end function
logical function IS_CONTIGUOUS(ARRAY)
! Array contiguity test.
! Returns .true. if ARRAY has rank zero or is contiguous, and .false. otherwise.
type(any_type), dimension(..) :: ARRAY
end function
subroutine __fortran_statement_OPEN(UNIT, NEWUNIT, FILE, ACCESS, ACTION, ASYNCHRONOUS, BLANK, DECIMAL, DELIM, &
ENCODING, ERR, FORM, IOSTAT, PAD, POSITION, RECL, ROUND, SIGN, STATUS)
! Connect or reconnect an external file to an input/output unit.
integer, intent(in) :: UNIT ! External file unit number.
integer, intent(out) :: NEWUNIT ! Automatially chosen unit number.
character(len=*), intent(in) :: FILE ! The name of the file to be connected.
character(len=*), intent(in) :: ACCESS ! Access mode one from 'SEQUENTIAL' (default), 'DIRECT' or 'STREAM'
character(len=*), intent(in) :: ACTION ! File access: 'READWRITE' (default), 'READ' or 'WRITE'
character(len=*), intent(in) :: ASYNCHRONOUS ! 'YES' allows asynchronous i/o on the unit, 'NO' does not allow.
character(len=*), intent(in) :: BLANK ! Controls how interpreted blanks. Values: 'NULL' (default) or 'ZERO'.
character(len=*), intent(in) :: DECIMAL ! Specifies the default decimal edit mode: 'POINT' (default) or 'COMMA'.
character(len=*), intent(in) :: DELIM ! Specifies delimiter for character constants in namelist: 'APOSTROPHE', 'QUOTE' or 'NONE'.
character(len=*), intent(in) :: ENCODING ! Shall be: 'DEFAULT' or 'UTF-8'.
integer, intent(in) :: ERR ! Statement label to go if error occurs.
character(len=*), intent(in) :: FORM ! Shall be: 'DEFAULT' or 'UTF-8'.
integer, intent(out) :: IOSTAT ! Returns: a zero value if no error, a positive value if an error.
character(len=*), intent(in) :: PAD ! Specifies if input records are padded with blanks: 'YES' (default) or 'NO'.
character(len=*), intent(in) :: POSITION ! Specifies the file position for a file connected: 'ASIS', 'REWIND', 'APPEND'.
integer, intent(in) :: RECL ! Specifies specifies the length of record.
character(len=*), intent(in) :: ROUND ! Rounding mode to be used: 'UP', 'DOWN', 'ZERO', 'NEAREST', 'COMPATIBLE' or 'PROCESSOR_DEFINED' (default).
character(len=*), intent(in) :: SIGN ! Specifies the sign mode in effect: 'PLUS', 'SUPPRESS' or 'PROCESSOR_DEFINED' (default).
character(len=*), intent(in) :: STATUS ! Specifies the status of the file when it is opened: 'OLD', 'NEW', 'SCRATCH', 'REPLACE', or 'UNKNOWN'.
end subroutine
module OpenMP
type(keywords) :: atomic, auto, barrier, capture, collapse, copyin, copyprivate, default, end, &
firstprivate, lastprivate, private, reduction, schedule, shared, critical, &
do, flush, master, ordered, parallel, sections, workshare, copyin, copyprivate, &
threadprivate, dynamic, guided, read, runtime, single, update, write, &
static, task, if, final, untied, none, mergeable, taskwait, taskyield, &
num_threads, section, nowait, &
endatomic, endcritical, enddo, endmaster, endordered, endparallel, endsections, &
endsingle, endtask, endworkshare, paralleldo, parallelsections, parallelworkshare, &
proc_bind, close, spread, simd, safelen, linear, aligned, declare, simdlen, lenear, &
uniform, inbranch, notingranch, target, device, map, to, from, teams, num_teams, &
thread_limit, distribute, dist_schedule, depend, in, out, inout, taskgroup, &
seq_cst, max, min, iand, ior, ieor, cancel, cancellation, point, omp_priv, &
monotonic, nonmonotonic, priority, taskloop, enter, data, exit, map, use_device_ptr, threads, source, sink
end module
module OpenACC
type(keywords) :: parallel, end, if, async, num_gangs, num_workers, vector_length, reduction, &
copy, copyin, copyout, create, present, present_or_copy, present_or_copyin, &
present_or_copyout, present_or_create, deviceptr, private, firstprivate, &
kernels, data, host_data, use_device, &
loop, collapse, gang, worker, vector, seq, independent, cache, &
declare, device_resident, update, host, device, wait
end module
Reference in a new issue Copy permalink