home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / numana01.zip / SRC / CX.MOD < prev    next >
Text File  |  1996-07-31  |  5KB  |  214 lines
  1. IMPLEMENTATION MODULE Cx;
  2.  
  3.         (********************************************************)
  4.         (*                                                      *)
  5.         (*              Complex number arithmetic               *)
  6.         (*                                                      *)
  7.         (*  Programmer:         P. Moylan                       *)
  8.         (*  Last edited:        31 July 1996                    *)
  9.         (*  Status:             OK                              *)
  10.         (*                                                      *)
  11.         (********************************************************)
  12.  
  13. FROM MiscM2 IMPORT
  14.     (* const*)  PI,
  15.     (* proc *)  WriteString, WriteLongReal,
  16.                 Sin, Cos, Sqrt, Exp, Log, ATan2;
  17.  
  18. FROM LongComplexMath IMPORT
  19.     (* proc *)  abs, arg, conj, sqrt, exp, ln, sin, cos, scalarMult;
  20.  
  21. (************************************************************************)
  22.  
  23. PROCEDURE Cmplx (x, y: LONGREAL): Complex;
  24.  
  25.     (* Returns x + iy. *)
  26.  
  27.     BEGIN
  28.         RETURN CMPLX (x, y);
  29.     END Cmplx;
  30.  
  31. (************************************************************************)
  32.  
  33. PROCEDURE Re (Z: Complex): LONGREAL;
  34.  
  35.     (* Returns the real part of Z. *)
  36.  
  37.     BEGIN
  38.         RETURN RE(Z);
  39.     END Re;
  40.  
  41. (************************************************************************)
  42.  
  43. PROCEDURE Im (Z: Complex): LONGREAL;
  44.  
  45.     (* Returns the imaginary part of Z. *)
  46.  
  47.     BEGIN
  48.         RETURN IM(Z);
  49.     END Im;
  50.  
  51. (************************************************************************)
  52.  
  53. PROCEDURE Magnitude (Z: Complex): LONGREAL;
  54.  
  55.     (* Returns the magnitude of Z. *)
  56.  
  57.     BEGIN
  58.         RETURN abs(Z);
  59.     END Magnitude;
  60.  
  61. (************************************************************************)
  62.  
  63. PROCEDURE Phase (Z: Complex): LONGREAL;
  64.  
  65.     (* Returns the phase (angle) of Z.  The result is in the range      *)
  66.     (* -PI to +PI, but never exactly equal to -PI.                      *)
  67.  
  68.     BEGIN
  69.         RETURN arg(Z);
  70.     END Phase;
  71.  
  72. (************************************************************************)
  73.  
  74. PROCEDURE Conjg (Z: Complex): Complex;
  75.  
  76.     (* Returns the complex conjugate of Z. *)
  77.  
  78.     BEGIN
  79.         RETURN conj(Z);
  80.     END Conjg;
  81.  
  82. (************************************************************************)
  83.  
  84. PROCEDURE Add (A, B: Complex): Complex;
  85.  
  86.     (* Computes A + B. *)
  87.  
  88.     BEGIN
  89.         RETURN A+B;
  90.     END Add;
  91.  
  92. (************************************************************************)
  93.  
  94. PROCEDURE Sub (A, B: Complex): Complex;
  95.  
  96.     (* Computes A - B. *)
  97.  
  98.     BEGIN
  99.         RETURN A-B;
  100.     END Sub;
  101.  
  102. (************************************************************************)
  103.  
  104. PROCEDURE Mul (A, B: Complex): Complex;
  105.  
  106.     (* Computes A*B. *)
  107.  
  108.     BEGIN
  109.         RETURN A*B;
  110.     END Mul;
  111.  
  112. (************************************************************************)
  113.  
  114. PROCEDURE RMul (A: LONGREAL;  B: Complex): Complex;
  115.  
  116.     (* Multiplication by a real number. *)
  117.  
  118.     BEGIN
  119.         RETURN scalarMult(A,B);
  120.     END RMul;
  121.  
  122. (************************************************************************)
  123.  
  124. PROCEDURE Div (A, B: Complex): Complex;
  125.  
  126.     (* Computes A/B. *)
  127.  
  128.     BEGIN
  129.         RETURN A/B;
  130.     END Div;
  131.  
  132. (************************************************************************)
  133.  
  134. PROCEDURE Sqt (Z: Complex): Complex;
  135.  
  136.     (* Returns the square root of Z. *)
  137.  
  138.     BEGIN
  139.         RETURN sqrt(Z);
  140.     END Sqt;
  141.  
  142. (************************************************************************)
  143.  
  144. PROCEDURE Cexp (Z: Complex): Complex;
  145.  
  146.     (* Complex exponential. *)
  147.  
  148.     BEGIN
  149.         RETURN exp(Z);
  150.     END Cexp;
  151.  
  152. (************************************************************************)
  153.  
  154. PROCEDURE Cln (Z: Complex): Complex;
  155.  
  156.     (* Complex logarithm (untested. *)
  157.  
  158.     BEGIN
  159.         RETURN ln(Z);
  160.     END Cln;
  161.  
  162. (************************************************************************)
  163.  
  164. PROCEDURE Csin (Z: Complex): Complex;
  165.  
  166.     (* Complex sine (untested). *)
  167.  
  168.     BEGIN
  169.         RETURN sin(Z);
  170.     END Csin;
  171.  
  172. (************************************************************************)
  173.  
  174. PROCEDURE Ccos (Z: Complex): Complex;
  175.  
  176.     (* Complex cosine (untested). *)
  177.  
  178.     BEGIN
  179.         RETURN cos(Z);
  180.     END Ccos;
  181.  
  182. (************************************************************************)
  183.  
  184. PROCEDURE Write (Z: Complex;  places: CARDINAL);
  185.  
  186.     (* Writes Z in Cartesian form, with "places" characters allowed     *)
  187.     (* for each of the real and imaginary parts.                        *)
  188.  
  189.     VAR j: CARDINAL;  impart: LONGREAL;
  190.  
  191.     BEGIN
  192.         WriteLongReal (RE(Z), places);
  193.         IF IM(Z) = 0.0 THEN
  194.             FOR j := 0 TO places+3 DO
  195.                 WriteString (" ");
  196.             END (*FOR*);
  197.         ELSE
  198.             impart := IM(Z);
  199.             IF impart < 0.0 THEN
  200.                 WriteString (" - ");
  201.                 impart := -impart;
  202.             ELSE
  203.                 WriteString (" + ");
  204.             END (*IF*);
  205.             WriteString ("j");
  206.             WriteLongReal (impart, places);
  207.         END (*IF*);
  208.     END Write;
  209.  
  210. (************************************************************************)
  211.  
  212. END Cx.
  213.  
  214.