SGI Techpubs Library

IRIX 6.5  »  Books  »  Developer  »  
MIPSpro Fortran Language Reference Manual, Volume 2
(document number: 007-3693-007 / published: 2002-11-19)    table of contents  |  additional info  |  download
find in page

Chapter 5. Intrinsic Procedures

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 n

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:

  1. Create a module that contains an INTRINSIC statement for each intrinsic procedure you wish to rename.

  2. 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).


MIPSpro Fortran Language Reference Manual, Volume 2
(document number: 007-3693-007 / published: 2002-11-19)    table of contents  |  additional info  |  download

    Front Matter
    About This Guide
    Chapter 1. Input and Output (I/O) Processing
    Chapter 2. Input and Output (I/O) Editing
    Chapter 3. Program Units
    Chapter 4. Using Procedures
    Chapter 5. Intrinsic Procedures
    Chapter 6. Scope, Association, and Definition
    Glossary
    Index


home/search | what's new | help