Chapter 5. Intrinsic Procedures

Chapter 5. Intrinsic Procedures
Prev		Next

The Fortran standard defines intrinsic procedures, which consist of intrinsic functions and intrinsic subroutines. The compiler includes several more intrinsic procedures as extensions to the standard.

Intrinsic procedures can be called from any program unit or subprogram. However, a user-written function or subroutine with the same name as an intrinsic function or subroutine takes precedence over the intrinsic procedure in a given scoping unit if one of the following is true:

Its interface is explicit.
It is listed in an EXTERNAL statement in that scoping unit.
It is a statement function.

A module or internal procedure, for example, overrides an intrinsic procedure with the same name, in the absence of an applicable INTRINSIC statement, because its interface is explicit. If a module or internal procedure is accessible by the same name as a name specified on an INTRINSIC statement, it is an error in a program unit.

This chapter introduces all of the intrinsic procedures supported by the compiler. Each procedure is described in detail on an online man page. For more information on any of the intrinsic procedures introduced in this chapter, enter man intrinsic_name at your system prompt.

Note: All intrinsic functions that are defined in the Fortran standard can be assumed to be pure functions.

5.1. Intrinsic Procedure Terms and Concepts

Intrinsic procedures are predefined by the language. They conform to the principles and rules for procedures as described in the MIPSpro Fortran Language Reference Manual, Volume 1. Intrinsic procedures are invoked in the same way as other procedures and employ the same argument association mechanism. The intrinsic procedure interfaces, including the argument keywords (dummy argument names) and argument options, are all described partially in this section and are described further in the man pages.

The four classes of intrinsic procedures are as follows:

Inquiry functions.
Elemental functions.
Transformational functions.
Subroutines. One intrinsic subroutine, MVBITS, is elemental and pure.

The compiler also includes the following types of intrinsic procedures:

Intrinsic procedures to support IEEE floating-point arithmetic.
Miscellaneous procedures. All procedures in this group are extensions to the Fortran standard.

5.1.1. Inquiry Functions

An inquiry function returns information about something. The results of these functions depend on the properties of the principal argument rather than the value of this argument. The argument can be undefined.

The Fortran standard inquiry functions are as follows (in the following list, the numeric model referred to is described in Section 5.3):

Name		Information returned
`ALLOCATED`		Array allocation status
`ASSOCIATED`		Pointer association status or comparison
`BIT_SIZE`		Number of bits in the bit manipulation model
`DIGITS`		Number of significant digits in the numeric model
`EPSILON`		Number that is almost negligible compared to one
`HUGE`		Largest number in the numeric model
`KIND`		Kind type parameter value
`LBOUND`		Lower dimension bounds of an array
`LEN`		Length of a character entity
`MAXEXPONENT`		Maximum exponent in the numeric model
`MINEXPONENT`		Minimum exponent in the numeric model
`PRECISION`		Decimal precision of the numeric model
`PRESENT`		Dummy argument presence
`RADIX`		Base of the numeric model
`RANGE`		Decimal exponent range of the numeric model
`SHAPE`		Shape of an array or scalar
`SIZE`		Total number of elements in an array
`TINY`		Smallest positive number in the numeric model
`UBOUND`		Upper dimension bounds of an array

5.1.2. Elemental Functions

Many intrinsic functions, and the MVBITS subroutine, can be referenced elementally; that is, the intrinsic is called with one or more array arguments and yields an array result.

The Fortran standard elemental functions are as follows:

Name		Information returned or operation
`ABS`		Absolute value
`ACHAR`		Character in given position in ASCII collating sequence
`ACOS`		Arccosine
`ADJUSTL`		Adjust a string left
`ADJUSTR`		Adjust a string right
`AIMAG`		Imaginary part of a complex number
`AINT`		Truncation to whole number
`ANINT`		Nearest whole number
`ASIN`		Arcsine
`ATAN`		Arctangent
`ATAN2`		Arctangent of a nonzero complex value
`BTEST`		Bit testing
`CEILING`		Least integer greater than or equal to a given real number
`CHAR`		Character in given position in the collating sequence used by this compiler
`CMPLX`		Conversion to complex type
`CONJG`		Conjugate of a complex number
`COS`		Cosine
`COSH`		Hyperbolic cosine
`DBLE`		Conversion to double-precision real type
`DIM`		Positive difference
`DPROD`		Double-precision real product
`EXP`		Exponential
`EXPONENT`		Exponent part of a numeric model number
`FLOOR`		Greatest integer less than or equal to a given real number
`FRACTION`		Fraction part of a numeric model number
`IACHAR`		Position of a character in the ASCII collating sequence
`IAND`		Logical `AND`
`IBCLR`		Clear a bit
`IBITS`		Bit extraction
`IBSET`		Set a bit
`ICHAR`		Position of a character in the collating sequence used by the compiler
`IEOR`		Exclusive `OR`
`INDEX`		Starting position of a substring
`INT`		Conversion to integer type
`IOR`		Inclusive `OR`
`ISHFT`		Logical shift
`ISHFTC`		Circular shift
`LEN_TRIM`		Length without trailing blank characters
`LGE`		Lexically greater than or equal
`LGT`		Lexically greater than
`LLE`		Lexically less than or equal
`LLT`		Lexically less than
`LOG`		Natural logarithm
`LOG10`		Common logarithm (base 10)
`LOGICAL`		Convert between objects of type logical with different kind type parameters
`MAX`		Maximum value
`MERGE`		Merge under mask
`MIN`		Minimum value
`MOD`		Remainder function
`MODULO`		Modulo function
`NEAREST`		Nearest different machine-representable number in given direction
`NINT`		Nearest integer
`NOT`		Logical complement
`REAL`		Conversion to real type
`RRSPACING`		Reciprocal of the relative spacing of numeric model numbers near given number
`SCALE`		Multiply a real by its base to an integer power
`SCAN`		Scan a string for a character in a set
`SET_EXPONENT`		Set exponent part of a numeric model number
`SIGN`		Transfer of sign
`SIN`		Sine
`SINH`		Hyperbolic sine
`SPACING`		Absolute spacing of numeric model numbers near a given number
`SQRT`		Square root
`TAN`		Tangent
`TANH`		Hyperbolic tangent
`VERIFY`		Verify the set of characters in a string

5.1.3. Transformational Functions

Transformational procedures have either a dummy argument that is array valued (for example, the SUM function) or an actual argument that is array valued without causing an elemental interpretation (for example, the SHAPE function). A transformational function transforms an array actual argument into a scalar result or another array, rather than applying the operation element-by-element.

The Fortran standard transformational functions are as follows:

Name		Information returned or operation
`ALL`		True if all values are true
`ANY`		True if any value is true
`COUNT`		Number of true elements in an array
`CSHIFT`		Circular shift
`DOT_PRODUCT`		Dot product of two rank one arrays
`EOSHIFT`		End-off shift
`MATMUL`		Matrix multiplication
`MAXLOC`		Location of a maximum value in an array
`MAXVAL`		Maximum value in an array
`MINLOC`		Location of a minimum value in an array
`MINVAL`		Minimum value in an array
`NULL`		Return a disassociated pointer
`PACK`		Pack an array into an array of rank one
`PRODUCT`		Product of array elements
`REPEAT`		Repeated concatenation
`RESHAPE`		Reshape an array
`SELECTED_INT_KIND`		Integer kind type parameter, given range
`SELECTED_REAL_KIND`		Real kind type parameter, given range
`SPREAD`		Replicates array by adding a dimension
`SUM`		Sum of array elements
`TRANSFER`		Treat first argument as if of type of second argument
`TRANSPOSE`		Transpose an array of rank two
`TRIM`		Remove trailing blank characters
`UNPACK`		Unpack an array of rank one into an array under a mask

5.1.4. Subroutines

An intrinsic subroutine is referenced by the CALL statement that uses its name explicitly. The name of an intrinsic subroutine cannot be used as an actual argument. MVBITS is an elemental subroutine.

The Fortran standard intrinsic subroutines are as follows:

Name		Purpose
`CPU_TIME`		Returns the processor time
`DATE_AND_TIME`		Obtains date and time
`MVBITS`		Copies bits from one bit manipulation model integer to another
`RANDOM_NUMBER`		Returns pseudorandom number
`RANDOM_SEED`		Initializes or restarts the pseudorandom number generator
`SYSTEM_CLOCK`		Obtains data from the system clock

5.1.5. Intrinsic Procedures to Support IEEE Floating-point Arithmetic (EXTENSION)

The intrinsic procedures described in this section support the IEEE Standard for Binary Floating-point Arithmetic.

Note: The intrinsic procedures to support IEEE floating-point arithmetic are supported on all IRIX platforms. See the man pages for each routine for more implementation information.

The IEEE intrinsic procedures allow you to obtain, alter, and restore the floating-point status flags. For example, they allow a procedure to save the current floating-point state as a single word on entry to a procedure and to restore the floating-point state before returning to the caller.

The IEEE intrinsic procedures are as follows:

Name	Information returned or operation
`CLEAR_IEEE_EXCEPTION`	Clears floating-point exception indicator
`DISABLE_IEEE_INTERRUPT`	Disables floating-point interrupt
`ENABLE_IEEE_INTERRUPT`	Enables floating-point interrupt
`GET_IEEE_EXCEPTIONS`	Retrieves flags that represent the current floating-point exception status
`GET_IEEE_INTERRUPTS`	Retrieves flags that represent the current floating-point interrupt status
`GET_IEEE_ROUNDING_MODE`	Returns current floating-point rounding mode
`GET_IEEE_STATUS`	Retrieves flags that represent the current floating-point status
`IEEE_BINARY_SCALE`	Returns y multiplied by 2ⁿ
`IEEE_CLASS`	Returns the class to which x belongs
`IEEE_COPY_SIGN`	Returns x with the sign of y
`IEEE_EXPONENT`	Returns the unbiased exponent of x
`IEEE_FINITE`	Tests for x being greater than negative infinity and less than positive infinity
`IEEE_IS_NAN`	Tests for x being a NaN
`IEEE_INT`	Converts x to an integral value according to the rounding mode in effect
`IEEE_NEXT_AFTER`	Returns the next representable neighbor of x in the direction toward y
`IEEE_REAL`	Converts x to a real value according to the rounding mode in effect
`IEEE_REMAINDER`	Returns the remainder of the operation x/ y
`IEEE_UNORDERED`	Tests for x or y being a NaN
`INT_MULT_UPPER`	Multiplies unsigned integers and returns the uppermost bits
`SET_IEEE_EXCEPTION`	Sets floating-point exception indicator
`SET_IEEE_EXCEPTIONS`	Restores the floating-point status
`SET_IEEE_INTERRUPTS`	Restores floating-point interrupt status
`SET_IEEE_ROUNDING_MODE`	Restores floating-point rounding mode
`SET_IEEE_STATUS`	Restores floating-point status before
`TEST_IEEE_EXCEPTION`	Returns the state of a floating-point exception
`TEST_IEEE_INTERRUPT`	Returns the state of a floating-point interrupt

5.1.5.1. Using Named Constants

A number of the procedures named in Section 5.1.5, use named constants. On systems that support IEEE floating-point arithmetic, the named constants are provided in module FTN_IEEE_DEFINITIONS. To use this module, include the following statement in your program:

USE FTN_IEEE_DEFINITIONS

The FTN_IEEE_DEFINITIONS module must be used if you want to use named constants to pass values to IEEE intrinsic procedures or to interpret return values. The named constants should always be used as arguments to the appropriate procedures, as opposed to using hard-coded values, because the values represented by the named constants might not be the same on all architectures. SGI reserves the right to change the values represented by the named constants.

The named constants are available to you if the scoping unit from which they are referenced (or a parent scoping unit) has used the module FTN_IEEE_DEFINITIONS. The following paragraphs describe the named constants that are available to you and the systems upon which they are supported.

The following named constants allow you to access floating-point exception flags:

IEEE_XPTN_CRI_INVALID_OPND (supported only on Cray T90 systems that support IEEE floating-point arithmetic)
IEEE_XPTN_INEXACT_RESULT
IEEE_XPTN_UNDERFLOW
IEEE_XPTN_OVERFLOW
IEEE_XPTN_DIV_BY_ZERO
IEEE_XPTN_INVALID_OPR
IEEE_XPTN_ALL

The following named constants allow you to access floating-point interrupt flags:

IEEE_NTPT_CRI_INVALID_OPND (supported only on Cray T90 systems that support IEEE floating-point arithmetic)
IEEE_NTPT_INEXACT_RESULT
IEEE_NTPT_UNDERFLOW
IEEE_NTPT_OVERFLOW
IEEE_NTPT_DIV_BY_ZERO
IEEE_NTPT_INVALID_OPR
IEEE_NTPT_ALL

The following named constants allow you to access the floating-point rounding mode:

IEEE_RM_NEAREST
IEEE_RM_POS_INFINITY
IEEE_RM_ZERO
IEEE_RM_NEG_INFINITY

The following named constants allow you to determine the class of a floating-point value:

IEEE_CLASS_SIGNALING_NAN
IEEE_CLASS_QUIET_NAN
IEEE_CLASS_NEG_INFINITY
IEEE_CLASS_NEG_NORM_NONZERO
IEEE_CLASS_NEG_DENORM
IEEE_CLASS_NEG_ZERO
IEEE_CLASS_POS_ZERO
IEEE_CLASS_POS_DENORM
IEEE_CLASS_POS_NORM_NONZERO
IEEE_CLASS_POS_INFINITY

5.1.5.2. Renaming Intrinsic Procedures

Some of the IEEE intrinsic procedure names are long. This was done to avoid creating names that might be identical to names that already exist in user programs. If, however, an IEEE intrinsic procedure name conflicts with an existing user identifier, you can use the Fortran renaming capabilities to provide your own local name by following these steps:

Create a module that contains an INTRINSIC statement for each intrinsic procedure you wish to rename.
Reference this module name in a USE statement in a context in which you want to reference the intrinsic procedure. Use a rename clause on the USE statement for the intrinsic procedures you want to rename.

For example, to rename IEEE_IS_NAN to IS_NAN:

MODULE MY_NAMES
INTRINSIC IEEE_IS_NAN
END MODULE
PROGRAM MAIN
USE MY_NAMES, IS_NAN => IEEE_IS_NAN
...
! REFERENCES TO IS_NAN HERE
! ARE ACTUALLY TO IEEE_IS_NAN
....
END PROGRAM

5.1.6. Miscellaneous Procedures (EXTENSION)

The compiler implements many intrinsic procedures that are extensions to the Fortran standard. Consult the man page for each intrinsic to determine whether individual intrinsics are elemental, inquiry, transformational, or are an intrinsic subroutine.

Not all of the miscellaneous procedures are implemented on all platforms. See the man pages for each routine for more implementation information.

The following functions are extensions to the Fortran standard:

Name	Information returned or operation
`ACOSD`	Accepts cosine, returns degrees.
`ADD_AND_FETCH`, `AND_AND_FETCH`, `NAND_AND_FETCH`, `OR_AND_FETCH`, `SUB_AND_FETCH`, `XOR_AND_FETCH`	Performs full barrier operations with the second argument on the first arguments and returns the new value of the second argument.
`ASIND`	Accepts sine, returns degrees.
`ATAND`	Accepts tangent, returns degrees.
`ATAN2D`	Accepts tangent numerator and denominator, returns degrees.
`C_LOC`	Provides the address of a C or C++ language entity.
`CLOC`	Obtains the address of a character entity.
`COMPARE_AND_SWAP`	Compares arguments. If they are equal, the value of the third argument is stored into the first and the return value is TRUE. Otherwise, the return value is FALSE.
`COSD`	Accepts degrees as argument, returns cosine.
`COT`	Returns cotangent.
`CVMGM`	Test for minus (negative).
`CVMGN`	Test for nonzero.
`CVMGP`	Test for positive (or zero).
`CVMGZ`	Test for zero.
`CVMGT`	Test for `TRUE`.
`DSHIFTL`	Shifts double word left.
`DSHIFTR`	Shifts double word right.
`DSM_CHUNKSIZE`	Returns the chunk size (ignoring partial chunks) in the given dimension for each of `BLOCK`, `CYCLIC`, and asterisk (`*`) distributions.
`DSM_DISTRIBUTION_BLOCK`	Returns 0 (`FALSE`) or 1 (`TRUE`) for a query on whether or not the specified dimension has a `BLOCK` distribution.
`DSM_DISTRIBUTION_CYCLIC`	Returns 0 (`FALSE`) or 1 (`TRUE`) for a query on whether or not the specified dimension has a `CYCLIC` distribution.
`DSM_DISTRIBUTION_STAR`	Returns 0 (`FALSE`) or 1 (`TRUE`) for a query on whether or not the specified dimension has an asterisk (`*`) distribution.
`DSM_ISDISTRIBUTED`	Returns 0 (`FALSE`) or 1 (`TRUE`) for a query on whether or not array is distributed (regular or reshaped) or not.
`DSM_ISRESHAPED`	Returns 0 (`FALSE`) or 1 (`TRUE`) for a query on whether or not array is reshaped or not.
`DSM_NUMCHUNKS`	Returns the number of chunks (including partial chunks) in the given dim for each of `BLOCK`, `CYCLIC`, and asterisk (`*`) distributions.
`DSM_NUMTHREADS`	Returns the number of threads in the specified dimension of a distributed array.
`DSM_REM_CHUNKSIZE`	Returns the remaining chunk size from index to the end of the current chunk, inclusive of each end point. Essentially it is the distance from index to the end of that contiguous block, inclusive.
`DSM_THIS_CHUNKSIZE`	Returns the chunk size for the chunk containing the specified index for each of `BLOCK`, `CYCLIC`, and asterisk (`*`). This value may be different from `DSM_CHUNKSIZE` due to edge effects that can lead to a partial chunk.
`DSM_THIS_STARTINGINDEX`	Returns the starting index value of the chunk containing the supplied index.
`DSM_THIS_THREADNUM`	Returns the thread number for the chunk containing the given index value for each of `BLOCK`, `CYCLIC`, and asterisk (`*`) distributions.
`EQV`	Performs logical equivalence.
`EXIT`	Terminates program execution.
`FCD`	Constructs a character pointer in Fortran Character Descriptor (FCD) format.
`FETCH_AND_ADD`, `FETCH_AND_AND`, `FETCH_AND_NAND`, `FETCH_AND_OR`, `FETCH_AND_SUB`, `FETCH_AND_XOR`	Performs full barrier operations with the second argument on the first arguments and returns the old value of the first argument.
`FREE`	Deallocates memory.
`FP_CLASS`	Returns the class of an IEEE real argument.
`GETPOS`	Obtains file position.
`IBCHNG`	Reverses the value of a specified bit in an integer.
`IDATE`	Return date or time in numerical form.
`ILEN`	Returns the length of the two's complement representation of an integer.
`IMAG`	Returns imaginary part of a complex number.
`IRTC`	Returns clock register contents.
`ISHA`	Performs an arithmetic shift.
`ISHC`	Rotates an integer left or right.
`ISHL`	Performs a logical shift.
`ISNAN`	Tests for NaNs.
`LEADZ`	Counts number of leading 0 bits.
`LENGTH`	Returns the number of words successfully transferred.
`LOC`	Returns address of a variable.
`LOCK_TEST_AND_SET`	Performs lock-acquire operations.
`LOCK_RELEASE`	Performs lock-release operations.
`LOG2_IMAGES`	Returns the base 2 logarithm of the number of excecuting images.
`LONG`	Returns an `INTEGER(KIND=4)` value.
`LSHIFT`	Performs a left shift with zero fill.
`M@CLR`	Clears BML bit.
`M@LD`	Loads transposed bit matrix.
`M@LDMX`	Loads bit matrix and multiplies.
`M@MX`	Multiplies bit matrix.
`M@UL`	Unloads bit matrix.
`MALLOC`	Allocates memory on the heap.
`MY_PE`	Returns the number of the processing element (PE) that is executing.
`MEMORY_BARRIER`	Blocks memory loads and stores until processes finish.
`NUMARG`	Returns the number of arguments in a function or subprogram call.
`NUM_IMAGES`	Returns the number of images that are executing.
`POPCNT`	Counts number of set bits.
`POPPAR`	Computes bit population parity.
`QEXT`	Converts a number to quad precision.
`REM_IMAGES`	Returns `MOD(NUM_IMAGES(), 2**LOG2_IMAGES()).`
`REMOTE_WRITE_BARRIER`	Blocks processor until remote writes have finished.
`RSHIFT`	Performs a right shift with zero fill.
`SECNDS`	Returns the time in seconds.
`SHIFTA`	Performs an arithmetic shift.
`SHORT`	Returns an `INTEGER(KIND=2)` value.
`SIND`	Accepts degrees, returns sine.
`SIZEOF`	Returns bytes of storage.
`SYNC_IMAGES`	Synchronizes images.
`SYNCHRONIZE`	Performs full barrier atomic synchronization.
`TAND`	Accepts degrees, returns tangent.
`THIS_IMAGE`	Returns an image number.
`TIME`	Returns the current time as set within the system.
`UNIT`	Performs I/O functions.
`WRITE_MEMORY_BARRIER`	Blocks processor until remote writes have finished.
`ZEXT`	Extends the argument with zeros.

5.2. Argument Keywords

Intrinsic procedure references can use keyword arguments, as described in Section 4.7.4 in Chapter 4. A number of Fortran intrinsic procedure arguments are optional. Using keywords allows you to omit corresponding actual arguments. In the following example, the keyword form shown is used because the optional first argument SIZE is omitted:

CALL RANDOM_SEED(PUT=SEED_VALUE)

If you are using argument keywords, the position at which the first argument keyword appears determines whether others in the call must also appear in keyword form. If an argument keyword is used, any other required arguments to the right of that argument must also appear in keyword form.

The following examples show correct use of actual arguments:

CALL DOT_PRODUCT(VECTOR_A=ARRAY1, VECTOR_B=ARRAY2)
CALL DOT_PRODUCT(ARRAY1, VECTOR_B=ARRAY2)
CALL DOT_PRODUCT(ARRAY1, ARRAY2)

The following examples show incorrect use of actual arguments:

CALL DOT_PRODUCT(VECTOR_A=ARRAY1, ARRAY2)
CALL DOT_PRODUCT(ARRAY2)

Intrinsic procedure keywords (dummy argument names) have been made as consistent as possible, including using the same name in different intrinsic procedures for dummy arguments that play a corresponding or identical role. These include DIM, MASK, KIND, and BACK.

DIM is used, mostly in the array reduction functions and in some of the other array functions, to specify the array dimension involved. DIM must be a scalar integer value and usually is optional.
MASK is used, mostly, in the array functions, to mask out elements of an array that are not to be involved in the operation. For example, in the function SUM, any element of the array that is not to be included in the sum of the elements can be excluded by using an appropriate mask. The MASK must be a logical array with the same shape as the array it is masking; it usually is an optional argument.
KIND is an argument that is used mainly in the transfer and conversion functions to specify the kind type parameter of the function result. The KIND actual argument must be a scalar integer initialization expression, even in elemental references; it usually is optional.
BACK is an optional logical argument used in several of the intrinsic functions to specify reverse order (backward) processing. For example, if BACK=.TRUE. in the INDEX function, then the search is performed beginning from the right end of the string rather than the left end.

5.3. Representation Models

Some intrinsic functions compute values in relationship to how data is represented. These values are based upon and determined by the underlying representation model. There are three such models:

The bit model
The integer number system model
The real number system model

These models, and the corresponding functions that return values related to the models, allow development of robust and portable code. For example, by obtaining information about the spacing of real numbers, you can control the convergence of a numerical algorithm so that the code achieves maximum accuracy while attaining convergence.

The models themselves apply to the compilers running on any platform. The values that go into these models, however, are platform-specific. Please see the models(3i) man page for information about how these models apply to the various platforms that the compiler supports.

5.4. Intrinsic Procedure Summary

This section summarizes the syntax of each intrinsic procedure. These tables are meant to supplement, not replace, the intrinsic procedure man pages. For more information on any of the intrinsics listed in these tables, enter man intrinsic_name at your system prompt.

Some intrinsic functions have both generic and specific names. The intrinsic functions that have specific names can be called with those names as well as with the generic names. To pass an intrinsic procedure as an actual argument, however, you must use the specific name. The following table shows the specific intrinsic procedure names available in the compiler. Some of the specific intrinsic names are the same as the generic names.

The argument names shown are the keywords for keyword argument calls. All of the optional arguments are enclosed in brackets ( [ ] ).

The following table shows the intrinsic procedures that the compiler supports both as part of the Fortran standard and as extensions to the standard. If the procedure has both a generic and a specific name, the generic name is shown first, and the specific names are listed underneath.

Table 5-1. Intrinsic procedures

Procedure name

Arguments

ABS
  ABS
  DABS
  QABS
  IABS
  IIABS
  JIABS
  KIABS
  CABS
  CQABS
  CDABS

([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)

ACHAR

([I=]i)

ACOS
  ACOS
  DACOS
  QACOS

([X=]x)
([X=]x)
([X=]x)
([X=]x)

ACOSD
  ACOSD
  DACOSD
  QACOSD

([X=]x)
([X=]x)
([X=]x)
([X=]x)

ADD_AND_FETCH

([I=]i, [J=]j)

ADJUSTL

([STRING=]string)

ADJUSTR

([STRING=]string)

AIMAG, IMAG
  AIMAG
  DIMAG
  QIMAG

([Z=]z)
([Z=]z)
([Z=]z)
([Z=]z)

AINT
  AINT
  DINT
  QINT

([A=]a [,[KIND=]kind])
([A=]a [,[KIND=]kind])
([A=]a)
([A=]a)

ALL

([MASK=]mask [,[DIM=]dim])

ALLOCATED

([ARRAY=]array)

AND

([I=]i, [J=]j)

AND_AND_FETCH

([I=]i, [J=]j)

ANINT
  ANINT
  DNINT
  QNINT

([A=]a [,[KIND=]kind])
([A=]a [,[KIND=]kind])
([A=]a)
([A=]a)

ANY

([MASK=]mask [,[DIM=]dim])

ASIN
  ASIN
  DASIN
  QASIN

([X=]x)
([X=]x)
([X=]x)
([X=]x)

ASIND
  ASIND
  DASIND
  QASIND

([X=]x)
([X=]x)
([X=]x)
([X=]x)

ASSOCIATED

([POINTER=]pointer [,[TARGET=]target])

ATAN
  ATAN
  DATAN
  QATAN

([X=]x)
([X=]x)
([X=]x)
([X=]x)

ATAND
  ATAND
  DATAND
  QATAND

([X=]x)
([X=]x)
([X=]x)
([X=]x)

ATAN2
  ATAN2
  DATAN2
  QATAN2

([Y=]y, [X=]x)
([Y=]y, [X=]x)
([Y=]y, [X=]x)
([Y=]y, [X=]x)

ATAN2D
  ATAN2D
  DATAN2D
  QATAN2D

([Y=]y, [X=]x)
([Y=]y, [X=]x)
([Y=]y, [X=]x)
([Y=]y, [X=]x)

BIT_SIZE

([I=]i)

BTEST
  BTEST
  BITEST
  BJTEST
  BKTEST

([I=]i, [POS=]pos)
([I=]i, [POS=]pos)
([I=]i, [POS=]pos)
([I=]i, [POS=]pos)
([I=]i, [POS=]pos)

CEILING

([A=]a [,[KIND=]kind])

CHAR

([I=]i [,[KIND=]kind])

CLEAR_IEEE_EXCEPTION

([EXCEPTION=]exception)

C_LOC

([X=]x)

CLOC

([C=]c)

CLOCK

()

CMPLX
  DCMPLX
  QCMPLX

([X=]x [,[Y=]y] [,[KIND=]kind])
([X=]x [,[Y=]y])
([X=]x [,[Y=]y])

COMPARE_AND_SWAP

([I=]i, [J=]j)

COMPL

([I=]i)

CONJG
  CONJG
  DCONJG
  QCONJG

([Z=]z)
([Z=]z)
([Z=]z)
([Z=]z)

COS
  COS
  DCOS
  QCOS
  CCOS
  CDCOS

([X=]x)
([X=]x)
([X=]x)
([X=]x)
([X=]x)
([X=]x)

COSD
  COSD
  DCOSD
  QCOSD

([X=]x)
([X=]x)
([X=]x)
([X=]x)

COSH
  COSH
  DCOSH
  QCOSH

([X=]x)
([X=]x)
([X=]x)
([X=]x)

COT
  COT
  COTAN
  DCOT
  DCOTAN
  QCOT
  QCOTAN

([X=]x)
([X=]x)
([X=]x)
([X=]x)
([X=]x)
([X=]x)
([X=]x)

COUNT

([MASK=]mask [,[DIM=]dim])

CPU_TIME

([TIME=]time)

CSHIFT

([ARRAY=]array, [SHIFT=]shift [,[DIM=]dim])

CSMG

([I=]i, [J=]j, [K=]k)

CVMGM

([I=]i, [J=]j, [K=]k)

CVMGN

([I=]i, [J=]j, [K=]k)

CVMGP

([I=]i, [J=]j, [K=]k)

CVMGT

([I=]i, [J=]j, [K=]k)

CVMGZ

([I=]i, [J=]j, [K=]k)

DATE, JDATE

()

DATE_AND_TIME

([[DATE=]date] [,[TIME=]time] [,[ZONE=]zone] [,[VALUES=]values])

DBLE
  DFLOAT
  DFLOATI
  DFLOATJ
  DFLOATK
  QFLOAT
  QFLOATI
  QFLOATJ
  QFLOATK

([A=]a)
([A=]a [,[KIND=]kind])
([A=]a [,[KIND=]kind])
([A=]a [,[KIND=]kind])
([A=]a [,[KIND=]kind])
([A=]a [,[KIND=]kind])
([A=]a [,[KIND=]kind])
([A=]a [,[KIND=]kind])
([A=]a [,[KIND=]kind])

DIGITS

([X=]x)

DIM
  DIM
  DDIM
  QDIM
  IDIM
  IIDIM
  JIDIM
  KIDIM

([X=]x, [Y=]y)
([X=]x, [Y=]y)
([X=]x, [Y=]y)
([X=]x, [Y=]y)
([X=]x, [Y=]y)
([X=]x, [Y=]y)
([X=]x, [Y=]y)
([X=]x, [Y=]y)

DISABLE_IEEE_INTERRUPT

([INTERRUPT=]interrupt)

DOT_PRODUCT

([VECTOR_A=]vector_a, [VECTOR_B=]vector_b)

DPROD
  QPROD

([X=]x, [Y=]y)
([X=]x, [Y=]y)

DSHIFTL

([I=]i, [J=]j, [K=]k)

DSHIFTR

([I=]i, [J=]j, [K=]k)

DSM_CHUNKSIZE

([ARRAY=]array, [DIM=]dim)

DSM_DISTRIBUTION_BLOCK

([ARRAY=]array, [DIM=]dim)

DSM_DISTRIBUTION_CYCLIC

([ARRAY=]array, [DIM=]dim)

DSM_DISTRIBUTION_STAR

([ARRAY=]array, [DIM=]dim)

DSM_ISDISTRIBUTED

([ARRAY=]array)

DSM_ISRESHAPED

([ARRAY=]array)

DSM_NUMCHUNKS

([ARRAY=]array, [DIM=]dim)

DSM_NUMTHREADS

([ARRAY=]array, [DIM=]dim)

DSM_REM_CHUNKSIZE

([ARRAY=]array, [DIM=]dim, [INDEX=]index)

DSM_THIS_CHUNKSIZE

([ARRAY=]array, [DIM=]dim, [INDEX=]index)

DSM_THIS_STARTINGINDEX

([ARRAY=]array, [DIM=]dim, [INDEX=]index)

DSM_THIS_THREADNUM

([ARRAY=]array, [DIM=]dim, [INDEX=]index)

ENABLE_IEEE_INTERRUPT

([INTERRUPT=]interrupt)

EOSHIFT

([ARRAY=]array, [SHIFT=]shift [,[BOUNDARY=]bound] [,[DIM=]dim])

EPSILON

([X=]x)

EQV

([I=]i, [J=]j)

EXIT

([STATUS=]status)

EXP
  EXP
  DEXP
  QEXP
  CEXP
  CDEXP
  CQDEXP

([X=]x)
([X=]x)
([X=]x)
([X=]x)
([X=]x)
([X=]x)
([X=]x)

EXPONENT

([X=]x)

FCD

([I=]i, [J=]j)

FETCH_AND_ADD

([I=]i, [J=]j)

FETCH_AND_AND

([I=]i, [J=]j)

FETCH_AND_NAND

([I=]i, [J=]j)

FETCH_AND_OR

([I=]i, [J=]j)

FETCH_AND_SUB

([I=]i, [J=]j)

FETCH_AND_XOR

([I=]i, [J=]j)

FLOOR

([A=]a [,[KIND=]kind])

FP_CLASS

([X=]x)

FRACTION

([X=]x)

FREE

([P=]iptr)

GET_IEEE_EXCEPTIONS

([STATUS=]status)

GET_IEEE_INTERRUPTS

([STATUS=]status)

GET_IEEE_ROUNDING_MODE

([ROUNDING_MODE=]rounding_mode)

GET_IEEE_STATUS

([STATUS=]status)

GETPOS

([I=]i)

HUGE

([X=]x)

IACHAR

([C=]c)

IAND
  IIAND
  JIAND
  KIAND

([I=]i, [J=]j)
([I=]i, [J=]j)
([I=]i, [J=]j)
([I=]i, [J=]j)

IBCHNG
  IIBCHNG
  JIBCHNG
  KIBCHNG

([I=]i, [POS=]pos)
([I=]i, [POS=]pos)
([I=]i, [POS=]pos)
([I=]i, [POS=]pos)

IBCLR
  IIBCLR
  JIBCLR
  KIBCLR

([I=]i, [POS=]pos)
([I=]i, [POS=]pos)
([I=]i, [POS=]pos)
([I=]i, [POS=]pos)

IBITS
  IIBITS
  JIBITS
  KIBITS

([I=]i, [POS=]pos, [LEN=]len)
([I=]i, [POS=]pos, [LEN=]len)
([I=]i, [POS=]pos, [LEN=]len)
([I=]i, [POS=]pos, [LEN=]len)

IBSET
  IIBSET
  JIBSET
  KIBSET

([I=]i, [POS=]pos)
([I=]i, [POS=]pos)
([I=]i, [POS=]pos)
([I=]i, [POS=]pos)

ICHAR

([C=]c)

IDATE

([IMON=]imon, [IDAY=]iday, [IYEAR=]iyear)

IEEE_BINARY_SCALE

([Y=]y, [N=]n)

IEEE_CLASS

([X=]x)

IEEE_COPY_SIGN

([X=]x, [Y=]y)

IEEE_EXPONENT

([X=]x [,[Y=]y])

IEEE_FINITE

([X=]x)

IEEE_INT

([X=]x [,[Y=]y])

IEEE_IS_NAN

([X=]x)

IEEE_NEXT_AFTER

([X=]x, [Y=]y)

IEEE_REAL

([X=]x [,[Y=]y])

IEEE_REMAINDER

([X=]x, [Y=]y)

IEEE_UNORDERED

([X=]x, [Y=]y)

IEOR
  IIEOR
  JIEOR
  KIEOR

([I=]i, [J=]j)
([I=]i, [J=]j)
([I=]i, [J=]j)
([I=]i, [J=]j)

ILEN

([I=]i)

INDEX

([STRING=]string, [SUBSTRING=]substring [,[BACK=]back])

INT
  INT2
  INT4
  INT8
  IINT
  JINT
  KINT
  IDINT
  IIDINT
  JIDINT
  KIDINT
  IQINT
  IIQINT
  JIQINT
  KIQINT
  IFIX
  IIFIX
  JFIX
  JIFIX

([A=]a [,[KIND=]kind])
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)

INT_MULT_UPPER

([I=]i, [J=]j)

INT24

([I=]i)

IOR
  IIOR
  JIOR
  KIOR

([I=]i, [J=]j)
([I=]i, [J=]j)
([I=]i, [J=]j)
([I=]i, [J=]j)

IRTC

()

ISHA
  IISHA
  JISHA
  KISHA

([I=]i, [SHFT=]shift)
([I=]i, [SHFT=]shift)
([I=]i, [SHFT=]shift)
([I=]i, [SHFT=]shift)

ISHC
  IISHC
  JISHC
  KISHC

([I=]i, [SHIFT=]shift)
([I=]i, [SHIFT=]shift)
([I=]i, [SHIFT=]shift)
([I=]i, [SHIFT=]shift)

ISHL
  IISHL
  JISHL
  KISHL

([I=]i, [SHIFT=]shift)
([I=]i, [SHIFT=]shift)
([I=]i, [SHIFT=]shift)
([I=]i, [SHIFT=]shift)

ISHFT
  IISHFT
  JISHFT
  KISHFT

([I=]i, [SHIFT=]shift)
([I=]i, [SHIFT=]shift)
([I=]i, [SHIFT=]shift)
([I=]i, [SHIFT=]shift)

ISHFTC
  IISHFTC
  JISHFTC
  KISHFTC

([I=]i, [SHIFT=]shift [,[SIZE=]size])
([I=]i, [SHIFT=]shift [,[SIZE=]size])
([I=]i, [SHIFT=]shift [,[SIZE=]size])
([I=]i, [SHIFT=]shift [,[SIZE=]size])

ISNAN

([X=]x)

KIND

([X=]x)

LBOUND

([ARRAY=]array [,[DIM=]dim])

LEADZ

([I=]i)

LEN

([STRING=]string)

LEN_TRIM

([STRING=]string)

LENGTH

([I=]i)

LGE

([STRING_A=]string_a, [STRING_B=]string_b)

LGT

([STRING_A=]string_a, [STRING_B=]string_b)

LLE

([STRING_A=]string_a, [STRING_B=]string_b)

LLT

([STRING_A=]string_a, [STRING_B=]string_b)

LOC

([I=]i)

LOCK_RELEASE

([I=]i)

LOCK_TEST_AND_SET

([I=]i, [J=]j)

LOG
  ALOG
  DLOG
  QLOG
  CLOG
  CDLOG

([X=]x)
([X=]x)
([X=]x)
([X=]x)
([X=]x)
([X=]x)

LOG2_IMAGES

()

LOG10
  ALOG10
  DLOG10
  QLOG10

([X=]x)
([X=]x)
([X=]x)
([X=]x)

LOGICAL

([L=]l [,[KIND=]kind])

LONG

([A=]a)

LSHIFT

([I=]i, [SHIFT=]shift)

M@CLR

()

M@LD

([X=]x)

M@LDMX

([X=]x, [Y=]y)

M@MX

([X=]x [,[Y=]y])

M@UL

()

MALLOC

([N=]nbytes)

MASK

([I=]i)

MATMUL

([MATRIX_A=]matrix_a, [MATRIX_B=]matrix_b)

MAX
  MAX0
  AMAX1
  DMAX1
  QMAX1
  MAX1
  AMAX0

([A1=]a1, [A2=]a2 [,[A3=]a3]...)
([A1=]a1, [A2=]a2 [,[A3=]a3]...)
([A1=]a1, [A2=]a2 [,[A3=]a3]...)
([A1=]a1, [A2=]a2 [,[A3=]a3]...)
([A1=]a1, [A2=]a2 [,[A3=]a3]...)
([A1=]a1, [A2=]a2 [,[A3=]a3]...)
([A1=]a1, [A2=]a2 [,[A3=]a3]...)

MAXEXPONENT

([X=]x)

MAXLOC

([ARRAY=]array [,[DIM=]dim] [,[MASK=]mask])

MAXVAL

([ARRAY=]array [,[DIM=]dim] [,[MASK=]mask])

MEMORY_BARRIER

()

MERGE

([TSOURCE=]tsource, [FSOURCE=]fsource, [MASK=]mask)

MIN
  MIN0
  AMIN1
  DMIN1
  QMIN1
  MIN1
  AMIN0

([A1=]a1, [A2=]a2 [,[A3=]a3]...)
([A1=]a1, [A2=]a2 [,[A3=]a3]...)
([A1=]a1, [A2=]a2 [,[A3=]a3]...)
([A1=]a1, [A2=]a2 [,[A3=]a3]...)
([A1=]a1, [A2=]a2 [,[A3=]a3]...)
([A1=]a1, [A2=]a2 [,[A3=]a3]...)
([A1=]a1, [A2=]a2 [,[A3=]a3]...)

MINEXPONENT

([X=]x)

MINLOC

([ARRAY=]array [,[DIM=]dim] [,[MASK=]mask])

MINVAL

([ARRAY=]array [,[DIM=]dim] [,[MASK=]mask])

MOD
  MOD
  AMOD
  DMOD
  IMOD
  JMOD
  KMOD
  QMOD

([A=]a, [P=]p)
([A=]a, [P=]p)
([A=]a, [P=]p)
([A=]a, [P=]p)
([A=]a, [P=]p)
([A=]a, [P=]p)
([A=]a, [P=]p)
([A=]a, [P=]p)

MODULO

([A=]a, [P=]p)

MVBITS

([FROM=]from, [FROMPOS=]frompos, [LEN=]len, [TO=]to, [TOPOS=]topos)

MY_PE

()

NAND_AND_FETCH

([I=]i, [J=]j)

NEAREST

([X=]x, [S=]s)

NEQV

([I=]i, [J=]j)

NINT
  NINT
  IDNINT
  ININT
  IQNINT
  JNINT
  KNINT

([A=]a [,[KIND=]kind])
([A=]a [,[KIND=]kind])
([A=]a [,[KIND=]kind])
([A=]a [,[KIND=]kind])
([A=]a [,[KIND=]kind])
([A=]a [,[KIND=]kind])

NOT
  INOT
  JNOT
  KNOT

([I=]i)
([I=]i)
([I=]i)
([I=]i)

NULL

([[MOLD=]mold])

NUMARG

()

NUM_IMAGES

()

OR

([I=]i, [J=]j)

OR_AND_FETCH

([I=]i, [J=]j)

PACK

([ARRAY=]array, [MASK=]mask [,[VECTOR=]vector])

POPCNT

([I=]i)

POPPAR

([I=]i)

PRECISION

([X=]x)

PRESENT

([A=]a)

PRODUCT

([ARRAY=]array [,[DIM=]dim] [,[MASK=]mask])

QEXT

([A=]a)

RADIX

([X=]x)

RANDOM_NUMBER

([HARVEST=]harvest)

RANDOM_SEED

([[SIZE=]size] [,[PUT=]put] [,[GET=]get])

RAN
  RANDU
  RANF
  RANGET
  RANSET

([I=]i)
([I1=]i1, [I2=]i2, [X=]x)
()
([I=]i)
([I=]i)

RANGE

([X=]x)

REAL
  DREAL
  QREAL
  FLOAT
  FLOATI
  FLOATJ
  FLOATK
  DFLOAT
  DFLOATI
  DFLOATJ
  DFLOATK
  QFLOAT
  QFLOATI
  QFLOATJ
  QFLOATK
  SNGL
  SNGLQ

([A=]a [,[KIND=]kind])
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)
([A=]a)

REM_IMAGES

()

REMOTE_WRITE_BARRIER

()

REPEAT

([STRING=]string, [NCOPIES=]ncopies)

RESHAPE

([SOURCE=]source, [SHAPE=]shape [,[PAD=]pad] [,[ORDER=]order])

RRSPACING

([X=]x)

RSHIFT

([I=]i, [NEGATIVE_SHIFT=]negative_shift)

RTC

()

SCALE

([X=]x, [I=]i)

SCAN

([STRING=]string, [SET=]set [,[BACK=]back])

SECNDS

([X=]x)

SELECTED_INT_KIND

([R=]r)

SELECTED_REAL_KIND

([[P=]p] [,[R=]r])

SET_EXPONENT

([X=]x, [I=]i)

SET_IEEE_EXCEPTION

([EXCEPTION=]exception)

SET_IEEE_EXCEPTIONS

([STATUS=]status)

SET_IEEE_INTERRUPTS

([STATUS=]status)

SET_IEEE_ROUNDING_MODE

([ROUNDING_MODE=]rounding_mode)

SET_IEEE_STATUS

([STATUS=]status)

SHAPE

([STATUS=]status)

SHIFT

([I=]i, [J=]j)

SHIFTA

([I=]i, [J=]j)

SHIFTL

([I=]i, [J=]j)

SHIFTR

([I=]i, [J=]j)

SHORT

([A=]a)

SIGN
  ISIGN
  DSIGN
  IISIGN
  JISIGN
  KISIGN
  QSIGN

([A=]a, [B=]b)
([A=]a, [B=]b)
([A=]a, [B=]b)
([A=]a, [B=]b)
([A=]a, [B=]b)
([A=]a, [B=]b)
([A=]a, [B=]b)

SIN
  SIN
  DSIN
  QSIN
  CSIN
  CDSIN
  CQSIN

([X=]x)
([X=]x)
([X=]x)
([X=]x)
([X=]x)
([X=]x)
([X=]x)

SIND
  SIND
  DSIND
  QSIND

([X=]x)
([X=]x)
([X=]x)
([X=]x)

SINH
  SINH
  DSINH
  QSINH

([X=]x)
([X=]x)
([X=]x)
([X=]x)

SIZE

([ARRAY=]array [,[DIM=]dim])

SIZEOF

([X=]x)

SPACING

([X=]x)

SPREAD

([SOURCE=]source, [DIM=]dim, [NCOPIES=]ncopies)

SQRT
  SQRT
  DSQRT
  QSQRT
  CSQRT
  CDSQRT
  CQSQRT

([X=]x)
([X=]x)
([X=]x)
([X=]x)
([X=]x)
([X=]x)
([X=]x)

SUB_AND_FETCH

([I=]i, [J=]j)

SUM

([ARRAY=]array [,[DIM=]dim] [,[MASK=]mask])

SYNC_IMAGES

([IMAGE=]image)

SYNCHRONIZE

()

SYSTEM_CLOCK

([[COUNT=]count] [,[COUNT_RATE=]count_rate] [,[COUNT_MAX=]count_max])

TAN
  TAN
  DTAN
  QTAN

([X=]x)
([X=]x)
([X=]x)
([X=]x)

TAND
  TAND
  DTAND
  QTAND

([X=]x)
([X=]x)
([X=]x)
([X=]x)

TANH
  TANH
  DTANH
  QTANH

([X=]x)
([X=]x)
([X=]x)
([X=]x)

TEST_IEEE_EXCEPTION

([EXCEPTION=]exception)

TEST_IEEE_INTERRUPT

([INTERRUPT=]interrupt)

THIS_IMAGE

([[ARRAY=]array [,[DIM=]dim]])

TIME

([BUF=]buf)

TINY

([X=]x)

TRANSFER

([SOURCE=]source, [MOLD=]mold [,[SIZE=]size])

TRANSPOSE

([MATRIX=]matrix)

TRIM

([STRING=]string)

UBOUND

([ARRAY=]array [,[DIM=]dim])

UNIT

([I=]i)

UNPACK

([VECTOR=]vector, [MASK=]mask, [FIELD=]field)

VERIFY

([STRING=]string, [SET=]set [,[BACK=]back])

XOR

([I=]i, [J=]j)

XOR_AND_FETCH

([I=]i, [J=]j)

WRITE_MEMORY_BARRIER

()

ZEXT

([X=]x)

5.5. Man Pages

These man pages can be accessed online through the man(1) command.

Note: Many intrinsic procedures have both a vector and a scalar version. If a vector version of an intrinsic procedure exists, and the intrinsic is called within a vectorizable loop, the compiler uses the vector version of the intrinsic. For information on which intrinsic procedures vectorize, see intro_intrin(3i).

Prev	Table of Contents	Next
Chapter 4. Using Procedures		Chapter 6. Scope, Association, and Definition