1. #ifndef __MYCOMPLEX__
    2. #define __MYCOMPLEX__
    4. class complex; 
    5. complex&
    6.   __doapl (complex* ths, const complex& r);
    7. complex&
    8.   __doami (complex* ths, const complex& r);
    9. complex&
    10.   __doaml (complex* ths, const complex& r);
    13. class complex
    14. {
    15. public:
    16.   complex (double r = 0, double i = 0): re (r), im (i) { }
    17.   complex& operator += (const complex&);
    18.   complex& operator -= (const complex&);
    19.   complex& operator *= (const complex&);
    20.   complex& operator /= (const complex&);
    21.   double real () const { return re; }
    22.   double imag () const { return im; }
    23. private:
    24.   double re, im;
    26.   friend complex& __doapl (complex *, const complex&);
    27.   friend complex& __doami (complex *, const complex&);
    28.   friend complex& __doaml (complex *, const complex&);
    29. };
    32. inline complex&
    33. __doapl (complex* ths, const complex& r)
    34. {
    35.   ths->re += r.re;
    36.   ths->im += r.im;
    37.   return *ths;
    38. }
    40. inline complex&
    41. complex::operator += (const complex& r)
    42. {
    43.   return __doapl (this, r);
    44. }
    46. inline complex&
    47. __doami (complex* ths, const complex& r)
    48. {
    49.   ths->re -= r.re;
    50.   ths->im -= r.im;
    51.   return *ths;
    52. }
    54. inline complex&
    55. complex::operator -= (const complex& r)
    56. {
    57.   return __doami (this, r);
    58. }
    60. inline complex&
    61. __doaml (complex* ths, const complex& r)
    62. {
    63.   double f = ths->re * r.re - ths->im * r.im;
    64.   ths->im = ths->re * r.im + ths->im * r.re;
    65.   ths->re = f;
    66.   return *ths;
    67. }
    69. inline complex&
    70. complex::operator *= (const complex& r)
    71. {
    72.   return __doaml (this, r);
    73. }
    75. inline double
    76. imag (const complex& x)
    77. {
    78.   return x.imag ();
    79. }
    81. inline double
    82. real (const complex& x)
    83. {
    84.   return x.real ();
    85. }
    87. inline complex
    88. operator + (const complex& x, const complex& y)
    89. {
    90.   return complex (real (x) + real (y), imag (x) + imag (y));
    91. }
    93. inline complex
    94. operator + (const complex& x, double y)
    95. {
    96.   return complex (real (x) + y, imag (x));
    97. }
    99. inline complex
    100. operator + (double x, const complex& y)
    101. {
    102.   return complex (x + real (y), imag (y));
    103. }
    105. inline complex
    106. operator - (const complex& x, const complex& y)
    107. {
    108.   return complex (real (x) - real (y), imag (x) - imag (y));
    109. }
    111. inline complex
    112. operator - (const complex& x, double y)
    113. {
    114.   return complex (real (x) - y, imag (x));
    115. }
    117. inline complex
    118. operator - (double x, const complex& y)
    119. {
    120.   return complex (x - real (y), - imag (y));
    121. }
    123. inline complex
    124. operator * (const complex& x, const complex& y)
    125. {
    126.   return complex (real (x) * real (y) - imag (x) * imag (y),
    127.                real (x) * imag (y) + imag (x) * real (y));
    128. }
    130. inline complex
    131. operator * (const complex& x, double y)
    132. {
    133.   return complex (real (x) * y, imag (x) * y);
    134. }
    136. inline complex
    137. operator * (double x, const complex& y)
    138. {
    139.   return complex (x * real (y), x * imag (y));
    140. }
    142. complex
    143. operator / (const complex& x, double y)
    144. {
    145.   return complex (real (x) / y, imag (x) / y);
    146. }
    148. inline complex
    149. operator + (const complex& x)
    150. {
    151.   return x;
    152. }
    154. inline complex
    155. operator - (const complex& x)
    156. {
    157.   return complex (-real (x), -imag (x));
    158. }
    160. inline bool
    161. operator == (const complex& x, const complex& y)
    162. {
    163.   return real (x) == real (y) && imag (x) == imag (y);
    164. }
    166. inline bool
    167. operator == (const complex& x, double y)
    168. {
    169.   return real (x) == y && imag (x) == 0;
    170. }
    172. inline bool
    173. operator == (double x, const complex& y)
    174. {
    175.   return x == real (y) && imag (y) == 0;
    176. }
    178. inline bool
    179. operator != (const complex& x, const complex& y)
    180. {
    181.   return real (x) != real (y) || imag (x) != imag (y);
    182. }
    184. inline bool
    185. operator != (const complex& x, double y)
    186. {
    187.   return real (x) != y || imag (x) != 0;
    188. }
    190. inline bool
    191. operator != (double x, const complex& y)
    192. {
    193.   return x != real (y) || imag (y) != 0;
    194. }
    196. #include <cmath>
    198. inline complex
    199. polar (double r, double t)
    200. {
    201.   return complex (r * cos (t), r * sin (t));
    202. }
    204. inline complex
    205. conj (const complex& x) 
    206. {
    207.   return complex (real (x), -imag (x));
    208. }
    210. inline double
    211. norm (const complex& x)
    212. {
    213.   return real (x) * real (x) + imag (x) * imag (x);
    214. }
    216. #endif   //__MYCOMPLEX__