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}  // std
231
232*/
233
234#include <__assert> // all public C++ headers provide the assertion handler
235#include <__config>
236#include <cmath>
237#include <iosfwd>
238#include <stdexcept>
239#include <version>
240
241#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
242#   include <sstream> // for std::basic_ostringstream
243#endif
244
245#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
246#  pragma GCC system_header
247#endif
248
249_LIBCPP_BEGIN_NAMESPACE_STD
250
251template<class _Tp> class _LIBCPP_TEMPLATE_VIS complex;
252
253template<class _Tp> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp> operator*(const complex<_Tp>& __z, const complex<_Tp>& __w);
254template<class _Tp> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp> operator/(const complex<_Tp>& __x, const complex<_Tp>& __y);
255
256template<class _Tp>
257class _LIBCPP_TEMPLATE_VIS complex
258{
259public:
260    typedef _Tp value_type;
261private:
262    value_type __re_;
263    value_type __im_;
264public:
265    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
266    complex(const value_type& __re = value_type(), const value_type& __im = value_type())
267        : __re_(__re), __im_(__im) {}
268    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
269    complex(const complex<_Xp>& __c)
270        : __re_(__c.real()), __im_(__c.imag()) {}
271
272    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 value_type real() const {return __re_;}
273    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 value_type imag() const {return __im_;}
274
275    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) {__re_ = __re;}
276    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) {__im_ = __im;}
277
278    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (const value_type& __re)
279        {__re_ = __re; __im_ = value_type(); return *this;}
280    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const value_type& __re) {__re_ += __re; return *this;}
281    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const value_type& __re) {__re_ -= __re; return *this;}
282    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const value_type& __re) {__re_ *= __re; __im_ *= __re; return *this;}
283    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const value_type& __re) {__re_ /= __re; __im_ /= __re; return *this;}
284
285    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (const complex<_Xp>& __c)
286        {
287            __re_ = __c.real();
288            __im_ = __c.imag();
289            return *this;
290        }
291    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const complex<_Xp>& __c)
292        {
293            __re_ += __c.real();
294            __im_ += __c.imag();
295            return *this;
296        }
297    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const complex<_Xp>& __c)
298        {
299            __re_ -= __c.real();
300            __im_ -= __c.imag();
301            return *this;
302        }
303    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c)
304        {
305            *this = *this * complex(__c.real(), __c.imag());
306            return *this;
307        }
308    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c)
309        {
310            *this = *this / complex(__c.real(), __c.imag());
311            return *this;
312        }
313};
314
315template<> class _LIBCPP_TEMPLATE_VIS complex<double>;
316template<> class _LIBCPP_TEMPLATE_VIS complex<long double>;
317
318template<>
319class _LIBCPP_TEMPLATE_VIS complex<float>
320{
321    float __re_;
322    float __im_;
323public:
324    typedef float value_type;
325
326    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(float __re = 0.0f, float __im = 0.0f)
327        : __re_(__re), __im_(__im) {}
328    _LIBCPP_INLINE_VISIBILITY
329    explicit _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
330    _LIBCPP_INLINE_VISIBILITY
331    explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
332
333    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR float real() const {return __re_;}
334    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR float imag() const {return __im_;}
335
336    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) {__re_ = __re;}
337    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) {__im_ = __im;}
338
339    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (float __re)
340        {__re_ = __re; __im_ = value_type(); return *this;}
341    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(float __re) {__re_ += __re; return *this;}
342    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(float __re) {__re_ -= __re; return *this;}
343    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(float __re) {__re_ *= __re; __im_ *= __re; return *this;}
344    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(float __re) {__re_ /= __re; __im_ /= __re; return *this;}
345
346    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (const complex<_Xp>& __c)
347        {
348            __re_ = __c.real();
349            __im_ = __c.imag();
350            return *this;
351        }
352    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const complex<_Xp>& __c)
353        {
354            __re_ += __c.real();
355            __im_ += __c.imag();
356            return *this;
357        }
358    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const complex<_Xp>& __c)
359        {
360            __re_ -= __c.real();
361            __im_ -= __c.imag();
362            return *this;
363        }
364    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c)
365        {
366            *this = *this * complex(__c.real(), __c.imag());
367            return *this;
368        }
369    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c)
370        {
371            *this = *this / complex(__c.real(), __c.imag());
372            return *this;
373        }
374};
375
376template<>
377class _LIBCPP_TEMPLATE_VIS complex<double>
378{
379    double __re_;
380    double __im_;
381public:
382    typedef double value_type;
383
384    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(double __re = 0.0, double __im = 0.0)
385        : __re_(__re), __im_(__im) {}
386    _LIBCPP_INLINE_VISIBILITY
387    _LIBCPP_CONSTEXPR complex(const complex<float>& __c);
388    _LIBCPP_INLINE_VISIBILITY
389    explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
390
391    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR double real() const {return __re_;}
392    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR double imag() const {return __im_;}
393
394    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) {__re_ = __re;}
395    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) {__im_ = __im;}
396
397    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (double __re)
398        {__re_ = __re; __im_ = value_type(); return *this;}
399    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(double __re) {__re_ += __re; return *this;}
400    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(double __re) {__re_ -= __re; return *this;}
401    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(double __re) {__re_ *= __re; __im_ *= __re; return *this;}
402    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(double __re) {__re_ /= __re; __im_ /= __re; return *this;}
403
404    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (const complex<_Xp>& __c)
405        {
406            __re_ = __c.real();
407            __im_ = __c.imag();
408            return *this;
409        }
410    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const complex<_Xp>& __c)
411        {
412            __re_ += __c.real();
413            __im_ += __c.imag();
414            return *this;
415        }
416    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const complex<_Xp>& __c)
417        {
418            __re_ -= __c.real();
419            __im_ -= __c.imag();
420            return *this;
421        }
422    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c)
423        {
424            *this = *this * complex(__c.real(), __c.imag());
425            return *this;
426        }
427    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c)
428        {
429            *this = *this / complex(__c.real(), __c.imag());
430            return *this;
431        }
432};
433
434template<>
435class _LIBCPP_TEMPLATE_VIS complex<long double>
436{
437    long double __re_;
438    long double __im_;
439public:
440    typedef long double value_type;
441
442    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(long double __re = 0.0L, long double __im = 0.0L)
443        : __re_(__re), __im_(__im) {}
444    _LIBCPP_INLINE_VISIBILITY
445    _LIBCPP_CONSTEXPR complex(const complex<float>& __c);
446    _LIBCPP_INLINE_VISIBILITY
447    _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
448
449    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR long double real() const {return __re_;}
450    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR long double imag() const {return __im_;}
451
452    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) {__re_ = __re;}
453    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) {__im_ = __im;}
454
455    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (long double __re)
456        {__re_ = __re; __im_ = value_type(); return *this;}
457    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(long double __re) {__re_ += __re; return *this;}
458    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(long double __re) {__re_ -= __re; return *this;}
459    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(long double __re) {__re_ *= __re; __im_ *= __re; return *this;}
460    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(long double __re) {__re_ /= __re; __im_ /= __re; return *this;}
461
462    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (const complex<_Xp>& __c)
463        {
464            __re_ = __c.real();
465            __im_ = __c.imag();
466            return *this;
467        }
468    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const complex<_Xp>& __c)
469        {
470            __re_ += __c.real();
471            __im_ += __c.imag();
472            return *this;
473        }
474    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const complex<_Xp>& __c)
475        {
476            __re_ -= __c.real();
477            __im_ -= __c.imag();
478            return *this;
479        }
480    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c)
481        {
482            *this = *this * complex(__c.real(), __c.imag());
483            return *this;
484        }
485    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c)
486        {
487            *this = *this / complex(__c.real(), __c.imag());
488            return *this;
489        }
490};
491
492inline
493_LIBCPP_CONSTEXPR
494complex<float>::complex(const complex<double>& __c)
495    : __re_(__c.real()), __im_(__c.imag()) {}
496
497inline
498_LIBCPP_CONSTEXPR
499complex<float>::complex(const complex<long double>& __c)
500    : __re_(__c.real()), __im_(__c.imag()) {}
501
502inline
503_LIBCPP_CONSTEXPR
504complex<double>::complex(const complex<float>& __c)
505    : __re_(__c.real()), __im_(__c.imag()) {}
506
507inline
508_LIBCPP_CONSTEXPR
509complex<double>::complex(const complex<long double>& __c)
510    : __re_(__c.real()), __im_(__c.imag()) {}
511
512inline
513_LIBCPP_CONSTEXPR
514complex<long double>::complex(const complex<float>& __c)
515    : __re_(__c.real()), __im_(__c.imag()) {}
516
517inline
518_LIBCPP_CONSTEXPR
519complex<long double>::complex(const complex<double>& __c)
520    : __re_(__c.real()), __im_(__c.imag()) {}
521
522// 26.3.6 operators:
523
524template<class _Tp>
525inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
526complex<_Tp>
527operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
528{
529    complex<_Tp> __t(__x);
530    __t += __y;
531    return __t;
532}
533
534template<class _Tp>
535inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
536complex<_Tp>
537operator+(const complex<_Tp>& __x, const _Tp& __y)
538{
539    complex<_Tp> __t(__x);
540    __t += __y;
541    return __t;
542}
543
544template<class _Tp>
545inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
546complex<_Tp>
547operator+(const _Tp& __x, const complex<_Tp>& __y)
548{
549    complex<_Tp> __t(__y);
550    __t += __x;
551    return __t;
552}
553
554template<class _Tp>
555inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
556complex<_Tp>
557operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
558{
559    complex<_Tp> __t(__x);
560    __t -= __y;
561    return __t;
562}
563
564template<class _Tp>
565inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
566complex<_Tp>
567operator-(const complex<_Tp>& __x, const _Tp& __y)
568{
569    complex<_Tp> __t(__x);
570    __t -= __y;
571    return __t;
572}
573
574template<class _Tp>
575inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
576complex<_Tp>
577operator-(const _Tp& __x, const complex<_Tp>& __y)
578{
579    complex<_Tp> __t(-__y);
580    __t += __x;
581    return __t;
582}
583
584template<class _Tp>
585_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
586operator*(const complex<_Tp>& __z, const complex<_Tp>& __w)
587{
588    _Tp __a = __z.real();
589    _Tp __b = __z.imag();
590    _Tp __c = __w.real();
591    _Tp __d = __w.imag();
592
593    // Avoid floating point operations that are invalid during constant evaluation
594    if (__libcpp_is_constant_evaluated()) {
595        bool __z_zero = __a == _Tp(0) && __b == _Tp(0);
596        bool __w_zero = __c == _Tp(0) && __d == _Tp(0);
597        bool __z_inf = std::__constexpr_isinf(__a) || std::__constexpr_isinf(__b);
598        bool __w_inf = std::__constexpr_isinf(__c) || std::__constexpr_isinf(__d);
599        bool __z_nan = !__z_inf && (
600            (std::__constexpr_isnan(__a) && std::__constexpr_isnan(__b))
601            || (std::__constexpr_isnan(__a) && __b == _Tp(0))
602            || (__a == _Tp(0) && std::__constexpr_isnan(__b))
603        );
604        bool __w_nan = !__w_inf && (
605            (std::__constexpr_isnan(__c) && std::__constexpr_isnan(__d))
606            || (std::__constexpr_isnan(__c) && __d == _Tp(0))
607            || (__c == _Tp(0) && std::__constexpr_isnan(__d))
608        );
609        if (__z_nan || __w_nan) {
610            return complex<_Tp>(_Tp(numeric_limits<_Tp>::quiet_NaN()), _Tp(0));
611        }
612        if (__z_inf || __w_inf) {
613            if (__z_zero || __w_zero) {
614                return complex<_Tp>(_Tp(numeric_limits<_Tp>::quiet_NaN()), _Tp(0));
615            }
616            return complex<_Tp>(_Tp(numeric_limits<_Tp>::infinity()), _Tp(numeric_limits<_Tp>::infinity()));
617        }
618        bool __z_nonzero_nan = !__z_inf && !__z_nan && (std::__constexpr_isnan(__a) || std::__constexpr_isnan(__b));
619        bool __w_nonzero_nan = !__w_inf && !__w_nan && (std::__constexpr_isnan(__c) || std::__constexpr_isnan(__d));
620        if (__z_nonzero_nan || __w_nonzero_nan) {
621            return complex<_Tp>(_Tp(numeric_limits<_Tp>::quiet_NaN()), _Tp(0));
622        }
623    }
624
625    _Tp __ac = __a * __c;
626    _Tp __bd = __b * __d;
627    _Tp __ad = __a * __d;
628    _Tp __bc = __b * __c;
629    _Tp __x = __ac - __bd;
630    _Tp __y = __ad + __bc;
631    if (std::__constexpr_isnan(__x) && std::__constexpr_isnan(__y))
632    {
633        bool __recalc = false;
634        if (std::__constexpr_isinf(__a) || std::__constexpr_isinf(__b))
635        {
636            __a = std::__constexpr_copysign(std::__constexpr_isinf(__a) ? _Tp(1) : _Tp(0), __a);
637            __b = std::__constexpr_copysign(std::__constexpr_isinf(__b) ? _Tp(1) : _Tp(0), __b);
638            if (std::__constexpr_isnan(__c))
639                __c = std::__constexpr_copysign(_Tp(0), __c);
640            if (std::__constexpr_isnan(__d))
641                __d = std::__constexpr_copysign(_Tp(0), __d);
642            __recalc = true;
643        }
644        if (std::__constexpr_isinf(__c) || std::__constexpr_isinf(__d))
645        {
646            __c = std::__constexpr_copysign(std::__constexpr_isinf(__c) ? _Tp(1) : _Tp(0), __c);
647            __d = std::__constexpr_copysign(std::__constexpr_isinf(__d) ? _Tp(1) : _Tp(0), __d);
648            if (std::__constexpr_isnan(__a))
649                __a = std::__constexpr_copysign(_Tp(0), __a);
650            if (std::__constexpr_isnan(__b))
651                __b = std::__constexpr_copysign(_Tp(0), __b);
652            __recalc = true;
653        }
654        if (!__recalc && (std::__constexpr_isinf(__ac) || std::__constexpr_isinf(__bd) ||
655                          std::__constexpr_isinf(__ad) || std::__constexpr_isinf(__bc)))
656        {
657            if (std::__constexpr_isnan(__a))
658                __a = std::__constexpr_copysign(_Tp(0), __a);
659            if (std::__constexpr_isnan(__b))
660                __b = std::__constexpr_copysign(_Tp(0), __b);
661            if (std::__constexpr_isnan(__c))
662                __c = std::__constexpr_copysign(_Tp(0), __c);
663            if (std::__constexpr_isnan(__d))
664                __d = std::__constexpr_copysign(_Tp(0), __d);
665            __recalc = true;
666        }
667        if (__recalc)
668        {
669            __x = _Tp(INFINITY) * (__a * __c - __b * __d);
670            __y = _Tp(INFINITY) * (__a * __d + __b * __c);
671        }
672    }
673    return complex<_Tp>(__x, __y);
674}
675
676template<class _Tp>
677inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
678complex<_Tp>
679operator*(const complex<_Tp>& __x, const _Tp& __y)
680{
681    complex<_Tp> __t(__x);
682    __t *= __y;
683    return __t;
684}
685
686template<class _Tp>
687inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
688complex<_Tp>
689operator*(const _Tp& __x, const complex<_Tp>& __y)
690{
691    complex<_Tp> __t(__y);
692    __t *= __x;
693    return __t;
694}
695
696template<class _Tp>
697_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
698operator/(const complex<_Tp>& __z, const complex<_Tp>& __w)
699{
700    int __ilogbw = 0;
701    _Tp __a = __z.real();
702    _Tp __b = __z.imag();
703    _Tp __c = __w.real();
704    _Tp __d = __w.imag();
705    _Tp __logbw = std::__constexpr_logb(std::__constexpr_fmax(std::__constexpr_fabs(__c), std::__constexpr_fabs(__d)));
706    if (std::__constexpr_isfinite(__logbw))
707    {
708        __ilogbw = static_cast<int>(__logbw);
709        __c = std::__constexpr_scalbn(__c, -__ilogbw);
710        __d = std::__constexpr_scalbn(__d, -__ilogbw);
711    }
712
713    // Avoid floating point operations that are invalid during constant evaluation
714    if (__libcpp_is_constant_evaluated()) {
715        bool __z_zero = __a == _Tp(0) && __b == _Tp(0);
716        bool __w_zero = __c == _Tp(0) && __d == _Tp(0);
717        bool __z_inf = std::__constexpr_isinf(__a) || std::__constexpr_isinf(__b);
718        bool __w_inf = std::__constexpr_isinf(__c) || std::__constexpr_isinf(__d);
719        bool __z_nan = !__z_inf && (
720            (std::__constexpr_isnan(__a) && std::__constexpr_isnan(__b))
721            || (std::__constexpr_isnan(__a) && __b == _Tp(0))
722            || (__a == _Tp(0) && std::__constexpr_isnan(__b))
723        );
724        bool __w_nan = !__w_inf && (
725            (std::__constexpr_isnan(__c) && std::__constexpr_isnan(__d))
726            || (std::__constexpr_isnan(__c) && __d == _Tp(0))
727            || (__c == _Tp(0) && std::__constexpr_isnan(__d))
728        );
729        if ((__z_nan || __w_nan) || (__z_inf && __w_inf)) {
730            return complex<_Tp>(_Tp(numeric_limits<_Tp>::quiet_NaN()), _Tp(0));
731        }
732        bool __z_nonzero_nan = !__z_inf && !__z_nan && (std::__constexpr_isnan(__a) || std::__constexpr_isnan(__b));
733        bool __w_nonzero_nan = !__w_inf && !__w_nan && (std::__constexpr_isnan(__c) || std::__constexpr_isnan(__d));
734        if (__z_nonzero_nan || __w_nonzero_nan) {
735            if (__w_zero) {
736                return complex<_Tp>(_Tp(numeric_limits<_Tp>::infinity()), _Tp(numeric_limits<_Tp>::infinity()));
737            }
738            return complex<_Tp>(_Tp(numeric_limits<_Tp>::quiet_NaN()), _Tp(0));
739        }
740        if (__w_inf) {
741            return complex<_Tp>(_Tp(0), _Tp(0));
742        }
743        if (__z_inf) {
744            return complex<_Tp>(_Tp(numeric_limits<_Tp>::infinity()), _Tp(numeric_limits<_Tp>::infinity()));
745        }
746        if (__w_zero) {
747            if (__z_zero) {
748                return complex<_Tp>(_Tp(numeric_limits<_Tp>::quiet_NaN()), _Tp(0));
749            }
750            return complex<_Tp>(_Tp(numeric_limits<_Tp>::infinity()), _Tp(numeric_limits<_Tp>::infinity()));
751        }
752    }
753
754    _Tp __denom = __c * __c + __d * __d;
755    _Tp __x = std::__constexpr_scalbn((__a * __c + __b * __d) / __denom, -__ilogbw);
756    _Tp __y = std::__constexpr_scalbn((__b * __c - __a * __d) / __denom, -__ilogbw);
757    if (std::__constexpr_isnan(__x) && std::__constexpr_isnan(__y))
758    {
759        if ((__denom == _Tp(0)) && (!std::__constexpr_isnan(__a) || !std::__constexpr_isnan(__b)))
760        {
761            __x = std::__constexpr_copysign(_Tp(INFINITY), __c) * __a;
762            __y = std::__constexpr_copysign(_Tp(INFINITY), __c) * __b;
763        } else if ((std::__constexpr_isinf(__a) || std::__constexpr_isinf(__b)) && std::__constexpr_isfinite(__c) &&
764                   std::__constexpr_isfinite(__d)) {
765            __a = std::__constexpr_copysign(std::__constexpr_isinf(__a) ? _Tp(1) : _Tp(0), __a);
766            __b = std::__constexpr_copysign(std::__constexpr_isinf(__b) ? _Tp(1) : _Tp(0), __b);
767            __x = _Tp(INFINITY) * (__a * __c + __b * __d);
768            __y = _Tp(INFINITY) * (__b * __c - __a * __d);
769        } else if (std::__constexpr_isinf(__logbw) && __logbw > _Tp(0) && std::__constexpr_isfinite(__a) &&
770                   std::__constexpr_isfinite(__b)) {
771            __c = std::__constexpr_copysign(std::__constexpr_isinf(__c) ? _Tp(1) : _Tp(0), __c);
772            __d = std::__constexpr_copysign(std::__constexpr_isinf(__d) ? _Tp(1) : _Tp(0), __d);
773            __x = _Tp(0) * (__a * __c + __b * __d);
774            __y = _Tp(0) * (__b * __c - __a * __d);
775        }
776    }
777    return complex<_Tp>(__x, __y);
778}
779
780template<class _Tp>
781inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
782complex<_Tp>
783operator/(const complex<_Tp>& __x, const _Tp& __y)
784{
785    return complex<_Tp>(__x.real() / __y, __x.imag() / __y);
786}
787
788template<class _Tp>
789inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
790complex<_Tp>
791operator/(const _Tp& __x, const complex<_Tp>& __y)
792{
793    complex<_Tp> __t(__x);
794    __t /= __y;
795    return __t;
796}
797
798template<class _Tp>
799inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
800complex<_Tp>
801operator+(const complex<_Tp>& __x)
802{
803    return __x;
804}
805
806template<class _Tp>
807inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
808complex<_Tp>
809operator-(const complex<_Tp>& __x)
810{
811    return complex<_Tp>(-__x.real(), -__x.imag());
812}
813
814template<class _Tp>
815inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
816bool
817operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
818{
819    return __x.real() == __y.real() && __x.imag() == __y.imag();
820}
821
822template<class _Tp>
823inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
824bool
825operator==(const complex<_Tp>& __x, const _Tp& __y)
826{
827    return __x.real() == __y && __x.imag() == 0;
828}
829
830#if _LIBCPP_STD_VER <= 17
831
832template<class _Tp>
833inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
834bool
835operator==(const _Tp& __x, const complex<_Tp>& __y)
836{
837    return __x == __y.real() && 0 == __y.imag();
838}
839
840template<class _Tp>
841inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
842bool
843operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
844{
845    return !(__x == __y);
846}
847
848template<class _Tp>
849inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
850bool
851operator!=(const complex<_Tp>& __x, const _Tp& __y)
852{
853    return !(__x == __y);
854}
855
856template<class _Tp>
857inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
858bool
859operator!=(const _Tp& __x, const complex<_Tp>& __y)
860{
861    return !(__x == __y);
862}
863
864#endif
865
866// 26.3.7 values:
867
868template <class _Tp, bool = is_integral<_Tp>::value,
869                     bool = is_floating_point<_Tp>::value
870                     >
871struct __libcpp_complex_overload_traits {};
872
873// Integral Types
874template <class _Tp>
875struct __libcpp_complex_overload_traits<_Tp, true, false>
876{
877    typedef double _ValueType;
878    typedef complex<double> _ComplexType;
879};
880
881// Floating point types
882template <class _Tp>
883struct __libcpp_complex_overload_traits<_Tp, false, true>
884{
885    typedef _Tp _ValueType;
886    typedef complex<_Tp> _ComplexType;
887};
888
889// real
890
891template<class _Tp>
892inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
893_Tp
894real(const complex<_Tp>& __c)
895{
896    return __c.real();
897}
898
899template <class _Tp>
900inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
901typename __libcpp_complex_overload_traits<_Tp>::_ValueType
902real(_Tp __re)
903{
904    return __re;
905}
906
907// imag
908
909template<class _Tp>
910inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
911_Tp
912imag(const complex<_Tp>& __c)
913{
914    return __c.imag();
915}
916
917template <class _Tp>
918inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
919typename __libcpp_complex_overload_traits<_Tp>::_ValueType
920imag(_Tp)
921{
922    return 0;
923}
924
925// abs
926
927template<class _Tp>
928inline _LIBCPP_INLINE_VISIBILITY
929_Tp
930abs(const complex<_Tp>& __c)
931{
932    return std::hypot(__c.real(), __c.imag());
933}
934
935// arg
936
937template<class _Tp>
938inline _LIBCPP_INLINE_VISIBILITY
939_Tp
940arg(const complex<_Tp>& __c)
941{
942    return std::atan2(__c.imag(), __c.real());
943}
944
945template <class _Tp>
946inline _LIBCPP_INLINE_VISIBILITY
947typename enable_if<
948    is_same<_Tp, long double>::value,
949    long double
950>::type
951arg(_Tp __re)
952{
953    return std::atan2l(0.L, __re);
954}
955
956template<class _Tp>
957inline _LIBCPP_INLINE_VISIBILITY
958typename enable_if
959<
960    is_integral<_Tp>::value || is_same<_Tp, double>::value,
961    double
962>::type
963arg(_Tp __re)
964{
965    return std::atan2(0., __re);
966}
967
968template <class _Tp>
969inline _LIBCPP_INLINE_VISIBILITY
970typename enable_if<
971    is_same<_Tp, float>::value,
972    float
973>::type
974arg(_Tp __re)
975{
976    return std::atan2f(0.F, __re);
977}
978
979// norm
980
981template<class _Tp>
982inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
983_Tp
984norm(const complex<_Tp>& __c)
985{
986    if (std::__constexpr_isinf(__c.real()))
987        return std::abs(__c.real());
988    if (std::__constexpr_isinf(__c.imag()))
989        return std::abs(__c.imag());
990    return __c.real() * __c.real() + __c.imag() * __c.imag();
991}
992
993template <class _Tp>
994inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
995typename __libcpp_complex_overload_traits<_Tp>::_ValueType
996norm(_Tp __re)
997{
998    typedef typename __libcpp_complex_overload_traits<_Tp>::_ValueType _ValueType;
999    return static_cast<_ValueType>(__re) * __re;
1000}
1001
1002// conj
1003
1004template<class _Tp>
1005inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
1006complex<_Tp>
1007conj(const complex<_Tp>& __c)
1008{
1009    return complex<_Tp>(__c.real(), -__c.imag());
1010}
1011
1012template <class _Tp>
1013inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
1014typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
1015conj(_Tp __re)
1016{
1017    typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;
1018    return _ComplexType(__re);
1019}
1020
1021
1022
1023// proj
1024
1025template<class _Tp>
1026inline _LIBCPP_INLINE_VISIBILITY
1027complex<_Tp>
1028proj(const complex<_Tp>& __c)
1029{
1030    complex<_Tp> __r = __c;
1031    if (std::__constexpr_isinf(__c.real()) || std::__constexpr_isinf(__c.imag()))
1032        __r = complex<_Tp>(INFINITY, std::copysign(_Tp(0), __c.imag()));
1033    return __r;
1034}
1035
1036template <class _Tp>
1037inline _LIBCPP_INLINE_VISIBILITY
1038typename enable_if
1039<
1040    is_floating_point<_Tp>::value,
1041    typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
1042>::type
1043proj(_Tp __re)
1044{
1045    if (std::__constexpr_isinf(__re))
1046        __re = std::abs(__re);
1047    return complex<_Tp>(__re);
1048}
1049
1050template <class _Tp>
1051inline _LIBCPP_INLINE_VISIBILITY
1052typename enable_if
1053<
1054    is_integral<_Tp>::value,
1055    typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
1056>::type
1057proj(_Tp __re)
1058{
1059    typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;
1060    return _ComplexType(__re);
1061}
1062
1063// polar
1064
1065template<class _Tp>
1066_LIBCPP_HIDE_FROM_ABI complex<_Tp>
1067polar(const _Tp& __rho, const _Tp& __theta = _Tp())
1068{
1069    if (std::__constexpr_isnan(__rho) || std::signbit(__rho))
1070        return complex<_Tp>(_Tp(NAN), _Tp(NAN));
1071    if (std::__constexpr_isnan(__theta))
1072    {
1073        if (std::__constexpr_isinf(__rho))
1074            return complex<_Tp>(__rho, __theta);
1075        return complex<_Tp>(__theta, __theta);
1076    }
1077    if (std::__constexpr_isinf(__theta))
1078    {
1079        if (std::__constexpr_isinf(__rho))
1080            return complex<_Tp>(__rho, _Tp(NAN));
1081        return complex<_Tp>(_Tp(NAN), _Tp(NAN));
1082    }
1083    _Tp __x = __rho * std::cos(__theta);
1084    if (std::__constexpr_isnan(__x))
1085        __x = 0;
1086    _Tp __y = __rho * std::sin(__theta);
1087    if (std::__constexpr_isnan(__y))
1088        __y = 0;
1089    return complex<_Tp>(__x, __y);
1090}
1091
1092// log
1093
1094template<class _Tp>
1095inline _LIBCPP_INLINE_VISIBILITY
1096complex<_Tp>
1097log(const complex<_Tp>& __x)
1098{
1099    return complex<_Tp>(std::log(std::abs(__x)), std::arg(__x));
1100}
1101
1102// log10
1103
1104template<class _Tp>
1105inline _LIBCPP_INLINE_VISIBILITY
1106complex<_Tp>
1107log10(const complex<_Tp>& __x)
1108{
1109    return std::log(__x) / std::log(_Tp(10));
1110}
1111
1112// sqrt
1113
1114template<class _Tp>
1115_LIBCPP_HIDE_FROM_ABI complex<_Tp>
1116sqrt(const complex<_Tp>& __x)
1117{
1118    if (std::__constexpr_isinf(__x.imag()))
1119        return complex<_Tp>(_Tp(INFINITY), __x.imag());
1120    if (std::__constexpr_isinf(__x.real()))
1121    {
1122        if (__x.real() > _Tp(0))
1123            return complex<_Tp>(__x.real(), std::__constexpr_isnan(__x.imag()) ? __x.imag() : std::copysign(_Tp(0), __x.imag()));
1124        return complex<_Tp>(std::__constexpr_isnan(__x.imag()) ? __x.imag() : _Tp(0), std::copysign(__x.real(), __x.imag()));
1125    }
1126    return std::polar(std::sqrt(std::abs(__x)), std::arg(__x) / _Tp(2));
1127}
1128
1129// exp
1130
1131template<class _Tp>
1132_LIBCPP_HIDE_FROM_ABI complex<_Tp>
1133exp(const complex<_Tp>& __x)
1134{
1135    _Tp __i = __x.imag();
1136    if (__i == 0) {
1137        return complex<_Tp>(std::exp(__x.real()), std::copysign(_Tp(0), __x.imag()));
1138    }
1139    if (std::__constexpr_isinf(__x.real()))
1140    {
1141        if (__x.real() < _Tp(0))
1142        {
1143            if (!std::__constexpr_isfinite(__i))
1144                __i = _Tp(1);
1145        }
1146        else if (__i == 0 || !std::__constexpr_isfinite(__i))
1147        {
1148            if (std::__constexpr_isinf(__i))
1149                __i = _Tp(NAN);
1150            return complex<_Tp>(__x.real(), __i);
1151        }
1152    }
1153    _Tp __e = std::exp(__x.real());
1154    return complex<_Tp>(__e * std::cos(__i), __e * std::sin(__i));
1155}
1156
1157// pow
1158
1159template<class _Tp>
1160inline _LIBCPP_INLINE_VISIBILITY
1161complex<_Tp>
1162pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1163{
1164    return std::exp(__y * std::log(__x));
1165}
1166
1167template<class _Tp, class _Up>
1168inline _LIBCPP_INLINE_VISIBILITY
1169complex<typename __promote<_Tp, _Up>::type>
1170pow(const complex<_Tp>& __x, const complex<_Up>& __y)
1171{
1172    typedef complex<typename __promote<_Tp, _Up>::type> result_type;
1173    return _VSTD::pow(result_type(__x), result_type(__y));
1174}
1175
1176template<class _Tp, class _Up>
1177inline _LIBCPP_INLINE_VISIBILITY
1178typename enable_if
1179<
1180    is_arithmetic<_Up>::value,
1181    complex<typename __promote<_Tp, _Up>::type>
1182>::type
1183pow(const complex<_Tp>& __x, const _Up& __y)
1184{
1185    typedef complex<typename __promote<_Tp, _Up>::type> result_type;
1186    return _VSTD::pow(result_type(__x), result_type(__y));
1187}
1188
1189template<class _Tp, class _Up>
1190inline _LIBCPP_INLINE_VISIBILITY
1191typename enable_if
1192<
1193    is_arithmetic<_Tp>::value,
1194    complex<typename __promote<_Tp, _Up>::type>
1195>::type
1196pow(const _Tp& __x, const complex<_Up>& __y)
1197{
1198    typedef complex<typename __promote<_Tp, _Up>::type> result_type;
1199    return _VSTD::pow(result_type(__x), result_type(__y));
1200}
1201
1202// __sqr, computes pow(x, 2)
1203
1204template<class _Tp>
1205inline _LIBCPP_INLINE_VISIBILITY
1206complex<_Tp>
1207__sqr(const complex<_Tp>& __x)
1208{
1209    return complex<_Tp>((__x.real() - __x.imag()) * (__x.real() + __x.imag()),
1210                        _Tp(2) * __x.real() * __x.imag());
1211}
1212
1213// asinh
1214
1215template<class _Tp>
1216_LIBCPP_HIDE_FROM_ABI complex<_Tp>
1217asinh(const complex<_Tp>& __x)
1218{
1219    const _Tp __pi(atan2(+0., -0.));
1220    if (std::__constexpr_isinf(__x.real()))
1221    {
1222        if (std::__constexpr_isnan(__x.imag()))
1223            return __x;
1224        if (std::__constexpr_isinf(__x.imag()))
1225            return complex<_Tp>(__x.real(), std::copysign(__pi * _Tp(0.25), __x.imag()));
1226        return complex<_Tp>(__x.real(), std::copysign(_Tp(0), __x.imag()));
1227    }
1228    if (std::__constexpr_isnan(__x.real()))
1229    {
1230        if (std::__constexpr_isinf(__x.imag()))
1231            return complex<_Tp>(__x.imag(), __x.real());
1232        if (__x.imag() == 0)
1233            return __x;
1234        return complex<_Tp>(__x.real(), __x.real());
1235    }
1236    if (std::__constexpr_isinf(__x.imag()))
1237        return complex<_Tp>(std::copysign(__x.imag(), __x.real()), std::copysign(__pi/_Tp(2), __x.imag()));
1238    complex<_Tp> __z = std::log(__x + std::sqrt(std::__sqr(__x) + _Tp(1)));
1239    return complex<_Tp>(std::copysign(__z.real(), __x.real()), std::copysign(__z.imag(), __x.imag()));
1240}
1241
1242// acosh
1243
1244template<class _Tp>
1245_LIBCPP_HIDE_FROM_ABI complex<_Tp>
1246acosh(const complex<_Tp>& __x)
1247{
1248    const _Tp __pi(atan2(+0., -0.));
1249    if (std::__constexpr_isinf(__x.real()))
1250    {
1251        if (std::__constexpr_isnan(__x.imag()))
1252            return complex<_Tp>(std::abs(__x.real()), __x.imag());
1253        if (std::__constexpr_isinf(__x.imag()))
1254        {
1255            if (__x.real() > 0)
1256                return complex<_Tp>(__x.real(), std::copysign(__pi * _Tp(0.25), __x.imag()));
1257            else
1258                return complex<_Tp>(-__x.real(), std::copysign(__pi * _Tp(0.75), __x.imag()));
1259        }
1260        if (__x.real() < 0)
1261            return complex<_Tp>(-__x.real(), std::copysign(__pi, __x.imag()));
1262        return complex<_Tp>(__x.real(), std::copysign(_Tp(0), __x.imag()));
1263    }
1264    if (std::__constexpr_isnan(__x.real()))
1265    {
1266        if (std::__constexpr_isinf(__x.imag()))
1267            return complex<_Tp>(std::abs(__x.imag()), __x.real());
1268        return complex<_Tp>(__x.real(), __x.real());
1269    }
1270    if (std::__constexpr_isinf(__x.imag()))
1271        return complex<_Tp>(std::abs(__x.imag()), std::copysign(__pi/_Tp(2), __x.imag()));
1272    complex<_Tp> __z = std::log(__x + std::sqrt(std::__sqr(__x) - _Tp(1)));
1273    return complex<_Tp>(std::copysign(__z.real(), _Tp(0)), std::copysign(__z.imag(), __x.imag()));
1274}
1275
1276// atanh
1277
1278template<class _Tp>
1279_LIBCPP_HIDE_FROM_ABI complex<_Tp>
1280atanh(const complex<_Tp>& __x)
1281{
1282    const _Tp __pi(atan2(+0., -0.));
1283    if (std::__constexpr_isinf(__x.imag()))
1284    {
1285        return complex<_Tp>(std::copysign(_Tp(0), __x.real()), std::copysign(__pi/_Tp(2), __x.imag()));
1286    }
1287    if (std::__constexpr_isnan(__x.imag()))
1288    {
1289        if (std::__constexpr_isinf(__x.real()) || __x.real() == 0)
1290            return complex<_Tp>(std::copysign(_Tp(0), __x.real()), __x.imag());
1291        return complex<_Tp>(__x.imag(), __x.imag());
1292    }
1293    if (std::__constexpr_isnan(__x.real()))
1294    {
1295        return complex<_Tp>(__x.real(), __x.real());
1296    }
1297    if (std::__constexpr_isinf(__x.real()))
1298    {
1299        return complex<_Tp>(std::copysign(_Tp(0), __x.real()), std::copysign(__pi/_Tp(2), __x.imag()));
1300    }
1301    if (std::abs(__x.real()) == _Tp(1) && __x.imag() == _Tp(0))
1302    {
1303        return complex<_Tp>(std::copysign(_Tp(INFINITY), __x.real()), std::copysign(_Tp(0), __x.imag()));
1304    }
1305    complex<_Tp> __z = std::log((_Tp(1) + __x) / (_Tp(1) - __x)) / _Tp(2);
1306    return complex<_Tp>(std::copysign(__z.real(), __x.real()), std::copysign(__z.imag(), __x.imag()));
1307}
1308
1309// sinh
1310
1311template<class _Tp>
1312_LIBCPP_HIDE_FROM_ABI complex<_Tp>
1313sinh(const complex<_Tp>& __x)
1314{
1315    if (std::__constexpr_isinf(__x.real()) && !std::__constexpr_isfinite(__x.imag()))
1316        return complex<_Tp>(__x.real(), _Tp(NAN));
1317    if (__x.real() == 0 && !std::__constexpr_isfinite(__x.imag()))
1318        return complex<_Tp>(__x.real(), _Tp(NAN));
1319    if (__x.imag() == 0 && !std::__constexpr_isfinite(__x.real()))
1320        return __x;
1321    return complex<_Tp>(std::sinh(__x.real()) * std::cos(__x.imag()), std::cosh(__x.real()) * std::sin(__x.imag()));
1322}
1323
1324// cosh
1325
1326template<class _Tp>
1327_LIBCPP_HIDE_FROM_ABI complex<_Tp>
1328cosh(const complex<_Tp>& __x)
1329{
1330    if (std::__constexpr_isinf(__x.real()) && !std::__constexpr_isfinite(__x.imag()))
1331        return complex<_Tp>(std::abs(__x.real()), _Tp(NAN));
1332    if (__x.real() == 0 && !std::__constexpr_isfinite(__x.imag()))
1333        return complex<_Tp>(_Tp(NAN), __x.real());
1334    if (__x.real() == 0 && __x.imag() == 0)
1335        return complex<_Tp>(_Tp(1), __x.imag());
1336    if (__x.imag() == 0 && !std::__constexpr_isfinite(__x.real()))
1337        return complex<_Tp>(std::abs(__x.real()), __x.imag());
1338    return complex<_Tp>(std::cosh(__x.real()) * std::cos(__x.imag()), std::sinh(__x.real()) * std::sin(__x.imag()));
1339}
1340
1341// tanh
1342
1343template<class _Tp>
1344_LIBCPP_HIDE_FROM_ABI complex<_Tp>
1345tanh(const complex<_Tp>& __x)
1346{
1347    if (std::__constexpr_isinf(__x.real()))
1348    {
1349        if (!std::__constexpr_isfinite(__x.imag()))
1350            return complex<_Tp>(std::copysign(_Tp(1), __x.real()), _Tp(0));
1351        return complex<_Tp>(std::copysign(_Tp(1), __x.real()), std::copysign(_Tp(0), std::sin(_Tp(2) * __x.imag())));
1352    }
1353    if (std::__constexpr_isnan(__x.real()) && __x.imag() == 0)
1354        return __x;
1355    _Tp __2r(_Tp(2) * __x.real());
1356    _Tp __2i(_Tp(2) * __x.imag());
1357    _Tp __d(std::cosh(__2r) + std::cos(__2i));
1358    _Tp __2rsh(std::sinh(__2r));
1359    if (std::__constexpr_isinf(__2rsh) && std::__constexpr_isinf(__d))
1360        return complex<_Tp>(__2rsh > _Tp(0) ? _Tp(1) : _Tp(-1),
1361                            __2i > _Tp(0) ? _Tp(0) : _Tp(-0.));
1362    return  complex<_Tp>(__2rsh/__d, std::sin(__2i)/__d);
1363}
1364
1365// asin
1366
1367template<class _Tp>
1368_LIBCPP_HIDE_FROM_ABI complex<_Tp>
1369asin(const complex<_Tp>& __x)
1370{
1371    complex<_Tp> __z = std::asinh(complex<_Tp>(-__x.imag(), __x.real()));
1372    return complex<_Tp>(__z.imag(), -__z.real());
1373}
1374
1375// acos
1376
1377template<class _Tp>
1378_LIBCPP_HIDE_FROM_ABI complex<_Tp>
1379acos(const complex<_Tp>& __x)
1380{
1381    const _Tp __pi(atan2(+0., -0.));
1382    if (std::__constexpr_isinf(__x.real()))
1383    {
1384        if (std::__constexpr_isnan(__x.imag()))
1385            return complex<_Tp>(__x.imag(), __x.real());
1386        if (std::__constexpr_isinf(__x.imag()))
1387        {
1388            if (__x.real() < _Tp(0))
1389                return complex<_Tp>(_Tp(0.75) * __pi, -__x.imag());
1390            return complex<_Tp>(_Tp(0.25) * __pi, -__x.imag());
1391        }
1392        if (__x.real() < _Tp(0))
1393            return complex<_Tp>(__pi, std::signbit(__x.imag()) ? -__x.real() : __x.real());
1394        return complex<_Tp>(_Tp(0), std::signbit(__x.imag()) ? __x.real() : -__x.real());
1395    }
1396    if (std::__constexpr_isnan(__x.real()))
1397    {
1398        if (std::__constexpr_isinf(__x.imag()))
1399            return complex<_Tp>(__x.real(), -__x.imag());
1400        return complex<_Tp>(__x.real(), __x.real());
1401    }
1402    if (std::__constexpr_isinf(__x.imag()))
1403        return complex<_Tp>(__pi/_Tp(2), -__x.imag());
1404    if (__x.real() == 0 && (__x.imag() == 0 || std::isnan(__x.imag())))
1405        return complex<_Tp>(__pi/_Tp(2), -__x.imag());
1406    complex<_Tp> __z = std::log(__x + std::sqrt(std::__sqr(__x) - _Tp(1)));
1407    if (std::signbit(__x.imag()))
1408        return complex<_Tp>(std::abs(__z.imag()), std::abs(__z.real()));
1409    return complex<_Tp>(std::abs(__z.imag()), -std::abs(__z.real()));
1410}
1411
1412// atan
1413
1414template<class _Tp>
1415_LIBCPP_HIDE_FROM_ABI complex<_Tp>
1416atan(const complex<_Tp>& __x)
1417{
1418    complex<_Tp> __z = std::atanh(complex<_Tp>(-__x.imag(), __x.real()));
1419    return complex<_Tp>(__z.imag(), -__z.real());
1420}
1421
1422// sin
1423
1424template<class _Tp>
1425_LIBCPP_HIDE_FROM_ABI complex<_Tp>
1426sin(const complex<_Tp>& __x)
1427{
1428    complex<_Tp> __z = std::sinh(complex<_Tp>(-__x.imag(), __x.real()));
1429    return complex<_Tp>(__z.imag(), -__z.real());
1430}
1431
1432// cos
1433
1434template<class _Tp>
1435inline _LIBCPP_INLINE_VISIBILITY
1436complex<_Tp>
1437cos(const complex<_Tp>& __x)
1438{
1439    return std::cosh(complex<_Tp>(-__x.imag(), __x.real()));
1440}
1441
1442// tan
1443
1444template<class _Tp>
1445_LIBCPP_HIDE_FROM_ABI complex<_Tp>
1446tan(const complex<_Tp>& __x)
1447{
1448    complex<_Tp> __z = std::tanh(complex<_Tp>(-__x.imag(), __x.real()));
1449    return complex<_Tp>(__z.imag(), -__z.real());
1450}
1451
1452#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
1453template<class _Tp, class _CharT, class _Traits>
1454_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
1455operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
1456{
1457    if (__is.good())
1458    {
1459        std::ws(__is);
1460        if (__is.peek() == _CharT('('))
1461        {
1462            __is.get();
1463            _Tp __r;
1464            __is >> __r;
1465            if (!__is.fail())
1466            {
1467                std::ws(__is);
1468                _CharT __c = __is.peek();
1469                if (__c == _CharT(','))
1470                {
1471                    __is.get();
1472                    _Tp __i;
1473                    __is >> __i;
1474                    if (!__is.fail())
1475                    {
1476                        std::ws(__is);
1477                        __c = __is.peek();
1478                        if (__c == _CharT(')'))
1479                        {
1480                            __is.get();
1481                            __x = complex<_Tp>(__r, __i);
1482                        }
1483                        else
1484                            __is.setstate(__is.failbit);
1485                    }
1486                    else
1487                        __is.setstate(__is.failbit);
1488                }
1489                else if (__c == _CharT(')'))
1490                {
1491                    __is.get();
1492                    __x = complex<_Tp>(__r, _Tp(0));
1493                }
1494                else
1495                    __is.setstate(__is.failbit);
1496            }
1497            else
1498                __is.setstate(__is.failbit);
1499        }
1500        else
1501        {
1502            _Tp __r;
1503            __is >> __r;
1504            if (!__is.fail())
1505                __x = complex<_Tp>(__r, _Tp(0));
1506            else
1507                __is.setstate(__is.failbit);
1508        }
1509    }
1510    else
1511        __is.setstate(__is.failbit);
1512    return __is;
1513}
1514
1515template<class _Tp, class _CharT, class _Traits>
1516_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
1517operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
1518{
1519    basic_ostringstream<_CharT, _Traits> __s;
1520    __s.flags(__os.flags());
1521    __s.imbue(__os.getloc());
1522    __s.precision(__os.precision());
1523    __s << '(' << __x.real() << ',' << __x.imag() << ')';
1524    return __os << __s.str();
1525}
1526#endif // !_LIBCPP_HAS_NO_LOCALIZATION
1527
1528#if _LIBCPP_STD_VER >= 14
1529// Literal suffix for complex number literals [complex.literals]
1530inline namespace literals
1531{
1532  inline namespace complex_literals
1533  {
1534    _LIBCPP_HIDE_FROM_ABI constexpr complex<long double> operator""il(long double __im)
1535    {
1536        return { 0.0l, __im };
1537    }
1538
1539    _LIBCPP_HIDE_FROM_ABI constexpr complex<long double> operator""il(unsigned long long __im)
1540    {
1541        return { 0.0l, static_cast<long double>(__im) };
1542    }
1543
1544
1545    _LIBCPP_HIDE_FROM_ABI constexpr complex<double> operator""i(long double __im)
1546    {
1547        return { 0.0, static_cast<double>(__im) };
1548    }
1549
1550    _LIBCPP_HIDE_FROM_ABI constexpr complex<double> operator""i(unsigned long long __im)
1551    {
1552        return { 0.0, static_cast<double>(__im) };
1553    }
1554
1555
1556    _LIBCPP_HIDE_FROM_ABI constexpr complex<float> operator""if(long double __im)
1557    {
1558        return { 0.0f, static_cast<float>(__im) };
1559    }
1560
1561    _LIBCPP_HIDE_FROM_ABI constexpr complex<float> operator""if(unsigned long long __im)
1562    {
1563        return { 0.0f, static_cast<float>(__im) };
1564    }
1565  } // namespace complex_literals
1566} // namespace literals
1567#endif
1568
1569_LIBCPP_END_NAMESPACE_STD
1570
1571#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
1572#  include <type_traits>
1573#endif
1574
1575#endif // _LIBCPP_COMPLEX
1576