-- TEST_GENERIC_COMPLEX_TYPES_2.ADA   version 0.1  23 Feb 1992
--
-- Ultimately this will be the second part of the conformance test
-- for GENERIC_COMPLEX_TYPES.
--
-- TEST_GENERIC_COMPLEX_TYPES_2 is not a complete test but rather a few
-- selected test cases. Please submit any more test cases you would like
-- to see included in a thorough test case.
 
with TEXT_IO;
with GENERIC_COMPLEX_TYPES;
with COMPLEX_IO;
with GENERIC_ELEMENTARY_FUNCTIONS;
 
procedure TEST_GENERIC_COMPLEX_TYPES_2 is
 
  subtype REAL is FLOAT ; -- test for all hardware types

  package COMPLEX_TYPES is new GENERIC_COMPLEX_TYPES(REAL);
  use COMPLEX_TYPES;
 
  package CX_IO is new COMPLEX_IO(REAL, COMPLEX);
 
  package ELEMENTARY_FUNCTIONS is new GENERIC_ELEMENTARY_FUNCTIONS(REAL);
 
  package FLOAT_TEXT_IO is new TEXT_IO.FLOAT_IO(REAL);
 
  -- shorthand notation
  function C(RE:FLOAT) return COMPLEX renames COMPOSE_FROM_CARTESIAN ;
  function C(RE,IM:FLOAT) return COMPLEX renames COMPOSE_FROM_CARTESIAN ;
 
 
  R1 : FLOAT;
  A1 : FLOAT;
  Z1 : COMPLEX;
  TEMP : FLOAT;
  TEMP1 : FLOAT;
  TEMP2 : FLOAT;
 
  PI : constant := 3.14159_26535_89793_23846_26433_83279_50288_41971 ;
  HALF_PI : constant := PI / 2.0;
  PI_OVER_3 : constant := PI / 3.0;
  PI_OVER_4 : constant := PI / 4.0;
  PI_OVER_6 : constant := PI / 6.0;
  SQRT_2 : constant := 1.41421_35623_73095_04880_16887_24209_69807_85696 ;
  SQRT_3 : constant := 1.73205_08075_68877_29352_74463_41505_87236_69428 ;
  SQRT_3_OVER_2 : constant := SQRT_3 / 2.0 ;
 
  LAST : FLOAT := FLOAT'LAST;
  FIRST : FLOAT := FLOAT'FIRST;
  BIG : FLOAT := FLOAT'SAFE_LARGE;
  S2BIG : FLOAT := BIG/SQRT_2; -- this can safely be multiplied by SQRT(2)
  HBIG : FLOAT := BIG/2.0; -- this can safely be doubled
  RBIG : FLOAT := ELEMENTARY_FUNCTIONS.SQRT(BIG); -- this can be squared
  S2RBIG : FLOAT := RBIG/SQRT_2;
  HRBIG : FLOAT := RBIG/2.0;
  SMALL : FLOAT := FLOAT'SAFE_SMALL;
  RSMALL : FLOAT := ELEMENTARY_FUNCTIONS.SQRT(SMALL); -- can be squared
  S2RSMALL : FLOAT := RSMALL/SQRT_2;
  HRSMALL : FLOAT := RSMALL/2.0;
  DSMALL : FLOAT := SMALL*2.0;  -- can be halved
  S2SMALL : FLOAT := SMALL*SQRT_2;
  EPSILON : FLOAT := 2.0 * FLOAT'EPSILON; -- refined below to be hardware
 
 
-- utility routines 

  FAILED  : BOOLEAN := FALSE;
  WARNING : BOOLEAN := FALSE;
  --
  -- the expected accuracy is 2 epsilon, but the test ARGUMENTs and test
  -- results can have an epsilon error, thus the 4 epsilon test criteria
  --
 
  procedure COMPARE ( Z1,Z2:COMPLEX ) is -- compare COMPLEX expected, computed
    function "/" ( Z : COMPLEX ;
                   X : FLOAT ) return COMPLEX is -- not in COMPLEX_TYPES
    begin
      return ( Z.RE / X , Z.IM / X ) ;
    end "/" ;
  begin
    if abs Z1 = 0.0 then
      if abs Z2 > 4.0 * EPSILON then
        TEXT_IO.PUT_LINE("ERROR^, 0.0 result greater than 4 epsilon");
        FAILED := TRUE;
      elsif abs Z2 > RSMALL then
        TEXT_IO.PUT_LINE("ERROR^, 0.0 result greater than root small");
        FAILED := TRUE;
      end if;
    elsif (abs(Z1-Z2)/abs Z1) > 4.0 * EPSILON then
      TEXT_IO.PUT_LINE("ERROR^, MODULUS of error/MODULUS result > 4 epsilon");
      FAILED := TRUE;
    end if;
    TEXT_IO.NEW_LINE;
  exception
    when others =>
      begin
        if (abs(Z1/BIG-Z2/BIG)/abs(Z1/BIG)) > 4.0 * EPSILON then
          TEXT_IO.PUT_LINE
                  ("ERROR^, MODULUS of error/MODULUS result > 4 epsilon");
          FAILED := TRUE;
        end if;
      exception
        when others =>
          TEXT_IO.PUT_LINE("PROBLEM^, unable to compute accuracy");
          WARNING := TRUE;
      end;
      TEXT_IO.NEW_LINE;
  end COMPARE;
 
  procedure COMPARE ( X1,X2:FLOAT ) is -- compare FLOAT expected, computed
  begin
    if X1 = 0.0 then
      if abs X2 > 4.0 * EPSILON then
        TEXT_IO.PUT_LINE("ERROR^, 0.0 result greater than 4 epsilon");
        FAILED := TRUE;
      elsif abs X2 > RSMALL then
        TEXT_IO.PUT_LINE("ERROR^, 0.0 result greater than root small");
        FAILED := TRUE;
      end if;
    elsif (abs(X1-X2)/abs X1) > 4.0 * EPSILON then
      TEXT_IO.PUT_LINE
              ("ERROR^, magnitude of error/magnitude result > 4 epsilon");
      FAILED := TRUE;
    end if;
    TEXT_IO.NEW_LINE;
  exception
    when others =>
      TEXT_IO.PUT_LINE("PROBLEM^, unable to compute accuracy");
      WARNING := TRUE;
      TEXT_IO.NEW_LINE;
  end COMPARE;
 
  procedure REPORT is
  begin
    if not FAILED and not WARNING then
      TEXT_IO.PUT_LINE("test of GENERIC_COMPLEX_TYPES part 2, PASSED.");
    elsif FAILED then
      TEXT_IO.PUT_LINE("test of GENERIC_COMPLEX_TYPES part 2, FAILED.");
    elsif WARNING then
      TEXT_IO.PUT_LINE("test of GENERIC_COMPLEX_TYPES part 2, has WARNING.");
    end if;
  end REPORT;

begin
 
  TEXT_IO.PUT_LINE("Begin Test_COMPLEX_Types");
  TEXT_IO.NEW_LINE;
 
  -- setup values for future use in tests

  FLOAT_TEXT_IO.DEFAULT_FORE := 1;
  FLOAT_TEXT_IO.DEFAULT_AFT := FLOAT'DIGITS+1;
 
  TEMP := EPSILON/2.0;
  TEMP1 := TEMP+1.0;
  while TEMP1 /= 1.0 loop
    EPSILON := EPSILON/2.0;
    TEMP := EPSILON/2.0;
    TEMP1:= TEMP+1.0;
  end loop;
 
  begin
    TEMP := RBIG * RBIG ;
  exception
    when CONSTRAINT_ERROR | NUMERIC_ERROR =>
      RBIG := RBIG / ( 1.0 + EPSILON ) ;
      TEMP := RBIG * RBIG ;
  end;
 
  TEMP2 := RSMALL * RSMALL ;
  if TEMP2 = 0.0 then
    RSMALL := RSMALL * ( 1.0 + EPSILON ) ;
    TEMP2 := RSMALL * RSMALL ;
    S2RSMALL := RSMALL/SQRT_2;
  end if;
 
  if ((2.0*S2RSMALL)*S2RSMALL+(2.0*S2RSMALL)*S2RSMALL)/2.0 = 0.0 then
    S2RSMALL := S2RSMALL * ( 1.0 + EPSILON ) ;
  end if;
  if ((2.0*S2RSMALL)*S2RSMALL+(2.0*S2RSMALL)*S2RSMALL)/2.0 = 0.0 then
    S2RSMALL := S2RSMALL * ( 1.0 + EPSILON ) ;
  end if;
 
  TEXT_IO.PUT_LINE("values used as test data, and a few attributes");
  FLOAT_TEXT_IO.PUT(LAST);
  TEXT_IO.PUT_LINE(" = last     'LAST");
  FLOAT_TEXT_IO.PUT(FIRST);
  TEXT_IO.PUT_LINE(" = first    'FIRST");
  FLOAT_TEXT_IO.PUT(BIG);
  TEXT_IO.PUT_LINE(" = big      'SAFE_LARGE");
  FLOAT_TEXT_IO.PUT(TEMP);
  TEXT_IO.PUT_LINE(" = rbig*rbig = big");
  FLOAT_TEXT_IO.PUT(S2BIG);
  TEXT_IO.PUT_LINE(" = s2big    'SAFE_LARGE/SQRT(2)");
  FLOAT_TEXT_IO.PUT(HBIG);
  TEXT_IO.PUT_LINE(" = hbig     'SAFE_LARGE/2");
  FLOAT_TEXT_IO.PUT(RBIG);
  TEXT_IO.PUT_LINE(" = rbig     SQRT('SAFE_LARGE)");
  FLOAT_TEXT_IO.PUT(S2RBIG);
  TEXT_IO.PUT_LINE(" = s2rbig   SQRT('SAFE_LARGE/2)");
  FLOAT_TEXT_IO.PUT(HRBIG);
  TEXT_IO.PUT_LINE(" = hrbig    SQRT('SAFE_LARGE)/2");
  FLOAT_TEXT_IO.PUT(RSMALL);
  TEXT_IO.PUT_LINE(" = rsmall   SQRT('SAFE_SMALL)");
  FLOAT_TEXT_IO.PUT(S2RSMALL);
  TEXT_IO.PUT_LINE(" = s2rsmall   SQRT('SAFE_SMALL/2)");
  FLOAT_TEXT_IO.PUT(HRSMALL);
  TEXT_IO.PUT_LINE(" = hrsmall   SQRT('SAFE_SMALL)/2");
  FLOAT_TEXT_IO.PUT(DSMALL);
  TEXT_IO.PUT_LINE(" = dsmall    'SAFE_SMALL*2");
  FLOAT_TEXT_IO.PUT(S2SMALL);
  TEXT_IO.PUT_LINE(" = s2small   'SAFE_SMALL*SQRT(2)*");
  FLOAT_TEXT_IO.PUT(TEMP2);
  TEXT_IO.PUT_LINE(" = rsmall*rsmall = small");
  FLOAT_TEXT_IO.PUT(SMALL);
  TEXT_IO.PUT_LINE(" = small     'SAFE_SMALL");
  FLOAT_TEXT_IO.PUT(FLOAT'SMALL);
  TEXT_IO.PUT_LINE(" = 'SMALL");
  FLOAT_TEXT_IO.PUT(FLOAT'EPSILON);
  TEXT_IO.PUT_LINE(" =           'EPSILON  Ada");
  FLOAT_TEXT_IO.PUT(EPSILON);
  TEXT_IO.PUT_LINE(" = epsilon   hardware");
  FLOAT_TEXT_IO.PUT(TEMP1);
  TEXT_IO.PUT_LINE(" = 1+epsilon/2");
  TEXT_IO.NEW_LINE;
 
  TEXT_IO.PUT_LINE("Format of printout below:");
  TEXT_IO.PUT_LINE(" computed result = function(actual parameter)");
  TEXT_IO.PUT_LINE(" expected result ");
  TEXT_IO.PUT_LINE(" error indication if any ");
  TEXT_IO.NEW_LINE;
--
---- Objects of type COMPLEX
-- 
---- test objects COMPLEX_ZERO, COMPLEX_ONE and COMPLEX_I
-- 
--  TEXT_IO.NEW_LINE;
--  TEXT_IO.PUT_LINE("testing objects COMPLEX_ZERO, COMPLEX_ONE and " &
--                   "COMPLEX_I");
-- 
--  Z1 := COMPLEX_ZERO ;
--  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = COMPLEX_ZERO");
--  CX_IO.PUT((0.0,0.0)); TEXT_IO.NEW_LINE;
--  COMPARE((0.0,0.0),Z1);
-- 
--  Z1 := COMPLEX_ONE ;
--  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = COMPLEX_ZERO");
--  CX_IO.PUT((1.0,0.0)); TEXT_IO.NEW_LINE;
--  COMPARE((1.0,0.0),Z1);
--
--  Z1 := COMPLEX_I ;
--  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = COMPLEX_I");
--  CX_IO.PUT((0.0,1.0)); TEXT_IO.NEW_LINE;
--  COMPARE((0.0,1.0),Z1);
 

-- Subprograms for type COMPLEX

-- Selection, conversion and composition operations
 
-- test COMPOSE_FROM_CARTESIAN ( RE )
 
  TEXT_IO.NEW_LINE;
  TEXT_IO.PUT_LINE("testing COMPOSE_FROM_CARTESIAN ( RE )");
 
  Z1 := COMPOSE_FROM_CARTESIAN(RE=>LAST);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = COMPOSE_FROM_CARTESIAN(last)");
  CX_IO.PUT(C(LAST,0.0)); TEXT_IO.NEW_LINE;
  COMPARE((LAST,0.0),Z1);
 
  Z1 := COMPOSE_FROM_CARTESIAN(FIRST);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = COMPOSE_FROM_CARTESIAN(first)");
  CX_IO.PUT(C(FIRST,0.0)); TEXT_IO.NEW_LINE;
  COMPARE((FIRST,0.0),Z1);
 
  Z1 := COMPOSE_FROM_CARTESIAN(SMALL);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = COMPOSE_FROM_CARTESIAN(small)");
  CX_IO.PUT(C(SMALL,0.0)); TEXT_IO.NEW_LINE;
  COMPARE((SMALL,0.0),Z1);
 
  Z1 := COMPOSE_FROM_CARTESIAN(-2.0);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = COMPOSE_FROM_CARTESIAN(-2.0)");
  CX_IO.PUT(C(-2.0,0.0)); TEXT_IO.NEW_LINE;
  COMPARE((-2.0,0.0),Z1);
 
 
-- test COMPOSE_FROM_CARTESIAN ( RE, IM)
 
  TEXT_IO.PUT_LINE("testing COMPOSE_FROM_CARTESIAN ( RE, " &
                   "IM ) ");
 
  Z1 := COMPOSE_FROM_CARTESIAN(SMALL,LAST);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = COMPOSE_FROM_CARTESIAN(small,last)");
  CX_IO.PUT(C(SMALL,LAST)); TEXT_IO.NEW_LINE;
  COMPARE((SMALL,LAST),Z1);
 
  Z1 := COMPOSE_FROM_CARTESIAN(-2.0,-3.0);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = COMPOSE_FROM_CARTESIAN(-2.0,-3.0)");
  CX_IO.PUT(C(-2.0,-3.0)); TEXT_IO.NEW_LINE;
  COMPARE((-2.0,-3.0),Z1);
 
-- test COMPOSE_FROM_POLAR ( MODULUS, ARGUMENT )
 
  TEXT_IO.NEW_LINE;
  TEXT_IO.PUT_LINE("testing COMPOSE_FROM_POLAR(MODULUS, ARGUMENT)" );
 
  Z1 :=COMPOSE_FROM_POLAR(BIG,0.0);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" =COMPOSE_FROM_POLAR(big,0.0)");
  CX_IO.PUT(C(BIG,0.0)); TEXT_IO.NEW_LINE;
  COMPARE((BIG,0.0),Z1);
 
  Z1 :=COMPOSE_FROM_POLAR(SMALL,0.0);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" =COMPOSE_FROM_POLAR(small,0.0)");
  CX_IO.PUT(C(SMALL,0.0)); TEXT_IO.NEW_LINE;
  COMPARE((SMALL,0.0),Z1);
 
  Z1 :=COMPOSE_FROM_POLAR(BIG,PI_OVER_4);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" =COMPOSE_FROM_POLAR(big,pi/4.0)");
  CX_IO.PUT(C(S2BIG,S2BIG)); TEXT_IO.NEW_LINE;
  COMPARE((S2BIG,S2BIG),Z1);
 
  Z1 := COMPOSE_FROM_POLAR(1.0,PI);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = COMPOSE_FROM_POLAR(1.0,pi)");
  CX_IO.PUT(C(-1.0,0.0)); TEXT_IO.NEW_LINE;
  COMPARE((-1.0,0.0),Z1);
 
-- test COMPOSE_FROM_POLAR ( MODULUS, ARGUMENT, CYCLE ) and
--      COMPOSE_FROM_POLAR ( MODULUS, ARGUMENT, CYCLE )
 
  TEXT_IO.NEW_LINE;
  TEXT_IO.PUT_LINE("testingCOMPOSE_FROM_POLAR( MODULUS, ARGUMENT, CYCLE ) and " &
                   "COMPOSE_FROM_POLAR(MODULUS, ARGUMENT, CYCLE )" );
 
  Z1 :=COMPOSE_FROM_POLAR(BIG,45.0,360.0);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" =COMPOSE_FROM_POLAR(big,45.0,360.0)");
  CX_IO.PUT(C(S2BIG,S2BIG)); TEXT_IO.NEW_LINE;
  COMPARE((S2BIG,S2BIG),Z1);
 
  Z1 :=COMPOSE_FROM_POLAR(SMALL,-0.25,1.0);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" =COMPOSE_FROM_POLAR(small,-0.25,1.0)");
  CX_IO.PUT(C(0.0,-SMALL)); TEXT_IO.NEW_LINE;
  COMPARE((0.0,-SMALL),Z1);
 
  Z1 := COMPOSE_FROM_POLAR(1.0,1.0,1.0);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = COMPOSE_FROM_POLAR(1.0,1.0,1.0)");
  CX_IO.PUT(C(1.0,0.0)); TEXT_IO.NEW_LINE;
  COMPARE((1.0,0.0),Z1);
 
-- test SET_RE ( Z , RE ) and SET_IM ( Z , IM )
 
  TEXT_IO.NEW_LINE;
  TEXT_IO.PUT_LINE("testing SET_RE( Z , RE ) and " &
                   "SET_IM( Z , RE )" );
 
  Z1 := (0.0,0.0) ;
  SET_RE(X=>Z1,RE=>3.0);
  SET_IM(X=>Z1,IM=>-2.0);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = set_RE(Z1,3.0)" &
                                        " set_IM(Z1,-2.0)" );
  CX_IO.PUT(C(3.0,-2.0)); TEXT_IO.NEW_LINE;
  COMPARE((3.0,-2.0),Z1);
 
 
-- test RE ( Z ) 
 
  TEXT_IO.NEW_LINE;
  TEXT_IO.PUT_LINE("testing RE( Z ) " );
 
  R1 := RE(X=>C(LAST,LAST));
  FLOAT_TEXT_IO.PUT(R1);
  TEXT_IO.PUT_LINE(" = RE((last,last))");
  FLOAT_TEXT_IO.PUT(LAST); TEXT_IO.NEW_LINE;
  COMPARE(LAST,R1);
 
  R1 := RE((SMALL,-SMALL));
  FLOAT_TEXT_IO.PUT(R1);
  TEXT_IO.PUT_LINE(" = RE(COMPOSE_FROM_CARTESIAN(small,-small))");
  FLOAT_TEXT_IO.PUT(SMALL); TEXT_IO.NEW_LINE;
  COMPARE(SMALL,R1);
 
  R1 := RE((-2.0,3.0));
  FLOAT_TEXT_IO.PUT(R1);
  TEXT_IO.PUT_LINE(" = RE(COMPOSE_FROM_CARTESIAN(-2.0,3.0))");
  FLOAT_TEXT_IO.PUT(-2.0); TEXT_IO.NEW_LINE;
  COMPARE(-2.0,R1);
 
-- test IM ( Z ) 
 
  TEXT_IO.NEW_LINE;
  TEXT_IO.PUT_LINE("testing IM( Z ) " );
 
  R1 := IM(X=>(LAST,LAST));
  FLOAT_TEXT_IO.PUT(R1);
  TEXT_IO.PUT_LINE(" = IM((last,last))");
  FLOAT_TEXT_IO.PUT(LAST); TEXT_IO.NEW_LINE;
  COMPARE(LAST,R1);
 
  R1 := IM((SMALL,-SMALL));
  FLOAT_TEXT_IO.PUT(R1);
  TEXT_IO.PUT_LINE(" = IM((small,-small))");
  FLOAT_TEXT_IO.PUT(-SMALL); TEXT_IO.NEW_LINE;
  COMPARE(-SMALL,R1);
 
  R1 := IM((2.0,-3.0));
  FLOAT_TEXT_IO.PUT(R1);
  TEXT_IO.PUT_LINE(" = IM((2.0,-3.0))");
  FLOAT_TEXT_IO.PUT(-3.0); TEXT_IO.NEW_LINE;
  COMPARE(-3.0,R1);
 
  R1 := IM((LAST,FIRST));
  FLOAT_TEXT_IO.PUT(R1);
  TEXT_IO.PUT_LINE(" = im(COMPOSE_FROM_CARTESIAN(last,first))");
  FLOAT_TEXT_IO.PUT(FIRST); TEXT_IO.NEW_LINE;
  COMPARE(FIRST,R1);
 
-- test MODULUS( Z )
 
  TEXT_IO.NEW_LINE;
  TEXT_IO.PUT_LINE("testing MODULUS( Z )");
 
  R1 := MODULUS((1.0,1.0));
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = MODULUS(1.0,1.0)");
  FLOAT_TEXT_IO.PUT(SQRT_2); TEXT_IO.NEW_LINE;
  COMPARE(SQRT_2,R1);
 
  R1 := MODULUS((S2BIG,S2BIG));
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = MODULUS(s2big,s2big)");
  FLOAT_TEXT_IO.PUT(BIG); TEXT_IO.NEW_LINE;
  COMPARE(BIG,R1);
 
  R1 := MODULUS((HBIG,HBIG));
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = MODULUS(hbig,hbig)");
  FLOAT_TEXT_IO.PUT(S2BIG); TEXT_IO.NEW_LINE;
  COMPARE(S2BIG,R1);
 
  R1 := MODULUS((RBIG,RBIG));
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = MODULUS(rbig,rbig)");
  FLOAT_TEXT_IO.PUT(SQRT_2*RBIG); TEXT_IO.NEW_LINE;
  COMPARE(SQRT_2*RBIG,R1);
 
  R1 := MODULUS((S2RBIG,S2RBIG));
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = MODULUS(s2rbig,s2rbig)");
  FLOAT_TEXT_IO.PUT(RBIG); TEXT_IO.NEW_LINE;
  COMPARE(RBIG,R1);
 
  R1 := MODULUS((HRBIG,HRBIG));
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = MODULUS(hrbig,hrbig)");
  FLOAT_TEXT_IO.PUT(S2RBIG); TEXT_IO.NEW_LINE;
  COMPARE(S2RBIG,R1);
 
  R1 := MODULUS((BIG,0.0));
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = MODULUS(big,0.0)");
  FLOAT_TEXT_IO.PUT(BIG); TEXT_IO.NEW_LINE;
  COMPARE(BIG,R1);
 
  R1 := MODULUS((0.0,BIG));
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = MODULUS(0.0,big)");
  FLOAT_TEXT_IO.PUT(BIG); TEXT_IO.NEW_LINE;
  COMPARE(BIG,R1);
 
  R1 := MODULUS((RSMALL,RSMALL));
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = MODULUS(rsmall,rsmall)");
  FLOAT_TEXT_IO.PUT(SQRT_2*RSMALL); TEXT_IO.NEW_LINE;
  COMPARE(SQRT_2*RSMALL,R1);
 
  R1 := MODULUS((S2RSMALL,S2RSMALL));
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = MODULUS(s2rsmall,s2rsmall)");
  FLOAT_TEXT_IO.PUT(RSMALL); TEXT_IO.NEW_LINE;
  COMPARE(RSMALL,R1);
 
  R1 := MODULUS((HRSMALL,HRSMALL));
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = MODULUS(hrsmall,hrsmall)");
  FLOAT_TEXT_IO.PUT(S2RSMALL); TEXT_IO.NEW_LINE;
  COMPARE(S2RSMALL,R1);
 
  R1 := MODULUS((DSMALL,DSMALL));
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = MODULUS(dsmall,dsmall)");
  FLOAT_TEXT_IO.PUT(SQRT_2*DSMALL); TEXT_IO.NEW_LINE;
  COMPARE(SQRT_2*DSMALL,R1);
 
  R1 := MODULUS((S2SMALL,S2SMALL));
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = MODULUS(s2small,s2small)");
  FLOAT_TEXT_IO.PUT(DSMALL); TEXT_IO.NEW_LINE;
  COMPARE(DSMALL,R1);
 
  R1 := MODULUS((SMALL,SMALL));
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = MODULUS(small,small)");
  FLOAT_TEXT_IO.PUT(S2SMALL); TEXT_IO.NEW_LINE;
  COMPARE(S2SMALL,R1);
 
  R1 := MODULUS((SMALL,0.0));
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = MODULUS(small,0.0)");
  FLOAT_TEXT_IO.PUT(SMALL); TEXT_IO.NEW_LINE;
  COMPARE(SMALL,R1);
 
  R1 := MODULUS((0.0,SMALL));
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = MODULUS(0.0,small)");
  FLOAT_TEXT_IO.PUT(SMALL); TEXT_IO.NEW_LINE;
  COMPARE(SMALL,R1);
 
  R1 := MODULUS((0.5,SQRT_3_OVER_2));
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = MODULUS(1/2,SQRT(3)/2)");
  FLOAT_TEXT_IO.PUT(1.0); TEXT_IO.NEW_LINE;
  COMPARE(1.0,R1);
 
  R1 := MODULUS((0.0,0.0));
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = MODULUS(0.0,0.0)");
  FLOAT_TEXT_IO.PUT(0.0); TEXT_IO.NEW_LINE;
  COMPARE(0.0,R1);
 
  R1 := MODULUS((3.0,4.0));
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = MODULUS(3.0,4.0)");
  FLOAT_TEXT_IO.PUT(5.0); TEXT_IO.NEW_LINE;
  COMPARE(5.0,R1);
 
-- test ARGUMENT( Z )
 
  TEXT_IO.NEW_LINE;
  TEXT_IO.PUT_LINE("testing ARGUMENT( Z )");
 
  A1 := ARGUMENT(X=>(0.0,0.0));
  FLOAT_TEXT_IO.PUT(A1); TEXT_IO.PUT_LINE(" = ARGUMENT(0.0,0.0)");
  FLOAT_TEXT_IO.PUT(0.0); TEXT_IO.NEW_LINE;
  COMPARE(0.0,A1);
 
  A1 := ARGUMENT((1.0,1.0));
  FLOAT_TEXT_IO.PUT(A1); TEXT_IO.PUT_LINE(" = ARGUMENT(1.0,1.0)");
  FLOAT_TEXT_IO.PUT(PI_OVER_4); TEXT_IO.NEW_LINE;
  COMPARE(PI_OVER_4,A1);
 
  A1 := ARGUMENT((BIG,BIG));
  FLOAT_TEXT_IO.PUT(A1); TEXT_IO.PUT_LINE(" = ARGUMENT((big,big))");
  FLOAT_TEXT_IO.PUT(PI_OVER_4); TEXT_IO.NEW_LINE;
  COMPARE(PI_OVER_4,A1);
 
  A1 := ARGUMENT((SMALL,SMALL));
  FLOAT_TEXT_IO.PUT(A1); TEXT_IO.PUT_LINE(" = ARGUMENT((small,small))");
  FLOAT_TEXT_IO.PUT(PI_OVER_4); TEXT_IO.NEW_LINE;
  COMPARE(PI_OVER_4,A1);
 
  A1 := ARGUMENT((-SMALL,SMALL));
  FLOAT_TEXT_IO.PUT(A1); TEXT_IO.PUT_LINE(" = ARGUMENT((-small,small))");
  FLOAT_TEXT_IO.PUT(3.0*PI_OVER_4); TEXT_IO.NEW_LINE;
  COMPARE(3.0*PI_OVER_4,A1);
 
  A1 := ARGUMENT((-SMALL,-SMALL));
  FLOAT_TEXT_IO.PUT(A1); TEXT_IO.PUT_LINE(" = ARGUMENT((-small,-small))");
  FLOAT_TEXT_IO.PUT(-3.0*PI_OVER_4); TEXT_IO.NEW_LINE;
  COMPARE(-3.0*PI_OVER_4,A1);
 
  A1 := ARGUMENT((SMALL,-SMALL));
  FLOAT_TEXT_IO.PUT(A1); TEXT_IO.PUT_LINE(" = ARGUMENT((small,-small))");
  FLOAT_TEXT_IO.PUT(-PI_OVER_4); TEXT_IO.NEW_LINE;
  COMPARE(-PI_OVER_4,A1);
 
  A1 := ARGUMENT((BIG,SMALL));
  FLOAT_TEXT_IO.PUT(A1); TEXT_IO.PUT_LINE(" = ARGUMENT((big,small))");
  FLOAT_TEXT_IO.PUT(0.0); TEXT_IO.NEW_LINE;
  COMPARE(0.0,A1);
 
  A1 := ARGUMENT((-1.0,SMALL));
  FLOAT_TEXT_IO.PUT(A1); TEXT_IO.PUT_LINE(" = ARGUMENT((-1.0,small))");
  FLOAT_TEXT_IO.PUT(PI); TEXT_IO.NEW_LINE;
  COMPARE(PI,A1);
 
  A1 := ARGUMENT((-1.0,-SMALL));
  FLOAT_TEXT_IO.PUT(A1); TEXT_IO.PUT_LINE(" = ARGUMENT((-1.0,-small))");
  FLOAT_TEXT_IO.PUT(-PI); TEXT_IO.NEW_LINE;
  COMPARE(-PI,A1);
 
  A1 := ARGUMENT((SMALL,BIG));
  FLOAT_TEXT_IO.PUT(A1); TEXT_IO.PUT_LINE(" = ARGUMENT((small,big))");
  FLOAT_TEXT_IO.PUT(HALF_PI); TEXT_IO.NEW_LINE;
  COMPARE(HALF_PI,A1);
 
  A1 := ARGUMENT((SMALL,-1.0));
  FLOAT_TEXT_IO.PUT(A1); TEXT_IO.PUT_LINE(" = ARGUMENT((small,-1.0))");
  FLOAT_TEXT_IO.PUT(-HALF_PI); TEXT_IO.NEW_LINE;
  COMPARE(-HALF_PI,A1);
 
  A1 := ARGUMENT((0.5,SQRT_3_OVER_2));
  FLOAT_TEXT_IO.PUT(A1); TEXT_IO.PUT_LINE(" = ARGUMENT((1/2,sqrt(3)/2))");
  FLOAT_TEXT_IO.PUT(PI_OVER_3); TEXT_IO.NEW_LINE;
  COMPARE(PI_OVER_3,A1);
 
  A1 := ARGUMENT((SQRT_3_OVER_2,0.5));
  FLOAT_TEXT_IO.PUT(A1); TEXT_IO.PUT_LINE(" = ARGUMENT((sqrt(3)/2,1/2))");
  FLOAT_TEXT_IO.PUT(PI_OVER_6); TEXT_IO.NEW_LINE;
  COMPARE(PI_OVER_6,A1);
 
-- test ARGUMENT( Z, CYCLE ) 
 
  TEXT_IO.NEW_LINE;
  TEXT_IO.PUT_LINE("testing ARGUMENT( Z, CYCLE ) ");
 
  A1 := ARGUMENT(X=>(BIG,BIG),CYCLE=>360.0);
  FLOAT_TEXT_IO.PUT(A1); TEXT_IO.PUT_LINE(" = ARGUMENT((big,big),360)");
  FLOAT_TEXT_IO.PUT(45.0); TEXT_IO.NEW_LINE;
  COMPARE(45.0,A1);
 
  A1 := ARGUMENT((-SMALL,-SMALL),1.0);
  FLOAT_TEXT_IO.PUT(A1); TEXT_IO.PUT_LINE(" = ARGUMENT((-small,-small),1.0)");
  FLOAT_TEXT_IO.PUT(-3.0/8.0); TEXT_IO.NEW_LINE;
  COMPARE(-3.0/8.0,A1);
 
  A1 := ARGUMENT((0.5,SQRT_3_OVER_2),360.0);
  FLOAT_TEXT_IO.PUT(A1); TEXT_IO.PUT_LINE(" = ARGUMENT((1/2,sqrt(3)/2),360.0)");
  FLOAT_TEXT_IO.PUT(60.0); TEXT_IO.NEW_LINE;
  COMPARE(60.0,A1);
 
  A1 := ARGUMENT((SQRT_3_OVER_2,0.5),360.0);
  FLOAT_TEXT_IO.PUT(A1); TEXT_IO.PUT_LINE(" = ARGUMENT((sqrt(3)/2,1/2),360.0)");
  FLOAT_TEXT_IO.PUT(30.0); TEXT_IO.NEW_LINE;
  COMPARE(30.0,A1);

-- COMPLEX arithmetic operations
 
-- test "abs"(Z)
 
  TEXT_IO.NEW_LINE;
  TEXT_IO.PUT_LINE("testing , ""abs""(Z)");
 
  R1 := abs (HBIG,HBIG);
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = abs (hbig,hbig)");
  FLOAT_TEXT_IO.PUT(S2BIG); TEXT_IO.NEW_LINE;
  COMPARE(S2BIG,R1);
 
  R1 := abs (-BIG,0.0);
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = abs (-big,0.0)");
  FLOAT_TEXT_IO.PUT(BIG); TEXT_IO.NEW_LINE;
  COMPARE(BIG,R1);
 
  R1 := abs (0.0,BIG);
  FLOAT_TEXT_IO.PUT(R1); TEXT_IO.PUT_LINE(" = abs (0.0,big)");
  FLOAT_TEXT_IO.PUT(BIG); TEXT_IO.NEW_LINE;
  COMPARE(BIG,R1);

-- test unary "+" and "-" on COMPLEX
 
  TEXT_IO.NEW_LINE;
  TEXT_IO.PUT_LINE("testing , ""+""(Z) and ""-""(Z)");
 
  Z1 := +(LAST,LAST);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = ""+""((last,last))");
  CX_IO.PUT(C(LAST,LAST)); TEXT_IO.NEW_LINE;
  COMPARE((LAST,LAST),Z1);
 
  Z1 := -(BIG,BIG);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = ""-""((big,big))");
  CX_IO.PUT(C(-BIG,-BIG)); TEXT_IO.NEW_LINE;
  COMPARE((-BIG,-BIG),Z1);
 
 
-- test CONJUGATE(Z) and CONJ(Z)
 
  TEXT_IO.NEW_LINE;
  TEXT_IO.PUT_LINE("testing  CONJUGATE(Z) ");
 
  Z1 := CONJUGATE((BIG,BIG));
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = conjugate((big,big))");
  CX_IO.PUT(C(BIG,-BIG)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(BIG,-BIG),Z1);
 
  Z1 := CONJUGATE((-SMALL,-SMALL));
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = conjugate((-small,-small))");
  CX_IO.PUT(C(-SMALL,SMALL)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(-SMALL,SMALL),Z1);
 
  Z1 := CONJUGATE((-1.0,-2.0));
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = conjugate((-1.0,-2.0))");
  CX_IO.PUT(C(-1.0,2.0)); TEXT_IO.NEW_LINE;
  COMPARE((-1.0,2.0),Z1);
 
-- test "+"(Z1,Z2)
 
  TEXT_IO.NEW_LINE;
  TEXT_IO.PUT_LINE("testing ""+""(Z1,Z2) ");
 
  Z1 := COMPOSE_FROM_CARTESIAN(1.0,2.0) + COMPOSE_FROM_CARTESIAN(5.0,7.0);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = (1.0,2.0) + (5.0,7.0)");
  CX_IO.PUT(C(6.0,9.0)); TEXT_IO.NEW_LINE;
  COMPARE((6.0,9.0),Z1);
 
  Z1 := (HBIG,HBIG) + (HBIG,HBIG);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = (hbig,hbig) + (hbig,hbig)");
  CX_IO.PUT(C(BIG,BIG)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(BIG,BIG),Z1);
 
  Z1 := (SMALL,SMALL) + (SMALL,SMALL);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = (small,small) + (small,small)");
  CX_IO.PUT(C(DSMALL,DSMALL)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(DSMALL,DSMALL),Z1);
 
  Z1 := COMPOSE_FROM_CARTESIAN(HBIG) + COMPOSE_FROM_CARTESIAN(HBIG,BIG);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = hbig + (hbig,big)");
  CX_IO.PUT(C(BIG,BIG)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(BIG,BIG),Z1);
 
  Z1 := COMPOSE_FROM_CARTESIAN(HBIG,BIG) + COMPOSE_FROM_CARTESIAN(HBIG);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = (hbig,big) + hbig");
  CX_IO.PUT(C(BIG,BIG)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(BIG,BIG),Z1);
 
  Z1 :="+"((BIG,BIG),(0.0,0.0));
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" =""+""((big,big),(0.0,0.0))");
  CX_IO.PUT(C(BIG,BIG)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(BIG,BIG),Z1);
 
 
-- test "-"(Z1,Z2)
  TEXT_IO.NEW_LINE;
  TEXT_IO.PUT_LINE("testing ""-""(Z1,Z2) ");
 
  Z1 := COMPOSE_FROM_CARTESIAN(5.0,9.0) - COMPOSE_FROM_CARTESIAN(1.0,2.0);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = (5.0,9.0) - (1.0,2.0)");
  CX_IO.PUT(C(4.0,7.0)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(4.0,7.0),Z1);
 
  Z1 := (BIG,BIG) - (HBIG,HBIG);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = (big,big) - (hbig,hbig)");
  CX_IO.PUT(C(HBIG,HBIG)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(HBIG,HBIG),Z1);
 
  Z1 := (DSMALL,DSMALL) - (SMALL,SMALL);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = (dsmall,dsmall) - (small,small)");
  CX_IO.PUT(C(SMALL,SMALL)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(SMALL,SMALL),Z1);
 
  Z1 := COMPOSE_FROM_CARTESIAN(BIG) - COMPOSE_FROM_CARTESIAN(BIG,BIG);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = big - (big,big)");
  CX_IO.PUT(C(0.0,-BIG)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(0.0,-BIG),Z1);
 
  Z1 := COMPOSE_FROM_CARTESIAN(-HBIG,BIG) - COMPOSE_FROM_CARTESIAN(HBIG);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = (-hbig,big) - hbig");
  CX_IO.PUT(C(-BIG,BIG)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(-BIG,BIG),Z1);
 
  Z1 := "-"((BIG,BIG),(SMALL,SMALL));
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = ""-""((big,big),(small,small))");
  CX_IO.PUT(C(BIG,BIG)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(BIG,BIG),Z1);
 
 
 
-- test "*"(Z1,Z2)
  TEXT_IO.NEW_LINE;
  TEXT_IO.PUT_LINE("testing ""*""(Z1,Z2) ");
 
  Z1 := C(1.0,1.0) * C(1.0,1.0);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (1.0,1.0) * (1.0,1.0)");
  CX_IO.PUT(C(0.0,2.0)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(0.0,2.0),Z1);
 
  Z1 := C(HRBIG,HRBIG) * C(HRBIG,HRBIG);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (hrbig,hrbig) * (hrbig,hrbig)");
  CX_IO.PUT(C(0.0,HBIG)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(0.0,HBIG),Z1);
 
  Z1 := C(S2RBIG,S2RBIG) * C(S2RBIG,S2RBIG);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (s2rbig,s2rbig) * (s2rbig,s2rbig)");
  CX_IO.PUT(C(0.0,BIG)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(0.0,BIG),Z1);
 
  Z1 := C(RSMALL,RSMALL) * C(RSMALL,RSMALL);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (rsmall,rsmall) * (rsmall,rsmall)");
  CX_IO.PUT(C(0.0,DSMALL)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(0.0,DSMALL),Z1);
 
  Z1 := C(S2RSMALL,S2RSMALL) * C(S2RSMALL,S2RSMALL);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (s2rsmall,s2rsmall) * (s2rsmall,s2rsmall)");
  CX_IO.PUT(C(0.0,SMALL)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(0.0,SMALL),Z1);
 
  Z1 := C(HBIG,HBIG) * C(1.0,1.0);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (hbig,hbig) * (1.0,1.0)");
  CX_IO.PUT(C(0.0,BIG)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(0.0,BIG),Z1);
 
  Z1 := C(BIG,0.0) * C(1.0,1.0);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (big,0.0) * (1.0,1.0)");
  CX_IO.PUT(C(BIG,BIG)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(BIG,BIG),Z1);
 
  Z1 := C(SMALL,0.0) * C(1.0,1.0);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (small,0.0) * (1.0,1.0)");
  CX_IO.PUT(C(SMALL,SMALL)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(SMALL,SMALL),Z1);
 
  Z1 := C(SMALL,BIG) * C(1.0,1.0);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (small,big,) * (1.0,1.0)");
  CX_IO.PUT(C(-BIG,BIG)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(-BIG,BIG),Z1);
 
  Z1 := C(BIG,SMALL) * C(1.0,1.0);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (big,small) * (1.0,1.0)");
  CX_IO.PUT(C(BIG,BIG)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(BIG,BIG),Z1);
 
  Z1 := C(BIG,BIG) * C(SMALL,SMALL);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (big,big) * (small,small)");
  CX_IO.PUT(C(0.0,(BIG*SMALL)*2.0)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(0.0,(BIG*SMALL)*2.0),Z1);
 
 
-- test "/"(Z1,Z2)
  TEXT_IO.NEW_LINE;
  TEXT_IO.PUT_LINE("testing ""/""(Z1,Z2) ");
 
  Z1 := C(1.0,1.0) / C(1.0,1.0);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (1.0,1.0) / (1.0,1.0)");
  CX_IO.PUT(C(1.0,0.0)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(1.0,0.0),Z1);
 
  Z1 := C(25.0,50.0) / C(3.0,4.0);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (25.0,50.0) / (3.0,4.0)");
  CX_IO.PUT(C(11.0,2.0)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(11.0,2.0),Z1);
 
  Z1 := C(25.0,50.0) / C(4.0,3.0);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (25.0,50.0) / (4.0,3.0)");
  CX_IO.PUT(C(10.0,5.0)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(10.0,5.0),Z1);
 
  Z1 := C(BIG,BIG) / C(BIG,BIG);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (big,big) / (big,big)");
  CX_IO.PUT(C(1.0,0.0)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(1.0,0.0),Z1);
 
  Z1 := C(BIG,-BIG) / C(-BIG,SMALL);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (big,-big) / (-big,small)");
  CX_IO.PUT(C(-1.0,1.0)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(-1.0,1.0),Z1);
 
  Z1 := C(BIG*SMALL,BIG*SMALL) / C(BIG,BIG);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (big*small,big*small) / (big,big)");
  CX_IO.PUT(C(SMALL,0.0)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(SMALL,0.0),Z1);
 
  Z1 := C(BIG*SMALL,BIG*SMALL) / C(SMALL,SMALL);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (big*small,big*small) / (small,small)");
  CX_IO.PUT(C(BIG,0.0)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(BIG,0.0),Z1);
 
  Z1 := C(BIG,BIG) / C(1.0,1.0);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (big,big) / (1.0,1.0)");
  CX_IO.PUT(C(BIG,0.0)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(BIG,0.0),Z1);
 
  Z1 := C(SMALL,SMALL) / C(1.0,1.0);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (small,small) / (1.0,1.0)");
  CX_IO.PUT(C(SMALL,0.0)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(SMALL,0.0),Z1);
 
  Z1 := C(BIG,SMALL) / C(SMALL,BIG);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (big,small) / (small,big)");
  CX_IO.PUT(C(0.0,-1.0)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(0.0,-1.0),Z1);
 
  Z1 := C(SMALL,BIG) / C(BIG,SMALL);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (small,big) / (big,small)");
  CX_IO.PUT(C(0.0,1.0)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(0.0,1.0),Z1);
 
  Z1 := (SMALL,SMALL) / (SMALL,SMALL);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (small,small) / (small,small)");
  CX_IO.PUT(C(1.0,0.0)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(1.0,0.0),Z1);
 
  Z1 := (SMALL,0.0) / (SMALL,2.0*SMALL);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (small,0.0) / (small,2.0*small)");
  CX_IO.PUT(C(0.2,-0.4)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(0.2,-0.4),Z1);
 
  Z1 := C(BIG) / C(BIG,BIG);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (big / (big,big)");
  CX_IO.PUT(C(0.5,-0.5)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(0.5,-0.5),Z1);
 
  Z1 := C(SMALL) / C(SMALL,SMALL);
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" (small / (small,small)");
  CX_IO.PUT(C(0.5,-0.5)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(0.5,-0.5),Z1);
 
 
-- test "**"(Z1,N)
 
  TEXT_IO.NEW_LINE;
  TEXT_IO.PUT_LINE("testing ""**""(Z1,N) ");
 
  Z1 := COMPOSE_FROM_CARTESIAN(0.0,0.0) ** 0;
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = (0.0,0.0) ** 0");
  CX_IO.PUT(C(1.0,0.0)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(1.0,0.0),Z1);
 
  Z1 := COMPOSE_FROM_CARTESIAN(0.0,0.0) ** 100;
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = (0.0,0.0) ** 100");
  CX_IO.PUT(C(0.0,0.0)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(0.0,0.0),Z1);
 
  Z1 := COMPOSE_FROM_CARTESIAN(1.0,1.0) ** 0;
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = (1.0,1.0) ** 0");
  CX_IO.PUT(C(1.0,0.0)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(1.0,0.0),Z1);
 
  Z1 := COMPOSE_FROM_CARTESIAN(SQRT_2,SQRT_2) ** 4;
  CX_IO.PUT(Z1); TEXT_IO.PUT_LINE(" = (sqrt_2,sqrt_2) ** 4");
  CX_IO.PUT(C(-16.0,0.0)); TEXT_IO.NEW_LINE;
  COMPARE(COMPOSE_FROM_CARTESIAN(-16.0,0.0),Z1);
 
  REPORT;

end TEST_GENERIC_COMPLEX_TYPES_2;