home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / magazine / drdobbs / 1989 / 01 / mod2cp.asc < prev    next >
Text File  |  1989-01-02  |  9KB  |  446 lines
  1.  
  2. _C++ VERSUS MODULA-2_
  3.  
  4. by Scott Ladd
  5.  
  6.  
  7. [LISTING ONE]
  8.  
  9. =======================
  10. Listing 1: COMPLEX.HPP
  11. =======================
  12.  
  13. //    Header:      Complex
  14. //    Version:     1.00
  15. //    Date:        10-Sep-1988
  16. //    Language:    C++
  17. //    Purpose:     Provides the class "complex" for C++ programs.
  18. //    Copyright 1988 by Scott Robert Ladd. All Rights Reserved.
  19.  
  20. #include "stream.hpp"
  21.  
  22. class complex
  23.     {
  24.     private:
  25.         double real;   // real part
  26.         double imag;   // imaginary part
  27.  
  28.     public:
  29.         // constructors
  30.         complex (void)
  31.             {
  32.             real = 0.0;
  33.             imag = 0.0;
  34.             }
  35.  
  36.         complex (complex &c);
  37.         complex (double &r, double &i);
  38.  
  39.         // value extraction methods
  40.         double get_real (void);
  41.         double get_imag (void);
  42.  
  43.         // assignment method
  44.         void assign (double &r, double &i);
  45.  
  46.         // calculation methods
  47.         complex operator = (complex &c);
  48.         complex operator + (complex &c);
  49.         complex operator - (complex &c);
  50.         complex operator * (complex &c);
  51.         complex operator / (complex &c);
  52.  
  53.         // output method
  54.         friend ostream& operator << (ostream &s, complex &c);
  55.     };
  56.  
  57. [LISTING TWO]
  58.  
  59. =======================
  60. Listing 2: COMPLEX.HPP
  61. =======================
  62.  
  63. //    Module:      Complex
  64. //    Version:     1.00
  65. //    Date:        10-Sep-1988
  66. //    Language:    C++
  67. //    Purpose:     Provides the class "complex" for C++ programs.
  68. //    Copyright 1988 by Scott Robert Ladd. All Rights Reserved.
  69.  
  70. #include "complex.hpp"
  71. #include "stream.hpp"
  72.  
  73. // constructor: copy initializer
  74. complex::complex (complex &c)
  75.     {
  76.     real = c.real;
  77.     imag = c.imag;
  78.     }
  79.  
  80. // constructor: real and imaginary parts specified
  81. complex::complex (double &r, double &i)
  82.     {
  83.     real = r;
  84.     imag = i;
  85.     }
  86.  
  87. // retrieve real portion
  88. double complex::get_real (void)
  89.     {
  90.     return real;
  91.     }
  92.  
  93. // retrieve imaginary portion
  94. double complex::get_imag (void)
  95.     {
  96.     return imag;
  97.     }
  98.  
  99. // set the value of a complex object to a pair of real values
  100. void complex::assign (double &r, double &i)
  101.     {
  102.     real = r;
  103.     imag = i;
  104.     }
  105.  
  106. // set the value of a complex number
  107. complex complex::operator = (complex &c)
  108.     {
  109.     real = c.real;
  110.     imag = c.imag;
  111.  
  112.     return *this;
  113.     }
  114.  
  115. // add two complex numbers
  116. complex complex::operator + (complex &c)
  117.     {
  118.     complex res;
  119.  
  120.     res.real = real + c.real;
  121.     res.imag = imag + c.imag;
  122.  
  123.     return res;
  124.     }
  125.  
  126. // subtract two complex numbers
  127. complex complex::operator - (complex &c)
  128.     {
  129.     complex res;
  130.  
  131.     res.real = real - c.real;
  132.     res.imag = imag - c.imag;
  133.  
  134.     return res;
  135.     }
  136.  
  137. // multiply two complex numbers
  138. complex complex::operator * (complex &c)
  139.     {
  140.     complex res;
  141.  
  142.     res.real = (real * c.real) - (imag * c.imag);
  143.     res.imag = (imag * c.real) + (real * c.imag);
  144.  
  145.     return res;
  146.     }
  147.  
  148. // divide two complex numbers
  149. complex complex::operator / (complex &c)
  150.     {
  151.     complex res;
  152.     double r, den;
  153.  
  154.     if (fabs(c.real) >= fabs(c.imag))
  155.         {
  156.         r = c.imag / c.real;
  157.         den = c.real + r * c.imag;
  158.         res.real = (real + r * imag) / den;
  159.         res.imag = (imag - r * real) / den;
  160.         }
  161.     else
  162.         {
  163.         r = c.real / c.imag;
  164.         den = c.imag + r * c.real;
  165.         res.real = (real * r + imag) / den;
  166.         res.imag = (imag * r - real) / den;
  167.         }
  168.  
  169.     return res;
  170.     }
  171.  
  172. // stream output of complex number
  173. ostream& operator << (ostream &s, complex &c)
  174.     {
  175.     char buf[80];
  176.  
  177.     sprintf(buf,"%1g%+1gi",c.real,c.imag);
  178.     return (s << buf);
  179.     }
  180.  
  181.  
  182.  
  183. [LISTING THREE]
  184.  
  185. =======================
  186. Listing 3: COMPTEST.CPP
  187. =======================
  188.  
  189. //    Program:     CompTest
  190. //    Version:     1.00
  191. //    Date:        10-Sep-1988
  192. //    Language:    C++
  193. //    Purpose:     Provides the class "complex" for C++ programs.
  194. //    Copyright 1988 by Scott Robert Ladd. All Rights Reserved.
  195.  
  196. #include "complex.hpp"
  197.  
  198. void main()
  199.     {
  200.     complex a(1.0,2.0),
  201.             b(-1.5,-5.5),
  202.             c;
  203.  
  204.     cout << "a = " << a << " b = " << b << " c = " << c << "\n";
  205.     c = a + b;
  206.     cout << c << "\n";
  207.     c = c - b;
  208.     cout << c << "\n";
  209.     c = b;
  210.     cout << c << "\n";
  211.     c = b * a;
  212.     cout << c << "\n";
  213.     c = c / a;
  214.     cout << c << "\n";
  215.     c = b / b;
  216.     cout << c << "\n";
  217.     }
  218.  
  219. [LISTING FOUR]
  220.  
  221. =======================
  222. Listing 4: COMPLEX.DEF
  223. =======================
  224.  
  225. DEFINITION MODULE Complex;
  226. (*
  227.     Version:     1.00
  228.     Date:        11-Sep-1988
  229.     Language:    Modula-2
  230.     Purpose:     Provides the type "complex" for Modula-2.
  231.     Copyright 1988 by Scott Robert Ladd. All Rights Reserved.
  232. *)
  233.  
  234. TYPE
  235.     COMPLEX;
  236.  
  237. PROCEDURE Create(VAR C : COMPLEX);
  238.  
  239. PROCEDURE Destroy(VAR C : COMPLEX);
  240.  
  241. PROCEDURE GetReal(C : COMPLEX) : LONGREAL;
  242.  
  243. PROCEDURE GetImag(C : COMPLEX) : LONGREAL;
  244.  
  245. PROCEDURE Assign(VAR C : COMPLEX; R, I : LONGREAL);
  246.  
  247. PROCEDURE Equate(VAR C1 : COMPLEX; C2 : COMPLEX);
  248.  
  249. PROCEDURE Add(VAR C : COMPLEX; C1, C2 : COMPLEX);
  250.  
  251. PROCEDURE Sub(VAR C : COMPLEX; C1, C2 : COMPLEX);
  252.  
  253. PROCEDURE Mult(VAR C : COMPLEX; C1, C2 : COMPLEX);
  254.  
  255. PROCEDURE Div(VAR C : COMPLEX; C1, C2 : COMPLEX);
  256.  
  257. PROCEDURE WriteComplex(C : COMPLEX);
  258.  
  259. END Complex.
  260.  
  261.  
  262. [LISTING FIVE]
  263.  
  264. =======================
  265. Listing 5: COMPLEX.MOD
  266. =======================
  267.  
  268. IMPLEMENTATION MODULE Complex;
  269. (*
  270.     Version:     1.00
  271.     Date:        11-Sep-1988
  272.     Language:    Modula-2
  273.     Purpose:     Provides the type "complex" for Modula-2.
  274.     Copyright 1988 by Scott Robert Ladd. All Rights Reserved.
  275. *)
  276.  
  277. FROM Str     IMPORT FixRealToStr;
  278. FROM IO      IMPORT WrStr, WrChar;
  279. FROM Storage IMPORT ALLOCATE, DEALLOCATE;
  280.  
  281. TYPE
  282.     COMPLEX = POINTER TO RECORD
  283.                   Real : LONGREAL;
  284.                   Imag : LONGREAL;
  285.               END;
  286.  
  287. PROCEDURE Create(VAR C : COMPLEX);
  288.   BEGIN
  289.     NEW(C);
  290.     C^.Real := 0.0;
  291.     C^.Imag := 0.0;
  292. END Create;
  293.  
  294. PROCEDURE Destroy(VAR C : COMPLEX);
  295.   BEGIN
  296.     DISPOSE(C);
  297. END Destroy;
  298.  
  299. PROCEDURE GetReal(C : COMPLEX) : LONGREAL;
  300.   BEGIN
  301.     RETURN C^.Real;
  302. END GetReal;
  303.  
  304. PROCEDURE GetImag(C : COMPLEX) : LONGREAL;
  305.   BEGIN
  306.     RETURN C^.Imag;
  307. END GetImag;
  308.  
  309. PROCEDURE Assign(VAR C : COMPLEX; R, I : LONGREAL);
  310.   BEGIN
  311.     C^.Real := R;
  312.     C^.Imag := I;
  313. END Assign;
  314.  
  315. PROCEDURE Equate(VAR C1 : COMPLEX; C2 : COMPLEX);
  316.   BEGIN
  317.     C1^.Real := C2^.Real;
  318.     C1^.Imag := C2^.Imag;
  319. END Equate;
  320.  
  321. PROCEDURE Add(VAR C : COMPLEX; C1, C2 : COMPLEX);
  322.   BEGIN
  323.     C^.Real := C1^.Real + C2^.Real;
  324.     C^.Imag := C1^.Imag + C2^.Imag;
  325. END Add;
  326.  
  327. PROCEDURE Sub(VAR C : COMPLEX; C1, C2 : COMPLEX);
  328.   BEGIN
  329.     C^.Real := C1^.Real - C2^.Real;
  330.     C^.Imag := C1^.Imag - C2^.Imag;
  331. END Sub;
  332.  
  333. PROCEDURE Mult(VAR C : COMPLEX; C1, C2 : COMPLEX);
  334.   BEGIN
  335.     C^.Real := (C1^.Real * C2^.Real) - (C1^.Imag * C2^.Imag);
  336.     C^.Imag := (C1^.Real * C2^.Imag) - (C1^.Imag * C2^.Real);
  337. END Mult;
  338.  
  339. PROCEDURE Div(VAR C : COMPLEX; C1, C2 : COMPLEX);
  340.   VAR
  341.     r1, r2 : LONGREAL;
  342.   BEGIN
  343.     IF ABS(C2^.Real) >= ABS(C2^.Imag) THEN
  344.         r1 := C2^.Imag / C2^.Real;
  345.         r2 := C2^.Real + r1 * C2^.Imag;
  346.         C^.Real := (C1^.Real + r1 * C1^.Imag) / r2;
  347.         C^.Imag := (C1^.Imag - r1 * C1^.Real) / r2;
  348.     ELSE
  349.         r1 := C2^.Real / C2^.Imag;
  350.         r2 := C2^.Imag + r1 * C2^.Real;
  351.         C^.Real := (C1^.Real * r1 + C1^.Imag) / r2;
  352.         C^.Imag := (C1^.Imag * r1 - C1^.Real) / r2;
  353.     END; (* IF *)
  354. END Div;
  355.  
  356. PROCEDURE WriteComplex(C : COMPLEX);
  357.   VAR
  358.     S  : ARRAY [0..10] OF CHAR;
  359.     OK : BOOLEAN;
  360.   BEGIN
  361.     FixRealToStr(C^.Real, 3, S, OK);
  362.     WrStr(S);
  363.     FixRealToStr(C^.Imag, 3, S, OK);
  364.     IF C^.Imag >= 0.0 THEN
  365.         WrChar('+');
  366.     END; (* IF *)
  367.     WrStr(S);
  368.     WrChar('i');
  369. END WriteComplex;
  370.  
  371. END Complex.
  372.  
  373. [LISTING SIX]
  374.  
  375. =======================
  376. Listing 6: COMPTEST.MOD
  377. =======================
  378.  
  379. MODULE CompTest;
  380. (*
  381.     Version:     1.00
  382.     Date:        11-Sep-1988
  383.     Language:    Modula-2
  384.     Purpose:     Tests the Complex module
  385.     Copyright 1988 by Scott Robert Ladd. All Rights Reserved.
  386. *)
  387.  
  388. FROM Complex IMPORT COMPLEX,
  389.                     Create, Destroy, Assign, Equate,
  390.                     Add, Sub, Mult, Div, WriteComplex;
  391.  
  392. FROM IO      IMPORT WrStr, WrLn;
  393.  
  394. VAR
  395.     a, b, c : COMPLEX;
  396.     r1, i1  : LONGREAL;
  397.     r2, i2  : LONGREAL;
  398.  
  399. BEGIN
  400.     r1 :=  1.0;
  401.     i1 :=  2.0;
  402.     r2 := -1.5;
  403.     i2 := -5.5;
  404.  
  405.     Create(a);
  406.     Create(b);
  407.     Create(c);
  408.  
  409.     Assign(a,r1,i1);
  410.     Assign(b,r2,i2);
  411.     Assign(c,r1,i2);
  412.  
  413.     WrStr("a = ");
  414.     WriteComplex(a);
  415.     WrStr(" b = ");
  416.     WriteComplex(b);
  417.     WrStr(" c = ");
  418.     WriteComplex(c);
  419.     WrLn;
  420.  
  421.     Add(c,a,b);
  422.     WriteComplex(c);
  423.     WrLn;
  424.  
  425.     Sub(c,c,b);
  426.     WriteComplex(c);
  427.     WrLn;
  428.  
  429.     Mult(c,b,a);
  430.     WriteComplex(c);
  431.     WrLn;
  432.  
  433.     Div(c,c,a);
  434.     WriteComplex(c);
  435.     WrLn;
  436.  
  437.     Div(c,b,b);
  438.     WriteComplex(c);
  439.     WrLn;
  440.  
  441.     Destroy(a);
  442.     Destroy(b);
  443.     Destroy(c);
  444.  
  445. END CompTest.
  446.