VMS Help
FORTRAN, Intrinsic Procedures
*Conan The Librarian (sorry for the slow response - running on an old VAX)
|
|
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 (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 (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 (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 (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 (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 (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 (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.
See also the NINT intrinsic function.
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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 |
+------+---------+----------+------------+-------------+
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.
DATE_AND_TIME ([date] ,[time] ,[zone] ,[values])
Returns character data on the real-time clock and date in a form
compatible with the representations defined in Standard ISO
8601:1988.
Optional arguments:
o The "date" must be scalar and of type character; its
length must be at least 8 to contain the complete value. Its
leftmost 8 characters are set to a value of the form CCYYMMDD,
where:
CC is the century
YY is the year within the century
MM is the month within the year
DD is the day within the month
o The "time" must be scalar and of type character; its
length must be at least 10 to contain the complete value. Its
leftmost 10 characters are set to a value of the form
hhmmss.sss, where:
hh is the hour of the day
mm is the minutes of the hour
ss.sss is the seconds and milliseconds of the minute
o The "zone" must be scalar and of type character; its
length must be at least 5 to contain the complete value. Its
leftmost 5 characters are set to a value of the form + or -
hhmm, where "hh" and "mm" are the time difference with respect
to Coordinated Universal Time (UTC) in hours and parts of an
hour expressed in minutes, respectively.
o The "values" must be an array of type INTEGER*4.
Its size must be at least 8. The values returned in "values"
are as follows:
values (1) is the 4-digit year
values (2) is the month of the year
values (3) is the day of the year
values (4) is the time difference with respect to
Coordinated Universal Time (UTC) in minutes
values (5) is the hour of the day (range 0 to 23)
values (6) is the minutes of the hour (range 0 to 59).
values (7) is the seconds of the minute (range 0 to 59).
values (8) is the milliseconds of the second (range 0 to 999).
Example:
Consider the following example executed on 1997 April 23 at
13:23:30.5 in a timezone one hour later than UTC:
INTEGER*4 DATE_TIME (8)
CHARACTER*12 REAL_CLOCK (3)
CALL DATE_AND_TIME (REAL_CLOCK (1), REAL_CLOCK (2),
+ REAL_CLOCK (3), DATE_TIME)
This assigns the value '19970423' to REAL_CLOCK (1), the value
'132330.500' to REAL_CLOCK (2), and the value '+0100' to REAL_CLOCK
(3). The following values are assigned to DATE_TIME: 1997, 4, 23,
60, 13, 23, 30, and 500.
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 (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 (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 (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 (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 (number, number)
A function that returns the product of two real values using the
next higher precision data type.
+------+---------+----------+------------+-------------+
| Args | Generic | Specific | Argument | Result Type |
+------+---------+----------+------------+-------------+
| 2 | DPROD | DPROD | REAL*4 | REAL*8 |
| | | none | REAL*8 | REAL*16 |
+------+---------+----------+------------+-------------+
3 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 ([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 (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 (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 (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 (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 ()
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 that is used to return the function value.
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 (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 (integer, start-position, length)
A function that returns the value of the bits of the
first argument specified by start-position and number
of bits. 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 (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 (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 (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 (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 (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.
See also the INT intrinsic function.
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.
See also the NINT intrinsic function.
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 (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 (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 (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 (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.
See also the AINT, IDINT, and IQINT.
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 (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.
See also the INT intrinsic function.
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.
See also the NINT intrinsic function.
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 (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 (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 (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 (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 (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 (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 (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 (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 intrinsic serves the same purpose as the %LOC built-in
function.
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 (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 (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 (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 (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.
See also the MAX intrinsic function.
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
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
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.
See also the MIN intrinsic function.
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 (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 (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.
See also the ANINT, IDNINT, and IQNINT intrinsic functions.
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 |
+------+---------+----------+------------+-------------+
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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 |
+------+---------+----------+------------+-------------+
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.
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.
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. Compaq 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.
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. Compaq 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.
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. Compaq 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.
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. Compaq 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.
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. Compaq 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.
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.
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.
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.
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.
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 Compaq 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.
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 Compaq 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.
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 Compaq 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.
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.
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 Compaq 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.
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, REAL*8 for
DROT, COMPLEX*8 for CSROT and COMPLEX*16 for ZDROT
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 and CROTG, REAL*8 for DROTG and
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.
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.
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 Compaq 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.
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 Compaq 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.
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.
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 Compaq 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.
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 Compaq 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 (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 |
+------+---------+----------+------------+-------------+
[legal]
[privacy]
[GNU]
[policy]
[netiquette]
[sponsors]
[FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.