libstdc++
tr1/complex
Go to the documentation of this file.
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 
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