Intrinsic functions, statement functions, and external functions are referred to collectively as functions.
External functions and subroutines are referred to collectively as external procedures.
An intrinsic function may be referenced in the main program or in any procedure subprogram of an executable program.
A statement function may be referenced only in the program unit in which the statement function statement appears.
An external function specified by a function subprogram may be referenced within any other procedure subprogram or the main program of the executable program. A subprogram must not reference itself, either directly or indirectly.
An external function specified by means other than a subprogram may be referenced within any procedure subprogram or the main program of the executable program.
If a character function is referenced in a program unit, the function length specified in the program unit must be an integer constant expression.
The form of a function reference is:
fun ( [a [,a]...] )
The type of the result of a statement function or external function reference is the same as the type of the function name. The type is specified in the same manner as for variables and arrays ( 4.1.2). The type of the result of an intrinsic function is specified in Table 5 ( 15.10).
Return of control from a referenced function completes execution of the function reference. The value of the function is available to the referencing expression.
An IMPLICIT statement does not change the type of an intrinsic function.
If a generic name is used to reference an intrinsic function, the type of the result (except for intrinsic functions performing type conversion, nearest integer, and absolute value with a complex argument) is the same as the type of the argument.
For those intrinsic functions that have more than one argument, all arguments must be of the same type.
If the specific name or generic name of an intrinsic function appears in the dummy argument list of a function or subroutine in a subprogram, that symbolic name does not identify an intrinsic function in the program unit. The data type identified with the symbolic name is specified in the same manner as for variables and arrays ( 4.1.2).
A name in an INTRINSIC statement must be the specific name or generic name of an intrinsic function.
The actual arguments that constitute the argument list must agree in order, number, and type with the specification in Table 5 and may be any expression of the specified type. An actual argument in an intrinsic function reference may be any expression except a character expression involving concatenation of an operand whose length specification is an asterisk in parentheses unless the operand is the symbolic name of a constant.
A specific name of an intrinsic function that appears in an INTRINSIC statement may be used as an actual argument in an external procedure reference; however, the names of intrinsic functions for type conversion, lexical relationship, and for choosing the largest or smallest value must not be used as actual arguments. Note that such an appearance does not cause the intrinsic function to be classified as an external function ( 18.2.10).
Restrictions on the range of arguments and results for intrinsic functions are described in 15.10.1.
A statement function statement is classified as a nonexecutable statement; it is not a part of the normal execution sequence.
fun ( [d [,d]...] ) = e
The relationship between fun and e must conform to the assignment rules in 10.1, 10.2, and 10.4. Note that the type of the expression may be different from the type of the statement function name.
Each d is a variable name called a statement function dummy argument. The statement function dummy argument list serves only to indicate order, number, and type of arguments for the statement function. The variable names that appear as dummy arguments of a statement function have a scope of that statement ( 18.1). A given symbolic name may appear only once in any statement function dummy argument list. The symbolic name of a statement function dummy argument may be used to identify other dummy arguments of the same type in different statement function statements. The name may also be used to identify a variable of the same type appearing elsewhere in the program unit, including its appearance as a dummy argument in a FUNCTION, SUBROUTINE, or ENTRY statement. The name must not be used to identify any other entity in the program unit except a common block.
Each primary of the expression e must be one of the following:
Each variable reference may be either a reference to a dummy argument of the statement function or a reference to a variable that appears within the same program unit as the statement function statement.
If a statement function dummy argument name is the same as the name of another entity, the appearance of that name in the expression of a statement function statement is a reference to the statement function dummy argument. A dummy argument that appears in a FUNCTION or SUBROUTINE statement may be referenced in the expression of a statement function statement within the subprogram. A dummy argument that appears in an ENTRY statement that precedes a statement function statement may be referenced in the expression of the statement function statement within the subprogram.
Execution of a statement function reference results in:
The resulting value is available to the expression that contains the function reference.
The actual arguments, which constitute the argument list, must agree in order, number, and type with the corresponding dummy arguments. An actual argument in a statement function reference may be any expression except a character expression involving concatenation of an operand whose length specification is an asterisk in parentheses unless the operand is the symbolic name of a constant.
When a statement function reference is executed, its actual arguments must be defined.
A statement function statement must not contain a reference to another statement function that appears following the reference in the sequence of lines in the program unit. The symbolic name used to identify a statement function must not appear as a symbolic name in any specification statement except in a type-statement (to specify the type of the function) or as the name of a common block in the same program unit.
An external function reference in the expression of a statement function statement must not cause a dummy argument of the statement function to become undefined or redefined.
The symbolic name of a statement function is a local name ( 18.1.2) and must not be the same as the name of any other entity in the program unit except the name of a common block.
The symbolic name of a statement function may not be an actual argument. It must not appear in an EXTERNAL statement.
A statement function statement in a function subprogram must not contain a function reference to the name of the function subprogram or an entry name in the function subprogram.
The length specification of a character statement function or statement function dummy argument of type character must be an integer constant expression.
The form of a FUNCTION statement is:
[typ] FUNCTION fun ( [d [,d]...] )
The symbolic name of a function subprogram or an associated entry name of the same type must appear as a variable name in the function subprogram. During every execution of the external function, this variable must become defined and, once defined, may be referenced or become redefined. The value of this variable when a RETURN or END statement is executed in the subprogram is the value of the function. If this variable is a character variable with a length specification that is an asterisk in parentheses, it must not appear as an operand for concatenation except in a character assignment statement ( 10.4).
An external function in a function subprogram may define one or more of its dummy arguments to return values in addition to the value of the function.
The type of the function name in the function reference must be the same as the type of the function name in the referenced function. The length of the character function in a character function reference must be the same as the length of the character function in the referenced function.
When an external function reference is executed, the function must be one of the external functions in the executable program.
An actual argument in Tan external function reference must be one of the following:
Note that an actual argument in a function reference may be a dummy argument that appears in a dummy argument list within the subprogram containing the reference.
The symbolic name of an external function is a global name ( 18.1.1) and must not be the same as any other global name or any local name, except a variable name, in the function subprogram.
Within a function subprogram, the symbolic name of a function specified by a FUNCTION or ENTRY statement must not appear in any other nonexecutable statement, except a type-statement. In an executable statement, such a name may appear only as a variable.
If the type of a function is specified in a FUNCTION statement, the function name must not appear in a type-statement. Note that a name must not have its type explicitly specified more than once in a program unit.
If the name of a function subprogram is of type character, each entry name in the function subprogram must be of type character. If the name of the function subprogram or any entry in the subprogram has a length of (*) declared, all such entities must have a length of (*) declared; otherwise, all such entities must have a length specification of the same integer value.
In a function subprogram, the symbolic name of a dummy argument is local to the program unit and must not appear in an EQUIVALENCE, PARAMETER, SAVE, INTRINSIC, DATA, or COMMON statement, except as a common block name.
A character dummy argument whose length specification is an asterisk in parentheses must not appear as an operand for concatenation, except in a character assignment statement ( 10.4).
A function specified in a subprogram may be referenced within any other procedure subprogram or the main program of the executable program. A function subprogram must not reference itself, either directly or indirectly.
The form of a SUBROUTINE statement is:
SUBROUTINE sub [( [d [,d]...] )]
Note that if there are no dummy arguments, either of the forms sub or sub() may be used in the SUBROUTINE statement. A subroutine that is specified by either form may be referenced by a CALL statement of the form CALL sub or CALL sub().
One or more dummy arguments of a subroutine in a subprogram may become defined or redefined to return results.
CALL sub [( [a [,a]...] )]
Return of control from the referenced subroutine completes execution of the CALL statement.
A subroutine specified in a subprogram may be referenced within any other procedure subprogram or the main program of the executable program. A subprogram must not reference itself, either directly or indirectly.
When a CALL statement is executed, the referenced subroutine must be one of the subroutines specified in subroutine subprograms or by other means in the executable program.
An actual argument in a subroutine reference must be one of the following:
Note that an actual argument in a subroutine reference may be a dummy argument name that appears in a dummy argument list within the subprogram containing the reference. An asterisk dummy argument must not be used as an actual argument in a subprogram reference.
The symbolic name of a subroutine is a global name ( 18.1.1) and must not be the same as any other global name or any local name in the program unit.
In a subroutine subprogram, the symbolic name of a dummy argument is local to the program unit and must not appear in an EQUIVALENCE, PARAMETER, SAVE, INTRINSIC, DATA, or COMMON statement, except as a common block name.
A character dummy argument whose length specification is an asterisk in parentheses must not appear as an operand for concatenation, except in a character assignment statement ( 10.4).
Optionally, a subprogram may have one or more ENTRY statements.
An ENTRY statement is classified as a nonexecutable statement.
ENTRY en [( [d [,d]...] )]
Note that if there are no dummy arguments, either of the forms en or en() may be used in the ENTRY statement. A function that is specified by either form must be referenced by the form en() ( 15.2.1). A subroutine that is specified by either form may be referenced by a CALL statement of the form CALL en or CALL en() .
The entry name en in a function subprogram may appear in a type-statement.
When an entry name en is used to reference a procedure, execution of the procedure begins with the first executable statement that follows the ENTRY statement whose entry name is en .
An entry name is available for reference in any program unit of an executable program, except in the program unit that contains the entry name in an ENTRY statement.
The order, number, type, and names of the dummy arguments in an ENTRY statement may be different from the order, number, type, and names of the dummy arguments in the FUNCTION statement or SUBROUTINE statement and other ENTRY statements in the same subprogram. However, each reference to a function or subroutine must use an actual argument list that agrees in order, number, and type with the dummy argument list in the corresponding FUNCTION, SUBROUTINE, or ENTRY statement. The use of a subroutine name or an alternate return specifier as an actual argument is an exception to the rule requiring agreement of type.
In a function subprogram, a variable name that is the same as an entry name must not appear in any statement that precedes the appearance of the entry name in an ENTRY statement, except in a type-statement.
If an entry name in a function subprogram is of type character, each entry name and the name of the function subprogram must be of type character. If the name of the function subprogram or any entry in the subprogram has a length of (*) declared, all such entities must have a length of (*) declared; otherwise, all such entities must have a length specification of the same integer value.
In a subprogram, a name that appears as a dummy argument in an ENTRY statement must not appear in an executable statement preceding that ENTRY statement unless it also appears in a FUNCTION, SUBROUTINE, or ENTRY statement that precedes the executable statement.
In a subprogram, a name that appears as a dummy argument in an ENTRY statement must not appear in the expression of a statement function statement unless the name is also a dummy argument of the statement function, appears in a FUNCTION or SUBROUTINE statement, or appears in an ENTRY statement that precedes the statement function statement.
If a dummy argument appears in an executable statement, the execution of the executable statement is permitted during the execution of a reference to the function or subroutine only if the dummy argument appears in the dummy argument list of the procedure name referenced. Note that the association of dummy arguments with actual arguments is not retained between references to a function or subroutine.
RETURNThe form of a RETURN statement in a subroutine subprogram is:
RETURN [e]where e is an integer expression.
In the execution of an executable program, a function or subroutine subprogram must not be referenced a second time without the prior execution of a RETURN or END statement in that procedure.
Execution of a RETURN statement in a function subprogram causes return of control to the currently referencing program unit. The value of the function ( 15.5) must be defined and is available to the referencing program unit.
Execution of a RETURN statement in a subroutine subprogram causes return of control to the currently referencing program unit. Return of control to the referencing program unit completes execution of the CALL statement.
Execution of a RETURN statement terminates the association between the dummy arguments of the external procedure in the subprogram and the current actual arguments.
If 1 <= e <= n , where n is the number of asterisks in the SUBROUTINE or subroutine ENTRY statement that specifies the currently referenced name, the value of e identifies the eth asterisk in the dummy argument list. Control is returned to the statement identified by the alternate return specifier in the CALL statement that is associated with the eth asterisk in the dummy argument list of the currently referenced name. This completes the execution of the CALL statement.
Note that if a named common block appears in the main program, the entities in the named common block do not become undefined at the execution of any RETURN statement in the executable program.
Data may be communicated to a statement function or intrinsic function by an argument list. Data may be communicated to and from an external procedure by an argument list or common blocks. Procedure names may be communicated to an external procedure only by an argument list.
A dummy argument appears in the argument list of a procedure. An actual argument appears in the argument list of a procedure reference.
The number of actual arguments must be the same as the number of dummy arguments in the procedure referenced.
Each dummy argument is classified as a variable, array, dummy procedure, or asterisk. Dummy argument names may appear wherever an actual name of the same class (Section 18) and type may appear, except where they are explicitly prohibited.
Dummy argument names of type integer may appear in adjustable dimensions in dummy array declarators ( 5.5.1). Dummy argument names must not appear in EQUIVALENCE, DATA, PARAMETER, SAVE, INTRINSIC, or COMMON statements, except as common block names. A dummy argument name must not be the same as the procedure name appearing in a FUNCTION, SUBROUTINE, ENTRY, or statement function statement in the same program unit.
The type of each actual argument must agree with the type of its associated dummy argument, except when the actual argument is a subroutine name ( 15.9.3.4) or an alternate return specifier ( 15.6.2.3).
All appearances within a function or subroutine subprogram of a dummy argument whose name appears in the dummy argument list of the procedure name referenced become associated with the actual argument when a reference to the function or subroutine is executed.
A valid association occurs only if the type of the actual argument is the same as the type of the corresponding dummy argument. A subroutine name has no type and must be associated with a dummy procedure name. An alternate return specifier has no type and must be associated with an asterisk.
If an actual argument is an expression, it is evaluated just before the association of arguments takes place.
If an actual argument is an array element name, its subscript is evaluated just before the association of arguments takes place. Note that the subscript value remains constant as long as that association of arguments persists, even if the subscript contains variables that are redefined during the association.
If an actual argument is a character substring name, its substring expressions are evaluated just before the association of arguments takes place. Note that the value of each of the substring expressions remains constant as long as that association of arguments persists, even if the substring expression contains variables that are redefined during the association.
If an actual argument is an external procedure name, the procedure must be available at the time a reference to it is executed.
If an actual argument becomes associated with a dummy argument that appears in an adjustable dimension ( 5.5.1), the actual argument must be defined with an integer value at the time the procedure is referenced.
A dummy argument is undefined if it is not currently associated with an actual argument. An adjustable array is undefined if the dummy argument array is not currently associated with an actual argument array or if any variable appearing in the adjustable array declarator is not currently associated with an actual argument and is not in a common block.
Argument association may be carried through more than one level of procedure reference. A valid association exists at the last level only if a valid association exists at all intermediate levels. Argument association within a program unit terminates at the execution of a RETURN or END statement in the program unit. Note that there is no retention of argument association between one reference of a subprogram and the next reference of the subprogram.
If a dummy argument of type character is an array name, the restriction on length is for the entire array and not for each array element. The length of an array element in the dummy argument array may be different from the length of an array element in an associated actual argument array, array element, or array element substring, but the dummy argument array must not extend beyond the end of the associated actual argument array.
If an actual argument is a character substring, the length of the actual argument is the length of the substring. If an actual argument is the concatenation of two or more operands, its length is the sum of the lengths of the operands.
If the actual argument is a variable name, array element name, or substring name, the associated dummy argument may be defined or redefined within the subprogram. If the actual argument is a constant, a symbolic name of a constant, a function reference, an expression involving operators, or an expression enclosed in parentheses, the associated dummy argument must not be redefined within the subprogram.
A dummy argument that is an array may be associated with an actual argument that is an array, array element, or array element substring.
If the actual argument is a noncharacter array name, the size of the dummy argument array must not exceed the size of the actual argument array, and each actual argument array element becomes associated with the dummy argument array element that has the same subscript value as the actual argument array element. Note that association by array elements exists for character arrays if there is agreement in length between the actual argument and the dummy argument array elements; if the lengths do not agree, the dummy and actual argument array elements do not consist of the same characters, but an association still exists.
If the actual argument is a noncharacter array element name, the size of the dummy argument array must not exceed the size of the actual argument array plus one minus the subscript value of the array element. When an actual argument is a noncharacter array element name with a subscript value of as , the dummy argument array element with a subscript value of ds becomes associated with the actual argument array element that has a subscript value of as + ds - 1 (Table 1, 5.4.3).
If the actual argument is a character array name, character array element name, or character array element substring name and begins at character storage unit acu of an array, character storage unit dcu of an associated dummy argument array becomes associated with character storage unit acu + dcu - 1 of the actual argument array.
If a dummy argument is used as if it were an external function, the associated actual argument must be an intrinsic function, external function, or dummy procedure. A dummy argument that becomes associated with an intrinsic function never has any automatic typing property, even if the dummy argument name appears in Table 5 ( 15.10). Therefore, the type of the dummy argument must agree with the type of the result of all specific actual arguments that become associated with the dummy argument. If a dummy argument name is used as if it were an external function and that name also appears in Table 5, the intrinsic function corresponding to the dummy argument name is not available for referencing within the subprogram.
A dummy argument that is used as a procedure name in a function reference and is associated with an intrinsic function must have arguments that agree in order, number, and type with those specified in Table 5 for the intrinsic function.
If a dummy argument appears in a type-statement and an EXTERNAL statement, the actual argument must be the name of an intrinsic function, external function, or dummy procedure.
If the dummy argument is referenced as a subroutine, the actual argument must be the name of a subroutine or dummy procedure and must not appear in a type-statement or be referenced as a function.
Note that it may not be possible to determine in a given program unit whether a dummy procedure is associated with a function or a subroutine. If a procedure name appears only in a dummy argument list, an EXTERNAL statement, and an actual argument list, it is not possible to determine whether the symbolic name becomes associated with a function or subroutine by examination of the subprogram alone.
A dummy argument that is an asterisk may be associated only with an actual argument that is an alternate return specifier in the CALL statement that identifies the current referencing name. If a dummy argument is an asterisk, the corresponding actual argument must be an alternate return specifier.
SUBROUTINE XYZ (A,B)and is referenced by
CALL XYZ (C,C)the[n the dummy arguments A and B each become associated with the same actual argument C and therefore with each other. Neither A nor B may become defined during this execution of subroutine XYZ or by any procedures referenced by XYZ.
If a subprogram reference causes a dummy argument to become associated with an entity in a common block in the referenced subprogram or in a subprogram referenced by the referenced subprogram, neither the dummy argument nor the entity in the common block may become defined within the subprogram or within a subprogram referenced by the referenced subprogram. For example, if a subroutine contains the statements:
and is referenced by a program unit that contains the statements:
then the dummy argument A becomes associated with the actual argument B, which is associated with C, which is in a common block. Neither A nor C may become defined during execution of the subroutine XYZ or by any procedures referenced by XYZ.
No difference in data type is permitted between the defined state and the type of the reference, except that either part of a complex datum may be referenced also as a real datum.
In a subprogram that has declared a named common block, the entities in the block remain defined after the execution of a RETURN or END statement if a common block of the same name has been declared in any program unit that is currently referencing the subprogram, either directly or indirectly. Otherwise, such entities become undefined at the execution of a RETURN or END statement, except for those that are specified by SAVE statements and those that were initially defined by DATA statements and have neither been redefined nor become undefined.
Execution of a RETURN or END statement does not cause entities in blank common or in any named common block that appears in the main program to become undefined.
Common blocks may be used also to reduce the total number of storage units required for an executable program by causing two or more subprograms to share some of the same storage units. This sharing of storage is permitted if the rules for defining and referencing data are not violated.
Notes for Table 5:
int(-3.7) = -3For a of type complex, int(a) is the value obtained by applying the above rule to the real part of a .
For a of type real, IFIX(a) is the same as INT(a) .
For a of type integer, FLOAT(a) is the same as REAL(a) .
For a of type complex, CMPLX(a) is a . For a of type integer, real, or double precision, CMPLX(a) is the complex value whose real part is REAL(a) and whose imaginary part is zero.
CMPLX(a ,a ) 1 2 is the complex value whose real part is REAL(a ) 1 and whose imaginary part is REAL(a ) 2 .
The value of ICHAR(a) is an integer in the range: 0 <= ICHAR(a) <= n-1 , where a is an argument of type character of length one. The value of a must be a character capable of representation in the processor. The position of that character in the collating sequence is the value of ICHAR.
For any characters c 1 and c 2 capable of representation in the processor, (c .LE c ) 1 2 is true if and only if (ICHAR(c ) .LE. ICHAR(c )) 1 2 is true, and (c .EQ. c ) 1 2 is true if and only if (ICHAR(c ) .EQ. ICHAR(c )) 1 2 is true.
CHAR(i) returns the character in the ith position of the processor collating sequence. The value is of type character of length one. i must be an integer expression whose value must be in the range 0 <= i <= n-1 .
If a 2 does not occur in a 1 , the value zero is returned. Note that zero is returned if LEN(a ) < LEN(a ) 1 2 .
LGT(a ,a ) 1 2 returns the value true if a 1 follows a 2 in the collating sequence described in ANSI X3.4-1977 (ASCII), and otherwise returns the value false.
LLE(a ,a ) 1 2 returns the value true if a =a 1 2 or if a 1 precedes a 2 in the collating sequence described in ANSI X3.4-1977 (ASCII), and otherwise returns the value false.
LLT(a ,a ) 1 2 returns the value true if a 1 precedes a 2 in the collating sequence described in ANSI X3.4-1977 (ASCII), and otherwise returns the value false.
If the operands for LGE, LGT, LLE, and LLT are of unequal length, the shorter operand is considered as if it were extended on the right with blanks to the length of the longer operand.
If either of the character entities being compared contains a character that is not in the ASCII character set, the result is processor-dependent.
The above restrictions on arguments and results also apply to the intrinsic functions when referenced by their generic names.
_________________________________________________________________________________________________ | | | | | | | | | | Number of| Generic| Specific| Type of | |Intrinsic_Function|__Definition_______|__Arguments|___Name__|__Name____|__Argument_|__Function_| | | | | | | | | |Type Conversion | Conversion | 1 | INT | - | Integer | Integer | | | to Integer | | | INT | Real | Integer | | | int(a) | | | IFIX | Real | Integer | | | See Note 1 | | | IDINT | Double | Integer | | | | | | - | Complex | Integer | | | __________________|___________|_________|__________|___________|___________| | | | | | | | | | | Conversion | 1 | REAL | REAL | Integer | Real | | | to Real | | | FLOAT | Integer | Real | | | See Note 2 | | | - | Real | Real | | | | | | SNGL | Double | Real | | | __________________|___________|_________|__-_______|__Complex__|__Real_____| | | | | | | | | | | Conversion | 1 | DBLE | - | Integer | Double | | | to Double | | | - | Real | Double | | | See Note 3 | | | - | Double | Double | | | | | | - | Complex | Double | | | __________________|___________|_________|__________|___________|___________| | | | | | | | | | | Conversion | 1 or 2 | CMPLX | - | Integer | Complex | | | to Complex | | | - | Real | Complex | | | See Note 4 | | | - | Double | Complex | | | __________________|___________|_________|__-_______|__Complex__|__Complex__| | | | | | | | | | | Conversion | 1 | | ICHAR | Character| Integer | | | to Integer | | | | | | | | See Note 5 | | | | | | | | __________________|___________|_________|__________|___________|___________| | | | | | | | | | | Conversion | 1 | | CHAR | Integer | Character| | | to Character | | | | | | |__________________|__See_Note_5_______|___________|_________|__________|___________|___________| | | | | | | | | |Truncation | int(a) | 1 | AINT | AINT | Real | Real | | | See Note 1 | | | DINT | Double | Double | |__________________|___________________|___________|_________|__________|___________|___________| | | | | | | | | |Nearest Whole | int(a+.5) if a>=0| 1 | ANINT | ANINT | Real | Real | |__Number__________|__int(a-.5)_if_a<__|___________|_________|__DNINT___|__Double___|__Double___| | | | | | | | | |Nearest Integer | int(a+.5) if a>=0| 1 | NINT | NINT | Real | Integer | | | int(a-.5) if a<0 | | | IDNINT | Double | Integer | |__________________|___________________|___________|_________|__________|___________|___________| | | | | | | | | |Absolute Value | |a| | 1 | ABS | IABS | Integer | Integer | | | See Note 6 | | | ABS | Real | Real | | | 2 1/2 | | | DABS | Double | Double | |__________________|__(ar_+ai_)________|___________|_________|__CABS____|__Complex__|__Real_____|
________________________________________________________________________________________________ | | | | | | | | | | Number of| Generic| Specific| Type of | |Intrinsic_Function_|__Definition______|__Arguments|___Name__|__Name____|__Argument_|__Function| | | | | | | | | |Remaindering | a -int(a /a )*a | 2 | MOD | MOD | Integer | Integer | | | 1 1 2 2| | | AMOD | Real | Real | | | See Note 1 | | | DMOD | Double | Double | |___________________|__________________|___________|_________|__________|___________|__________| | | | | | | | | |Transfer of Sign | |a1| if a2 >= 0| 2 | SIGN | ISIGN | Integer | Integer | | | -|a1| if a2 < 0 | | | SIGN | Real | Real | |___________________|__________________|___________|_________|__DSIGN___|__Double___|__Double__| | | | | | | | | |Positive Difference| a -a if a >a | 2 | DIM | IDIM | Integer | Integer | | | 10 2 if a1<=2 | | | DIM | Real | Real | | | 1 2 | | | DDIM | Double | Double | |___________________|__________________|___________|_________|__________|___________|__________| | | | | | | | | |Double Precision | a1*a2 | 2 | | DPROD | Real | Double | |__Product__________|__________________|___________|_________|__________|___________|__________| | | | | | | | | |Choosing Largest | max(a ,a ,...) | >=2 | Max | MAX0 | Integer | Integer | | Value | 1 2 | | | AMAX1 | Real | Real | | | | | | DMAX1 | Double | Double | | | | | ________|__________|___________|__________| | | | | | | | | | | | | | AMAX0 | Integer | Real | |___________________|__________________|___________|_________|__MAX1____|__Real_____|__Integer_| | | | | | | | | |Choosing Smallest | min(a ,a ,...) | >=2 | MIN | MIN0 | Integer | Integer | | Value | 1 2 | | | AMIN1 | Real | Real | | | | | | DMIN1 | Double | Double | | | | | ________|__________|___________|__________| | | | | | | | | | | | | | AMIN0 | Integer | Real | |___________________|__________________|___________|_________|__MIN1____|__Real_____|__Integer_| | | | | | | | | |Length | Length of | 1 | | LEN | Character| Integer | | | Character Entity| | | | | | |___________________|__________________|___________|_________|__________|___________|__________| | | | | | | | | |Index of | Location of | 2 | | INDEX | Character| Integer | |a Substring | Substring a2 | | | | | | | | in String a1 | | | | | | |___________________|__See_Note_1______|___________|_________|__________|___________|__________| | | | | | | | | |Imaginary Part of | ai | 1 | | AIMAG | Complex | Real | | Complex Argument | See Note 6 | | | | | | |___________________|__________________|___________|_________|__________|___________|__________| | | | | | | | | |Conjugate of a | (ar,-ai) | 1 | | CONJG | Complex | Complex | |_Complex_Argument__|__See_Note_6______|___________|_________|__________|___________|__________| | | | | | | | | |Square Root | (a)1/2 | 1 | SQRT | SQRT | Real | Real | | | | | | DSQRT | Double | Double | | | | | | CSQRT | Complex | Complex | |___________________|__________________|___________|_________|__________|___________|__________|
___________________________________________________________________________________________ | | | | | | | | | | Number of| Generic| Specific| Type of | |Intrinsic_Function|__Definition___|__Arguments|___Name__|__Name____|__Argument|__Function| | | | | | | | | |Exponential | e**a | 1 | EXP | EXP | Real | Real | | | | | | DEXP | Double | Double | | | | | | CEXP | Complex | Complex | |__________________|_______________|___________|_________|__________|__________|__________| | | | | | | | | |Natural Logarithm | log(a) | 1 | LOG | ALOG | Real | Real | | | | | | DLOG | Double | Double | |__________________|_______________|___________|_________|__CLOG____|__Complex_|__Complex_| | | | | | | | | |Common Logarithm | log10(a) | 1 | LOG10 | ALOG10 | Real | Real | | | | | | DLOG10 | Double | Double | |__________________|_______________|___________|_________|__________|__________|__________| | | | | | | | | |Sine | sin(a) | 1 | SIN | SIN | Real | Real | | | | | | DSIN | Double | Double | |__________________|_______________|___________|_________|__CSIN____|__Complex_|__Complex_| | | | | | | | | |Cosine | cos(a) | 1 | COS | COS | Real | Real | | | | | | DCOS | Double | Double | | | | | | CCOS | Complex | Complex | |__________________|_______________|___________|_________|__________|__________|__________| | | | | | | | | |Tangent | tan(a) | 1 | TAN | TAN | Real | Real | |__________________|_______________|___________|_________|__DTAN____|__Double__|__Double__| | | | | | | | | |Arcsine | arcsin(a) | 1 | ASIN | ASIN | Real | Real | | | | | | DASIN | Double | Double | |__________________|_______________|___________|_________|__________|__________|__________| | | | | | | | | |Arccosine | arccos(a) | 1 | ACOS | ACOS | Real | Real | |__________________|_______________|___________|_________|__DACOS___|__Double__|__Double__| | | | | | | | | |Arctangent | arctan(a) | 1 | ATAN | ATAN | Real | Real | | | | | | DATAN | Double | Double | | | ______________|___________|_________|__________|__________|__________| | | | | | | | | | | arctan(a1/a2)| 2 | ATAN2 | ATAN2 | Real | Real | |__________________|_______________|___________|_________|__DATAN2__|__Double__|__Double__| | | | | | | | | |Hyperbolic Sine | sinh(a) | 1 | SINH | SINH | Real | Real | | | | | | DSINH | Double | Double | |__________________|_______________|___________|_________|__________|__________|__________| | | | | | | | | |Hyperbolic Cosine | cosh(a) | 1 | COSH | COSH | Real | Real | |__________________|_______________|___________|_________|__DCOSH___|__Double__|__Double__| | | | | | | | | |Hyperbolic Tangent| tanh(a) | 1 | TANH | TANH | Real | Real | | | | | | DTANH | Double | Double | |__________________|_______________|___________|_________|__________|__________|__________|
__________________________________________________________________________________________ | | | | | | | | | | Number of| Generic| Specific| Type of | |Intrinsic_Function|__Definition_|__Arguments|___Name__|__Name____|__Argument_|__Function| | | | | | | | | |Lexically Greater | a >= a | 2 | | LGE | Character| Logical | | Than or Equal | 1 2 | | | | | | | | See Note 12| | | | | | |__________________|_____________|___________|_________|__________|___________|__________| | | | | | | | | |Lexically Greater | a1 > a2 | 2 | | LGT | Character| Logical | |__Than____________|__See_Note_12|___________|_________|__________|___________|__________| | | | | | | | | |Lexically Less | a <= a | 2 | | LLE | Character| Logical | | Than or Equal | 1 2 | | | | | | | | See Note 12| | | | | | |__________________|_____________|___________|_________|__________|___________|__________| | | | | | | | | |Lexically Less | a1 < a2 | 2 | | LLT | Character| Logical | |__Than____________|__See_Note_12|___________|_________|__________|___________|__________|
'