visus
/
toolchain-gcc-arm-embedded
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
Branch: main
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'main'
${ noResults }
toolchain-gcc-arm-embedded/arm-none-eabi/include/c++/10.2.1/tr1/complex

421 lines
12KB
Raw Permalink Blame History 

  1. // TR1 complex -*- C++ -*-

  2. 

  3. // Copyright (C) 2006-2020 Free Software Foundation, Inc.

  4. //

  5. // This file is part of the GNU ISO C++ Library.  This library is free

  6. // software; you can redistribute it and/or modify it under the

  7. // terms of the GNU General Public License as published by the

  8. // Free Software Foundation; either version 3, or (at your option)

  9. // any later version.

  10. 

  11. // This library is distributed in the hope that it will be useful,

  12. // but WITHOUT ANY WARRANTY; without even the implied warranty of

  13. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  14. // GNU General Public License for more details.

  15. 

  16. // Under Section 7 of GPL version 3, you are granted additional

  17. // permissions described in the GCC Runtime Library Exception, version

  18. // 3.1, as published by the Free Software Foundation.

  19. 

  20. // You should have received a copy of the GNU General Public License and

  21. // a copy of the GCC Runtime Library Exception along with this program;

  22. // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see

  23. // <http://www.gnu.org/licenses/>.

  24. 

  25. /** @file tr1/complex

  26.  *  This is a TR1 C++ Library header. 

  27.  */

  28. 

  29. #ifndef _GLIBCXX_TR1_COMPLEX

  30. #define _GLIBCXX_TR1_COMPLEX 1

  31. 

  32. #pragma GCC system_header

  33. 

  34. #include <complex>

  35. 

  36. namespace std _GLIBCXX_VISIBILITY(default)

  37. {

  38. _GLIBCXX_BEGIN_NAMESPACE_VERSION

  39. 

  40. namespace tr1

  41. {

  42.   /**

  43.    * @addtogroup complex_numbers

  44.    * @{

  45.    */

  46. 

  47. #if __cplusplus >= 201103L

  48.   using std::acos;

  49.   using std::asin;

  50.   using std::atan;

  51.   using std::acosh;

  52.   using std::asinh;

  53.   using std::atanh;

  54. #else

  55.   template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);

  56.   template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);

  57.   template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);

  58.   template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);

  59.   template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);

  60.   template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);

  61. #endif

  62. 

  63.   // The std::fabs return type in C++11 mode is different (just _Tp).

  64.   template<typename _Tp> std::complex<_Tp> fabs(const std::complex<_Tp>&);

  65. 

  66. #if __cplusplus < 201103L

  67.   template<typename _Tp>

  68.     inline std::complex<_Tp>

  69.     __complex_acos(const std::complex<_Tp>& __z)

  70.     {

  71.       const std::complex<_Tp> __t = std::tr1::asin(__z);

  72.       const _Tp __pi_2 = 1.5707963267948966192313216916397514L;

  73.       return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());

  74.     }

  75. 

  76. #if _GLIBCXX_USE_C99_COMPLEX_TR1

  77.   inline __complex__ float

  78.   __complex_acos(__complex__ float __z)

  79.   { return __builtin_cacosf(__z); }

  80. 

  81.   inline __complex__ double

  82.   __complex_acos(__complex__ double __z)

  83.   { return __builtin_cacos(__z); }

  84. 

  85.   inline __complex__ long double

  86.   __complex_acos(const __complex__ long double& __z)

  87.   { return __builtin_cacosl(__z); }

  88. 

  89.   template<typename _Tp>

  90.     inline std::complex<_Tp>

  91.     acos(const std::complex<_Tp>& __z)

  92.     { return __complex_acos(__z.__rep()); }

  93. #else

  94.   /// acos(__z) [8.1.2].

  95.   //  Effects:  Behaves the same as C99 function cacos, defined

  96.   //            in subclause 7.3.5.1.

  97.   template<typename _Tp>

  98.     inline std::complex<_Tp>

  99.     acos(const std::complex<_Tp>& __z)

  100.     { return __complex_acos(__z); }

  101. #endif

  102. 

  103.   template<typename _Tp>

  104.     inline std::complex<_Tp>

  105.     __complex_asin(const std::complex<_Tp>& __z)

  106.     {

  107.       std::complex<_Tp> __t(-__z.imag(), __z.real());

  108.       __t = std::tr1::asinh(__t);

  109.       return std::complex<_Tp>(__t.imag(), -__t.real());

  110.     }

  111. 

  112. #if _GLIBCXX_USE_C99_COMPLEX_TR1

  113.   inline __complex__ float

  114.   __complex_asin(__complex__ float __z)

  115.   { return __builtin_casinf(__z); }

  116. 

  117.   inline __complex__ double

  118.   __complex_asin(__complex__ double __z)

  119.   { return __builtin_casin(__z); }

  120. 

  121.   inline __complex__ long double

  122.   __complex_asin(const __complex__ long double& __z)

  123.   { return __builtin_casinl(__z); }

  124. 

  125.   template<typename _Tp>

  126.     inline std::complex<_Tp>

  127.     asin(const std::complex<_Tp>& __z)

  128.     { return __complex_asin(__z.__rep()); }

  129. #else

  130.   /// asin(__z) [8.1.3].

  131.   //  Effects:  Behaves the same as C99 function casin, defined

  132.   //            in subclause 7.3.5.2.

  133.   template<typename _Tp>

  134.     inline std::complex<_Tp>

  135.     asin(const std::complex<_Tp>& __z)

  136.     { return __complex_asin(__z); }

  137. #endif

  138.   

  139.   template<typename _Tp>

  140.     std::complex<_Tp>

  141.     __complex_atan(const std::complex<_Tp>& __z)

  142.     {

  143.       const _Tp __r2 = __z.real() * __z.real();

  144.       const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();

  145. 

  146.       _Tp __num = __z.imag() + _Tp(1.0);

  147.       _Tp __den = __z.imag() - _Tp(1.0);

  148. 

  149.       __num = __r2 + __num * __num;

  150.       __den = __r2 + __den * __den;

  151. 

  152.       return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),

  153. 			       _Tp(0.25) * log(__num / __den));

  154.     }

  155. 

  156. #if _GLIBCXX_USE_C99_COMPLEX_TR1

  157.   inline __complex__ float

  158.   __complex_atan(__complex__ float __z)

  159.   { return __builtin_catanf(__z); }

  160. 

  161.   inline __complex__ double

  162.   __complex_atan(__complex__ double __z)

  163.   { return __builtin_catan(__z); }

  164. 

  165.   inline __complex__ long double

  166.   __complex_atan(const __complex__ long double& __z)

  167.   { return __builtin_catanl(__z); }

  168. 

  169.   template<typename _Tp>

  170.     inline std::complex<_Tp>

  171.     atan(const std::complex<_Tp>& __z)

  172.     { return __complex_atan(__z.__rep()); }

  173. #else

  174.   /// atan(__z) [8.1.4].

  175.   //  Effects:  Behaves the same as C99 function catan, defined

  176.   //            in subclause 7.3.5.3.

  177.   template<typename _Tp>

  178.     inline std::complex<_Tp>

  179.     atan(const std::complex<_Tp>& __z)

  180.     { return __complex_atan(__z); }

  181. #endif

  182. 

  183.   template<typename _Tp>

  184.     std::complex<_Tp>

  185.     __complex_acosh(const std::complex<_Tp>& __z)

  186.     {

  187.       // Kahan's formula.

  188.       return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0)))

  189. 				 + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0))));

  190.     }

  191. 

  192. #if _GLIBCXX_USE_C99_COMPLEX_TR1

  193.   inline __complex__ float

  194.   __complex_acosh(__complex__ float __z)

  195.   { return __builtin_cacoshf(__z); }

  196. 

  197.   inline __complex__ double

  198.   __complex_acosh(__complex__ double __z)

  199.   { return __builtin_cacosh(__z); }

  200. 

  201.   inline __complex__ long double

  202.   __complex_acosh(const __complex__ long double& __z)

  203.   { return __builtin_cacoshl(__z); }

  204. 

  205.   template<typename _Tp>

  206.     inline std::complex<_Tp>

  207.     acosh(const std::complex<_Tp>& __z)

  208.     { return __complex_acosh(__z.__rep()); }

  209. #else

  210.   /// acosh(__z) [8.1.5].

  211.   //  Effects:  Behaves the same as C99 function cacosh, defined

  212.   //            in subclause 7.3.6.1.

  213.   template<typename _Tp>

  214.     inline std::complex<_Tp>

  215.     acosh(const std::complex<_Tp>& __z)

  216.     { return __complex_acosh(__z); }

  217. #endif

  218. 

  219.   template<typename _Tp>

  220.     std::complex<_Tp>

  221.     __complex_asinh(const std::complex<_Tp>& __z)

  222.     {

  223.       std::complex<_Tp> __t((__z.real() - __z.imag())

  224. 			    * (__z.real() + __z.imag()) + _Tp(1.0),

  225. 			    _Tp(2.0) * __z.real() * __z.imag());

  226.       __t = std::sqrt(__t);

  227. 

  228.       return std::log(__t + __z);

  229.     }

  230. 

  231. #if _GLIBCXX_USE_C99_COMPLEX_TR1

  232.   inline __complex__ float

  233.   __complex_asinh(__complex__ float __z)

  234.   { return __builtin_casinhf(__z); }

  235. 

  236.   inline __complex__ double

  237.   __complex_asinh(__complex__ double __z)

  238.   { return __builtin_casinh(__z); }

  239. 

  240.   inline __complex__ long double

  241.   __complex_asinh(const __complex__ long double& __z)

  242.   { return __builtin_casinhl(__z); }

  243. 

  244.   template<typename _Tp>

  245.     inline std::complex<_Tp>

  246.     asinh(const std::complex<_Tp>& __z)

  247.     { return __complex_asinh(__z.__rep()); }

  248. #else

  249.   /// asinh(__z) [8.1.6].

  250.   //  Effects:  Behaves the same as C99 function casin, defined

  251.   //            in subclause 7.3.6.2.

  252.   template<typename _Tp>

  253.     inline std::complex<_Tp>

  254.     asinh(const std::complex<_Tp>& __z)

  255.     { return __complex_asinh(__z); }

  256. #endif

  257. 

  258.   template<typename _Tp>

  259.     std::complex<_Tp>

  260.     __complex_atanh(const std::complex<_Tp>& __z)

  261.     {

  262.       const _Tp __i2 = __z.imag() * __z.imag();

  263.       const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();

  264. 

  265.       _Tp __num = _Tp(1.0) + __z.real();

  266.       _Tp __den = _Tp(1.0) - __z.real();

  267. 

  268.       __num = __i2 + __num * __num;

  269.       __den = __i2 + __den * __den;

  270. 

  271.       return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),

  272. 			       _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));

  273.     }

  274. 

  275. #if _GLIBCXX_USE_C99_COMPLEX_TR1

  276.   inline __complex__ float

  277.   __complex_atanh(__complex__ float __z)

  278.   { return __builtin_catanhf(__z); }

  279. 

  280.   inline __complex__ double

  281.   __complex_atanh(__complex__ double __z)

  282.   { return __builtin_catanh(__z); }

  283. 

  284.   inline __complex__ long double

  285.   __complex_atanh(const __complex__ long double& __z)

  286.   { return __builtin_catanhl(__z); }

  287. 

  288.   template<typename _Tp>

  289.     inline std::complex<_Tp>

  290.     atanh(const std::complex<_Tp>& __z)

  291.     { return __complex_atanh(__z.__rep()); }

  292. #else

  293.   /// atanh(__z) [8.1.7].

  294.   //  Effects:  Behaves the same as C99 function catanh, defined

  295.   //            in subclause 7.3.6.3.

  296.   template<typename _Tp>

  297.     inline std::complex<_Tp>

  298.     atanh(const std::complex<_Tp>& __z)

  299.     { return __complex_atanh(__z); }

  300. #endif

  301. 

  302. #endif // C++11

  303. 

  304.   template<typename _Tp>

  305.     inline std::complex<_Tp>

  306.     /// fabs(__z) [8.1.8].

  307.     //  Effects:  Behaves the same as C99 function cabs, defined

  308.     //            in subclause 7.3.8.1.

  309.     fabs(const std::complex<_Tp>& __z)

  310.     { return std::abs(__z); }

  311. 

  312.   /// Additional overloads [8.1.9].

  313. #if __cplusplus < 201103L

  314. 

  315.   template<typename _Tp>

  316.     inline typename __gnu_cxx::__promote<_Tp>::__type

  317.     arg(_Tp __x)

  318.     {

  319.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;

  320. #if (_GLIBCXX_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC)

  321.       return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L)

  322. 	                       : __type();

  323. #else

  324.       return std::arg(std::complex<__type>(__x));

  325. #endif

  326.     }

  327. 

  328.   template<typename _Tp>

  329.     inline typename __gnu_cxx::__promote<_Tp>::__type

  330.     imag(_Tp)

  331.     { return _Tp(); }

  332. 

  333.   template<typename _Tp>

  334.     inline typename __gnu_cxx::__promote<_Tp>::__type

  335.     norm(_Tp __x)

  336.     {

  337.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;

  338.       return __type(__x) * __type(__x);

  339.     }

  340. 

  341.   template<typename _Tp>

  342.     inline typename __gnu_cxx::__promote<_Tp>::__type

  343.     real(_Tp __x)

  344.     { return __x; }

  345. 

  346. #endif

  347. 

  348.   template<typename _Tp, typename _Up>

  349.     inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>

  350.     pow(const std::complex<_Tp>& __x, const _Up& __y)

  351.     {

  352.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;

  353.       return std::pow(std::complex<__type>(__x), __type(__y));

  354.     }

  355. 

  356.   template<typename _Tp, typename _Up>

  357.     inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>

  358.     pow(const _Tp& __x, const std::complex<_Up>& __y)

  359.     {

  360.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;

  361.       return std::pow(__type(__x), std::complex<__type>(__y));

  362.     }

  363. 

  364.   template<typename _Tp, typename _Up>

  365.     inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>

  366.     pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)

  367.     {

  368.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;

  369.       return std::pow(std::complex<__type>(__x),

  370. 		      std::complex<__type>(__y));

  371.     }

  372. 

  373.   using std::arg;

  374. 

  375.   template<typename _Tp>

  376.     inline std::complex<_Tp>

  377.     conj(const std::complex<_Tp>& __z)

  378.     { return std::conj(__z); }

  379. 

  380.   template<typename _Tp>

  381.     inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type>

  382.     conj(_Tp __x)

  383.     { return __x; }

  384. 

  385.   using std::imag;

  386.   using std::norm;

  387.   using std::polar;

  388. 

  389.   template<typename _Tp, typename _Up>

  390.     inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>

  391.     polar(const _Tp& __rho, const _Up& __theta)

  392.     {

  393.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;

  394.       return std::polar(__type(__rho), __type(__theta));

  395.     }

  396. 

  397.   using std::real;

  398. 

  399.   template<typename _Tp>

  400.     inline std::complex<_Tp>

  401.     pow(const std::complex<_Tp>& __x, const _Tp& __y)

  402.     { return std::pow(__x, __y); }

  403. 

  404.   template<typename _Tp>

  405.     inline std::complex<_Tp>

  406.     pow(const _Tp& __x, const std::complex<_Tp>& __y)

  407.     { return std::pow(__x, __y); }

  408. 

  409.   template<typename _Tp>

  410.     inline std::complex<_Tp>

  411.     pow(const std::complex<_Tp>& __x, const std::complex<_Tp>& __y)

  412.     { return std::pow(__x, __y); }

  413. 

  414. // @} group complex_numbers

  415. }

  416. 

  417. _GLIBCXX_END_NAMESPACE_VERSION

  418. }

  419. 

  420. #endif // _GLIBCXX_TR1_COMPLEX