10      !+ 
        ! Sample program to demonstrate a call to MTH$HEXP from BASIC. 
        !- 
 
        EXTERNAL SUB MTH$HEXP ( HFLOAT, HFLOAT ) 
 
        DECLARE HFLOAT X,Y      ! X and Y are H-floating 
        DIGITS$ = '###.#################################' 
        X = '1.2345678901234567891234567892'H 
        CALL MTH$HEXP (Y,X) 
        A$ = 'MTH$HEXP of ' + DIGITS$ + ' is ' + DIGITS$ 
        PRINT USING A$, X, Y 
        END 
 
      

IDENTIFICATION DIVISION. 
PROGRAM-ID.    FLOATING_POINT. 
* 
*  Calls MTH$EXP using a Floating Point data type. 
*  Calls MTH$DEXP using a Double Floating Point data type. 
* 
ENVIRONMENT DIVISION. 
DATA DIVISION. 
WORKING-STORAGE SECTION. 
01 FLOAT_PT     COMP-1. 
01 ANSWER_F     COMP-1. 
01 DOUBLE_PT    COMP-2. 
01 ANSWER_D     COMP-2. 
PROCEDURE DIVISION. 
P0. 
        MOVE 12.34 TO FLOAT_PT. 
        MOVE 3.456 TO DOUBLE_PT. 
 
        CALL "MTH$EXP" USING BY REFERENCE FLOAT_PT GIVING ANSWER_F. 
        DISPLAY " MTH$EXP of ", FLOAT_PT CONVERSION, " is ", 
                                               ANSWER_F CONVERSION. 
 
        CALL "MTH$DEXP" USING BY REFERENCE DOUBLE_PT GIVING ANSWER_D. 
        DISPLAY " MTH$DEXP of ", DOUBLE_PT CONVERSION, " is ", 
                                               ANSWER_D CONVERSION. 
        STOP RUN. 
 
 
 
 
      

C+ 
C This Fortran program computes the log base 2 of x, log2(x) in 
C G-floating double precision by using the RTL routine MTH$GLOG2. 
C 
C Declare X and Y and MTH$GLOG2 as double precision values. 
C 
C MTH$GLOG2 will return a double precision value to variable Y. 
C- 
 REAL*8 X, Y, MTH$GLOG2 
 X = 16.0 
 Y = MTH$GLOG2(X) 
 WRITE (6,1) X, Y 
1 FORMAT (' MTH$GLOG2(',F4.1,') is ',F4.1) 
 END 
 
      

C+ 
C This Fortran program computes the log base 2 of x, log2(x) in 
C H-floating precision by using the RTL routine MTH$HLOG2. 
C 
C Declare X and Y and MTH$GLOG2 as REAL*16 values. 
C 
C MTH$HLOG2 will return a REAL*16 value to variable Y. 
C- 
 REAL*16 X, Y 
 X = 16.12345678901234567890123456789 
 CALL MTH$HLOG2(Y, X) 
 WRITE (6,1) X, Y 
1 FORMAT (' MTH$HLOG2(',F30.27,') is ',F30.28) 
 END 
 
      

C+ 
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 
 
      

        .TITLE  EXAMPLE_JSB 
;+ 
;  This example calls MTH$DEXP by using a MACRO JSB command. 
;  The JSB command expects R0/R1 to contain the quadword input value X. 
;  The result of the JSB will be located in R0/R1. 
;-    
        .EXTRN  MTH$DEXP_R6     ;MTH$DEXP is an external routine. 
        .PSECT  DATA, PIC, EXE, NOWRT 
X:      .DOUBLE 2.0             ; X is 2.0 
        .ENTRY  EXAMPLE_JSB, ^M<> 
        MOVQ    X, R0           ; X is in registers R0 and R1 
        JSB     G^MTH$DEXP_R6   ; The result is returned in R0/R1. 
        RET 
        .END    EXAMPLE_JSB 
 
 
 
      

        .TITLE EXAMPLE_CALLG 
;+ 
;  This example calls MTH$HEXP by using a MACRO CALLG command. 
;  The CALLG command expects that the address of the return value 
;  Y, the address of the input value X, and the argument count 2 be 
;  stored in memory; this program stores this information in ARGUMENTS. 
;  The result of the CALLG will be located in R0/R1. 
;-       
        .EXTRN  MTH$HEXP        ; MTH$HEXP is an external routine. 
        .PSECT  DATA, PIC, EXE, WRT 
ARGUMENTS: 
        .LONG   2               ; The CALLG will use two arguments. 
        .ADDRESS Y, X           ; The first argument must be the address 
                                ;  receiving the computed value, while 
                                ;  the second argument is used to 
                                ;  compute exp(X). 
X:      .H_FLOATING 2           ; X = 2.0 
Y:      .H_FLOATING 0           ; Y is the result, initially set to 0. 
        .ENTRY  EXAMPLE_G, ^M<> 
        CALLG   ARGUMENTS, G^MTH$HEXP ; CALLG returns the value to Y. 
        RET 
        .END    EXAMPLE_G 
 
 
 
      

        .TITLE EXAMPLE_CALLS 
;+ 
;  This example calls MTH$HEXP by using the MACRO CALLS command. 
;  The CALLS command expects the SP to contain the H-floating address of 
;  the return value, the address of the input argument X, and the argument 
;  count 2. The result of the CALLS will be located in registers R0-R3. 
;-    
      .EXTRN  MTH$HEXP        ; MTH$HEXP is an external routine. 
      .PSECT  DATA, PIC, EXE, WRT 
Y:    .H_FLOATING 0           ; Y is the result, initially set to 0. 
X:    .H_FLOATING 2           ; X = 2 
      .ENTRY  EXAMPLE_S, ^M<> 
      MOVAL   X, -(SP)        ; The address of X is in the SP. 
      MOVAL   Y, -(SP)        ; The address of Y is in the SP 
      CALLS   Y, G^MTH$HEXP   ; The value is returned to the address of Y. 
      RET 
      .END    EXAMPLE_S 
 
 
 
      

        .TITLE  COMPLEX_EX1 
;+ 
;   This example calls MTH$CLOG by using a MACRO CALLG command. 
;   To compute the complex natural logarithm of Z = (2.0,1.0) register 
;   R0 is loaded with 2.0, the real part of Z, and register R1 is loaded 
;   with 1.0, the imaginary part of Z. The CALLG to MTH$CLOG 
;   returns the value of the natural logarithm of Z in 
;   registers R0 and R1. R0 gets the real part of Z and R1 
;   gets the imaginary part. 
;-    
        .EXTRN  MTH$CLOG 
        .PSECT  DATA, PIC, EXE, NOWRT 
ARGS:   .LONG   1               ; The CALLG will use one argument. 
        .ADDRESS REAL           ; The one argument that the CALLG 
                                ;  uses is the address of the argument 
                                ;  of MTH$CLOG. 
REAL:   .FLOAT  2               ; real part of Z is 2.0 
IMAG:   .FLOAT  1               ; imaginary part Z is 1.0 
        .ENTRY  COMPLEX_EX1, ^M<> 
        CALLG   ARGS, G^MTH$CLOG; MTH$CLOG returns the real part of the 
                                ;  complex natural logarithm in R0 and 
                                ;  the imaginary part in R1. 
        RET 
        .END    COMPLEX_EX1 
 
 
      

        .TITLE  COMPLEX_EX2 
;+ 
;   This example calls MTH$CLOG by using a MACRO CALLS command. 
;   To compute the complex natural logarithm of Z = (2.0,1.0) register 
;   R0 is loaded with 2.0, the real part of Z, and register R1 is loaded 
;   with 1.0, the imaginary part of Z.  The CALLS to MTH$CLOG 
;   returns the value of the natural logarithm of Z in registers R0 
;   and R1. R0 gets the real part of Z and R1 gets the imaginary 
;   part. 
;- 
        .EXTRN  MTH$CLOG 
        .PSECT  DATA, PIC, EXE, NOWRT 
REAL:   .FLOAT  2               ; real part of Z is 2.0 
IMAG:   .FLOAT  1               ; imaginary part Z is 1.0 
        .ENTRY  COMPLEX_EX2, ^M<> 
        MOVAL   REAL, -(SP)     ; SP <-- address of Z. Real part of Z is 
                                ;  in @(SP) and imaginary part is in 
        CALLS   #1, G^MTH$CLOG  ;  @(SP)+4. 
                                ; MTH$CLOG return the real part of the 
                                ;  complex natural logarithm in R0 and 
                                ;  the imaginary part in R1. 
        RET 
        .END    COMPLEX_EX2 
 
 
      

{+} 
{ Sample program to demonstrate a call to MTH$DEXP from PASCAL. 
{-} 
 
PROGRAM CALL_MTH$DEXP (OUTPUT); 
 
{+} 
{ Declare variables used by this program. 
{-} 
 
VAR 
    X : DOUBLE := 3.456;        { X,Y are D-floating unless overridden } 
    Y : DOUBLE;                 { with /DOUBLE qualifier on compilation } 
 
{+} 
{ Declare the RTL routine used by this program. 
{-} 
 
[EXTERNAL,ASYNCHRONOUS] 
                  FUNCTION MTH$DEXP (VAR value : DOUBLE) : DOUBLE; EXTERN; 
BEGIN 
    Y := MTH$DEXP (x); 
    WRITELN ('MTH$DEXP of ', X:5:3, ' is ', Y:20:16); 
END. 
 
 
      

{+} 
{ Sample program to demonstrate a call to MTH$HEXP from PASCAL. 
{-} 
 
PROGRAM CALL_MTH$HEXP (OUTPUT); 
 
{+} 
{ Declare variables used by this program. 
{-} 
 
VAR 
    X : QUADRUPLE := 1.2345678901234567891234567892; { X is H-floating } 
    Y : QUADRUPLE;                                   { Y is H-floating } 
 
{+} 
{ Declare the RTL routine used by this program. 
{-} 
 
[EXTERNAL,ASYNCHRONOUS] PROCEDURE MTH$HEXP (VAR h_exp : QUADRUPLE; 
value : QUADRUPLE); EXTERN; 
 
BEGIN 
    MTH$HEXP (Y,X); 
    WRITELN ('MTH$HEXP of ', X:30:28, ' is ', Y:35:33); 
END. 
 
 
      

/* 
*                                                                           * 
*       This program tests a MTH$D entry point                              * 
*                                                                           * 
*/ 
TEST:   PROC OPTIONS (MAIN) ; 
 
        DCL (MTH$DEXP) 
                ENTRY (FLOAT(53)) RETURNS (FLOAT(53)); 
        DCL OPERAND FLOAT(53); 
        DCL RESULT FLOAT(53); 
 
/*** Begin test ***/ 
        OPERAND = 3.456; 
        RESULT = MTH$DEXP(OPERAND); 
        PUT EDIT ('MTH$DEXP of ', OPERAND, ' is ', 
            RESULT)(A(12),F(5,3),A(4),F(20,15)); 
 
END TEST; 
 
 
      

/* 
*                                                                           * 
*       This program tests a MTH$H entry point.                             * 
*       Note that in the PL/I statement below, the /G-float switch          * 
*       is needed to compile both G- and H-floating point MTH$ routines.    */ 
 
TEST:   PROC OPTIONS (MAIN) ; 
 
        DCL (MTH$HEXP) 
                ENTRY (FLOAT (113), FLOAT (113)) ; 
        DCL OPERAND FLOAT (113); 
        DCL RESULT FLOAT (113); 
 
/*** Begin test ***/ 
        OPERAND = 1.234578901234567891234567892; 
        CALL MTH$HEXP(RESULT,OPERAND); 
        PUT EDIT ('MTH$HEXP of ', OPERAND, ' is ', 
            RESULT) (A(12),F(29,27),A(4),F(29,27)); 
 
END TEST; 
 
 
      

-- This Ada program calls the MTH$SQRT and MTH$JNINT routines. 
-- 
with FLOAT_MATH_LIB; 
    -- Package FLOAT_MATH_LIB is an instantiation of the generic package 
    -- MATH_LIB for the FLOAT datatype.  This package provides the most 
    -- common mathematical functions (SQRT, SIN, COS, etc.) in an easy 
    -- to use fashion.  An added benefit is that the VAX Ada compiler 
    -- will use the faster JSB interface for these routines. 
with MTH; 
    -- Package MTH defines all the MTH$ routines.  It should be used when 
    -- package MATH_LIB is not sufficient.  All functions are defined here 
    -- as "valued procedures" for consistency. 
with FLOAT_TEXT_IO, INTEGER_TEXT_IO, TEXT_IO; 
procedure ADA_EXAMPLE is 
    FLOAT_VAL: FLOAT; 
    INT_VAL: INTEGER; 
begin 
    -- Prompt for initial value. 
    TEXT_IO.PUT ("Enter value: "); 
    FLOAT_TEXT_IO.GET (FLOAT_VAL); 
    TEXT_IO.NEW_LINE; 
 
    -- Take the square root by using the SQRT routine from package 
    -- FLOAT_MATH_LIB.  The compiler will use the JSB interface 
    -- to MTH$SQRT. 
    FLOAT_VAL := FLOAT_MATH_LIB.SQRT (FLOAT_VAL); 
 
    -- Find the nearest integer using MTH$JNINT.  Argument names are 
    -- the same as those listed for MTH$JNINT in the reference 
    -- section of this manual. 
    MTH.JNINT (F_FLOATING => FLOAT_VAL, RESULT => INT_VAL); 
 
    -- Write the result. 
    TEXT_IO.PUT ("Result is: "); 
    INTEGER_TEXT_IO.PUT (INT_VAL); 
    TEXT_IO.NEW_LINE; 
end ADA_EXAMPLE;