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