libstdc++
tr1/complex
Go to the documentation of this file.
1// TR1 complex -*- C++ -*-
2
3// Copyright (C) 2006-2023 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 <bits/requires_hosted.h> // TR1
35
36#include <complex>
37
38namespace std _GLIBCXX_VISIBILITY(default)
39{
40_GLIBCXX_BEGIN_NAMESPACE_VERSION
41
42namespace tr1
43{
44 /**
45 * @addtogroup complex_numbers
46 * @{
47 */
48
49#if __cplusplus >= 201103L
50 using std::acos;
51 using std::asin;
52 using std::atan;
53 using std::acosh;
54 using std::asinh;
55 using std::atanh;
56#else
57 template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
58 template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
59 template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);
60 template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
61 template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
62 template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);
63#endif
64
65 // The std::fabs return type in C++11 mode is different (just _Tp).
66 template<typename _Tp> std::complex<_Tp> fabs(const std::complex<_Tp>&);
67
68#if __cplusplus < 201103L
69 template<typename _Tp>
70 inline std::complex<_Tp>
71 __complex_acos(const std::complex<_Tp>& __z)
72 {
73 const std::complex<_Tp> __t = std::tr1::asin(__z);
74 const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
75 return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
76 }
77
78#if _GLIBCXX_USE_C99_COMPLEX_TR1
79 inline __complex__ float
80 __complex_acos(__complex__ float __z)
81 { return __builtin_cacosf(__z); }
82
83 inline __complex__ double
84 __complex_acos(__complex__ double __z)
85 { return __builtin_cacos(__z); }
86
87 inline __complex__ long double
88 __complex_acos(const __complex__ long double& __z)
89 { return __builtin_cacosl(__z); }
90
91 template<typename _Tp>
92 inline std::complex<_Tp>
93 acos(const std::complex<_Tp>& __z)
94 { return __complex_acos(__z.__rep()); }
95#else
96 /// acos(__z) [8.1.2].
97 // Effects: Behaves the same as C99 function cacos, defined
98 // in subclause 7.3.5.1.
99 template<typename _Tp>
100 inline std::complex<_Tp>
101 acos(const std::complex<_Tp>& __z)
102 { return __complex_acos(__z); }
103#endif
104
105 template<typename _Tp>
106 inline std::complex<_Tp>
107 __complex_asin(const std::complex<_Tp>& __z)
108 {
109 std::complex<_Tp> __t(-__z.imag(), __z.real());
110 __t = std::tr1::asinh(__t);
111 return std::complex<_Tp>(__t.imag(), -__t.real());
112 }
113
114#if _GLIBCXX_USE_C99_COMPLEX_TR1
115 inline __complex__ float
116 __complex_asin(__complex__ float __z)
117 { return __builtin_casinf(__z); }
118
119 inline __complex__ double
120 __complex_asin(__complex__ double __z)
121 { return __builtin_casin(__z); }
122
123 inline __complex__ long double
124 __complex_asin(const __complex__ long double& __z)
125 { return __builtin_casinl(__z); }
126
127 template<typename _Tp>
128 inline std::complex<_Tp>
129 asin(const std::complex<_Tp>& __z)
130 { return __complex_asin(__z.__rep()); }
131#else
132 /// asin(__z) [8.1.3].
133 // Effects: Behaves the same as C99 function casin, defined
134 // in subclause 7.3.5.2.
135 template<typename _Tp>
136 inline std::complex<_Tp>
137 asin(const std::complex<_Tp>& __z)
138 { return __complex_asin(__z); }
139#endif
140
141 template<typename _Tp>
142 std::complex<_Tp>
143 __complex_atan(const std::complex<_Tp>& __z)
144 {
145 const _Tp __r2 = __z.real() * __z.real();
146 const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
147
148 _Tp __num = __z.imag() + _Tp(1.0);
149 _Tp __den = __z.imag() - _Tp(1.0);
150
151 __num = __r2 + __num * __num;
152 __den = __r2 + __den * __den;
153
154 return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
155 _Tp(0.25) * log(__num / __den));
156 }
157
158#if _GLIBCXX_USE_C99_COMPLEX_TR1
159 inline __complex__ float
160 __complex_atan(__complex__ float __z)
161 { return __builtin_catanf(__z); }
162
163 inline __complex__ double
164 __complex_atan(__complex__ double __z)
165 { return __builtin_catan(__z); }
166
167 inline __complex__ long double
168 __complex_atan(const __complex__ long double& __z)
169 { return __builtin_catanl(__z); }
170
171 template<typename _Tp>
172 inline std::complex<_Tp>
173 atan(const std::complex<_Tp>& __z)
174 { return __complex_atan(__z.__rep()); }
175#else
176 /// atan(__z) [8.1.4].
177 // Effects: Behaves the same as C99 function catan, defined
178 // in subclause 7.3.5.3.
179 template<typename _Tp>
180 inline std::complex<_Tp>
181 atan(const std::complex<_Tp>& __z)
182 { return __complex_atan(__z); }
183#endif
184
185 template<typename _Tp>
186 std::complex<_Tp>
187 __complex_acosh(const std::complex<_Tp>& __z)
188 {
189 // Kahan's formula.
190 return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0)))
191 + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0))));
192 }
193
194#if _GLIBCXX_USE_C99_COMPLEX_TR1
195 inline __complex__ float
196 __complex_acosh(__complex__ float __z)
197 { return __builtin_cacoshf(__z); }
198
199 inline __complex__ double
200 __complex_acosh(__complex__ double __z)
201 { return __builtin_cacosh(__z); }
202
203 inline __complex__ long double
204 __complex_acosh(const __complex__ long double& __z)
205 { return __builtin_cacoshl(__z); }
206
207 template<typename _Tp>
208 inline std::complex<_Tp>
209 acosh(const std::complex<_Tp>& __z)
210 { return __complex_acosh(__z.__rep()); }
211#else
212 /// acosh(__z) [8.1.5].
213 // Effects: Behaves the same as C99 function cacosh, defined
214 // in subclause 7.3.6.1.
215 template<typename _Tp>
216 inline std::complex<_Tp>
217 acosh(const std::complex<_Tp>& __z)
218 { return __complex_acosh(__z); }
219#endif
220
221 template<typename _Tp>
222 std::complex<_Tp>
223 __complex_asinh(const std::complex<_Tp>& __z)
224 {
225 std::complex<_Tp> __t((__z.real() - __z.imag())
226 * (__z.real() + __z.imag()) + _Tp(1.0),
227 _Tp(2.0) * __z.real() * __z.imag());
228 __t = std::sqrt(__t);
229
230 return std::log(__t + __z);
231 }
232
233#if _GLIBCXX_USE_C99_COMPLEX_TR1
234 inline __complex__ float
235 __complex_asinh(__complex__ float __z)
236 { return __builtin_casinhf(__z); }
237
238 inline __complex__ double
239 __complex_asinh(__complex__ double __z)
240 { return __builtin_casinh(__z); }
241
242 inline __complex__ long double
243 __complex_asinh(const __complex__ long double& __z)
244 { return __builtin_casinhl(__z); }
245
246 template<typename _Tp>
247 inline std::complex<_Tp>
248 asinh(const std::complex<_Tp>& __z)
249 { return __complex_asinh(__z.__rep()); }
250#else
251 /// asinh(__z) [8.1.6].
252 // Effects: Behaves the same as C99 function casin, defined
253 // in subclause 7.3.6.2.
254 template<typename _Tp>
255 inline std::complex<_Tp>
256 asinh(const std::complex<_Tp>& __z)
257 { return __complex_asinh(__z); }
258#endif
259
260 template<typename _Tp>
261 std::complex<_Tp>
262 __complex_atanh(const std::complex<_Tp>& __z)
263 {
264 const _Tp __i2 = __z.imag() * __z.imag();
265 const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
266
267 _Tp __num = _Tp(1.0) + __z.real();
268 _Tp __den = _Tp(1.0) - __z.real();
269
270 __num = __i2 + __num * __num;
271 __den = __i2 + __den * __den;
272
273 return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
274 _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
275 }
276
277#if _GLIBCXX_USE_C99_COMPLEX_TR1
278 inline __complex__ float
279 __complex_atanh(__complex__ float __z)
280 { return __builtin_catanhf(__z); }
281
282 inline __complex__ double
283 __complex_atanh(__complex__ double __z)
284 { return __builtin_catanh(__z); }
285
286 inline __complex__ long double
287 __complex_atanh(const __complex__ long double& __z)
288 { return __builtin_catanhl(__z); }
289
290 template<typename _Tp>
291 inline std::complex<_Tp>
292 atanh(const std::complex<_Tp>& __z)
293 { return __complex_atanh(__z.__rep()); }
294#else
295 /// atanh(__z) [8.1.7].
296 // Effects: Behaves the same as C99 function catanh, defined
297 // in subclause 7.3.6.3.
298 template<typename _Tp>
299 inline std::complex<_Tp>
300 atanh(const std::complex<_Tp>& __z)
301 { return __complex_atanh(__z); }
302#endif
303
304#endif // C++11
305
306 template<typename _Tp>
307 inline std::complex<_Tp>
308 /// fabs(__z) [8.1.8].
309 // Effects: Behaves the same as C99 function cabs, defined
310 // in subclause 7.3.8.1.
311 fabs(const std::complex<_Tp>& __z)
312 { return std::abs(__z); }
313
314 /// Additional overloads [8.1.9].
315#if __cplusplus < 201103L
316
317 template<typename _Tp>
318 inline typename __gnu_cxx::__promote<_Tp>::__type
319 arg(_Tp __x)
320 {
321 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
322#if (_GLIBCXX_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC)
323 return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L)
324 : __type();
325#else
326 return std::arg(std::complex<__type>(__x));
327#endif
328 }
329
330 template<typename _Tp>
331 inline typename __gnu_cxx::__promote<_Tp>::__type
332 imag(_Tp)
333 { return _Tp(); }
334
335 template<typename _Tp>
336 inline typename __gnu_cxx::__promote<_Tp>::__type
337 norm(_Tp __x)
338 {
339 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
340 return __type(__x) * __type(__x);
341 }
342
343 template<typename _Tp>
344 inline typename __gnu_cxx::__promote<_Tp>::__type
345 real(_Tp __x)
346 { return __x; }
347
348#endif
349
350 template<typename _Tp, typename _Up>
351 inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
352 pow(const std::complex<_Tp>& __x, const _Up& __y)
353 {
354 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
355 return std::pow(std::complex<__type>(__x), __type(__y));
356 }
357
358 template<typename _Tp, typename _Up>
359 inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
360 pow(const _Tp& __x, const std::complex<_Up>& __y)
361 {
362 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
363 return std::pow(__type(__x), std::complex<__type>(__y));
364 }
365
366 template<typename _Tp, typename _Up>
367 inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
368 pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
369 {
370 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
371 return std::pow(std::complex<__type>(__x),
372 std::complex<__type>(__y));
373 }
374
375 using std::arg;
376
377 template<typename _Tp>
378 inline std::complex<_Tp>
379 conj(const std::complex<_Tp>& __z)
380 { return std::conj(__z); }
381
382 template<typename _Tp>
383 inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
384 conj(_Tp __x)
385 { return __x; }
386
387 using std::imag;
388 using std::norm;
389 using std::polar;
390
391 template<typename _Tp, typename _Up>
392 inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
393 polar(const _Tp& __rho, const _Up& __theta)
394 {
395 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
396 return std::polar(__type(__rho), __type(__theta));
397 }
398
399 using std::real;
400
401 template<typename _Tp>
402 inline std::complex<_Tp>
403 pow(const std::complex<_Tp>& __x, const _Tp& __y)
404 { return std::pow(__x, __y); }
405
406 template<typename _Tp>
407 inline std::complex<_Tp>
408 pow(const _Tp& __x, const std::complex<_Tp>& __y)
409 { return std::pow(__x, __y); }
410
411 template<typename _Tp>
412 inline std::complex<_Tp>
413 pow(const std::complex<_Tp>& __x, const std::complex<_Tp>& __y)
414 { return std::pow(__x, __y); }
415
416/// @} group complex_numbers
417}
418
419_GLIBCXX_END_NAMESPACE_VERSION
420}
421
422#endif // _GLIBCXX_TR1_COMPLEX