Converted from .HLP to .HTML by HLPTOHTML.

fortran .HLP

## ABS

ABS (number)

A function that returns the absolute value of the argument. The absolute value of a complex number, (X,Y), is the real value: (X**2 + Y**2)**(1/2).

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ABS | IIABS | INTEGER*2 | INTEGER*2 | | | | JIABS | INTEGER*4 | INTEGER*4 | | | | ABS | REAL*4 | REAL*4 | | | | DABS | REAL*8 | REAL*8 | | | | QABS | REAL*16 | REAL*16 | | | | CABS | COMPLEX*8 | REAL*4 | | | | CDABS | COMPLEX*16 | REAL*8 | | | | ZABS | COMPLEX*16 | REAL*8 | +------+---------+----------+------------+-------------+ See also the IABS intrinsic function.

## ACOS

ACOS (number)

A function that returns the arc cosine of the argument in radians. The absolute value of the argument must be less than or equal to 1.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ACOS | ACOS | REAL*4 | REAL*4 | | | | DACOS | REAL*8 | REAL*8 | | | | QACOS | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+

## ACOSD

ACOSD (real-number)

A function that returns the arc cosine of the argument in degrees. The value of the argument must be between 0 (exclusive) and 1 (inclusive).

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ACOSD | ACOSD | REAL*4 | REAL*4 | | | | DACOSD | REAL*8 | REAL*8 | | | | QACOSD | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+

## AIMAG

AIMAG (complex-number)

A function that returns the imaginary part of a complex number. The argument must be a COMPLEX*8 data type. The result is a REAL*4 data type.

## AINT

AINT (real-number)

A function that returns the largest integer whose absolute value does not exceed the absolute value of the argument and has the same sign as the argument.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | AINT | AINT | REAL*4 | REAL*4 | | | | DINT | REAL*8 | REAL*8 | | | | QINT | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+ See also the INT intrinsic function.

## AMAX0

AMAX0 (number, number, ...)

A function that returns the greatest of the values specified in the argument list.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | AMAX0 | AIMAX0 | INTEGER*2 | REAL*4 | | | | AJMAX0 | INTEGER*4 | REAL*4 | +------+---------+----------+------------+-------------+ See also the MAX intrinsic function.

## AMIN0

AMIN0 (number, number, ...)

A function that returns the lowest of the values specified in the argument list.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | AMIN0 | AIMIN0 | INTEGER*2 | REAL*4 | | | | AJMIN0 | INTEGER*4 | REAL*4 | +------+---------+----------+------------+-------------+ See also the MIN intrinsic function.

## ANINT

ANINT (real-number)

A function that returns the value of the integer nearest to the value of the argument.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ANINT | ANINT | REAL*4 | REAL*4 | | | | DNINT | REAL*8 | REAL*8 | | | | QNINT | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+ [x] is defined as the largest integer whose magnitude does not exceed the magnitude of x and whose sign is the same as that of x.

## ASIN

ASIN (real-number)

A function that returns the arc sine of the argument in radians. The absolute value of the argument must be less than or equal to 1.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ASIN | ASIN | REAL*4 | REAL*4 | | | | DASIN | REAL*8 | REAL*8 | | | | QASIN | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+

## ASIND

ASIND (real-number)

A function that returns the arc sine of the argument in degrees. The value of the argument must be between 0 (exclusive) and 1 (inclusive).

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ASIND | ASIND | REAL*4 | REAL*4 | | | | DASIND | REAL*8 | REAL*8 | | | | QASIND | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+

## ATAN

ATAN (real-number)

A function that returns the arc tangent of the argument in radians.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ATAN | ATAN | REAL*4 | REAL*4 | | | | DATAN | REAL*8 | REAL*8 | | | | QATAN | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+

## ATAND

ATAND (real-number)

A function that returns the arc tangent of the argument in degrees. The value of the argument must be greater than 0.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ATAND | ATAND | REAL*4 | REAL*4 | | | | DATAND | REAL*8 | REAL*8 | | | | QATAND | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+

## ATAN2

ATAN2 (real-number, real-number)

A function that returns the arc tangent of the quotient of the two arguments in radians. If both arguments are zero, the result is undefined. If the first argument is positive, the result is positive. If the first argument is negative, the result is negative. If the first argument is zero, the result is zero. If the second argument is zero, the absolute value of the result is pi/2.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | ATAN2 | ATAN2 | REAL*4 | REAL*4 | | | | DATAN2 | REAL*8 | REAL*8 | | | | QATAN2 | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+ The range of the result is -pi < result < pi.

## ATAN2D

ATAN2D (real-number, real-number)

A function that returns the arc tangent of the quotient of the two arguments in degrees. If both arguments are zero, the result is undefined. If the first argument is positive, the result is positive. If the first argument is negative, the result is negative. If the first argument is zero, the result is zero. If the second argument is zero, the absolute value of the result is 90 degrees. The value of the argument must be greater than zero.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | ATAN2D | ATAN2D | REAL*4 | REAL*4 | | | | DATAN2D | REAL*8 | REAL*8 | | | | QATAN2D | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+ The range of the result is -180 degrees < result < 180 degrees.

## BTEST

BTEST (integer, position)

A function that returns a logical value of true if the bit within the integer specified by position is set to 1. The low-order bit is position 0.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | BTEST | BITEST | INTEGER*2 | INTEGER*2 | | | | BJTEST | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+

## CHAR

CHAR (integer)

A function that returns the character associated with the ASCII value specified by the argument. The argument must be BYTE, LOGICAL*1, LOGICAL*2, LOGICAL*4, INTEGER*1, INTEGER*2, or INTEGER*4 in data type. The result must be CHARACTER in type. The input value must be in the range 0 to 255.

## CMPLX

CMPLX (number [,number])

A function that converts the argument(s) into a COMPLEX*8 value. If one argument is specified, the argument is converted into the real part of the complex value and the imaginary part becomes zero. If two arguments are specified, the first argument is converted into the real part of the complex value and the second argument is converted into the imaginary part of the complex value. If two arguments are specified, they must have the same data type.

+-------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +-------+---------+----------+------------+-------------+ | 1,2 | CMPLX | CMPLX | INTEGER*2 | COMPLEX*8 | | 1,2 | | CMPLX | INTEGER*4 | COMPLEX*8 | | 1,2 | | CMPLX | REAL*4 | COMPLEX*8 | | 1,2 | | CMPLX | REAL*8 | COMPLEX*8 | | 1,2 | | CMPLX | REAL*16 | COMPLEX*8 | | 1 | | CMPLX | COMPLEX*8 | COMPLEX*8 | | 1 | | CMPLX | COMPLEX*16 | COMPLEX*8 | +-------+---------+----------+------------+-------------+

## CONJG

CONJG (complex-number)

A function that returns the complex conjugate of the argument. If the argument is (X,Y), its complex conjugate is (X,-Y).

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | CONJG | CONJG | COMPLEX*8 | COMPLEX*8 | | | | DCONJG | COMPLEX*16 | COMPLEX*16 | +------+---------+----------+------------+-------------+

## COS

COS (number)

A function that returns the cosine of the argument. The argument must be in radians; it is treated modulo 2*pi.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | COS | COS | REAL*4 | REAL*4 | | | | DCOS | REAL*8 | REAL*8 | | | | QCOS | REAL*16 | REAL*16 | | | | CCOS | COMPLEX*8 | COMPLEX*8 | | | | CDCOS | COMPLEX*16 | COMPLEX*16 | | | | ZCOS | COMPLEX*16 | COMPLEX*16 | +------+---------+----------+------------+-------------+

## COSD

COSD (number)

A function that returns the cosine of the argument. The argument must be in degrees; it is treated modulo 360.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | COSD | COSD | REAL*4 | REAL*4 | | | | DCOSD | REAL*8 | REAL*8 | | | | QCOSD | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+

## COSH

COSH (real-number)

A function that returns the hyperbolic cosine of the argument.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | COSH | COSH | REAL*4 | REAL*4 | | | | DCOSH | REAL*8 | REAL*8 | | | | QCOSH | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+

## DATE

CALL DATE (buf)

buf Is a 9-byte variable, array, array element, or character substring.

A subroutine that gets the current date as set within the system. The date is returned as a 9-byte ASCII character string as follows:

dd-mmm-yy

If "buf" is numeric type and smaller than 9 bytes, data corruption can occur.

If "buf" is character type, its associated length is passed to the subroutine. If "buf" is smaller than 9 bytes, the subroutine truncates the date to fit in the specified length. Note that if a CHARACTER array is passed, the subroutine stores the date in the first array element, using the element length, not the length of the entire array. For example, consider the following:

CHARACTER*1 DAY(9) . . . CALL DATE(DAY)

The length of the first array element in CHARACTER array DAY is passed to the DATE subroutine. The subroutine then truncates the date to fit into the one-character element, producing an incorrect result.

## DBLE

DBLE (number)

A function that converts the argument into a REAL*8 value.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | DBLE | DBLE | INTEGER*2 | REAL*8 | | | | DBLE | INTEGER*4 | REAL*8 | | | | DBLE | REAL*4 | REAL*8 | | | | DBLE | REAL*8 | REAL*8 | | | | DBLEQ | REAL*16 | REAL*8 | | | | DBLE | COMPLEX*8 | REAL*8 | | | | DBLE | COMPLEX*16 | REAL*8 | +------+---------+----------+------------+-------------+

## DCMPLX

DCMPLX (number [,number])

A function that converts the argument(s) into a COMPLEX*16 value. If one argument is specified, the argument is converted into the real part of the complex value and the imaginary part becomes zero. If two arguments are specified, the first argument is converted into the real part of the complex value and the second argument is converted into the imaginary part of the complex value. If two arguments are specified, they must have the same data type.

+-------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +-------+---------+----------+------------+-------------+ | 1,2 | DCMPLX | DCMPLX | INTEGER*2 | COMPLEX*16 | | 1,2 | | DCMPLX | INTEGER*4 | COMPLEX*16 | | 1,2 | | DCMPLX | REAL*4 | COMPLEX*16 | | 1,2 | | DCMPLX | REAL*8 | COMPLEX*16 | | 1,2 | | DCMPLX | REAL*16 | COMPLEX*16 | | 1 | | DCMPLX | COMPLEX*8 | COMPLEX*16 | | 1 | | DCMPLX | COMPLEX*16 | COMPLEX*16 | +-------+---------+----------+------------+-------------+

## DFLOAT

DFLOAT (integer)

A function that converts the argument into a REAL*8 value.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | DFLOAT | DFLOTI | INTEGER*2 | REAL*8 | | | | DFLOTJ | INTEGER*4 | REAL*8 | +------+---------+----------+------------+-------------+

## DIM

DIM (number, number)

A function that returns the value of the first argument minus the minimum (MIN) of the two arguments.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | DIM | IIDIM | INTEGER*2 | INTEGER*2 | | | | JIDIM | INTEGER*4 | INTEGER*4 | | | | DIM | REAL*4 | REAL*4 | | | | DDIM | REAL*8 | REAL*8 | | | | QDIM | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+ See also the IDIM intrinsic function.

## DIMAG

DIMAG (imaginary)

A function that returns the imaginary part of a complex number. The argument must be a COMPLEX*16 data type. The result is a REAL*8 data type.

## DPROD

DPROD (real4-number, real4-number)

A function that returns the product of two REAL*4 values as a REAL*8 value.

## DREAL

DREAL (complex-number)

A function that returns the real part of a complex number. The argument must be a COMPLEX*16 data type. The result is a REAL*8 data type.

## EXIT

EXIT ([status])

A subroutine that terminates the program, closes all files, and returns you to DCL command level. The optional argument specifies the exit status of the program and defaults to SS\$_NORMAL (a value of 1 -- normal completion of program).

## EXP

EXP (exponent)

A function that returns e**X, where X is the value of the argument.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | EXP | EXP | REAL*4 | REAL*4 | | | | DEXP | REAL*8 | REAL*8 | | | | QEXP | REAL*16 | REAL*16 | | | | CEXP | COMPLEX*8 | COMPLEX*8 | | | | CDEXP | COMPLEX*16 | COMPLEX*16 | | | | ZEXP | COMPLEX*16 | COMPLEX*16 | +------+---------+----------+------------+-------------+

## FLOAT

FLOAT (integer)

A function that converts the argument to a REAL*4 value.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | FLOAT | FLOATI | INTEGER*2 | REAL*4 | | | | FLOATJ | INTEGER*4 | REAL*4 | +------+---------+----------+------------+-------------+

## IABS

IABS (number)

A function that returns the absolute value of the argument. The absolute value of a complex number, (X,Y), is the real value (X**2 + Y**2)**(1/2).

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | IABS | IIABS | INTEGER*2 | INTEGER*2 | | | | JIABS | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+ See also the ABS intrinsic function.

## IAND

IAND (integer, integer)

A function that performs a logical AND of the arguments on a bit by bit basis.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | IAND | IIAND | INTEGER*2 | INTEGER*2 | | | | JIAND | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+

## IARGCOUNT

IARGCOUNT ()

A function that returns the count of actual arguments passed to the current routine. The result is an INTEGER*4 data type. Note that functions with a type of CHARACTER, COMPLEX*16 or REAL*16 have an extra argument added used to return the function value.

## IARGPTR

IARGPTR ()

A function that returns a pointer to the actual argument list for the current routine. The result is an INTEGER*4 data type. The actual argument list is an array of INTEGER*4 values, the first of which contains the argument count.

## IBCLR

IBCLR (integer, position)

A function that returns the value of the first argument with the specified bit set to 0. The low-order bit is position 0.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | IBCLR | IIBCLR | INTEGER*2 | INTEGER*2 | | | | JIBCLR | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+

## IBITS

IBITS (integer, start-position, length)

A function that returns the value of the bits specified by start-position and end-position. The low-order bit is position 0.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 3 | IBITS | IIBITS | INTEGER*2 | INTEGER*2 | | | | JIBITS | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+

## IBSET

IBSET (integer, position)

A function that returns the value of the first argument with the specified bit set to 1. The low-order bit is position 0.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | IBSET | IIBSET | INTEGER*2 | INTEGER*2 | | | | JIBSET | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+

## ICHAR

ICHAR (character)

A function that returns the ASCII value of the argument. The argument must be a character expression with a length of one. The result is an INTEGER*4 data type.

## IDATE

IDATE (month,day,year)

A subroutine that returns three values representing the current date. The arguments must be defined as integers or integer array elements. The month is represented as the number of the month (1 - 12). The day is represented as the day of the month. The year is represented as the last two digits of the year.

## IDIM

IDIM (number, number)

A function that returns the value of the first argument minus the minimum (MIN) of the two arguments.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | IDIM | IIDIM | INTEGER*2 | INTEGER*2 | | | | JIDIM | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+ See also the DIM intrinsic function.

## IDINT

IDINT (number)

A function that returns the largest integer whose absolute value does not exceed the absolute value of the argument and has the same sign as the argument.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | IDINT | IIDINT | REAL*8 | INTEGER*2 | | | | JIDINT | REAL*8 | INTEGER*4 | +------+---------+----------+------------+-------------+ The function returns an INTEGER*4 value if the /I4 command qualifier is in effect; otherwise it returns an INTEGER*2 value.

## IDNINT

IDNINT (real-number)

A function that returns the value of the integer nearest to the value of the argument.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | IDNINT | IIDNNT | REAL*8 | INTEGER*2 | | | | JIDNNT | REAL*8 | INTEGER*4 | +------+---------+----------+------------+-------------+ The function returns an INTEGER*4 value if the /I4 command qualifier is in effect; otherwise it returns an INTEGER*2 value.

## IEOR

IEOR (integer, integer)

A function that performs an exclusive OR of the arguments on a bit by bit basis.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | IEOR | IIEOR | INTEGER*2 | INTEGER*2 | | | | JIEOR | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+

## IFIX

IFIX (real4-number)

A function that converts a real number to an integer.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | IFIX | IIFIX | REAL*4 | INTEGER*2 | | | | JIFIX | REAL*4 | INTEGER*4 | +------+---------+----------+------------+-------------+ The function returns an INTEGER*4 value if the /I4 command qualifier is in effect; otherwise it returns an INTEGER*2 value.

IIFIX can also be spelled HFIX (to comply with the MIA standard).

## IMAG

IMAG (complex-number)

A function that returns the imaginary part of a complex number. +------+-----------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+-----------+----------+------------+-------------+ | 1 | IMAG | AIMAG | COMPLEX*8 | REAL*4 | | | | DIMAG | COMPLEX*16 | REAL*8 | +--------------------------------------------------------+

## INDEX

INDEX (string, substring)

A function that searches a string for the first occurrence of a substring and returns the starting position of the substring as an INTEGER*4 value.

## INT

INT (number)

A function that returns the largest integer whose absolute value does not exceed the absolute value of the argument and has the same sign as the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | INT | IINT | REAL*4 | INTEGER*2 | | | | JINT | REAL*4 | INTEGER*4 | | | | IIDINT | REAL*8 | INTEGER*2 | | | | JIDINT | REAL*8 | INTEGER*4 | | | | IIQINT | REAL*16 | INTEGER*2 | | | | JIQINT | REAL*16 | INTEGER*4 | | | | JIQINT | COMPLEX*8 | INTEGER*2 | | | | JIQINT | COMPLEX*8 | INTEGER*4 | | | | JIQINT | COMPLEX*16 | INTEGER*2 | | | | JIQINT | COMPLEX*16 | INTEGER*4 | +------+---------+----------+------------+-------------+ The function returns an INTEGER*4 value if the /I4 command qualifier is in effect; otherwise it returns an INTEGER*2 value.

## IOR

IOR (integer, integer)

A function that performs a logical OR of the arguments on a bit by bit basis (bitwise inclusive OR). +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | IOR | IIOR | INTEGER*2 | INTEGER*2 | | | | JIOR | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+

## IQINT

IQINT (number)

A function that returns the largest integer whose absolute value does not exceed the absolute value of the argument and has the same sign as the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | IQINT | IIQINT | REAL*16 | INTEGER*2 | | | | JIQINT | REAL*16 | INTEGER*4 | +------+---------+----------+------------+-------------+ The function returns an INTEGER*4 value if the /I4 command qualifier is in effect; otherwise it returns an INTEGER*2 value.

## IQNINT

IQNINT (number)

A function that returns the value of the integer nearest to the value of the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | IQNINT | IIQNNT | REAL*16 | INTEGER*2 | | | | JIQNNT | REAL*16 | INTEGER*4 | +------+---------+----------+------------+-------------+ The function returns an INTEGER*4 value if the /I4 command qualifier is in effect; otherwise it returns an INTEGER*2 value.

## ISHFT

ISHFT (a1,a2)

Bitwise logical shift - a1 is an integer, a2 is the no-of-positions

A function that logically shifts a1 left (if a2 is positive) or right (if a2 is negative) by ABS(a2) bits. If ABS(a2) is greater than or equal to the length in bits of a1, the result is 0. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | ISHFT | IISHFT | INTEGER*2 | INTEGER*2 | | | | JISHFT | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+

## ISHFTC

ISHFTC (a1,a2,a3)

Bitwise circular shift - a1 is an integer, a2 is no-of-positions, and a3 is no-of-bits

A function that circularly shifts the rightmost a3 bits of a1 by a2 places; bits in a1 beyond the value specified by a3 are unaffected. The bits pushed off the left end replace those shifted from the right end. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 3 | ISHFTC | IISHFTC | INTEGER*2 | INTEGER*2 | | | | JISHFTC | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+

## ISIGN

ISIGN (value, sign)

A function that assigns the sign of the second argument to the absolute value of the first. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | ISIGN | IISIGN | INTEGER*2 | INTEGER*2 | | | | JISIGN | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+ See also the SIGN intrinsic function.

## LEN

LEN (character)

A function that returns the number of characters in the argument. The argument must be a character expression. The result is an INTEGER*4 value.

## LGE

LGE (character, character)

A function that returns a value of true if the first character string is greater than or equal to the second character string. The ASCII collating sequence determines the relationship between the arguments. The arguments must be character expressions. The result is a LOGICAL*4 value.

## LGT

LGT (character, character)

A function that returns a value of true if the first character string is greater than the second character string. The arguments must be character expressions. The ASCII collating sequence determines the relationship between the arguments.

## LLE

LLE (character, character)

A function that returns a value of true if the first character string is less than or equal to the second character string. The arguments must be character expressions. The ASCII collating sequence determines the relationship between the arguments.

## LLT

LLT (character, character)

A function that returns a value of true if the first character string is less than the second character string. The arguments must be character expressions. The ASCII collating sequence determines the relationship between the arguments.

## LOC

LOC (arg) Returns the actual storage address of a data element. The argument can be any data value. The result is an INTEGER*4 data type. In the case of global symbols, LOC returns the value of the symbol rather than its address.

The %LOC built-in function serves the same purpose as the LOC intrinsic.

## LOG

LOG (number)

A function that returns the natural log (base e) of the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | LOG | ALOG | REAL*4 | REAL*4 | | | | DLOG | REAL*8 | REAL*8 | | | | QLOG | REAL*16 | REAL*16 | | | | CLOG | COMPLEX*8 | COMPLEX*8 | | | | CDLOG | COMPLEX*16 | COMPLEX*16 | | | | ZLOG | COMPLEX*16 | COMPLEX*16 | +------+---------+----------+------------+-------------+ The argument for ALOG and DLOG must be greater than zero. The argument for CLOG and CDLOG must not be (0.,0.).

## LOG10

LOG10 (number)

A function that returns the common log (base 10) of the argument. The argument must be greater than zero. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | LOG10 | ALOG10 | REAL*4 | REAL*4 | | | | DLOG10 | REAL*8 | REAL*8 | | | | QLOG10 | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+ The argument for ALOG10, DLOG10, and QLOG10 must be greater than zero.

## MAX

MAX (number, number, ...)

A function that returns the greatest of the values specified in the argument list. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | MAX | IMAX0 | INTEGER*2 | INTEGER*2 | | | | JMAX0 | INTEGER*4 | INTEGER*4 | | | | AMAX1 | REAL*4 | REAL*4 | | | | DMAX1 | REAL*8 | REAL*8 | | | | QMAX1 | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+ See also the AMAX0, MAX0, and MAX1 intrinsic functions.

## MAX0

MAX0 (number, number, ...)

A function that returns the greatest of the values specified in the argument list. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | MAX0 | IMAX0 | INTEGER*2 | INTEGER*2 | | | | JMAX0 | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+ See also the MAX intrinsic function.

## MAX1

MAX1 (number, number, ...)

A function that returns the greatest of the values specified in the argument list. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | MAX1 | IMAX1 | REAL*4 | INTEGER*2 | | | | JMAX1 | REAL*4 | INTEGER*4 | +------+---------+----------+------------+-------------+ The function returns an INTEGER*4 value if the /I4 command qualifier is in effect; otherwise, it returns an INTEGER*2 value.

## MIN

MIN (number, number, ...)

A function that returns the lowest of the values specified in the argument list. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | MIN | IMIN0 | INTEGER*2 | INTEGER*2 | | | | JMIN0 | INTEGER*4 | INTEGER*4 | | | | AMIN1 | REAL*4 | REAL*4 | | | | DMIN1 | REAL*8 | REAL*8 | | | | QMIN1 | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+ See also the AMIN0, MIN0, and MIN1 intrinsic functions.

## MIN0

MIN0

A function that returns the lowest of the values specified in the argument list. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | MIN0 | IMIN0 | INTEGER*2 | INTEGER*2 | | | | JMIN0 | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+ See also the MIN intrinsic function.

## MIN1

MIN1

A function that returns the lowest of the values specified in the argument list. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | n | MIN1 | IMIN1 | REAL*4 | INTEGER*2 | | | | JMIN1 | REAL*4 | INTEGER*4 | +------+---------+----------+------------+-------------+

The function returns an INTEGER*4 value if the /I4 command qualifier is in effect; otherwise it returns an INTEGER*2 value.

## MOD

MOD (dividend, divisor)

A function that divides the first argument by the second and returns the remainder. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | MOD | IMOD | INTEGER*2 | INTEGER*2 | | | | JMOD | INTEGER*4 | INTEGER*4 | | | | AMOD | REAL*4 | REAL*4 | | | | DMOD | REAL*8 | REAL*8 | | | | QMOD | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+

## MVBITS

MVBITS (integer1, start1, len, integer2, start2)

A subroutine that moves bits from one location to another. Specify the arguments as follows:

integer1 An integer variable or array element that contains the bits to be transferred.

start1 An integer expression that identifies the position of the first bit within integer1 to be transferred.

len An integer expression that specifies the number of bits to be transferred.

integer2 An integer variable or array element that identifies the location to which the bits are being transferred.

start2 An integer expression that identifies the starting position within integer2 for the bits being transferred.

The low-order bit in either integer is position 0. The last bit position in either integer must not exceed 31.

## NINT

NINT (real-number)

A function that returns the value of the integer nearest to the value of the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | NINT | ININT | REAL*4 | INTEGER*2 | | | | JNINT | REAL*4 | INTEGER*4 | | | | IIDNNT | REAL*8 | INTEGER*2 | | | | JIDNNT | REAL*8 | INTEGER*4 | | | | IIQNNT | REAL*16 | INTEGER*2 | | | | JIQNNT | REAL*16 | INTEGER*4 | +------+---------+----------+------------+-------------+ The function returns an INTEGER*4 value if the /I4 command qualifier is in effect; otherwise it returns an INTEGER*2 value.

## NOT

NOT (integer)

A function that complements each bit of the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | NOT | INOT | INTEGER*2 | INTEGER*2 | | | | JNOT | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+

## NWORKERS

The intrinsic function NWORKERS requires no arguments and returns an INTEGER*4 value that represents the total number of processes executing an application. NWORKERS will be most useful in parallel applications for determining the size of the iteration segments to be executed by the parallel processes. For example: CPAR\$ DO_PARALLEL (N+NWORKERS( )-1) / NWORKERS( ) DO I = 1, N ... ENDDO In this example, the size of each iteration segment to be executed in the parallel processes would be the total number of iterations in the parallel DO loop divided by the number of available processes. (Specifying "(N+NWORKERS( )-1)" guarantees that you can never get an illegal segment value of 0.)

By using NWORKERS as a variable in the calculation to establish iteration segment size, the segment size adjusts automatically when the application is run on systems with varying numbers of available processors.

## QEXT

QEXT (number)

A function that converts the argument to a REAL*16 value. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | QEXT | QEXT | INTEGER*2 | REAL*16 | | | | QEXT | INTEGER*4 | REAL*16 | | | | QEXT | REAL*4 | REAL*16 | | | | QEXTD | REAL*8 | REAL*16 | | | | QEXT | REAL*16 | REAL*16 | | | | QEXT | COMPLEX*8 | REAL*16 | | | | QEXT | COMPLEX*16 | REAL*16 | +------+---------+----------+------------+-------------+

## QFLOAT

QFLOAT (integer)

A function that converts an integer value to a REAL*16 value. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | QFLOAT | QFLOAT | INTEGER*2 | REAL*16 | | | | QFLOAT | INTEGER*4 | REAL*16 | +------+---------+----------+------------+-------------+

## RAN

RAN (seed)

A function that returns a different REAL*4 number between 0.0 (inclusive) and 1.0 (exclusive) each time it is invoked. The argument must be an INTEGER*4 variable or array element. For best results, you should initialize the argument to a large, odd value before invoking RAN the first time. To generate different sets of random values, initialize the seed to a different value on each run. Do not modify the seed during a run.

## REAL

REAL (number)

A function that converts the argument to a real value. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | REAL | FLOATI | INTEGER*2 | REAL*4 | | | | FLOATJ | INTEGER*4 | REAL*4 | | | | REAL | REAL*4 | REAL*4 | | | | SNGL | REAL*8 | REAL*4 | | | | SNGLQ | REAL*16 | REAL*4 | | | | REAL | COMPLEX*8 | REAL*4 | | | | REAL | COMPLEX*16 | REAL*4 | +------+---------+----------+------------+-------------+

## SECNDS

SECNDS (real-number)

A subroutine that returns the number of seconds since midnight minus the value of the argument. The argument must be a REAL*4 data type. The return value is a REAL*4 data type. The time returned is accurate to .01 seconds.

## SIGN

SIGN (value, sign)

A function that assigns the sign of the second argument to the absolute value of the first. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 2 | SIGN | IISIGN | INTEGER*2 | INTEGER*2 | | | | JISIGN | INTEGER*4 | INTEGER*4 | | | | SIGN | REAL*4 | REAL*4 | | | | DSIGN | REAL*8 | REAL*8 | | | | QSIGN | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+ See also the ISIGN intrinsic function.

## SIN

SIN (number)

A function that returns the sine of the argument. The argument must be in radians; it is treated modulo 2*pi. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | SIN | SIN | REAL*4 | REAL*4 | | | | DSIN | REAL*8 | REAL*8 | | | | QSIN | REAL*16 | REAL*16 | | | | CSIN | COMPLEX*8 | COMPLEX*8 | | | | CDSIN | COMPLEX*16 | COMPLEX*16 | | | | ZSIN | COMPLEX*16 | COMPLEX*16 | +------+---------+----------+------------+-------------+

## SIND

SIND (number)

A function that returns the sine of the argument. The argument must be in degrees; it is treated modulo 360. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | SIND | SIND | REAL*4 | REAL*4 | | | | DSIND | REAL*8 | REAL*8 | | | | QSIND | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+

## SINH

SINH (number)

A function that returns the hyperbolic sine of the argument. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | SINH | SINH | REAL*4 | REAL*4 | | | | DSINH | REAL*8 | REAL*8 | | | | QSINH | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+

## SIZEOF

SIZEOF (arg)

A function that returns the number of bytes of storage used by the argument. +------+---------+----------+---------------------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+---------------------------+-------------+ | 1 | -- | SIZEOF | Anything with a valid | INTEGER*4 | | | | | data type, except assumed-| | | | | | size arrays or passed- | | | | | | length characters. | | +------+---------+----------+---------------------------+-------------+

## SQRT

SQRT (number)

A function that returns the square root of the argument. The result is the principal value, with the real part greater than or equal to zero. If the real part is zero, the result is the principal value, with the imaginary part greater than or equal to zero. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | SQRT | SQRT | REAL*4 | REAL*4 | | | | DSQRT | REAL*8 | REAL*8 | | | | QSQRT | REAL*16 | REAL*16 | | | | CSQRT | COMPLEX*8 | COMPLEX*8 | | | | CDSQRT | COMPLEX*16 | COMPLEX*8 | | | | ZSQRT | COMPLEX*16 | COMPLEX*8 | +------+---------+----------+------------+-------------+ The argument for SQRT and DSQRT must be greater than or equal to zero. The argument for QSQRT must be greater than zero.

## TAN

TAN (real-number)

A function that returns the tangent of the argument. The argument must be in radians; it is treated modulo 2*pi. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | TAN | TAN | REAL*4 | REAL*4 | | | | DTAN | REAL*8 | REAL*8 | | | | QTAN | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+

## TAND

TAND (real-number)

A function that returns the tangent of the argument. The argument must be in degrees; it is treated modulo 360. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | TAND | TAND | REAL*4 | REAL*4 | | | | DTAND | REAL*8 | REAL*8 | | | | QTAND | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+

## TANH

TANH (real-number)

A function that returns the hyperbolic tangent of the argument.

+------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | TANH | TANH | REAL*4 | REAL*4 | | | | DTANH | REAL*8 | REAL*8 | | | | QTANH | REAL*16 | REAL*16 | +------+---------+----------+------------+-------------+

## TIME

CALL TIME (buf)

buf Is an 8-byte variable, array, array element, or character substring.

A subroutine that places the current time in 24-hour ASCII format in the argument. The time is returned as an 8-byte ASCII character string having the following form:

hh:mm:ss

A 24-hour clock is used.

If "buf" is numeric type and smaller than 8 bytes, data corruption can occur.

If "buf" is character type, its associated length is passed to the subroutine. If "buf" is smaller than 8 bytes, the subroutine truncates the date to fit in the specified length. Note that if a CHARACTER array is passed, the subroutine stores the time in the first array element, using the element length, not the length of the entire array. For example, consider the following:

CHARACTER*1 HOUR(8) . . . CALL TIME(HOUR)

The length of the first array element in CHARACTER array HOUR is passed to the TIME subroutine. The subroutine then truncates the time to fit into the one-character element, producing an incorrect result.

## IxAMAX

INTEGER*4 ISAMAX (n, x, incx) INTEGER*4 IDAMAX (n, x, incx) INTEGER*4 ICAMAX (n, x, incx) INTEGER*4 IZAMAX (n, x, incx)

Functions that return the index of the first selected element of the array argument which has the maximum absolute value.

These functions are part of the BLAS1 Basic Set, and are only available on VAX processors.

Arguments

n

Integer number of elements in array "x" to be accessed.

x

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for ISAMAX, REAL*8 for IDAMAX, COMPLEX*8 for ICAMAX, COMPLEX*16 for IZAMAX.

incx

Integer index increment used in selecting which elements of array "x" are accessed.

## IxAMIN

INTEGER*4 ISAMIN (n, x, incx) INTEGER*4 IDAMIN (n, x, incx) INTEGER*4 ICAMIN (n, x, incx) INTEGER*4 IZAMIN (n, x, incx)

Functions that return the index of the first selected element of the array "x" that has the minimum absolute value. For these routines, the absolute value of a complex number is defined as the sum of the absolute values of the real and imaginary parts.

These routines are part of the BLAS1 Extended Set, and are available only on VAX processors. Digital Extended Math Library product may be needed to resolve references to Extended Set routines that are not expanded inline by the compiler.

Arguments

n

Integer number of elements in array "x" to be accessed.

x

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for ISAMIN, REAL*8 for IDAMIN, COMPLEX*8 for ICAMIN, COMPLEX*16 for IZAMIN.

incx

Integer index increment used in selecting which elements of array "x" are accessed.

## IxMAX

INTEGER*4 ISMAX (n, x, incx) INTEGER*4 IDMAX (n, x, incx) INTEGER*4 ICMAX (n, x, incx) INTEGER*4 IZMAX (n, x, incx)

Functions that return the index of the first selected element of the array "x" that has the maximum value.

These routines are part of the BLAS1 Extended Set, and are available only on VAX processors. Digital Extended Math Library product may be needed to resolve references to Extended Set routines that are not expanded inline by the compiler.

Arguments

n

Integer number of elements in array "x" to be accessed.

x

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for ISMAX, REAL*8 for IDMAX, COMPLEX*8 for ICMAX, COMPLEX*16 for IZMAX.

incx

Integer index increment used in selecting which elements of array "x" are accessed.

## IxMIN

INTEGER*4 ISMIN (n, x, incx) INTEGER*4 IDMIN (n, x, incx) INTEGER*4 ICMIN (n, x, incx) INTEGER*4 IZMIN (n, x, incx)

Functions that return the index of the first selected element of the array "x" that has the minimum value.

These routines are part of the BLAS1 Extended Set, and are available only on VAX processors. Digital Extended Math Library product may be needed to resolve references to Extended Set routines that are not expanded inline by the compiler.

Arguments

n

Integer number of elements in array "x" to be accessed.

x

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for ISMIN, REAL*8 for IDMIN, COMPLEX*8 for ICMIN, COMPLEX*16 for IZMIN.

incx

Integer index increment used in selecting which elements of array "x" are accessed.

## xAMAX

REAL*4 SAMAX (n, x, incx) REAL*8 DAMAX (n, x, incx) COMPLEX*8 CAMAX (n, x, incx) COMPLEX*16 ZAMAX (n, x, incx)

Functions that return the first selected element of the array "x" that has the maximum absolute value. For these routines, the absolute value of a complex number is defined as the sum of the absolute values of the real and imaginary parts.

These routines are part of the BLAS1 Extended Set, and are available only on VAX processors. Digital Extended Math Library product may be needed to resolve references to Extended Set routines that are not expanded inline by the compiler.

Arguments

n

Integer number of elements in array "x" to be accessed.

x

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for SAMAX, REAL*8 for DAMAX, COMPLEX*8 for CAMAX, COMPLEX*16 for ZAMAX.

incx

Integer index increment used in selecting which elements of array "x" are accessed.

## xAMIN

REAL*4 SAMIN (n, x, incx) REAL*8 DAMIN (n, x, incx) COMPLEX*8 CAMIN (n, x, incx) COMPLEX*16 ZAMIN (n, x, incx)

Functions that return the first selected element of the array "x" that has the minimum absolute value. For these routines, the absolute value of a complex number is defined as the sum of the absolute values of the real and imaginary parts.

These routines are part of the BLAS1 Extended Set, and are available only on VAX processors. Digital Extended Math Library product may be needed to resolve references to Extended Set routines that are not expanded inline by the compiler.

Arguments

n

Integer number of elements in array "x" to be accessed.

x

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for SAMIN, REAL*8 for DAMIN, COMPLEX*8 for CAMIN, COMPLEX*16 for ZAMIN.

incx

Integer index increment used in selecting which elements of array "x" are accessed.

## xASUM

REAL*4 SASUM (n, x, incx) REAL*8 DASUM (n, x, incx) REAL*4 SCASUM (n, x, incx) REAL*8 DZASUM (n, x, incx)

Functions that return the sum of the absolute values of selected elements of the array argument.

These functions are part of the BLAS1 Basic Set, and are only available on VAX processors.

Arguments

n

Integer number of elements in array "x" to be accessed.

x

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for SASUM, REAL*8 for DASUM, COMPLEX*8 for SCASUM, COMPLEX*16 for DZASUM.

incx

Integer index increment used in selecting which elements of array "x" are accessed.

## xAXPY

SAXPY (n, a, x, incx, y, incy) DAXPY (n, a, x, incx, y, incy) CAXPY (n, a, x, incx, y, incy) ZAXPY (n, a, x, incx, y, incy)

Subroutines that multiply an array by a scalar value and add an array.

These subroutines are part of the BLAS1 Basic Set, and are only available on VAX processors.

Arguments

n

Integer number of elements in arrays "x" and "y" to be accessed.

a

Scalar multiplier for array "x". The data type is REAL*4 for SAXPY, REAL*8 for DAXPY, COMPLEX*8 for CAXPY, COMPLEX*16 for ZAXPY.

x

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for SAXPY, REAL*8 for DAXPY, COMPLEX*8 for CAXPY, COMPLEX*16 for ZAXPY. The elements in array "x" are multiplied by the scalar argument a and then added to elements of array "y".

incx

Integer index increment used in selecting which elements of array "x" are accessed.

y

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for SAXPY, REAL*8 for DAXPY, COMPLEX*8 for CAXPY, COMPLEX*16 for ZAXPY. The elements of array "y" are replaced by the result of adding their value to the product of the corresponding elements of array "x" and the scalar argument "a".

incy

Integer index increment used in selecting which elements of array "y" are accessed.

## xCOPY

SCOPY (n, x, incx, y, incy) DCOPY (n, x, incx, y, incy) CCOPY (n, x, incx, y, incy) ZCOPY (n, x, incx, y, incy)

Subroutines that copy selected elements of one array to another array.

These subroutines are part of the BLAS1 Basic Set, and are only available on VAX processors.

Arguments

n

Integer number of elements in arrays "x" and "y" to be accessed.

x

Array containing the elements to be copied or array reference to the first such element. The data type is REAL*4 for SCOPY, REAL*8 for DCOPY, COMPLEX*8 for CCOPY, COMPLEX*16 for ZCOPY. The elements in array "x" are copied to the corresponding elements of array "y".

incx

Integer index increment used in selecting which elements of array "x" are accessed.

y

Array containing the elements to receive the copied values or array reference to the first such element. The data type is REAL*4 for SCOPY, REAL*8 for DCOPY, COMPLEX*8 for CCOPY, COMPLEX*16 for ZCOPY. The elements of array "y" are replaced by the corresponding elements of array "x".

incy

Integer index increment used in selecting which elements of array "y" are accessed.

## xDOTx

REAL*4 SDOT (n, x, incx, y, incy) REAL*8 DDOT (n, x, incx, y, incy) COMPLEX*8 CDOTC (n, x, incx, y, incy) COMPLEX*8 CDOTU (n, x, incx, y, incy) COMPLEX*16 ZDOTC (n, x, incx, y, incy) COMPLEX*16 ZDOTU (n, x, incx, y, incy)

Functions that return the inner product of two arrays. CDOTC and ZDOTC compute conjugated values while CDOTU and ZDOTU compute unconjugated values.

These functions are part of the BLAS1 Basic Set, and are only available on VAX processors.

Arguments

n

Integer number of elements in arrays "x" and "y" to be accessed.

x

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for SDOT, REAL*8 for DDOT, COMPLEX*8 for CDOTC and CDOTU, COMPLEX*16 for ZDOTC and ZDOTU.

incx

Integer index increment used in selecting which elements of array "x" are accessed.

y

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for SDOT, REAL*8 for DDOT, COMPLEX*8 for CDOTC and CDOTU, COMPLEX*16 for ZDOTC and ZDOTU.

incy

Integer index increment used in selecting which elements of array "y" are accessed.

## xMAX

REAL*4 SMAX (n, x, incx) REAL*8 DMAX (n, x, incx) COMPLEX*8 CMAX (n, x, incx) COMPLEX*16 ZMAX (n, x, incx)

Functions that return the first selected element of the array "x" that has the maximum value.

These routines are part of the BLAS1 Extended Set, and are available only on VAX processors. The Digital Extended Math Library product may be needed to resolve references to Extended Set routines that are not expanded inline by the compiler.

Arguments

n

Integer number of elements in array "x" to be accessed.

x

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for SMAX, REAL*8 for DMAX, COMPLEX*8 for CMAX, COMPLEX*16 for ZMAX.

incx

Integer index increment used in selecting which elements of array "x" are accessed.

## xMIN

REAL*4 SMIN (n, x, incx) REAL*8 DMIN (n, x, incx) COMPLEX*8 CMIN (n, x, incx) COMPLEX*16 ZMIN (n, x, incx)

Functions that return the first selected element of the array "x" that has the minimum value.

These routines are part of the BLAS1 Extended Set, and are available only on VAX processors. The Digital Extended Math Library product may be needed to resolve references to Extended Set routines that are not expanded inline by the compiler.

Arguments

n

Integer number of elements in array "x" to be accessed.

x

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for SMIN, REAL*8 for DMIN, COMPLEX*8 for CMIN, COMPLEX*16 for ZMIN.

incx

Integer index increment used in selecting which elements of array "x" are accessed.

## xNORM2

REAL*4 SNORM2 (n, x, incx) REAL*8 DNORM2 (n, x, incx) REAL*4 SCNORM2 (n, x, incx) REAL*8 DZNORM2 (n, x, incx)

Functions that return the Euclidean norm of array "x" that is the square root of the sum of the squares of the absolute values of the array elements. For the purposes of these routines, the absolute value of a complex value is the square root of the sum of the squares of the real and imaginary parts.

Unlike the BLAS1 routines xNRM2, the xNORM2 routines assume that intermediate underflow or overflow exceptions will not occur.

These routines are part of the BLAS1 Extended Set, and are available only on VAX processors. The Digital Extended Math Library product may be needed to resolve references to Extended Set routines that are not expanded inline by the compiler.

Arguments

n

Integer number of elements in array "x" to be accessed.

x

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for SNORM2, REAL*8 for DNORM2, COMPLEX*8 for SCNORM2, COMPLEX*16 for DZNORM2.

incx

Integer index increment used in selecting which elements of array "x" are accessed.

## xNRM2

REAL*4 SNRM2 (n, x, incx) REAL*8 DNRM2 (n, x, incx) REAL*4 SCNRM2 (n, x, incx) REAL*8 DZNRM2 (n, x, incx)

Functions that return the Euclidean norm of a array. These functions cannot be inlined.

These functions are part of the BLAS1 Basic Set, and are only available on VAX processors.

Arguments

n

Integer number of elements in array "x" to be accessed.

x

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for SNRM2, REAL*8 for DNRM2, COMPLEX*8 for SCNRM2, COMPLEX*16 for DZNRM2.

incx

Integer index increment used in selecting which elements of array "x" are accessed.

## xNRSQ

REAL*4 SNRSQ (n, x, incx) REAL*8 DNRSQ (n, x, incx) REAL*4 SCNRSQ (n, x, incx) REAL*8 DZNRSQ (n, x, incx)

Functions that return the sum of the squares of the absolute values of the elements of array "x". For the purposes of these routines, the absolute value of a complex value is the square root of the sum of the squares of the real and imaginary parts.

These routines are part of the BLAS1 Extended Set, and are available only on VAX processors. The Digital Extended Math Library product may be needed to resolve references to Extended Set routines that are not expanded inline by the compiler.

Arguments

n

Integer number of elements in array "x" to be accessed.

x

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for SNRSQ, REAL*8 for DNRSQ, COMPLEX*8 for SCNRSQ, COMPLEX*16 for DZNRSQ.

incx

Integer index increment used in selecting which elements of array "x" are accessed.

## xROT

SROT (n, x, incx, y, incy, c, s) DROT (n, x, incx, y, incy, c, s) CSROT (n, x, incx, y, incy, c, s) ZDROT (n, x, incx, y, incy, c, s)

Subroutines that apply a Givens plane rotation to a pair of arrays. CSROT and ZDROT apply a real rotation to a pair of complex arrays.

These routines are part of the BLAS1 Basic Set, and are only available on VAX processors.

Arguments

n

Integer number of elements in arrays "x" and "y" to be accessed.

x

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for SROT, REAL*8 for DROT, COMPLEX*8 for CSROT, COMPLEX*16 for ZDROT.

incx

Integer index increment used in selecting which elements of array "x" are accessed.

y

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for SROT, REAL*8 for DROT, COMPLEX*8 for CSROT, COMPLEX*16 for ZDROT.

incy

Integer index increment used in selecting which elements of array "y" are accessed.

c

First rotation element, which can be interpreted as the cosine of the angle of rotation. This argument can be generated by the xROTG routines. The data type is REAL*4 for SROT and CSROT, REAL*8 for DROT and ZDROT.

s

Second rotation element, which can be interpreted as the sine of the angle of rotation. This argument can be generated by the xROTG routines. The data type is REAL*4 for SROT and CSROT, REAL*8 for DROT and ZDROT.

## xROTG

SROTG (a, b, c, s) DROTG (a, b, c, s) CROTG (a, b, c, s) ZROTG (a, b, c, s)

Subroutines that generate the elements for a Givens plane rotation. These subroutines cannot be inlined.

These routines are part of the BLAS1 Basic Set, and are only available on VAX processors.

Arguments

a

On entry, first element of the input array. On exit, rotated element r. The data type is REAL*4 for SROTG, REAL*8 for DROTG, COMPLEX*8 for CROTG, COMPLEX*16 for ZROTG.

b

On entry, second element of the input array. On exit from SROTG and DROTG, reconstruction element z. The data type is REAL*4 for SROTG, REAL*8 for DROTG, COMPLEX*8 for CROTG, COMPLEX*16 for ZROTG.

c

Variable into which is stored the first rotation element, which can be interpreted as the cosine of the angle of rotation. The data type is REAL*4 for SROTG, REAL*8 for DROTG, COMPLEX*8 for CROTG, COMPLEX*16 for ZROTG.

s

Variable into which is stored the second rotation element, which can be interpreted as the sine of the angle of rotation. The data type is REAL*4 for SROTG, REAL*8 for DROTG, COMPLEX*8 for CROTG, COMPLEX*16 for ZROTG.

## xSCAL

SSCAL (n, a, x, incx) DSCAL (n, a, x, incx) CSCAL (n, a, x, incx) CSSCAL (n, a, x, incx) ZSCAL (n, a, x, incx) ZDSCAL (n, a, x, incx)

Subroutines that scale the elements of an array by a scalar value.

These routines are part of the BLAS1 Basic Set, and are only available on VAX processors.

Arguments

n

Integer number of elements in array "x" to be accessed.

a

Scalar value to be multiplied by each selected element in array "x". The data type is REAL*4 for SSCAL and CSSCAL, REAL*8 for DSCAL and ZDSCAL, COMPLEX*8 for CSCAL and COMPLEX*16 for ZSCAL.

x

Array containing the elements to be scaled or array reference to the first such element. The selected elements are replaced by the scaled value. The data type is REAL*4 for SSCAL, REAL*8 for DSCAL, COMPLEX*8 for CSCAL and CSSCAL, COMPLEX*16 for ZSCAL and ZDSCAL.

incx

Integer index increment used in selecting which elements of array "x" are accessed.

## xSET

SSET (n, a, x, incx) DSET (n, a, x, incx) CSET (n, a, x, incx) ZSET (n, a, x, incx)

Subroutines that set all selected elements of array "x" to scalar value "a".

These routines are part of the BLAS1 Extended Set, and are available only on VAX processors. The Digital Extended Math Library product may be needed to resolve references to Extended Set routines that are not expanded inline by the compiler.

Arguments

n

Integer number of elements in array "x" to be accessed.

a

Scalar value to be stored in all selected elements of array "x". The data type is REAL*4 for SSET, REAL*8 for DSET, COMPLEX*8 for CSET, COMPLEX*16 for ZSET

x

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for SSET, REAL*8 for DSET, COMPLEX*8 for CSET, COMPLEX*16 for ZSET.

incx

Integer index increment used in selecting which elements of array "x" are accessed.

## xSUM

REAL*4 SSUM (n, x, incx) REAL*8 DSUM (n, x, incx) COMPLEX*8 CSUM (n, x, incx) COMPLEX*16 ZSUM (n, x, incx)

Functions that return the sum of the selected elements of array "x".

These routines are part of the BLAS1 Extended Set, and are available only on VAX processors. The Digital Extended Math Library product may be needed to resolve references to Extended Set routines that are not expanded inline by the compiler.

Arguments

n

Integer number of elements in array "x" to be accessed.

x

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for SSUM, REAL*8 for DSUM, COMPLEX*8 for CSUM, COMPLEX*16 for ZSUM.

incx

Integer index increment used in selecting which elements of array "x" are accessed.

## xSWAP

SSWAP (n, x, incx, y, incy) DSWAP (n, x, incx, y, incy) CSWAP (n, x, incx, y, incy) ZSWAP (n, x, incx, y, incy)

Subroutines that swap elements between two arrays.

These routines are part of the BLAS1 Basic Set, and are only available on VAX processors.

Arguments

n

Integer number of elements in arrays "x" and "y" to be accessed.

x

Array containing elements to be swapped with corresponding elements in array "y", or array reference to the first such element. The data type is REAL*4 for SSWAP, REAL*8 for DSWAP, COMPLEX*8 for CSWAP, COMPLEX*16 for ZSWAP.

incx

Integer index increment used in selecting which elements of array "x" are accessed.

y

Array containing elements to be swapped with corresponding elements in array "x", or array reference to the first such element. The data type is REAL*4 for SSWAP, REAL*8 for DSWAP, COMPLEX*8 for CSWAP, COMPLEX*16 for ZSWAP.

incy

Integer index increment used in selecting which elements of array "y" are accessed.

## xVCAL

SVCAL (n, a, x, incx, y, incy) DVCAL (n, a, x, incx, y, incy) CVCAL (n, a, x, incx, y, incy) CSVCAL (n, a, x, incx, y, incy) ZVCAL (n, a, x, incx, y, incy) ZDVCAL (n, a, x, incx, y, incy)

Subroutines that scale the elements of array "x" by scalar value "a" and store the results in array "y".

These routines are part of the BLAS1 Extended Set, and are available only on VAX processors. The Digital Extended Math Library product may be needed to resolve references to Extended Set routines that are not expanded inline by the compiler.

Arguments

n

Integer number of elements in arrays "x" and "y" to be accessed.

a

Scalar value to be multiplied by each selected element in array "x". The data type is REAL*4 for SVCAL and CSVCAL, REAL*8 for DVCAL and ZDVCAL, COMPLEX*8 for CVCAL and COMPLEX*16 for ZVCAL.

x

Array containing the elements to be scaled or array reference to the first such element. The data type is REAL*4 for SVCAL, REAL*8 for DVCAL, COMPLEX*8 for CVCAL and CSVCAL, COMPLEX*16 for ZVCAL and ZDVCAL.

incx

Integer index increment used in selecting which elements of array "x" are accessed.

y

Array into which the scaled elements are stored or array reference to the first such element. The data type is REAL*4 for SVCAL, REAL*8 for DVCAL, COMPLEX*8 for CVCAL and CSVCAL, COMPLEX*16 for ZVCAL and ZDVCAL.

incy

Integer index increment used in selecting which elements of array "y" are accessed.

## xZAXPY

SZAXPY (n, a, x, incx, y, incy, z, incz) DZAXPY (n, a, x, incx, y, incy, z, incz) CZAXPY (n, a, x, incx, y, incy, z, incz) ZZAXPY (n, a, x, incx, y, incy, z, incz)

Subroutines that multiply an array "x" by a scalar "a" and add an array "y"; the result is stored in a third array "z".

These routines are part of the BLAS1 Extended Set, and are available only on VAX processors. The Digital Extended Math Library product may be needed to resolve references to Extended Set routines that are not expanded inline by the compiler.

Arguments

n

Integer number of elements in arrays "x", "y" and "z" to be accessed.

a

Scalar multiplier for array x. The data type is REAL*4 for SZAXPY, REAL*8 for DZAXPY, COMPLEX*8 for CZAXPY, COMPLEX*16 for ZZAXPY.

x

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for SZAXPY, REAL*8 for DZAXPY, COMPLEX*8 for CZAXPY, COMPLEX*16 for ZZAXPY. The elements in array "x" are multiplied by the scalar argument "a" and then added to elements of array "y"; the results are stored in array "z".

incx

Integer index increment used in selecting which elements of array "x" are accessed.

y

Array containing the elements to be accessed or array reference to the first such element. The data type is REAL*4 for SZAXPY, REAL*8 for DZAXPY, COMPLEX*8 for CZAXPY, COMPLEX*16 for ZZAXPY. The elements of array "y" are added to the product of scalar "a" and array "x"; the result is stored in array "z".

incy

Integer index increment used in selecting which elements of array "y" are accessed.

z

Array containing the elements to receive the result values or array reference to the first such element. The data type is REAL*4 for SZAXPY, REAL*8 for DZAXPY, COMPLEX*8 for CZAXPY, COMPLEX*16 for ZZAXPY.

incz

Integer index increment used in selecting which elements of array "z" are accessed.

## ZEXT

ZEXT (integer)

A function that returns the value of the argument, zero extended. +------+---------+----------+------------+-------------+ | Args | Generic | Specific | Argument | Result Type | +------+---------+----------+------------+-------------+ | 1 | ZEXT | IZEXT | LOGICAL*1 | INTEGER*2 | | | | IZEXT | LOGICAL*2 | INTEGER*2 | | | | IZEXT | INTEGER*2 | INTEGER*2 | | | | JZEXT | LOGICAL*1 | INTEGER*4 | | | | JZEXT | LOGICAL*2 | INTEGER*4 | | | | JZEXT | LOGICAL*4 | INTEGER*4 | | | | JZEXT | INTEGER*2 | INTEGER*4 | | | | JZEXT | INTEGER*4 | INTEGER*4 | +------+---------+----------+------------+-------------+