Format

OTS$CALL_PROC target-func-value ,target-sig-info ,standard-args ,...

Returns

None.

Arguments

Function value for the procedure to be called.

Signature information is used to transform the standard arguments into the form required by a translated image (if needed). The representation of signature information is described in the OpenVMS Calling Standard.

standard-args

Zero or more arguments to be passed to the called routine, passed using standard conventions (including the AI register).

Description

When translated code support is requested, the compiled code must call the special service routine, OTS$CALL_PROC. The actual parameters to the target function are passed to OTS$CALL_PROC as though the target routine is native code that is being invoked directly.

OTS$CALL_PROC first determines whether the target routine is part of a translated image.

If the target is in native code, then OTS$CALL_PROC completes the call in a way that makes its mediation transparent (that is, control need not pass back through it for the return). The native parameters are used without modification.

If the target is in translated code, then OTS$CALL_PROC passes control to the Translated Image Environment (TIE). For additional information, see the VSI OpenVMS Calling Standard.

Condition Values Returned

None.

Format

OTS$CNVOUT
   D-G-H-S-or-T-float-pt-input-val ,fixed-length-resultant-string
   ,digits-in-fraction

OTS$CNVOUT_G
   D-G-H-S-or-T-float-pt-input-val ,fixed-length-resultant-string
   ,digits-in-fraction

OTS$CNVOUT_H
   D-G-H-S-or-T-float-pt-input-val ,fixed-length-resultant-string
   ,digits-in-fraction (VAX only)

OTS$CNVOUT_S
   D-G-H-S-or-T-float-pt-input-val ,fixed-length-resultant-string
   ,digits-in-fraction (VAX only)

OTS$CNVOUT_T
   D-G-H-S-or-T-float-pt-input-val ,fixed-length-resultant-string
   ,digits-in-fraction (VAX only)

Returns

Arguments

Value that OTS$CNVOUT converts to a character string. For OTS$CNVOUT, the D-G-H-S-or-T-float-pt-input-val argument is the address of a D-floating number containing the value. For OTS$CNVOUT_G, the D-G-H-S-or-T-float-pt-input-val argument is the address of a G-floating number containing the value. For OTS$CNVOUT_S, the D-G-H-S-or-T-float-pt-input-val argument is the address of an IEEE S-floating number containing the value. For OTS$CNVOUT_T, the D-G-H-S-or-T-float-pt-input-val argument is the address of an IEEE T-floating number containing the value.

Output string into which OTS$CNVOUT writes the character string result of the conversion. The fixed-length-resultant-string argument is the address of a descriptor pointing to the output string.

Number of digits in the fractional portion of the result. The digits-in-fraction argument is an unsigned longword containing the number of digits to be written to the fractional portion of the result.

Condition Values Returned

Format

OTS$CVT_L_TB
   varying-input-value,fixed-length-resultant-string [,number-of-digits]
   [,input-value-size]

Returns

Arguments

Unsigned byte, word, or longword that OTS$CVT_L_TB converts to an unsigned decimal representation in an ASCII text string. (The value of the input-value-size argument determines whether varying-input-value is a byte, word, or longword.) The varying-input-value argument is the address of the unsigned integer.

ASCII text string that OTS$CVT_L_TB creates when it converts the integer value. The fixed-length-resultant-string argument is the address of a descriptor pointing to this ASCII text string. The string is assumed to be of fixed length (CLASS_S descriptor).

Minimum number of digits in the binary representation to be generated. The number-of-digits argument is a signed longword containing this minimum number. If the minimum number of digits is omitted, the default is 1. If the actual number of significant digits is less than the minimum number of digits, leading zeros are produced. If the minimum number of digits is zero and the value of the integer to be converted is also zero, OTS$CVT_L_TB creates a blank string.

Size of the integer to be converted, in bytes. The input-value-size argument is a signed longword containing the byte size. This is an optional argument. If the size is omitted, the default is 4 (longword).

Condition Values Returned

Format

OTS$CVT_L_TI
   varying-input-value ,fixed-length-resultant-string [,number-of-digits]
   [,input-value-size] [,flags-value]

Returns

Arguments

A signed integer that OTS$CVT_L_TI converts to a signed decimal representation in an ASCII text string. The varying-input-value argument is the address of the signed integer.

On VAX systems, the integer can be a signed byte, word, or longword. The value of the input-value-size argument determines whether varying-input-value is a byte, word, or longword.

On Alpha and I64 systems, the integer can be a signed byte, word, longword, or quadword. The value of the input-value-size argument determines whether varying-input-value is a byte, word, longword, or quadword.

Decimal ASCII text string that OTS$CVT_L_TI creates when it converts the signed integer. The fixed-length-resultant-string argument is the address of a CLASS_S descriptor pointing to this text string. The string is assumed to be of fixed length.

Minimum number of digits to be generated when OTS$CVT_L_TI converts the signed integer to a decimal ASCII text string. The number-of-digits argument is a signed longword containing this number. If the minimum number of digits is omitted, the default value is 1. If the actual number of significant digits is smaller, OTS$CVT_L_TI inserts leading zeros into the output string. If number-of-digits is zero and varying-input-value is zero, OTS$CVT_L_TI writes a blank string to the output string.

Size of the integer to be converted, in bytes. The input-value-size argument is a signed longword containing this value size. If the size is omitted, the default is 4 (longword).

On VAX systems, the value size must be 1, 2, or 4. If value size is 1 or 2, the value is sign-extended to a longword before conversion.

On Alpha and I64 systems, the value size must be 1, 2, 4, or 8. If the value is 1, 2, or 4, the value is sign-extended to a quadword before conversion.

Caller-supplied flags that you can use if you want OTS$CVT_L_TI to insert a plus sign before the converted number. The flags-value argument is an unsigned longword containing the flags.

The caller flags are described in the following table:

If flags-value is omitted, all bits are clear and the plus sign is not inserted.

Condition Values Returned

Format

OTS$CVT_L_TL longword-integer-value ,fixed-length-resultant-string

Returns

Arguments

Value that OTS$CVT_L_TL converts to an ASCII text string. The longword-integer-value argument is the address of a signed longword containing this integer value.

Output string that OTS$CVT_L_TL creates when it converts the integer value to an ASCII text string. The fixed-length-resultant-string argument is the address of a descriptor pointing to this ASCII text string.

The output string is assumed to be of fixed length (CLASS_S descriptor).

If bit 0 of longword-integer-value is set, OTS$CVT_L_TL stores the character T in the rightmost character of fixed-length-resultant-string. If bit 0 is clear, it stores the character F. In either case, it fills the remaining characters of fixed-length-resultant-string with blanks.

Condition Values Returned

Example

5 !+
  ! This is an example program
  ! showing the use of OTS$CVT_L_TL.
  !-

  VALUE% = 10
  OUTSTR$ = ' '
  CALL OTS$CVT_L_TL(VALUE%, OUTSTR$)
  PRINT OUTSTR$
9 END

This BASIC example illustrates the use of OTS$CVT_L_TL. The output generated by this program is 'F'.

Format

OTS$CVT_L_TO
   varying-input-value ,fixed-length-resultant-string [,number-of-digits]
   [,input-value-size]

Returns

Arguments

Unsigned byte, word, or longword that OTS$CVT_L_TO converts to an unsigned decimal representation in an ASCII text string. (The value of the input-value-size argument determines whether varying-input-value is a byte, word, or longword.) The varying-input-value argument is the address of the unsigned integer.

Output string that OTS$CVT_L_TO creates when it converts the integer value to an octal ASCII text string. The fixed-length-resultant-string argument is the address of a descriptor pointing to the octal ASCII text string. The string is assumed to be of fixed length (CLASS_S descriptor).

Minimum number of digits that OTS$CVT_L_TO generates when it converts the integer value to an octal ASCII text string. The number-of-digits argument is a signed longword containing the minimum number of digits. If it is omitted, the default is 1. If the actual number of significant digits in the octal ASCII text string is less than the minimum number of digits, OTS$CVT_L_TO inserts leading zeros into the output string. If number-of-digits is 0 and varying-input-value is 0, OTS$CVT_L_TO writes a blank string to the output string.

Size of the integer to be converted, in bytes. The input-value-size argument is a signed longword containing the number of bytes in the integer to be converted by OTS$CVT_L_TO. If it is omitted, the default is 4 (longword).

Condition Values Returned

Format

OTS$CVT_L_TU
   varying-input-value ,fixed-length-resultant-string [,number-of-digits]
   [,input-value-size]

Returns

Arguments

An unsigned integer that OTS$CVT_L_TU converts to an unsigned decimal representation in an ASCII text string. The varying-input-value argument is the address of the unsigned integer.

On VAX systems, the integer can be an unsigned byte, word, or longword. (The value of the input-value-size argument determines whether varying-input-value is a byte, word, or longword.)

On Alpha and I64 systems, the integer can be an unsigned byte, word, longword, or quadword. (The value of the input-value-size argument determines whether varying-input-value is a byte, word, longword, or quadword.)

Output string that OTS$CVT_L_TU creates when it converts the integer value to unsigned decimal representation in an ASCII text string. The fixed-length-resultant-string argument is the address of a descriptor pointing to this ASCII text string.

Minimum number of digits in the ASCII text string that OTS$CVT_L_TU creates. The number-of-digits argument is a signed longword containing the minimum number. If the minimum number of digits is omitted, the default is 1.

If the actual number of significant digits in the output string created is less than the minimum number, OTS$CVT_L_TU inserts leading zeros into the output string. If the minimum number of digits is zero and the integer value to be converted is also zero, OTS$CVT_L_TU writes a blank string to the output string.

Size of the integer to be converted, in bytes. The input-value-size argument is a signed longword containing this value size. If the size is omitted, the default is 4 (longword).

On VAX systems, the value size must be 1, 2, or 4.

On Alpha and I64 systems, the value size must be 1, 2, 4, or 8.

Condition Values Returned

Format

OTS$CVT_L_TZ
   varying-input-value ,fixed-length-resultant-string [,number-of-digits]
   [,input-value-size]

Returns

Arguments

Unsigned byte, word, or longword that OTS$CVT_L_TZ converts to an unsigned decimal representation in an ASCII text string. (The value of the input-value-size argument determines whether varying-input-value is a byte, word, or longword.) The varying-input-value argument is the address of the unsigned integer.

Output string that OTS$CVT_L_TZ creates when it converts the integer value to a hexadecimal ASCII text string. The fixed-length-resultant-string argument is the address of a descriptor pointing to this ASCII text string. The string is assumed to be of fixed length (CLASS_S descriptor).

Minimum number of digits in the ASCII text string that OTS$CVT_L_TZ creates when it converts the integer. The number-of-digits argument is a signed longword containing this minimum number. If it is omitted, the default is 1. If the actual number of significant digits in the text string that OTS$CVT_L_TZ creates is less than this minimum number, OTS$CVT_L_TZ inserts leading zeros in the output string. If the minimum number of digits is zero and the integer value to be converted is also zero, OTS$CVT_L_TZ writes a blank string to the output string.

Size of the integer that OTS$CVT_L_TZ converts, in bytes. The input-value-size argument is a signed longword containing the value size. If the size is omitted, the default is 4 (longword).

Condition Values Returned

Example

with TEXT_IO; use TEXT_IO;
procedure SHOW_CONVERT is

   type INPUT_INT is new INTEGER range 0..INTEGER'LAST;

   INTVALUE : INPUT_INT := 256;
   HEXSTRING : STRING(1..11);

   procedure CONVERT_TO_HEX (I : in INPUT_INT; HS : out STRING);
   pragma INTERFACE (RTL, CONVERT_TO_HEX);
   pragma IMPORT_routine (INTERNAL => CONVERT_TO_HEX,
                            EXTERNAL => "OTS$CVT_L_TZ",
                            MECHANISM =>(REFERENCE,
                                         DESCRIPTOR (CLASS => S)));

begin
   CONVERT_TO_HEX (INTVALUE, HEXSTRING);
   PUT_LINE("This is the value of HEXSTRING");
   PUT_LINE(HEXSTRING);
end;

This Ada example uses OTS$CVT_L_TZ to convert a longword integer to hexadecimal text.

Format

OTS$CVT_T_D
   fixed-or-dynamic-input-string ,floating-point-value
   [,digits-in-fraction] [,scale-factor] [,flags-value] [,extension-bits]

OTS$CVT_T_F
   fixed-or-dynamic-input-string ,floating-point-value
   [,digits-in-fraction] [,scale-factor] [,flags-value] [,extension-bits]

OTS$CVT_T_G
   fixed-or-dynamic-input-string ,floating-point-value
   [,digits-in-fraction] [,scale-factor] [,flags-value] [,extension-bits]

OTS$CVT_T_H
   fixed-or-dynamic-input-string ,floating-point-value
   [,digits-in-fraction] [,scale-factor] [,flags-value] [,extension-bits]

OTS$CVT_T_S
   fixed-or-dynamic-input-string ,floating-point-value
   [,digits-in-fraction] [,scale-factor] [,flags-value] [,extension-bits]

OTS$CVT_T_T
   fixed-or-dynamic-input-string ,floating-point-value
   [,digits-in-fraction] [,scale-factor] [,flags-value] [,extension-bits]

Returns

Arguments

fixed-or-dynamic-input-string

Input string containing an ASCII text string representation of a numeric value that OTS$CVT_T_xconverts to a D-floating, F-floating, G-floating, H-floating, IEEE S-floating, or IEEE T-floating value. The fixed-or-dynamic-input-string argument is the address of a descriptor pointing to the input string.

The syntax of a valid input string is as follows:

E, e, D, d, Q, and q are the possible exponent letters. They are semantically equivalent. Other elements in the preceding syntax are defined as follows:

Floating-point value that OTS$CVT_T_x creates when it converts the input string. The floating-point-value argument is the address of the floating-point value. The data type of floating-point-value depends on the called routine as shown in the following table:

Number of digits in the fraction if no decimal point is included in the input string. The digits-in-fraction argument contains the number of digits. If the number of digits is omitted, the default is zero.

Scale factor. The scale-factor argument contains the value of the scale factor. If bit 6 of the flags-value argument is clear, the resultant value is divided by 10^scale-factor unless the exponent is present. If bit 6 of flags-value is set, the scale factor is always applied. If the scale factor is omitted, the default is zero.

User-supplied flags. The flags-value argument contains the user-supplied flags described in the following table:

If you omit the flags-value argument, OTS$CVT_T_x defaults all flags to clear.

Extra precision bits. The extension-bits argument is the address of a word containing the extra precision bits. Ifextension-bits is present, floating-point-value is not rounded, and the first n bits after truncation are returned left-justified in this argument, as follows:

A value represented by extension bits is suitable for use as the extension operand in an EMOD instruction.

The extra precision bits returned for H-floating may not be precise because OTS$CVT_T_H carries its calculations to only 128 bits. However the error should be small.

Description

The OTS$CVT_T_D, OTS$CVT_T_F, OTS$CVT_T_G, OTS$CVT_T_H, OTS$CVT_T_S, and OTS$CVT_T_T routines support Fortran D, E, F, and G input type conversion as well as similar types for other languages.

These routines provide run-time support for BASIC and Fortran input statements.

Although Alpha and I64 systems do not generally support H-floating operations, you can use OTS$CVT_T_H to convert a text string to an H-floating value on an Alpha or I64 system.

Condition Values Returned

Example

C+
C This is a Fortran program demonstrating the use of
C OTS$CVT_T_F.
C-

        REAL*4 A
        CHARACTER*10 T(5)
        DATA T/'1234567+23','8.786534+3','-983476E-3','-23.734532','45'/
        DO 2 I = 1, 5
        TYPE 1,I,T(I)
 1      FORMAT(' Input string ',I1,' is ',A10)

C+
C B is the return status.
C T(I) is the string to be converted to an
C F-floating point value.  A is the F-floating
C point conversion of T(I).  %VAL(5) means 5 digits
C are in the fraction if no decimal point is in
C the input string T(I).
C-
        B = OTS$CVT_T_F(T(I),A,%VAL(5),,)
        TYPE *,' Output of OTSCVT_T_F is     ',A
        TYPE *,'  '
 2      CONTINUE
        END

Input string 1 is 1234567+23
 Output of OTSCVT_T_F is       1.2345669E+24
Input string 2 is 8.786534+3
 Output of OTSCVT_T_F is        8786.534
Input string 3 is -983476E-3
 Output of OTSCVT_T_F is      -9.8347599E-03
Input string 4 is -23.734532
 Output of OTSCVT_T_F is       -23.73453
Input string 5 is 45
 Output of OTSCVT_T_F is        45000.00

Format

OTS$CVT_TB_L
   fixed-or-dynamic-input-string ,varying-output-value [,output-value-size]
   [,flags-value]

Returns

Arguments

Input string containing the string representation of an unsigned binary value that OTS$CVT_TB_L converts to an unsigned integer value. The fixed-or-dynamic-input-string argument is the address of a descriptor pointing to the input string. The valid input characters are blanks and the digits 0 and 1. No sign is permitted.

Unsigned integer of specified size that OTS$CVT_TB_L creates when it converts the ASCII text string. The varying-output-value argument is the address of the integer. The value of the output-value-size argument determines the size in bytes of the output value.

Arbitrary number of bytes to be occupied by the unsigned integer output value. The output-value-size argument contains a value that equals the size in bytes of the output value. If the value ofoutput-value-size is zero or a negative number, OTS$CVT_TB_L returns an input conversion error. If you omit the output-value-size argument, the default is 4 (longword).

User-supplied flag that OTS$CVT_TB_L uses to determine how to interpret blanks within the input string. The flags-value argument contains this user-supplied flag.

OTS$CVT_TB_L defines the flag as follows:

If you omit the flags-value argument, OTS$CVT_TB_L defaults all flags to clear.

Condition Values Returned

Example

    OPTION                              &
        TYPE = EXPLICIT

    !+
    !   This program demonstrates the use of OTS$CVT_TB_L from BASIC.
    !   Several binary numbers are read and then converted to their
    !   integer equivalents.
    !-

    !+
    !   DECLARATIONS
    !-

    DECLARE STRING BIN_STR
    DECLARE LONG BIN_VAL, I, RET_STATUS
    DECLARE LONG CONSTANT FLAGS = 17        ! 2^0 + 2^4
    EXTERNAL LONG FUNCTION OTS$CVT_TB_L (STRING, LONG, &
        LONG BY VALUE, LONG BY VALUE)

    !+
    !   MAIN PROGRAM
    !-

    !+
    !   Read the data, convert it to binary, and print the result.
    !-



    FOR I = 1 TO 5
        READ BIN_STR
        RET_STATUS = OTS$CVT_TB_L( BIN_STR, BIN_VAL, '4'L, FLAGS)
        PRINT BIN_STR;" treated as a binary number equals";BIN_VAL
    NEXT I

    !+
    !   Done, end the program.
    !-

    GOTO 32767

999 Data    "1111", "1 111", "1011011", "11111111", "00000000"

32767 END

This BASIC example program demonstrates how to call OTS$CVT_TB_L to convert binary text to a longword integer.

1111 treated as a binary number equals 15
1 111 treated as a binary number equals 15
1011011 treated as a binary number equals 91
11111111 treated as a binary number equals 255
00000000 treated as a binary number equals 0

Format

OTS$CVT_TI_L
   fixed-or-dynamic-input-string ,varying-output-value [,output-value-size]
   [,flags-value]

Returns

Arguments

Input ASCII text string that OTS$CVT_TI_L converts to a signed integer. The fixed-or-dynamic-input-string argument is the address of a descriptor pointing to the input string.

The syntax of a valid ASCII text input string is as follows:

OTS$CVT_TI_L always ignores leading blanks.

varying-output-value

Signed integer that OTS$CVT_TI_L creates when it converts the ASCII text string. The varying-output-value argument is the address of the signed integer. The value of the output-value-sizeargument determines the size of varying-output-value.

Number of bytes to be occupied by the value created when OTS$CVT_TI_L converts the ASCII text string to an integer value. The output-value-size argument contains the number of bytes in varying-output-value.

On VAX systems, valid values for the output-value-size argument are 1, 2, and 4. The value determines whether the integer value that OTS$CVT_TI_L creates is a byte, word, or longword.

On Alpha and I64 systems, valid values for the output-value-size argument are 1, 2, 4, and 8. The value determines whether the integer value that OTS$CVT_TI_L creates is a byte, word, longword, or quadword.

For VAX and Alpha systems, if you specify a 0 (zero) or omit the output-value-size argument, the size of the output value defaults to 4 (longword). If you specify any other value, OTS$CVT_TI_L returns an input conversion error.

User-supplied flags that OTS$CVT_TI_L uses to determine how blanks and tabs are interpreted. The flags-value argument is an unsigned longword containing the value of the flags.

If you omit the flags-value argument, OTS$CVT_TI_L defaults all flags to clear.

Condition Values Returned

Format

OTS$CVT_TL_L
   fixed-or-dynamic-input-string ,varying-output-value [,output-value-size]

Returns

Arguments

Input string containing an ASCII text representation of a FORTRAN-77 L format that OTS$CVT_TL_L converts to a signed integer value. The fixed-or-dynamic-input-string argument is the address of a descriptor pointing to the input string.

Common ASCII text representations of a FORTRAN-77 logical are .TRUE., .FALSE., T, t, F, and f. In practice, an OTS$CVT_TL_L input string is valid if it adheres to the following syntax:

One of the letters T, t, F, or f is required. Other elements in the preceding syntax are defined as follows:

Signed integer that OTS$CVT_TL_L creates when it converts the ASCII text string. The varying-output-value argument is the address of the signed integer. The value of the output-value-size argument determines the size in bytes of the signed integer.

OTS$CVT_TL_L returns –1 as the contents of the varying-output-value argument if the character denoted by "letter" is T or t. Otherwise, OTS$CVT_TL_L sets varying-output-value to zero.

Number of bytes to be occupied by the signed integer created when OTS$CVT_TL_L converts the ASCII text string to an integer value. The output-value-size argument contains a value that equals the size in bytes of the output value. If output-value-size contains a zero or a negative number, OTS$CVT_TL_L returns an input conversion error.

On VAX systems, valid values for the output-value-size argument are 1, 2, and 4. The value determines whether the integer value that OTS$CVT_TL_L creates is a byte, word, or longword.

On Alpha and I64 systems, valid values for the output-value-size argument are 1, 2, 4, and 8. This value determines whether the integer value that OTS$CVT_TL_L creates is a byte, word, longword, or quadword.

For VAX, Alpha, and I64 systems, if you omit the output-value-size argument, the default is 4 (longword).

Condition Values Returned

Format

OTS$CVT_TO_L
   fixed-or-dynamic-input-string ,varying-output-value [,output-value-size]
   [,flags-value]

Returns

Arguments

Input string containing the string representation of an unsigned octal value that OTS$CVT_TO_L converts to an unsigned integer. The fixed-or-dynamic-input-string argument is the address of a descriptor pointing to the input string. The valid input characters are blanks and the digits 0 through 7. No sign is permitted.

Unsigned integer of specified size that OTS$CVT_TO_L creates when it converts the ASCII text string. The varying-output-value argument is the address of the unsigned integer. The value of the output-value-size argument determines the size in bytes of the output value.

Arbitrary number of bytes to be occupied by the unsigned integer output value. The output-value-size argument contains a value that equals the size in bytes of the output value. If the value ofoutput-value-size is zero or a negative number, OTS$CVT_TO_L returns an input conversion error. If you omit the output-value-size argument, the default is 4 (longword).

User-supplied flag that OTS$CVT_TO_L uses to determine how to interpret blanks within the input string. The flags-value argument contains the user-supplied flag described in the following table:

If you omit the flags-value argument, OTS$CVT_TO_L defaults the flag to clear.

Condition Values Returned

Example

OCTAL_CONV: PROCEDURE OPTIONS (MAIN) RETURNS (FIXED BINARY (31));

%INCLUDE $STSDEF;     /* Include definition of return status values */
DECLARE OTS$CVT_TO_L ENTRY
        (CHARACTER (*),       /* Input string passed by descriptor */
        FIXED BINARY (31),    /* Returned value passed by reference */
        FIXED BINARY VALUE,   /* Size for returned value passed by value */
        FIXED BINARY VALUE)   /* Flags passed by value */
        RETURNS (FIXED BINARY (31))   /* Return status */
        OPTIONS (VARIABLE);   /* Arguments may be omitted */

DECLARE INPUT CHARACTER (10);
DECLARE VALUE FIXED BINARY (31);
DECLARE SIZE  FIXED BINARY(31) INITIAL(4) READONLY STATIC; /* Longword */
DECLARE FLAGS FIXED BINARY(31) INITIAL(1) READONLY STATIC; /* Ignore 
                                                              blanks */

ON ENDFILE (SYSIN) STOP;

DO WHILE ('1'B);              /* Loop continuously, until end of file */
        PUT SKIP (2);
        GET LIST (INPUT) OPTIONS (PROMPT ('Octal value: '));
        STS$VALUE = OTS$CVT_TO_L (INPUT, VALUE, SIZE, FLAGS);
        IF ^STS$SUCCESS THEN RETURN (STS$VALUE);
        PUT SKIP EDIT (INPUT, 'Octal equals', VALUE, 'Decimal')
                        (A,X,A,X,F(10),X,A);
        END;

END OCTAL_CONV;

$ RUN OCTAL
Octal value: 1
1  Octal equals 1 Decimal
Octal value: 11
11   Octal equals   9 Decimal
Octal value: 1017346
1017346 Octal equals 274150 Decimal
Octal value: Ctrl/Z

Format

OTS$CVT_TU_L
   fixed-or-dynamic-input-string ,varying-output-value [,output-value-size]
   [,flags-value]

Returns

Arguments

Input string containing an ASCII text string representation of an unsigned decimal value that OTS$CVT_TU_L converts to an unsigned integer value. The fixed-or-dynamic-input-string argument is the address of a descriptor pointing to the input string. Valid input characters are the space and the digits 0 through 9. No sign is permitted.

Unsigned integer that OTS$CVT_TU_L creates when it converts the ASCII text string. The varying-output-value argument is the address of the unsigned integer. The value of the output-value-size argument determines the size of varying-output-value.

Number of bytes occupied by the value created when OTS$CVT_TU_L converts the input string. The output-value-size argument contains the number of bytes in varying-output-value.

On VAX systems, valid values for the output-value-size argument are 1, 2, and 4. The value determines whether the integer value that OTS$CVT_TU_L creates is a byte, word, or longword.

On Alpha and I64 systems, valid values for the output-value-size argument are 1, 2, 4, and 8. The value determines whether the integer value that OTS$CVT_TU_L creates is a byte, word, longword, or quadword.

For VAX, Alpha, and I64 systems, if you specify a 0 (zero) or omit the output-value-size argument, the size of the output value defaults to 4 (longword). If you specify any other value, OTS$CVT_TU_L returns an input conversion error.

User-supplied flags that OTS$CVT_TU_L uses to determine how blanks and tabs are interpreted. The flags-value argument contains the user-supplied flags as described in the following table:

If you omit the flags-value argument, OTS$CVT_TU_L defaults all flags to clear.

Condition Values Returned

Format

OTS$CVT_TZ_L
   fixed-or-dynamic-input-string ,varying-output-value [,output-value-size]
   [,flags-value]

Returns

Arguments

Input string containing the string representation of an unsigned hexadecimal value that OTS$CVT_TZ_L converts to an unsigned integer. The fixed-or-dynamic-input-string argument is the address of a descriptor pointing to the input string. The valid input characters are blanks, the digits 0 through 7, and the letters A through F. Letters can be uppercase or lowercase. No sign is permitted.

Unsigned integer of specified size that OTS$CVT_TZ_L creates when it converts the ASCII text string. The varying-output-value argument is the address of the unsigned integer. The value of the output-value-size argument determines the size in bytes of the output value.

Arbitrary number of bytes to be occupied by the unsigned integer output value. The output-value-size argument contains a value that equals the size in bytes of the output value. If the value ofoutput-value-size is zero or a negative number, OTS$CVT_TZ_L returns an input conversion error. If you omit the output-value-size argument, the default is 4 (longword).

User-supplied flags that OTS$CVT_TZ_L uses to determine how to interpret blanks within the input string. The flags-value argument contains these user-supplied flags as described in the following table:

If you omit the flags-value argument, OTS$CVT_TZ_L defaults the flag to clear.

Condition Values Returned

Examples

Format

OTS$DIVC complex-dividend ,complex-divisor

OTS$DIVCD_R3 complex-dividend ,complex-divisor (VAX only)

OTS$DIVCG_R3 complex-dividend ,complex-divisor

OTS$DIVCS complex-dividend ,complex-divisor

OTS$DIVCT_R3 complex-dividend ,complex-divisor

Each of these formats corresponds to one of the floating-point complex types.

Returns

Complex result of complex division. OTS$DIVC returns an F-floating complex number. OTS$DIVCD_R3 returns a D-floating complex number. OTS$DIVCG_R3 returns a G-floating complex number. OST$DIVCS returns an IEEE S-floating complex number. OTS$DIVCT_R3 returns an IEEE T-floating complex number.

Arguments

Complex dividend. The complex-dividend argument contains a floating-point complex value. For OTS$DIVC, complex-dividend is an F-floating complex number. For OTS$DIVCD_R3, complex-dividend is a D-floating complex number. For OTS$DIVCG_R3, complex-dividend is a G-floating complex number. For OTS$DIVCT_R3, complex-dividend is an IEEE T-floating complex number.

Complex divisor. The complex-divisor argument contains the value of the divisor. For OTS$DIVC,complex-divisor is an F-floating complex number. For OTS$DIVCD_R3, complex-divisor is a D-floating complex number. For OTS$DIVCG_R3, complex-divisor is a G-floating complex number. For OTS$DIVCS, complex-divisor is an IEEE S-floating complex number. For OTS$DIVCS, complex-dividend is an IEEE S-floating complex number. For OTS$DIVCT_R3, complex-divisoris an IEEE T-floating complex number.

Description

These routines return a complex result of a division on complex numbers.

The complex result is computed as follows:

r = (ac + bd)/(c2 + d2)
i = (bc - ad)/(c2 + d2)

On Alpha and I64 systems, some restrictions apply when linking OTS$DIVC or OTS$DIVCG_R3. See Chapter 1, Run-Time Library General Purpose (OTS$) Facility for more information about these restrictions.

Condition Values Signaled

Examples

Format

OTS$DIV_PK_LONG
   packed-decimal-dividend ,packed-decimal-divisor ,divisor-precision
   ,packed-decimal-quotient ,quotient-precision ,precision-data ,scale-data

Returns

Arguments

Dividend. The packed-decimal-dividend argument is the address of a packed decimal string that contains the shifted dividend.

c = 31 - prec(packed-decimal-dividend)

Multiplying packed-decimal-dividend by 10^c makes packed-decimal-dividend a 31-digit number.

Divisor. The packed-decimal-divisor argument is the address of a packed decimal string that contains the divisor.

Precision of the divisor. The divisor-precision argument is a signed word that contains the precision of the divisor. The high-order bits are filled with zeros.

Quotient. The packed-decimal-quotient argument is the address of the packed decimal string into which OTS$DIV_PK_LONG writes the quotient.

Precision of the quotient. The quotient-precision argument is a signed word that contains the precision of the quotient. The high-order bits are filled with zeros.

Additional digits of precision required. The precision-data argument is a signed word that contains the value of the additional digits of precision required.

precision-data = scale(packed-decimal-quotient)
+ scale(packed-decimal-divisor)
- scale(packed-decimal-dividend)
- 31 + prec(packed-decimal-dividend)

Scale factor of the decimal point. The scale-data argument is a signed word that contains the scale data.

scale-data = 31 - prec(packed-decimal-divisor)

Description

b = scale(packed-decimal-quotient)
+ scale(packed-decimal-divisor)
- scale(packed-decimal-dividend)
+ prec(packed-decimal-dividend)

If b is greater than 31, then OTS$DIV_PK_LONG can be used to perform the division. If b is less than 31, you could use the instruction DIVP instead.

When using this routine on an OpenVMS Alpha system, an I64 system, or on an OpenVMS VAX system and you have determined that you cannot use DIVP, you need to determine whether you should use OTS$DIV_PK_LONG or OTS$DIV_PK_SHORT. To determine this, you must examine the value of scale-data. If scale-data is less than or equal to 1, then you should use OTS$DIV_PK_LONG. If scale-data is greater than 1, you should use OTS$DIV_PK_SHORT instead.

Condition Values Returned

Example

1

    OPTION                              &
        TYPE = EXPLICIT

    !+
    !   This program uses OTS$DIV_PK_LONG to perform packed decimal
    !   division.
    !-


    !+
    !   DECLARATIONS
    !-

    DECLARE DECIMAL (31, 2)     NATIONAL_DEBT
    DECLARE DECIMAL (30, 3)     POPULATION
    DECLARE DECIMAL (10, 5)     PER_CAPITA_DEBT

    EXTERNAL SUB OTS$DIV_PK_LONG (DECIMAL(31,2), DECIMAL (30, 3), &
        WORD BY VALUE, DECIMAL(10, 5), WORD BY VALUE, WORD BY VALUE, &
        WORD BY VALUE)

    !+
    !   Prompt the user for the required input.
    !-

    INPUT   "Enter national debt: ";NATIONAL_DEBT
    INPUT   "Enter current population: ";POPULATION


    !+
    !   Perform the division and print the result.
    !
    !   scale(divd) = 2
    !   scale(divr) = 3
    !   scale(quot) = 5
    !
    !   prec(divd) = 31
    !   prec(divr) = 30
    !   prec(quot) = 10
    !
    !   prec-data  = scale(quot) + scale(divr) - scale(divd) - 31 +
    !                prec(divd)
    !   prec-data  =   5      +   3      -     2    - 31 +   31
    !   prec-data  = 6
    !
    !   b = scale(quot) + scale(divr) - scale(divd) + prec(divd)
    !   b =   5      +   3      -     2    +    31
    !   b = 37
    !
    !   c = 31 - prec(divd)
    !   c = 31 -   31
    !   c = 0
    !
    !   scale-data = 31 - prec(divr)
    !   scale-data = 31 -   30
    !   scale-data = 1
    !
    !   b is greater than 31, so either OTS$DIV_PK_LONG or
    !      OTS$DIV_PK_SHORT may be used to perform the division.
    !      If b is less than or equal to 31, then the DIVP
    !      instruction may be used.
    !
    !   scale-data is less than or equal to 1, so OTS$DIV_PK_LONG
    !      should be used instead of OTS$DIV_PK_SHORT.
    !
    !-

    CALL OTS$DIV_PK_LONG( NATIONAL_DEBT, POPULATION, '30'W,
    PER_CAPITA_DEBT, & '10'W, '6'W, '1'W)

    PRINT   "The per capita debt is ";PER_CAPITA_DEBT
    END

$ RUN DEBT
Enter national debt: ?  12345678
Enter current population: ?  1212
The per capita debt is 10186.20297

Format

OTS$DIV_PK_SHORT
   packed-decimal-dividend ,packed-decimal-divisor ,divisor-precision
   ,packed-decimal-quotient ,quotient-precision ,precision-data

Returns

Arguments

Dividend. The packed-decimal-dividend argument is the address of a packed decimal string that contains the shifted dividend.

c = 31 - prec(packed-decimal-dividend)

Multiplying packed-decimal-dividend by 10^c makes packed-decimal-dividend a 31-digit number.

Divisor. The packed-decimal-divisor argument is the address of a packed decimal string that contains the divisor.

Precision of the divisor. The divisor-precision argument is a signed word integer that contains the precision of the divisor; high-order bits are filled with zeros.

Quotient. The packed-decimal-quotient argument is the address of a packed decimal string into which OTS$DIV_PK_SHORT writes the quotient.

Precision of the quotient. The quotient-precision argument is a signed word that contains the precision of the quotient; high-order bits are filled with zeros.

Additional digits of precision required. The precision-data argument is a signed word that contains the value of the additional digits of precision required.

precision-data = scale(packed-decimal-quotient)
+ scale(packed-decimal-divisor)
- scale(packed-decimal-dividend)
- 31 + prec(packed-decimal-dividend)

Description

b = scale(packed-decimal-quotient) + scale(packed-decimal-divisor) -
  scale(packed-decimal-dividend) + prec(packed-decimal-dividend)

If b is greater than 31, then OTS$DIV_PK_SHORT can be used to perform the division. If b is less than 31, you could use the VAX instruction DIVP instead.

When using this routine on an OpenVMS Alpha system, an I64 system, or on an OpenVMS VAX system and you have determined that you cannot use DIVP, you need to determine whether you should use OTS$DIV_PK_LONG or OTS$DIV_PK_SHORT. To determine this, you must examine the value of scale-data. If scale-data is less than or equal to 1, then you should use OTS$DIV_PK_LONG. If scale-data is greater than 1, you should use OTS$DIV_PK_SHORT instead.

Condition Values Returned

Format

OTS$JUMP_TO_BPV bound-func-value ,standard-args ,...

Returns

None.

Arguments

Function value for the procedure being called.

standard-args

Zero or more arguments to be passed to the called routine, passed using standard conventions (including the AI register).

Description

When a procedure value that refers to a bound procedure descriptor is used to make a call, the routine designated in the OTS_ENTRY field (typically OTS$JUMP_TO_BPV) receives control with the GP register pointing to the bound procedure descriptor (instead of a global offset table). This routine performs the following steps:

Control arrives at the real target procedure address with both the GP and environment register values established appropriately.

   OTS$JUMP_TO_BPV::
        add     gp=gp,24        ; Adjust GP to point to entry address
        ld8     r9=[gp],16      ; Load target entry address
        mov     b6=r9
        ld8     r9=[gp],-8      ; Load target environment value
        ld8     gp=[gp]         ; Load target GP
        br      b6              ; Transfer to target

Note that there can be multiple OTS$JUMP_TO_BPV-like support routines, corresponding to different target registers where the environment value should be placed. The code that creates the bound function descriptor is also necessarily compiled by the same compiler that compiles the target procedure, thus can correctly select an appropriate support routine.

Condition Values Returned

None.

Format

OTS$MOVE3 length-value ,source-array ,destination-array

Corresponding JSB Entry Point

OTS$MOVE3_R5

Returns

None.

Arguments

Number of bytes of data to move. The length-value argument is a signed longword that contains the number of bytes to move. The value of length-value may range from 0 to 2,147,483,647 bytes.

Data to be moved by OTS$MOVE3. The source-array argument contains the address of an unsigned byte array that contains this data.

Address into which source-array will be moved. The destination-array argument is the address of an unsigned byte array into which OTS$MOVE3 writes the source data.

Description

OTS$MOVE3 performs the same function as the VAX MOVC3 instruction except that the length-value is a longword integer rather than a word integer. When called from the JSB entry point, the register outputs of OTS$MOVE3_R5 follow the same pattern as those of the MOVC3 instruction:

For more information, see the description of the MOVC3 instruction in the VAX Architecture Reference Manual. See also the routine LIB$MOVC3, which is a callable version of the MOVC3 instruction.

Condition Values Returned

None.

Format

OTS$MOVE5
   longword-int-source-length ,source-array ,fill-value
   ,longword-int-dest-length ,destination-array

Corresponding JSB Entry Point

OTS$MOVE5_R5

Returns

None.

Arguments

Number of bytes of data to move. The longword-int-source-length argument is a signed longword that contains this number. The value of longword-int-source-length may range from 0 to 2,147,483,647.

Data to be moved by OTS$MOVE5. The source-array argument contains the address of an unsigned byte array that contains this data.

Character used to pad the source data if longword-int-source-length is less than longword-int-dest-length. The fill-value argument contains the address of an unsigned byte that is this character.

Size of the destination area in bytes. The longword-int-dest-length argument is a signed longword containing this size. The value of longword-int-dest-length may range from 0 through 2,147,483,647.

Address into which source-array is moved. The destination-array argument is the address of an unsigned byte array into which OTS$MOVE5 writes the source data.

Description

OTS$MOVE5 performs the same function as the VAX MOVC5 instruction except that the longword-int-source-length and longword-int-dest-length arguments are longword integers rather than word integers. When called from the JSB entry point, the register outputs of OTS$MOVE5_R5 follow the same pattern as those of the MOVC5 instruction:

For more information, see the description of the MOVC5 instruction in the VAX Architecture Reference Manual. See also the routine LIB$MOVC5, which is a callable version of the MOVC5 instruction.

Condition Values Returned

None.

Format

OTS$MULCD_R3 complex-multiplier ,complex-multiplicand (VAX only)

OTS$MULCG_R3 complex-multiplier ,complex-multiplicand

OTS$MULCT_R3 complex-multiplier ,complex-multiplicand

OTS$MULCS complex-multiplier ,complex-multiplicand

These formats correspond to the D-floating, G-floating, IEEE S-floating, and IEEE T-floating complex types.

Returns

Complex result of multiplying two complex numbers. OTS$MULCD_R3 returns a D-floating complex number. OTS$MULCG_R3 returns a G-floating complex number. OTS$MULCS returns an IEEE S-Floating complex number. OTS$MULCT_R3 returns an IEEE T-floating complex number.

Arguments

Complex multiplier. The complex-multiplier argument contains the complex multiplier. For OTS$MULCD_R3, complex-multiplier is a D-floating complex number. For OTS$MULCG_R3, complex-multiplier is a G-floating complex number. For OTS$MULCS, complex-multiplier is a IEEE S-Floating complex number. For OTS$MULCT_R3, complex-multiplier is an IEEE T-floating complex number.

Complex multiplicand. The complex-multiplicand argument contains the complex multiplicand. For OTS$MULCD_R3, complex-multiplicand is a D-floating complex number. For OTS$MULCG_R3, complex-multiplicand is a G-floating complex number. For OTS$MULCS, complex-multiplicandis an IEEE S-floating complex number. For OTS$MULCT_R3, complex-multiplicand is an IEEE T-floating complex number.

Description

OTS$MULCx calculates the complex product of two complex values.

The complex product is computed as follows:

  (a,b) * (c,d) = (ac-bd) + 
                     
                        -1
                     
                  (ad+bc)
           Therefore:  r = ac - bd
           Therefore:  i = ad + bc

On Alpha and I64 systems, some restrictions apply when linking OTS$MULCG_R3, OTS$MULCS, and OTS$MULCT_R3. See Chapter 1, Run-Time Library General Purpose (OTS$) Facility for more information about these restrictions.

Condition Values Signaled

Example

C+
C    This Fortran example forms the product of
C    two complex numbers using OTS$MULCD_R3
C    and the Fortran random number generator RAN.
C
C    Declare Z1, Z2, and Z_Q as complex values. OTS$MULCD_R3
C    returns the complex product of Z1 times Z2:
C    Z_Q = Z1 * Z2
C-

        COMPLEX*16 Z1,Z2,Z_Q
C+
C    Generate a complex number.
C-
        Z1 = (8.0,4.0)
C+
C    Generate another complex number.
C-
        Z2 = (2.0,3.0)
C+
C    Compute the complex product of Z1*Z2.
C-
        Z_Q = Z1 * Z2
        TYPE *, ' The complex product of',Z1,' times ',Z2,' is'
        TYPE *, '     ',Z_Q
        END

 The complex product of (8.000000000000000,4.000000000000000) times
(2.000000000000000,3.000000000000000) is
      (4.000000000000000,32.00000000000000)

Format

OTS$POWCC complex-base ,complex-exponent-value

OTS$POWCDCD_R3 complex-base ,complex-exponent-value (VAX only)

OTS$POWCGCG_R3 complex-base ,complex-exponent-value

OTS$POWCSCS complex-base ,complex-exponent-value

OTS$POWCTCT_R3 complex-base ,complex-exponent-value

Each of these formats corresponds to one of the floating-point complex types.

Returns

Result of raising a complex base to a complex exponent. OTS$POWCC returns an F-floating complex number. OTS$POWCDCD_R3 returns a D-floating complex number. OTS$POWCGCG_R3 returns a G-floating complex number. OTS$POWCSCS returns an IEEE S-floating complex number. OTS$POWCTCT_R3 returns an IEEE T-floating complex number.

Arguments

Complex base. The complex-base argument contains the value of the base. For OTS$POWCC, complex-base is an F-floating complex number. For OTS$POWCDCD_R3, complex-base is a D-floating complex number. For OTS$POWCGCG_R3, complex-base is a G-floating complex number. For OTS$POWCSCS, complex-base is an IEEE S-floating complex number. For OTS$POWCTCT_R3, complex-base is an IEEE T-floating complex number.

Complex exponent. The complex-exponent-value argument contains the value of the exponent. For OTS$POWCC, complex-exponent-value is an F-floating complex number. For OTS$POWCDCD_R3, complex-exponent-value is a D-floating complex number. For OTS$POWCGCG_R3, complex-exponent-value is a G-floating complex number. For OTS$POWCSCS, complex-exponent-value is an IEEE S-floating complex number. For OTS$POWCTCT_R3, complex-exponent-value is an IEEE T-floating complex number.

Description

xy = exp(y * log(x)) 

In this example, x and y are of type COMPLEX.

On Alpha and I64 systems, some restrictions apply when linking OTS$POWCC or OTS$POWCGCG_R3. See Chapter 1, Run-Time Library General Purpose (OTS$) Facility for more information about these restrictions.

Condition Values Signaled

Examples

Format

OTS$POWCJ complex-base ,longword-integer-exponent

OTS$POWCDJ_R3 complex-base ,longword-integer-exponent (VAX only)

OTS$POWCGJ_R3 complex-base ,longword-integer-exponent (VAX only)

OTS$POWCSJ complex-base ,longword-integer-exponent

OTS$POWCTJ_R3 complex-base ,longword-integer-exponent

Each of these formats corresponds to one of the floating-point complex types.

Returns

Complex result of raising a complex base to an integer exponent. OTS$POWCJ returns an F-floating complex number. OTS$POWCDJ_R3 returns a D-floating complex number. OTS$POWCGJ_R3 returns a G-floating complex number. OTS$POWCGS_R3 returns an IEEE S-floating complex number. OTS$POWCGT_R3 returns an IEEE T-floating complex number. In each format, the result and base are of the same data type.

Arguments

Complex base. The complex-base argument contains the complex base. For OTS$POWCJ, complex-base is an F-floating complex number. For OTS$POWCDJ_R3, complex-base is a D-floating complex number. For OTS$POWCGJ_R3, complex-base is a G-floating complex number. For OTS$POWCSJ, complex-base is an IEEE S-floating complex number. For OTS$POWCTJ_R3,complex-base is an IEEE T-floating complex number.

Exponent. The longword-integer-exponent argument is a signed longword containing the exponent.

Description

The OTS$POWCxJ routines return the complex result of raising a complex base to an integer exponent. The complex result is as follows:

On Alpha and I64 systems, some restrictions apply when linking OTS$POWCJ, OTS$POWCSJ, and OTS$POWCTJ_R3. See Chapter 1, Run-Time Library General Purpose (OTS$) Facility for more information about these restrictions.

Condition Values Signaled

Example

+
C    This Fortran example raises a complex base to
C    a NONNEGATIVE integer power using OTS$POWCJ.
C
C    Declare Z1, Z2, Z3, and OTS$POWCJ as complex values.
C    Then OTS$POWCJ returns the complex result of
C    Z1**Z2:   Z3 = OTS$POWCJ(Z1,Z2),
C    where Z1 and Z2 are passed by value.
C-
        COMPLEX Z1,Z3,OTS$POWCJ
        INTEGER Z2
C+
C    Generate a complex base.
C-
        Z1 = (2.0,3.0)
C+
C    Generate an integer power.
C-
        Z2 = 2

C+
C    Compute the complex value of Z1**Z2.
C-
        Z3 = OTS$POWCJ( %VAL(REAL(Z1)), %VAL(AIMAG(Z1)), %VAL(Z2))
        TYPE 1,Z1,Z2,Z3
  1     FORMAT(' The value of (',F10.8,',',F11.8,')**',I1,' is
     +  (',F11.8,',',F12.8,').')
        END

The value of (2.00000000, 3.00000000)**2 is
(-5.00000000, 12.00000000).

Format

OTS$POWDD D-floating-point-base ,D-floating-point-exponent

Returns

Result of raising a D-floating base to a D-floating exponent.

Arguments

Base. The D-floating-point-base argument is a D-floating number containing the base.

Exponent. The D-floating-point-exponent argument is a D-floating number that contains the exponent.

Description

OTS$POWDD raises a D-floating base to a D-floating exponent.

The internal calculations and the floating-point result have the same precision as the base value.

The D-floating result for OTS$POWDD is given by the following:

Floating-point overflow can occur.

Undefined exponentiation occurs if the base is zero and the exponent is zero or negative, or if the base is negative.

Condition Values Signaled

Format

OTS$POWDJ D-floating-point-base ,longword-integer-exponent

Returns

Result of raising a D-floating base to a longword exponent.

Arguments

Base. The D-floating-point-base argument is a D-floating number containing the base.

Exponent. The longword-integer-exponent argument is a signed longword that contains the signed longword integer exponent.

Description

OTS$POWDJ raises a D-floating base to a longword exponent.

The internal calculations and the floating-point result have the same precision as the base value.

The floating-point result is as follows:

Floating-point overflow can occur.

Undefined exponentiation occurs if the base is zero and the exponent is zero or negative.

Condition Values Signaled

Format

OTS$POWDR D-floating-point-base ,F-floating-point-exponent

Returns

Result of raising a D-floating base to an F-floating exponent.

Arguments

Base. The D-floating-point-base argument is a D-floating number containing the base.

Exponent. The F-floating-point-exponent argument is an F-floating number that contains the exponent.

Description

OTS$POWDR raises a D-floating base to an F-floating exponent.

The internal calculations and the floating-point result have the same precision as the base value.

OTS$POWDR converts the F-floating exponent to a D-floating number. The D-floating result for OTS$POWDR is given by the following:

Floating-point overflow can occur.

Undefined exponentiation occurs if the base is zero and the exponent is zero or negative, or if the base is negative.

Condition Values Signaled

Format

OTS$POWGG G-floating-point-base ,G-floating-point-exponent

Returns

Result of raising a G-floating base to a G-floating exponent.

Arguments

Base that OTS$POWGG raises to a G-floating exponent. The G-floating-point-base argument is a G-floating number containing the base.

Exponent to which OTS$POWGG raises the base. The G-floating-point-exponent argument is a G-floating number containing the exponent.

Description

OTS$POWGG raises a G-floating base to a G-floating exponent.

The internal calculations and the floating-point result have the same precision as the base value.

The G-floating result for OTS$POWGG is as follows:

Floating-point overflow can occur.

Undefined exponentiation occurs if the base is zero and the exponent is zero or negative, or if the base is negative.

On Alpha and I64 systems, some restrictions apply when linking OTS$POWGG. See Chapter 1, Run-Time Library General Purpose (OTS$) Facility for more information about these restrictions.

Condition Values Signaled

Example

C+
C   This example demonstrates the use of OTS$POWGG,
C   which raises a G-floating point base
C   to a G-floating point power.
C-
        REAL*8 X,Y,RESULT,OTS$POWGG
C+
C   The arguments of OTS$POWGG are passed by value. Fortran can
C   only pass INTEGER and REAL*4 expressions as VALUE. Since
C   INTEGER and REAL*4 values are one longword long, while REAL*8
C   values are two longwords long, equate the base (and power) to
C   two-dimensional INTEGER vectors. These vectors will be passed
C   by VALUE.
C-
        INTEGER N(2),M(2)
        EQUIVALENCE (N(1),X), (M(1),Y)
        X = 8.0
        Y = 2.0
C+
C  To pass X by value, pass N(1) and N(2) by value. Similarly for Y.
C-
        RESULT = OTS$POWGG(%VAL(N(1)),%VAL(N(2)),%VAL(M(1)),%VAL(M(2)))
        TYPE *,' 8.0**2.0 IS ',RESULT
        X = 9.0
        Y = -0.5
C+
C   In Fortran, OTS$POWWGG is indirectly called by simply using the
C   exponentiation operator.
C-
        RESULT = X**Y
        TYPE *,' 9.0**-0.5 IS ',RESULT
        END

This Fortran example uses OTS$POWGG to raise a G-floating base to a G-floating exponent.

The output generated by this example is as follows:

8.0**2.0 IS    64.0000000000000
9.0**-0.5 IS  0.333333333333333

Format

OTS$POWGJ G-floating-point-base ,longword-integer-exponent

Returns

Result of raising a G-floating base to a longword exponent.

Arguments

Base that OTS$POWGJ raises to a longword exponent. The G-floating-point-base argument is a G-floating number containing the base.

Exponent to which OTS$POWGJ raises the base. The longword-integer-exponent argument is a signed longword containing the exponent.

Description

OTS$POWGJ raises a G-floating base to a longword exponent.

The internal calculations and the floating-point result have the same precision as the base value.

The floating-point result is as follows:

Floating-point overflow can occur.

Undefined exponentiation occurs if the base is zero and the exponent is zero or negative.

On Alpha and I64 systems, some restrictions apply when linking OTS$POWGJ. See Chapter 1, Run-Time Library General Purpose (OTS$) Facility for more information about these restrictions.

Condition Values Signaled

Format

OTS$POWHH_R3 H-floating-point-base ,H-floating-point-exponent

Returns

Result of raising an H-floating base to an H-floating exponent.

Arguments

Base. The H-floating-point-base argument is an H-floating number containing the base.

Exponent. The H-floating-point-exponent argument is an H-floating number that contains the H-floating exponent.

Description

OTS$POWHH_R3 raises an H-floating base to an H-floating exponent.

The internal calculations and the floating-point result have the same precision as the base value.

The H-floating result for OTS$POWHH_R3 is as follows:

Floating-point overflow can occur.

Undefined exponentiation occurs if the base is zero and the exponent is zero or negative, or if the base is negative.

Condition Values Signaled

Example

C+
C Example of OTS$POWHH, which raises an H_floating
C point base to an H_floating point power. In Fortran,
C it is not directly called.
C-
        REAL*16 X,Y,RESULT
        X = 9877356535.0
        Y = -0.5837653
C+
C In Fortran, OTS$POWWHH is indirectly called by simply using the
C exponentiation operator.
C-
        RESULT = X**Y
        TYPE *,' 9877356535.0**-0.5837653 IS ',RESULT
        END

      

This Fortran example demonstrates how to call OTS$POWHH_R3 to raise an H-floating base to an H-floating power.

9877356535.0**-0.5837653 IS   1.463779145994628357482343598205427E-0006

Format

OTS$POWHJ_R3 H-floating-point-base ,longword-integer-exponent

Returns

Result of raising an H-floating base to a longword exponent.

Arguments

Base. The H-floating-point-base argument is an H-floating number containing the base.

Exponent. The longword-integer-exponent argument is a signed longword that contains the signed longword exponent.

Description

OTS$POWHJ_R3 raises an H-floating base to a longword exponent.

The internal calculations and the floating-point result have the same precision as the base value.

The floating-point result is as follows:

Floating-point overflow can occur.

Undefined exponentiation occurs if the base is zero and the exponent is zero or negative.

Condition Values Signaled

Format

OTS$POWII word-integer-base ,word-integer-exponent

Returns

Result of raising a word base to a word exponent.

Arguments

Base. The word-integer-base argument is a signed word containing the base.

Exponent. The word-integer-exponent argument is a signed word containing the exponent.

Description

The OTS$POWII routine raises a word base to a word exponent.

On Alpha and I64 systems, some restrictions apply when linking OTS$POWII. See Chapter 1, Run-Time Library General Purpose (OTS$) Facility for more information about these restrictions.

Condition Values Signaled