Intrinsic Procedures

Description of all intrinsic procedures, from FORTRAN 77 to Fortran 2018:

The procedure tables have the following form:

Syntax
Description Procedure Class Language Standard

Logical Functions

result = iand(i, j)

Returns the bitwise logical AND of i and j [integer, or BOZ constant since Fortran 2008].

elemental function Fortran 90, Fortran 2008
result = ior(i, j)

Returns the bitwise logical inclusive-OR of i and j [integer, or BOZ constant since Fortran 2008].

elemental function Fortran 90, Fortran 2008
result = ieor(i, j)

Returns the bitwise logical exclusive-OR of i and j [integer, or BOZ constant since Fortran 2008].

elemental function Fortran 90, Fortran 2008
result = not(i)

Returns the bitwise logical inverse of i.

elemental function Fortran 90

Mathematical Functions

Power & Logarithmic Functions

result = exp(x)

Returns the base e exponential of x [real, complex].

elemental function FORTRAN 77
result = gamma(x)

Returns gamma of x [real], equals Γ(x) = (x - 1)!, with x > 0.

elemental function Fortran 2008
result = log(x)

The natural logarithm of x [real, complex] to the base e.

elemental function FORTRAN 77
result = log10(x)

The logarithm of x [real] to the base 10.

elemental function FORTRAN 77
result = log_gamma(x)

Returns the natural logarithm of the absolute value of the gamma function [real], with x > 0.

elemental function Fortran 2008
result = sqrt(x)

Returns the square root of x [real, complex].

elemental function FORTRAN 77

Trigonometric Functions

result = acos(x)

The arccosine of x [real, complex since Fortran 2008].

elemental function FORTRAN 77, Fortran 2008
result = asin(x)

The arcsin of x [real, complex since Fortran 2008].

elemental function FORTRAN 77, Fortran 2008
result = atan(x)
result = atan(x, y)

The arctangent of x [real], or single complex argument or two real arguments x, y since Fortran 2008.

elemental function FORTRAN 77, Fortran 2008
result = atan2(y, x)

The arctangent of y, x [real] with respect to the correct quadrant.

elemental function FORTRAN 77
result = cos(x)

The cosine of x [real, complex].

elemental function FORTRAN 77
result = hypot(x, y)

Returns the Euclidean distance between x and y [real], i. e., sqrt(x**2 + y**2).

elemental function Fortran 2008
result = norm2(array[, dim])

Returns the Euclidean vector norm (L2 norm) of array [real] along optional dimension dim.

transformational function Fortran 2008
result = sin(x)

The sine of x [real, complex].

elemental function FORTRAN 77
result = tan(x)

The tangent of x [real, complex since Fortran 2008].

elemental function FORTRAN 77, Fortran 2008

Hyperbolic Functions

result = acosh(x)

The inverse hyperbolic cosine of x [real, complex].

elemental function Fortran 2008
result = asinh(x)

The inverse hyperbolic sine of x [real, complex].

elemental function Fortran 2008
result = atanh(x)

The inverse hyperbolic tangent of x [real, complex].

elemental function Fortran 2008
result = cosh(x)

The hyperbolic cosine of x [real, complex since Fortran 2008].

elemental function FORTRAN 77, Fortran 2008
result = sinh(x)

The hyperbolic sine of x [real, complex since Fortran 2008].

elemental function Fortran 90, Fortran 2008
result = tanh(x)

The hyperbolic tangent of x [real, complex since Fortran 2008].

elemental function FORTRAN 77, Fortran 2008

Error Functions

result = erf(x)

Computes the error function of x [real]:

erf
elemental function Fortran 2008
result = erfc(x)

Computes the complementary error function of x [real]:

erfc
elemental function Fortran 2008
result = erfc_scaled(x)

Computes the exponentially-scaled complementary error function of x [real].

elemental function Fortran 2008

Bessel Functions

result = bessel_j0(x)

Computes the Bessel function of the first kind of order 0 of x [real]. The return value is of type real, lies in the range −0.4027… ≤ Bessel(0, x) ≤ 1, and has the same kind as x.

elemental function Fortran 2008
result = bessel_j1(x)

Computes the Bessel function of the first kind of order 1 of x [real]. The return value is of type real, lies in the range −0.5818… ≤ Bessel(0, x) ≤ 0.5818, and has the same kind as x.

elemental function Fortran 2008
result = bessel_jn(n, x)
result = bessel_jn(n1, n2, x)

The elemental function bessel_jn(n, x) computes the Bessel function of the first kind of order n [integer scalar or array] of x [real scalar or array]. If n and x are arrays, their ranks and shapes have to conform.

The transformational function bessel_jn(n1, n2, x) returns an array with the Bessel functions of the first kind of the orders n1 to n2 [integer, ≥ 0].

elemental function, transformational function Fortran 2008
result = bessel_y0(x)

Computes the Bessel function of the second kind of order 0 of x [real]. The return value is of type real and has the same kind as x.

elemental function Fortran 2008
result = bessel_y1(x)

Computes the Bessel function of the second kind of order 1 of x [real]. The return value is of type real and has the same kind as x.

elemental function Fortran 2008
result = bessel_yn(n, x)
result = bessel_yn(n1, n2, x)

The elemental function bessel_jn(n, x) computes the Bessel function of the second kind of order n [integer scalar or array] of x [real scalar or array]. If n and x are arrays, their ranks and shapes have to conform.

The transformational function bessel_jn(n1, n2, x) returns an array with the Bessel functions of the second kind of the orders n1 to n2 [integer, ≥ 0].

elemental function, transformational function Fortran 2008

Arithmetic Functions

result = abs(a)

Returns the absolute value of a [numeric].

elemental function FORTRAN 77
result = aimag(z)

Yields the imaginary part [real] of the argument z [complex]. The result has the kind parameter of the argument.

elemental function FORTRAN 77
result = aint(a[, kind])

Truncates the argument a [real] to a whole number [real], with optional real kind [integer] of the result.

elemental function FORTRAN 77
result = anint(a[, kind])

Rounds the argumnet a [real] to the nearest whole number [real], with optional kind parameter of the result.

elemental function FORTRAN 77
result = ceiling(a[, kind])

Returns the least integer greater than or equal to a [real], with optional integer kind [integer] of the result.

elemental function Fortran 95
result = conjg(z)

Returns the conjugate of z [complex]. If z is (x, y) then the result is (x, −y).

elemental function FORTRAN 77
result = digits(x)

Returns the number of significant binary digits of the internal model representation of x [integer, real].

inquiry function Fortran 90
result = dim(x, y)

Returns the difference x - y [integer, real] if the result is positive, otherwise returns zero

elemental function FORTRAN 77
result = dprod(x, y)

Returns the double product of x and y [real] as kind real(kind=8), i. e., x * y.

elemental function FORTRAN 77
result = epsilon(x)

Returns the smallest number e of the same kind as x [real] such as that 1 + e > 1.

inquiry function Fortran 90
result = exponent(x)

Returns the value of the exponent part of x [real]. If x is zero, the value zero is returned.

elemental function Fortran 90
result = floor(a[, kind])

Returns the greatest integer less than or equal to a [real], with optional integer kind.

elemental function Fortran 95
result = fraction(x)

Returns the fractional part of the model representation of x [real].

elemental function Fortran 90
result = huge(x)

Returns the largest number that is not an infinity in the model of the type of a [real, integer].

inquiry function Fortran 90
result = maxexponent(x)

Returns the maximum exponent [integer] in the model of the type of x [real].

inquiry function Fortran 90
result = minexponent(x)

Returns the minimum exponent [integer] in the model of the type of x [real].

elemental function Fortran 90
result = nearest(x, s)

Returns the processor-representable number nearest to x [real] in the direction indicated by the sign of s [real, ≠ 0]. If s is positive, the routine returns a number greater than x and nearest to it; if s is negative, a number smaller than x and nearest to it instead.

elemental function Fortran 90
result = modulo(a, p)

Computes a [integer, real] modulo p [same type].

elemental function Fortran 95
result = nint(a, kind)

Returns argument a [real] rounded to the nearest whole number, with optional integer kind of the result since Fortran 90.

elemental function FORTRAN 77, Fortran 90
result = precision(x)

Returns the decimal precision in the model of the type of x [real, complex].

inquiry function Fortran 90
result = radix(x)

Returns the base of the model representing the entity x [integer, real].

inquiry function Fortran 90
result = range(x)

Returns the decimal exponent range in the model of the type of x [numeric].

inquiry function Fortran 90
result = rrspacing(x)

Returns the reciprocal of the relative spacing of model numbers near x [real]. The result is equal to abs(fraction(x)) * float(radix(x))**digits(x).

elemental function Fortran 90
result = scale(x, i)

Returns x * radix(x)**i, with x of type real and i of type integer.

elemental function Fortran 90
result = set_exponent(x, i)

Returns the real number whose fractional part is that of x [real] and whose exponent part is i [integer], i. e., fraction(x) * radix(x)**i.

elemental function Fortran 90
result = sign(a, b)

Returns the value of a with the sign of b [integer, real].

elemental function FORTRAN 77
result = spacing(x)

Returns the distance between x [real] and the nearest adjacent number of the same type.

elemental function Fortran 90

Bit Procedures

result = bge(i, j)

Returns .true. if i [integer] is bitwise greater than or equal to j [integer], else .false..

elemental function Fortran 2008
result = bgt(i, j)

Returns .true. if i [integer] is bitwise greater than j [integer], else .false..

elemental function Fortran 2008
result = ble(i, j)

Returns .true. if i [integer] is bitwise less than or equal to j [integer], else .false..

elemental function Fortran 2008
result = blt(i, j)

Returns .true. if i [integer] is bitwise less than j [integer], else .false..

elemental function Fortran 2008
result = btest(i, pos)

Returns .true. if the bit at position pos [integer] in i [integer] is set (test bit). The couting of the bits starts at 0.

elemental function Fortran 90
result = bit_size(i)

Returns the number of bits (integer precision plus sign bit) represented by the type of i [integer].

inquiry function Fortran 90
result = dshiftl(i, j, shift)

Combines bits of i and j [integer, BOZ constant). The rightmost shift [integer] bits of the result are the leftmost shift bits of j, and the remaining bits are the rightmost bits of i.

elemental function Fortran 2008
result = dshiftr(i, j, shift)

Combines bits of i and j [integer, BOZ constant). The leftmost shift [integer] bits of the result are the rightmost shift bits of i, and the remaining bits are the leftmost bits of j.

elemental function Fortran 2008
result = ibclr(i, pos)

Returns the value of i [integer] with the bit at position pos [integer] set to zero (clear bit).

elemental function Fortran 90
result = ibits(i, pos, len)

Extracts a field of length len [integer] from i [integer], starting from bit position pos [integer] and extending left for len bits (bit extraction). The result is right-justified and the remaining bits are set to zero. The value of pos + len must be ≤ bit_size(i).

elemental function Fortran 90
result = ibset(i, pos)

Returns the value of i [integer] with the bit at position pos set to one (set bit).

elemental function Fortran 90
result = ishft(i, shift)

Returns i [integer] with all bits shifted by shift [integer] places: left if shift > 0, right if shift < 0, and no shift if shift = 0. Zeros are shifted in from the opposite end.

elemental function Fortran 90
result = ishftc(i, shift[, size])

Returns a value corresponding to i [integer] with the rightmost size [integer] bits shifted circularly shift [integer] 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).

elemental function Fortran 90
result = leadz(i)

Returns the number of leading zero bits of i [integer].

elemental function Fortran 2008
result = maskl(i[, kind])

Returns an integer that has its leftmost i [integer] bits set to 1, and the remaining bits set to 0, with optional integer kind [integer] of the result.

elemental function Fortran 2008
result = maskr(i[, kind])

Returns an integer that has its rightmost i [integer] bits set to 1, and the remaining bits set to 0, with optional integer kind [integer] of the result.

elemental function Fortran 2008
result = merge_bits(i, j, mask)

Merges the bit of i and j [integer] as determined by the mask mask [integer, BOZ constant).

elemental function Fortran 2008
call mvbits(from, frompos, len, to, topos)

Moves len [integer] bits from positions frompos [integer] through frompos + len - 1 of from [integer] to positions topos [integer] through topos + len - 1 of to [integer].

The values of frompos + len - 1 and topos + len - 1 must be less than bit_size(from).

elemental subroutine Fortran 90
result = popcnt(i)

Returns the number of bits set (i. e., 1 bits) in the binary representation of i [integer]

elemental function Fortran 2008
result = poppar(i)

Returns the parity of the number of bits set in i [integer], i. e., zero if i has an even number of bits set, and one for an odd number of bits set.

elemental function Fortran 2008
result = shifta(i, shift)

Returns i [integer] with all bits shifted right by shift [integer] places with fill. 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.

elemental function Fortran 2008
result = shiftl(i, shift)

Returns i [integer] with all bits shifted left by shift [integer] places.

elemental function Fortran 2008
result = shiftr(i, shift)

Returns i [integer] with all bits shifted right by shift [integer] places.

elemental function Fortran 2008
result = trailz(i)

Returns the number of trailing zero bits of i [integer].

elemental function Fortran 2008

Array Procedures

result = all(mask[, dim])

Determines if all the values in array mask [logical] are .true. along optional dimension dim [integer]. Returns .true. if all elements of mask are .true. or mask has zero size, else .false..

transformational function Fortran 90
result = any(mask[, dim])

Determines if any of the values in array mask [logical] are .true. along optional dimension dim [integer]. Returns .true. if any element of mask is .true., else .false..

transformational function Fortran 90
result = count(mask[, dim, kind])

Counts the number of .true. elements in mask [logical] along optional dimension dim [integer], and with optional logical kind [integer] of the result since Fortran 2003. If the array has zero size, or all of the elements are .false., then the result is 0.

transformational function Fortran 90, Fortran 2003
result = cshift(array, shift[, dim])

Performs a circular shift on elements of array along optional dimension dim [integer].

If the rank of array is one, then all elements are shifted by shift [integer] 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.

transformational function Fortran 90
result = eoshift(array, shift[, boundary, dim])

Performs an end-off shift on elements of array along optional dimension dim [integer].

If the rank of array is one, then all elements are shifted by shift [integer] 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 [same type as array] 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.

transformational function Fortran 90
result = findloc(array, value, dim[, mask][, kind][, back])
result = findloc(array, value[, mask][, kind][, back])

Determines the location [integer] of the element in array [intrinsic] with the value given in the value [intrinsic] argument, or, if dim [integer] is supplied, determines the locations of the elements equal to value along each row of the array in the dim direction.

If mask [logical] is present, only the elements for which mask is .true. are considered. If more than one element in the array has the value value, the location returned is that of the first such element in array element order if back [logical] is not present or if it is .false..

If back is .true., the location returned is that of the last such element.

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.

transformational function Fortran 2008
result = iall(array[, mask])
result = iall(array, dim[, mask])

Bitwise AND of array elements [integer]. Reduces with bitwise AND the elements of array along dimension dim if the corresponding element in mask is .true..

transformational function Fortran 2008
result = iany(array[, mask])
result = iany(array, dim[, mask])

Bitwise inclusive-OR of array elements [integer]. Reduces with bitwise OR the elements of array along dimension dim if the corresponding element in mask is .true..

transformational function Fortran 2008
result = is_contiguous(array)

Returns .true. if the passed array is contiguous, else .false..

inquiry function Fortran 2008
result = lbound(array[, dim[, kind]])

Returns the lower bounds of array, or a single lower bound along the dim [integer] dimension, with optional integer kind [integer] of the result since Fortran 2003.

inquiry function Fortran 90, Fortran 2003
result = maxloc(array, dim[, mask][, kind][, back])
result = maxloc(array[, mask][, kind][, back])

Determines the location of the element [integer] in array [integer or real, character since Fortran 2003] with the maximum value, or, if dim [integer] is supplied, determines the locations of the minimum element along each row of the array in the dim direction, with optional integer kind of the result since Fortran 2003.

If mask [logical] 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 optional back [logical, since Fortran 2008] argument is not present, or is .false.. If back is .true., the location returned is that of the last such element.

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.

transformational function Fortran 95, Fortran 2003, Fortran 2008
result = maxval(array, dim[, mask])
result = maxval(array[, mask])

Returns the maximum value of the elements in array [integer, real], or, if dim is supplied, determines the maximum value along each row of array in the dim direction.

If mask [logical] is present, only the elements for which mask is .true. are considered.

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

transformational function Fortran 90
result = minloc(array, dim[, mask][, kind][, back])
result = minloc(array[, mask][, kind][, back])

Determines the location of the element [integer] in array [integer or real, character since Fortran 2003] with the minimum value, or, if dim [integer] is supplied, determines the locations of the minimum element along each row of the array in the dim direction, with optional integer kind of the result since Fortran 2003.

If mask [logical] 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 optional back [logical, since Fortran 2008] argument is not present, or is .false.. If back is .true., the location returned is that of the last such element.

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.

transformational function Fortran 90, Fortran 2003, Fortran 2008
result = minval(array, dim[, mask])
result = minval(array[, mask])

Returns the minimum value of the elements in array [integer, real], or, if dim is supplied, determines the minimum value along each row of array in the dim direction.

If mask [logical] is present, only the elements for which mask is .true. are considered.

If 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) if array is of character type.

transformational function Fortran 90
call move_alloc(from, to)

Moves the allocation from array from to array to. The array from will be deallocated.

pure subroutine Fortran 2003
result = 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 [logical] equals .true.. Afterwards, positions are filled with elements taken from vector [same type as array].

transformational function Fortran 90
result = product(array[, mask])
result = product(array, dim[, mask])

Multiplies the elements of array [numeric] along dimension dim if the corresponding element in mask [logical] is .true..

transformational function Fortran 90
result = rank(a)

Returns the rank of a scalar or array data object a.

inquiry function TS 29113
result = reshape(source, shape[, pad, order])

Reshapes array source to correspond to shape [integer array]. If necessary, the new array may be padded with elements from pad or permuted as defined by order [integer array].

transformational function Fortran 90
result = shape(source[, kind])

Determines the shape of array source, with optional integer kind of the result since Fortran 2003.

inquiry function Fortran 90, Fortran 2003
result = 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, with optional integer kind of the result since Fortran 2003.

inquiry function Fortran 90, Fortran 2003
result = sum(array[, mask])
result = sum(array, dim[, mask])

Adds the elements of array [numeric] along dimension dim if the corresponding element in mask [logical] is .true..

transformational function Fortran 90
result = ubound(array[, dim[, kind]])

Returns the upper bounds of array, or a single upper bound along the dim [integer] dimension, with optional integer kind [integer] of the result since Fortran 2003.

inquiry function Fortran 90, Fortran 2003
result = unpack(vector, mask, field)

Stores the elements of vector in an array of higher rank, with vector having at least as many elements as mask has .true. values. The resulting array corresponds to field with .true. elements of mask replaced by values from vector in array element order.

transformational function Fortran 90

Vector & Matrix Functions

result = dot_product(vector_a, vector_b)

Computes the dot product multiplication of two vectors vector_a and vector_b (both either numeric or logical].

transformational function Fortran 90
result = matmul(matrix_a, matrix_b)

Performs a matrix multiplication on numeric or logical arguments, with rank one or two.

transformational function Fortran 90
result = transpose(matrix)

Transposes array matrix of rank two. The result has the same type as matrix, and has shape [ m, n ] if matrix has shape [ n, m ].

transformational function Fortran 90

Character Functions

result = achar(i[, kind])

Returns the character located at position i in the ASCII collating sequence, with optional character kind kind since Fortran 2003.

elemental function FORTRAN 77, Fortran 2003
result = adjustl(string)

Left-adjust string [character] by removing leading spaces. Spaces are inserted at the end of the string as needed. The return value is of the same kind as string.

elemental function Fortran 90
result = adjustr(string)

Right-adjust string [character] by removing trailing spaces. Spaces are inserted at the start of the string as needed. The return value is of the same kind as string.

elemental function Fortran 90
result = iachar(c[, kind])

Returns the code for the ASCII character in the first character position of c [character], with optional integer kind of the result since Fortran 2003.

elemental function Fortran 95, Fortran 2003
result = index(string, substring[, back[, kind]])

Returns the position of the start of the first occurrence of substring [character] within string [character], with optional integer kind argument of the result since Fortran 2003 (counting from one).

If substring is not present in string, zero is returned. If the back argument [logical] is present and .true., the return value is the start of the last occurrence rather than the first.

elemental function FORTRAN 77, Fortran 2003
result = len(string[, kind])

Returns the length of string [character], with optional integer kind of the result since Fortran 2003. If string is an array, the length of an element is returned.

inquiry function FORTRAN 77, Fortran 2003
result = len_trim(string[, kind])

Returns the length of string [character], ignoring any trailing blanks, and with optional integer kind kind of the result since Fortran 2003.

elemental function Fortran 90, Fortran 2003
result = lge(string_a, string_b)

Returns .true. if string_a [character] is lexically greater than or equal to string_b [character], where the two strings are interpreted as containing ASCII character codes.

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

elemental function FORTRAN 77
result = lgt(string_a, string_b)

Returns .true. if string_a [character] is lexically greater than string_b [character], where the two strings are interpreted as containing ASCII character codes.

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

elemental function FORTRAN 77
result = lle(string_a, string_b)

Returns .true. if string_a [character] is lexically less than or equal to string_b [character], where the two strings are interpreted as containing ASCII character codes.

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

elemental function FORTRAN 77
result = llt(string_a, string_b)

Returns .true. if string_a [character] is lexically less than string_b [character], where the two strings are interpreted as containing ASCII character codes.

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

elemental function FORTRAN 77
result = new_line(c)

Returns the new-line character [character(len=1)] of the same kind as argument c [character], for example, print *, new_line('A').

inquiry function Fortran 2003
result = repeat(string, ncopies)

Concatenates ncopies [integer] of given string. The result is a new scalar of type character built up from ncopies copies of string.

transformational function Fortran 90
result = scan(string, set[, back[, kind]])

Scans a string [character] for any of the characters in a set of characters. If back [logical] is either absent or equals .false., this function returns the position of the leftmost character of string that is in set, else the rightmost position is returned.

If no character of set is found in string, the result is zero. The return value is of integer kind since Fortran 2003.

elemental function Fortran 90, Fortran 2003
result = trim(string)

Removes trailing blank character of string.

transformational function Fortran 90
result = verify(string, set[, back[, kind]])

Verifies that all the characters in string belong to the set of characters in set, with optional integer kind argument of the result since Fortran 2003.

If back [logical] is either absent or equals .false., the 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 string are found in set, the result is zero.

elemental function Fortran 90, Fortran 2003

Type Functions

result = allocated(array)
result = allocated(scalar)

Returns .true. if array or scalar (Fortran 2003) is allocated, else .false.. The arguments must be allocatable.

inquiry function Fortran 90, Fortran 2003
result = associated(pointer[, target])

Returns .true. if pointer is associated or associated with target, else .false..

inquiry function Fortran 90
result = extends_type_of(a, mold)

Queries dynamic type for extension. Returns .true. if a is an extension of mold, else .false..

inquiry function Fortran 2003
result = is_iostat_end(i)

Returns .true. if argument i [integer] has the value of the I/O status “end of file”, else .false.. The function is equivalent to comparing the variable with the IOSTAT_END parameter of the intrinsic module iso_fortran_env.

elemental function Fortran 2003
result = is_iostat_eor(i)

Returns .true. if argument i [integer] has the value of the I/O status “end of record”, else .false.. The function is equivalent to comparing the variable with the IOSTAT_EOR parameter of the intrinsic module iso_fortran_env.

elemental function Fortran 2003
result = kind(x)

Returns the kind value of the entity x [logical, integer, real, complex, character, either scalar or array].

transformational function Fortran 95
result = null([mold])

Returns a disassociated pointer. If mold is present, a disassociated pointer of the same type is returned, otherwise the type is determined by context. The argument mold may be required in Fortran 2003.

transformational function Fortran 95, Fortran 2003
result = present(a)

Returns .true. if the given optional dummy argument of a function or subroutine is present, else .false..

inquiry function Fortran 90
result = same_type_as(a, b)

Queries dynamic types for equality. Returns .true. if a is of the same type as b, else .false..

inquiry function Fortran 2003
result = selected_char_kind(name)

Returns the kind value [integer] for the character set named name [character], if a character set with such a name is supported, or −1 otherwise.

The character sets are compiler-depended, and may include ascii/default and ISO_10646 (Universal Character Set, UCS-4) that is equivalent to Unicode.

transformational function Fortran 2003
result = selected_int_kind(r)

Return the kind value [integer] of the smallest integer type that can represent all values ranging from −10r (exclusive) to 10r (exclusive) [integer].

If there is no integer kind that accommodates this range, the function returns −1.

transformational function Fortran 90
result = selected_real_kind([p, r, radix])

Returns the kind value [integer] of a real data type with decimal precision of at least p [integer] digits, exponent range of at least r [integer], and optionally with a radix of radix [integer] since Fortran 2008.

If the radix argument is absent, real kinds with any radix can be returned. If more than one real data type meet the criteria, the kind of the data type with the smallest decimal precision is returned. If no real data type matches the criteria, the result is < 0.

transformational function Fortran 90, Fortran 2008
result = storage_size(x[, kind])

Returns the storage size of argument a [scalar or array] in bits, with optional integer kind of the result.

elemental function Fortran 2008
result = 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. The result has the same type as mold, with the bit level representation of source.

transformational function Fortran 90

Type Conversion Functions

result = char(c[, kind])

Returns the character represented by i [integer]. The return value is of type character(len=1), and optionally of character kind kind.

elemental function FORTRAN 77
result = 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, else it is set to 0.0. If x is complex then y must not be present.

elemental function FORTRAN 77
result = dble(a)

Converts a [numeric] to double precision real type.

elemental function FORTRAN 77
result = ichar(c[, kind])

Returns the code for the character in the first character position of c [character] in the system’s native character set, with optional integer kind of the result since Fortran 2003.

elemental function FORTRAN 77, Fortran 2003
result = int(a[, kind])

Converts a [numeric, BOZ constant since Fortran 2008] to integer type, with optional integer kind kind of the result since Fortran 2008.

elemental function FORTRAN 77, Fortran 2008
result = logical(l[, kind])

Converts l [logical] to other logical kind kind.

elemental function Fortran 90
result = real(a[, kind])

Converts a [numeric] to single precision real type, with optional real kind of the result since Fortran 90.

elemental function FORTRAN 77, Fortran 90

Random Number Procedures

call random_init(repeatable, image_distinct)

Initialises a pseudo-random number generator. If repeatable [logical] is .true., the seed is set to a processor-dependent value that is the same each time the subroutine is called from the same image. If image_distinct is .true., the seed is set to a processor-dependent value that is distinct from the seed set by a call to the subroutine in another image.

subroutine Fortran 2018
call random_number(harvest)

Returns a single pseudorandom number or an array of pseudorandom numbers from the uniform distribution over the range 0 ≤ x < 1 in scalar or array harvest [real]. In a multi-threaded program (e. g., OpenMP), each thread will have its own random number state.

subroutine Fortran 90
call random_seed([size, put, get])

Restarts or queries the state of the pseudo-random number generator used by random_number(). If the subroutine is called without arguments, it is seeded with random data retrieved from the operating system.

The optional argument size [integer] specifies the minimum size of the arrays used with the put and get arguments. The put [integer] argument sets the seed to the passed array, the get [integer] argument instead returns the seed as array.

subroutine Fortran 90

System Procedures

result = compiler_options()

Returns a string with the options used for compiling. The function has to be imported from module iso_fortran_env.

inquiry function Fortran 2008
result = compiler_version()

Returns a string with the name and the version of the compiler. The function has to be imported from module iso_fortran_env.

inquiry function Fortran 2008
result = command_argument_count()

Returns the number of arguments passed on the command-line as integer.

inquiry function Fortran 2003
call cpu_time(time)

Returns the elapsed CPU time in seconds in time [real]. If a time source is available, the time will be reported with microsecond resolution. If no time source is available, argument time is set to -1.0.

subroutine Fortran 95
call date_and_time(date, time, zone, values)

Returns the corresponding date and time information from the real-time system clock.

The argument date [character(len=8)] has the form ccyymmdd, argument time [character(len=10)] the form hhmmss.sss, argument zone [character(len=5)] the form (+-)hhmm, representing the difference with respect to Coordinated Universal Time (UTC).

The argument values(8) [integer(kind=8)] contains:

  • values(1): The year.
  • values(2): The month.
  • values(3): The day of the month.
  • values(4): Time difference with UTC in minutes.
  • values(5): The hour of the day.
  • values(6): The minutes of the hour.
  • values(7): The seconds of the minute.
  • values(8): The milliseconds of the second.
subroutine Fortran 90
call execute_command_line(command[, wait, exitstat, cmdstat, cmdmsg])

Runs a shell command command [character], synchronously (default) or asynchronously (if argument wait is .false.). After synchronous execution, exitstat [integer] contains the exit code of the command, as returned by system.

Argument cmdstat [integer] is set to zero if the command-line was executed (whatever its exit status was). cmdmsg [character] is assigned an error message if an error has occurred.

subroutine Fortran 2008
call get_command([command, length, status])

Retrieves the entire command-line that was used to invoke the program. If command [character] is present, it stores the command-line. If length [integer] is present, it is assigned the length of the command-line.

If status [integer] 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.

subroutine Fortran 2003
call get_command_argument(number[, value, length, status])

Retrieves the number-th argument that was passed on the command-line. Argument value [character] argument holds the command-line argument. If the argument cannot hold the argument, it is truncated to fit its length. If there are less than number [integer] arguments specified at the command line, value will be filled with blanks.

If number equals 0, value is set to the name of the program. The length [integer] argument contains the length of command-line argument.

If the argument retrieval fails, status is a positive number; if value contains a truncated command line argument, status [integer] is −1; and otherwise the status is zero.

subroutine Fortran 2003
call get_environment_variable(name[, value, length, status, trim_name])

Retrieves the value of the environmental variable name [both character]. If trim_name [logical] is present with the value .false., the trailing blanks in name are significant; otherwise they are not part of the environment variable name.

The subroutine need not be thread-safe. It is the responsibility of the user to ensure that the environment is not being updated concurrently with a call to the subroutine.

subroutine Fortran 2003

ISO C Binding Procedures

The intrinsic Fortran module iso_c_binding has to imported with use, intrinsic :: iso_c_binding first to access any of the following procedures.

result = c_associated(cptr1[, cptr2])

Returns .true. if the C pointer cptr1 [type(c_ptr)] is associated, or if cptr1 is associated with the target cptr2 [type(c_ptr)], else .false..

inquiry function Fortran 2003
call c_f_pointer(cptr, fptr[, shape])

Assigns the target of the C pointer cptr [type(c_ptr)] to the Fortran pointer fptr [pointer], and optionally specifies its shape [integer array].

subroutine Fortran 2003
call c_f_procpointer(cptr, fptr)

Assigns the target of the C function pointer cptr [type(c_funptr)] to the Fortran procedure pointer fptr [procedure].

subroutine Fortran 2003
result = c_funloc(x)

Determines the C address [type(c_funptr)] of procedure x [interoperable procedure, procedure pointer].

inquiry function Fortran 2003
result = c_loc(x)

Determines the C address [type(c_ptr)] of variable x [interoperable type with pointer or target attribute].

inquiry function Fortran 2003
result = c_sizeof(x)

Calculates the number of bytes of storage [integer(kind=c_size_t)] the expression x [interoperable type] occupies.

If x has the pointer attribute, the number of bytes of the storage area pointed to is returned. If the argument is of a derived type with pointer or allocatable components, the return value does not account for the sizes of the data pointed to by these components.

inquiry function Fortran 2008

CoArray Procedures

call atomic_add(atom, value[, stat])

Atomically adds value [scalar of the same type as atom] to the variable atom [integer(kind=atomic_int_kind), coarray or coindexed].

When stat [integer] is present and the invocation was successful, it is assigned the value 0, or a positive value if the invocation has failed.

In particular, for a coindexed atom, if the remote image has stopped, it is assigned the value of STAT_STOPPED_IMAGE, and if the remote image has failed, the value STAT_FAILED_IMAGE, both from intrinsic Fortran module iso_fortran_env.

atomic subroutine TS 18508
call atomic_and(atom, value[, stat])

Atomically defines atom [integer(kind=atomic_int_kind), coarray or coindexed] with the bitwise AND between the values of atom and value [scalar of the same type as atom].

When stat [integer] is present and the invocation was successful, it is assigned the value 0, or a positive value if the invocation has failed.

In particular, for a coindexed atom, if the remote image has stopped, it is assigned the value of STAT_STOPPED_IMAGE and if the remote image has failed, the value STAT_FAILED_IMAGE, both from intrinsic Fortran module iso_fortran_env.

atomic subroutine TS 18508
call atomic_cas(atom, old, compare, new[, stat])

Compares the variable atom [integer(kind=atomic_int_kind) or logical(kind=atomic_logical_kind), scalar coarray or coindexed] with the value of compare. If the value is the same, atom is set to the value of new.

old is set to the value of atom that was used for the comparison.

When stat [integer] is present and the invocation was successful, it is assigned 0, else a positive value. In particular, for a coindexed atom, if the remote image has stopped, it is assigned the value of STAT_STOPPED_IMAGE and if the remote image has failed, the value STAT_FAILED_IMAGE, both from intrinsic Fortran module iso_fortran_env.

atomic subroutine TS 18508
call atomic_define(atom, value[, stat])

Defines the variable atom [integer(kind=atomic_int_kind) or logical(kind=atomic_logical_kind), scalar coarray or coindexed] with the value value atomically.

When stat [integer, since TS 18508] is present and the invocation was successful, it is assigned 0, else a positive value. In particular, for a coindexed atom, if the remote image has stopped, it is assigned the value of STAT_STOPPED_IMAGE and if the remote image has failed, the value STAT_FAILED_IMAGE, both from intrinsic Fortran module iso_fortran_env.

atomic subroutine Fortran 2008, TS 18508
call atomic_fetch_add(atom, value, old[, stat])

Atomically stores the value of atom [integer(kind=atomic_int_kind) or logical(kind=atomic_logical_kind), scalar coarray or coindexed] in old and adds the value of var to the variable atom.

When stat [integer] is present and the invocation was successful, it is assigned 0, else a positive value. In particular, for a coindexed atom, if the remote image has stopped, it is assigned the value of STAT_STOPPED_IMAGE and if the remote image has failed, the value STAT_FAILED_IMAGE, both from intrinsic Fortran module iso_fortran_env.

atomic subroutine TS 18508
call atomic_fetch_and(atom, value, old[, stat])

Atomically stores the value of atom [integer(kind=atomic_int_kind), scalar coarray or coindexed] in old and defines atom with the bitwise AND between the values of atom and value.

When stat [integer] is present and the invocation was successful, it is assigned 0, else a positive value. In particular, for a coindexed atom, if the remote image has stopped, it is assigned the value of STAT_STOPPED_IMAGE and if the remote image has failed, the value STAT_FAILED_IMAGE, both from intrinsic Fortran module iso_fortran_env.

atomic subroutine TS 18508
call atomic_fetch_or(atom, value, old[, stat])

Atomically stores the value of atom [integer(kind=atomic_int_kind), scalar coarray or coindexed] in old and defines atom with the bitwise OR between the values of atom and value.

When stat [integer] is present and the invocation was successful, it is assigned 0, else a positive value. In particular, for a coindexed atom, if the remote image has stopped, it is assigned the value of STAT_STOPPED_IMAGE and if the remote image has failed, the value STAT_FAILED_IMAGE, both from intrinsic Fortran module iso_fortran_env.

atomic subroutine TS 18508
call atomic_fetch_xor(atom, value, old[, stat])

Atomically stores the value of atom [integer(kind=atomic_int_kind), scalar coarray or coindexed] in old and defines atom with the bitwise XOR between the values of atom and value.

When stat [integer] is present and the invocation was successful, it is assigned 0, else a positive value. In particular, for a coindexed atom, if the remote image has stopped, it is assigned the value of STAT_STOPPED_IMAGE and if the remote image has failed, the value STAT_FAILED_IMAGE, both from intrinsic Fortran module iso_fortran_env.

atomic subroutine TS 18508
call atomic_or(atom, value[, stat])

Atomically defines atom [integer(kind=atomic_int_kind), scalar coarray or coindexed] with the bitwise AND between the values of atom and value.

When stat [integer] is present and the invocation was successful, it is assigned 0, else a positive value. In particular, for a coindexed atom, if the remote image has stopped, it is assigned the value of STAT_STOPPED_IMAGE and if the remote image has failed, the value STAT_FAILED_IMAGE, both from intrinsic Fortran module iso_fortran_env.

atomic subroutine TS 18508
call atomic_ref(value, atom[, stat])

Atomically assigns the value of the variable atom [integer(kind=atomic_int_kind) or logical(kind=atomic_logical_kind), scalar coarray or coindexed] to value.

When stat [integer, since TS 18508] is present and the invocation was successful, it is assigned 0, else a positive value. In particular, for a coindexed atom, if the remote image has stopped, it is assigned the value of STAT_STOPPED_IMAGE and if the remote image has failed, the value STAT_FAILED_IMAGE, both from intrinsic Fortran module iso_fortran_env.

atomic subroutine Fortran 2008, TS 18508
call atomic_xor(atom, value[, stat])

Atomically defines atom [integer(kind=atomic_int_kind), scalar coarray or coindexed] with the bitwise XOR between the values of atom and value.

When stat [integer] is present and the invocation was successful, it is assigned 0, else a positive value. In particular, for a coindexed atom, if the remote image has stopped, it is assigned the value of STAT_STOPPED_IMAGE and if the remote image has failed, the value STAT_FAILED_IMAGE, both from intrinsic Fortran module iso_fortran_env.

atomic subroutine TS 18508
call co_broadcast(a, source_image[, stat, errmsg])

Copies the value of argument a [integer, real, character; scalar or array] on the image with image index source_image [integer] to all images in the current team. a becomes defined as if by intrinsic assignment.

If the execution was successful and stat [integer] is present, it is assigned 0, else a positive value and, if present, errmsg [character] gets assigned a value describing the occurred error.

collective subroutine TS 18508
call co_max(a[, result_image, stat, errmsg])

Determines element-wise the maximal value of a [integer, real, character; scalar or array] on all images of the current team. If result_image [integer] is present, the maximum values are returned in a on the specified image only and the value of a on the other images become undefined. If result_image is not present, the value is returned on all images.

If the execution was successful and stat [integer] is present, it is assigned 0, else a positive value and, if present, errmsg [character] gets assigned a value describing the occurred error.

collective subroutine TS 18508
call co_min(a[, result_image, stat, errmsg])

Determines element-wise the minimum value of a [integer, real, character; scalar or array] on all images of the current team. If result_image [integer] is present, the minimum values are returned in a on the specified image only and the value of a on the other images become undefined. If result_image is not present, the value is returned on all images.

If the execution was successful and stat [integer] is present, it is assigned 0, else a positive value and, if present, errmsg [character] gets assigned a value describing the occurred error.

collective subroutine TS 18508
call co_reduce(a, operator[, result_image, stat, errmsg])

Determines element-wise the reduction of the value of a [scalar or array] on all images of the current team. The pure function passed as operator [two scalar nonallocatable arguments of the same type as a] is used to pairwise reduce the values of a by passing either the value of a of different images or the result values of such a reduction as argument.

If a is an array, the deduction is done element wise. If result_image [integer] is present, the result values are returned in a on the specified image only and the value of a on the other images become undefined. If result_image is not present, the value is returned on all images.

If the execution was successful and stat [integer] is present, it is assigned 0, else a positive value and, if present, errmsg [character] gets assigned a value describing the occurred error.

collective subroutine TS 18508
call co_sum(a[, result_image, stat, errmsg])

Sums up the values of each element of a [integer, real, or complex] on all images of the current team. If result_image [integer] is present, the summed-up values are returned in a on the specified image only and the value of a on the other images become undefined. If result_image is not present, the value is returned on all images.

If the execution was successful and stat [integer] is present, it is assigned 0, else a positive value and, if present, errmsg [character] gets assigned a value describing the occurred error.

collective subroutine TS 18508
call event_query(event, count[, stat])

Assigns the number of events to count [integer] which have been posted to event [type(event_type)] and not yet been removed by calling event wait.

When stat [integer] is present and the invocation was successful, it is assigned zero, otherwise a positive value and count [integer] is assigned −1.

subroutine TS 18508
result = image_index(coarray, sub)

Returns the image index belonging to a cosubscript. For invalid cosubscripts the result is zero.

inquiry function Fortran 2008
result = lcobound(coarray[, dim[, kind]])

Returns the lower bounds of coarray [coarray], or a single lower cobound along the dim [integer] codimension, with optional integer kind [integer] of the result.

inquiry function Fortran 2008
result = num_images(distance, failed)

Returns the number of images, with optional distance [integer, ≥ 0] and failed [logical] since TS 18508.

If distance is not present or has value 0, the number of images in the current team is returned. For values smaller or equal distance to the initial team, it returns the number of images index on the ancestor team which has a distance of distance from the invoking team. If distance is larger than the distance to the initial team, the number of images of the initial team is returned.

If failed is not present the total number of images is returned; if it has the value .true., the number of failed images is returned, otherwise, the number of images which do have not the failed status.

transformational function Fortran 2008, TS 18508
result = this_image()
result = this_image(distance)
result = this_image(coarray[, dim])

Returns the cosubscript for this image, with optional distance [integer, ≥ 0] since TS 18508.

If coarray [coarray] is not present, the result is scalar; if distance is not present or has value 0, its value is the image index on the invoking image for the current team, for values smaller or equal distance to the initial team, it returns the image index on the ancestor team which has a distance of distance from the invoking team.

If distance is larger than the distance to the initial team, the image index of the initial team is returned. Otherwise when the coarray is present, if dim [integer], between one and the corank of coarray is not present, a rank − 1 array with corank elements is returned, containing the cosubscripts for coarray specifying the invoking image.

If dim is present, a scalar is returned, with the value of the dim element of this_image(coarray).

transformational function Fortran 2008, TS 18508
result = ucobound(coarray[, dim[, kind]])

Returns the upper bounds of coarray [coarray], or a single lower cobound along the dim [integer] codimension, with optional integer kind [integer] of the result.

inquiry function Fortran 2008

References