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