libstdc++
complex
Go to the documentation of this file.
1// The template and inlines for the -*- C++ -*- complex number classes.
2
3// Copyright (C) 1997-2024 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>
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
50#ifdef __clang__
51#pragma clang diagnostic push
52#pragma clang diagnostic ignored "-Wc99-extensions"
53#endif
54
55#define __glibcxx_want_constexpr_complex
56#define __glibcxx_want_complex_udls
57#include <bits/version.h>
58
59namespace std _GLIBCXX_VISIBILITY(default)
60{
61_GLIBCXX_BEGIN_NAMESPACE_VERSION
62
63 /**
64 * @defgroup complex_numbers Complex Numbers
65 * @ingroup numerics
66 *
67 * Classes and functions for complex numbers.
68 * @{
69 */
70
71 // Forward declarations.
72 template<typename _Tp> class complex;
73 template<> class complex<float>;
74 template<> class complex<double>;
75 template<> class complex<long double>;
76
77 /// Return magnitude of @a z.
78 template<typename _Tp> _Tp abs(const complex<_Tp>&);
79 /// Return phase angle of @a z.
80 template<typename _Tp> _Tp arg(const complex<_Tp>&);
81 /// Return @a z magnitude squared.
82 template<typename _Tp> _Tp _GLIBCXX20_CONSTEXPR norm(const complex<_Tp>&);
83
84 /// Return complex conjugate of @a z.
85 template<typename _Tp>
86 _GLIBCXX20_CONSTEXPR complex<_Tp> conj(const complex<_Tp>&);
87 /// Return complex with magnitude @a rho and angle @a theta.
88 template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);
89
90 // Transcendentals:
91 /// Return complex cosine of @a z.
92 template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);
93 /// Return complex hyperbolic cosine of @a z.
94 template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);
95 /// Return complex base e exponential of @a z.
96 template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);
97 /// Return complex natural logarithm of @a z.
98 template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);
99 /// Return complex base 10 logarithm of @a z.
100 template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);
101 /// Return @a x to the @a y'th power.
102 template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);
103 /// Return @a x to the @a y'th power.
104 template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
105 /// Return @a x to the @a y'th power.
106 template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
107 const complex<_Tp>&);
108 /// Return @a x to the @a y'th power.
109 template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
110 /// Return complex sine of @a z.
111 template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);
112 /// Return complex hyperbolic sine of @a z.
113 template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);
114 /// Return complex square root of @a z.
115 template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);
116 /// Return complex tangent of @a z.
117 template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);
118 /// Return complex hyperbolic tangent of @a z.
119 template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
120
121
122 // 26.2.2 Primary template class complex
123 /**
124 * Template to represent complex numbers.
125 *
126 * Specializations for float, double, and long double are part of the
127 * library. Results with any other type are not guaranteed.
128 *
129 * @param Tp Type of real and imaginary values.
130 */
131 template<typename _Tp>
133 {
134 public:
135 /// Value typedef.
136 typedef _Tp value_type;
137
138 /// Default constructor. First parameter is x, second parameter is y.
139 /// Unspecified parameters default to 0.
140 _GLIBCXX_CONSTEXPR complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
141 : _M_real(__r), _M_imag(__i) { }
142
143 // Let the compiler synthesize the copy constructor
144#if __cplusplus >= 201103L
145 constexpr complex(const complex&) = default;
146#endif
147
148 /// Converting constructor.
149 template<typename _Up>
150#if __cplusplus > 202002L
151 explicit(!requires(_Up __u) { _Tp{__u}; })
152#endif
153 _GLIBCXX_CONSTEXPR complex(const complex<_Up>& __z)
154 : _M_real(_Tp(__z.real())), _M_imag(_Tp(__z.imag())) { }
155
156#if __cplusplus >= 201103L
157 // _GLIBCXX_RESOLVE_LIB_DEFECTS
158 // DR 387. std::complex over-encapsulated.
159 _GLIBCXX_ABI_TAG_CXX11
160 constexpr _Tp
161 real() const { return _M_real; }
162
163 _GLIBCXX_ABI_TAG_CXX11
164 constexpr _Tp
165 imag() const { return _M_imag; }
166#else
167 /// Return real part of complex number.
168 _Tp&
169 real() { return _M_real; }
170
171 /// Return real part of complex number.
172 const _Tp&
173 real() const { return _M_real; }
174
175 /// Return imaginary part of complex number.
176 _Tp&
177 imag() { return _M_imag; }
178
179 /// Return imaginary part of complex number.
180 const _Tp&
181 imag() const { return _M_imag; }
182#endif
183
184 // _GLIBCXX_RESOLVE_LIB_DEFECTS
185 // DR 387. std::complex over-encapsulated.
186 _GLIBCXX20_CONSTEXPR void
187 real(_Tp __val) { _M_real = __val; }
188
189 _GLIBCXX20_CONSTEXPR void
190 imag(_Tp __val) { _M_imag = __val; }
191
192 /// Assign a scalar to this complex number.
193 _GLIBCXX20_CONSTEXPR complex<_Tp>& operator=(const _Tp&);
194
195 /// Add a scalar to this complex number.
196 // 26.2.5/1
197 _GLIBCXX20_CONSTEXPR complex<_Tp>&
198 operator+=(const _Tp& __t)
199 {
200 _M_real += __t;
201 return *this;
202 }
203
204 /// Subtract a scalar from this complex number.
205 // 26.2.5/3
206 _GLIBCXX20_CONSTEXPR complex<_Tp>&
207 operator-=(const _Tp& __t)
208 {
209 _M_real -= __t;
210 return *this;
211 }
212
213 /// Multiply this complex number by a scalar.
214 _GLIBCXX20_CONSTEXPR complex<_Tp>& operator*=(const _Tp&);
215 /// Divide this complex number by a scalar.
216 _GLIBCXX20_CONSTEXPR complex<_Tp>& operator/=(const _Tp&);
217
218 // Let the compiler synthesize the copy assignment operator
219#if __cplusplus >= 201103L
220 _GLIBCXX20_CONSTEXPR complex& operator=(const complex&) = default;
221#endif
222
223 /// Assign another complex number to this one.
224 template<typename _Up>
225 _GLIBCXX20_CONSTEXPR complex<_Tp>& operator=(const complex<_Up>&);
226 /// Add another complex number to this one.
227 template<typename _Up>
228 _GLIBCXX20_CONSTEXPR complex<_Tp>& operator+=(const complex<_Up>&);
229 /// Subtract another complex number from this one.
230 template<typename _Up>
231 _GLIBCXX20_CONSTEXPR complex<_Tp>& operator-=(const complex<_Up>&);
232 /// Multiply this complex number by another.
233 template<typename _Up>
234 _GLIBCXX20_CONSTEXPR complex<_Tp>& operator*=(const complex<_Up>&);
235 /// Divide this complex number by another.
236 template<typename _Up>
237 _GLIBCXX20_CONSTEXPR complex<_Tp>& operator/=(const complex<_Up>&);
238
239 _GLIBCXX_CONSTEXPR complex __rep() const
240 { return *this; }
241
242 private:
243 _Tp _M_real;
244 _Tp _M_imag;
245 };
246
247 template<typename _Tp>
248 _GLIBCXX20_CONSTEXPR complex<_Tp>&
250 {
251 _M_real = __t;
252 _M_imag = _Tp();
253 return *this;
254 }
255
256 // 26.2.5/5
257 template<typename _Tp>
258 _GLIBCXX20_CONSTEXPR complex<_Tp>&
260 {
261 _M_real *= __t;
262 _M_imag *= __t;
263 return *this;
264 }
265
266 // 26.2.5/7
267 template<typename _Tp>
268 _GLIBCXX20_CONSTEXPR complex<_Tp>&
270 {
271 _M_real /= __t;
272 _M_imag /= __t;
273 return *this;
274 }
275
276 template<typename _Tp>
277 template<typename _Up>
278 _GLIBCXX20_CONSTEXPR complex<_Tp>&
280 {
281 _M_real = __z.real();
282 _M_imag = __z.imag();
283 return *this;
284 }
285
286 // 26.2.5/9
287 template<typename _Tp>
288 template<typename _Up>
289 _GLIBCXX20_CONSTEXPR complex<_Tp>&
291 {
292 _M_real += __z.real();
293 _M_imag += __z.imag();
294 return *this;
295 }
296
297 // 26.2.5/11
298 template<typename _Tp>
299 template<typename _Up>
300 _GLIBCXX20_CONSTEXPR complex<_Tp>&
302 {
303 _M_real -= __z.real();
304 _M_imag -= __z.imag();
305 return *this;
306 }
307
308 // 26.2.5/13
309 // XXX: This is a grammar school implementation.
310 template<typename _Tp>
311 template<typename _Up>
312 _GLIBCXX20_CONSTEXPR complex<_Tp>&
314 {
315 const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
316 _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
317 _M_real = __r;
318 return *this;
319 }
320
321 // 26.2.5/15
322 // XXX: This is a grammar school implementation.
323 template<typename _Tp>
324 template<typename _Up>
325 _GLIBCXX20_CONSTEXPR complex<_Tp>&
327 {
328 const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag();
329 const _Tp __n = std::norm(__z);
330 _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
331 _M_real = __r / __n;
332 return *this;
333 }
334
335 // Operators:
336 ///@{
337 /// Return new complex value @a x plus @a y.
338 template<typename _Tp>
339 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
340 operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
341 {
342 complex<_Tp> __r = __x;
343 __r += __y;
344 return __r;
345 }
346
347 template<typename _Tp>
348 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
349 operator+(const complex<_Tp>& __x, const _Tp& __y)
350 {
351 complex<_Tp> __r = __x;
352 __r += __y;
353 return __r;
354 }
355
356 template<typename _Tp>
357 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
358 operator+(const _Tp& __x, const complex<_Tp>& __y)
359 {
360 complex<_Tp> __r = __y;
361 __r += __x;
362 return __r;
363 }
364 ///@}
365
366 ///@{
367 /// Return new complex value @a x minus @a y.
368 template<typename _Tp>
369 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
370 operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
371 {
372 complex<_Tp> __r = __x;
373 __r -= __y;
374 return __r;
375 }
376
377 template<typename _Tp>
378 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
379 operator-(const complex<_Tp>& __x, const _Tp& __y)
380 {
381 complex<_Tp> __r = __x;
382 __r -= __y;
383 return __r;
384 }
385
386 template<typename _Tp>
387 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
388 operator-(const _Tp& __x, const complex<_Tp>& __y)
389 {
390 complex<_Tp> __r = -__y;
391 __r += __x;
392 return __r;
393 }
394 ///@}
395
396 ///@{
397 /// Return new complex value @a x times @a y.
398 template<typename _Tp>
399 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
400 operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
401 {
402 complex<_Tp> __r = __x;
403 __r *= __y;
404 return __r;
405 }
406
407 template<typename _Tp>
408 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
409 operator*(const complex<_Tp>& __x, const _Tp& __y)
410 {
411 complex<_Tp> __r = __x;
412 __r *= __y;
413 return __r;
414 }
415
416 template<typename _Tp>
417 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
418 operator*(const _Tp& __x, const complex<_Tp>& __y)
419 {
420 complex<_Tp> __r = __y;
421 __r *= __x;
422 return __r;
423 }
424 ///@}
425
426 ///@{
427 /// Return new complex value @a x divided by @a y.
428 template<typename _Tp>
429 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
430 operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
431 {
432 complex<_Tp> __r = __x;
433 __r /= __y;
434 return __r;
435 }
436
437 template<typename _Tp>
438 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
439 operator/(const complex<_Tp>& __x, const _Tp& __y)
440 {
441 complex<_Tp> __r = __x;
442 __r /= __y;
443 return __r;
444 }
445
446 template<typename _Tp>
447 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
448 operator/(const _Tp& __x, const complex<_Tp>& __y)
449 {
450 complex<_Tp> __r = __x;
451 __r /= __y;
452 return __r;
453 }
454 ///@}
455
456 /// Return @a x.
457 template<typename _Tp>
458 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
460 { return __x; }
461
462 /// Return complex negation of @a x.
463 template<typename _Tp>
464 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
466 { return complex<_Tp>(-__x.real(), -__x.imag()); }
467
468 ///@{
469 /// Return true if @a x is equal to @a y.
470 template<typename _Tp>
471 inline _GLIBCXX_CONSTEXPR bool
472 operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
473 { return __x.real() == __y.real() && __x.imag() == __y.imag(); }
474
475 template<typename _Tp>
476 inline _GLIBCXX_CONSTEXPR bool
477 operator==(const complex<_Tp>& __x, const _Tp& __y)
478 { return __x.real() == __y && __x.imag() == _Tp(); }
479
480#if !(__cpp_impl_three_way_comparison >= 201907L)
481 template<typename _Tp>
482 inline _GLIBCXX_CONSTEXPR bool
483 operator==(const _Tp& __x, const complex<_Tp>& __y)
484 { return __x == __y.real() && _Tp() == __y.imag(); }
485 ///@}
486
487 ///@{
488 /// Return false if @a x is equal to @a y.
489 template<typename _Tp>
490 inline _GLIBCXX_CONSTEXPR bool
491 operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
492 { return __x.real() != __y.real() || __x.imag() != __y.imag(); }
493
494 template<typename _Tp>
495 inline _GLIBCXX_CONSTEXPR bool
496 operator!=(const complex<_Tp>& __x, const _Tp& __y)
497 { return __x.real() != __y || __x.imag() != _Tp(); }
498
499 template<typename _Tp>
500 inline _GLIBCXX_CONSTEXPR bool
501 operator!=(const _Tp& __x, const complex<_Tp>& __y)
502 { return __x != __y.real() || _Tp() != __y.imag(); }
503#endif
504 ///@}
505
506 /// Extraction operator for complex values.
507 template<typename _Tp, typename _CharT, class _Traits>
508 basic_istream<_CharT, _Traits>&
510 {
511 bool __fail = true;
512 _CharT __ch;
513 if (__is >> __ch)
514 {
515 if (_Traits::eq(__ch, __is.widen('(')))
516 {
517 _Tp __u;
518 if (__is >> __u >> __ch)
519 {
520 const _CharT __rparen = __is.widen(')');
521 if (_Traits::eq(__ch, __rparen))
522 {
523 __x = __u;
524 __fail = false;
525 }
526 else if (_Traits::eq(__ch, __is.widen(',')))
527 {
528 _Tp __v;
529 if (__is >> __v >> __ch)
530 {
531 if (_Traits::eq(__ch, __rparen))
532 {
533 __x = complex<_Tp>(__u, __v);
534 __fail = false;
535 }
536 else
537 __is.putback(__ch);
538 }
539 }
540 else
541 __is.putback(__ch);
542 }
543 }
544 else
545 {
546 __is.putback(__ch);
547 _Tp __u;
548 if (__is >> __u)
549 {
550 __x = __u;
551 __fail = false;
552 }
553 }
554 }
555 if (__fail)
557 return __is;
558 }
559
560 /// Insertion operator for complex values.
561 template<typename _Tp, typename _CharT, class _Traits>
562 basic_ostream<_CharT, _Traits>&
563 operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
564 {
565 basic_ostringstream<_CharT, _Traits> __s;
566 __s.flags(__os.flags());
567 __s.imbue(__os.getloc());
568 __s.precision(__os.precision());
569 __s << '(' << __x.real() << ',' << __x.imag() << ')';
570 return __os << __s.str();
571 }
572
573 // Values
574#if __cplusplus >= 201103L
575 template<typename _Tp>
576 constexpr _Tp
577 real(const complex<_Tp>& __z)
578 { return __z.real(); }
579
580 template<typename _Tp>
581 constexpr _Tp
582 imag(const complex<_Tp>& __z)
583 { return __z.imag(); }
584#else
585 template<typename _Tp>
586 inline _Tp&
587 real(complex<_Tp>& __z)
588 { return __z.real(); }
589
590 template<typename _Tp>
591 inline const _Tp&
592 real(const complex<_Tp>& __z)
593 { return __z.real(); }
594
595 template<typename _Tp>
596 inline _Tp&
597 imag(complex<_Tp>& __z)
598 { return __z.imag(); }
599
600 template<typename _Tp>
601 inline const _Tp&
602 imag(const complex<_Tp>& __z)
603 { return __z.imag(); }
604#endif
605
606#if _GLIBCXX_USE_C99_COMPLEX
607#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
608 inline _Float16
609 __complex_abs(__complex__ _Float16 __z)
610 { return _Float16(__builtin_cabsf(__z)); }
611
612 inline _Float16
613 __complex_arg(__complex__ _Float16 __z)
614 { return _Float16(__builtin_cargf(__z)); }
615
616 inline __complex__ _Float16
617 __complex_cos(__complex__ _Float16 __z)
618 { return static_cast<__complex__ _Float16>(__builtin_ccosf(__z)); }
619
620 inline __complex__ _Float16
621 __complex_cosh(__complex__ _Float16 __z)
622 { return static_cast<__complex__ _Float16>(__builtin_ccoshf(__z)); }
623
624 inline __complex__ _Float16
625 __complex_exp(__complex__ _Float16 __z)
626 { return static_cast<__complex__ _Float16>(__builtin_cexpf(__z)); }
627
628 inline __complex__ _Float16
629 __complex_log(__complex__ _Float16 __z)
630 { return static_cast<__complex__ _Float16>(__builtin_clogf(__z)); }
631
632 inline __complex__ _Float16
633 __complex_sin(__complex__ _Float16 __z)
634 { return static_cast<__complex__ _Float16>(__builtin_csinf(__z)); }
635
636 inline __complex__ _Float16
637 __complex_sinh(__complex__ _Float16 __z)
638 { return static_cast<__complex__ _Float16>(__builtin_csinhf(__z)); }
639
640 inline __complex__ _Float16
641 __complex_sqrt(__complex__ _Float16 __z)
642 { return static_cast<__complex__ _Float16>(__builtin_csqrtf(__z)); }
643
644 inline __complex__ _Float16
645 __complex_tan(__complex__ _Float16 __z)
646 { return static_cast<__complex__ _Float16>(__builtin_ctanf(__z)); }
647
648 inline __complex__ _Float16
649 __complex_tanh(__complex__ _Float16 __z)
650 { return static_cast<__complex__ _Float16>(__builtin_ctanhf(__z)); }
651
652 inline __complex__ _Float16
653 __complex_pow(__complex__ _Float16 __x, __complex__ _Float16 __y)
654 { return static_cast<__complex__ _Float16>(__builtin_cpowf(__x, __y)); }
655#endif
656
657#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
658 inline _Float32
659 __complex_abs(__complex__ _Float32 __z) { return __builtin_cabsf(__z); }
660
661 inline _Float32
662 __complex_arg(__complex__ _Float32 __z) { return __builtin_cargf(__z); }
663
664 inline __complex__ _Float32
665 __complex_cos(__complex__ _Float32 __z) { return __builtin_ccosf(__z); }
666
667 inline __complex__ _Float32
668 __complex_cosh(__complex__ _Float32 __z) { return __builtin_ccoshf(__z); }
669
670 inline __complex__ _Float32
671 __complex_exp(__complex__ _Float32 __z) { return __builtin_cexpf(__z); }
672
673 inline __complex__ _Float32
674 __complex_log(__complex__ _Float32 __z) { return __builtin_clogf(__z); }
675
676 inline __complex__ _Float32
677 __complex_sin(__complex__ _Float32 __z) { return __builtin_csinf(__z); }
678
679 inline __complex__ _Float32
680 __complex_sinh(__complex__ _Float32 __z) { return __builtin_csinhf(__z); }
681
682 inline __complex__ _Float32
683 __complex_sqrt(__complex__ _Float32 __z) { return __builtin_csqrtf(__z); }
684
685 inline __complex__ _Float32
686 __complex_tan(__complex__ _Float32 __z) { return __builtin_ctanf(__z); }
687
688 inline __complex__ _Float32
689 __complex_tanh(__complex__ _Float32 __z) { return __builtin_ctanhf(__z); }
690
691 inline __complex__ _Float32
692 __complex_pow(__complex__ _Float32 __x, __complex__ _Float32 __y)
693 { return __builtin_cpowf(__x, __y); }
694#endif
695
696#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
697 inline _Float64
698 __complex_abs(__complex__ _Float64 __z) { return __builtin_cabs(__z); }
699
700 inline _Float64
701 __complex_arg(__complex__ _Float64 __z) { return __builtin_carg(__z); }
702
703 inline __complex__ _Float64
704 __complex_cos(__complex__ _Float64 __z) { return __builtin_ccos(__z); }
705
706 inline __complex__ _Float64
707 __complex_cosh(__complex__ _Float64 __z) { return __builtin_ccosh(__z); }
708
709 inline __complex__ _Float64
710 __complex_exp(__complex__ _Float64 __z) { return __builtin_cexp(__z); }
711
712 inline __complex__ _Float64
713 __complex_log(__complex__ _Float64 __z) { return __builtin_clog(__z); }
714
715 inline __complex__ _Float64
716 __complex_sin(__complex__ _Float64 __z) { return __builtin_csin(__z); }
717
718 inline __complex__ _Float64
719 __complex_sinh(__complex__ _Float64 __z) { return __builtin_csinh(__z); }
720
721 inline __complex__ _Float64
722 __complex_sqrt(__complex__ _Float64 __z) { return __builtin_csqrt(__z); }
723
724 inline __complex__ _Float64
725 __complex_tan(__complex__ _Float64 __z) { return __builtin_ctan(__z); }
726
727 inline __complex__ _Float64
728 __complex_tanh(__complex__ _Float64 __z) { return __builtin_ctanh(__z); }
729
730 inline __complex__ _Float64
731 __complex_pow(__complex__ _Float64 __x, __complex__ _Float64 __y)
732 { return __builtin_cpow(__x, __y); }
733#endif
734
735#if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
736 inline _Float128
737 __complex_abs(__complex__ _Float128 __z) { return __builtin_cabsl(__z); }
738
739 inline _Float128
740 __complex_arg(__complex__ _Float128 __z) { return __builtin_cargl(__z); }
741
742 inline __complex__ _Float128
743 __complex_cos(__complex__ _Float128 __z) { return __builtin_ccosl(__z); }
744
745 inline __complex__ _Float128
746 __complex_cosh(__complex__ _Float128 __z) { return __builtin_ccoshl(__z); }
747
748 inline __complex__ _Float128
749 __complex_exp(__complex__ _Float128 __z) { return __builtin_cexpl(__z); }
750
751 inline __complex__ _Float128
752 __complex_log(__complex__ _Float128 __z) { return __builtin_clogl(__z); }
753
754 inline __complex__ _Float128
755 __complex_sin(__complex__ _Float128 __z) { return __builtin_csinl(__z); }
756
757 inline __complex__ _Float128
758 __complex_sinh(__complex__ _Float128 __z) { return __builtin_csinhl(__z); }
759
760 inline __complex__ _Float128
761 __complex_sqrt(__complex__ _Float128 __z) { return __builtin_csqrtl(__z); }
762
763 inline __complex__ _Float128
764 __complex_tan(__complex__ _Float128 __z) { return __builtin_ctanl(__z); }
765
766 inline __complex__ _Float128
767 __complex_tanh(__complex__ _Float128 __z) { return __builtin_ctanhl(__z); }
768
769 inline __complex__ _Float128
770 __complex_pow(__complex__ _Float128 __x, __complex__ _Float128 __y)
771 { return __builtin_cpowl(__x, __y); }
772#elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
773 inline _Float128
774 __complex_abs(__complex__ _Float128 __z) { return __builtin_cabsf128(__z); }
775
776 inline _Float128
777 __complex_arg(__complex__ _Float128 __z) { return __builtin_cargf128(__z); }
778
779 inline __complex__ _Float128
780 __complex_cos(__complex__ _Float128 __z) { return __builtin_ccosf128(__z); }
781
782 inline __complex__ _Float128
783 __complex_cosh(__complex__ _Float128 __z) { return __builtin_ccoshf128(__z); }
784
785 inline __complex__ _Float128
786 __complex_exp(__complex__ _Float128 __z) { return __builtin_cexpf128(__z); }
787
788 inline __complex__ _Float128
789 __complex_log(__complex__ _Float128 __z) { return __builtin_clogf128(__z); }
790
791 inline __complex__ _Float128
792 __complex_sin(__complex__ _Float128 __z) { return __builtin_csinf128(__z); }
793
794 inline __complex__ _Float128
795 __complex_sinh(__complex__ _Float128 __z) { return __builtin_csinhf128(__z); }
796
797 inline __complex__ _Float128
798 __complex_sqrt(__complex__ _Float128 __z) { return __builtin_csqrtf128(__z); }
799
800 inline __complex__ _Float128
801 __complex_tan(__complex__ _Float128 __z) { return __builtin_ctanf128(__z); }
802
803 inline __complex__ _Float128
804 __complex_tanh(__complex__ _Float128 __z) { return __builtin_ctanhf128(__z); }
805
806 inline __complex__ _Float128
807 __complex_pow(__complex__ _Float128 __x, __complex__ _Float128 __y)
808 { return __builtin_cpowf128(__x, __y); }
809#endif
810
811#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
812 inline __gnu_cxx::__bfloat16_t
813 __complex_abs(__complex__ decltype(0.0bf16) __z)
814 { return __gnu_cxx::__bfloat16_t(__builtin_cabsf(__z)); }
815
816 inline __gnu_cxx::__bfloat16_t
817 __complex_arg(__complex__ decltype(0.0bf16) __z)
818 { return __gnu_cxx::__bfloat16_t(__builtin_cargf(__z)); }
819
820 inline __complex__ decltype(0.0bf16)
821 __complex_cos(__complex__ decltype(0.0bf16) __z)
822 { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_ccosf(__z)); }
823
824 inline __complex__ decltype(0.0bf16)
825 __complex_cosh(__complex__ decltype(0.0bf16) __z)
826 { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_ccoshf(__z)); }
827
828 inline __complex__ decltype(0.0bf16)
829 __complex_exp(__complex__ decltype(0.0bf16) __z)
830 { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_cexpf(__z)); }
831
832 inline __complex__ decltype(0.0bf16)
833 __complex_log(__complex__ decltype(0.0bf16) __z)
834 { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_clogf(__z)); }
835
836 inline __complex__ decltype(0.0bf16)
837 __complex_sin(__complex__ decltype(0.0bf16) __z)
838 { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_csinf(__z)); }
839
840 inline __complex__ decltype(0.0bf16)
841 __complex_sinh(__complex__ decltype(0.0bf16) __z)
842 { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_csinhf(__z)); }
843
844 inline __complex__ decltype(0.0bf16)
845 __complex_sqrt(__complex__ decltype(0.0bf16) __z)
846 { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_csqrtf(__z)); }
847
848 inline __complex__ decltype(0.0bf16)
849 __complex_tan(__complex__ decltype(0.0bf16) __z)
850 { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_ctanf(__z)); }
851
852 inline __complex__ decltype(0.0bf16)
853 __complex_tanh(__complex__ decltype(0.0bf16) __z)
854 { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_ctanhf(__z)); }
855
856 inline __complex__ decltype(0.0bf16)
857 __complex_pow(__complex__ decltype(0.0bf16) __x,
858 __complex__ decltype(0.0bf16) __y)
859 { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_cpowf(__x,
860 __y)); }
861#endif
862#endif
863
864 // 26.2.7/3 abs(__z): Returns the magnitude of __z.
865 template<typename _Tp>
866 inline _Tp
867 __complex_abs(const complex<_Tp>& __z)
868 {
869 _Tp __x = __z.real();
870 _Tp __y = __z.imag();
871 const _Tp __s = std::max(abs(__x), abs(__y));
872 if (__s == _Tp()) // well ...
873 return __s;
874 __x /= __s;
875 __y /= __s;
876 return __s * sqrt(__x * __x + __y * __y);
877 }
878
879#if _GLIBCXX_USE_C99_COMPLEX
880 inline float
881 __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }
882
883 inline double
884 __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }
885
886 inline long double
887 __complex_abs(const __complex__ long double& __z)
888 { return __builtin_cabsl(__z); }
889
890 template<typename _Tp>
891 inline _Tp
892 abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
893#else
894 template<typename _Tp>
895 inline _Tp
896 abs(const complex<_Tp>& __z) { return __complex_abs(__z); }
897#endif
898
899
900 // 26.2.7/4: arg(__z): Returns the phase angle of __z.
901 template<typename _Tp>
902 inline _Tp
903 __complex_arg(const complex<_Tp>& __z)
904 { return atan2(__z.imag(), __z.real()); }
905
906#if _GLIBCXX_USE_C99_COMPLEX
907 inline float
908 __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }
909
910 inline double
911 __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }
912
913 inline long double
914 __complex_arg(const __complex__ long double& __z)
915 { return __builtin_cargl(__z); }
916
917 template<typename _Tp>
918 inline _Tp
919 arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
920#else
921 template<typename _Tp>
922 inline _Tp
923 arg(const complex<_Tp>& __z) { return __complex_arg(__z); }
924#endif
925
926 // 26.2.7/5: norm(__z) returns the squared magnitude of __z.
927 // As defined, norm() is -not- a norm is the common mathematical
928 // sense used in numerics. The helper class _Norm_helper<> tries to
929 // distinguish between builtin floating point and the rest, so as
930 // to deliver an answer as close as possible to the real value.
931 template<bool>
932 struct _Norm_helper
933 {
934 template<typename _Tp>
935 static inline _GLIBCXX20_CONSTEXPR _Tp _S_do_it(const complex<_Tp>& __z)
936 {
937 const _Tp __x = __z.real();
938 const _Tp __y = __z.imag();
939 return __x * __x + __y * __y;
940 }
941 };
942
943 template<>
944 struct _Norm_helper<true>
945 {
946 template<typename _Tp>
947 static inline _GLIBCXX20_CONSTEXPR _Tp _S_do_it(const complex<_Tp>& __z)
948 {
949 //_Tp __res = std::abs(__z);
950 //return __res * __res;
951 const _Tp __x = __z.real();
952 const _Tp __y = __z.imag();
953 return __x * __x + __y * __y;
954 }
955 };
956
957 template<typename _Tp>
958 inline _GLIBCXX20_CONSTEXPR _Tp
959 norm(const complex<_Tp>& __z)
960 {
961 return _Norm_helper<__is_floating<_Tp>::__value
962 && !_GLIBCXX_FAST_MATH>::_S_do_it(__z);
963 }
964
965 template<typename _Tp>
966 inline complex<_Tp>
967 polar(const _Tp& __rho, const _Tp& __theta)
968 {
969 __glibcxx_assert( __rho >= 0 );
970 return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta));
971 }
972
973 template<typename _Tp>
974 inline _GLIBCXX20_CONSTEXPR complex<_Tp>
975 conj(const complex<_Tp>& __z)
976 { return complex<_Tp>(__z.real(), -__z.imag()); }
977
978 // Transcendentals
979
980 // 26.2.8/1 cos(__z): Returns the cosine of __z.
981 template<typename _Tp>
982 inline complex<_Tp>
983 __complex_cos(const complex<_Tp>& __z)
984 {
985 const _Tp __x = __z.real();
986 const _Tp __y = __z.imag();
987 return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
988 }
989
990#if _GLIBCXX_USE_C99_COMPLEX
991 inline __complex__ float
992 __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }
993
994 inline __complex__ double
995 __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }
996
997 inline __complex__ long double
998 __complex_cos(const __complex__ long double& __z)
999 { return __builtin_ccosl(__z); }
1000
1001 template<typename _Tp>
1002 inline complex<_Tp>
1003 cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }
1004#else
1005 template<typename _Tp>
1006 inline complex<_Tp>
1007 cos(const complex<_Tp>& __z) { return __complex_cos(__z); }
1008#endif
1009
1010 // 26.2.8/2 cosh(__z): Returns the hyperbolic cosine of __z.
1011 template<typename _Tp>
1012 inline complex<_Tp>
1013 __complex_cosh(const complex<_Tp>& __z)
1014 {
1015 const _Tp __x = __z.real();
1016 const _Tp __y = __z.imag();
1017 return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
1018 }
1019
1020#if _GLIBCXX_USE_C99_COMPLEX
1021 inline __complex__ float
1022 __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }
1023
1024 inline __complex__ double
1025 __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }
1026
1027 inline __complex__ long double
1028 __complex_cosh(const __complex__ long double& __z)
1029 { return __builtin_ccoshl(__z); }
1030
1031 template<typename _Tp>
1032 inline complex<_Tp>
1033 cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }
1034#else
1035 template<typename _Tp>
1036 inline complex<_Tp>
1037 cosh(const complex<_Tp>& __z) { return __complex_cosh(__z); }
1038#endif
1039
1040 // 26.2.8/3 exp(__z): Returns the complex base e exponential of x
1041 template<typename _Tp>
1042 inline complex<_Tp>
1043 __complex_exp(const complex<_Tp>& __z)
1044 { return std::polar<_Tp>(exp(__z.real()), __z.imag()); }
1045
1046#if _GLIBCXX_USE_C99_COMPLEX
1047 inline __complex__ float
1048 __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }
1049
1050 inline __complex__ double
1051 __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }
1052
1053 inline __complex__ long double
1054 __complex_exp(const __complex__ long double& __z)
1055 { return __builtin_cexpl(__z); }
1056
1057 template<typename _Tp>
1058 inline complex<_Tp>
1059 exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
1060#else
1061 template<typename _Tp>
1062 inline complex<_Tp>
1063 exp(const complex<_Tp>& __z) { return __complex_exp(__z); }
1064#endif
1065
1066 // 26.2.8/5 log(__z): Returns the natural complex logarithm of __z.
1067 // The branch cut is along the negative axis.
1068 template<typename _Tp>
1069 inline complex<_Tp>
1070 __complex_log(const complex<_Tp>& __z)
1071 { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
1072
1073#if _GLIBCXX_USE_C99_COMPLEX
1074 inline __complex__ float
1075 __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }
1076
1077 inline __complex__ double
1078 __complex_log(__complex__ double __z) { return __builtin_clog(__z); }
1079
1080 inline __complex__ long double
1081 __complex_log(const __complex__ long double& __z)
1082 { return __builtin_clogl(__z); }
1083
1084 template<typename _Tp>
1085 inline complex<_Tp>
1086 log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }
1087#else
1088 template<typename _Tp>
1089 inline complex<_Tp>
1090 log(const complex<_Tp>& __z) { return __complex_log(__z); }
1091#endif
1092
1093 template<typename _Tp>
1094 inline complex<_Tp>
1096 { return std::log(__z) / log(_Tp(10.0)); }
1097
1098 // 26.2.8/10 sin(__z): Returns the sine of __z.
1099 template<typename _Tp>
1100 inline complex<_Tp>
1101 __complex_sin(const complex<_Tp>& __z)
1102 {
1103 const _Tp __x = __z.real();
1104 const _Tp __y = __z.imag();
1105 return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
1106 }
1107
1108#if _GLIBCXX_USE_C99_COMPLEX
1109 inline __complex__ float
1110 __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }
1111
1112 inline __complex__ double
1113 __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }
1114
1115 inline __complex__ long double
1116 __complex_sin(const __complex__ long double& __z)
1117 { return __builtin_csinl(__z); }
1118
1119 template<typename _Tp>
1120 inline complex<_Tp>
1121 sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }
1122#else
1123 template<typename _Tp>
1124 inline complex<_Tp>
1125 sin(const complex<_Tp>& __z) { return __complex_sin(__z); }
1126#endif
1127
1128 // 26.2.8/11 sinh(__z): Returns the hyperbolic sine of __z.
1129 template<typename _Tp>
1130 inline complex<_Tp>
1131 __complex_sinh(const complex<_Tp>& __z)
1132 {
1133 const _Tp __x = __z.real();
1134 const _Tp __y = __z.imag();
1135 return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
1136 }
1137
1138#if _GLIBCXX_USE_C99_COMPLEX
1139 inline __complex__ float
1140 __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
1141
1142 inline __complex__ double
1143 __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }
1144
1145 inline __complex__ long double
1146 __complex_sinh(const __complex__ long double& __z)
1147 { return __builtin_csinhl(__z); }
1148
1149 template<typename _Tp>
1150 inline complex<_Tp>
1151 sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
1152#else
1153 template<typename _Tp>
1154 inline complex<_Tp>
1155 sinh(const complex<_Tp>& __z) { return __complex_sinh(__z); }
1156#endif
1157
1158 // 26.2.8/13 sqrt(__z): Returns the complex square root of __z.
1159 // The branch cut is on the negative axis.
1160 template<typename _Tp>
1161 complex<_Tp>
1162 __complex_sqrt(const complex<_Tp>& __z)
1163 {
1164 _Tp __x = __z.real();
1165 _Tp __y = __z.imag();
1166
1167 if (__x == _Tp())
1168 {
1169 _Tp __t = sqrt(abs(__y) / 2);
1170 return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
1171 }
1172 else
1173 {
1174 _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
1175 _Tp __u = __t / 2;
1176 return __x > _Tp()
1177 ? complex<_Tp>(__u, __y / __t)
1178 : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
1179 }
1180 }
1181
1182#if _GLIBCXX_USE_C99_COMPLEX
1183 inline __complex__ float
1184 __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }
1185
1186 inline __complex__ double
1187 __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }
1188
1189 inline __complex__ long double
1190 __complex_sqrt(const __complex__ long double& __z)
1191 { return __builtin_csqrtl(__z); }
1192
1193 template<typename _Tp>
1194 inline complex<_Tp>
1195 sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
1196#else
1197 template<typename _Tp>
1198 inline complex<_Tp>
1199 sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z); }
1200#endif
1201
1202 // 26.2.8/14 tan(__z): Return the complex tangent of __z.
1203
1204 template<typename _Tp>
1205 inline complex<_Tp>
1206 __complex_tan(const complex<_Tp>& __z)
1207 { return std::sin(__z) / std::cos(__z); }
1208
1209#if _GLIBCXX_USE_C99_COMPLEX
1210 inline __complex__ float
1211 __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }
1212
1213 inline __complex__ double
1214 __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }
1215
1216 inline __complex__ long double
1217 __complex_tan(const __complex__ long double& __z)
1218 { return __builtin_ctanl(__z); }
1219
1220 template<typename _Tp>
1221 inline complex<_Tp>
1222 tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
1223#else
1224 template<typename _Tp>
1225 inline complex<_Tp>
1226 tan(const complex<_Tp>& __z) { return __complex_tan(__z); }
1227#endif
1228
1229
1230 // 26.2.8/15 tanh(__z): Returns the hyperbolic tangent of __z.
1231
1232 template<typename _Tp>
1233 inline complex<_Tp>
1234 __complex_tanh(const complex<_Tp>& __z)
1235 { return std::sinh(__z) / std::cosh(__z); }
1236
1237#if _GLIBCXX_USE_C99_COMPLEX
1238 inline __complex__ float
1239 __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }
1240
1241 inline __complex__ double
1242 __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }
1243
1244 inline __complex__ long double
1245 __complex_tanh(const __complex__ long double& __z)
1246 { return __builtin_ctanhl(__z); }
1247
1248 template<typename _Tp>
1249 inline complex<_Tp>
1250 tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
1251#else
1252 template<typename _Tp>
1253 inline complex<_Tp>
1254 tanh(const complex<_Tp>& __z) { return __complex_tanh(__z); }
1255#endif
1256
1257
1258 // 26.2.8/9 pow(__x, __y): Returns the complex power base of __x
1259 // raised to the __y-th power. The branch
1260 // cut is on the negative axis.
1261 template<typename _Tp>
1262 complex<_Tp>
1263 __complex_pow_unsigned(complex<_Tp> __x, unsigned __n)
1264 {
1265 complex<_Tp> __y = __n % 2 ? __x : complex<_Tp>(1);
1266
1267 while (__n >>= 1)
1268 {
1269 __x *= __x;
1270 if (__n % 2)
1271 __y *= __x;
1272 }
1273
1274 return __y;
1275 }
1276
1277 // In C++11 mode we used to implement the resolution of
1278 // DR 844. complex pow return type is ambiguous.
1279 // thus the following overload was disabled in that mode. However, doing
1280 // that causes all sorts of issues, see, for example:
1281 // http://gcc.gnu.org/ml/libstdc++/2013-01/msg00058.html
1282 // and also PR57974.
1283 template<typename _Tp>
1284 inline complex<_Tp>
1285 pow(const complex<_Tp>& __z, int __n)
1286 {
1287 return __n < 0
1288 ? complex<_Tp>(1) / std::__complex_pow_unsigned(__z, -(unsigned)__n)
1289 : std::__complex_pow_unsigned(__z, __n);
1290 }
1291
1292 template<typename _Tp>
1293 complex<_Tp>
1294 pow(const complex<_Tp>& __x, const _Tp& __y)
1295 {
1296#if ! _GLIBCXX_USE_C99_COMPLEX
1297 if (__x == _Tp())
1298 return _Tp();
1299#endif
1300 if (__x.imag() == _Tp() && __x.real() > _Tp())
1301 return pow(__x.real(), __y);
1302
1303 complex<_Tp> __t = std::log(__x);
1304 return std::polar<_Tp>(exp(__y * __t.real()), __y * __t.imag());
1305 }
1306
1307 template<typename _Tp>
1308 inline complex<_Tp>
1309 __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1310 { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
1311
1312#if _GLIBCXX_USE_C99_COMPLEX
1313 inline __complex__ float
1314 __complex_pow(__complex__ float __x, __complex__ float __y)
1315 { return __builtin_cpowf(__x, __y); }
1316
1317 inline __complex__ double
1318 __complex_pow(__complex__ double __x, __complex__ double __y)
1319 { return __builtin_cpow(__x, __y); }
1320
1321 inline __complex__ long double
1322 __complex_pow(const __complex__ long double& __x,
1323 const __complex__ long double& __y)
1324 { return __builtin_cpowl(__x, __y); }
1325
1326 template<typename _Tp>
1327 inline complex<_Tp>
1328 pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1329 { return __complex_pow(__x.__rep(), __y.__rep()); }
1330#else
1331 template<typename _Tp>
1332 inline complex<_Tp>
1333 pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1334 { return __complex_pow(__x, __y); }
1335#endif
1336
1337 template<typename _Tp>
1338 inline complex<_Tp>
1339 pow(const _Tp& __x, const complex<_Tp>& __y)
1340 {
1341 return __x > _Tp() ? std::polar<_Tp>(pow(__x, __y.real()),
1342 __y.imag() * log(__x))
1343 : std::pow(complex<_Tp>(__x), __y);
1344 }
1345
1346 /// 26.2.3 complex specializations
1347 /// complex<float> specialization
1348 template<>
1349 class complex<float>
1350 {
1351 public:
1352 typedef float value_type;
1353 typedef __complex__ float _ComplexT;
1354
1355 _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1356
1357 _GLIBCXX_CONSTEXPR complex(float __r = 0.0f, float __i = 0.0f)
1358#if __cplusplus >= 201103L
1359 : _M_value{ __r, __i } { }
1360#else
1361 {
1362 __real__ _M_value = __r;
1363 __imag__ _M_value = __i;
1364 }
1365#endif
1366
1367#if __cplusplus >= 201103L
1368 _GLIBCXX14_CONSTEXPR complex(const complex&) = default;
1369#endif
1370
1371#if __cplusplus > 202002L
1372 template<typename _Up>
1373 explicit(!requires(_Up __u) { value_type{__u}; })
1374 constexpr complex(const complex<_Up>& __z)
1375 : _M_value{ value_type(__z.real()), value_type(__z.imag()) } { }
1376#else
1377 explicit _GLIBCXX_CONSTEXPR complex(const complex<double>&);
1378 explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
1379#endif
1380
1381#if __cplusplus >= 201103L
1382 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1383 // DR 387. std::complex over-encapsulated.
1384 __attribute ((__abi_tag__ ("cxx11")))
1385 constexpr float
1386 real() const { return __real__ _M_value; }
1387
1388 __attribute ((__abi_tag__ ("cxx11")))
1389 constexpr float
1390 imag() const { return __imag__ _M_value; }
1391#else
1392 float&
1393 real() { return __real__ _M_value; }
1394
1395 const float&
1396 real() const { return __real__ _M_value; }
1397
1398 float&
1399 imag() { return __imag__ _M_value; }
1400
1401 const float&
1402 imag() const { return __imag__ _M_value; }
1403#endif
1404
1405 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1406 // DR 387. std::complex over-encapsulated.
1407 _GLIBCXX20_CONSTEXPR void
1408 real(float __val) { __real__ _M_value = __val; }
1409
1410 _GLIBCXX20_CONSTEXPR void
1411 imag(float __val) { __imag__ _M_value = __val; }
1412
1413 _GLIBCXX20_CONSTEXPR complex&
1414 operator=(float __f)
1415 {
1416 _M_value = __f;
1417 return *this;
1418 }
1419
1420 _GLIBCXX20_CONSTEXPR complex&
1421 operator+=(float __f)
1422 {
1423 _M_value += __f;
1424 return *this;
1425 }
1426
1427 _GLIBCXX20_CONSTEXPR complex&
1428 operator-=(float __f)
1429 {
1430 _M_value -= __f;
1431 return *this;
1432 }
1433
1434 _GLIBCXX20_CONSTEXPR complex&
1435 operator*=(float __f)
1436 {
1437 _M_value *= __f;
1438 return *this;
1439 }
1440
1441 _GLIBCXX20_CONSTEXPR complex&
1442 operator/=(float __f)
1443 {
1444 _M_value /= __f;
1445 return *this;
1446 }
1447
1448 // Let the compiler synthesize the copy and assignment
1449 // operator. It always does a pretty good job.
1450#if __cplusplus >= 201103L
1451 _GLIBCXX14_CONSTEXPR complex& operator=(const complex&) = default;
1452#endif
1453
1454 template<typename _Tp>
1455 _GLIBCXX20_CONSTEXPR complex&
1456 operator=(const complex<_Tp>& __z)
1457 {
1458 __real__ _M_value = __z.real();
1459 __imag__ _M_value = __z.imag();
1460 return *this;
1461 }
1462
1463 template<typename _Tp>
1464 _GLIBCXX20_CONSTEXPR complex&
1465 operator+=(const complex<_Tp>& __z)
1466 {
1467 _M_value += __z.__rep();
1468 return *this;
1469 }
1470
1471 template<class _Tp>
1472 _GLIBCXX20_CONSTEXPR complex&
1473 operator-=(const complex<_Tp>& __z)
1474 {
1475 _M_value -= __z.__rep();
1476 return *this;
1477 }
1478
1479 template<class _Tp>
1480 _GLIBCXX20_CONSTEXPR complex&
1481 operator*=(const complex<_Tp>& __z)
1482 {
1483 const _ComplexT __t = __z.__rep();
1484 _M_value *= __t;
1485 return *this;
1486 }
1487
1488 template<class _Tp>
1489 _GLIBCXX20_CONSTEXPR complex&
1490 operator/=(const complex<_Tp>& __z)
1491 {
1492 const _ComplexT __t = __z.__rep();
1493 _M_value /= __t;
1494 return *this;
1495 }
1496
1497 _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1498
1499 private:
1500 _ComplexT _M_value;
1501 };
1502
1503 /// 26.2.3 complex specializations
1504 /// complex<double> specialization
1505 template<>
1506 class complex<double>
1507 {
1508 public:
1509 typedef double value_type;
1510 typedef __complex__ double _ComplexT;
1511
1512 _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1513
1514 _GLIBCXX_CONSTEXPR complex(double __r = 0.0, double __i = 0.0)
1515#if __cplusplus >= 201103L
1516 : _M_value{ __r, __i } { }
1517#else
1518 {
1519 __real__ _M_value = __r;
1520 __imag__ _M_value = __i;
1521 }
1522#endif
1523
1524#if __cplusplus >= 201103L
1525 _GLIBCXX14_CONSTEXPR complex(const complex&) = default;
1526#endif
1527
1528#if __cplusplus > 202002L
1529 template<typename _Up>
1530 explicit(!requires(_Up __u) { value_type{__u}; })
1531 constexpr complex(const complex<_Up>& __z)
1532 : _M_value{ value_type(__z.real()), value_type(__z.imag()) } { }
1533#else
1534 _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
1535 : _M_value(__z.__rep()) { }
1536
1537 explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
1538#endif
1539
1540#if __cplusplus >= 201103L
1541 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1542 // DR 387. std::complex over-encapsulated.
1543 __attribute ((__abi_tag__ ("cxx11")))
1544 constexpr double
1545 real() const { return __real__ _M_value; }
1546
1547 __attribute ((__abi_tag__ ("cxx11")))
1548 constexpr double
1549 imag() const { return __imag__ _M_value; }
1550#else
1551 double&
1552 real() { return __real__ _M_value; }
1553
1554 const double&
1555 real() const { return __real__ _M_value; }
1556
1557 double&
1558 imag() { return __imag__ _M_value; }
1559
1560 const double&
1561 imag() const { return __imag__ _M_value; }
1562#endif
1563
1564 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1565 // DR 387. std::complex over-encapsulated.
1566 _GLIBCXX20_CONSTEXPR void
1567 real(double __val) { __real__ _M_value = __val; }
1568
1569 _GLIBCXX20_CONSTEXPR void
1570 imag(double __val) { __imag__ _M_value = __val; }
1571
1572 _GLIBCXX20_CONSTEXPR complex&
1573 operator=(double __d)
1574 {
1575 _M_value = __d;
1576 return *this;
1577 }
1578
1579 _GLIBCXX20_CONSTEXPR complex&
1580 operator+=(double __d)
1581 {
1582 _M_value += __d;
1583 return *this;
1584 }
1585
1586 _GLIBCXX20_CONSTEXPR complex&
1587 operator-=(double __d)
1588 {
1589 _M_value -= __d;
1590 return *this;
1591 }
1592
1593 _GLIBCXX20_CONSTEXPR complex&
1594 operator*=(double __d)
1595 {
1596 _M_value *= __d;
1597 return *this;
1598 }
1599
1600 _GLIBCXX20_CONSTEXPR complex&
1601 operator/=(double __d)
1602 {
1603 _M_value /= __d;
1604 return *this;
1605 }
1606
1607 // The compiler will synthesize this, efficiently.
1608#if __cplusplus >= 201103L
1609 _GLIBCXX14_CONSTEXPR complex& operator=(const complex&) = default;
1610#endif
1611
1612 template<typename _Tp>
1613 _GLIBCXX20_CONSTEXPR complex&
1614 operator=(const complex<_Tp>& __z)
1615 {
1616 _M_value = __z.__rep();
1617 return *this;
1618 }
1619
1620 template<typename _Tp>
1621 _GLIBCXX20_CONSTEXPR complex&
1622 operator+=(const complex<_Tp>& __z)
1623 {
1624 _M_value += __z.__rep();
1625 return *this;
1626 }
1627
1628 template<typename _Tp>
1629 _GLIBCXX20_CONSTEXPR complex&
1630 operator-=(const complex<_Tp>& __z)
1631 {
1632 _M_value -= __z.__rep();
1633 return *this;
1634 }
1635
1636 template<typename _Tp>
1637 _GLIBCXX20_CONSTEXPR complex&
1638 operator*=(const complex<_Tp>& __z)
1639 {
1640 const _ComplexT __t = __z.__rep();
1641 _M_value *= __t;
1642 return *this;
1643 }
1644
1645 template<typename _Tp>
1646 _GLIBCXX20_CONSTEXPR complex&
1647 operator/=(const complex<_Tp>& __z)
1648 {
1649 const _ComplexT __t = __z.__rep();
1650 _M_value /= __t;
1651 return *this;
1652 }
1653
1654 _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1655
1656 private:
1657 _ComplexT _M_value;
1658 };
1659
1660 /// 26.2.3 complex specializations
1661 /// complex<long double> specialization
1662 template<>
1663 class complex<long double>
1664 {
1665 public:
1666 typedef long double value_type;
1667 typedef __complex__ long double _ComplexT;
1668
1669 _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1670
1671 _GLIBCXX_CONSTEXPR complex(long double __r = 0.0L,
1672 long double __i = 0.0L)
1673#if __cplusplus >= 201103L
1674 : _M_value{ __r, __i } { }
1675#else
1676 {
1677 __real__ _M_value = __r;
1678 __imag__ _M_value = __i;
1679 }
1680#endif
1681
1682#if __cplusplus >= 201103L
1683 _GLIBCXX14_CONSTEXPR complex(const complex&) = default;
1684#endif
1685
1686#if __cplusplus > 202002L
1687 template<typename _Up>
1688 explicit(!requires(_Up __u) { value_type{__u}; })
1689 constexpr complex(const complex<_Up>& __z)
1690 : _M_value{ value_type(__z.real()), value_type(__z.imag()) } { }
1691#else
1692 _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
1693 : _M_value(__z.__rep()) { }
1694
1695 _GLIBCXX_CONSTEXPR complex(const complex<double>& __z)
1696 : _M_value(__z.__rep()) { }
1697#endif
1698
1699#if __cplusplus >= 201103L
1700 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1701 // DR 387. std::complex over-encapsulated.
1702 __attribute ((__abi_tag__ ("cxx11")))
1703 constexpr long double
1704 real() const { return __real__ _M_value; }
1705
1706 __attribute ((__abi_tag__ ("cxx11")))
1707 constexpr long double
1708 imag() const { return __imag__ _M_value; }
1709#else
1710 long double&
1711 real() { return __real__ _M_value; }
1712
1713 const long double&
1714 real() const { return __real__ _M_value; }
1715
1716 long double&
1717 imag() { return __imag__ _M_value; }
1718
1719 const long double&
1720 imag() const { return __imag__ _M_value; }
1721#endif
1722
1723 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1724 // DR 387. std::complex over-encapsulated.
1725 _GLIBCXX20_CONSTEXPR void
1726 real(long double __val) { __real__ _M_value = __val; }
1727
1728 _GLIBCXX20_CONSTEXPR void
1729 imag(long double __val) { __imag__ _M_value = __val; }
1730
1731 _GLIBCXX20_CONSTEXPR complex&
1732 operator=(long double __r)
1733 {
1734 _M_value = __r;
1735 return *this;
1736 }
1737
1738 _GLIBCXX20_CONSTEXPR complex&
1739 operator+=(long double __r)
1740 {
1741 _M_value += __r;
1742 return *this;
1743 }
1744
1745 _GLIBCXX20_CONSTEXPR complex&
1746 operator-=(long double __r)
1747 {
1748 _M_value -= __r;
1749 return *this;
1750 }
1751
1752 _GLIBCXX20_CONSTEXPR complex&
1753 operator*=(long double __r)
1754 {
1755 _M_value *= __r;
1756 return *this;
1757 }
1758
1759 _GLIBCXX20_CONSTEXPR complex&
1760 operator/=(long double __r)
1761 {
1762 _M_value /= __r;
1763 return *this;
1764 }
1765
1766 // The compiler knows how to do this efficiently
1767#if __cplusplus >= 201103L
1768 _GLIBCXX14_CONSTEXPR complex& operator=(const complex&) = default;
1769#endif
1770
1771 template<typename _Tp>
1772 _GLIBCXX20_CONSTEXPR complex&
1773 operator=(const complex<_Tp>& __z)
1774 {
1775 _M_value = __z.__rep();
1776 return *this;
1777 }
1778
1779 template<typename _Tp>
1780 _GLIBCXX20_CONSTEXPR complex&
1781 operator+=(const complex<_Tp>& __z)
1782 {
1783 _M_value += __z.__rep();
1784 return *this;
1785 }
1786
1787 template<typename _Tp>
1788 _GLIBCXX20_CONSTEXPR complex&
1789 operator-=(const complex<_Tp>& __z)
1790 {
1791 _M_value -= __z.__rep();
1792 return *this;
1793 }
1794
1795 template<typename _Tp>
1796 _GLIBCXX20_CONSTEXPR complex&
1797 operator*=(const complex<_Tp>& __z)
1798 {
1799 const _ComplexT __t = __z.__rep();
1800 _M_value *= __t;
1801 return *this;
1802 }
1803
1804 template<typename _Tp>
1805 _GLIBCXX20_CONSTEXPR complex&
1806 operator/=(const complex<_Tp>& __z)
1807 {
1808 const _ComplexT __t = __z.__rep();
1809 _M_value /= __t;
1810 return *this;
1811 }
1812
1813 _GLIBCXX_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1814
1815 private:
1816 _ComplexT _M_value;
1817 };
1818
1819#if __cplusplus > 202002L
1820 template<typename _Tp>
1821 struct __complex_type
1822 { };
1823
1824#ifdef __STDCPP_FLOAT16_T__
1825 template<>
1826 struct __complex_type<_Float16>
1827 { typedef __complex__ _Float16 type; };
1828#endif
1829
1830#ifdef __STDCPP_FLOAT32_T__
1831 template<>
1832 struct __complex_type<_Float32>
1833 { typedef __complex__ _Float32 type; };
1834#endif
1835
1836#ifdef __STDCPP_FLOAT64_T__
1837 template<>
1838 struct __complex_type<_Float64>
1839 { typedef __complex__ _Float64 type; };
1840#endif
1841
1842#ifdef __STDCPP_FLOAT128_T__
1843 template<>
1844 struct __complex_type<_Float128>
1845 { typedef __complex__ _Float128 type; };
1846#endif
1847
1848#ifdef __STDCPP_BFLOAT16_T__
1849 template<>
1850 struct __complex_type<__gnu_cxx::__bfloat16_t>
1851 { typedef __complex__ decltype(0.0bf16) type; };
1852#endif
1853
1854 template<typename _Tp>
1855 requires requires { typename __complex_type<_Tp>::type; }
1856 class complex<_Tp>
1857 {
1858 public:
1859 typedef _Tp value_type;
1860 typedef typename std::__complex_type<_Tp>::type _ComplexT;
1861
1862 constexpr complex(_ComplexT __z) : _M_value(__z) { }
1863
1864 constexpr complex(_Tp __r = _Tp(), _Tp __i = _Tp())
1865 : _M_value{ __r, __i } { }
1866
1867 template<typename _Up>
1868 explicit(!requires(_Up __u) { value_type{__u}; })
1869 constexpr complex(const complex<_Up>& __z)
1870 : _M_value{ value_type(__z.real()), value_type(__z.imag()) } { }
1871
1872 constexpr _Tp
1873 real() const { return __real__ _M_value; }
1874
1875 constexpr _Tp
1876 imag() const { return __imag__ _M_value; }
1877
1878 constexpr void
1879 real(_Tp __val) { __real__ _M_value = __val; }
1880
1881 constexpr void
1882 imag(_Tp __val) { __imag__ _M_value = __val; }
1883
1884 constexpr complex&
1885 operator=(_Tp __f)
1886 {
1887 _M_value = __f;
1888 return *this;
1889 }
1890
1891 constexpr complex&
1892 operator+=(_Tp __f)
1893 {
1894 _M_value += __f;
1895 return *this;
1896 }
1897
1898 constexpr complex&
1899 operator-=(_Tp __f)
1900 {
1901 _M_value -= __f;
1902 return *this;
1903 }
1904
1905 constexpr complex&
1906 operator*=(_Tp __f)
1907 {
1908 _M_value *= __f;
1909 return *this;
1910 }
1911
1912 constexpr complex&
1913 operator/=(_Tp __f)
1914 {
1915 _M_value /= __f;
1916 return *this;
1917 }
1918
1919 // Let the compiler synthesize the copy and assignment
1920 // operator. It always does a pretty good job.
1921 constexpr complex(const complex&) = default;
1922 constexpr complex& operator=(const complex&) = default;
1923
1924 template<typename _Up>
1925 constexpr complex&
1926 operator=(const complex<_Up>& __z)
1927 {
1928 __real__ _M_value = __z.real();
1929 __imag__ _M_value = __z.imag();
1930 return *this;
1931 }
1932
1933 template<typename _Up>
1934 constexpr complex&
1935 operator+=(const complex<_Up>& __z)
1936 {
1937 _M_value += __z.__rep();
1938 return *this;
1939 }
1940
1941 template<class _Up>
1942 constexpr complex&
1943 operator-=(const complex<_Up>& __z)
1944 {
1945 _M_value -= __z.__rep();
1946 return *this;
1947 }
1948
1949 template<class _Up>
1950 constexpr complex&
1951 operator*=(const complex<_Up>& __z)
1952 {
1953 const _ComplexT __t = __z.__rep();
1954 _M_value *= __t;
1955 return *this;
1956 }
1957
1958 template<class _Up>
1959 constexpr complex&
1960 operator/=(const complex<_Up>& __z)
1961 {
1962 const _ComplexT __t = __z.__rep();
1963 _M_value /= __t;
1964 return *this;
1965 }
1966
1967 constexpr _ComplexT __rep() const { return _M_value; }
1968
1969 private:
1970 _ComplexT _M_value;
1971 };
1972#endif
1973
1974#if __cplusplus <= 202002L
1975 // These bits have to be at the end of this file, so that the
1976 // specializations have all been defined.
1977 inline _GLIBCXX_CONSTEXPR
1978 complex<float>::complex(const complex<double>& __z)
1979 : _M_value(__z.__rep()) { }
1980
1981 inline _GLIBCXX_CONSTEXPR
1982 complex<float>::complex(const complex<long double>& __z)
1983 : _M_value(__z.__rep()) { }
1984
1985 inline _GLIBCXX_CONSTEXPR
1986 complex<double>::complex(const complex<long double>& __z)
1987 : _M_value(__z.__rep()) { }
1988#endif
1989
1990 // Inhibit implicit instantiations for required instantiations,
1991 // which are defined via explicit instantiations elsewhere.
1992 // NB: This syntax is a GNU extension.
1993#if _GLIBCXX_EXTERN_TEMPLATE
1994 extern template istream& operator>>(istream&, complex<float>&);
1995 extern template ostream& operator<<(ostream&, const complex<float>&);
1996 extern template istream& operator>>(istream&, complex<double>&);
1997 extern template ostream& operator<<(ostream&, const complex<double>&);
1998 extern template istream& operator>>(istream&, complex<long double>&);
1999 extern template ostream& operator<<(ostream&, const complex<long double>&);
2000
2001#ifdef _GLIBCXX_USE_WCHAR_T
2002 extern template wistream& operator>>(wistream&, complex<float>&);
2003 extern template wostream& operator<<(wostream&, const complex<float>&);
2004 extern template wistream& operator>>(wistream&, complex<double>&);
2005 extern template wostream& operator<<(wostream&, const complex<double>&);
2006 extern template wistream& operator>>(wistream&, complex<long double>&);
2007 extern template wostream& operator<<(wostream&, const complex<long double>&);
2008#endif
2009#endif
2010
2011 /// @} group complex_numbers
2012
2013_GLIBCXX_END_NAMESPACE_VERSION
2014} // namespace
2015
2016#if __cplusplus >= 201103L
2017
2018namespace std _GLIBCXX_VISIBILITY(default)
2019{
2020_GLIBCXX_BEGIN_NAMESPACE_VERSION
2021
2022 // Forward declarations.
2023 template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
2024 template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
2025 template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);
2026
2027 template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
2028 template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
2029 template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);
2030 // DR 595.
2031 template<typename _Tp> _Tp fabs(const std::complex<_Tp>&);
2032
2033 template<typename _Tp>
2034 inline std::complex<_Tp>
2035 __complex_acos(const std::complex<_Tp>& __z)
2036 {
2037 const std::complex<_Tp> __t = std::asin(__z);
2038 const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
2039 return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
2040 }
2041
2042#if _GLIBCXX_USE_C99_COMPLEX_ARC
2043#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2044 inline __complex__ _Float16
2045 __complex_acos(__complex__ _Float16 __z)
2046 { return static_cast<__complex__ _Float16>(__builtin_cacosf(__z)); }
2047
2048 inline __complex__ _Float16
2049 __complex_asin(__complex__ _Float16 __z)
2050 { return static_cast<__complex__ _Float16>(__builtin_casinf(__z)); }
2051
2052 inline __complex__ _Float16
2053 __complex_atan(__complex__ _Float16 __z)
2054 { return static_cast<__complex__ _Float16>(__builtin_catanf(__z)); }
2055
2056 inline __complex__ _Float16
2057 __complex_acosh(__complex__ _Float16 __z)
2058 { return static_cast<__complex__ _Float16>(__builtin_cacoshf(__z)); }
2059
2060 inline __complex__ _Float16
2061 __complex_asinh(__complex__ _Float16 __z)
2062 { return static_cast<__complex__ _Float16>(__builtin_casinhf(__z)); }
2063
2064 inline __complex__ _Float16
2065 __complex_atanh(__complex__ _Float16 __z)
2066 { return static_cast<__complex__ _Float16>(__builtin_catanhf(__z)); }
2067#endif
2068
2069#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2070 inline __complex__ _Float32
2071 __complex_acos(__complex__ _Float32 __z)
2072 { return __builtin_cacosf(__z); }
2073
2074 inline __complex__ _Float32
2075 __complex_asin(__complex__ _Float32 __z)
2076 { return __builtin_casinf(__z); }
2077
2078 inline __complex__ _Float32
2079 __complex_atan(__complex__ _Float32 __z)
2080 { return __builtin_catanf(__z); }
2081
2082 inline __complex__ _Float32
2083 __complex_acosh(__complex__ _Float32 __z)
2084 { return __builtin_cacoshf(__z); }
2085
2086 inline __complex__ _Float32
2087 __complex_asinh(__complex__ _Float32 __z)
2088 { return __builtin_casinhf(__z); }
2089
2090 inline __complex__ _Float32
2091 __complex_atanh(__complex__ _Float32 __z)
2092 { return __builtin_catanhf(__z); }
2093#endif
2094
2095#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
2096 inline __complex__ _Float64
2097 __complex_acos(__complex__ _Float64 __z)
2098 { return __builtin_cacos(__z); }
2099
2100 inline __complex__ _Float64
2101 __complex_asin(__complex__ _Float64 __z)
2102 { return __builtin_casin(__z); }
2103
2104 inline __complex__ _Float64
2105 __complex_atan(__complex__ _Float64 __z)
2106 { return __builtin_catan(__z); }
2107
2108 inline __complex__ _Float64
2109 __complex_acosh(__complex__ _Float64 __z)
2110 { return __builtin_cacosh(__z); }
2111
2112 inline __complex__ _Float64
2113 __complex_asinh(__complex__ _Float64 __z)
2114 { return __builtin_casinh(__z); }
2115
2116 inline __complex__ _Float64
2117 __complex_atanh(__complex__ _Float64 __z)
2118 { return __builtin_catanh(__z); }
2119#endif
2120
2121#if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
2122 inline __complex__ _Float128
2123 __complex_acos(__complex__ _Float128 __z)
2124 { return __builtin_cacosl(__z); }
2125
2126 inline __complex__ _Float128
2127 __complex_asin(__complex__ _Float128 __z)
2128 { return __builtin_casinl(__z); }
2129
2130 inline __complex__ _Float128
2131 __complex_atan(__complex__ _Float128 __z)
2132 { return __builtin_catanl(__z); }
2133
2134 inline __complex__ _Float128
2135 __complex_acosh(__complex__ _Float128 __z)
2136 { return __builtin_cacoshl(__z); }
2137
2138 inline __complex__ _Float128
2139 __complex_asinh(__complex__ _Float128 __z)
2140 { return __builtin_casinhl(__z); }
2141
2142 inline __complex__ _Float128
2143 __complex_atanh(__complex__ _Float128 __z)
2144 { return __builtin_catanhl(__z); }
2145#elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
2146 inline __complex__ _Float128
2147 __complex_acos(__complex__ _Float128 __z)
2148 { return __builtin_cacosf128(__z); }
2149
2150 inline __complex__ _Float128
2151 __complex_asin(__complex__ _Float128 __z)
2152 { return __builtin_casinf128(__z); }
2153
2154 inline __complex__ _Float128
2155 __complex_atan(__complex__ _Float128 __z)
2156 { return __builtin_catanf128(__z); }
2157
2158 inline __complex__ _Float128
2159 __complex_acosh(__complex__ _Float128 __z)
2160 { return __builtin_cacoshf128(__z); }
2161
2162 inline __complex__ _Float128
2163 __complex_asinh(__complex__ _Float128 __z)
2164 { return __builtin_casinhf128(__z); }
2165
2166 inline __complex__ _Float128
2167 __complex_atanh(__complex__ _Float128 __z)
2168 { return __builtin_catanhf128(__z); }
2169#endif
2170
2171#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2172 inline __complex__ decltype(0.0bf16)
2173 __complex_acos(__complex__ decltype(0.0bf16) __z)
2174 { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_cacosf(__z)); }
2175
2176 inline __complex__ decltype(0.0bf16)
2177 __complex_asin(__complex__ decltype(0.0bf16) __z)
2178 { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_casinf(__z)); }
2179
2180 inline __complex__ decltype(0.0bf16)
2181 __complex_atan(__complex__ decltype(0.0bf16) __z)
2182 { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_catanf(__z)); }
2183
2184 inline __complex__ decltype(0.0bf16)
2185 __complex_acosh(__complex__ decltype(0.0bf16) __z)
2186 { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_cacoshf(__z)); }
2187
2188 inline __complex__ decltype(0.0bf16)
2189 __complex_asinh(__complex__ decltype(0.0bf16) __z)
2190 { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_casinhf(__z)); }
2191
2192 inline __complex__ decltype(0.0bf16)
2193 __complex_atanh(__complex__ decltype(0.0bf16) __z)
2194 { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_catanhf(__z)); }
2195#endif
2196#endif
2197
2198#if _GLIBCXX_USE_C99_COMPLEX_ARC
2199 inline __complex__ float
2200 __complex_acos(__complex__ float __z)
2201 { return __builtin_cacosf(__z); }
2202
2203 inline __complex__ double
2204 __complex_acos(__complex__ double __z)
2205 { return __builtin_cacos(__z); }
2206
2207 inline __complex__ long double
2208 __complex_acos(const __complex__ long double& __z)
2209 { return __builtin_cacosl(__z); }
2210
2211 template<typename _Tp>
2212 inline std::complex<_Tp>
2213 acos(const std::complex<_Tp>& __z)
2214 { return __complex_acos(__z.__rep()); }
2215#else
2216 /// acos(__z) [8.1.2].
2217 // Effects: Behaves the same as C99 function cacos, defined
2218 // in subclause 7.3.5.1.
2219 template<typename _Tp>
2220 inline std::complex<_Tp>
2221 acos(const std::complex<_Tp>& __z)
2222 { return __complex_acos(__z); }
2223#endif
2224
2225 template<typename _Tp>
2226 inline std::complex<_Tp>
2227 __complex_asin(const std::complex<_Tp>& __z)
2228 {
2229 std::complex<_Tp> __t(-__z.imag(), __z.real());
2230 __t = std::asinh(__t);
2231 return std::complex<_Tp>(__t.imag(), -__t.real());
2232 }
2233
2234#if _GLIBCXX_USE_C99_COMPLEX_ARC
2235 inline __complex__ float
2236 __complex_asin(__complex__ float __z)
2237 { return __builtin_casinf(__z); }
2238
2239 inline __complex__ double
2240 __complex_asin(__complex__ double __z)
2241 { return __builtin_casin(__z); }
2242
2243 inline __complex__ long double
2244 __complex_asin(const __complex__ long double& __z)
2245 { return __builtin_casinl(__z); }
2246
2247 template<typename _Tp>
2248 inline std::complex<_Tp>
2249 asin(const std::complex<_Tp>& __z)
2250 { return __complex_asin(__z.__rep()); }
2251#else
2252 /// asin(__z) [8.1.3].
2253 // Effects: Behaves the same as C99 function casin, defined
2254 // in subclause 7.3.5.2.
2255 template<typename _Tp>
2256 inline std::complex<_Tp>
2257 asin(const std::complex<_Tp>& __z)
2258 { return __complex_asin(__z); }
2259#endif
2260
2261 template<typename _Tp>
2263 __complex_atan(const std::complex<_Tp>& __z)
2264 {
2265 const _Tp __r2 = __z.real() * __z.real();
2266 const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
2267
2268 _Tp __num = __z.imag() + _Tp(1.0);
2269 _Tp __den = __z.imag() - _Tp(1.0);
2270
2271 __num = __r2 + __num * __num;
2272 __den = __r2 + __den * __den;
2273
2274 return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
2275 _Tp(0.25) * log(__num / __den));
2276 }
2277
2278#if _GLIBCXX_USE_C99_COMPLEX_ARC
2279 inline __complex__ float
2280 __complex_atan(__complex__ float __z)
2281 { return __builtin_catanf(__z); }
2282
2283 inline __complex__ double
2284 __complex_atan(__complex__ double __z)
2285 { return __builtin_catan(__z); }
2286
2287 inline __complex__ long double
2288 __complex_atan(const __complex__ long double& __z)
2289 { return __builtin_catanl(__z); }
2290
2291 template<typename _Tp>
2292 inline std::complex<_Tp>
2293 atan(const std::complex<_Tp>& __z)
2294 { return __complex_atan(__z.__rep()); }
2295#else
2296 /// atan(__z) [8.1.4].
2297 // Effects: Behaves the same as C99 function catan, defined
2298 // in subclause 7.3.5.3.
2299 template<typename _Tp>
2300 inline std::complex<_Tp>
2301 atan(const std::complex<_Tp>& __z)
2302 { return __complex_atan(__z); }
2303#endif
2304
2305 template<typename _Tp>
2307 __complex_acosh(const std::complex<_Tp>& __z)
2308 {
2309 // Kahan's formula.
2310 return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0)))
2311 + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0))));
2312 }
2313
2314#if _GLIBCXX_USE_C99_COMPLEX_ARC
2315 inline __complex__ float
2316 __complex_acosh(__complex__ float __z)
2317 { return __builtin_cacoshf(__z); }
2318
2319 inline __complex__ double
2320 __complex_acosh(__complex__ double __z)
2321 { return __builtin_cacosh(__z); }
2322
2323 inline __complex__ long double
2324 __complex_acosh(const __complex__ long double& __z)
2325 { return __builtin_cacoshl(__z); }
2326
2327 template<typename _Tp>
2328 inline std::complex<_Tp>
2329 acosh(const std::complex<_Tp>& __z)
2330 { return __complex_acosh(__z.__rep()); }
2331#else
2332 /// acosh(__z) [8.1.5].
2333 // Effects: Behaves the same as C99 function cacosh, defined
2334 // in subclause 7.3.6.1.
2335 template<typename _Tp>
2336 inline std::complex<_Tp>
2337 acosh(const std::complex<_Tp>& __z)
2338 { return __complex_acosh(__z); }
2339#endif
2340
2341 template<typename _Tp>
2343 __complex_asinh(const std::complex<_Tp>& __z)
2344 {
2345 std::complex<_Tp> __t((__z.real() - __z.imag())
2346 * (__z.real() + __z.imag()) + _Tp(1.0),
2347 _Tp(2.0) * __z.real() * __z.imag());
2348 __t = std::sqrt(__t);
2349
2350 return std::log(__t + __z);
2351 }
2352
2353#if _GLIBCXX_USE_C99_COMPLEX_ARC
2354 inline __complex__ float
2355 __complex_asinh(__complex__ float __z)
2356 { return __builtin_casinhf(__z); }
2357
2358 inline __complex__ double
2359 __complex_asinh(__complex__ double __z)
2360 { return __builtin_casinh(__z); }
2361
2362 inline __complex__ long double
2363 __complex_asinh(const __complex__ long double& __z)
2364 { return __builtin_casinhl(__z); }
2365
2366 template<typename _Tp>
2367 inline std::complex<_Tp>
2368 asinh(const std::complex<_Tp>& __z)
2369 { return __complex_asinh(__z.__rep()); }
2370#else
2371 /// asinh(__z) [8.1.6].
2372 // Effects: Behaves the same as C99 function casin, defined
2373 // in subclause 7.3.6.2.
2374 template<typename _Tp>
2375 inline std::complex<_Tp>
2376 asinh(const std::complex<_Tp>& __z)
2377 { return __complex_asinh(__z); }
2378#endif
2379
2380 template<typename _Tp>
2382 __complex_atanh(const std::complex<_Tp>& __z)
2383 {
2384 const _Tp __i2 = __z.imag() * __z.imag();
2385 const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
2386
2387 _Tp __num = _Tp(1.0) + __z.real();
2388 _Tp __den = _Tp(1.0) - __z.real();
2389
2390 __num = __i2 + __num * __num;
2391 __den = __i2 + __den * __den;
2392
2393 return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
2394 _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
2395 }
2396
2397#if _GLIBCXX_USE_C99_COMPLEX_ARC
2398 inline __complex__ float
2399 __complex_atanh(__complex__ float __z)
2400 { return __builtin_catanhf(__z); }
2401
2402 inline __complex__ double
2403 __complex_atanh(__complex__ double __z)
2404 { return __builtin_catanh(__z); }
2405
2406 inline __complex__ long double
2407 __complex_atanh(const __complex__ long double& __z)
2408 { return __builtin_catanhl(__z); }
2409
2410 template<typename _Tp>
2411 inline std::complex<_Tp>
2412 atanh(const std::complex<_Tp>& __z)
2413 { return __complex_atanh(__z.__rep()); }
2414#else
2415 /// atanh(__z) [8.1.7].
2416 // Effects: Behaves the same as C99 function catanh, defined
2417 // in subclause 7.3.6.3.
2418 template<typename _Tp>
2419 inline std::complex<_Tp>
2420 atanh(const std::complex<_Tp>& __z)
2421 { return __complex_atanh(__z); }
2422#endif
2423
2424 template<typename _Tp>
2425 inline _Tp
2426 /// fabs(__z) [8.1.8].
2427 // Effects: Behaves the same as C99 function cabs, defined
2428 // in subclause 7.3.8.1.
2429 fabs(const std::complex<_Tp>& __z)
2430 { return std::abs(__z); }
2431
2432 /// Additional overloads [8.1.9].
2433 template<typename _Tp>
2434 inline typename __gnu_cxx::__promote<_Tp>::__type
2435 arg(_Tp __x)
2436 {
2437 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
2438#if (_GLIBCXX11_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC)
2439 return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L)
2440 : __type();
2441#else
2442 return std::arg(std::complex<__type>(__x));
2443#endif
2444 }
2445
2446 template<typename _Tp>
2447 _GLIBCXX_CONSTEXPR inline typename __gnu_cxx::__promote<_Tp>::__type
2448 imag(_Tp)
2449 { return _Tp(); }
2450
2451 template<typename _Tp>
2452 _GLIBCXX20_CONSTEXPR inline typename __gnu_cxx::__promote<_Tp>::__type
2453 norm(_Tp __x)
2454 {
2455 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
2456 return __type(__x) * __type(__x);
2457 }
2458
2459 template<typename _Tp>
2460 _GLIBCXX_CONSTEXPR inline typename __gnu_cxx::__promote<_Tp>::__type
2461 real(_Tp __x)
2462 { return __x; }
2463
2464 template<typename _Tp, typename _Up>
2466 pow(const std::complex<_Tp>& __x, const _Up& __y)
2467 {
2468 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
2469 return std::pow(std::complex<__type>(__x), __type(__y));
2470 }
2471
2472 template<typename _Tp, typename _Up>
2474 pow(const _Tp& __x, const std::complex<_Up>& __y)
2475 {
2476 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
2477 return std::pow(__type(__x), std::complex<__type>(__y));
2478 }
2479
2480 template<typename _Tp, typename _Up>
2482 pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
2483 {
2484 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
2485 return std::pow(std::complex<__type>(__x),
2487 }
2488
2489 // Forward declarations.
2490 // DR 781.
2491 template<typename _Tp>
2493
2494 // Generic implementation of std::proj, does not work for infinities.
2495 template<typename _Tp>
2496 inline std::complex<_Tp>
2497 __complex_proj(const std::complex<_Tp>& __z)
2498 { return __z; }
2499
2500#if _GLIBCXX_USE_C99_COMPLEX
2501 inline complex<float>
2502 __complex_proj(const complex<float>& __z)
2503 { return __builtin_cprojf(__z.__rep()); }
2504
2505 inline complex<double>
2506 __complex_proj(const complex<double>& __z)
2507 { return __builtin_cproj(__z.__rep()); }
2508
2509 inline complex<long double>
2510 __complex_proj(const complex<long double>& __z)
2511 { return __builtin_cprojl(__z.__rep()); }
2512
2513#if __cplusplus > 202002L
2514#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2515 inline __complex__ _Float16
2516 __complex_proj(__complex__ _Float16 __z)
2517 { return static_cast<__complex__ _Float16>(__builtin_cprojf(__z)); }
2518#endif
2519
2520#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2521 inline __complex__ _Float32
2522 __complex_proj(__complex__ _Float32 __z)
2523 { return __builtin_cprojf(__z); }
2524#endif
2525
2526#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
2527 inline __complex__ _Float64
2528 __complex_proj(__complex__ _Float64 __z)
2529 { return __builtin_cproj(__z); }
2530#endif
2531
2532#if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
2533 inline __complex__ _Float128
2534 __complex_proj(__complex__ _Float128 __z)
2535 { return __builtin_cprojl(__z); }
2536#elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
2537 inline __complex__ _Float128
2538 __complex_proj(__complex__ _Float128 __z)
2539 { return __builtin_cprojf128(__z); }
2540#endif
2541
2542#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2543 inline __complex__ decltype(0.0bf16)
2544 __complex_proj(__complex__ decltype(0.0bf16) __z)
2545 { return static_cast<__complex__ decltype(0.0bf16)>(__builtin_cprojf(__z)); }
2546#endif
2547
2548 template<typename _Tp>
2549 requires requires { typename __complex_type<_Tp>::type; }
2550 inline complex<_Tp>
2551 __complex_proj(const complex<_Tp>& __z)
2552 { return __complex_proj(__z.__rep()); }
2553#endif
2554
2555#elif defined _GLIBCXX_USE_C99_MATH_FUNCS
2556 inline complex<float>
2557 __complex_proj(const complex<float>& __z)
2558 {
2559 if (__builtin_isinf(__z.real()) || __builtin_isinf(__z.imag()))
2560 return complex<float>(__builtin_inff(),
2561 __builtin_copysignf(0.0f, __z.imag()));
2562 return __z;
2563 }
2564
2565 inline complex<double>
2566 __complex_proj(const complex<double>& __z)
2567 {
2568 if (__builtin_isinf(__z.real()) || __builtin_isinf(__z.imag()))
2569 return complex<double>(__builtin_inf(),
2570 __builtin_copysign(0.0, __z.imag()));
2571 return __z;
2572 }
2573
2574 inline complex<long double>
2575 __complex_proj(const complex<long double>& __z)
2576 {
2577 if (__builtin_isinf(__z.real()) || __builtin_isinf(__z.imag()))
2578 return complex<long double>(__builtin_infl(),
2579 __builtin_copysignl(0.0l, __z.imag()));
2580 return __z;
2581 }
2582#endif
2583
2584 template<typename _Tp>
2585 inline std::complex<_Tp>
2586 proj(const std::complex<_Tp>& __z)
2587 { return __complex_proj(__z); }
2588
2589 // Overload for scalars
2590 template<typename _Tp>
2592 proj(_Tp __x)
2593 {
2594 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
2595 return std::proj(std::complex<__type>(__x));
2596 }
2597
2598 template<typename _Tp>
2599 inline _GLIBCXX20_CONSTEXPR
2601 conj(_Tp __x)
2602 {
2603 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
2604 return std::complex<__type>(__x, -__type());
2605 }
2606
2607#ifdef __cpp_lib_complex_udls // C++ >= 14
2608
2609inline namespace literals {
2610inline namespace complex_literals {
2611#pragma GCC diagnostic push
2612#pragma GCC diagnostic ignored "-Wliteral-suffix"
2613
2614 constexpr std::complex<float>
2615 operator""if(long double __num)
2616 { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
2617
2618 constexpr std::complex<float>
2619 operator""if(unsigned long long __num)
2620 { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
2621
2622 constexpr std::complex<double>
2623 operator""i(long double __num)
2624 { return std::complex<double>{0.0, static_cast<double>(__num)}; }
2625
2626 constexpr std::complex<double>
2627 operator""i(unsigned long long __num)
2628 { return std::complex<double>{0.0, static_cast<double>(__num)}; }
2629
2631 operator""il(long double __num)
2632 { return std::complex<long double>{0.0L, __num}; }
2633
2635 operator""il(unsigned long long __num)
2636 { return std::complex<long double>{0.0L, static_cast<long double>(__num)}; }
2637
2638#pragma GCC diagnostic pop
2639} // inline namespace complex_literals
2640} // inline namespace literals
2641
2642#endif // __cpp_lib_complex_udls
2643
2644_GLIBCXX_END_NAMESPACE_VERSION
2645} // namespace
2646
2647#endif // C++11
2648
2649#ifdef __clang__
2650#pragma clang diagnostic pop
2651#endif
2652
2653#endif /* _GLIBCXX_COMPLEX */
complex< _Tp > log10(const complex< _Tp > &)
Return complex base 10 logarithm of z.
Definition complex:1095
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
Definition complex:400
complex< _Tp > sin(const complex< _Tp > &)
Return complex sine of z.
Definition complex:1125
constexpr complex< _Tp > operator-(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x minus y.
Definition complex:370
constexpr complex< _Tp > & operator*=(const _Tp &)
Multiply this complex number by a scalar.
Definition complex:259
complex< _Tp > log(const complex< _Tp > &)
Return complex natural logarithm of z.
Definition complex:1090
complex< _Tp > tan(const complex< _Tp > &)
Return complex tangent of z.
Definition complex:1226
complex< _Tp > polar(const _Tp &, const _Tp &=0)
Return complex with magnitude rho and angle theta.
Definition complex:967
constexpr complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
Definition complex:340
_Tp abs(const complex< _Tp > &)
Return magnitude of z.
Definition complex:896
complex< _Tp > exp(const complex< _Tp > &)
Return complex base e exponential of z.
Definition complex:1063
complex< _Tp > cosh(const complex< _Tp > &)
Return complex hyperbolic cosine of z.
Definition complex:1037
_Tp arg(const complex< _Tp > &)
Return phase angle of z.
Definition complex:923
constexpr complex< _Tp > & operator=(const _Tp &)
Assign a scalar to this complex number.
Definition complex:249
complex< _Tp > tanh(const complex< _Tp > &)
Return complex hyperbolic tangent of z.
Definition complex:1254
constexpr complex< _Tp > conj(const complex< _Tp > &)
Return complex conjugate of z.
Definition complex:975
complex< _Tp > pow(const complex< _Tp > &, int)
Return x to the y'th power.
Definition complex:1285
constexpr complex< _Tp > operator/(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x divided by y.
Definition complex:430
complex< _Tp > sinh(const complex< _Tp > &)
Return complex hyperbolic sine of z.
Definition complex:1155
_Tp constexpr norm(const complex< _Tp > &)
Return z magnitude squared.
Definition complex:959
constexpr complex< _Tp > & operator/=(const _Tp &)
Divide this complex number by a scalar.
Definition complex:269
complex< _Tp > cos(const complex< _Tp > &)
Return complex cosine of z.
Definition complex:1007
complex< _Tp > sqrt(const complex< _Tp > &)
Return complex square root of z.
Definition complex:1199
basic_ostream< char > ostream
Base class for char output streams.
Definition iosfwd:143
basic_istream< char > istream
Base class for char input streams.
Definition iosfwd:140
basic_ostream< wchar_t > wostream
Base class for wchar_t output streams.
Definition iosfwd:183
basic_istream< wchar_t > wistream
Base class for wchar_t input streams.
Definition iosfwd:180
constexpr const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
ISO C++ entities toplevel namespace is std.
std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, bitset< _Nb > &__x)
Global I/O operators for bitsets.
Definition bitset:1593
std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const bitset< _Nb > &__x)
Global I/O operators for bitsets.
Definition bitset:1683
GNU extensions for public use.
_Tp value_type
Value typedef.
Definition complex:136
constexpr complex(const _Tp &__r=_Tp(), const _Tp &__i=_Tp())
Default constructor. First parameter is x, second parameter is y. Unspecified parameters default to 0...
Definition complex:140
constexpr complex(const complex< _Up > &__z)
Converting constructor.
Definition complex:153
constexpr complex< _Tp > & operator-=(const _Tp &__t)
Subtract a scalar from this complex number.
Definition complex:207
constexpr complex< _Tp > & operator+=(const _Tp &__t)
Add a scalar to this complex number.
Definition complex:198
void setstate(iostate __state)
Sets additional flags in the error state.
Definition basic_ios.h:161
char_type widen(char __c) const
Widens characters.
Definition basic_ios.h:453
Template class basic_istream.
Definition istream:61
__istream_type & putback(char_type __c)
Unextracting a single character.
Definition istream.tcc:763
fmtflags flags() const
Access to format flags.
Definition ios_base.h:661
static const iostate failbit
Indicates that an input operation failed to read the expected characters, or that an output operation...
Definition ios_base.h:433