This table shows the number of arguments for each function and what data
types are permitted. The data type codes are: `I` = Integer, `R`
= Real, `D` = Double precision, `X` = Complex, `C` =
Character, `L` = Logical, `*` means the result has the same data
type as the argument(s). Note that if there is more than one argument in
such cases they must all have the same data type.

R = ABS(X) |
Takes the modulus of a complex number (i.e. the square-root of the sum of the squares of the two components). |

* = ACOS(RD) |
Arc-cosine; the result is in the range 0 to |

R = AIMAG(X) |
Extracts the imaginary component of a complex number. Use REAL to extract the real component. |

* = ANINT(RD) |
Rounds to the nearest whole number. |

* = ATAN2(RD,RD) |
Arc-tangent of arg/_{1}arg
resolved into the
correct quadrant, the result is in the range
to . It is an error to have both arguments zero._{2} |

C = CHAR(I) |
Returns Nth character in local character code table. |

X = CMPLX(IRDX,IRD) |
Converts to complex, second arg optional. |

X = CONJG(X) |
Computes the complex conjugate of a complex number. |

* = COS(RDX) |
Cosine of the angle in radians. |

D = DBLE(IRDX) |
Converts to double precision. |

* = DIM(IRD,IRD) |
Returns the positive difference of arg and
_{1}arg, i.e. if _{2}arg > _{1}arg it returns (_{2}arg - _{1}arg),
otherwise zero._{2} |

D = DPROD(R,R) |
Computes the double precision product of two real values. |

* = EXP(RDX) |
Returns the exponential, i.e. e to the power
of the argument. This is the inverse of the natural logarithm. |

I = ICHAR(C) |
Returns position of first character of the string in the local character code table. |

I = INDEX(C,C) |
Searches first string and returns position of second string within it starting at 1, otherwise zero. |

I = INT(IRDX) |
Converts to integer by truncation. |

I = LEN(C) |
Returns length of the argument in characters. |

L = LGE(C,C) |
Lexical comparison using ASCII collating sequence:
returns true if arg >= _{1}arg._{2} |

L = LGT(C,C) |
Lexical comparison using ASCII collating sequence:
returns true if arg > _{1}arg._{2} |

L = LLE(C,C) |
Lexical comparison using ASCII collating sequence:
returns true if arg <= _{1}arg._{2} |

L = LLT(C,C) |
Lexical comparison using ASCII collating sequence:
returns true if arg < _{1}arg._{2} |

* = LOG(RDX) |
Logarithm to base e (where e=2.718...). |

* = LOG10(RD) |
Logarithm to base 10. |

* = MAX(IRD,IRD,...) |
Returns the largest of its arguments. |

* = MIN(IRD,IRD,...) |
Returns the smallest of its arguments. |

* = MOD(IRD,IRD) |
Returns arg modulo _{1}arg, i.e. the
remainder after dividing _{2}arg by _{1}arg._{2} |

R = REAL(IRDX) |
Converts to real. |

* = SIGN(IRD,IRD) |
Performs sign transfer: if arg is
negative the
result is -_{2}arg, if _{1}arg is zero or positive the result is
+_{2}arg._{1} |

* = SQRT(RDX) |
Square root (error if arg negative). |

* = TAN(RD) |
Tangent of the angle in radians. |