home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD1.bin / gnu / lib / g++-include / complext.hi < prev    next >
Text File  |  1994-12-22  |  7KB  |  274 lines
  1. // The template and inlines for the -*- C++ -*- complex number classes.
  2. // Copyright (C) 1994 Free Software Foundation
  3.  
  4. // This file is part of the GNU ANSI C++ Library.  This library is free
  5. // software; you can redistribute it and/or modify it under the terms of
  6. // the GNU General Public License as published by the Free Software
  7. // Foundation; either version 2, or (at your option) any later version.
  8.  
  9. // This library is distributed in the hope that it will be useful,
  10. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. // GNU General Public License for more details.
  13.  
  14. // You should have received a copy of the GNU General Public License
  15. // along with GNU CC; see the file COPYING.  If not, write to
  16. // the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  
  18. // As a special exception, if you link this library with files compiled
  19. // with a GNU compiler to produce an executable, this does not cause the
  20. // resulting executable to be covered by the GNU General Public License.
  21. // This exception does not however invalidate any other reasons why the
  22. // executable file might be covered by the GNU General Public License.
  23.  
  24. // Written by Jason Merrill based upon the specification in the 27 May 1994
  25. // C++ working paper, ANSI document X3J16/94-0098.
  26.  
  27. #ifdef __GNUG__
  28. #pragma interface
  29. #endif
  30.  
  31. #include <cmath>
  32.  
  33. template <class FLOAT>
  34. class __complex
  35. {
  36. public:
  37.   __complex (FLOAT r = 0, FLOAT i = 0): re (r), im (i) { }
  38.   __complex& operator += (__complex);
  39.   __complex& operator -= (__complex);
  40.   __complex& operator *= (__complex);
  41.   __complex& operator /= (__complex);
  42. private:
  43.   FLOAT re, im;
  44.  
  45.   friend FLOAT real (__complex);
  46.   friend FLOAT imag (__complex);
  47. };
  48.  
  49. // Declare specializations.
  50. class __complex<double>;
  51. class __complex<long double>;
  52.  
  53. template <class FLOAT>
  54. inline __complex<FLOAT>&
  55. __complex<FLOAT>::operator += (__complex<FLOAT> r)
  56. {
  57.   re += r.re;
  58.   im += r.im;
  59.   return *this;
  60. }
  61.  
  62. template <class FLOAT>
  63. inline __complex<FLOAT>&
  64. __complex<FLOAT>::operator -= (__complex<FLOAT> r)
  65. {
  66.   re -= r.re;
  67.   im -= r.im;
  68.   return *this;
  69. }
  70.  
  71. template <class FLOAT>
  72. inline __complex<FLOAT>&
  73. __complex<FLOAT>::operator *= (__complex<FLOAT> r)
  74. {
  75.   FLOAT f = re * r.re - im * r.im;
  76.   im = re * r.im + im * r.re;
  77.   re = f;
  78.   return *this;
  79. }
  80.  
  81. template <class FLOAT> inline FLOAT
  82. imag (__complex<FLOAT> x)
  83. {
  84.   return x.im;
  85. }
  86.  
  87. template <class FLOAT> inline FLOAT
  88. real (__complex<FLOAT> x)
  89. {
  90.   return x.re;
  91. }
  92.  
  93. #ifdef __GNUG__
  94. extern template float imag (__complex<float>);
  95. extern template float real (__complex<float>);
  96. #endif
  97.  
  98. template <class FLOAT> inline __complex<FLOAT>
  99. operator + (__complex<FLOAT> x, __complex<FLOAT> y)
  100. {
  101.   return __complex<FLOAT> (real (x) + real (y), imag (x) + imag (y));
  102. }
  103.  
  104. template <class FLOAT> inline __complex<FLOAT>
  105. operator + (__complex<FLOAT> x, FLOAT y)
  106. {
  107.   return __complex<FLOAT> (real (x) + y, imag (x));
  108. }
  109.  
  110. template <class FLOAT> inline __complex<FLOAT>
  111. operator + (FLOAT x, __complex<FLOAT> y)
  112. {
  113.   return __complex<FLOAT> (x + real (y), imag (y));
  114. }
  115.  
  116. template <class FLOAT> inline __complex<FLOAT>
  117. operator - (__complex<FLOAT> x, __complex<FLOAT> y)
  118. {
  119.   return __complex<FLOAT> (real (x) - real (y), imag (x) - imag (y));
  120. }
  121.  
  122. template <class FLOAT> inline __complex<FLOAT>
  123. operator - (__complex<FLOAT> x, FLOAT y)
  124. {
  125.   return __complex<FLOAT> (real (x) - y, imag (x));
  126. }
  127.  
  128. template <class FLOAT> inline __complex<FLOAT>
  129. operator - (FLOAT x, __complex<FLOAT> y)
  130. {
  131.   return __complex<FLOAT> (x - real (y), - imag (y));
  132. }
  133.  
  134. template <class FLOAT> inline __complex<FLOAT>
  135. operator * (__complex<FLOAT> x, __complex<FLOAT> y)
  136. {
  137.   return __complex<FLOAT> (real (x) * real (y) - imag (x) * imag (y),
  138.                real (x) * imag (y) + imag (x) * real (y));
  139. }
  140.  
  141. template <class FLOAT> inline __complex<FLOAT>
  142. operator * (__complex<FLOAT> x, FLOAT y)
  143. {
  144.   return __complex<FLOAT> (real (x) * y, imag (x) * y);
  145. }
  146.  
  147. template <class FLOAT> inline __complex<FLOAT>
  148. operator * (FLOAT x, __complex<FLOAT> y)
  149. {
  150.   return __complex<FLOAT> (x * real (y), x * imag (y));
  151. }
  152.  
  153. template <class FLOAT> __complex<FLOAT>
  154. operator / (__complex<FLOAT> x, FLOAT y)
  155. {
  156.   return __complex<FLOAT> (real (x) / y, imag (x) / y);
  157. }
  158.  
  159. template <class FLOAT> inline __complex<FLOAT>
  160. operator + (__complex<FLOAT> x)
  161. {
  162.   return x;
  163. }
  164.  
  165. template <class FLOAT> inline __complex<FLOAT>
  166. operator - (__complex<FLOAT> x)
  167. {
  168.   return __complex<FLOAT> (-real (x), -imag (x));
  169. }
  170.  
  171. template <class FLOAT> inline bool
  172. operator == (__complex<FLOAT> x, __complex<FLOAT> y)
  173. {
  174.   return real (x) == real (y) && imag (x) == imag (y);
  175. }
  176.  
  177. template <class FLOAT> inline bool
  178. operator == (__complex<FLOAT> x, FLOAT y)
  179. {
  180.   return real (x) == y && imag (x) == 0;
  181. }
  182.  
  183. template <class FLOAT> inline bool
  184. operator == (FLOAT x, __complex<FLOAT> y)
  185. {
  186.   return x == real (y) && imag (y) == 0;
  187. }
  188.  
  189. template <class FLOAT> inline bool
  190. operator != (__complex<FLOAT> x, __complex<FLOAT> y)
  191. {
  192.   return real (x) != real (y) || imag (x) != imag (y);
  193. }
  194.  
  195. template <class FLOAT> inline bool
  196. operator != (__complex<FLOAT> x, FLOAT y)
  197. {
  198.   return real (x) != y || imag (x) != 0;
  199. }
  200.  
  201. template <class FLOAT> inline bool
  202. operator != (FLOAT x, __complex<FLOAT> y)
  203. {
  204.   return x != real (y) || imag (y) != 0;
  205. }
  206.  
  207. template <class FLOAT> inline FLOAT
  208. abs (__complex<FLOAT> x)
  209. {
  210.   return hypot (real (x), imag (x));
  211. }
  212.  
  213. template <class FLOAT> inline FLOAT
  214. arg (__complex<FLOAT> x)
  215. {
  216.   return atan2 (imag (x), real (x));
  217. }
  218.  
  219. template <class FLOAT> inline __complex<FLOAT>
  220. polar (FLOAT r, FLOAT t)
  221. {
  222.   return __complex<FLOAT> (r * cos (t), r * sin (t));
  223. }
  224.  
  225. template <class FLOAT> inline __complex<FLOAT>
  226. conj (__complex<FLOAT> x) 
  227. {
  228.   return __complex<FLOAT> (real (x), -imag (x));
  229. }
  230.  
  231. template <class FLOAT> inline FLOAT
  232. norm (__complex<FLOAT> x)
  233. {
  234.   return real (x) * real (x) + imag (x) * imag (x);
  235. }
  236.  
  237. // Declarations of templates in complext.ccI
  238.  
  239. template <class FLOAT> __complex<FLOAT> operator / (__complex<FLOAT>,
  240.                             __complex<FLOAT>);
  241. template <class FLOAT> __complex<FLOAT> operator / (FLOAT, __complex<FLOAT>);
  242. template <class FLOAT> __complex<FLOAT> cos (__complex<FLOAT>);
  243. template <class FLOAT> __complex<FLOAT> cosh (__complex<FLOAT>);
  244. template <class FLOAT> __complex<FLOAT> exp (__complex<FLOAT>);
  245. template <class FLOAT> __complex<FLOAT> log (__complex<FLOAT>);
  246. template <class FLOAT> __complex<FLOAT> pow (__complex<FLOAT>,
  247.                          __complex<FLOAT>);
  248. template <class FLOAT> __complex<FLOAT> pow (__complex<FLOAT>, FLOAT);
  249. template <class FLOAT> __complex<FLOAT> pow (__complex<FLOAT>, int);
  250. template <class FLOAT> __complex<FLOAT> pow (FLOAT, __complex<FLOAT>);
  251. template <class FLOAT> __complex<FLOAT> sin (__complex<FLOAT>);
  252. template <class FLOAT> __complex<FLOAT> sinh (__complex<FLOAT>);
  253. template <class FLOAT> __complex<FLOAT> sqrt (__complex<FLOAT>);
  254.  
  255. class istream;
  256. class ostream;
  257. template <class FLOAT> istream& operator >> (istream&, __complex<FLOAT>&);
  258. template <class FLOAT> ostream& operator << (ostream&, __complex<FLOAT>);
  259.  
  260. // Specializations and such
  261.  
  262. template <class FLOAT>
  263. inline __complex<float>
  264. _float_complex(const __complex<FLOAT>& r)
  265. {
  266.   return __complex<float> (real (r), imag (r));
  267. }
  268.  
  269. #include <dcomplex.hI>
  270. #include <ldcomplex.hI>
  271.  
  272. // Declare the instantiations.
  273. #include <cinst.hI>
  274.