OpenCores
URL https://opencores.org/ocsvn/altor32/altor32/trunk

Subversion Repositories altor32

[/] [altor32/] [trunk/] [gcc-x64/] [or1knd-elf/] [or1knd-elf/] [include/] [c++/] [4.8.0/] [tr1/] [complex] - Blame information for rev 35

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 35 ultra_embe 
// TR1 complex -*- C++ -*-
2 
 
3 
// Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
4 
// Free Software Foundation, Inc.
5 
//
6 
// This file is part of the GNU ISO C++ Library.  This library is free
7 
// software; you can redistribute it and/or modify it under the
8 
// terms of the GNU General Public License as published by the
9 
// Free Software Foundation; either version 3, or (at your option)
10 
// any later version.
11 
 
12 
// This library is distributed in the hope that it will be useful,
13 
// but WITHOUT ANY WARRANTY; without even the implied warranty of
14 
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 
// GNU General Public License for more details.
16 
 
17 
// Under Section 7 of GPL version 3, you are granted additional
18 
// permissions described in the GCC Runtime Library Exception, version
19 
// 3.1, as published by the Free Software Foundation.
20 
 
21 
// You should have received a copy of the GNU General Public License and
22 
// a copy of the GCC Runtime Library Exception along with this program;
23 
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
24 
// .
25 
 
26 
/** @file tr1/complex
27 
 *  This is a TR1 C++ Library header.
28 
 */
29 
 
30 
#ifndef _GLIBCXX_TR1_COMPLEX
31 
#define _GLIBCXX_TR1_COMPLEX 1
32 
 
33 
#pragma GCC system_header
34 
 
35 
#include
36 
 
37 
namespace std _GLIBCXX_VISIBILITY(default)
38 
{
39 
namespace tr1
40 
{
41 
_GLIBCXX_BEGIN_NAMESPACE_VERSION
42 
 
43 
  /**
44 
   * @addtogroup complex_numbers
45 
   * @{
46 
   */
47 
 
48 
#if __cplusplus >= 201103L
49 
  using std::acos;
50 
  using std::asin;
51 
  using std::atan;
52 
#else
53 
  template std::complex<_Tp> acos(const std::complex<_Tp>&);
54 
  template std::complex<_Tp> asin(const std::complex<_Tp>&);
55 
  template std::complex<_Tp> atan(const std::complex<_Tp>&);
56 
#endif
57 
 
58 
  template std::complex<_Tp> acosh(const std::complex<_Tp>&);
59 
  template std::complex<_Tp> asinh(const std::complex<_Tp>&);
60 
  template std::complex<_Tp> atanh(const std::complex<_Tp>&);
61 
 
62 
  // The std::fabs return type in C++0x mode is different (just _Tp).
63 
  template std::complex<_Tp> fabs(const std::complex<_Tp>&);
64 
 
65 
#if __cplusplus < 201103L
66 
  template
67 
    inline std::complex<_Tp>
68 
    __complex_acos(const std::complex<_Tp>& __z)
69 
    {
70 
      const std::complex<_Tp> __t = std::tr1::asin(__z);
71 
      const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
72 
      return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
73 
    }
74 
 
75 
#if _GLIBCXX_USE_C99_COMPLEX_TR1
76 
  inline __complex__ float
77 
  __complex_acos(__complex__ float __z)
78 
  { return __builtin_cacosf(__z); }
79 
 
80 
  inline __complex__ double
81 
  __complex_acos(__complex__ double __z)
82 
  { return __builtin_cacos(__z); }
83 
 
84 
  inline __complex__ long double
85 
  __complex_acos(const __complex__ long double& __z)
86 
  { return __builtin_cacosl(__z); }
87 
 
88 
  template
89 
    inline std::complex<_Tp>
90 
    acos(const std::complex<_Tp>& __z)
91 
    { return __complex_acos(__z.__rep()); }
92 
#else
93 
  /// acos(__z) [8.1.2].
94 
  //  Effects:  Behaves the same as C99 function cacos, defined
95 
  //            in subclause 7.3.5.1.
96 
  template
97 
    inline std::complex<_Tp>
98 
    acos(const std::complex<_Tp>& __z)
99 
    { return __complex_acos(__z); }
100 
#endif
101 
 
102 
  template
103 
    inline std::complex<_Tp>
104 
    __complex_asin(const std::complex<_Tp>& __z)
105 
    {
106 
      std::complex<_Tp> __t(-__z.imag(), __z.real());
107 
      __t = std::tr1::asinh(__t);
108 
      return std::complex<_Tp>(__t.imag(), -__t.real());
109 
    }
110 
 
111 
#if _GLIBCXX_USE_C99_COMPLEX_TR1
112 
  inline __complex__ float
113 
  __complex_asin(__complex__ float __z)
114 
  { return __builtin_casinf(__z); }
115 
 
116 
  inline __complex__ double
117 
  __complex_asin(__complex__ double __z)
118 
  { return __builtin_casin(__z); }
119 
 
120 
  inline __complex__ long double
121 
  __complex_asin(const __complex__ long double& __z)
122 
  { return __builtin_casinl(__z); }
123 
 
124 
  template
125 
    inline std::complex<_Tp>
126 
    asin(const std::complex<_Tp>& __z)
127 
    { return __complex_asin(__z.__rep()); }
128 
#else
129 
  /// asin(__z) [8.1.3].
130 
  //  Effects:  Behaves the same as C99 function casin, defined
131 
  //            in subclause 7.3.5.2.
132 
  template
133 
    inline std::complex<_Tp>
134 
    asin(const std::complex<_Tp>& __z)
135 
    { return __complex_asin(__z); }
136 
#endif
137 
 
138 
  template
139 
    std::complex<_Tp>
140 
    __complex_atan(const std::complex<_Tp>& __z)
141 
    {
142 
      const _Tp __r2 = __z.real() * __z.real();
143 
      const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
144 
 
145 
      _Tp __num = __z.imag() + _Tp(1.0);
146 
      _Tp __den = __z.imag() - _Tp(1.0);
147 
 
148 
      __num = __r2 + __num * __num;
149 
      __den = __r2 + __den * __den;
150 
 
151 
      return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
152 
                               _Tp(0.25) * log(__num / __den));
153 
    }
154 
 
155 
#if _GLIBCXX_USE_C99_COMPLEX_TR1
156 
  inline __complex__ float
157 
  __complex_atan(__complex__ float __z)
158 
  { return __builtin_catanf(__z); }
159 
 
160 
  inline __complex__ double
161 
  __complex_atan(__complex__ double __z)
162 
  { return __builtin_catan(__z); }
163 
 
164 
  inline __complex__ long double
165 
  __complex_atan(const __complex__ long double& __z)
166 
  { return __builtin_catanl(__z); }
167 
 
168 
  template
169 
    inline std::complex<_Tp>
170 
    atan(const std::complex<_Tp>& __z)
171 
    { return __complex_atan(__z.__rep()); }
172 
#else
173 
  /// atan(__z) [8.1.4].
174 
  //  Effects:  Behaves the same as C99 function catan, defined
175 
  //            in subclause 7.3.5.3.
176 
  template
177 
    inline std::complex<_Tp>
178 
    atan(const std::complex<_Tp>& __z)
179 
    { return __complex_atan(__z); }
180 
#endif
181 
 
182 
#endif // C++11
183 
 
184 
  template
185 
    std::complex<_Tp>
186 
    __complex_acosh(const std::complex<_Tp>& __z)
187 
    {
188 
      // Kahan's formula.
189 
      return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0)))
190 
                                 + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0))));
191 
    }
192 
 
193 
#if _GLIBCXX_USE_C99_COMPLEX_TR1
194 
  inline __complex__ float
195 
  __complex_acosh(__complex__ float __z)
196 
  { return __builtin_cacoshf(__z); }
197 
 
198 
  inline __complex__ double
199 
  __complex_acosh(__complex__ double __z)
200 
  { return __builtin_cacosh(__z); }
201 
 
202 
  inline __complex__ long double
203 
  __complex_acosh(const __complex__ long double& __z)
204 
  { return __builtin_cacoshl(__z); }
205 
 
206 
  template
207 
    inline std::complex<_Tp>
208 
    acosh(const std::complex<_Tp>& __z)
209 
    { return __complex_acosh(__z.__rep()); }
210 
#else
211 
  /// acosh(__z) [8.1.5].
212 
  //  Effects:  Behaves the same as C99 function cacosh, defined
213 
  //            in subclause 7.3.6.1.
214 
  template
215 
    inline std::complex<_Tp>
216 
    acosh(const std::complex<_Tp>& __z)
217 
    { return __complex_acosh(__z); }
218 
#endif
219 
 
220 
  template
221 
    std::complex<_Tp>
222 
    __complex_asinh(const std::complex<_Tp>& __z)
223 
    {
224 
      std::complex<_Tp> __t((__z.real() - __z.imag())
225 
                            * (__z.real() + __z.imag()) + _Tp(1.0),
226 
                            _Tp(2.0) * __z.real() * __z.imag());
227 
      __t = std::sqrt(__t);
228 
 
229 
      return std::log(__t + __z);
230 
    }
231 
 
232 
#if _GLIBCXX_USE_C99_COMPLEX_TR1
233 
  inline __complex__ float
234 
  __complex_asinh(__complex__ float __z)
235 
  { return __builtin_casinhf(__z); }
236 
 
237 
  inline __complex__ double
238 
  __complex_asinh(__complex__ double __z)
239 
  { return __builtin_casinh(__z); }
240 
 
241 
  inline __complex__ long double
242 
  __complex_asinh(const __complex__ long double& __z)
243 
  { return __builtin_casinhl(__z); }
244 
 
245 
  template
246 
    inline std::complex<_Tp>
247 
    asinh(const std::complex<_Tp>& __z)
248 
    { return __complex_asinh(__z.__rep()); }
249 
#else
250 
  /// asinh(__z) [8.1.6].
251 
  //  Effects:  Behaves the same as C99 function casin, defined
252 
  //            in subclause 7.3.6.2.
253 
  template
254 
    inline std::complex<_Tp>
255 
    asinh(const std::complex<_Tp>& __z)
256 
    { return __complex_asinh(__z); }
257 
#endif
258 
 
259 
  template
260 
    std::complex<_Tp>
261 
    __complex_atanh(const std::complex<_Tp>& __z)
262 
    {
263 
      const _Tp __i2 = __z.imag() * __z.imag();
264 
      const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
265 
 
266 
      _Tp __num = _Tp(1.0) + __z.real();
267 
      _Tp __den = _Tp(1.0) - __z.real();
268 
 
269 
      __num = __i2 + __num * __num;
270 
      __den = __i2 + __den * __den;
271 
 
272 
      return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
273 
                               _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
274 
    }
275 
 
276 
#if _GLIBCXX_USE_C99_COMPLEX_TR1
277 
  inline __complex__ float
278 
  __complex_atanh(__complex__ float __z)
279 
  { return __builtin_catanhf(__z); }
280 
 
281 
  inline __complex__ double
282 
  __complex_atanh(__complex__ double __z)
283 
  { return __builtin_catanh(__z); }
284 
 
285 
  inline __complex__ long double
286 
  __complex_atanh(const __complex__ long double& __z)
287 
  { return __builtin_catanhl(__z); }
288 
 
289 
  template
290 
    inline std::complex<_Tp>
291 
    atanh(const std::complex<_Tp>& __z)
292 
    { return __complex_atanh(__z.__rep()); }
293 
#else
294 
  /// atanh(__z) [8.1.7].
295 
  //  Effects:  Behaves the same as C99 function catanh, defined
296 
  //            in subclause 7.3.6.3.
297 
  template
298 
    inline std::complex<_Tp>
299 
    atanh(const std::complex<_Tp>& __z)
300 
    { return __complex_atanh(__z); }
301 
#endif
302 
 
303 
  template
304 
    inline std::complex<_Tp>
305 
    /// fabs(__z) [8.1.8].
306 
    //  Effects:  Behaves the same as C99 function cabs, defined
307 
    //            in subclause 7.3.8.1.
308 
    fabs(const std::complex<_Tp>& __z)
309 
    { return std::abs(__z); }
310 
 
311 
  /// Additional overloads [8.1.9].
312 
#if __cplusplus < 201103L
313 
 
314 
  template
315 
    inline typename __gnu_cxx::__promote<_Tp>::__type
316 
    arg(_Tp __x)
317 
    {
318 
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
319 
#if (_GLIBCXX_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC)
320 
      return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L)
321 
                               : __type();
322 
#else
323 
      return std::arg(std::complex<__type>(__x));
324 
#endif
325 
    }
326 
 
327 
  template
328 
    inline typename __gnu_cxx::__promote<_Tp>::__type
329 
    imag(_Tp)
330 
    { return _Tp(); }
331 
 
332 
  template
333 
    inline typename __gnu_cxx::__promote<_Tp>::__type
334 
    norm(_Tp __x)
335 
    {
336 
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
337 
      return __type(__x) * __type(__x);
338 
    }
339 
 
340 
  template
341 
    inline typename __gnu_cxx::__promote<_Tp>::__type
342 
    real(_Tp __x)
343 
    { return __x; }
344 
 
345 
#endif
346 
 
347 
  template
348 
    inline std::complex::__type>
349 
    pow(const std::complex<_Tp>& __x, const _Up& __y)
350 
    {
351 
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
352 
      return std::pow(std::complex<__type>(__x), __type(__y));
353 
    }
354 
 
355 
  template
356 
    inline std::complex::__type>
357 
    pow(const _Tp& __x, const std::complex<_Up>& __y)
358 
    {
359 
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
360 
      return std::pow(__type(__x), std::complex<__type>(__y));
361 
    }
362 
 
363 
  template
364 
    inline std::complex::__type>
365 
    pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
366 
    {
367 
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
368 
      return std::pow(std::complex<__type>(__x),
369 
                      std::complex<__type>(__y));
370 
    }
371 
 
372 
  using std::arg;
373 
 
374 
  template
375 
    inline std::complex<_Tp>
376 
    conj(const std::complex<_Tp>& __z)
377 
    { return std::conj(__z); }
378 
 
379 
  template
380 
    inline std::complex::__type>
381 
    conj(_Tp __x)
382 
    { return __x; }
383 
 
384 
  using std::imag;
385 
  using std::norm;
386 
  using std::polar;
387 
 
388 
  template
389 
    inline std::complex::__type>
390 
    polar(const _Tp& __rho, const _Up& __theta)
391 
    {
392 
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
393 
      return std::polar(__type(__rho), __type(__theta));
394 
    }
395 
 
396 
  using std::real;
397 
 
398 
  template
399 
    inline std::complex<_Tp>
400 
    pow(const std::complex<_Tp>& __x, const _Tp& __y)
401 
    { return std::pow(__x, __y); }
402 
 
403 
  template
404 
    inline std::complex<_Tp>
405 
    pow(const _Tp& __x, const std::complex<_Tp>& __y)
406 
    { return std::pow(__x, __y); }
407 
 
408 
  template
409 
    inline std::complex<_Tp>
410 
    pow(const std::complex<_Tp>& __x, const std::complex<_Tp>& __y)
411 
    { return std::pow(__x, __y); }
412 
 
413 
// @} group complex_numbers
414 
 
415 
_GLIBCXX_END_NAMESPACE_VERSION
416 
}
417 
}
418 
 
419 
#endif // _GLIBCXX_TR1_COMPLEX

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.