home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / Misc / OB3.2D2.DMS / in.adf / Module / COMPLEX.mod < prev    next >
Encoding:
Text File  |  1994-08-05  |  2.9 KB  |  156 lines
  1. (*-------------------------------------------------------------------------*)
  2. (*                                                                         *)
  3. (*  Amiga Oberon Interface Module: COMPLEX            Date: 02-Nov-92      *)
  4. (*                                                                         *)
  5. (*   © 1992 by Fridtjof Siebert                                            *)
  6. (*                                                                         *)
  7. (*-------------------------------------------------------------------------*)
  8.  
  9. MODULE COMPLEX;
  10.  
  11. IMPORT BT * := BasicTypes, MATHLIB, math := MathIEEEDoubBas;
  12.  
  13. TYPE
  14.   COMPLEX * = POINTER TO COMPLEXDesc;
  15.  
  16.   COMPLEXDesc * = RECORD (BT.FIELDDesc)
  17.     re-,im-: LONGREAL;
  18.   END;
  19.  
  20.  
  21. PROCEDURE Create * (re,im: LONGREAL): COMPLEX;
  22. (*
  23.  * ensure
  24.  *   Result.re=re;
  25.  *   Result.im=im;
  26.  *)
  27.  
  28. VAR
  29.   c: COMPLEX;
  30.  
  31. BEGIN
  32.   NEW(c);
  33.   c.re := re;
  34.   c.im := im;
  35.   RETURN c;
  36. END Create;
  37.  
  38.  
  39. PROCEDURE (m: COMPLEX) Add   * (n: BT.GROUP): BT.GROUP;
  40. BEGIN
  41.   WITH n: COMPLEX DO
  42.     RETURN Create(m.re+n.re,m.im+n.im);
  43.   END;
  44. END Add;
  45.  
  46.  
  47. PROCEDURE (m: COMPLEX) Neg   * (): BT.GROUP;
  48. BEGIN
  49.   RETURN Create(-m.re,-m.im);
  50. END Neg;
  51.  
  52.  
  53. PROCEDURE (m: COMPLEX) Sub   * (n: BT.GROUP): BT.GROUP;
  54. BEGIN
  55.   WITH n: COMPLEX DO
  56.     RETURN Create(m.re-n.re,m.im-n.im);
  57.   END;
  58. END Sub;
  59.  
  60.  
  61. PROCEDURE (m: COMPLEX) Norm  * (): LONGREAL;
  62. BEGIN
  63.   RETURN MATHLIB.SQRT(MATHLIB.SQR(m.re) + MATHLIB.SQR(m.im));
  64. END Norm;
  65.  
  66.  
  67. PROCEDURE (m: COMPLEX) Mul   * (n: BT.RING): BT.RING;
  68. BEGIN
  69.   WITH n: COMPLEX DO
  70.     RETURN Create(m.re*n.re - m.im * n.im,
  71.                   m.im*n.re + m.re * n.im);
  72.   END;
  73. END Mul;
  74.  
  75.  
  76. PROCEDURE (m: COMPLEX) InvAllowed * (): BOOLEAN;
  77. BEGIN
  78.   RETURN (m.re#0) OR (m.im#0);
  79. END InvAllowed;
  80.  
  81.  
  82. PROCEDURE (m: COMPLEX) Inv   * (): BT.FIELD;
  83. VAR
  84.   l: LONGREAL;
  85. BEGIN
  86.   l := MATHLIB.SQR(m.re) + MATHLIB.SQR(m.im);
  87.   RETURN Create( m.re / l, - m.im / l);
  88. END Inv;
  89.  
  90.  
  91. PROCEDURE (m: COMPLEX) Div   * (n: BT.FIELD): BT.FIELD;
  92. VAR
  93.   l: LONGREAL;
  94. BEGIN
  95.  
  96.   WITH n: COMPLEX DO
  97.     l := MATHLIB.SQR(n.re) + MATHLIB.SQR(n.im);
  98.     RETURN Create( (m.re*n.re + m.im*n.im) / l,
  99.                    (m.im*n.re - m.re*n.im) / l);
  100.   END;
  101. END Div;
  102.  
  103.  
  104. PROCEDURE (m: COMPLEX) isEqual * (n: BT.COMPAREABLE): BOOLEAN; (* a = b *)
  105. BEGIN
  106.   WITH n: COMPLEX DO
  107.     RETURN (m.re=n.re) & (m.im=n.im);
  108.   END;
  109. END isEqual;
  110.  
  111.  
  112. PROCEDURE (m: COMPLEX) Compare * (n: BT.COMPAREABLE): LONGINT;
  113. VAR
  114.   nm,nn: LONGREAL;
  115. BEGIN
  116.   nm := m.Norm(); nn := n(COMPLEX).Norm();
  117.   IF    nm = nn THEN
  118.     RETURN 0
  119.   ELSIF nm > nn THEN
  120.     RETURN 1
  121.   ELSE
  122.     RETURN -1
  123.   END;
  124. END Compare;
  125.  
  126.  
  127. PROCEDURE (m: COMPLEX) Argument * (): LONGREAL;
  128. (*
  129.  * Determines Argument of m.
  130.  *
  131.  * m = m.Norm*(cos(m.Argument()) + i*sin(m.Argument())
  132.  *)
  133.  
  134. VAR
  135.   arg: LONGREAL;
  136.  
  137. BEGIN
  138.   IF m.re=0 THEN
  139.     IF m.im>0 THEN
  140.       arg :=  math.pi2;
  141.     ELSE
  142.       arg := -math.pi2;
  143.     END;
  144.   ELSE
  145.     arg := MATHLIB.ATAN(m.im/m.re);
  146.     IF m.re<0 THEN
  147.       arg := arg + math.pi;
  148.     END;
  149.   END;
  150.   RETURN arg;
  151. END Argument;
  152.  
  153.  
  154. END COMPLEX.
  155.  
  156.