complext.h
上传用户:sichengcw
上传日期:2009-02-17
资源大小:202k
文件大小:11k
源码类别:

STL

开发平台:

Visual C++

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