|
HP OpenVMS Systems Documentation |
|
HP Fortran for OpenVMS
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| Previous | Contents | Index |
| Description: | Returns the imaginary part of a complex number. 1 | ||
| Class: | Elemental function; Generic | ||
| Arguments: | Z must be of type complex. | ||
| Results: | The result is of type real with the same kind parameter as Z. If Z has the value (x, y), the result has the value y. | ||
| Specific Name | Argument Type | Result Type |
|---|---|---|
| AIMAG 1 | COMPLEX(4) | REAL(4) |
| DIMAG | COMPLEX(8) | REAL(8) |
| QIMAG | COMPLEX(16) | REAL(16) |
Examples
AIMAG ((4.0, 5.0)) has the value 5.0.
9.4.8 AINT (A [,KIND])
| Description: | Truncates a value to a whole number. | ||
| Class: | Elemental function; Generic | ||
| Arguments: | A | Must be of type real. | |
| KIND (opt) | Must be a scalar integer initialization expression. | ||
| Results: |
The result is of type real. If KIND is present, the kind parameter of
the result is that specified by KIND; otherwise, the kind parameter is
that of A.
The result is defined as the largest integer whose magnitude does not exceed the magnitude of A and whose sign is the same as that of A. If |A| is less than 1, AINT (A) has the value zero. |
||
| Specific Name | Argument Type | Result Type |
|---|---|---|
| AINT | REAL(4) | REAL(4) |
| DINT | REAL(8) | REAL(8) |
| QINT | REAL(16) | REAL(16) |
Examples
AINT (3.678) has the value 3.0.
AINT (--1.375) has the value --1.0.
9.4.9 ALL (MASK [,DIM])
| Description: | Determines if all values are true in an entire array or in a specified dimension of an array. | ||
| Class: | Transformational function; Generic | ||
| Arguments: | MASK | Must be a logical array. | |
| DIM (opt) | Must be a scalar integer with a value in the range 1 to n, where n is the rank of MASK. | ||
| Results: |
The result is an array or a scalar of type logical.
The result is a scalar if DIM is omitted or MASK has rank one. A scalar result is true only if all elements of MASK are true, or MASK has size zero. The result has the value false if any element of MASK is false. An array result has the same type and kind parameters as MASK, and a rank that is one less than MASK. Its shape is (d 1, d 2, ..., d DIM-1, d DIM+1, ..., d n), where (d 1, d 2,..., d n) is the shape of MASK. Each element in an array result is true only if all elements in the one dimensional array defined by MASK (s 1, s 2, ..., s DIM-1, :, s DIM+1, ..., s n) are true. |
||
Examples
ALL ((/.TRUE., .FALSE., .TRUE./)) has the value false because some elements of MASK are not true.
ALL ((/.TRUE., .TRUE., .TRUE./)) has the value true because all elements of MASK are true.
A is the array <left[ symbol><matrix symbol> 1&5&7<cr symbol> 3&6&8<cr symbol> <right] symbol> and B is the array <left[ symbol><matrix symbol> 0&5&7<cr symbol> 2&6&9<cr symbol> <right] symbol> .
ALL (A .EQ. B, DIM=1) tests to see if all elements in each column of A are equal to the elements in the corresponding column of B. The result has the value (false, true, false) because only the second column has elements that are all equal.
ALL (A .EQ. B, DIM=2) tests to see if all elements in each row of A are
equal to the elements in the corresponding row of B. The result has the
value (false, false) because each row has some elements that are not
equal.
9.4.10 ALLOCATED (ARRAY)
| Description: | Indicates whether an allocatable array is currently allocated. | ||
| Class: | Inquiry function; Generic | ||
| Arguments: | ARRAY must be an allocatable array. | ||
| Results: |
The result is a scalar of type default logical.
The result has the value true if ARRAY is currently allocated, false if ARRAY is not currently allocated, or undefined if its allocation status is undefined. |
||
Examples
Consider the following:
REAL, ALLOCATABLE, DIMENSION (:,:,:) :: E PRINT *, ALLOCATED (E) ! Returns the value false ALLOCATE (E (12, 15, 20)) PRINT *, ALLOCATED (E) ! Returns the value true |
| Description: | Calculates the nearest whole number. | ||
| Class: | Elemental function; Generic | ||
| Arguments: | A | Must be of type real. | |
| KIND (opt) | Must be a scalar integer initialization expression. | ||
| Results: | The result is of type real. If KIND is present, the kind parameter is that specified by KIND; otherwise, the kind parameter is that of A. If A is greater than zero, ANINT (A) has the value AINT (A + 0.5); if A is less than or equal to zero, ANINT (A) has the value AINT (A - 0.5). | ||
| Specific Name | Argument Type | Result Type |
|---|---|---|
| ANINT | REAL(4) | REAL(4) |
| DNINT | REAL(8) | REAL(8) |
| QNINT | REAL(16) | REAL(16) |
Examples
ANINT (3.456) has the value 3.0.
ANINT (--2.798) has the value --3.0.
9.4.12 ANY (MASK [,DIM])
| Description: | Determines if any value is true in an entire array or in a specified dimension of an array. | ||
| Class: | Transformational function; Generic | ||
| Arguments: | MASK | Must be a logical array. | |
| DIM (opt) | Must be a scalar integer expression with a value in the range 1 to n, where n is the rank of MASK. | ||
| Results: |
The result is an array or a scalar of type logical.
The result is a scalar if DIM is omitted or MASK has rank one. A scalar result is true if any elements of MASK are true. The result has the value false if no element of MASK is true, or MASK has size zero. An array result has the same type and kind parameters as MASK, and a rank that is one less than MASK. Its shape is (d 1, d 2, ..., d DIM-1, d DIM+1, ..., d n), where (d 1, d 2,..., d n) is the shape of MASK. Each element in an array result is true if any elements in the one dimensional array defined by MASK (s 1, s 2, ..., s DIM-1, :, s DIM+1, ..., s n) are true. |
||
Examples
ANY ((/.FALSE., .FALSE., .TRUE./)) has the value true because one element is true.
A is the array <left[ symbol><matrix symbol> 1&5&7<cr symbol> 3&6&8<cr symbol> <right] symbol> and B is the array <left[ symbol><matrix symbol> 0&5&7<cr symbol> 2&6&9<cr symbol> <right] symbol> .
ANY (A .EQ. B, DIM=1) tests to see if any elements in each column of A are equal to the elements in the corresponding column of B. The result has the value (false, true, true) because the second and third columns have at least one element that is equal.
ANY (A .EQ. B, DIM=2) tests to see if any elements in each row of A are
equal to the elements in the corresponding row of B. The result has the
value (true, true) because each row has at least one element that is
equal.
9.4.13 ASIN (X)
| Description: | Produces the arcsine of X. | ||
| Class: | Elemental function; Generic | ||
| Arguments: | X must be of type real. The |X| must be less than or equal to 1. | ||
| Results: | The result type is the same as X and is expressed in radians. The value lies in the range --Pi sign/2 to Pi sign/2. | ||
| Specific Name | Argument Type | Result Type |
|---|---|---|
| ASIN | REAL(4) | REAL(4) |
| DASIN | REAL(8) | REAL(8) |
| QASIN | REAL(16) | REAL(16) |
Examples
ASIN (0.79345021) has the value 0.9164571.
Examples
ASIND (0.2467590) has the value 14.28581.
Arguments are passed by value. If you want to pass an argument by
reference (for example, a whole array, a character string, or a record
structure), you can use the %REF built-in function. (See Section 8.8.9.1.)
Labels are allowed, but all references must be from within the
same ASM (Alpha only) function. This lets you set up looping
constructs, for example. Cross-jumping between ASM functions is not
permitted.
In general, an ASM function can appear anywhere that an intrinsic
function can be used. Since the supplied assembly code, assembly
directives, or assembly data is integrated into the code stream, the
compiler may choose to use different registers, better code sequences,
and so on, just as if the code were written in Fortran.
You do not have absolute control over instruction sequences and
registers, and the compiler may intersperse other code together with
the ASM code for better performance. Better code sequences may be
substituted by the optimizer if it chooses to do so.
Only register names beginning with a dollar sign ($) or percent
sign (%) are permitted. For more information on register name
conventions, see your operating system documentation set.
Examples
Consider the following:
This example shows an integer ASM function that adds up 9 values and
returns the sum as its result. Note that the user stores the function
result in register $0.
All arguments are passed by value. The arguments not passed in
registers can be named %6, %7, and %8, which correspond to the actual
arguments 7, 8, and 9 (since %0 is the first argument). Notice that you
can reference reserved registers like %fp.
The compiler creates the appropriate argument list. So, in this
example, the first argument value (1) will be available in register
$16, and the eighth argument value (8) will be available in %7, which
is actually 8($30).
9.4.14 ASIND (X)
Description:
Produces the arcsine of X.
Class:
Elemental function; Generic
Arguments:
X must be of type real and must be greater than or equal to zero. The
|X| must be less than or equal to 1.
Results:
The result type is the same as X and is expressed in degrees.
Specific Name
Argument Type
Result Type
ASIND
REAL(4)
REAL(4)
DASIND
REAL(8)
REAL(8)
QASIND
REAL(16)
REAL(16)
9.4.15 ASM (STRING [,A,...]) (Alpha only)
Description:
Lets you use assembler instructions in an executable program.
Class:
Nonelemental function; Generic
Arguments:
STRING
Must be of type character. It is a character constant or a
concatenation of character constants containing the assembler
instructions.
A (opt)
Can be of any type. This can be a source or destination argument for
the instruction, for example.
Results:
The result is a scalar of type INTEGER(8), REAL(4), or REAL(8).
Specific Name
Argument Type1
Result Type
ASM
2
CHARACTER
INTEGER(8)
FASM
3
CHARACTER
REAL(4)
DASM
3
CHARACTER
REAL(8)
1For the first argument.
2The value must be stored in register $0 by the user code.
3The value must be stored in register $F0 by the user code.
! Concatenation is recommended for clarity.
! Notice that ";" separates instructions.
!
nine=9
type *, asm('addq %0, $17, $0;'// ! Adds the first two arguments
1 'ldq $22, %6;'// ! and puts the answer in
1 'ldq $23, %7;'// ! register $0
1 'ldq $24, %8;'// !
1 'mov $0, %fp;'// ! Comments are not allowed in the
1 'addq $18, %fp, $0;'// ! constant, but are allowed here
1 'addq $19, $0, $0;'//
1 'addq $20, $0, $0;'//
1 'addq $21, $0, $0;'//
1 'addq $22, $0, $0;'//
1 'addq $23, $0, $0;'//
1 'addq $24, $0, $0;',
1 1,2,3,4,5,6,7,8,nine) ! The actual arguments to the
! ASM (usually by value)
end
9.4.16 ASSOCIATED (POINTER [,TARGET])
| Description: | Returns the association status of its pointer argument or indicates whether the pointer is associated with the target. | ||
| Class: | Inquiry function; Generic | ||
| Arguments: | POINTER | Must be a pointer (of any data type). | |
| TARGET (opt) | Must be a pointer or target. | ||
| The pointer (in POINTER or TARGET) must not have an association status that is undefined. | |||
| Results: |
The result is a scalar of type default logical.
If only POINTER appears, the result is true if it is currently associated with a target; otherwise, the result is false. If TARGET also appears and is a target, the result is true if POINTER is currently associated with TARGET; otherwise, the result is false. If TARGET is a pointer, the result is true if both POINTER and TARGET are currently associated with the same target; otherwise, the result is false. (If either POINTER or TARGET is disassociated, the result is false.) The setting of compiler options specifying integer size can affect this function. |
||
Examples
Consider the following:
REAL, TARGET, DIMENSION (0:50) :: TAR REAL, POINTER, DIMENSION (:) :: PTR PTR => TAR PRINT *, ASSOCIATED (PTR, TAR) ! Returns the value true |
The subscript range for PTR is 0:50. Consider the following pointer assignment statements:
(1) PTR => TAR (:) (2) PTR => TAR (0:50) (3) PTR => TAR (0:49) |
For statements 1 and 2, ASSOCIATED (PTR, TAR) is true because TAR has not changed (the subscript range for PTR in both cases is 1:51, following the rules for deferred-shape arrays). For statement 3, ASSOCIATED (PTR, TAR) is false because the upper bound of PTR has changed.
Consider the following:
REAL, POINTER, DIMENSION (:) :: PTR2, PTR3 ALLOCATE (PTR2 (0:15)) PTR3 => PTR2 PRINT *, ASSOCIATED (PTR2, PTR3) ! Returns the value true ... NULLIFY (PTR2) NULLIFY (PTR3) PRINT *, ASSOCIATED (PTR2, PTR3) ! Returns the value false |
| Previous | Next | Contents | Index |