COMPLEX = RECORD ("C-Type")

(* unbound accessors for convenience *)

(* bound accessor and mutator *)

(* convenience accessors *)

(* general accessor and mutator *)

PROCEDURE [.] component ( n : CARDINAL; z : COMPLEX ) : REAL; (* Returns the value of the n-th component of complex number z *)

PROCEDURE [!] setComponent ( n : CARDINAL; VAR z : COMPLEX; r : REAL ); (* Overwrites the value of the n-th component of complex number z with r *)

PROCEDURE Cmplx ( re, im : REAL ) : COMPLEX;

CONST [{}] allowValueConstructors = TRUE;

        re,        (* real part *)

    COMPLEX = OPAQUE RECORD ("C-Type")

CONST [TYPE] semanticModel = 'C'; (* obsolete *)

    COMPLEX = OPAQUE RECORD ['C']

    ['C'] COMPLEX = OPAQUE RECORD

CONST [{}] allowValueConstructors = TRUE; (* either this or ... *)

CONST [:=] allowValueConstructors = TRUE; (* but this needs more checks *)

(* literal assignment *)

CONST [{}] allowStructuredLiteralAssignment = TRUE; (* this is simplest *)

CONST [:=] allowStructuredLiteralAssignment = TRUE; (* this needs more checks *)

(* monadic arithmetic operations *)

(* dyadic arithmetic operations *)

(* number type *)

CONST [TYPE] semanticModel = 'C';

(* IO operations, bound to READ, WRITE and WRITEF *)

   - the numeric value of the numeral string read is assigned to the variable passed in for z

(* Writes the textual representation of COMPLEX value z in simple format to output stream outfile *)

FROM File IO? IMPORT File; (* required for IO *)

(* COMPLEX type *)

        re : REAL; (* real part *)
        im : REAL; (* imaginary part *)

(* number system *)

CONST [C] isComplexNumberType = TRUE;

(* constructs a complex number from an ordered pair *)

(* hooks for standard procedures READ, WRITE and WRITEF *)

PROCEDURE Read( infile : File; VAR z : COMPLEX );

   - the numeric value of the numeral string read is assigned to the variable passed in for b
   - the file status is set to any of success, outOfRange, wrongFormat, endOfLine, or endOfInput *)

PROCEDURE Write( outfile : File; z : COMPLEX ); (* Writes the textual representation of value z in simple format to output stream outfile *)

PROCEDURE Write F?( outfile : File; fmtStr : ARRAY OF CHAR; items : CARDINAL; VARIADIC v[items] OF z : COMPLEX ); (* Writes a formatted textual representation of one or more COMPLEX values to output stream outfile. The value

   of parameter items is calculated and inserted automatically. The output format is determined by fmtStr. *)

DEFINITION MODULE COMPLEX;

(* Complex Numbers *) 

FROM FileIO IMPORT File;

TYPE
    COMPLEX = OPAQUE RECORD
        re : REAL;
        im : REAL;
    END;

(* constructor and accessors *)

PROCEDURE Cmplx ( real, imag : REAL ) : COMPLEX;
(* constructs a complex from an ordered pair *)

PROCEDURE Re ( z : COMPLEX ) : REAL;
(* returns the real part of a complex number *)

PROCEDURE Im ( z : COMPLEX ) : REAL;
(* returns the imaginary part of a complex number *)


(* unary arithmetic operations *) 

PROCEDURE [ABS] abs ( z : COMPLEX ) : COMPLEX; 

PROCEDURE [NEG] neg ( z : COMPLEX ) : COMPLEX; 


(* binary arithmetic operations *) 

PROCEDURE [+] add ( z1, z2 : COMPLEX ) : COMPLEX; 

PROCEDURE [-] sub ( z1, z2 : COMPLEX ) : COMPLEX; 

PROCEDURE [*] multiply ( z1, z2 : COMPLEX ) : COMPLEX; 

PROCEDURE [/] divide ( z1, z2 : COMPLEX ) : COMPLEX; 


(* relational operations *) 

PROCEDURE [=] isEqual ( z1, z2 : COMPLEX ) : BOOLEAN; 

PROCEDURE [#] isNotEqual ( z1, z2 : COMPLEX ) : BOOLEAN; 


(* IO operations *)

PROCEDURE (* [READ] *) Read( infile : File; VAR z : COMPLEX );
(* Reads the textual representation of a COMPLEX value in simple format from input stream infile
   - any leading whitespace is skipped
   - any remaining characters that are part of the numeral being read are removed from infile
   - the numeric value of the numeral string read is assigned to the variable passed in for z
   - the file status is set to any of allRight, outOfRange, wrongFormat, endOfLine, or endOfInput *)

PROCEDURE (* [WRITE] *) Write( outfile : File; z : COMPLEX );
(* Writes the textual representation of z in scientific format showing nine places after the
   decimal point to output stream outfile without padding. *)

PROCEDURE (* [WRITEF] *) WriteF( outfile : File; z : COMPLEX; n : CARDINAL);
(* Writes the textual representation of z in scientific format showing n places after the
   decimal point to output stream outfile without padding. *)

PROCEDURE (* [WRITEF] *) WriteFixed( outfile : File; z : COMPLEX; i, n : CARDINAL );
(* Writes the textual representation of z in simple format with the decimal point at position i
    and showing n places after the decimal point to output stream outfile.

(* unbound IO operations *)

PROCEDURE WriteEng( outfile : File; num : COMPLEX; n, m, exp : CARDINAL );
(* Writes the textual representation of z in engineering format showing n places before and
   m places after the decimal point with exponent exp to output stream outfile without padding.
   Parameters m and exp are rounded to the nearest value of three. *)

PROCEDURE WriteLedger( outfile : File; num : COMPLEX; i, n : CARDINAL );
(* Writes the textual representation of z in ledger format with the sign at position 0, the decimal
   point at position i and showing n places after the decimal point to output stream outfile. *)

END COMPLEX.