master
1// -*- C++ -*-
2//===----------------------------------------------------------------------===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP_COMPLEX
11#define _LIBCPP_COMPLEX
12
13/*
14 complex synopsis
15
16namespace std
17{
18
19template<class T>
20class complex
21{
22public:
23 typedef T value_type;
24
25 complex(const T& re = T(), const T& im = T()); // constexpr in C++14
26 complex(const complex&); // constexpr in C++14
27 template<class X> complex(const complex<X>&); // constexpr in C++14
28
29 T real() const; // constexpr in C++14
30 T imag() const; // constexpr in C++14
31
32 void real(T); // constexpr in C++20
33 void imag(T); // constexpr in C++20
34
35 complex<T>& operator= (const T&); // constexpr in C++20
36 complex<T>& operator+=(const T&); // constexpr in C++20
37 complex<T>& operator-=(const T&); // constexpr in C++20
38 complex<T>& operator*=(const T&); // constexpr in C++20
39 complex<T>& operator/=(const T&); // constexpr in C++20
40
41 complex& operator=(const complex&); // constexpr in C++20
42 template<class X> complex<T>& operator= (const complex<X>&); // constexpr in C++20
43 template<class X> complex<T>& operator+=(const complex<X>&); // constexpr in C++20
44 template<class X> complex<T>& operator-=(const complex<X>&); // constexpr in C++20
45 template<class X> complex<T>& operator*=(const complex<X>&); // constexpr in C++20
46 template<class X> complex<T>& operator/=(const complex<X>&); // constexpr in C++20
47};
48
49template<>
50class complex<float>
51{
52public:
53 typedef float value_type;
54
55 constexpr complex(float re = 0.0f, float im = 0.0f);
56 explicit constexpr complex(const complex<double>&);
57 explicit constexpr complex(const complex<long double>&);
58
59 constexpr float real() const;
60 void real(float); // constexpr in C++20
61 constexpr float imag() const;
62 void imag(float); // constexpr in C++20
63
64 complex<float>& operator= (float); // constexpr in C++20
65 complex<float>& operator+=(float); // constexpr in C++20
66 complex<float>& operator-=(float); // constexpr in C++20
67 complex<float>& operator*=(float); // constexpr in C++20
68 complex<float>& operator/=(float); // constexpr in C++20
69
70 complex<float>& operator=(const complex<float>&); // constexpr in C++20
71 template<class X> complex<float>& operator= (const complex<X>&); // constexpr in C++20
72 template<class X> complex<float>& operator+=(const complex<X>&); // constexpr in C++20
73 template<class X> complex<float>& operator-=(const complex<X>&); // constexpr in C++20
74 template<class X> complex<float>& operator*=(const complex<X>&); // constexpr in C++20
75 template<class X> complex<float>& operator/=(const complex<X>&); // constexpr in C++20
76};
77
78template<>
79class complex<double>
80{
81public:
82 typedef double value_type;
83
84 constexpr complex(double re = 0.0, double im = 0.0);
85 constexpr complex(const complex<float>&);
86 explicit constexpr complex(const complex<long double>&);
87
88 constexpr double real() const;
89 void real(double); // constexpr in C++20
90 constexpr double imag() const;
91 void imag(double); // constexpr in C++20
92
93 complex<double>& operator= (double); // constexpr in C++20
94 complex<double>& operator+=(double); // constexpr in C++20
95 complex<double>& operator-=(double); // constexpr in C++20
96 complex<double>& operator*=(double); // constexpr in C++20
97 complex<double>& operator/=(double); // constexpr in C++20
98 complex<double>& operator=(const complex<double>&); // constexpr in C++20
99
100 template<class X> complex<double>& operator= (const complex<X>&); // constexpr in C++20
101 template<class X> complex<double>& operator+=(const complex<X>&); // constexpr in C++20
102 template<class X> complex<double>& operator-=(const complex<X>&); // constexpr in C++20
103 template<class X> complex<double>& operator*=(const complex<X>&); // constexpr in C++20
104 template<class X> complex<double>& operator/=(const complex<X>&); // constexpr in C++20
105};
106
107template<>
108class complex<long double>
109{
110public:
111 typedef long double value_type;
112
113 constexpr complex(long double re = 0.0L, long double im = 0.0L);
114 constexpr complex(const complex<float>&);
115 constexpr complex(const complex<double>&);
116
117 constexpr long double real() const;
118 void real(long double); // constexpr in C++20
119 constexpr long double imag() const;
120 void imag(long double); // constexpr in C++20
121
122 complex<long double>& operator=(const complex<long double>&); // constexpr in C++20
123 complex<long double>& operator= (long double); // constexpr in C++20
124 complex<long double>& operator+=(long double); // constexpr in C++20
125 complex<long double>& operator-=(long double); // constexpr in C++20
126 complex<long double>& operator*=(long double); // constexpr in C++20
127 complex<long double>& operator/=(long double); // constexpr in C++20
128
129 template<class X> complex<long double>& operator= (const complex<X>&); // constexpr in C++20
130 template<class X> complex<long double>& operator+=(const complex<X>&); // constexpr in C++20
131 template<class X> complex<long double>& operator-=(const complex<X>&); // constexpr in C++20
132 template<class X> complex<long double>& operator*=(const complex<X>&); // constexpr in C++20
133 template<class X> complex<long double>& operator/=(const complex<X>&); // constexpr in C++20
134};
135
136// 26.3.6 operators:
137template<class T> complex<T> operator+(const complex<T>&, const complex<T>&); // constexpr in C++20
138template<class T> complex<T> operator+(const complex<T>&, const T&); // constexpr in C++20
139template<class T> complex<T> operator+(const T&, const complex<T>&); // constexpr in C++20
140template<class T> complex<T> operator-(const complex<T>&, const complex<T>&); // constexpr in C++20
141template<class T> complex<T> operator-(const complex<T>&, const T&); // constexpr in C++20
142template<class T> complex<T> operator-(const T&, const complex<T>&); // constexpr in C++20
143template<class T> complex<T> operator*(const complex<T>&, const complex<T>&); // constexpr in C++20
144template<class T> complex<T> operator*(const complex<T>&, const T&); // constexpr in C++20
145template<class T> complex<T> operator*(const T&, const complex<T>&); // constexpr in C++20
146template<class T> complex<T> operator/(const complex<T>&, const complex<T>&); // constexpr in C++20
147template<class T> complex<T> operator/(const complex<T>&, const T&); // constexpr in C++20
148template<class T> complex<T> operator/(const T&, const complex<T>&); // constexpr in C++20
149template<class T> complex<T> operator+(const complex<T>&); // constexpr in C++20
150template<class T> complex<T> operator-(const complex<T>&); // constexpr in C++20
151template<class T> bool operator==(const complex<T>&, const complex<T>&); // constexpr in C++14
152template<class T> bool operator==(const complex<T>&, const T&); // constexpr in C++14
153template<class T> bool operator==(const T&, const complex<T>&); // constexpr in C++14, removed in C++20
154template<class T> bool operator!=(const complex<T>&, const complex<T>&); // constexpr in C++14, removed in C++20
155template<class T> bool operator!=(const complex<T>&, const T&); // constexpr in C++14, removed in C++20
156template<class T> bool operator!=(const T&, const complex<T>&); // constexpr in C++14, removed in C++20
157
158template<class T, class charT, class traits>
159 basic_istream<charT, traits>&
160 operator>>(basic_istream<charT, traits>&, complex<T>&);
161template<class T, class charT, class traits>
162 basic_ostream<charT, traits>&
163 operator<<(basic_ostream<charT, traits>&, const complex<T>&);
164
165// 26.3.7 values:
166
167template<class T> T real(const complex<T>&); // constexpr in C++14
168 long double real(long double); // constexpr in C++14
169 double real(double); // constexpr in C++14
170template<Integral T> double real(T); // constexpr in C++14
171 float real(float); // constexpr in C++14
172
173template<class T> T imag(const complex<T>&); // constexpr in C++14
174 long double imag(long double); // constexpr in C++14
175 double imag(double); // constexpr in C++14
176template<Integral T> double imag(T); // constexpr in C++14
177 float imag(float); // constexpr in C++14
178
179template<class T> T abs(const complex<T>&);
180
181template<class T> T arg(const complex<T>&);
182 long double arg(long double);
183 double arg(double);
184template<Integral T> double arg(T);
185 float arg(float);
186
187template<class T> T norm(const complex<T>&); // constexpr in C++20
188 long double norm(long double); // constexpr in C++20
189 double norm(double); // constexpr in C++20
190template<Integral T> double norm(T); // constexpr in C++20
191 float norm(float); // constexpr in C++20
192
193template<class T> complex<T> conj(const complex<T>&); // constexpr in C++20
194 complex<long double> conj(long double); // constexpr in C++20
195 complex<double> conj(double); // constexpr in C++20
196template<Integral T> complex<double> conj(T); // constexpr in C++20
197 complex<float> conj(float); // constexpr in C++20
198
199template<class T> complex<T> proj(const complex<T>&);
200 complex<long double> proj(long double);
201 complex<double> proj(double);
202template<Integral T> complex<double> proj(T);
203 complex<float> proj(float);
204
205template<class T> complex<T> polar(const T&, const T& = T());
206
207// 26.3.8 transcendentals:
208template<class T> complex<T> acos(const complex<T>&);
209template<class T> complex<T> asin(const complex<T>&);
210template<class T> complex<T> atan(const complex<T>&);
211template<class T> complex<T> acosh(const complex<T>&);
212template<class T> complex<T> asinh(const complex<T>&);
213template<class T> complex<T> atanh(const complex<T>&);
214template<class T> complex<T> cos (const complex<T>&);
215template<class T> complex<T> cosh (const complex<T>&);
216template<class T> complex<T> exp (const complex<T>&);
217template<class T> complex<T> log (const complex<T>&);
218template<class T> complex<T> log10(const complex<T>&);
219
220template<class T> complex<T> pow(const complex<T>&, const T&);
221template<class T> complex<T> pow(const complex<T>&, const complex<T>&);
222template<class T> complex<T> pow(const T&, const complex<T>&);
223
224template<class T> complex<T> sin (const complex<T>&);
225template<class T> complex<T> sinh (const complex<T>&);
226template<class T> complex<T> sqrt (const complex<T>&);
227template<class T> complex<T> tan (const complex<T>&);
228template<class T> complex<T> tanh (const complex<T>&);
229
230 // [complex.tuple], tuple interface
231 template<class T> struct tuple_size; // Since C++26
232 template<size_t I, class T> struct tuple_element; // Since C++26
233 template<class T> struct tuple_size<complex<T>>; // Since C++26
234 template<size_t I, class T> struct tuple_element<I, complex<T>>; // Since C++26
235 template<size_t I, class T>
236 constexpr T& get(complex<T>&) noexcept; // Since C++26
237 template<size_t I, class T>
238 constexpr T&& get(complex<T>&&) noexcept; // Since C++26
239 template<size_t I, class T>
240 constexpr const T& get(const complex<T>&) noexcept; // Since C++26
241 template<size_t I, class T>
242 constexpr const T&& get(const complex<T>&&) noexcept; // Since C++26
243
244 // [complex.literals], complex literals
245 inline namespace literals {
246 inline namespace complex_literals {
247 constexpr complex<long double> operator""il(long double); // Since C++14
248 constexpr complex<long double> operator""il(unsigned long long); // Since C++14
249 constexpr complex<double> operator""i(long double); // Since C++14
250 constexpr complex<double> operator""i(unsigned long long); // Since C++14
251 constexpr complex<float> operator""if(long double); // Since C++14
252 constexpr complex<float> operator""if(unsigned long long); // Since C++14
253 }
254 }
255} // std
256
257*/
258
259#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
260# include <__cxx03/complex>
261#else
262# include <__config>
263# include <__cstddef/size_t.h>
264# include <__fwd/complex.h>
265# include <__fwd/tuple.h>
266# include <__tuple/tuple_element.h>
267# include <__tuple/tuple_size.h>
268# include <__type_traits/conditional.h>
269# include <__utility/move.h>
270# include <cmath>
271# include <version>
272
273# if _LIBCPP_HAS_LOCALIZATION
274# include <sstream> // for std::basic_ostringstream
275# endif
276
277# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
278# pragma GCC system_header
279# endif
280
281_LIBCPP_PUSH_MACROS
282# include <__undef_macros>
283
284_LIBCPP_BEGIN_NAMESPACE_STD
285
286template <class _Tp>
287class complex;
288
289template <class _Tp, __enable_if_t<is_floating_point<_Tp>::value, int> = 0>
290_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
291operator*(const complex<_Tp>& __z, const complex<_Tp>& __w);
292
293template <class _Tp, __enable_if_t<!is_floating_point<_Tp>::value, int> = 0>
294_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
295operator*(const complex<_Tp>& __z, const complex<_Tp>& __w);
296
297template <class _Tp, __enable_if_t<is_floating_point<_Tp>::value, int> = 0>
298_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
299operator/(const complex<_Tp>& __x, const complex<_Tp>& __y);
300
301template <class _Tp, __enable_if_t<!is_floating_point<_Tp>::value, int> = 0>
302_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
303operator/(const complex<_Tp>& __x, const complex<_Tp>& __y);
304
305template <class _Tp>
306class complex {
307public:
308 typedef _Tp value_type;
309
310private:
311 value_type __re_;
312 value_type __im_;
313
314public:
315 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
316 complex(const value_type& __re = value_type(), const value_type& __im = value_type())
317 : __re_(__re), __im_(__im) {}
318 template <class _Xp>
319 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 complex(const complex<_Xp>& __c)
320 : __re_(__c.real()), __im_(__c.imag()) {}
321
322 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 value_type real() const { return __re_; }
323 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 value_type imag() const { return __im_; }
324
325 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) { __re_ = __re; }
326 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) { __im_ = __im; }
327
328 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator=(const value_type& __re) {
329 __re_ = __re;
330 __im_ = value_type();
331 return *this;
332 }
333 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const value_type& __re) {
334 __re_ += __re;
335 return *this;
336 }
337 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const value_type& __re) {
338 __re_ -= __re;
339 return *this;
340 }
341 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const value_type& __re) {
342 __re_ *= __re;
343 __im_ *= __re;
344 return *this;
345 }
346 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const value_type& __re) {
347 __re_ /= __re;
348 __im_ /= __re;
349 return *this;
350 }
351
352 template <class _Xp>
353 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator=(const complex<_Xp>& __c) {
354 __re_ = __c.real();
355 __im_ = __c.imag();
356 return *this;
357 }
358 template <class _Xp>
359 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const complex<_Xp>& __c) {
360 __re_ += __c.real();
361 __im_ += __c.imag();
362 return *this;
363 }
364 template <class _Xp>
365 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const complex<_Xp>& __c) {
366 __re_ -= __c.real();
367 __im_ -= __c.imag();
368 return *this;
369 }
370 template <class _Xp>
371 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c) {
372 *this = *this * complex(__c.real(), __c.imag());
373 return *this;
374 }
375 template <class _Xp>
376 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c) {
377 *this = *this / complex(__c.real(), __c.imag());
378 return *this;
379 }
380
381# if _LIBCPP_STD_VER >= 26
382 template <size_t _Ip, class _Xp>
383 friend _LIBCPP_HIDE_FROM_ABI constexpr _Xp& get(complex<_Xp>&) noexcept;
384
385 template <size_t _Ip, class _Xp>
386 friend _LIBCPP_HIDE_FROM_ABI constexpr _Xp&& get(complex<_Xp>&&) noexcept;
387
388 template <size_t _Ip, class _Xp>
389 friend _LIBCPP_HIDE_FROM_ABI constexpr const _Xp& get(const complex<_Xp>&) noexcept;
390
391 template <size_t _Ip, class _Xp>
392 friend _LIBCPP_HIDE_FROM_ABI constexpr const _Xp&& get(const complex<_Xp>&&) noexcept;
393# endif
394};
395
396template <>
397class complex<double>;
398template <>
399class complex<long double>;
400
401struct __from_builtin_tag {};
402
403template <class _Tp>
404using __complex_t _LIBCPP_NODEBUG =
405 __conditional_t<is_same<_Tp, float>::value,
406 _Complex float,
407 __conditional_t<is_same<_Tp, double>::value, _Complex double, _Complex long double> >;
408
409template <class _Tp>
410_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __complex_t<_Tp> __make_complex(_Tp __re, _Tp __im) {
411# if __has_builtin(__builtin_complex)
412 return __builtin_complex(__re, __im);
413# else
414 return __complex_t<_Tp>{__re, __im};
415# endif
416}
417
418template <>
419class complex<float> {
420 float __re_;
421 float __im_;
422
423public:
424 typedef float value_type;
425
426 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR complex(float __re = 0.0f, float __im = 0.0f) : __re_(__re), __im_(__im) {}
427
428 template <class _Tag, __enable_if_t<_IsSame<_Tag, __from_builtin_tag>::value, int> = 0>
429 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit complex(_Tag, _Complex float __v)
430 : __re_(__real__ __v), __im_(__imag__ __v) {}
431
432 _LIBCPP_HIDE_FROM_ABI explicit _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
433 _LIBCPP_HIDE_FROM_ABI explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
434
435 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR float real() const { return __re_; }
436 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR float imag() const { return __im_; }
437
438 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) { __re_ = __re; }
439 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) { __im_ = __im; }
440
441 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Complex float __builtin() const { return std::__make_complex(__re_, __im_); }
442 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void __builtin(_Complex float __f) {
443 __re_ = __real__ __f;
444 __im_ = __imag__ __f;
445 }
446
447 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator=(float __re) {
448 __re_ = __re;
449 __im_ = value_type();
450 return *this;
451 }
452 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(float __re) {
453 __re_ += __re;
454 return *this;
455 }
456 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(float __re) {
457 __re_ -= __re;
458 return *this;
459 }
460 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(float __re) {
461 __re_ *= __re;
462 __im_ *= __re;
463 return *this;
464 }
465 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(float __re) {
466 __re_ /= __re;
467 __im_ /= __re;
468 return *this;
469 }
470
471 template <class _Xp>
472 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator=(const complex<_Xp>& __c) {
473 __re_ = __c.real();
474 __im_ = __c.imag();
475 return *this;
476 }
477 template <class _Xp>
478 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const complex<_Xp>& __c) {
479 __re_ += __c.real();
480 __im_ += __c.imag();
481 return *this;
482 }
483 template <class _Xp>
484 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const complex<_Xp>& __c) {
485 __re_ -= __c.real();
486 __im_ -= __c.imag();
487 return *this;
488 }
489 template <class _Xp>
490 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c) {
491 *this = *this * complex(__c.real(), __c.imag());
492 return *this;
493 }
494 template <class _Xp>
495 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c) {
496 *this = *this / complex(__c.real(), __c.imag());
497 return *this;
498 }
499
500# if _LIBCPP_STD_VER >= 26
501 template <size_t _Ip, class _Xp>
502 friend _LIBCPP_HIDE_FROM_ABI constexpr _Xp& get(complex<_Xp>&) noexcept;
503
504 template <size_t _Ip, class _Xp>
505 friend _LIBCPP_HIDE_FROM_ABI constexpr _Xp&& get(complex<_Xp>&&) noexcept;
506
507 template <size_t _Ip, class _Xp>
508 friend _LIBCPP_HIDE_FROM_ABI constexpr const _Xp& get(const complex<_Xp>&) noexcept;
509
510 template <size_t _Ip, class _Xp>
511 friend _LIBCPP_HIDE_FROM_ABI constexpr const _Xp&& get(const complex<_Xp>&&) noexcept;
512# endif
513};
514
515template <>
516class complex<double> {
517 double __re_;
518 double __im_;
519
520public:
521 typedef double value_type;
522
523 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR complex(double __re = 0.0, double __im = 0.0) : __re_(__re), __im_(__im) {}
524
525 template <class _Tag, __enable_if_t<_IsSame<_Tag, __from_builtin_tag>::value, int> = 0>
526 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit complex(_Tag, _Complex double __v)
527 : __re_(__real__ __v), __im_(__imag__ __v) {}
528
529 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR complex(const complex<float>& __c);
530 _LIBCPP_HIDE_FROM_ABI explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
531
532 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR double real() const { return __re_; }
533 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR double imag() const { return __im_; }
534
535 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) { __re_ = __re; }
536 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) { __im_ = __im; }
537
538 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Complex double __builtin() const {
539 return std::__make_complex(__re_, __im_);
540 }
541
542 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void __builtin(_Complex double __f) {
543 __re_ = __real__ __f;
544 __im_ = __imag__ __f;
545 }
546
547 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator=(double __re) {
548 __re_ = __re;
549 __im_ = value_type();
550 return *this;
551 }
552 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(double __re) {
553 __re_ += __re;
554 return *this;
555 }
556 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(double __re) {
557 __re_ -= __re;
558 return *this;
559 }
560 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(double __re) {
561 __re_ *= __re;
562 __im_ *= __re;
563 return *this;
564 }
565 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(double __re) {
566 __re_ /= __re;
567 __im_ /= __re;
568 return *this;
569 }
570
571 template <class _Xp>
572 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator=(const complex<_Xp>& __c) {
573 __re_ = __c.real();
574 __im_ = __c.imag();
575 return *this;
576 }
577 template <class _Xp>
578 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const complex<_Xp>& __c) {
579 __re_ += __c.real();
580 __im_ += __c.imag();
581 return *this;
582 }
583 template <class _Xp>
584 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const complex<_Xp>& __c) {
585 __re_ -= __c.real();
586 __im_ -= __c.imag();
587 return *this;
588 }
589 template <class _Xp>
590 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c) {
591 *this = *this * complex(__c.real(), __c.imag());
592 return *this;
593 }
594 template <class _Xp>
595 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c) {
596 *this = *this / complex(__c.real(), __c.imag());
597 return *this;
598 }
599
600# if _LIBCPP_STD_VER >= 26
601 template <size_t _Ip, class _Xp>
602 friend _LIBCPP_HIDE_FROM_ABI constexpr _Xp& get(complex<_Xp>&) noexcept;
603
604 template <size_t _Ip, class _Xp>
605 friend _LIBCPP_HIDE_FROM_ABI constexpr _Xp&& get(complex<_Xp>&&) noexcept;
606
607 template <size_t _Ip, class _Xp>
608 friend _LIBCPP_HIDE_FROM_ABI constexpr const _Xp& get(const complex<_Xp>&) noexcept;
609
610 template <size_t _Ip, class _Xp>
611 friend _LIBCPP_HIDE_FROM_ABI constexpr const _Xp&& get(const complex<_Xp>&&) noexcept;
612# endif
613};
614
615template <>
616class complex<long double> {
617 long double __re_;
618 long double __im_;
619
620public:
621 typedef long double value_type;
622
623 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR complex(long double __re = 0.0L, long double __im = 0.0L)
624 : __re_(__re), __im_(__im) {}
625
626 template <class _Tag, __enable_if_t<_IsSame<_Tag, __from_builtin_tag>::value, int> = 0>
627 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit complex(_Tag, _Complex long double __v)
628 : __re_(__real__ __v), __im_(__imag__ __v) {}
629
630 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR complex(const complex<float>& __c);
631 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
632
633 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR long double real() const { return __re_; }
634 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR long double imag() const { return __im_; }
635
636 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) { __re_ = __re; }
637 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) { __im_ = __im; }
638
639 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Complex long double __builtin() const {
640 return std::__make_complex(__re_, __im_);
641 }
642
643 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void __builtin(_Complex long double __f) {
644 __re_ = __real__ __f;
645 __im_ = __imag__ __f;
646 }
647
648 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator=(long double __re) {
649 __re_ = __re;
650 __im_ = value_type();
651 return *this;
652 }
653 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(long double __re) {
654 __re_ += __re;
655 return *this;
656 }
657 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(long double __re) {
658 __re_ -= __re;
659 return *this;
660 }
661 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(long double __re) {
662 __re_ *= __re;
663 __im_ *= __re;
664 return *this;
665 }
666 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(long double __re) {
667 __re_ /= __re;
668 __im_ /= __re;
669 return *this;
670 }
671
672 template <class _Xp>
673 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator=(const complex<_Xp>& __c) {
674 __re_ = __c.real();
675 __im_ = __c.imag();
676 return *this;
677 }
678 template <class _Xp>
679 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const complex<_Xp>& __c) {
680 __re_ += __c.real();
681 __im_ += __c.imag();
682 return *this;
683 }
684 template <class _Xp>
685 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const complex<_Xp>& __c) {
686 __re_ -= __c.real();
687 __im_ -= __c.imag();
688 return *this;
689 }
690 template <class _Xp>
691 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c) {
692 *this = *this * complex(__c.real(), __c.imag());
693 return *this;
694 }
695 template <class _Xp>
696 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c) {
697 *this = *this / complex(__c.real(), __c.imag());
698 return *this;
699 }
700
701# if _LIBCPP_STD_VER >= 26
702 template <size_t _Ip, class _Xp>
703 friend _LIBCPP_HIDE_FROM_ABI constexpr _Xp& get(complex<_Xp>&) noexcept;
704
705 template <size_t _Ip, class _Xp>
706 friend _LIBCPP_HIDE_FROM_ABI constexpr _Xp&& get(complex<_Xp>&&) noexcept;
707
708 template <size_t _Ip, class _Xp>
709 friend _LIBCPP_HIDE_FROM_ABI constexpr const _Xp& get(const complex<_Xp>&) noexcept;
710
711 template <size_t _Ip, class _Xp>
712 friend _LIBCPP_HIDE_FROM_ABI constexpr const _Xp&& get(const complex<_Xp>&&) noexcept;
713# endif
714};
715
716inline _LIBCPP_CONSTEXPR complex<float>::complex(const complex<double>& __c) : __re_(__c.real()), __im_(__c.imag()) {}
717
718inline _LIBCPP_CONSTEXPR complex<float>::complex(const complex<long double>& __c)
719 : __re_(__c.real()), __im_(__c.imag()) {}
720
721inline _LIBCPP_CONSTEXPR complex<double>::complex(const complex<float>& __c) : __re_(__c.real()), __im_(__c.imag()) {}
722
723inline _LIBCPP_CONSTEXPR complex<double>::complex(const complex<long double>& __c)
724 : __re_(__c.real()), __im_(__c.imag()) {}
725
726inline _LIBCPP_CONSTEXPR complex<long double>::complex(const complex<float>& __c)
727 : __re_(__c.real()), __im_(__c.imag()) {}
728
729inline _LIBCPP_CONSTEXPR complex<long double>::complex(const complex<double>& __c)
730 : __re_(__c.real()), __im_(__c.imag()) {}
731
732// 26.3.6 operators:
733
734template <class _Tp>
735inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
736operator+(const complex<_Tp>& __x, const complex<_Tp>& __y) {
737 complex<_Tp> __t(__x);
738 __t += __y;
739 return __t;
740}
741
742template <class _Tp>
743inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
744operator+(const complex<_Tp>& __x, const _Tp& __y) {
745 complex<_Tp> __t(__x);
746 __t += __y;
747 return __t;
748}
749
750template <class _Tp>
751inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
752operator+(const _Tp& __x, const complex<_Tp>& __y) {
753 complex<_Tp> __t(__y);
754 __t += __x;
755 return __t;
756}
757
758template <class _Tp>
759inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
760operator-(const complex<_Tp>& __x, const complex<_Tp>& __y) {
761 complex<_Tp> __t(__x);
762 __t -= __y;
763 return __t;
764}
765
766template <class _Tp>
767inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
768operator-(const complex<_Tp>& __x, const _Tp& __y) {
769 complex<_Tp> __t(__x);
770 __t -= __y;
771 return __t;
772}
773
774template <class _Tp>
775inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
776operator-(const _Tp& __x, const complex<_Tp>& __y) {
777 complex<_Tp> __t(-__y);
778 __t += __x;
779 return __t;
780}
781
782template <class _Tp, __enable_if_t<is_floating_point<_Tp>::value, int> >
783_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
784operator*(const complex<_Tp>& __lhs, const complex<_Tp>& __rhs) {
785 return complex<_Tp>(__from_builtin_tag(), __lhs.__builtin() * __rhs.__builtin());
786}
787
788template <class _Tp, __enable_if_t<!is_floating_point<_Tp>::value, int> >
789_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
790operator*(const complex<_Tp>& __z, const complex<_Tp>& __w) {
791 _Tp __a = __z.real();
792 _Tp __b = __z.imag();
793 _Tp __c = __w.real();
794 _Tp __d = __w.imag();
795
796 return complex<_Tp>((__a * __c) - (__b * __d), (__a * __d) + (__b * __c));
797}
798
799template <class _Tp>
800inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
801operator*(const complex<_Tp>& __x, const _Tp& __y) {
802 complex<_Tp> __t(__x);
803 __t *= __y;
804 return __t;
805}
806
807template <class _Tp>
808inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
809operator*(const _Tp& __x, const complex<_Tp>& __y) {
810 complex<_Tp> __t(__y);
811 __t *= __x;
812 return __t;
813}
814
815template <class _Tp, __enable_if_t<is_floating_point<_Tp>::value, int> >
816_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
817operator/(const complex<_Tp>& __lhs, const complex<_Tp>& __rhs) {
818 return complex<_Tp>(__from_builtin_tag(), __lhs.__builtin() / __rhs.__builtin());
819}
820
821template <class _Tp, __enable_if_t<!is_floating_point<_Tp>::value, int> >
822_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
823operator/(const complex<_Tp>& __z, const complex<_Tp>& __w) {
824 _Tp __a = __z.real();
825 _Tp __b = __z.imag();
826 _Tp __c = __w.real();
827 _Tp __d = __w.imag();
828
829 _Tp __denom = __c * __c + __d * __d;
830 return complex<_Tp>((__a * __c + __b * __d) / __denom, (__b * __c - __a * __d) / __denom);
831}
832
833template <class _Tp>
834inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
835operator/(const complex<_Tp>& __x, const _Tp& __y) {
836 return complex<_Tp>(__x.real() / __y, __x.imag() / __y);
837}
838
839template <class _Tp>
840inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
841operator/(const _Tp& __x, const complex<_Tp>& __y) {
842 complex<_Tp> __t(__x);
843 __t /= __y;
844 return __t;
845}
846
847template <class _Tp>
848inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp> operator+(const complex<_Tp>& __x) {
849 return __x;
850}
851
852template <class _Tp>
853inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp> operator-(const complex<_Tp>& __x) {
854 return complex<_Tp>(-__x.real(), -__x.imag());
855}
856
857template <class _Tp>
858inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
859operator==(const complex<_Tp>& __x, const complex<_Tp>& __y) {
860 return __x.real() == __y.real() && __x.imag() == __y.imag();
861}
862
863template <class _Tp>
864inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator==(const complex<_Tp>& __x, const _Tp& __y) {
865 return __x.real() == __y && __x.imag() == 0;
866}
867
868# if _LIBCPP_STD_VER <= 17
869
870template <class _Tp>
871inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator==(const _Tp& __x, const complex<_Tp>& __y) {
872 return __x == __y.real() && 0 == __y.imag();
873}
874
875template <class _Tp>
876inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
877operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y) {
878 return !(__x == __y);
879}
880
881template <class _Tp>
882inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator!=(const complex<_Tp>& __x, const _Tp& __y) {
883 return !(__x == __y);
884}
885
886template <class _Tp>
887inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator!=(const _Tp& __x, const complex<_Tp>& __y) {
888 return !(__x == __y);
889}
890
891# endif
892
893// 26.3.7 values:
894
895template <class _Tp, bool = is_integral<_Tp>::value, bool = is_floating_point<_Tp>::value >
896struct __libcpp_complex_overload_traits {};
897
898// Integral Types
899template <class _Tp>
900struct __libcpp_complex_overload_traits<_Tp, true, false> {
901 typedef double _ValueType;
902 typedef complex<double> _ComplexType;
903};
904
905// Floating point types
906template <class _Tp>
907struct __libcpp_complex_overload_traits<_Tp, false, true> {
908 typedef _Tp _ValueType;
909 typedef complex<_Tp> _ComplexType;
910};
911
912// real
913
914template <class _Tp>
915inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp real(const complex<_Tp>& __c) {
916 return __c.real();
917}
918
919template <class _Tp>
920inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename __libcpp_complex_overload_traits<_Tp>::_ValueType
921real(_Tp __re) {
922 return __re;
923}
924
925// imag
926
927template <class _Tp>
928inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp imag(const complex<_Tp>& __c) {
929 return __c.imag();
930}
931
932template <class _Tp>
933inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename __libcpp_complex_overload_traits<_Tp>::_ValueType
934imag(_Tp) {
935 return 0;
936}
937
938// abs
939
940template <class _Tp>
941inline _LIBCPP_HIDE_FROM_ABI _Tp abs(const complex<_Tp>& __c) {
942 return std::hypot(__c.real(), __c.imag());
943}
944
945// arg
946
947template <class _Tp>
948inline _LIBCPP_HIDE_FROM_ABI _Tp arg(const complex<_Tp>& __c) {
949 return std::atan2(__c.imag(), __c.real());
950}
951
952template <class _Tp, __enable_if_t<is_same<_Tp, long double>::value, int> = 0>
953inline _LIBCPP_HIDE_FROM_ABI long double arg(_Tp __re) {
954 return std::atan2l(0.L, __re);
955}
956
957template <class _Tp, __enable_if_t<is_integral<_Tp>::value || is_same<_Tp, double>::value, int> = 0>
958inline _LIBCPP_HIDE_FROM_ABI double arg(_Tp __re) {
959 return std::atan2(0., __re);
960}
961
962template <class _Tp, __enable_if_t<is_same<_Tp, float>::value, int> = 0>
963inline _LIBCPP_HIDE_FROM_ABI float arg(_Tp __re) {
964 return std::atan2f(0.F, __re);
965}
966
967// norm
968
969template <class _Tp>
970inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp norm(const complex<_Tp>& __c) {
971 if (std::__constexpr_isinf(__c.real()))
972 return std::abs(__c.real());
973 if (std::__constexpr_isinf(__c.imag()))
974 return std::abs(__c.imag());
975 return __c.real() * __c.real() + __c.imag() * __c.imag();
976}
977
978template <class _Tp>
979inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 typename __libcpp_complex_overload_traits<_Tp>::_ValueType
980norm(_Tp __re) {
981 typedef typename __libcpp_complex_overload_traits<_Tp>::_ValueType _ValueType;
982 return static_cast<_ValueType>(__re) * __re;
983}
984
985// conj
986
987template <class _Tp>
988inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp> conj(const complex<_Tp>& __c) {
989 return complex<_Tp>(__c.real(), -__c.imag());
990}
991
992template <class _Tp>
993inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
994conj(_Tp __re) {
995 typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;
996 return _ComplexType(__re);
997}
998
999// proj
1000
1001template <class _Tp>
1002inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> proj(const complex<_Tp>& __c) {
1003 complex<_Tp> __r = __c;
1004 if (std::isinf(__c.real()) || std::isinf(__c.imag()))
1005 __r = complex<_Tp>(INFINITY, std::copysign(_Tp(0), __c.imag()));
1006 return __r;
1007}
1008
1009template <class _Tp, __enable_if_t<is_floating_point<_Tp>::value, int> = 0>
1010inline _LIBCPP_HIDE_FROM_ABI typename __libcpp_complex_overload_traits<_Tp>::_ComplexType proj(_Tp __re) {
1011 if (std::isinf(__re))
1012 __re = std::abs(__re);
1013 return complex<_Tp>(__re);
1014}
1015
1016template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
1017inline _LIBCPP_HIDE_FROM_ABI typename __libcpp_complex_overload_traits<_Tp>::_ComplexType proj(_Tp __re) {
1018 typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;
1019 return _ComplexType(__re);
1020}
1021
1022// polar
1023
1024template <class _Tp>
1025_LIBCPP_HIDE_FROM_ABI complex<_Tp> polar(const _Tp& __rho, const _Tp& __theta = _Tp()) {
1026 if (std::isnan(__rho) || std::signbit(__rho))
1027 return complex<_Tp>(_Tp(NAN), _Tp(NAN));
1028 if (std::isnan(__theta)) {
1029 if (std::isinf(__rho))
1030 return complex<_Tp>(__rho, __theta);
1031 return complex<_Tp>(__theta, __theta);
1032 }
1033 if (std::isinf(__theta)) {
1034 if (std::isinf(__rho))
1035 return complex<_Tp>(__rho, _Tp(NAN));
1036 return complex<_Tp>(_Tp(NAN), _Tp(NAN));
1037 }
1038 _Tp __x = __rho * std::cos(__theta);
1039 if (std::isnan(__x))
1040 __x = 0;
1041 _Tp __y = __rho * std::sin(__theta);
1042 if (std::isnan(__y))
1043 __y = 0;
1044 return complex<_Tp>(__x, __y);
1045}
1046
1047// log
1048
1049template <class _Tp>
1050inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> log(const complex<_Tp>& __x) {
1051 return complex<_Tp>(std::log(std::abs(__x)), std::arg(__x));
1052}
1053
1054// log10
1055
1056template <class _Tp>
1057inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> log10(const complex<_Tp>& __x) {
1058 return std::log(__x) / std::log(_Tp(10));
1059}
1060
1061// sqrt
1062
1063template <class _Tp>
1064_LIBCPP_HIDE_FROM_ABI complex<_Tp> sqrt(const complex<_Tp>& __x) {
1065 if (std::isinf(__x.imag()))
1066 return complex<_Tp>(_Tp(INFINITY), __x.imag());
1067 if (std::isinf(__x.real())) {
1068 if (__x.real() > _Tp(0))
1069 return complex<_Tp>(__x.real(), std::isnan(__x.imag()) ? __x.imag() : std::copysign(_Tp(0), __x.imag()));
1070 return complex<_Tp>(std::isnan(__x.imag()) ? __x.imag() : _Tp(0), std::copysign(__x.real(), __x.imag()));
1071 }
1072 return std::polar(std::sqrt(std::abs(__x)), std::arg(__x) / _Tp(2));
1073}
1074
1075// exp
1076
1077template <class _Tp>
1078_LIBCPP_HIDE_FROM_ABI complex<_Tp> exp(const complex<_Tp>& __x) {
1079 _Tp __i = __x.imag();
1080 if (__i == 0) {
1081 return complex<_Tp>(std::exp(__x.real()), std::copysign(_Tp(0), __x.imag()));
1082 }
1083 if (std::isinf(__x.real())) {
1084 if (__x.real() < _Tp(0)) {
1085 if (!std::isfinite(__i))
1086 __i = _Tp(1);
1087 } else if (__i == 0 || !std::isfinite(__i)) {
1088 if (std::isinf(__i))
1089 __i = _Tp(NAN);
1090 return complex<_Tp>(__x.real(), __i);
1091 }
1092 }
1093 _Tp __e = std::exp(__x.real());
1094 return complex<_Tp>(__e * std::cos(__i), __e * std::sin(__i));
1095}
1096
1097// pow
1098
1099template <class _Tp>
1100inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> pow(const complex<_Tp>& __x, const complex<_Tp>& __y) {
1101 return std::exp(__y * std::log(__x));
1102}
1103
1104template <class _Tp, class _Up, __enable_if_t<is_floating_point<_Tp>::value && is_floating_point<_Up>::value, int> = 0>
1105inline _LIBCPP_HIDE_FROM_ABI complex<__promote_t<_Tp, _Up> > pow(const complex<_Tp>& __x, const complex<_Up>& __y) {
1106 typedef complex<__promote_t<_Tp, _Up> > result_type;
1107 return std::pow(result_type(__x), result_type(__y));
1108}
1109
1110template <class _Tp, class _Up, __enable_if_t<is_floating_point<_Tp>::value && is_arithmetic<_Up>::value, int> = 0>
1111inline _LIBCPP_HIDE_FROM_ABI complex<__promote_t<_Tp, _Up> > pow(const complex<_Tp>& __x, const _Up& __y) {
1112 typedef complex<__promote_t<_Tp, _Up> > result_type;
1113 return std::pow(result_type(__x), result_type(__y));
1114}
1115
1116template <class _Tp, class _Up, __enable_if_t<is_arithmetic<_Tp>::value && is_floating_point<_Up>::value, int> = 0>
1117inline _LIBCPP_HIDE_FROM_ABI complex<__promote_t<_Tp, _Up> > pow(const _Tp& __x, const complex<_Up>& __y) {
1118 typedef complex<__promote_t<_Tp, _Up> > result_type;
1119 return std::pow(result_type(__x), result_type(__y));
1120}
1121
1122// __sqr, computes pow(x, 2)
1123
1124template <class _Tp>
1125inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> __sqr(const complex<_Tp>& __x) {
1126 return complex<_Tp>((__x.real() - __x.imag()) * (__x.real() + __x.imag()), _Tp(2) * __x.real() * __x.imag());
1127}
1128
1129// asinh
1130
1131template <class _Tp>
1132_LIBCPP_HIDE_FROM_ABI complex<_Tp> asinh(const complex<_Tp>& __x) {
1133 const _Tp __pi(atan2(+0., -0.));
1134 if (std::isinf(__x.real())) {
1135 if (std::isnan(__x.imag()))
1136 return __x;
1137 if (std::isinf(__x.imag()))
1138 return complex<_Tp>(__x.real(), std::copysign(__pi * _Tp(0.25), __x.imag()));
1139 return complex<_Tp>(__x.real(), std::copysign(_Tp(0), __x.imag()));
1140 }
1141 if (std::isnan(__x.real())) {
1142 if (std::isinf(__x.imag()))
1143 return complex<_Tp>(__x.imag(), __x.real());
1144 if (__x.imag() == 0)
1145 return __x;
1146 return complex<_Tp>(__x.real(), __x.real());
1147 }
1148 if (std::isinf(__x.imag()))
1149 return complex<_Tp>(std::copysign(__x.imag(), __x.real()), std::copysign(__pi / _Tp(2), __x.imag()));
1150 complex<_Tp> __z = std::log(__x + std::sqrt(std::__sqr(__x) + _Tp(1)));
1151 return complex<_Tp>(std::copysign(__z.real(), __x.real()), std::copysign(__z.imag(), __x.imag()));
1152}
1153
1154// acosh
1155
1156template <class _Tp>
1157_LIBCPP_HIDE_FROM_ABI complex<_Tp> acosh(const complex<_Tp>& __x) {
1158 const _Tp __pi(atan2(+0., -0.));
1159 if (std::isinf(__x.real())) {
1160 if (std::isnan(__x.imag()))
1161 return complex<_Tp>(std::abs(__x.real()), __x.imag());
1162 if (std::isinf(__x.imag())) {
1163 if (__x.real() > 0)
1164 return complex<_Tp>(__x.real(), std::copysign(__pi * _Tp(0.25), __x.imag()));
1165 else
1166 return complex<_Tp>(-__x.real(), std::copysign(__pi * _Tp(0.75), __x.imag()));
1167 }
1168 if (__x.real() < 0)
1169 return complex<_Tp>(-__x.real(), std::copysign(__pi, __x.imag()));
1170 return complex<_Tp>(__x.real(), std::copysign(_Tp(0), __x.imag()));
1171 }
1172 if (std::isnan(__x.real())) {
1173 if (std::isinf(__x.imag()))
1174 return complex<_Tp>(std::abs(__x.imag()), __x.real());
1175 return complex<_Tp>(__x.real(), __x.real());
1176 }
1177 if (std::isinf(__x.imag()))
1178 return complex<_Tp>(std::abs(__x.imag()), std::copysign(__pi / _Tp(2), __x.imag()));
1179 complex<_Tp> __z = std::log(__x + std::sqrt(std::__sqr(__x) - _Tp(1)));
1180 return complex<_Tp>(std::copysign(__z.real(), _Tp(0)), std::copysign(__z.imag(), __x.imag()));
1181}
1182
1183// atanh
1184
1185template <class _Tp>
1186_LIBCPP_HIDE_FROM_ABI complex<_Tp> atanh(const complex<_Tp>& __x) {
1187 const _Tp __pi(atan2(+0., -0.));
1188 if (std::isinf(__x.imag())) {
1189 return complex<_Tp>(std::copysign(_Tp(0), __x.real()), std::copysign(__pi / _Tp(2), __x.imag()));
1190 }
1191 if (std::isnan(__x.imag())) {
1192 if (std::isinf(__x.real()) || __x.real() == 0)
1193 return complex<_Tp>(std::copysign(_Tp(0), __x.real()), __x.imag());
1194 return complex<_Tp>(__x.imag(), __x.imag());
1195 }
1196 if (std::isnan(__x.real())) {
1197 return complex<_Tp>(__x.real(), __x.real());
1198 }
1199 if (std::isinf(__x.real())) {
1200 return complex<_Tp>(std::copysign(_Tp(0), __x.real()), std::copysign(__pi / _Tp(2), __x.imag()));
1201 }
1202 if (std::abs(__x.real()) == _Tp(1) && __x.imag() == _Tp(0)) {
1203 return complex<_Tp>(std::copysign(_Tp(INFINITY), __x.real()), std::copysign(_Tp(0), __x.imag()));
1204 }
1205 complex<_Tp> __z = std::log((_Tp(1) + __x) / (_Tp(1) - __x)) / _Tp(2);
1206 return complex<_Tp>(std::copysign(__z.real(), __x.real()), std::copysign(__z.imag(), __x.imag()));
1207}
1208
1209// sinh
1210
1211template <class _Tp>
1212_LIBCPP_HIDE_FROM_ABI complex<_Tp> sinh(const complex<_Tp>& __x) {
1213 if (std::isinf(__x.real()) && !std::isfinite(__x.imag()))
1214 return complex<_Tp>(__x.real(), _Tp(NAN));
1215 if (__x.real() == 0 && !std::isfinite(__x.imag()))
1216 return complex<_Tp>(__x.real(), _Tp(NAN));
1217 if (__x.imag() == 0 && !std::isfinite(__x.real()))
1218 return __x;
1219 return complex<_Tp>(std::sinh(__x.real()) * std::cos(__x.imag()), std::cosh(__x.real()) * std::sin(__x.imag()));
1220}
1221
1222// cosh
1223
1224template <class _Tp>
1225_LIBCPP_HIDE_FROM_ABI complex<_Tp> cosh(const complex<_Tp>& __x) {
1226 if (std::isinf(__x.real()) && !std::isfinite(__x.imag()))
1227 return complex<_Tp>(std::abs(__x.real()), _Tp(NAN));
1228 if (__x.real() == 0 && !std::isfinite(__x.imag()))
1229 return complex<_Tp>(_Tp(NAN), __x.real());
1230 if (__x.real() == 0 && __x.imag() == 0)
1231 return complex<_Tp>(_Tp(1), __x.imag());
1232 if (__x.imag() == 0 && !std::isfinite(__x.real()))
1233 return complex<_Tp>(std::abs(__x.real()), __x.imag());
1234 return complex<_Tp>(std::cosh(__x.real()) * std::cos(__x.imag()), std::sinh(__x.real()) * std::sin(__x.imag()));
1235}
1236
1237// tanh
1238
1239template <class _Tp>
1240_LIBCPP_HIDE_FROM_ABI complex<_Tp> tanh(const complex<_Tp>& __x) {
1241 if (std::isinf(__x.real())) {
1242 if (!std::isfinite(__x.imag()))
1243 return complex<_Tp>(std::copysign(_Tp(1), __x.real()), _Tp(0));
1244 return complex<_Tp>(std::copysign(_Tp(1), __x.real()), std::copysign(_Tp(0), std::sin(_Tp(2) * __x.imag())));
1245 }
1246 if (std::isnan(__x.real()) && __x.imag() == 0)
1247 return __x;
1248 _Tp __2r(_Tp(2) * __x.real());
1249 _Tp __2i(_Tp(2) * __x.imag());
1250 _Tp __d(std::cosh(__2r) + std::cos(__2i));
1251 _Tp __2rsh(std::sinh(__2r));
1252 if (std::isinf(__2rsh) && std::isinf(__d))
1253 return complex<_Tp>(__2rsh > _Tp(0) ? _Tp(1) : _Tp(-1), __2i > _Tp(0) ? _Tp(0) : _Tp(-0.));
1254 return complex<_Tp>(__2rsh / __d, std::sin(__2i) / __d);
1255}
1256
1257// asin
1258
1259template <class _Tp>
1260_LIBCPP_HIDE_FROM_ABI complex<_Tp> asin(const complex<_Tp>& __x) {
1261 complex<_Tp> __z = std::asinh(complex<_Tp>(-__x.imag(), __x.real()));
1262 return complex<_Tp>(__z.imag(), -__z.real());
1263}
1264
1265// acos
1266
1267template <class _Tp>
1268_LIBCPP_HIDE_FROM_ABI complex<_Tp> acos(const complex<_Tp>& __x) {
1269 const _Tp __pi(atan2(+0., -0.));
1270 if (std::isinf(__x.real())) {
1271 if (std::isnan(__x.imag()))
1272 return complex<_Tp>(__x.imag(), __x.real());
1273 if (std::isinf(__x.imag())) {
1274 if (__x.real() < _Tp(0))
1275 return complex<_Tp>(_Tp(0.75) * __pi, -__x.imag());
1276 return complex<_Tp>(_Tp(0.25) * __pi, -__x.imag());
1277 }
1278 if (__x.real() < _Tp(0))
1279 return complex<_Tp>(__pi, std::signbit(__x.imag()) ? -__x.real() : __x.real());
1280 return complex<_Tp>(_Tp(0), std::signbit(__x.imag()) ? __x.real() : -__x.real());
1281 }
1282 if (std::isnan(__x.real())) {
1283 if (std::isinf(__x.imag()))
1284 return complex<_Tp>(__x.real(), -__x.imag());
1285 return complex<_Tp>(__x.real(), __x.real());
1286 }
1287 if (std::isinf(__x.imag()))
1288 return complex<_Tp>(__pi / _Tp(2), -__x.imag());
1289 if (__x.real() == 0 && (__x.imag() == 0 || std::isnan(__x.imag())))
1290 return complex<_Tp>(__pi / _Tp(2), -__x.imag());
1291 complex<_Tp> __z = std::log(__x + std::sqrt(std::__sqr(__x) - _Tp(1)));
1292 if (std::signbit(__x.imag()))
1293 return complex<_Tp>(std::abs(__z.imag()), std::abs(__z.real()));
1294 return complex<_Tp>(std::abs(__z.imag()), -std::abs(__z.real()));
1295}
1296
1297// atan
1298
1299template <class _Tp>
1300_LIBCPP_HIDE_FROM_ABI complex<_Tp> atan(const complex<_Tp>& __x) {
1301 complex<_Tp> __z = std::atanh(complex<_Tp>(-__x.imag(), __x.real()));
1302 return complex<_Tp>(__z.imag(), -__z.real());
1303}
1304
1305// sin
1306
1307template <class _Tp>
1308_LIBCPP_HIDE_FROM_ABI complex<_Tp> sin(const complex<_Tp>& __x) {
1309 complex<_Tp> __z = std::sinh(complex<_Tp>(-__x.imag(), __x.real()));
1310 return complex<_Tp>(__z.imag(), -__z.real());
1311}
1312
1313// cos
1314
1315template <class _Tp>
1316inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> cos(const complex<_Tp>& __x) {
1317 return std::cosh(complex<_Tp>(-__x.imag(), __x.real()));
1318}
1319
1320// tan
1321
1322template <class _Tp>
1323_LIBCPP_HIDE_FROM_ABI complex<_Tp> tan(const complex<_Tp>& __x) {
1324 complex<_Tp> __z = std::tanh(complex<_Tp>(-__x.imag(), __x.real()));
1325 return complex<_Tp>(__z.imag(), -__z.real());
1326}
1327
1328# if _LIBCPP_HAS_LOCALIZATION
1329template <class _Tp, class _CharT, class _Traits>
1330_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
1331operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x) {
1332 if (__is.good()) {
1333 std::ws(__is);
1334 if (__is.peek() == _CharT('(')) {
1335 __is.get();
1336 _Tp __r;
1337 __is >> __r;
1338 if (!__is.fail()) {
1339 std::ws(__is);
1340 _CharT __c = __is.peek();
1341 if (__c == _CharT(',')) {
1342 __is.get();
1343 _Tp __i;
1344 __is >> __i;
1345 if (!__is.fail()) {
1346 std::ws(__is);
1347 __c = __is.peek();
1348 if (__c == _CharT(')')) {
1349 __is.get();
1350 __x = complex<_Tp>(__r, __i);
1351 } else
1352 __is.setstate(__is.failbit);
1353 } else
1354 __is.setstate(__is.failbit);
1355 } else if (__c == _CharT(')')) {
1356 __is.get();
1357 __x = complex<_Tp>(__r, _Tp(0));
1358 } else
1359 __is.setstate(__is.failbit);
1360 } else
1361 __is.setstate(__is.failbit);
1362 } else {
1363 _Tp __r;
1364 __is >> __r;
1365 if (!__is.fail())
1366 __x = complex<_Tp>(__r, _Tp(0));
1367 else
1368 __is.setstate(__is.failbit);
1369 }
1370 } else
1371 __is.setstate(__is.failbit);
1372 return __is;
1373}
1374
1375template <class _Tp, class _CharT, class _Traits>
1376_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
1377operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x) {
1378 basic_ostringstream<_CharT, _Traits> __s;
1379 __s.flags(__os.flags());
1380 __s.imbue(__os.getloc());
1381 __s.precision(__os.precision());
1382 __s << '(' << __x.real() << ',' << __x.imag() << ')';
1383 return __os << __s.str();
1384}
1385# endif // _LIBCPP_HAS_LOCALIZATION
1386
1387# if _LIBCPP_STD_VER >= 26
1388
1389// [complex.tuple], tuple interface
1390
1391template <class _Tp>
1392struct tuple_size<complex<_Tp>> : integral_constant<size_t, 2> {};
1393
1394template <size_t _Ip, class _Tp>
1395struct tuple_element<_Ip, complex<_Tp>> {
1396 static_assert(_Ip < 2, "Index value is out of range.");
1397 using type _LIBCPP_NODEBUG = _Tp;
1398};
1399
1400template <size_t _Ip, class _Xp>
1401_LIBCPP_HIDE_FROM_ABI constexpr _Xp& get(complex<_Xp>& __z) noexcept {
1402 static_assert(_Ip < 2, "Index value is out of range.");
1403 if constexpr (_Ip == 0) {
1404 return __z.__re_;
1405 } else {
1406 return __z.__im_;
1407 }
1408}
1409
1410template <size_t _Ip, class _Xp>
1411_LIBCPP_HIDE_FROM_ABI constexpr _Xp&& get(complex<_Xp>&& __z) noexcept {
1412 static_assert(_Ip < 2, "Index value is out of range.");
1413 if constexpr (_Ip == 0) {
1414 return std::move(__z.__re_);
1415 } else {
1416 return std::move(__z.__im_);
1417 }
1418}
1419
1420template <size_t _Ip, class _Xp>
1421_LIBCPP_HIDE_FROM_ABI constexpr const _Xp& get(const complex<_Xp>& __z) noexcept {
1422 static_assert(_Ip < 2, "Index value is out of range.");
1423 if constexpr (_Ip == 0) {
1424 return __z.__re_;
1425 } else {
1426 return __z.__im_;
1427 }
1428}
1429
1430template <size_t _Ip, class _Xp>
1431_LIBCPP_HIDE_FROM_ABI constexpr const _Xp&& get(const complex<_Xp>&& __z) noexcept {
1432 static_assert(_Ip < 2, "Index value is out of range.");
1433 if constexpr (_Ip == 0) {
1434 return std::move(__z.__re_);
1435 } else {
1436 return std::move(__z.__im_);
1437 }
1438}
1439
1440# endif // _LIBCPP_STD_VER >= 26
1441
1442# if _LIBCPP_STD_VER >= 14
1443// Literal suffix for complex number literals [complex.literals]
1444inline namespace literals {
1445inline namespace complex_literals {
1446_LIBCPP_HIDE_FROM_ABI inline constexpr complex<long double> operator""il(long double __im) { return {0.0l, __im}; }
1447
1448_LIBCPP_HIDE_FROM_ABI inline constexpr complex<long double> operator""il(unsigned long long __im) {
1449 return {0.0l, static_cast<long double>(__im)};
1450}
1451
1452_LIBCPP_HIDE_FROM_ABI inline constexpr complex<double> operator""i(long double __im) {
1453 return {0.0, static_cast<double>(__im)};
1454}
1455
1456_LIBCPP_HIDE_FROM_ABI inline constexpr complex<double> operator""i(unsigned long long __im) {
1457 return {0.0, static_cast<double>(__im)};
1458}
1459
1460_LIBCPP_HIDE_FROM_ABI inline constexpr complex<float> operator""if(long double __im) {
1461 return {0.0f, static_cast<float>(__im)};
1462}
1463
1464_LIBCPP_HIDE_FROM_ABI inline constexpr complex<float> operator""if(unsigned long long __im) {
1465 return {0.0f, static_cast<float>(__im)};
1466}
1467} // namespace complex_literals
1468} // namespace literals
1469# endif
1470
1471_LIBCPP_END_NAMESPACE_STD
1472
1473_LIBCPP_POP_MACROS
1474
1475# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
1476# include <iosfwd>
1477# include <stdexcept>
1478# include <type_traits>
1479# endif
1480#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
1481
1482#endif // _LIBCPP_COMPLEX