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