include/c++/stl/stl/_complex.h

   1 /*
   2  * Copyright (c) 1999
   3  * Silicon Graphics Computer Systems, Inc.
   4  *
   5  * Copyright (c) 1999
   6  * Boris Fomitchev
   7  *
   8  * This material is provided "as is", with absolutely no warranty expressed
   9  * or implied. Any use is at your own risk.
  10  *
  11  * Permission to use or copy this software for any purpose is hereby granted
  12  * without fee, provided the above notices are retained on all copies.
  13  * Permission to modify the code and to distribute modified code is granted,
  14  * provided the above notices are retained, and a notice that the code was
  15  * modified is included with the above copyright notice.
  16  *
  17  */
  18 #ifndef _STLP_INTERNAL_COMPLEX
  19 #define _STLP_INTERNAL_COMPLEX
  20
  21 // This header declares the template class complex, as described in
  22 // in the draft C++ standard.  Single-precision complex numbers
  23 // are complex<float>, double-precision are complex<double>, and
  24 // quad precision are complex<long double>.
  25
  26 // Note that the template class complex is declared within namespace
  27 // std, as called for by the draft C++ standard.
  28
  29 #ifndef _STLP_INTERNAL_CMATH
  30 #  include <stl/_cmath.h>
  31 #endif
  32
  33 _STLP_BEGIN_NAMESPACE
  34
  35 #if !defined (_STLP_NO_COMPLEX_SPECIALIZATIONS)    //*TY 02/25/2000 - added for MPW compiler workaround
  36
  37 template <class _Tp> struct complex;
  38
  39 _STLP_TEMPLATE_NULL struct complex<float>;
  40 _STLP_TEMPLATE_NULL struct complex<double>;
  41 #  if !defined (_STLP_NO_LONG_DOUBLE)
  42 _STLP_TEMPLATE_NULL struct complex<long double>;
  43 #  endif
  44 #endif /* _STLP_NO_COMPLEX_SPECIALIZATIONS */
  45
  46 template <class _Tp>
  47 struct complex {
  48   typedef _Tp value_type;
  49   typedef complex<_Tp> _Self;
  50
  51   // Constructors, destructor, assignment operator.
  52   complex() : _M_re(0), _M_im(0) {}
  53   complex(const value_type& __x)
  54     : _M_re(__x), _M_im(0) {}
  55   complex(const value_type& __x, const value_type& __y)
  56     : _M_re(__x), _M_im(__y) {}
  57   complex(const _Self& __z)
  58     : _M_re(__z._M_re), _M_im(__z._M_im) {}
  59
  60   _Self& operator=(const _Self& __z) {
  61     _M_re = __z._M_re;
  62     _M_im = __z._M_im;
  63     return *this;
  64   }
  65
  66 #if defined (_STLP_MEMBER_TEMPLATES) && (defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) || defined(_STLP_NO_COMPLEX_SPECIALIZATIONS))
  67   template <class _Tp2>
  68   explicit complex(const complex<_Tp2>& __z)
  69     : _M_re(__z._M_re), _M_im(__z._M_im) {}
  70
  71   template <class _Tp2>
  72   _Self& operator=(const complex<_Tp2>& __z) {
  73     _M_re = __z._M_re;
  74     _M_im = __z._M_im;
  75     return *this;
  76   }
  77 #endif /* _STLP_MEMBER_TEMPLATES */
  78
  79   // Element access.
  80   value_type real() const { return _M_re; }
  81   value_type imag() const { return _M_im; }
  82
  83   // Arithmetic op= operations involving one real argument.
  84
  85   _Self& operator= (const value_type& __x) {
  86     _M_re = __x;
  87     _M_im = 0;
  88     return *this;
  89   }
  90   _Self& operator+= (const value_type& __x) {
  91     _M_re += __x;
  92     return *this;
  93   }
  94   _Self& operator-= (const value_type& __x) {
  95     _M_re -= __x;
  96     return *this;
  97   }
  98   _Self& operator*= (const value_type& __x) {
  99     _M_re *= __x;
 100     _M_im *= __x;
 101     return *this;
 102   }
 103   _Self& operator/= (const value_type& __x) {
 104     _M_re /= __x;
 105     _M_im /= __x;
 106     return *this;
 107   }
 108
 109   // Arithmetic op= operations involving two complex arguments.
 110
 111   static void  _STLP_CALL _div(const value_type& __z1_r, const value_type& __z1_i,
 112                                const value_type& __z2_r, const value_type& __z2_i,
 113                                value_type& __res_r, value_type& __res_i);
 114
 115   static void _STLP_CALL _div(const value_type& __z1_r,
 116                               const value_type& __z2_r, const value_type& __z2_i,
 117                               value_type& __res_r, value_type& __res_i);
 118
 119 #if defined (_STLP_MEMBER_TEMPLATES) // && defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
 120
 121   template <class _Tp2> _Self& operator+= (const complex<_Tp2>& __z) {
 122     _M_re += __z._M_re;
 123     _M_im += __z._M_im;
 124     return *this;
 125   }
 126
 127   template <class _Tp2> _Self& operator-= (const complex<_Tp2>& __z) {
 128     _M_re -= __z._M_re;
 129     _M_im -= __z._M_im;
 130     return *this;
 131   }
 132
 133   template <class _Tp2> _Self& operator*= (const complex<_Tp2>& __z) {
 134     value_type __r = _M_re * __z._M_re - _M_im * __z._M_im;
 135     value_type __i = _M_re * __z._M_im + _M_im * __z._M_re;
 136     _M_re = __r;
 137     _M_im = __i;
 138     return *this;
 139   }
 140
 141   template <class _Tp2> _Self& operator/= (const complex<_Tp2>& __z) {
 142     value_type __r;
 143     value_type __i;
 144     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
 145     _M_re = __r;
 146     _M_im = __i;
 147     return *this;
 148   }
 149 #endif /* _STLP_MEMBER_TEMPLATES */
 150
 151   _Self& operator+= (const _Self& __z) {
 152     _M_re += __z._M_re;
 153     _M_im += __z._M_im;
 154     return *this;
 155   }
 156
 157   _Self& operator-= (const _Self& __z) {
 158     _M_re -= __z._M_re;
 159     _M_im -= __z._M_im;
 160     return *this;
 161   }
 162
 163   _Self& operator*= (const _Self& __z) {
 164     value_type __r = _M_re * __z._M_re - _M_im * __z._M_im;
 165     value_type __i = _M_re * __z._M_im + _M_im * __z._M_re;
 166     _M_re = __r;
 167     _M_im = __i;
 168     return *this;
 169   }
 170
 171   _Self& operator/= (const _Self& __z) {
 172     value_type __r;
 173     value_type __i;
 174     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
 175     _M_re = __r;
 176     _M_im = __i;
 177     return *this;
 178   }
 179
 180   // Data members.
 181   value_type _M_re;
 182   value_type _M_im;
 183 };
 184
 185 #if !defined (_STLP_NO_COMPLEX_SPECIALIZATIONS)    //*TY 02/25/2000 - added for MPW compiler workaround
 186 // Explicit specializations for float, double, long double.  The only
 187 // reason for these specializations is to enable automatic conversions
 188 // from complex<float> to complex<double>, and complex<double> to
 189 // complex<long double>.
 190
 191 _STLP_TEMPLATE_NULL
 192 struct _STLP_CLASS_DECLSPEC complex<float> {
 193   typedef float value_type;
 194   typedef complex<float> _Self;
 195   // Constructors, destructor, assignment operator.
 196
 197   complex(value_type __x = 0.0f, value_type __y = 0.0f)
 198     : _M_re(__x), _M_im(__y) {}
 199
 200   complex(const complex<float>& __z)    : _M_re(__z._M_re), _M_im(__z._M_im) {}
 201
 202   inline explicit complex(const complex<double>& __z);
 203 #  ifndef _STLP_NO_LONG_DOUBLE
 204   inline explicit complex(const complex<long double>& __z);
 205 #  endif
 206   // Element access.
 207   value_type real() const { return _M_re; }
 208   value_type imag() const { return _M_im; }
 209
 210   // Arithmetic op= operations involving one real argument.
 211
 212   _Self& operator= (value_type __x) {
 213     _M_re = __x;
 214     _M_im = 0.0f;
 215     return *this;
 216   }
 217   _Self& operator+= (value_type __x) {
 218     _M_re += __x;
 219     return *this;
 220   }
 221   _Self& operator-= (value_type __x) {
 222     _M_re -= __x;
 223     return *this;
 224   }
 225   _Self& operator*= (value_type __x) {
 226     _M_re *= __x;
 227     _M_im *= __x;
 228     return *this;
 229   }
 230   _Self& operator/= (value_type __x) {
 231     _M_re /= __x;
 232     _M_im /= __x;
 233     return *this;
 234   }
 235
 236   // Arithmetic op= operations involving two complex arguments.
 237
 238   static void _STLP_CALL _div(const float& __z1_r, const float& __z1_i,
 239                               const float& __z2_r, const float& __z2_i,
 240                               float& __res_r, float& __res_i);
 241
 242   static void _STLP_CALL _div(const float& __z1_r,
 243                               const float& __z2_r, const float& __z2_i,
 244                               float& __res_r, float& __res_i);
 245
 246 #  if defined (_STLP_MEMBER_TEMPLATES)
 247   template <class _Tp2>
 248   complex<float>& operator=(const complex<_Tp2>& __z) {
 249     _M_re = __z._M_re;
 250     _M_im = __z._M_im;
 251     return *this;
 252   }
 253
 254   template <class _Tp2>
 255   complex<float>& operator+= (const complex<_Tp2>& __z) {
 256     _M_re += __z._M_re;
 257     _M_im += __z._M_im;
 258     return *this;
 259   }
 260
 261   template <class _Tp2>
 262   complex<float>& operator-= (const complex<_Tp2>& __z) {
 263     _M_re -= __z._M_re;
 264     _M_im -= __z._M_im;
 265     return *this;
 266   }
 267
 268   template <class _Tp2>
 269   complex<float>& operator*= (const complex<_Tp2>& __z) {
 270     float __r = _M_re * __z._M_re - _M_im * __z._M_im;
 271     float __i = _M_re * __z._M_im + _M_im * __z._M_re;
 272     _M_re = __r;
 273     _M_im = __i;
 274     return *this;
 275   }
 276
 277   template <class _Tp2>
 278   complex<float>& operator/= (const complex<_Tp2>& __z) {
 279     float __r;
 280     float __i;
 281     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
 282     _M_re = __r;
 283     _M_im = __i;
 284     return *this;
 285   }
 286
 287 #  endif /* _STLP_MEMBER_TEMPLATES */
 288
 289   _Self& operator=(const _Self& __z) {
 290     _M_re = __z._M_re;
 291     _M_im = __z._M_im;
 292     return *this;
 293   }
 294
 295   _Self& operator+= (const _Self& __z) {
 296     _M_re += __z._M_re;
 297     _M_im += __z._M_im;
 298     return *this;
 299   }
 300
 301   _Self& operator-= (const _Self& __z) {
 302     _M_re -= __z._M_re;
 303     _M_im -= __z._M_im;
 304     return *this;
 305   }
 306
 307   _Self& operator*= (const _Self& __z) {
 308     value_type __r = _M_re * __z._M_re - _M_im * __z._M_im;
 309     value_type __i = _M_re * __z._M_im + _M_im * __z._M_re;
 310     _M_re = __r;
 311     _M_im = __i;
 312     return *this;
 313   }
 314
 315   _Self& operator/= (const _Self& __z) {
 316     value_type __r;
 317     value_type __i;
 318     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
 319     _M_re = __r;
 320     _M_im = __i;
 321     return *this;
 322   }
 323
 324   // Data members.
 325   value_type _M_re;
 326   value_type _M_im;
 327 };
 328
 329 _STLP_TEMPLATE_NULL
 330 struct _STLP_CLASS_DECLSPEC complex<double> {
 331   typedef double value_type;
 332   typedef complex<double> _Self;
 333
 334   // Constructors, destructor, assignment operator.
 335
 336   complex(value_type __x = 0.0, value_type __y = 0.0)
 337     : _M_re(__x), _M_im(__y) {}
 338
 339   complex(const complex<double>& __z)
 340     : _M_re(__z._M_re), _M_im(__z._M_im) {}
 341   inline complex(const complex<float>& __z);
 342 #  if !defined (_STLP_NO_LONG_DOUBLE)
 343   explicit inline complex(const complex<long double>& __z);
 344 #  endif
 345   // Element access.
 346   value_type real() const { return _M_re; }
 347   value_type imag() const { return _M_im; }
 348
 349   // Arithmetic op= operations involving one real argument.
 350
 351   _Self& operator= (value_type __x) {
 352     _M_re = __x;
 353     _M_im = 0.0;
 354     return *this;
 355   }
 356   _Self& operator+= (value_type __x) {
 357     _M_re += __x;
 358     return *this;
 359   }
 360   _Self& operator-= (value_type __x) {
 361     _M_re -= __x;
 362     return *this;
 363   }
 364   _Self& operator*= (value_type __x) {
 365     _M_re *= __x;
 366     _M_im *= __x;
 367     return *this;
 368   }
 369   _Self& operator/= (value_type __x) {
 370     _M_re /= __x;
 371     _M_im /= __x;
 372     return *this;
 373   }
 374
 375   // Arithmetic op= operations involving two complex arguments.
 376
 377   static void _STLP_CALL _div(const double& __z1_r, const double& __z1_i,
 378                               const double& __z2_r, const double& __z2_i,
 379                               double& __res_r, double& __res_i);
 380   static void _STLP_CALL _div(const double& __z1_r,
 381                               const double& __z2_r, const double& __z2_i,
 382                               double& __res_r, double& __res_i);
 383
 384 #  if defined (_STLP_MEMBER_TEMPLATES) && defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
 385   template <class _Tp2>
 386   complex<double>& operator=(const complex<_Tp2>& __z) {
 387     _M_re = __z._M_re;
 388     _M_im = __z._M_im;
 389     return *this;
 390   }
 391
 392   template <class _Tp2>
 393   complex<double>& operator+= (const complex<_Tp2>& __z) {
 394     _M_re += __z._M_re;
 395     _M_im += __z._M_im;
 396     return *this;
 397   }
 398
 399   template <class _Tp2>
 400   complex<double>& operator-= (const complex<_Tp2>& __z) {
 401     _M_re -= __z._M_re;
 402     _M_im -= __z._M_im;
 403     return *this;
 404   }
 405
 406   template <class _Tp2>
 407   complex<double>& operator*= (const complex<_Tp2>& __z) {
 408     double __r = _M_re * __z._M_re - _M_im * __z._M_im;
 409     double __i = _M_re * __z._M_im + _M_im * __z._M_re;
 410     _M_re = __r;
 411     _M_im = __i;
 412     return *this;
 413   }
 414
 415   template <class _Tp2>
 416   complex<double>& operator/= (const complex<_Tp2>& __z) {
 417     double __r;
 418     double __i;
 419     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
 420     _M_re = __r;
 421     _M_im = __i;
 422     return *this;
 423   }
 424
 425 #  endif /* _STLP_MEMBER_TEMPLATES */
 426
 427   _Self& operator=(const _Self& __z) {
 428     _M_re = __z._M_re;
 429     _M_im = __z._M_im;
 430     return *this;
 431   }
 432
 433   _Self& operator+= (const _Self& __z) {
 434     _M_re += __z._M_re;
 435     _M_im += __z._M_im;
 436     return *this;
 437   }
 438
 439   _Self& operator-= (const _Self& __z) {
 440     _M_re -= __z._M_re;
 441     _M_im -= __z._M_im;
 442     return *this;
 443   }
 444
 445   _Self& operator*= (const _Self& __z) {
 446     value_type __r = _M_re * __z._M_re - _M_im * __z._M_im;
 447     value_type __i = _M_re * __z._M_im + _M_im * __z._M_re;
 448     _M_re = __r;
 449     _M_im = __i;
 450     return *this;
 451   }
 452
 453   _Self& operator/= (const _Self& __z) {
 454     value_type __r;
 455     value_type __i;
 456     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
 457     _M_re = __r;
 458     _M_im = __i;
 459     return *this;
 460   }
 461
 462   // Data members.
 463   value_type _M_re;
 464   value_type _M_im;
 465 };
 466
 467 #  if !defined (_STLP_NO_LONG_DOUBLE)
 468
 469 _STLP_TEMPLATE_NULL
 470 struct _STLP_CLASS_DECLSPEC complex<long double> {
 471   typedef long double value_type;
 472   typedef complex<long double> _Self;
 473
 474   // Constructors, destructor, assignment operator.
 475   complex(value_type __x = 0.0l, value_type __y = 0.0l)
 476     : _M_re(__x), _M_im(__y) {}
 477
 478   complex(const complex<long double>& __z)
 479     : _M_re(__z._M_re), _M_im(__z._M_im) {}
 480   inline complex(const complex<float>& __z);
 481   inline complex(const complex<double>& __z);
 482
 483   // Element access.
 484   value_type real() const { return _M_re; }
 485   value_type imag() const { return _M_im; }
 486
 487   // Arithmetic op= operations involving one real argument.
 488
 489   _Self& operator= (value_type __x) {
 490     _M_re = __x;
 491     _M_im = 0.0l;
 492     return *this;
 493   }
 494   _Self& operator+= (value_type __x) {
 495     _M_re += __x;
 496     return *this;
 497   }
 498   _Self& operator-= (value_type __x) {
 499     _M_re -= __x;
 500     return *this;
 501   }
 502   _Self& operator*= (value_type __x) {
 503     _M_re *= __x;
 504     _M_im *= __x;
 505     return *this;
 506   }
 507   _Self& operator/= (value_type __x) {
 508     _M_re /= __x;
 509     _M_im /= __x;
 510     return *this;
 511   }
 512
 513   // Arithmetic op= operations involving two complex arguments.
 514
 515   static void _STLP_CALL _div(const long double& __z1_r, const long double& __z1_i,
 516                               const long double& __z2_r, const long double& __z2_i,
 517                               long double& __res_r, long double& __res_i);
 518
 519   static void _STLP_CALL _div(const long double& __z1_r,
 520                               const long double& __z2_r, const long double& __z2_i,
 521                               long double& __res_r, long double& __res_i);
 522
 523 #    if defined (_STLP_MEMBER_TEMPLATES) && defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
 524
 525   template <class _Tp2>
 526   complex<long double>& operator=(const complex<_Tp2>& __z) {
 527     _M_re = __z._M_re;
 528     _M_im = __z._M_im;
 529     return *this;
 530   }
 531
 532   template <class _Tp2>
 533   complex<long double>& operator+= (const complex<_Tp2>& __z) {
 534     _M_re += __z._M_re;
 535     _M_im += __z._M_im;
 536     return *this;
 537   }
 538
 539   template <class _Tp2>
 540   complex<long double>& operator-= (const complex<_Tp2>& __z) {
 541     _M_re -= __z._M_re;
 542     _M_im -= __z._M_im;
 543     return *this;
 544   }
 545
 546   template <class _Tp2>
 547   complex<long double>& operator*= (const complex<_Tp2>& __z) {
 548     long double __r = _M_re * __z._M_re - _M_im * __z._M_im;
 549     long double __i = _M_re * __z._M_im + _M_im * __z._M_re;
 550     _M_re = __r;
 551     _M_im = __i;
 552     return *this;
 553   }
 554
 555   template <class _Tp2>
 556   complex<long double>& operator/= (const complex<_Tp2>& __z) {
 557     long double __r;
 558     long double __i;
 559     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
 560     _M_re = __r;
 561     _M_im = __i;
 562     return *this;
 563   }
 564
 565 #    endif /* _STLP_MEMBER_TEMPLATES */
 566
 567   _Self& operator=(const _Self& __z) {
 568     _M_re = __z._M_re;
 569     _M_im = __z._M_im;
 570     return *this;
 571   }
 572
 573   _Self& operator+= (const _Self& __z) {
 574     _M_re += __z._M_re;
 575     _M_im += __z._M_im;
 576     return *this;
 577   }
 578
 579   _Self& operator-= (const _Self& __z) {
 580     _M_re -= __z._M_re;
 581     _M_im -= __z._M_im;
 582     return *this;
 583   }
 584
 585   _Self& operator*= (const _Self& __z) {
 586     value_type __r = _M_re * __z._M_re - _M_im * __z._M_im;
 587     value_type __i = _M_re * __z._M_im + _M_im * __z._M_re;
 588     _M_re = __r;
 589     _M_im = __i;
 590     return *this;
 591   }
 592
 593   _Self& operator/= (const _Self& __z) {
 594     value_type __r;
 595     value_type __i;
 596     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);
 597     _M_re = __r;
 598     _M_im = __i;
 599     return *this;
 600   }
 601
 602   // Data members.
 603   value_type _M_re;
 604   value_type _M_im;
 605 };
 606
 607 #  endif /* _STLP_NO_LONG_DOUBLE */
 608
 609 // Converting constructors from one of these three specialized types
 610 // to another.
 611
 612 inline complex<float>::complex(const complex<double>& __z)
 613   : _M_re((float)__z._M_re), _M_im((float)__z._M_im) {}
 614 inline complex<double>::complex(const complex<float>& __z)
 615   : _M_re(__z._M_re), _M_im(__z._M_im) {}
 616 #  ifndef _STLP_NO_LONG_DOUBLE
 617 inline complex<float>::complex(const complex<long double>& __z)
 618   : _M_re((float)__z._M_re), _M_im((float)__z._M_im) {}
 619 inline complex<double>::complex(const complex<long double>& __z)
 620   : _M_re((double)__z._M_re), _M_im((double)__z._M_im) {}
 621 inline complex<long double>::complex(const complex<float>& __z)
 622   : _M_re(__z._M_re), _M_im(__z._M_im) {}
 623 inline complex<long double>::complex(const complex<double>& __z)
 624   : _M_re(__z._M_re), _M_im(__z._M_im) {}
 625 #  endif
 626
 627 #endif /* SPECIALIZATIONS */
 628
 629 // Unary non-member arithmetic operators.
 630
 631 template <class _Tp>
 632 inline complex<_Tp> _STLP_CALL operator+(const complex<_Tp>& __z)
 633 { return __z; }
 634
 635 template <class _Tp>
 636 inline complex<_Tp> _STLP_CALL  operator-(const complex<_Tp>& __z)
 637 { return complex<_Tp>(-__z._M_re, -__z._M_im); }
 638
 639 // Non-member arithmetic operations involving one real argument.
 640
 641 template <class _Tp>
 642 inline complex<_Tp> _STLP_CALL operator+(const _Tp& __x, const complex<_Tp>& __z)
 643 { return complex<_Tp>(__x + __z._M_re, __z._M_im); }
 644
 645 template <class _Tp>
 646 inline complex<_Tp> _STLP_CALL operator+(const complex<_Tp>& __z, const _Tp& __x)
 647 { return complex<_Tp>(__z._M_re + __x, __z._M_im); }
 648
 649 template <class _Tp>
 650 inline complex<_Tp> _STLP_CALL operator-(const _Tp& __x, const complex<_Tp>& __z)
 651 { return complex<_Tp>(__x - __z._M_re, -__z._M_im); }
 652
 653 template <class _Tp>
 654 inline complex<_Tp> _STLP_CALL operator-(const complex<_Tp>& __z, const _Tp& __x)
 655 { return complex<_Tp>(__z._M_re - __x, __z._M_im); }
 656
 657 template <class _Tp>
 658 inline complex<_Tp> _STLP_CALL operator*(const _Tp& __x, const complex<_Tp>& __z)
 659 { return complex<_Tp>(__x * __z._M_re, __x * __z._M_im); }
 660
 661 template <class _Tp>
 662 inline complex<_Tp> _STLP_CALL operator*(const complex<_Tp>& __z, const _Tp& __x)
 663 { return complex<_Tp>(__z._M_re * __x, __z._M_im * __x); }
 664
 665 template <class _Tp>
 666 inline complex<_Tp> _STLP_CALL operator/(const _Tp& __x, const complex<_Tp>& __z) {
 667   complex<_Tp> __result;
 668   complex<_Tp>::_div(__x,
 669                      __z._M_re, __z._M_im,
 670                      __result._M_re, __result._M_im);
 671   return __result;
 672 }
 673
 674 template <class _Tp>
 675 inline complex<_Tp> _STLP_CALL operator/(const complex<_Tp>& __z, const _Tp& __x)
 676 { return complex<_Tp>(__z._M_re / __x, __z._M_im / __x); }
 677
 678 // Non-member arithmetic operations involving two complex arguments
 679
 680 template <class _Tp>
 681 inline complex<_Tp> _STLP_CALL
 682 operator+(const complex<_Tp>& __z1, const complex<_Tp>& __z2)
 683 { return complex<_Tp>(__z1._M_re + __z2._M_re, __z1._M_im + __z2._M_im); }
 684
 685 template <class _Tp>
 686 inline complex<_Tp> _STLP_CALL
 687 operator-(const complex<_Tp>& __z1, const complex<_Tp>& __z2)
 688 { return complex<_Tp>(__z1._M_re - __z2._M_re, __z1._M_im - __z2._M_im); }
 689
 690 template <class _Tp>
 691 inline complex<_Tp> _STLP_CALL
 692 operator*(const complex<_Tp>& __z1, const complex<_Tp>& __z2) {
 693   return complex<_Tp>(__z1._M_re * __z2._M_re - __z1._M_im * __z2._M_im,
 694                       __z1._M_re * __z2._M_im + __z1._M_im * __z2._M_re);
 695 }
 696
 697 template <class _Tp>
 698 inline complex<_Tp> _STLP_CALL
 699 operator/(const complex<_Tp>& __z1, const complex<_Tp>& __z2) {
 700   complex<_Tp> __result;
 701   complex<_Tp>::_div(__z1._M_re, __z1._M_im,
 702                      __z2._M_re, __z2._M_im,
 703                      __result._M_re, __result._M_im);
 704   return __result;
 705 }
 706
 707 // Comparison operators.
 708
 709 template <class _Tp>
 710 inline bool _STLP_CALL operator==(const complex<_Tp>& __z1, const complex<_Tp>& __z2)
 711 { return __z1._M_re == __z2._M_re && __z1._M_im == __z2._M_im; }
 712
 713 template <class _Tp>
 714 inline bool _STLP_CALL operator==(const complex<_Tp>& __z, const _Tp& __x)
 715 { return __z._M_re == __x && __z._M_im == 0; }
 716
 717 template <class _Tp>
 718 inline bool _STLP_CALL operator==(const _Tp& __x, const complex<_Tp>& __z)
 719 { return __x == __z._M_re && 0 == __z._M_im; }
 720
 721 //04/27/04 dums: removal of this check, if it is restablish
 722 //please explain why the other operators are not macro guarded
 723 //#ifdef _STLP_FUNCTION_TMPL_PARTIAL_ORDER
 724
 725 template <class _Tp>
 726 inline bool _STLP_CALL operator!=(const complex<_Tp>& __z1, const complex<_Tp>& __z2)
 727 { return __z1._M_re != __z2._M_re || __z1._M_im != __z2._M_im; }
 728
 729 //#endif /* _STLP_FUNCTION_TMPL_PARTIAL_ORDER */
 730
 731 template <class _Tp>
 732 inline bool _STLP_CALL operator!=(const complex<_Tp>& __z, const _Tp& __x)
 733 { return __z._M_re != __x || __z._M_im != 0; }
 734
 735 template <class _Tp>
 736 inline bool _STLP_CALL operator!=(const _Tp& __x, const complex<_Tp>& __z)
 737 { return __x != __z._M_re || 0 != __z._M_im; }
 738
 739 // Other basic arithmetic operations
 740 template <class _Tp>
 741 inline _Tp _STLP_CALL real(const complex<_Tp>& __z)
 742 { return __z._M_re; }
 743
 744 template <class _Tp>
 745 inline _Tp _STLP_CALL imag(const complex<_Tp>& __z)
 746 { return __z._M_im; }
 747
 748 template <class _Tp>
 749 _Tp _STLP_CALL abs(const complex<_Tp>& __z);
 750
 751 template <class _Tp>
 752 _Tp _STLP_CALL arg(const complex<_Tp>& __z);
 753
 754 template <class _Tp>
 755 inline _Tp _STLP_CALL norm(const complex<_Tp>& __z)
 756 { return __z._M_re * __z._M_re + __z._M_im * __z._M_im; }
 757
 758 template <class _Tp>
 759 inline complex<_Tp> _STLP_CALL conj(const complex<_Tp>& __z)
 760 { return complex<_Tp>(__z._M_re, -__z._M_im); }
 761
 762 template <class _Tp>
 763 complex<_Tp> _STLP_CALL polar(const _Tp& __rho)
 764 { return complex<_Tp>(__rho, 0); }
 765
 766 template <class _Tp>
 767 complex<_Tp> _STLP_CALL polar(const _Tp& __rho, const _Tp& __phi);
 768
 769 _STLP_TEMPLATE_NULL
 770 _STLP_DECLSPEC float _STLP_CALL abs(const complex<float>&);
 771 _STLP_TEMPLATE_NULL
 772 _STLP_DECLSPEC double _STLP_CALL abs(const complex<double>&);
 773 _STLP_TEMPLATE_NULL
 774 _STLP_DECLSPEC float _STLP_CALL arg(const complex<float>&);
 775 _STLP_TEMPLATE_NULL
 776 _STLP_DECLSPEC double _STLP_CALL arg(const complex<double>&);
 777 _STLP_TEMPLATE_NULL
 778 _STLP_DECLSPEC complex<float> _STLP_CALL polar(const float& __rho, const float& __phi);
 779 _STLP_TEMPLATE_NULL
 780 _STLP_DECLSPEC complex<double> _STLP_CALL polar(const double& __rho, const double& __phi);
 781
 782 template <class _Tp>
 783 _Tp _STLP_CALL abs(const complex<_Tp>& __z)
 784 { return _Tp(abs(complex<double>(double(__z.real()), double(__z.imag())))); }
 785
 786 template <class _Tp>
 787 _Tp _STLP_CALL arg(const complex<_Tp>& __z)
 788 { return _Tp(arg(complex<double>(double(__z.real()), double(__z.imag())))); }
 789
 790 template <class _Tp>
 791 complex<_Tp> _STLP_CALL polar(const _Tp& __rho, const _Tp& __phi) {
 792   complex<double> __tmp = polar(double(__rho), double(__phi));
 793   return complex<_Tp>(_Tp(__tmp.real()), _Tp(__tmp.imag()));
 794 }
 795
 796 #if !defined (_STLP_NO_LONG_DOUBLE)
 797 _STLP_TEMPLATE_NULL
 798 _STLP_DECLSPEC long double _STLP_CALL arg(const complex<long double>&);
 799 _STLP_TEMPLATE_NULL
 800 _STLP_DECLSPEC long double _STLP_CALL abs(const complex<long double>&);
 801 _STLP_TEMPLATE_NULL
 802 _STLP_DECLSPEC complex<long double> _STLP_CALL polar(const long double&, const long double&);
 803 #endif
 804
 805
 806 #if !defined (_STLP_USE_NO_IOSTREAMS)
 807
 808 _STLP_END_NAMESPACE
 809
 810 #  include <iosfwd>
 811
 812 _STLP_BEGIN_NAMESPACE
 813
 814 // Complex output, in the form (re,im).  We use a two-step process
 815 // involving stringstream so that we get the padding right.
 816 template <class _Tp, class _CharT, class _Traits>
 817 basic_ostream<_CharT, _Traits>&  _STLP_CALL
 818 operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __z);
 819
 820 template <class _Tp, class _CharT, class _Traits>
 821 basic_istream<_CharT, _Traits>& _STLP_CALL
 822 operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __z);
 823
 824 // Specializations for narrow characters; lets us avoid widen.
 825
 826 _STLP_OPERATOR_TEMPLATE
 827 _STLP_DECLSPEC basic_istream<char, char_traits<char> >& _STLP_CALL
 828 operator>>(basic_istream<char, char_traits<char> >& __is, complex<float>& __z);
 829
 830 _STLP_OPERATOR_TEMPLATE
 831 _STLP_DECLSPEC basic_istream<char, char_traits<char> >& _STLP_CALL
 832 operator>>(basic_istream<char, char_traits<char> >& __is, complex<double>& __z);
 833
 834 _STLP_OPERATOR_TEMPLATE
 835 _STLP_DECLSPEC basic_ostream<char, char_traits<char> >& _STLP_CALL
 836 operator<<(basic_ostream<char, char_traits<char> >& __is, const complex<float>& __z);
 837
 838 _STLP_OPERATOR_TEMPLATE
 839 _STLP_DECLSPEC basic_ostream<char, char_traits<char> >& _STLP_CALL
 840 operator<<(basic_ostream<char, char_traits<char> >& __is, const complex<double>& __z);
 841
 842 #  if !defined (_STLP_NO_LONG_DOUBLE)
 843 _STLP_OPERATOR_TEMPLATE
 844 _STLP_DECLSPEC basic_istream<char, char_traits<char> >& _STLP_CALL
 845 operator>>(basic_istream<char, char_traits<char> >& __is, complex<long double>& __z);
 846
 847 _STLP_OPERATOR_TEMPLATE
 848 _STLP_DECLSPEC basic_ostream<char, char_traits<char> >& _STLP_CALL
 849 operator<<(basic_ostream<char, char_traits<char> >& __is, const complex<long double>& __z);
 850
 851 #  endif
 852
 853 #  if defined (_STLP_USE_TEMPLATE_EXPORT) && ! defined (_STLP_NO_WCHAR_T)
 854
 855 _STLP_EXPORT_TEMPLATE basic_istream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
 856 operator>>(basic_istream<wchar_t, char_traits<wchar_t> >&, complex<double>&);
 857 _STLP_EXPORT_TEMPLATE basic_ostream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
 858 operator<<(basic_ostream<wchar_t, char_traits<wchar_t> >&, const complex<double>&);
 859 _STLP_EXPORT_TEMPLATE basic_istream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
 860 operator>>(basic_istream<wchar_t, char_traits<wchar_t> >&, complex<float>&);
 861 _STLP_EXPORT_TEMPLATE basic_ostream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
 862 operator<<(basic_ostream<wchar_t, char_traits<wchar_t> >&, const complex<float>&);
 863
 864 #    if !defined (_STLP_NO_LONG_DOUBLE)
 865 _STLP_EXPORT_TEMPLATE basic_istream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
 866 operator>>(basic_istream<wchar_t, char_traits<wchar_t> >&, complex<long double>&);
 867 _STLP_EXPORT_TEMPLATE basic_ostream<wchar_t, char_traits<wchar_t> >& _STLP_CALL
 868 operator<<(basic_ostream<wchar_t, char_traits<wchar_t> >&, const complex<long double>&);
 869 #    endif
 870 #  endif
 871 #endif
 872
 873
 874 // Transcendental functions.  These are defined only for float,
 875 //  double, and long double.  (Sqrt isn't transcendental, of course,
 876 //  but it's included in this section anyway.)
 877
 878 _STLP_DECLSPEC complex<float> _STLP_CALL sqrt(const complex<float>&);
 879
 880 _STLP_DECLSPEC complex<float> _STLP_CALL exp(const complex<float>&);
 881 _STLP_DECLSPEC complex<float> _STLP_CALL  log(const complex<float>&);
 882 _STLP_DECLSPEC complex<float> _STLP_CALL log10(const complex<float>&);
 883
 884 _STLP_DECLSPEC complex<float> _STLP_CALL pow(const complex<float>&, int);
 885 _STLP_DECLSPEC complex<float> _STLP_CALL pow(const complex<float>&, const float&);
 886 _STLP_DECLSPEC complex<float> _STLP_CALL pow(const float&, const complex<float>&);
 887 _STLP_DECLSPEC complex<float> _STLP_CALL pow(const complex<float>&, const complex<float>&);
 888
 889 _STLP_DECLSPEC complex<float> _STLP_CALL sin(const complex<float>&);
 890 _STLP_DECLSPEC complex<float> _STLP_CALL cos(const complex<float>&);
 891 _STLP_DECLSPEC complex<float> _STLP_CALL tan(const complex<float>&);
 892
 893 _STLP_DECLSPEC complex<float> _STLP_CALL sinh(const complex<float>&);
 894 _STLP_DECLSPEC complex<float> _STLP_CALL cosh(const complex<float>&);
 895 _STLP_DECLSPEC complex<float> _STLP_CALL tanh(const complex<float>&);
 896
 897 _STLP_DECLSPEC complex<double> _STLP_CALL sqrt(const complex<double>&);
 898
 899 _STLP_DECLSPEC complex<double> _STLP_CALL exp(const complex<double>&);
 900 _STLP_DECLSPEC complex<double> _STLP_CALL log(const complex<double>&);
 901 _STLP_DECLSPEC complex<double> _STLP_CALL log10(const complex<double>&);
 902
 903 _STLP_DECLSPEC complex<double> _STLP_CALL pow(const complex<double>&, int);
 904 _STLP_DECLSPEC complex<double> _STLP_CALL pow(const complex<double>&, const double&);
 905 _STLP_DECLSPEC complex<double> _STLP_CALL pow(const double&, const complex<double>&);
 906 _STLP_DECLSPEC complex<double> _STLP_CALL pow(const complex<double>&, const complex<double>&);
 907
 908 _STLP_DECLSPEC complex<double> _STLP_CALL sin(const complex<double>&);
 909 _STLP_DECLSPEC complex<double> _STLP_CALL cos(const complex<double>&);
 910 _STLP_DECLSPEC complex<double> _STLP_CALL tan(const complex<double>&);
 911
 912 _STLP_DECLSPEC complex<double> _STLP_CALL sinh(const complex<double>&);
 913 _STLP_DECLSPEC complex<double> _STLP_CALL cosh(const complex<double>&);
 914 _STLP_DECLSPEC complex<double> _STLP_CALL tanh(const complex<double>&);
 915
 916 #if !defined (_STLP_NO_LONG_DOUBLE)
 917 _STLP_DECLSPEC complex<long double> _STLP_CALL sqrt(const complex<long double>&);
 918 _STLP_DECLSPEC complex<long double> _STLP_CALL exp(const complex<long double>&);
 919 _STLP_DECLSPEC complex<long double> _STLP_CALL log(const complex<long double>&);
 920 _STLP_DECLSPEC complex<long double> _STLP_CALL log10(const complex<long double>&);
 921
 922 _STLP_DECLSPEC complex<long double> _STLP_CALL pow(const complex<long double>&, int);
 923 _STLP_DECLSPEC complex<long double> _STLP_CALL pow(const complex<long double>&, const long double&);
 924 _STLP_DECLSPEC complex<long double> _STLP_CALL pow(const long double&, const complex<long double>&);
 925 _STLP_DECLSPEC complex<long double> _STLP_CALL pow(const complex<long double>&,
 926                                                    const complex<long double>&);
 927
 928 _STLP_DECLSPEC complex<long double> _STLP_CALL sin(const complex<long double>&);
 929 _STLP_DECLSPEC complex<long double> _STLP_CALL cos(const complex<long double>&);
 930 _STLP_DECLSPEC complex<long double> _STLP_CALL tan(const complex<long double>&);
 931
 932 _STLP_DECLSPEC complex<long double> _STLP_CALL sinh(const complex<long double>&);
 933 _STLP_DECLSPEC complex<long double> _STLP_CALL cosh(const complex<long double>&);
 934 _STLP_DECLSPEC complex<long double> _STLP_CALL tanh(const complex<long double>&);
 935 #endif
 936
 937 _STLP_END_NAMESPACE
 938
 939 #ifndef _STLP_LINK_TIME_INSTANTIATION
 940 #  include <stl/_complex.c>
 941 #endif
 942
 943 #endif
 944
 945 // Local Variables:
 946 // mode:C++
 947 // End: