// The template and inlines for the -*- C++ -*- complex number classes.
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
-// 2006, 2007, 2008
+// 2006, 2007, 2008, 2009, 2010, 2011
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 2, or (at your option)
+// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
-// You should have received a copy of the GNU General Public License
-// along with this library; see the file COPYING. If not, write to
-// the Free Software Foundation, 51 Franklin Street, Fifth Floor,
-// Boston, MA 02110-1301, USA.
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
-// As a special exception, you may use this file as part of a free software
-// library without restriction. Specifically, if other files instantiate
-// templates or use macros or inline functions from this file, or you compile
-// this file and link it with other files to produce an executable, this
-// file does not by itself cause the resulting executable to be covered by
-// the GNU General Public License. This exception does not however
-// invalidate any other reasons why the executable file might be covered by
-// the GNU General Public License.
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
/** @file include/complex
* This is a Standard C++ Library header.
#include <cmath>
#include <sstream>
-_GLIBCXX_BEGIN_NAMESPACE(std)
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ /**
+ * @defgroup complex_numbers Complex Numbers
+ * @ingroup numerics
+ *
+ * Classes and functions for complex numbers.
+ * @{
+ */
// Forward declarations.
template<typename _Tp> class complex;
template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);
/// Return complex hyperbolic tangent of @a z.
template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
- //@}
// 26.2.2 Primary template class complex
/// Default constructor. First parameter is x, second parameter is y.
/// Unspecified parameters default to 0.
- complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
+ _GLIBCXX_CONSTEXPR complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
: _M_real(__r), _M_imag(__i) { }
// Lets the compiler synthesize the copy constructor
// complex (const complex<_Tp>&);
/// Copy constructor.
template<typename _Up>
- complex(const complex<_Up>& __z)
+ _GLIBCXX_CONSTEXPR complex(const complex<_Up>& __z)
: _M_real(__z.real()), _M_imag(__z.imag()) { }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated.
- _Tp real() const
- { return _M_real; }
+ constexpr _Tp
+ real() const { return _M_real; }
- _Tp imag() const
- { return _M_imag; }
+ constexpr _Tp
+ imag() const { return _M_imag; }
#else
/// Return real part of complex number.
- _Tp& real()
- { return _M_real; }
+ _Tp&
+ real() { return _M_real; }
/// Return real part of complex number.
- const _Tp& real() const
- { return _M_real; }
+ const _Tp&
+ real() const { return _M_real; }
/// Return imaginary part of complex number.
- _Tp& imag()
- { return _M_imag; }
+ _Tp&
+ imag() { return _M_imag; }
/// Return imaginary part of complex number.
- const _Tp& imag() const
- { return _M_imag; }
+ const _Tp&
+ imag() const { return _M_imag; }
#endif
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated.
- void real(_Tp __val)
- { _M_real = __val; }
+ void
+ real(_Tp __val) { _M_real = __val; }
- void imag(_Tp __val)
- { _M_imag = __val; }
+ void
+ imag(_Tp __val) { _M_imag = __val; }
/// Assign this complex number to scalar @a t.
complex<_Tp>& operator=(const _Tp&);
template<typename _Up>
complex<_Tp>& operator/=(const complex<_Up>&);
- const complex& __rep() const
+ _GLIBCXX_USE_CONSTEXPR complex __rep() const
{ return *this; }
private:
operator+(const complex<_Tp>& __x, const _Tp& __y)
{
complex<_Tp> __r = __x;
- __r.real() += __y;
+ __r += __y;
return __r;
}
operator+(const _Tp& __x, const complex<_Tp>& __y)
{
complex<_Tp> __r = __y;
- __r.real() += __x;
+ __r += __x;
return __r;
}
//@}
operator-(const complex<_Tp>& __x, const _Tp& __y)
{
complex<_Tp> __r = __x;
- __r.real() -= __y;
+ __r -= __y;
return __r;
}
operator-(const _Tp& __x, const complex<_Tp>& __y)
{
complex<_Tp> __r(__x, -__y.imag());
- __r.real() -= __y.real();
+ __r -= __y.real();
return __r;
}
//@}
//@{
/// Return true if @a x is equal to @a y.
template<typename _Tp>
- inline bool
+ inline _GLIBCXX_CONSTEXPR bool
operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
{ return __x.real() == __y.real() && __x.imag() == __y.imag(); }
template<typename _Tp>
- inline bool
+ inline _GLIBCXX_CONSTEXPR bool
operator==(const complex<_Tp>& __x, const _Tp& __y)
{ return __x.real() == __y && __x.imag() == _Tp(); }
template<typename _Tp>
- inline bool
+ inline _GLIBCXX_CONSTEXPR bool
operator==(const _Tp& __x, const complex<_Tp>& __y)
{ return __x == __y.real() && _Tp() == __y.imag(); }
//@}
//@{
/// Return false if @a x is equal to @a y.
template<typename _Tp>
- inline bool
+ inline _GLIBCXX_CONSTEXPR bool
operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
{ return __x.real() != __y.real() || __x.imag() != __y.imag(); }
template<typename _Tp>
- inline bool
+ inline _GLIBCXX_CONSTEXPR bool
operator!=(const complex<_Tp>& __x, const _Tp& __y)
{ return __x.real() != __y || __x.imag() != _Tp(); }
template<typename _Tp>
- inline bool
+ inline _GLIBCXX_CONSTEXPR bool
operator!=(const _Tp& __x, const complex<_Tp>& __y)
{ return __x != __y.real() || _Tp() != __y.imag(); }
//@}
// Values
#ifdef __GXX_EXPERIMENTAL_CXX0X__
template<typename _Tp>
- inline _Tp
+ inline constexpr _Tp
real(const complex<_Tp>& __z)
{ return __z.real(); }
template<typename _Tp>
- inline _Tp
+ inline constexpr _Tp
imag(const complex<_Tp>& __z)
{ return __z.imag(); }
#else
// raised to the __y-th power. The branch
// cut is on the negative axis.
#ifndef __GXX_EXPERIMENTAL_CXX0X__
+ template<typename _Tp>
+ complex<_Tp>
+ __complex_pow_unsigned(complex<_Tp> __x, unsigned __n)
+ {
+ complex<_Tp> __y = __n % 2 ? __x : complex<_Tp>(1);
+
+ while (__n >>= 1)
+ {
+ __x *= __x;
+ if (__n % 2)
+ __y *= __x;
+ }
+
+ return __y;
+ }
+
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 844. complex pow return type is ambiguous.
template<typename _Tp>
inline complex<_Tp>
pow(const complex<_Tp>& __z, int __n)
- { return std::__pow_helper(__z, __n); }
+ {
+ return __n < 0
+ ? complex<_Tp>(1) / std::__complex_pow_unsigned(__z, -__n)
+ : std::__complex_pow_unsigned(__z, __n);
+ }
#endif
template<typename _Tp>
typedef float value_type;
typedef __complex__ float _ComplexT;
- complex(_ComplexT __z) : _M_value(__z) { }
+ _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
- complex(float __r = 0.0f, float __i = 0.0f)
+ _GLIBCXX_CONSTEXPR complex(float __r = 0.0f, float __i = 0.0f)
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ : _M_value{ __r, __i } { }
+#else
{
__real__ _M_value = __r;
__imag__ _M_value = __i;
}
+#endif
- explicit complex(const complex<double>&);
- explicit complex(const complex<long double>&);
+ explicit _GLIBCXX_CONSTEXPR complex(const complex<double>&);
+ explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
#ifdef __GXX_EXPERIMENTAL_CXX0X__
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated.
- float real() const
- { return __real__ _M_value; }
+ constexpr float
+ real() const { return __real__ _M_value; }
- float imag() const
- { return __imag__ _M_value; }
+ constexpr float
+ imag() const { return __imag__ _M_value; }
#else
- float& real()
- { return __real__ _M_value; }
+ float&
+ real() { return __real__ _M_value; }
- const float& real() const
- { return __real__ _M_value; }
+ const float&
+ real() const { return __real__ _M_value; }
- float& imag()
- { return __imag__ _M_value; }
+ float&
+ imag() { return __imag__ _M_value; }
- const float& imag() const
- { return __imag__ _M_value; }
+ const float&
+ imag() const { return __imag__ _M_value; }
#endif
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated.
- void real(float __val)
- { __real__ _M_value = __val; }
+ void
+ real(float __val) { __real__ _M_value = __val; }
- void imag(float __val)
- { __imag__ _M_value = __val; }
+ void
+ imag(float __val) { __imag__ _M_value = __val; }
- complex<float>&
+ complex&
operator=(float __f)
{
- __real__ _M_value = __f;
- __imag__ _M_value = 0.0f;
+ _M_value = __f;
return *this;
}
- complex<float>&
+ complex&
operator+=(float __f)
{
- __real__ _M_value += __f;
+ _M_value += __f;
return *this;
}
- complex<float>&
+ complex&
operator-=(float __f)
{
- __real__ _M_value -= __f;
+ _M_value -= __f;
return *this;
}
- complex<float>&
+ complex&
operator*=(float __f)
{
_M_value *= __f;
return *this;
}
- complex<float>&
+ complex&
operator/=(float __f)
{
_M_value /= __f;
// complex& operator=(const complex&);
template<typename _Tp>
- complex<float>&
+ complex&
operator=(const complex<_Tp>& __z)
{
__real__ _M_value = __z.real();
}
template<typename _Tp>
- complex<float>&
+ complex&
operator+=(const complex<_Tp>& __z)
{
__real__ _M_value += __z.real();
}
template<class _Tp>
- complex<float>&
+ complex&
operator-=(const complex<_Tp>& __z)
{
__real__ _M_value -= __z.real();
}
template<class _Tp>
- complex<float>&
+ complex&
operator*=(const complex<_Tp>& __z)
{
_ComplexT __t;
}
template<class _Tp>
- complex<float>&
+ complex&
operator/=(const complex<_Tp>& __z)
{
_ComplexT __t;
return *this;
}
- const _ComplexT& __rep() const { return _M_value; }
+ _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; }
private:
_ComplexT _M_value;
typedef double value_type;
typedef __complex__ double _ComplexT;
- complex(_ComplexT __z) : _M_value(__z) { }
+ _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
- complex(double __r = 0.0, double __i = 0.0)
+ _GLIBCXX_CONSTEXPR complex(double __r = 0.0, double __i = 0.0)
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ : _M_value{ __r, __i } { }
+#else
{
__real__ _M_value = __r;
__imag__ _M_value = __i;
}
+#endif
- complex(const complex<float>& __z)
+ _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
: _M_value(__z.__rep()) { }
- explicit complex(const complex<long double>&);
+ explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
#ifdef __GXX_EXPERIMENTAL_CXX0X__
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated.
- double real() const
- { return __real__ _M_value; }
+ constexpr double
+ real() const { return __real__ _M_value; }
- double imag() const
- { return __imag__ _M_value; }
+ constexpr double
+ imag() const { return __imag__ _M_value; }
#else
- double& real()
- { return __real__ _M_value; }
+ double&
+ real() { return __real__ _M_value; }
- const double& real() const
- { return __real__ _M_value; }
+ const double&
+ real() const { return __real__ _M_value; }
- double& imag()
- { return __imag__ _M_value; }
+ double&
+ imag() { return __imag__ _M_value; }
- const double& imag() const
- { return __imag__ _M_value; }
+ const double&
+ imag() const { return __imag__ _M_value; }
#endif
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated.
- void real(double __val)
- { __real__ _M_value = __val; }
+ void
+ real(double __val) { __real__ _M_value = __val; }
- void imag(double __val)
- { __imag__ _M_value = __val; }
+ void
+ imag(double __val) { __imag__ _M_value = __val; }
- complex<double>&
+ complex&
operator=(double __d)
{
- __real__ _M_value = __d;
- __imag__ _M_value = 0.0;
+ _M_value = __d;
return *this;
}
- complex<double>&
+ complex&
operator+=(double __d)
{
- __real__ _M_value += __d;
+ _M_value += __d;
return *this;
}
- complex<double>&
+ complex&
operator-=(double __d)
{
- __real__ _M_value -= __d;
+ _M_value -= __d;
return *this;
}
- complex<double>&
+ complex&
operator*=(double __d)
{
_M_value *= __d;
return *this;
}
- complex<double>&
+ complex&
operator/=(double __d)
{
_M_value /= __d;
// complex& operator=(const complex&);
template<typename _Tp>
- complex<double>&
+ complex&
operator=(const complex<_Tp>& __z)
{
__real__ _M_value = __z.real();
}
template<typename _Tp>
- complex<double>&
+ complex&
operator+=(const complex<_Tp>& __z)
{
__real__ _M_value += __z.real();
}
template<typename _Tp>
- complex<double>&
+ complex&
operator-=(const complex<_Tp>& __z)
{
__real__ _M_value -= __z.real();
}
template<typename _Tp>
- complex<double>&
+ complex&
operator*=(const complex<_Tp>& __z)
{
_ComplexT __t;
}
template<typename _Tp>
- complex<double>&
+ complex&
operator/=(const complex<_Tp>& __z)
{
_ComplexT __t;
return *this;
}
- const _ComplexT& __rep() const { return _M_value; }
+ _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; }
private:
_ComplexT _M_value;
typedef long double value_type;
typedef __complex__ long double _ComplexT;
- complex(_ComplexT __z) : _M_value(__z) { }
+ _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
- complex(long double __r = 0.0L, long double __i = 0.0L)
+ _GLIBCXX_CONSTEXPR complex(long double __r = 0.0L,
+ long double __i = 0.0L)
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ : _M_value{ __r, __i } { }
+#else
{
__real__ _M_value = __r;
__imag__ _M_value = __i;
}
+#endif
- complex(const complex<float>& __z)
+ _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
: _M_value(__z.__rep()) { }
- complex(const complex<double>& __z)
+ _GLIBCXX_CONSTEXPR complex(const complex<double>& __z)
: _M_value(__z.__rep()) { }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated.
- long double real() const
- { return __real__ _M_value; }
+ constexpr long double
+ real() const { return __real__ _M_value; }
- long double imag() const
- { return __imag__ _M_value; }
+ constexpr long double
+ imag() const { return __imag__ _M_value; }
#else
- long double& real()
- { return __real__ _M_value; }
+ long double&
+ real() { return __real__ _M_value; }
- const long double& real() const
- { return __real__ _M_value; }
+ const long double&
+ real() const { return __real__ _M_value; }
- long double& imag()
- { return __imag__ _M_value; }
+ long double&
+ imag() { return __imag__ _M_value; }
- const long double& imag() const
- { return __imag__ _M_value; }
+ const long double&
+ imag() const { return __imag__ _M_value; }
#endif
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated.
- void real(long double __val)
- { __real__ _M_value = __val; }
+ void
+ real(long double __val) { __real__ _M_value = __val; }
- void imag(long double __val)
- { __imag__ _M_value = __val; }
+ void
+ imag(long double __val) { __imag__ _M_value = __val; }
- complex<long double>&
+ complex&
operator=(long double __r)
{
- __real__ _M_value = __r;
- __imag__ _M_value = 0.0L;
+ _M_value = __r;
return *this;
}
- complex<long double>&
+ complex&
operator+=(long double __r)
{
- __real__ _M_value += __r;
+ _M_value += __r;
return *this;
}
- complex<long double>&
+ complex&
operator-=(long double __r)
{
- __real__ _M_value -= __r;
+ _M_value -= __r;
return *this;
}
- complex<long double>&
+ complex&
operator*=(long double __r)
{
_M_value *= __r;
return *this;
}
- complex<long double>&
+ complex&
operator/=(long double __r)
{
_M_value /= __r;
// complex& operator=(const complex&);
template<typename _Tp>
- complex<long double>&
+ complex&
operator=(const complex<_Tp>& __z)
{
__real__ _M_value = __z.real();
}
template<typename _Tp>
- complex<long double>&
+ complex&
operator+=(const complex<_Tp>& __z)
{
__real__ _M_value += __z.real();
}
template<typename _Tp>
- complex<long double>&
+ complex&
operator-=(const complex<_Tp>& __z)
{
__real__ _M_value -= __z.real();
}
template<typename _Tp>
- complex<long double>&
+ complex&
operator*=(const complex<_Tp>& __z)
{
_ComplexT __t;
}
template<typename _Tp>
- complex<long double>&
+ complex&
operator/=(const complex<_Tp>& __z)
{
_ComplexT __t;
return *this;
}
- const _ComplexT& __rep() const { return _M_value; }
+ _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; }
private:
_ComplexT _M_value;
// These bits have to be at the end of this file, so that the
// specializations have all been defined.
- // ??? No, they have to be there because of compiler limitation at
- // inlining. It suffices that class specializations be defined.
- inline
+ inline _GLIBCXX_CONSTEXPR
complex<float>::complex(const complex<double>& __z)
: _M_value(__z.__rep()) { }
- inline
+ inline _GLIBCXX_CONSTEXPR
complex<float>::complex(const complex<long double>& __z)
: _M_value(__z.__rep()) { }
- inline
+ inline _GLIBCXX_CONSTEXPR
complex<double>::complex(const complex<long double>& __z)
: _M_value(__z.__rep()) { }
#endif
#endif
-_GLIBCXX_END_NAMESPACE
+ // @} group complex_numbers
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
-_GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
+namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// See ext/type_traits.h for the primary template.
template<typename _Tp, typename _Up>
typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
};
-_GLIBCXX_END_NAMESPACE
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#ifdef __GXX_EXPERIMENTAL_CXX0X__
-# if defined(_GLIBCXX_INCLUDE_AS_TR1)
-# error C++0x header cannot be included from TR1 header
-# endif
-# if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
-# include <tr1_impl/complex>
-# else
-# define _GLIBCXX_INCLUDE_AS_CXX0X
-# define _GLIBCXX_BEGIN_NAMESPACE_TR1
-# define _GLIBCXX_END_NAMESPACE_TR1
-# define _GLIBCXX_TR1
-# include <tr1_impl/complex>
-# undef _GLIBCXX_TR1
-# undef _GLIBCXX_END_NAMESPACE_TR1
-# undef _GLIBCXX_BEGIN_NAMESPACE_TR1
-# undef _GLIBCXX_INCLUDE_AS_CXX0X
-# endif
-
-_GLIBCXX_BEGIN_NAMESPACE(std)
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ // Forward declarations.
+ template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
+ template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
+ template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);
+
+ template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
+ template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
+ template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);
+ // DR 595.
+ template<typename _Tp> _Tp fabs(const std::complex<_Tp>&);
+
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ __complex_acos(const std::complex<_Tp>& __z)
+ {
+ const std::complex<_Tp> __t = std::asin(__z);
+ const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
+ return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
+ }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+ inline __complex__ float
+ __complex_acos(__complex__ float __z)
+ { return __builtin_cacosf(__z); }
+
+ inline __complex__ double
+ __complex_acos(__complex__ double __z)
+ { return __builtin_cacos(__z); }
+
+ inline __complex__ long double
+ __complex_acos(const __complex__ long double& __z)
+ { return __builtin_cacosl(__z); }
+
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ acos(const std::complex<_Tp>& __z)
+ { return __complex_acos(__z.__rep()); }
+#else
+ /// acos(__z) [8.1.2].
+ // Effects: Behaves the same as C99 function cacos, defined
+ // in subclause 7.3.5.1.
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ acos(const std::complex<_Tp>& __z)
+ { return __complex_acos(__z); }
+#endif
+
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ __complex_asin(const std::complex<_Tp>& __z)
+ {
+ std::complex<_Tp> __t(-__z.imag(), __z.real());
+ __t = std::asinh(__t);
+ return std::complex<_Tp>(__t.imag(), -__t.real());
+ }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+ inline __complex__ float
+ __complex_asin(__complex__ float __z)
+ { return __builtin_casinf(__z); }
+
+ inline __complex__ double
+ __complex_asin(__complex__ double __z)
+ { return __builtin_casin(__z); }
+
+ inline __complex__ long double
+ __complex_asin(const __complex__ long double& __z)
+ { return __builtin_casinl(__z); }
+
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ asin(const std::complex<_Tp>& __z)
+ { return __complex_asin(__z.__rep()); }
+#else
+ /// asin(__z) [8.1.3].
+ // Effects: Behaves the same as C99 function casin, defined
+ // in subclause 7.3.5.2.
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ asin(const std::complex<_Tp>& __z)
+ { return __complex_asin(__z); }
+#endif
+
+ template<typename _Tp>
+ std::complex<_Tp>
+ __complex_atan(const std::complex<_Tp>& __z)
+ {
+ const _Tp __r2 = __z.real() * __z.real();
+ const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
+
+ _Tp __num = __z.imag() + _Tp(1.0);
+ _Tp __den = __z.imag() - _Tp(1.0);
+
+ __num = __r2 + __num * __num;
+ __den = __r2 + __den * __den;
+
+ return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
+ _Tp(0.25) * log(__num / __den));
+ }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+ inline __complex__ float
+ __complex_atan(__complex__ float __z)
+ { return __builtin_catanf(__z); }
+
+ inline __complex__ double
+ __complex_atan(__complex__ double __z)
+ { return __builtin_catan(__z); }
+
+ inline __complex__ long double
+ __complex_atan(const __complex__ long double& __z)
+ { return __builtin_catanl(__z); }
+
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ atan(const std::complex<_Tp>& __z)
+ { return __complex_atan(__z.__rep()); }
+#else
+ /// atan(__z) [8.1.4].
+ // Effects: Behaves the same as C99 function catan, defined
+ // in subclause 7.3.5.3.
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ atan(const std::complex<_Tp>& __z)
+ { return __complex_atan(__z); }
+#endif
+
+ template<typename _Tp>
+ std::complex<_Tp>
+ __complex_acosh(const std::complex<_Tp>& __z)
+ {
+ std::complex<_Tp> __t((__z.real() - __z.imag())
+ * (__z.real() + __z.imag()) - _Tp(1.0),
+ _Tp(2.0) * __z.real() * __z.imag());
+ __t = std::sqrt(__t);
+
+ return std::log(__t + __z);
+ }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+ inline __complex__ float
+ __complex_acosh(__complex__ float __z)
+ { return __builtin_cacoshf(__z); }
+
+ inline __complex__ double
+ __complex_acosh(__complex__ double __z)
+ { return __builtin_cacosh(__z); }
+
+ inline __complex__ long double
+ __complex_acosh(const __complex__ long double& __z)
+ { return __builtin_cacoshl(__z); }
+
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ acosh(const std::complex<_Tp>& __z)
+ { return __complex_acosh(__z.__rep()); }
+#else
+ /// acosh(__z) [8.1.5].
+ // Effects: Behaves the same as C99 function cacosh, defined
+ // in subclause 7.3.6.1.
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ acosh(const std::complex<_Tp>& __z)
+ { return __complex_acosh(__z); }
+#endif
+
+ template<typename _Tp>
+ std::complex<_Tp>
+ __complex_asinh(const std::complex<_Tp>& __z)
+ {
+ std::complex<_Tp> __t((__z.real() - __z.imag())
+ * (__z.real() + __z.imag()) + _Tp(1.0),
+ _Tp(2.0) * __z.real() * __z.imag());
+ __t = std::sqrt(__t);
+
+ return std::log(__t + __z);
+ }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+ inline __complex__ float
+ __complex_asinh(__complex__ float __z)
+ { return __builtin_casinhf(__z); }
+
+ inline __complex__ double
+ __complex_asinh(__complex__ double __z)
+ { return __builtin_casinh(__z); }
+
+ inline __complex__ long double
+ __complex_asinh(const __complex__ long double& __z)
+ { return __builtin_casinhl(__z); }
+
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ asinh(const std::complex<_Tp>& __z)
+ { return __complex_asinh(__z.__rep()); }
+#else
+ /// asinh(__z) [8.1.6].
+ // Effects: Behaves the same as C99 function casin, defined
+ // in subclause 7.3.6.2.
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ asinh(const std::complex<_Tp>& __z)
+ { return __complex_asinh(__z); }
+#endif
+
+ template<typename _Tp>
+ std::complex<_Tp>
+ __complex_atanh(const std::complex<_Tp>& __z)
+ {
+ const _Tp __i2 = __z.imag() * __z.imag();
+ const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
+
+ _Tp __num = _Tp(1.0) + __z.real();
+ _Tp __den = _Tp(1.0) - __z.real();
+
+ __num = __i2 + __num * __num;
+ __den = __i2 + __den * __den;
+
+ return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
+ _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
+ }
+
+#if _GLIBCXX_USE_C99_COMPLEX_TR1
+ inline __complex__ float
+ __complex_atanh(__complex__ float __z)
+ { return __builtin_catanhf(__z); }
+
+ inline __complex__ double
+ __complex_atanh(__complex__ double __z)
+ { return __builtin_catanh(__z); }
+
+ inline __complex__ long double
+ __complex_atanh(const __complex__ long double& __z)
+ { return __builtin_catanhl(__z); }
+
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ atanh(const std::complex<_Tp>& __z)
+ { return __complex_atanh(__z.__rep()); }
+#else
+ /// atanh(__z) [8.1.7].
+ // Effects: Behaves the same as C99 function catanh, defined
+ // in subclause 7.3.6.3.
+ template<typename _Tp>
+ inline std::complex<_Tp>
+ atanh(const std::complex<_Tp>& __z)
+ { return __complex_atanh(__z); }
+#endif
+
+ template<typename _Tp>
+ inline _Tp
+ /// fabs(__z) [8.1.8].
+ // Effects: Behaves the same as C99 function cabs, defined
+ // in subclause 7.3.8.1.
+ fabs(const std::complex<_Tp>& __z)
+ { return std::abs(__z); }
+
+ /// Additional overloads [8.1.9].
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ arg(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+#if (_GLIBCXX_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC)
+ return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L)
+ : __type();
+#else
+ return std::arg(std::complex<__type>(__x));
+#endif
+ }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ imag(_Tp)
+ { return _Tp(); }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ norm(_Tp __x)
+ {
+ typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+ return __type(__x) * __type(__x);
+ }
+
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ real(_Tp __x)
+ { return __x; }
+
+ template<typename _Tp, typename _Up>
+ inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
+ pow(const std::complex<_Tp>& __x, const _Up& __y)
+ {
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return std::pow(std::complex<__type>(__x), __type(__y));
+ }
+
+ template<typename _Tp, typename _Up>
+ inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
+ pow(const _Tp& __x, const std::complex<_Up>& __y)
+ {
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return std::pow(__type(__x), std::complex<__type>(__y));
+ }
+
+ template<typename _Tp, typename _Up>
+ inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
+ pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
+ {
+ typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+ return std::pow(std::complex<__type>(__x),
+ std::complex<__type>(__y));
+ }
// Forward declarations.
// DR 781.
{ return __complex_proj(__z); }
#endif
+ // DR 1137.
template<typename _Tp>
- inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
proj(_Tp __x)
- {
- typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
- return std::proj(std::complex<__type>(__x));
- }
+ { return __x; }
-_GLIBCXX_END_NAMESPACE
+ template<typename _Tp>
+ inline typename __gnu_cxx::__promote<_Tp>::__type
+ conj(_Tp __x)
+ { return __x; }
-#endif
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif // __GXX_EXPERIMENTAL_CXX0X__
-#endif /* _GLIBCXX_COMPLEX */
+#endif /* _GLIBCXX_COMPLEX */
projects / gcc.git / blobdiff