complex (operator==, !=): Mark constexpr.
[gcc.git] / libstdc++-v3 / include / std / complex
1 // The template and inlines for the -*- C++ -*- complex number classes.
2
3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4 // 2006, 2007, 2008, 2009, 2010
5 // Free Software Foundation, Inc.
6 //
7 // This file is part of the GNU ISO C++ Library. This library is free
8 // software; you can redistribute it and/or modify it under the
9 // terms of the GNU General Public License as published by the
10 // Free Software Foundation; either version 3, or (at your option)
11 // any later version.
12
13 // This library is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
17
18 // Under Section 7 of GPL version 3, you are granted additional
19 // permissions described in the GCC Runtime Library Exception, version
20 // 3.1, as published by the Free Software Foundation.
21
22 // You should have received a copy of the GNU General Public License and
23 // a copy of the GCC Runtime Library Exception along with this program;
24 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
25 // <http://www.gnu.org/licenses/>.
26
27 /** @file include/complex
28 * This is a Standard C++ Library header.
29 */
30
31 //
32 // ISO C++ 14882: 26.2 Complex Numbers
33 // Note: this is not a conforming implementation.
34 // Initially implemented by Ulrich Drepper <drepper@cygnus.com>
35 // Improved by Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr>
36 //
37
38 #ifndef _GLIBCXX_COMPLEX
39 #define _GLIBCXX_COMPLEX 1
40
41 #pragma GCC system_header
42
43 #include <bits/c++config.h>
44 #include <bits/cpp_type_traits.h>
45 #include <ext/type_traits.h>
46 #include <cmath>
47 #include <sstream>
48
49 _GLIBCXX_BEGIN_NAMESPACE(std)
50
51 /**
52 * @defgroup complex_numbers Complex Numbers
53 * @ingroup numerics
54 *
55 * Classes and functions for complex numbers.
56 * @{
57 */
58
59 // Forward declarations.
60 template<typename _Tp> class complex;
61 template<> class complex<float>;
62 template<> class complex<double>;
63 template<> class complex<long double>;
64
65 /// Return magnitude of @a z.
66 template<typename _Tp> _Tp abs(const complex<_Tp>&);
67 /// Return phase angle of @a z.
68 template<typename _Tp> _Tp arg(const complex<_Tp>&);
69 /// Return @a z magnitude squared.
70 template<typename _Tp> _Tp norm(const complex<_Tp>&);
71
72 /// Return complex conjugate of @a z.
73 template<typename _Tp> complex<_Tp> conj(const complex<_Tp>&);
74 /// Return complex with magnitude @a rho and angle @a theta.
75 template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);
76
77 // Transcendentals:
78 /// Return complex cosine of @a z.
79 template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);
80 /// Return complex hyperbolic cosine of @a z.
81 template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);
82 /// Return complex base e exponential of @a z.
83 template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);
84 /// Return complex natural logarithm of @a z.
85 template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);
86 /// Return complex base 10 logarithm of @a z.
87 template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);
88 #ifndef __GXX_EXPERIMENTAL_CXX0X__
89 // DR 844.
90 /// Return @a x to the @a y'th power.
91 template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);
92 #endif
93 /// Return @a x to the @a y'th power.
94 template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
95 /// Return @a x to the @a y'th power.
96 template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
97 const complex<_Tp>&);
98 /// Return @a x to the @a y'th power.
99 template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
100 /// Return complex sine of @a z.
101 template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);
102 /// Return complex hyperbolic sine of @a z.
103 template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);
104 /// Return complex square root of @a z.
105 template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);
106 /// Return complex tangent of @a z.
107 template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);
108 /// Return complex hyperbolic tangent of @a z.
109 template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
110
111
112 // 26.2.2 Primary template class complex
113 /**
114 * Template to represent complex numbers.
115 *
116 * Specializations for float, double, and long double are part of the
117 * library. Results with any other type are not guaranteed.
118 *
119 * @param Tp Type of real and imaginary values.
120 */
121 template<typename _Tp>
122 struct complex
123 {
124 /// Value typedef.
125 typedef _Tp value_type;
126
127 /// Default constructor. First parameter is x, second parameter is y.
128 /// Unspecified parameters default to 0.
129 _GLIBCXX_CONSTEXPR complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
130 : _M_real(__r), _M_imag(__i) { }
131
132 // Lets the compiler synthesize the copy constructor
133 // complex (const complex<_Tp>&);
134 /// Copy constructor.
135 template<typename _Up>
136 _GLIBCXX_CONSTEXPR complex(const complex<_Up>& __z)
137 : _M_real(__z.real()), _M_imag(__z.imag()) { }
138
139 #ifdef __GXX_EXPERIMENTAL_CXX0X__
140 // _GLIBCXX_RESOLVE_LIB_DEFECTS
141 // DR 387. std::complex over-encapsulated.
142 constexpr _Tp
143 real() const { return _M_real; }
144
145 constexpr _Tp
146 imag() const { return _M_imag; }
147 #else
148 /// Return real part of complex number.
149 _Tp&
150 real() { return _M_real; }
151
152 /// Return real part of complex number.
153 const _Tp&
154 real() const { return _M_real; }
155
156 /// Return imaginary part of complex number.
157 _Tp&
158 imag() { return _M_imag; }
159
160 /// Return imaginary part of complex number.
161 const _Tp&
162 imag() const { return _M_imag; }
163 #endif
164
165 // _GLIBCXX_RESOLVE_LIB_DEFECTS
166 // DR 387. std::complex over-encapsulated.
167 void
168 real(_Tp __val) { _M_real = __val; }
169
170 void
171 imag(_Tp __val) { _M_imag = __val; }
172
173 /// Assign this complex number to scalar @a t.
174 complex<_Tp>& operator=(const _Tp&);
175
176 /// Add @a t to this complex number.
177 // 26.2.5/1
178 complex<_Tp>&
179 operator+=(const _Tp& __t)
180 {
181 _M_real += __t;
182 return *this;
183 }
184
185 /// Subtract @a t from this complex number.
186 // 26.2.5/3
187 complex<_Tp>&
188 operator-=(const _Tp& __t)
189 {
190 _M_real -= __t;
191 return *this;
192 }
193
194 /// Multiply this complex number by @a t.
195 complex<_Tp>& operator*=(const _Tp&);
196 /// Divide this complex number by @a t.
197 complex<_Tp>& operator/=(const _Tp&);
198
199 // Lets the compiler synthesize the
200 // copy and assignment operator
201 // complex<_Tp>& operator= (const complex<_Tp>&);
202 /// Assign this complex number to complex @a z.
203 template<typename _Up>
204 complex<_Tp>& operator=(const complex<_Up>&);
205 /// Add @a z to this complex number.
206 template<typename _Up>
207 complex<_Tp>& operator+=(const complex<_Up>&);
208 /// Subtract @a z from this complex number.
209 template<typename _Up>
210 complex<_Tp>& operator-=(const complex<_Up>&);
211 /// Multiply this complex number by @a z.
212 template<typename _Up>
213 complex<_Tp>& operator*=(const complex<_Up>&);
214 /// Divide this complex number by @a z.
215 template<typename _Up>
216 complex<_Tp>& operator/=(const complex<_Up>&);
217
218 _GLIBCXX_USE_CONSTEXPR complex __rep() const
219 { return *this; }
220
221 private:
222 _Tp _M_real;
223 _Tp _M_imag;
224 };
225
226 template<typename _Tp>
227 complex<_Tp>&
228 complex<_Tp>::operator=(const _Tp& __t)
229 {
230 _M_real = __t;
231 _M_imag = _Tp();
232 return *this;
233 }
234
235 // 26.2.5/5
236 template<typename _Tp>
237 complex<_Tp>&
238 complex<_Tp>::operator*=(const _Tp& __t)
239 {
240 _M_real *= __t;
241 _M_imag *= __t;
242 return *this;
243 }
244
245 // 26.2.5/7
246 template<typename _Tp>
247 complex<_Tp>&
248 complex<_Tp>::operator/=(const _Tp& __t)
249 {
250 _M_real /= __t;
251 _M_imag /= __t;
252 return *this;
253 }
254
255 template<typename _Tp>
256 template<typename _Up>
257 complex<_Tp>&
258 complex<_Tp>::operator=(const complex<_Up>& __z)
259 {
260 _M_real = __z.real();
261 _M_imag = __z.imag();
262 return *this;
263 }
264
265 // 26.2.5/9
266 template<typename _Tp>
267 template<typename _Up>
268 complex<_Tp>&
269 complex<_Tp>::operator+=(const complex<_Up>& __z)
270 {
271 _M_real += __z.real();
272 _M_imag += __z.imag();
273 return *this;
274 }
275
276 // 26.2.5/11
277 template<typename _Tp>
278 template<typename _Up>
279 complex<_Tp>&
280 complex<_Tp>::operator-=(const complex<_Up>& __z)
281 {
282 _M_real -= __z.real();
283 _M_imag -= __z.imag();
284 return *this;
285 }
286
287 // 26.2.5/13
288 // XXX: This is a grammar school implementation.
289 template<typename _Tp>
290 template<typename _Up>
291 complex<_Tp>&
292 complex<_Tp>::operator*=(const complex<_Up>& __z)
293 {
294 const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
295 _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
296 _M_real = __r;
297 return *this;
298 }
299
300 // 26.2.5/15
301 // XXX: This is a grammar school implementation.
302 template<typename _Tp>
303 template<typename _Up>
304 complex<_Tp>&
305 complex<_Tp>::operator/=(const complex<_Up>& __z)
306 {
307 const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag();
308 const _Tp __n = std::norm(__z);
309 _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
310 _M_real = __r / __n;
311 return *this;
312 }
313
314 // Operators:
315 //@{
316 /// Return new complex value @a x plus @a y.
317 template<typename _Tp>
318 inline complex<_Tp>
319 operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
320 {
321 complex<_Tp> __r = __x;
322 __r += __y;
323 return __r;
324 }
325
326 template<typename _Tp>
327 inline complex<_Tp>
328 operator+(const complex<_Tp>& __x, const _Tp& __y)
329 {
330 complex<_Tp> __r = __x;
331 __r += __y;
332 return __r;
333 }
334
335 template<typename _Tp>
336 inline complex<_Tp>
337 operator+(const _Tp& __x, const complex<_Tp>& __y)
338 {
339 complex<_Tp> __r = __y;
340 __r += __x;
341 return __r;
342 }
343 //@}
344
345 //@{
346 /// Return new complex value @a x minus @a y.
347 template<typename _Tp>
348 inline complex<_Tp>
349 operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
350 {
351 complex<_Tp> __r = __x;
352 __r -= __y;
353 return __r;
354 }
355
356 template<typename _Tp>
357 inline complex<_Tp>
358 operator-(const complex<_Tp>& __x, const _Tp& __y)
359 {
360 complex<_Tp> __r = __x;
361 __r -= __y;
362 return __r;
363 }
364
365 template<typename _Tp>
366 inline complex<_Tp>
367 operator-(const _Tp& __x, const complex<_Tp>& __y)
368 {
369 complex<_Tp> __r(__x, -__y.imag());
370 __r -= __y.real();
371 return __r;
372 }
373 //@}
374
375 //@{
376 /// Return new complex value @a x times @a y.
377 template<typename _Tp>
378 inline complex<_Tp>
379 operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
380 {
381 complex<_Tp> __r = __x;
382 __r *= __y;
383 return __r;
384 }
385
386 template<typename _Tp>
387 inline complex<_Tp>
388 operator*(const complex<_Tp>& __x, const _Tp& __y)
389 {
390 complex<_Tp> __r = __x;
391 __r *= __y;
392 return __r;
393 }
394
395 template<typename _Tp>
396 inline complex<_Tp>
397 operator*(const _Tp& __x, const complex<_Tp>& __y)
398 {
399 complex<_Tp> __r = __y;
400 __r *= __x;
401 return __r;
402 }
403 //@}
404
405 //@{
406 /// Return new complex value @a x divided by @a y.
407 template<typename _Tp>
408 inline complex<_Tp>
409 operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
410 {
411 complex<_Tp> __r = __x;
412 __r /= __y;
413 return __r;
414 }
415
416 template<typename _Tp>
417 inline complex<_Tp>
418 operator/(const complex<_Tp>& __x, const _Tp& __y)
419 {
420 complex<_Tp> __r = __x;
421 __r /= __y;
422 return __r;
423 }
424
425 template<typename _Tp>
426 inline complex<_Tp>
427 operator/(const _Tp& __x, const complex<_Tp>& __y)
428 {
429 complex<_Tp> __r = __x;
430 __r /= __y;
431 return __r;
432 }
433 //@}
434
435 /// Return @a x.
436 template<typename _Tp>
437 inline complex<_Tp>
438 operator+(const complex<_Tp>& __x)
439 { return __x; }
440
441 /// Return complex negation of @a x.
442 template<typename _Tp>
443 inline complex<_Tp>
444 operator-(const complex<_Tp>& __x)
445 { return complex<_Tp>(-__x.real(), -__x.imag()); }
446
447 //@{
448 /// Return true if @a x is equal to @a y.
449 template<typename _Tp>
450 inline _GLIBCXX_CONSTEXPR bool
451 operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
452 { return __x.real() == __y.real() && __x.imag() == __y.imag(); }
453
454 template<typename _Tp>
455 inline _GLIBCXX_CONSTEXPR bool
456 operator==(const complex<_Tp>& __x, const _Tp& __y)
457 { return __x.real() == __y && __x.imag() == _Tp(); }
458
459 template<typename _Tp>
460 inline _GLIBCXX_CONSTEXPR bool
461 operator==(const _Tp& __x, const complex<_Tp>& __y)
462 { return __x == __y.real() && _Tp() == __y.imag(); }
463 //@}
464
465 //@{
466 /// Return false if @a x is equal to @a y.
467 template<typename _Tp>
468 inline _GLIBCXX_CONSTEXPR bool
469 operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
470 { return __x.real() != __y.real() || __x.imag() != __y.imag(); }
471
472 template<typename _Tp>
473 inline _GLIBCXX_CONSTEXPR bool
474 operator!=(const complex<_Tp>& __x, const _Tp& __y)
475 { return __x.real() != __y || __x.imag() != _Tp(); }
476
477 template<typename _Tp>
478 inline _GLIBCXX_CONSTEXPR bool
479 operator!=(const _Tp& __x, const complex<_Tp>& __y)
480 { return __x != __y.real() || _Tp() != __y.imag(); }
481 //@}
482
483 /// Extraction operator for complex values.
484 template<typename _Tp, typename _CharT, class _Traits>
485 basic_istream<_CharT, _Traits>&
486 operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
487 {
488 _Tp __re_x, __im_x;
489 _CharT __ch;
490 __is >> __ch;
491 if (__ch == '(')
492 {
493 __is >> __re_x >> __ch;
494 if (__ch == ',')
495 {
496 __is >> __im_x >> __ch;
497 if (__ch == ')')
498 __x = complex<_Tp>(__re_x, __im_x);
499 else
500 __is.setstate(ios_base::failbit);
501 }
502 else if (__ch == ')')
503 __x = __re_x;
504 else
505 __is.setstate(ios_base::failbit);
506 }
507 else
508 {
509 __is.putback(__ch);
510 __is >> __re_x;
511 __x = __re_x;
512 }
513 return __is;
514 }
515
516 /// Insertion operator for complex values.
517 template<typename _Tp, typename _CharT, class _Traits>
518 basic_ostream<_CharT, _Traits>&
519 operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
520 {
521 basic_ostringstream<_CharT, _Traits> __s;
522 __s.flags(__os.flags());
523 __s.imbue(__os.getloc());
524 __s.precision(__os.precision());
525 __s << '(' << __x.real() << ',' << __x.imag() << ')';
526 return __os << __s.str();
527 }
528
529 // Values
530 #ifdef __GXX_EXPERIMENTAL_CXX0X__
531 template<typename _Tp>
532 inline _Tp
533 real(const complex<_Tp>& __z)
534 { return __z.real(); }
535
536 template<typename _Tp>
537 inline _Tp
538 imag(const complex<_Tp>& __z)
539 { return __z.imag(); }
540 #else
541 template<typename _Tp>
542 inline _Tp&
543 real(complex<_Tp>& __z)
544 { return __z.real(); }
545
546 template<typename _Tp>
547 inline const _Tp&
548 real(const complex<_Tp>& __z)
549 { return __z.real(); }
550
551 template<typename _Tp>
552 inline _Tp&
553 imag(complex<_Tp>& __z)
554 { return __z.imag(); }
555
556 template<typename _Tp>
557 inline const _Tp&
558 imag(const complex<_Tp>& __z)
559 { return __z.imag(); }
560 #endif
561
562 // 26.2.7/3 abs(__z): Returns the magnitude of __z.
563 template<typename _Tp>
564 inline _Tp
565 __complex_abs(const complex<_Tp>& __z)
566 {
567 _Tp __x = __z.real();
568 _Tp __y = __z.imag();
569 const _Tp __s = std::max(abs(__x), abs(__y));
570 if (__s == _Tp()) // well ...
571 return __s;
572 __x /= __s;
573 __y /= __s;
574 return __s * sqrt(__x * __x + __y * __y);
575 }
576
577 #if _GLIBCXX_USE_C99_COMPLEX
578 inline float
579 __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }
580
581 inline double
582 __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }
583
584 inline long double
585 __complex_abs(const __complex__ long double& __z)
586 { return __builtin_cabsl(__z); }
587
588 template<typename _Tp>
589 inline _Tp
590 abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
591 #else
592 template<typename _Tp>
593 inline _Tp
594 abs(const complex<_Tp>& __z) { return __complex_abs(__z); }
595 #endif
596
597
598 // 26.2.7/4: arg(__z): Returns the phase angle of __z.
599 template<typename _Tp>
600 inline _Tp
601 __complex_arg(const complex<_Tp>& __z)
602 { return atan2(__z.imag(), __z.real()); }
603
604 #if _GLIBCXX_USE_C99_COMPLEX
605 inline float
606 __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }
607
608 inline double
609 __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }
610
611 inline long double
612 __complex_arg(const __complex__ long double& __z)
613 { return __builtin_cargl(__z); }
614
615 template<typename _Tp>
616 inline _Tp
617 arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
618 #else
619 template<typename _Tp>
620 inline _Tp
621 arg(const complex<_Tp>& __z) { return __complex_arg(__z); }
622 #endif
623
624 // 26.2.7/5: norm(__z) returns the squared magnitude of __z.
625 // As defined, norm() is -not- a norm is the common mathematical
626 // sens used in numerics. The helper class _Norm_helper<> tries to
627 // distinguish between builtin floating point and the rest, so as
628 // to deliver an answer as close as possible to the real value.
629 template<bool>
630 struct _Norm_helper
631 {
632 template<typename _Tp>
633 static inline _Tp _S_do_it(const complex<_Tp>& __z)
634 {
635 const _Tp __x = __z.real();
636 const _Tp __y = __z.imag();
637 return __x * __x + __y * __y;
638 }
639 };
640
641 template<>
642 struct _Norm_helper<true>
643 {
644 template<typename _Tp>
645 static inline _Tp _S_do_it(const complex<_Tp>& __z)
646 {
647 _Tp __res = std::abs(__z);
648 return __res * __res;
649 }
650 };
651
652 template<typename _Tp>
653 inline _Tp
654 norm(const complex<_Tp>& __z)
655 {
656 return _Norm_helper<__is_floating<_Tp>::__value
657 && !_GLIBCXX_FAST_MATH>::_S_do_it(__z);
658 }
659
660 template<typename _Tp>
661 inline complex<_Tp>
662 polar(const _Tp& __rho, const _Tp& __theta)
663 { return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); }
664
665 template<typename _Tp>
666 inline complex<_Tp>
667 conj(const complex<_Tp>& __z)
668 { return complex<_Tp>(__z.real(), -__z.imag()); }
669
670 // Transcendentals
671
672 // 26.2.8/1 cos(__z): Returns the cosine of __z.
673 template<typename _Tp>
674 inline complex<_Tp>
675 __complex_cos(const complex<_Tp>& __z)
676 {
677 const _Tp __x = __z.real();
678 const _Tp __y = __z.imag();
679 return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
680 }
681
682 #if _GLIBCXX_USE_C99_COMPLEX
683 inline __complex__ float
684 __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }
685
686 inline __complex__ double
687 __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }
688
689 inline __complex__ long double
690 __complex_cos(const __complex__ long double& __z)
691 { return __builtin_ccosl(__z); }
692
693 template<typename _Tp>
694 inline complex<_Tp>
695 cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }
696 #else
697 template<typename _Tp>
698 inline complex<_Tp>
699 cos(const complex<_Tp>& __z) { return __complex_cos(__z); }
700 #endif
701
702 // 26.2.8/2 cosh(__z): Returns the hyperbolic cosine of __z.
703 template<typename _Tp>
704 inline complex<_Tp>
705 __complex_cosh(const complex<_Tp>& __z)
706 {
707 const _Tp __x = __z.real();
708 const _Tp __y = __z.imag();
709 return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
710 }
711
712 #if _GLIBCXX_USE_C99_COMPLEX
713 inline __complex__ float
714 __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }
715
716 inline __complex__ double
717 __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }
718
719 inline __complex__ long double
720 __complex_cosh(const __complex__ long double& __z)
721 { return __builtin_ccoshl(__z); }
722
723 template<typename _Tp>
724 inline complex<_Tp>
725 cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }
726 #else
727 template<typename _Tp>
728 inline complex<_Tp>
729 cosh(const complex<_Tp>& __z) { return __complex_cosh(__z); }
730 #endif
731
732 // 26.2.8/3 exp(__z): Returns the complex base e exponential of x
733 template<typename _Tp>
734 inline complex<_Tp>
735 __complex_exp(const complex<_Tp>& __z)
736 { return std::polar(exp(__z.real()), __z.imag()); }
737
738 #if _GLIBCXX_USE_C99_COMPLEX
739 inline __complex__ float
740 __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }
741
742 inline __complex__ double
743 __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }
744
745 inline __complex__ long double
746 __complex_exp(const __complex__ long double& __z)
747 { return __builtin_cexpl(__z); }
748
749 template<typename _Tp>
750 inline complex<_Tp>
751 exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
752 #else
753 template<typename _Tp>
754 inline complex<_Tp>
755 exp(const complex<_Tp>& __z) { return __complex_exp(__z); }
756 #endif
757
758 // 26.2.8/5 log(__z): Returns the natural complex logarithm of __z.
759 // The branch cut is along the negative axis.
760 template<typename _Tp>
761 inline complex<_Tp>
762 __complex_log(const complex<_Tp>& __z)
763 { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
764
765 #if _GLIBCXX_USE_C99_COMPLEX
766 inline __complex__ float
767 __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }
768
769 inline __complex__ double
770 __complex_log(__complex__ double __z) { return __builtin_clog(__z); }
771
772 inline __complex__ long double
773 __complex_log(const __complex__ long double& __z)
774 { return __builtin_clogl(__z); }
775
776 template<typename _Tp>
777 inline complex<_Tp>
778 log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }
779 #else
780 template<typename _Tp>
781 inline complex<_Tp>
782 log(const complex<_Tp>& __z) { return __complex_log(__z); }
783 #endif
784
785 template<typename _Tp>
786 inline complex<_Tp>
787 log10(const complex<_Tp>& __z)
788 { return std::log(__z) / log(_Tp(10.0)); }
789
790 // 26.2.8/10 sin(__z): Returns the sine of __z.
791 template<typename _Tp>
792 inline complex<_Tp>
793 __complex_sin(const complex<_Tp>& __z)
794 {
795 const _Tp __x = __z.real();
796 const _Tp __y = __z.imag();
797 return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
798 }
799
800 #if _GLIBCXX_USE_C99_COMPLEX
801 inline __complex__ float
802 __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }
803
804 inline __complex__ double
805 __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }
806
807 inline __complex__ long double
808 __complex_sin(const __complex__ long double& __z)
809 { return __builtin_csinl(__z); }
810
811 template<typename _Tp>
812 inline complex<_Tp>
813 sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }
814 #else
815 template<typename _Tp>
816 inline complex<_Tp>
817 sin(const complex<_Tp>& __z) { return __complex_sin(__z); }
818 #endif
819
820 // 26.2.8/11 sinh(__z): Returns the hyperbolic sine of __z.
821 template<typename _Tp>
822 inline complex<_Tp>
823 __complex_sinh(const complex<_Tp>& __z)
824 {
825 const _Tp __x = __z.real();
826 const _Tp __y = __z.imag();
827 return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
828 }
829
830 #if _GLIBCXX_USE_C99_COMPLEX
831 inline __complex__ float
832 __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
833
834 inline __complex__ double
835 __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }
836
837 inline __complex__ long double
838 __complex_sinh(const __complex__ long double& __z)
839 { return __builtin_csinhl(__z); }
840
841 template<typename _Tp>
842 inline complex<_Tp>
843 sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
844 #else
845 template<typename _Tp>
846 inline complex<_Tp>
847 sinh(const complex<_Tp>& __z) { return __complex_sinh(__z); }
848 #endif
849
850 // 26.2.8/13 sqrt(__z): Returns the complex square root of __z.
851 // The branch cut is on the negative axis.
852 template<typename _Tp>
853 complex<_Tp>
854 __complex_sqrt(const complex<_Tp>& __z)
855 {
856 _Tp __x = __z.real();
857 _Tp __y = __z.imag();
858
859 if (__x == _Tp())
860 {
861 _Tp __t = sqrt(abs(__y) / 2);
862 return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
863 }
864 else
865 {
866 _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
867 _Tp __u = __t / 2;
868 return __x > _Tp()
869 ? complex<_Tp>(__u, __y / __t)
870 : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
871 }
872 }
873
874 #if _GLIBCXX_USE_C99_COMPLEX
875 inline __complex__ float
876 __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }
877
878 inline __complex__ double
879 __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }
880
881 inline __complex__ long double
882 __complex_sqrt(const __complex__ long double& __z)
883 { return __builtin_csqrtl(__z); }
884
885 template<typename _Tp>
886 inline complex<_Tp>
887 sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
888 #else
889 template<typename _Tp>
890 inline complex<_Tp>
891 sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z); }
892 #endif
893
894 // 26.2.8/14 tan(__z): Return the complex tangent of __z.
895
896 template<typename _Tp>
897 inline complex<_Tp>
898 __complex_tan(const complex<_Tp>& __z)
899 { return std::sin(__z) / std::cos(__z); }
900
901 #if _GLIBCXX_USE_C99_COMPLEX
902 inline __complex__ float
903 __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }
904
905 inline __complex__ double
906 __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }
907
908 inline __complex__ long double
909 __complex_tan(const __complex__ long double& __z)
910 { return __builtin_ctanl(__z); }
911
912 template<typename _Tp>
913 inline complex<_Tp>
914 tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
915 #else
916 template<typename _Tp>
917 inline complex<_Tp>
918 tan(const complex<_Tp>& __z) { return __complex_tan(__z); }
919 #endif
920
921
922 // 26.2.8/15 tanh(__z): Returns the hyperbolic tangent of __z.
923
924 template<typename _Tp>
925 inline complex<_Tp>
926 __complex_tanh(const complex<_Tp>& __z)
927 { return std::sinh(__z) / std::cosh(__z); }
928
929 #if _GLIBCXX_USE_C99_COMPLEX
930 inline __complex__ float
931 __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }
932
933 inline __complex__ double
934 __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }
935
936 inline __complex__ long double
937 __complex_tanh(const __complex__ long double& __z)
938 { return __builtin_ctanhl(__z); }
939
940 template<typename _Tp>
941 inline complex<_Tp>
942 tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
943 #else
944 template<typename _Tp>
945 inline complex<_Tp>
946 tanh(const complex<_Tp>& __z) { return __complex_tanh(__z); }
947 #endif
948
949
950 // 26.2.8/9 pow(__x, __y): Returns the complex power base of __x
951 // raised to the __y-th power. The branch
952 // cut is on the negative axis.
953 #ifndef __GXX_EXPERIMENTAL_CXX0X__
954 template<typename _Tp>
955 complex<_Tp>
956 __complex_pow_unsigned(complex<_Tp> __x, unsigned __n)
957 {
958 complex<_Tp> __y = __n % 2 ? __x : complex<_Tp>(1);
959
960 while (__n >>= 1)
961 {
962 __x *= __x;
963 if (__n % 2)
964 __y *= __x;
965 }
966
967 return __y;
968 }
969
970 // _GLIBCXX_RESOLVE_LIB_DEFECTS
971 // DR 844. complex pow return type is ambiguous.
972 template<typename _Tp>
973 inline complex<_Tp>
974 pow(const complex<_Tp>& __z, int __n)
975 {
976 return __n < 0
977 ? complex<_Tp>(1) / std::__complex_pow_unsigned(__z, -__n)
978 : std::__complex_pow_unsigned(__z, __n);
979 }
980 #endif
981
982 template<typename _Tp>
983 complex<_Tp>
984 pow(const complex<_Tp>& __x, const _Tp& __y)
985 {
986 #ifndef _GLIBCXX_USE_C99_COMPLEX
987 if (__x == _Tp())
988 return _Tp();
989 #endif
990 if (__x.imag() == _Tp() && __x.real() > _Tp())
991 return pow(__x.real(), __y);
992
993 complex<_Tp> __t = std::log(__x);
994 return std::polar(exp(__y * __t.real()), __y * __t.imag());
995 }
996
997 template<typename _Tp>
998 inline complex<_Tp>
999 __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1000 { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
1001
1002 #if _GLIBCXX_USE_C99_COMPLEX
1003 inline __complex__ float
1004 __complex_pow(__complex__ float __x, __complex__ float __y)
1005 { return __builtin_cpowf(__x, __y); }
1006
1007 inline __complex__ double
1008 __complex_pow(__complex__ double __x, __complex__ double __y)
1009 { return __builtin_cpow(__x, __y); }
1010
1011 inline __complex__ long double
1012 __complex_pow(const __complex__ long double& __x,
1013 const __complex__ long double& __y)
1014 { return __builtin_cpowl(__x, __y); }
1015
1016 template<typename _Tp>
1017 inline complex<_Tp>
1018 pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1019 { return __complex_pow(__x.__rep(), __y.__rep()); }
1020 #else
1021 template<typename _Tp>
1022 inline complex<_Tp>
1023 pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1024 { return __complex_pow(__x, __y); }
1025 #endif
1026
1027 template<typename _Tp>
1028 inline complex<_Tp>
1029 pow(const _Tp& __x, const complex<_Tp>& __y)
1030 {
1031 return __x > _Tp() ? std::polar(pow(__x, __y.real()),
1032 __y.imag() * log(__x))
1033 : std::pow(complex<_Tp>(__x), __y);
1034 }
1035
1036 // 26.2.3 complex specializations
1037 // complex<float> specialization
1038 template<>
1039 struct complex<float>
1040 {
1041 typedef float value_type;
1042 typedef __complex__ float _ComplexT;
1043
1044 _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1045
1046 _GLIBCXX_CONSTEXPR complex(float __r = 0.0f, float __i = 0.0f)
1047 : _M_value(__r + __i * 1.0fi) { }
1048
1049 explicit _GLIBCXX_CONSTEXPR complex(const complex<double>&);
1050 explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
1051
1052 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1053 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1054 // DR 387. std::complex over-encapsulated.
1055 constexpr float
1056 real() const { return __real__ _M_value; }
1057
1058 constexpr float
1059 imag() const { return __imag__ _M_value; }
1060 #else
1061 float&
1062 real() { return __real__ _M_value; }
1063
1064 const float&
1065 real() const { return __real__ _M_value; }
1066
1067 float&
1068 imag() { return __imag__ _M_value; }
1069
1070 const float&
1071 imag() const { return __imag__ _M_value; }
1072 #endif
1073
1074 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1075 // DR 387. std::complex over-encapsulated.
1076 void
1077 real(float __val) { __real__ _M_value = __val; }
1078
1079 void
1080 imag(float __val) { __imag__ _M_value = __val; }
1081
1082 complex&
1083 operator=(float __f)
1084 {
1085 _M_value = __f;
1086 return *this;
1087 }
1088
1089 complex&
1090 operator+=(float __f)
1091 {
1092 _M_value += __f;
1093 return *this;
1094 }
1095
1096 complex&
1097 operator-=(float __f)
1098 {
1099 _M_value -= __f;
1100 return *this;
1101 }
1102
1103 complex&
1104 operator*=(float __f)
1105 {
1106 _M_value *= __f;
1107 return *this;
1108 }
1109
1110 complex&
1111 operator/=(float __f)
1112 {
1113 _M_value /= __f;
1114 return *this;
1115 }
1116
1117 // Let the compiler synthesize the copy and assignment
1118 // operator. It always does a pretty good job.
1119 // complex& operator=(const complex&);
1120
1121 template<typename _Tp>
1122 complex&
1123 operator=(const complex<_Tp>& __z)
1124 {
1125 __real__ _M_value = __z.real();
1126 __imag__ _M_value = __z.imag();
1127 return *this;
1128 }
1129
1130 template<typename _Tp>
1131 complex&
1132 operator+=(const complex<_Tp>& __z)
1133 {
1134 __real__ _M_value += __z.real();
1135 __imag__ _M_value += __z.imag();
1136 return *this;
1137 }
1138
1139 template<class _Tp>
1140 complex&
1141 operator-=(const complex<_Tp>& __z)
1142 {
1143 __real__ _M_value -= __z.real();
1144 __imag__ _M_value -= __z.imag();
1145 return *this;
1146 }
1147
1148 template<class _Tp>
1149 complex&
1150 operator*=(const complex<_Tp>& __z)
1151 {
1152 _ComplexT __t;
1153 __real__ __t = __z.real();
1154 __imag__ __t = __z.imag();
1155 _M_value *= __t;
1156 return *this;
1157 }
1158
1159 template<class _Tp>
1160 complex&
1161 operator/=(const complex<_Tp>& __z)
1162 {
1163 _ComplexT __t;
1164 __real__ __t = __z.real();
1165 __imag__ __t = __z.imag();
1166 _M_value /= __t;
1167 return *this;
1168 }
1169
1170 _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1171
1172 private:
1173 _ComplexT _M_value;
1174 };
1175
1176 // 26.2.3 complex specializations
1177 // complex<double> specialization
1178 template<>
1179 struct complex<double>
1180 {
1181 typedef double value_type;
1182 typedef __complex__ double _ComplexT;
1183
1184 _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1185
1186 _GLIBCXX_CONSTEXPR complex(double __r = 0.0, double __i = 0.0)
1187 : _M_value(__r + __i * 1.0i) { }
1188
1189 _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
1190 : _M_value(__z.__rep()) { }
1191
1192 explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
1193
1194 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1195 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1196 // DR 387. std::complex over-encapsulated.
1197 constexpr double
1198 real() const { return __real__ _M_value; }
1199
1200 constexpr double
1201 imag() const { return __imag__ _M_value; }
1202 #else
1203 double&
1204 real() { return __real__ _M_value; }
1205
1206 const double&
1207 real() const { return __real__ _M_value; }
1208
1209 double&
1210 imag() { return __imag__ _M_value; }
1211
1212 const double&
1213 imag() const { return __imag__ _M_value; }
1214 #endif
1215
1216 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1217 // DR 387. std::complex over-encapsulated.
1218 void
1219 real(double __val) { __real__ _M_value = __val; }
1220
1221 void
1222 imag(double __val) { __imag__ _M_value = __val; }
1223
1224 complex&
1225 operator=(double __d)
1226 {
1227 _M_value = __d;
1228 return *this;
1229 }
1230
1231 complex&
1232 operator+=(double __d)
1233 {
1234 _M_value += __d;
1235 return *this;
1236 }
1237
1238 complex&
1239 operator-=(double __d)
1240 {
1241 _M_value -= __d;
1242 return *this;
1243 }
1244
1245 complex&
1246 operator*=(double __d)
1247 {
1248 _M_value *= __d;
1249 return *this;
1250 }
1251
1252 complex&
1253 operator/=(double __d)
1254 {
1255 _M_value /= __d;
1256 return *this;
1257 }
1258
1259 // The compiler will synthesize this, efficiently.
1260 // complex& operator=(const complex&);
1261
1262 template<typename _Tp>
1263 complex&
1264 operator=(const complex<_Tp>& __z)
1265 {
1266 __real__ _M_value = __z.real();
1267 __imag__ _M_value = __z.imag();
1268 return *this;
1269 }
1270
1271 template<typename _Tp>
1272 complex&
1273 operator+=(const complex<_Tp>& __z)
1274 {
1275 __real__ _M_value += __z.real();
1276 __imag__ _M_value += __z.imag();
1277 return *this;
1278 }
1279
1280 template<typename _Tp>
1281 complex&
1282 operator-=(const complex<_Tp>& __z)
1283 {
1284 __real__ _M_value -= __z.real();
1285 __imag__ _M_value -= __z.imag();
1286 return *this;
1287 }
1288
1289 template<typename _Tp>
1290 complex&
1291 operator*=(const complex<_Tp>& __z)
1292 {
1293 _ComplexT __t;
1294 __real__ __t = __z.real();
1295 __imag__ __t = __z.imag();
1296 _M_value *= __t;
1297 return *this;
1298 }
1299
1300 template<typename _Tp>
1301 complex&
1302 operator/=(const complex<_Tp>& __z)
1303 {
1304 _ComplexT __t;
1305 __real__ __t = __z.real();
1306 __imag__ __t = __z.imag();
1307 _M_value /= __t;
1308 return *this;
1309 }
1310
1311 _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1312
1313 private:
1314 _ComplexT _M_value;
1315 };
1316
1317 // 26.2.3 complex specializations
1318 // complex<long double> specialization
1319 template<>
1320 struct complex<long double>
1321 {
1322 typedef long double value_type;
1323 typedef __complex__ long double _ComplexT;
1324
1325 _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1326
1327 _GLIBCXX_CONSTEXPR complex(long double __r = 0.0L,
1328 long double __i = 0.0L)
1329 : _M_value(__r + __i * 1.0Li) { }
1330
1331 _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
1332 : _M_value(__z.__rep()) { }
1333
1334 _GLIBCXX_CONSTEXPR complex(const complex<double>& __z)
1335 : _M_value(__z.__rep()) { }
1336
1337 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1338 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1339 // DR 387. std::complex over-encapsulated.
1340 constexpr long double
1341 real() const { return __real__ _M_value; }
1342
1343 constexpr long double
1344 imag() const { return __imag__ _M_value; }
1345 #else
1346 long double&
1347 real() { return __real__ _M_value; }
1348
1349 const long double&
1350 real() const { return __real__ _M_value; }
1351
1352 long double&
1353 imag() { return __imag__ _M_value; }
1354
1355 const long double&
1356 imag() const { return __imag__ _M_value; }
1357 #endif
1358
1359 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1360 // DR 387. std::complex over-encapsulated.
1361 void
1362 real(long double __val) { __real__ _M_value = __val; }
1363
1364 void
1365 imag(long double __val) { __imag__ _M_value = __val; }
1366
1367 complex&
1368 operator=(long double __r)
1369 {
1370 _M_value = __r;
1371 return *this;
1372 }
1373
1374 complex&
1375 operator+=(long double __r)
1376 {
1377 _M_value += __r;
1378 return *this;
1379 }
1380
1381 complex&
1382 operator-=(long double __r)
1383 {
1384 _M_value -= __r;
1385 return *this;
1386 }
1387
1388 complex&
1389 operator*=(long double __r)
1390 {
1391 _M_value *= __r;
1392 return *this;
1393 }
1394
1395 complex&
1396 operator/=(long double __r)
1397 {
1398 _M_value /= __r;
1399 return *this;
1400 }
1401
1402 // The compiler knows how to do this efficiently
1403 // complex& operator=(const complex&);
1404
1405 template<typename _Tp>
1406 complex&
1407 operator=(const complex<_Tp>& __z)
1408 {
1409 __real__ _M_value = __z.real();
1410 __imag__ _M_value = __z.imag();
1411 return *this;
1412 }
1413
1414 template<typename _Tp>
1415 complex&
1416 operator+=(const complex<_Tp>& __z)
1417 {
1418 __real__ _M_value += __z.real();
1419 __imag__ _M_value += __z.imag();
1420 return *this;
1421 }
1422
1423 template<typename _Tp>
1424 complex&
1425 operator-=(const complex<_Tp>& __z)
1426 {
1427 __real__ _M_value -= __z.real();
1428 __imag__ _M_value -= __z.imag();
1429 return *this;
1430 }
1431
1432 template<typename _Tp>
1433 complex&
1434 operator*=(const complex<_Tp>& __z)
1435 {
1436 _ComplexT __t;
1437 __real__ __t = __z.real();
1438 __imag__ __t = __z.imag();
1439 _M_value *= __t;
1440 return *this;
1441 }
1442
1443 template<typename _Tp>
1444 complex&
1445 operator/=(const complex<_Tp>& __z)
1446 {
1447 _ComplexT __t;
1448 __real__ __t = __z.real();
1449 __imag__ __t = __z.imag();
1450 _M_value /= __t;
1451 return *this;
1452 }
1453
1454 _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1455
1456 private:
1457 _ComplexT _M_value;
1458 };
1459
1460 // These bits have to be at the end of this file, so that the
1461 // specializations have all been defined.
1462 inline _GLIBCXX_CONSTEXPR
1463 complex<float>::complex(const complex<double>& __z)
1464 : _M_value(__z.__rep()) { }
1465
1466 inline _GLIBCXX_CONSTEXPR
1467 complex<float>::complex(const complex<long double>& __z)
1468 : _M_value(__z.__rep()) { }
1469
1470 inline _GLIBCXX_CONSTEXPR
1471 complex<double>::complex(const complex<long double>& __z)
1472 : _M_value(__z.__rep()) { }
1473
1474 // Inhibit implicit instantiations for required instantiations,
1475 // which are defined via explicit instantiations elsewhere.
1476 // NB: This syntax is a GNU extension.
1477 #if _GLIBCXX_EXTERN_TEMPLATE
1478 extern template istream& operator>>(istream&, complex<float>&);
1479 extern template ostream& operator<<(ostream&, const complex<float>&);
1480 extern template istream& operator>>(istream&, complex<double>&);
1481 extern template ostream& operator<<(ostream&, const complex<double>&);
1482 extern template istream& operator>>(istream&, complex<long double>&);
1483 extern template ostream& operator<<(ostream&, const complex<long double>&);
1484
1485 #ifdef _GLIBCXX_USE_WCHAR_T
1486 extern template wistream& operator>>(wistream&, complex<float>&);
1487 extern template wostream& operator<<(wostream&, const complex<float>&);
1488 extern template wistream& operator>>(wistream&, complex<double>&);
1489 extern template wostream& operator<<(wostream&, const complex<double>&);
1490 extern template wistream& operator>>(wistream&, complex<long double>&);
1491 extern template wostream& operator<<(wostream&, const complex<long double>&);
1492 #endif
1493 #endif
1494
1495 // @} group complex_numbers
1496
1497 _GLIBCXX_END_NAMESPACE
1498
1499 _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
1500
1501 // See ext/type_traits.h for the primary template.
1502 template<typename _Tp, typename _Up>
1503 struct __promote_2<std::complex<_Tp>, _Up>
1504 {
1505 public:
1506 typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
1507 };
1508
1509 template<typename _Tp, typename _Up>
1510 struct __promote_2<_Tp, std::complex<_Up> >
1511 {
1512 public:
1513 typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
1514 };
1515
1516 template<typename _Tp, typename _Up>
1517 struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
1518 {
1519 public:
1520 typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
1521 };
1522
1523 _GLIBCXX_END_NAMESPACE
1524
1525 #ifdef __GXX_EXPERIMENTAL_CXX0X__
1526
1527 _GLIBCXX_BEGIN_NAMESPACE(std)
1528
1529 // Forward declarations.
1530 template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
1531 template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
1532 template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);
1533
1534 template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
1535 template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
1536 template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);
1537 // DR 595.
1538 template<typename _Tp> _Tp fabs(const std::complex<_Tp>&);
1539
1540 template<typename _Tp>
1541 inline std::complex<_Tp>
1542 __complex_acos(const std::complex<_Tp>& __z)
1543 {
1544 const std::complex<_Tp> __t = std::asin(__z);
1545 const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
1546 return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
1547 }
1548
1549 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1550 inline __complex__ float
1551 __complex_acos(__complex__ float __z)
1552 { return __builtin_cacosf(__z); }
1553
1554 inline __complex__ double
1555 __complex_acos(__complex__ double __z)
1556 { return __builtin_cacos(__z); }
1557
1558 inline __complex__ long double
1559 __complex_acos(const __complex__ long double& __z)
1560 { return __builtin_cacosl(__z); }
1561
1562 template<typename _Tp>
1563 inline std::complex<_Tp>
1564 acos(const std::complex<_Tp>& __z)
1565 { return __complex_acos(__z.__rep()); }
1566 #else
1567 /// acos(__z) [8.1.2].
1568 // Effects: Behaves the same as C99 function cacos, defined
1569 // in subclause 7.3.5.1.
1570 template<typename _Tp>
1571 inline std::complex<_Tp>
1572 acos(const std::complex<_Tp>& __z)
1573 { return __complex_acos(__z); }
1574 #endif
1575
1576 template<typename _Tp>
1577 inline std::complex<_Tp>
1578 __complex_asin(const std::complex<_Tp>& __z)
1579 {
1580 std::complex<_Tp> __t(-__z.imag(), __z.real());
1581 __t = std::asinh(__t);
1582 return std::complex<_Tp>(__t.imag(), -__t.real());
1583 }
1584
1585 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1586 inline __complex__ float
1587 __complex_asin(__complex__ float __z)
1588 { return __builtin_casinf(__z); }
1589
1590 inline __complex__ double
1591 __complex_asin(__complex__ double __z)
1592 { return __builtin_casin(__z); }
1593
1594 inline __complex__ long double
1595 __complex_asin(const __complex__ long double& __z)
1596 { return __builtin_casinl(__z); }
1597
1598 template<typename _Tp>
1599 inline std::complex<_Tp>
1600 asin(const std::complex<_Tp>& __z)
1601 { return __complex_asin(__z.__rep()); }
1602 #else
1603 /// asin(__z) [8.1.3].
1604 // Effects: Behaves the same as C99 function casin, defined
1605 // in subclause 7.3.5.2.
1606 template<typename _Tp>
1607 inline std::complex<_Tp>
1608 asin(const std::complex<_Tp>& __z)
1609 { return __complex_asin(__z); }
1610 #endif
1611
1612 template<typename _Tp>
1613 std::complex<_Tp>
1614 __complex_atan(const std::complex<_Tp>& __z)
1615 {
1616 const _Tp __r2 = __z.real() * __z.real();
1617 const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
1618
1619 _Tp __num = __z.imag() + _Tp(1.0);
1620 _Tp __den = __z.imag() - _Tp(1.0);
1621
1622 __num = __r2 + __num * __num;
1623 __den = __r2 + __den * __den;
1624
1625 return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
1626 _Tp(0.25) * log(__num / __den));
1627 }
1628
1629 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1630 inline __complex__ float
1631 __complex_atan(__complex__ float __z)
1632 { return __builtin_catanf(__z); }
1633
1634 inline __complex__ double
1635 __complex_atan(__complex__ double __z)
1636 { return __builtin_catan(__z); }
1637
1638 inline __complex__ long double
1639 __complex_atan(const __complex__ long double& __z)
1640 { return __builtin_catanl(__z); }
1641
1642 template<typename _Tp>
1643 inline std::complex<_Tp>
1644 atan(const std::complex<_Tp>& __z)
1645 { return __complex_atan(__z.__rep()); }
1646 #else
1647 /// atan(__z) [8.1.4].
1648 // Effects: Behaves the same as C99 function catan, defined
1649 // in subclause 7.3.5.3.
1650 template<typename _Tp>
1651 inline std::complex<_Tp>
1652 atan(const std::complex<_Tp>& __z)
1653 { return __complex_atan(__z); }
1654 #endif
1655
1656 template<typename _Tp>
1657 std::complex<_Tp>
1658 __complex_acosh(const std::complex<_Tp>& __z)
1659 {
1660 std::complex<_Tp> __t((__z.real() - __z.imag())
1661 * (__z.real() + __z.imag()) - _Tp(1.0),
1662 _Tp(2.0) * __z.real() * __z.imag());
1663 __t = std::sqrt(__t);
1664
1665 return std::log(__t + __z);
1666 }
1667
1668 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1669 inline __complex__ float
1670 __complex_acosh(__complex__ float __z)
1671 { return __builtin_cacoshf(__z); }
1672
1673 inline __complex__ double
1674 __complex_acosh(__complex__ double __z)
1675 { return __builtin_cacosh(__z); }
1676
1677 inline __complex__ long double
1678 __complex_acosh(const __complex__ long double& __z)
1679 { return __builtin_cacoshl(__z); }
1680
1681 template<typename _Tp>
1682 inline std::complex<_Tp>
1683 acosh(const std::complex<_Tp>& __z)
1684 { return __complex_acosh(__z.__rep()); }
1685 #else
1686 /// acosh(__z) [8.1.5].
1687 // Effects: Behaves the same as C99 function cacosh, defined
1688 // in subclause 7.3.6.1.
1689 template<typename _Tp>
1690 inline std::complex<_Tp>
1691 acosh(const std::complex<_Tp>& __z)
1692 { return __complex_acosh(__z); }
1693 #endif
1694
1695 template<typename _Tp>
1696 std::complex<_Tp>
1697 __complex_asinh(const std::complex<_Tp>& __z)
1698 {
1699 std::complex<_Tp> __t((__z.real() - __z.imag())
1700 * (__z.real() + __z.imag()) + _Tp(1.0),
1701 _Tp(2.0) * __z.real() * __z.imag());
1702 __t = std::sqrt(__t);
1703
1704 return std::log(__t + __z);
1705 }
1706
1707 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1708 inline __complex__ float
1709 __complex_asinh(__complex__ float __z)
1710 { return __builtin_casinhf(__z); }
1711
1712 inline __complex__ double
1713 __complex_asinh(__complex__ double __z)
1714 { return __builtin_casinh(__z); }
1715
1716 inline __complex__ long double
1717 __complex_asinh(const __complex__ long double& __z)
1718 { return __builtin_casinhl(__z); }
1719
1720 template<typename _Tp>
1721 inline std::complex<_Tp>
1722 asinh(const std::complex<_Tp>& __z)
1723 { return __complex_asinh(__z.__rep()); }
1724 #else
1725 /// asinh(__z) [8.1.6].
1726 // Effects: Behaves the same as C99 function casin, defined
1727 // in subclause 7.3.6.2.
1728 template<typename _Tp>
1729 inline std::complex<_Tp>
1730 asinh(const std::complex<_Tp>& __z)
1731 { return __complex_asinh(__z); }
1732 #endif
1733
1734 template<typename _Tp>
1735 std::complex<_Tp>
1736 __complex_atanh(const std::complex<_Tp>& __z)
1737 {
1738 const _Tp __i2 = __z.imag() * __z.imag();
1739 const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
1740
1741 _Tp __num = _Tp(1.0) + __z.real();
1742 _Tp __den = _Tp(1.0) - __z.real();
1743
1744 __num = __i2 + __num * __num;
1745 __den = __i2 + __den * __den;
1746
1747 return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
1748 _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
1749 }
1750
1751 #if _GLIBCXX_USE_C99_COMPLEX_TR1
1752 inline __complex__ float
1753 __complex_atanh(__complex__ float __z)
1754 { return __builtin_catanhf(__z); }
1755
1756 inline __complex__ double
1757 __complex_atanh(__complex__ double __z)
1758 { return __builtin_catanh(__z); }
1759
1760 inline __complex__ long double
1761 __complex_atanh(const __complex__ long double& __z)
1762 { return __builtin_catanhl(__z); }
1763
1764 template<typename _Tp>
1765 inline std::complex<_Tp>
1766 atanh(const std::complex<_Tp>& __z)
1767 { return __complex_atanh(__z.__rep()); }
1768 #else
1769 /// atanh(__z) [8.1.7].
1770 // Effects: Behaves the same as C99 function catanh, defined
1771 // in subclause 7.3.6.3.
1772 template<typename _Tp>
1773 inline std::complex<_Tp>
1774 atanh(const std::complex<_Tp>& __z)
1775 { return __complex_atanh(__z); }
1776 #endif
1777
1778 template<typename _Tp>
1779 inline _Tp
1780 /// fabs(__z) [8.1.8].
1781 // Effects: Behaves the same as C99 function cabs, defined
1782 // in subclause 7.3.8.1.
1783 fabs(const std::complex<_Tp>& __z)
1784 { return std::abs(__z); }
1785
1786 /// Additional overloads [8.1.9].
1787 template<typename _Tp>
1788 inline typename __gnu_cxx::__promote<_Tp>::__type
1789 arg(_Tp __x)
1790 {
1791 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1792 #if (_GLIBCXX_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC)
1793 return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L)
1794 : __type();
1795 #else
1796 return std::arg(std::complex<__type>(__x));
1797 #endif
1798 }
1799
1800 template<typename _Tp>
1801 inline typename __gnu_cxx::__promote<_Tp>::__type
1802 imag(_Tp)
1803 { return _Tp(); }
1804
1805 template<typename _Tp>
1806 inline typename __gnu_cxx::__promote<_Tp>::__type
1807 norm(_Tp __x)
1808 {
1809 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1810 return __type(__x) * __type(__x);
1811 }
1812
1813 template<typename _Tp>
1814 inline typename __gnu_cxx::__promote<_Tp>::__type
1815 real(_Tp __x)
1816 { return __x; }
1817
1818 template<typename _Tp, typename _Up>
1819 inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
1820 pow(const std::complex<_Tp>& __x, const _Up& __y)
1821 {
1822 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1823 return std::pow(std::complex<__type>(__x), __type(__y));
1824 }
1825
1826 template<typename _Tp, typename _Up>
1827 inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
1828 pow(const _Tp& __x, const std::complex<_Up>& __y)
1829 {
1830 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1831 return std::pow(__type(__x), std::complex<__type>(__y));
1832 }
1833
1834 template<typename _Tp, typename _Up>
1835 inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
1836 pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
1837 {
1838 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1839 return std::pow(std::complex<__type>(__x),
1840 std::complex<__type>(__y));
1841 }
1842
1843 // Forward declarations.
1844 // DR 781.
1845 template<typename _Tp> std::complex<_Tp> proj(const std::complex<_Tp>&);
1846
1847 template<typename _Tp>
1848 std::complex<_Tp>
1849 __complex_proj(const std::complex<_Tp>& __z)
1850 {
1851 const _Tp __den = (__z.real() * __z.real()
1852 + __z.imag() * __z.imag() + _Tp(1.0));
1853
1854 return std::complex<_Tp>((_Tp(2.0) * __z.real()) / __den,
1855 (_Tp(2.0) * __z.imag()) / __den);
1856 }
1857
1858 #if _GLIBCXX_USE_C99_COMPLEX
1859 inline __complex__ float
1860 __complex_proj(__complex__ float __z)
1861 { return __builtin_cprojf(__z); }
1862
1863 inline __complex__ double
1864 __complex_proj(__complex__ double __z)
1865 { return __builtin_cproj(__z); }
1866
1867 inline __complex__ long double
1868 __complex_proj(const __complex__ long double& __z)
1869 { return __builtin_cprojl(__z); }
1870
1871 template<typename _Tp>
1872 inline std::complex<_Tp>
1873 proj(const std::complex<_Tp>& __z)
1874 { return __complex_proj(__z.__rep()); }
1875 #else
1876 template<typename _Tp>
1877 inline std::complex<_Tp>
1878 proj(const std::complex<_Tp>& __z)
1879 { return __complex_proj(__z); }
1880 #endif
1881
1882 // DR 1137.
1883 template<typename _Tp>
1884 inline typename __gnu_cxx::__promote<_Tp>::__type
1885 proj(_Tp __x)
1886 { return __x; }
1887
1888 template<typename _Tp>
1889 inline typename __gnu_cxx::__promote<_Tp>::__type
1890 conj(_Tp __x)
1891 { return __x; }
1892
1893 _GLIBCXX_END_NAMESPACE
1894
1895 #endif // __GXX_EXPERIMENTAL_CXX0X__
1896
1897 #endif /* _GLIBCXX_COMPLEX */