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

source code of include/c++/13/complex