1// TR1 complex -*- C++ -*- 2 3// Copyright (C) 2006-2018 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 36namespace std _GLIBCXX_VISIBILITY(default) 37{ 38_GLIBCXX_BEGIN_NAMESPACE_VERSION 39 40namespace 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 421