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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libstdc++-v3/] [include/] [std/] [complex] - Blame information for rev 766

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 742 jeremybenn 
// The template and inlines for the -*- C++ -*- complex number classes.
2 
 
3 
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4 
// 2006, 2007, 2008, 2009, 2010, 2011
5 
// Free Software Foundation, Inc.
6 
//
7 
// This file is part of the GNU ISO C++ Library.  This library is free
8 
// software; you can redistribute it and/or modify it under the
9 
// terms of the GNU General Public License as published by the
10 
// Free Software Foundation; either version 3, or (at your option)
11 
// any later version.
12 
 
13 
// This library is distributed in the hope that it will be useful,
14 
// but WITHOUT ANY WARRANTY; without even the implied warranty of
15 
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 
// GNU General Public License for more details.
17 
 
18 
// Under Section 7 of GPL version 3, you are granted additional
19 
// permissions described in the GCC Runtime Library Exception, version
20 
// 3.1, as published by the Free Software Foundation.
21 
 
22 
// You should have received a copy of the GNU General Public License and
23 
// a copy of the GCC Runtime Library Exception along with this program;
24 
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
25 
// .
26 
 
27 
/** @file include/complex
28 
 *  This is a Standard C++ Library header.
29 
 */
30 
 
31 
//
32 
// ISO C++ 14882: 26.2  Complex Numbers
33 
// Note: this is not a conforming implementation.
34 
// Initially implemented by Ulrich Drepper
35 
// Improved by Gabriel Dos Reis
36 
//
37 
 
38 
#ifndef _GLIBCXX_COMPLEX
39 
#define _GLIBCXX_COMPLEX 1
40 
 
41 
#pragma GCC system_header
42 
 
43 
#include
44 
#include
45 
#include
46 
#include
47 
#include
48 
 
49 
namespace std _GLIBCXX_VISIBILITY(default)
50 
{
51 
_GLIBCXX_BEGIN_NAMESPACE_VERSION
52 
 
53 
  /**
54 
   * @defgroup complex_numbers Complex Numbers
55 
   * @ingroup numerics
56 
   *
57 
   * Classes and functions for complex numbers.
58 
   * @{
59 
   */
60 
 
61 
  // Forward declarations.
62 
  template class complex;
63 
  template<> class complex;
64 
  template<> class complex;
65 
  template<> class complex;
66 
 
67 
  ///  Return magnitude of @a z.
68 
  template _Tp abs(const complex<_Tp>&);
69 
  ///  Return phase angle of @a z.
70 
  template _Tp arg(const complex<_Tp>&);
71 
  ///  Return @a z magnitude squared.
72 
  template _Tp norm(const complex<_Tp>&);
73 
 
74 
  ///  Return complex conjugate of @a z.
75 
  template complex<_Tp> conj(const complex<_Tp>&);
76 
  ///  Return complex with magnitude @a rho and angle @a theta.
77 
  template complex<_Tp> polar(const _Tp&, const _Tp& = 0);
78 
 
79 
  // Transcendentals:
80 
  /// Return complex cosine of @a z.
81 
  template complex<_Tp> cos(const complex<_Tp>&);
82 
  /// Return complex hyperbolic cosine of @a z.
83 
  template complex<_Tp> cosh(const complex<_Tp>&);
84 
  /// Return complex base e exponential of @a z.
85 
  template complex<_Tp> exp(const complex<_Tp>&);
86 
  /// Return complex natural logarithm of @a z.
87 
  template complex<_Tp> log(const complex<_Tp>&);
88 
  /// Return complex base 10 logarithm of @a z.
89 
  template complex<_Tp> log10(const complex<_Tp>&);
90 
#ifndef __GXX_EXPERIMENTAL_CXX0X__
91 
  // DR 844.
92 
  /// Return @a x to the @a y'th power.
93 
  template complex<_Tp> pow(const complex<_Tp>&, int);
94 
#endif
95 
  /// Return @a x to the @a y'th power.
96 
  template complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
97 
  /// Return @a x to the @a y'th power.
98 
  template complex<_Tp> pow(const complex<_Tp>&,
99 
                                          const complex<_Tp>&);
100 
  /// Return @a x to the @a y'th power.
101 
  template complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
102 
  /// Return complex sine of @a z.
103 
  template complex<_Tp> sin(const complex<_Tp>&);
104 
  /// Return complex hyperbolic sine of @a z.
105 
  template complex<_Tp> sinh(const complex<_Tp>&);
106 
  /// Return complex square root of @a z.
107 
  template complex<_Tp> sqrt(const complex<_Tp>&);
108 
  /// Return complex tangent of @a z.
109 
  template complex<_Tp> tan(const complex<_Tp>&);
110 
  /// Return complex hyperbolic tangent of @a z.
111 
  template complex<_Tp> tanh(const complex<_Tp>&);
112 
 
113 
 
114 
  // 26.2.2  Primary template class complex
115 
  /**
116 
   *  Template to represent complex numbers.
117 
   *
118 
   *  Specializations for float, double, and long double are part of the
119 
   *  library.  Results with any other type are not guaranteed.
120 
   *
121 
   *  @param  Tp  Type of real and imaginary values.
122 
  */
123 
  template
124 
    struct complex
125 
    {
126 
      /// Value typedef.
127 
      typedef _Tp value_type;
128 
 
129 
      ///  Default constructor.  First parameter is x, second parameter is y.
130 
      ///  Unspecified parameters default to 0.
131 
      _GLIBCXX_CONSTEXPR complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
132 
      : _M_real(__r), _M_imag(__i) { }
133 
 
134 
      // Lets the compiler synthesize the copy constructor
135 
      // complex (const complex<_Tp>&);
136 
      ///  Copy constructor.
137 
      template
138 
        _GLIBCXX_CONSTEXPR complex(const complex<_Up>& __z)
139 
        : _M_real(__z.real()), _M_imag(__z.imag()) { }
140 
 
141 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
142 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
143 
      // DR 387. std::complex over-encapsulated.
144 
      constexpr _Tp
145 
      real() { return _M_real; }
146 
 
147 
      constexpr _Tp
148 
      imag() { return _M_imag; }
149 
#else
150 
      ///  Return real part of complex number.
151 
      _Tp&
152 
      real() { return _M_real; }
153 
 
154 
      ///  Return real part of complex number.
155 
      const _Tp&
156 
      real() const { return _M_real; }
157 
 
158 
      ///  Return imaginary part of complex number.
159 
      _Tp&
160 
      imag() { return _M_imag; }
161 
 
162 
      ///  Return imaginary part of complex number.
163 
      const _Tp&
164 
      imag() const { return _M_imag; }
165 
#endif
166 
 
167 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
168 
      // DR 387. std::complex over-encapsulated.
169 
      void
170 
      real(_Tp __val) { _M_real = __val; }
171 
 
172 
      void
173 
      imag(_Tp __val) { _M_imag = __val; }
174 
 
175 
      /// Assign this complex number to scalar @a t.
176 
      complex<_Tp>& operator=(const _Tp&);
177 
 
178 
      /// Add @a t to this complex number.
179 
      // 26.2.5/1
180 
      complex<_Tp>&
181 
      operator+=(const _Tp& __t)
182 
      {
183 
        _M_real += __t;
184 
        return *this;
185 
      }
186 
 
187 
      /// Subtract @a t from this complex number.
188 
      // 26.2.5/3
189 
      complex<_Tp>&
190 
      operator-=(const _Tp& __t)
191 
      {
192 
        _M_real -= __t;
193 
        return *this;
194 
      }
195 
 
196 
      /// Multiply this complex number by @a t.
197 
      complex<_Tp>& operator*=(const _Tp&);
198 
      /// Divide this complex number by @a t.
199 
      complex<_Tp>& operator/=(const _Tp&);
200 
 
201 
      // Lets the compiler synthesize the
202 
      // copy and assignment operator
203 
      // complex<_Tp>& operator= (const complex<_Tp>&);
204 
      /// Assign this complex number to complex @a z.
205 
      template
206 
        complex<_Tp>& operator=(const complex<_Up>&);
207 
      /// Add @a z to this complex number.
208 
      template
209 
        complex<_Tp>& operator+=(const complex<_Up>&);
210 
      /// Subtract @a z from this complex number.
211 
      template
212 
        complex<_Tp>& operator-=(const complex<_Up>&);
213 
      /// Multiply this complex number by @a z.
214 
      template
215 
        complex<_Tp>& operator*=(const complex<_Up>&);
216 
      /// Divide this complex number by @a z.
217 
      template
218 
        complex<_Tp>& operator/=(const complex<_Up>&);
219 
 
220 
      _GLIBCXX_USE_CONSTEXPR complex __rep() const
221 
      { return *this; }
222 
 
223 
    private:
224 
      _Tp _M_real;
225 
      _Tp _M_imag;
226 
    };
227 
 
228 
  template
229 
    complex<_Tp>&
230 
    complex<_Tp>::operator=(const _Tp& __t)
231 
    {
232 
     _M_real = __t;
233 
     _M_imag = _Tp();
234 
     return *this;
235 
    }
236 
 
237 
  // 26.2.5/5
238 
  template
239 
    complex<_Tp>&
240 
    complex<_Tp>::operator*=(const _Tp& __t)
241 
    {
242 
      _M_real *= __t;
243 
      _M_imag *= __t;
244 
      return *this;
245 
    }
246 
 
247 
  // 26.2.5/7
248 
  template
249 
    complex<_Tp>&
250 
    complex<_Tp>::operator/=(const _Tp& __t)
251 
    {
252 
      _M_real /= __t;
253 
      _M_imag /= __t;
254 
      return *this;
255 
    }
256 
 
257 
  template
258 
    template
259 
    complex<_Tp>&
260 
    complex<_Tp>::operator=(const complex<_Up>& __z)
261 
    {
262 
      _M_real = __z.real();
263 
      _M_imag = __z.imag();
264 
      return *this;
265 
    }
266 
 
267 
  // 26.2.5/9
268 
  template
269 
    template
270 
    complex<_Tp>&
271 
    complex<_Tp>::operator+=(const complex<_Up>& __z)
272 
    {
273 
      _M_real += __z.real();
274 
      _M_imag += __z.imag();
275 
      return *this;
276 
    }
277 
 
278 
  // 26.2.5/11
279 
  template
280 
    template
281 
    complex<_Tp>&
282 
    complex<_Tp>::operator-=(const complex<_Up>& __z)
283 
    {
284 
      _M_real -= __z.real();
285 
      _M_imag -= __z.imag();
286 
      return *this;
287 
    }
288 
 
289 
  // 26.2.5/13
290 
  // XXX: This is a grammar school implementation.
291 
  template
292 
    template
293 
    complex<_Tp>&
294 
    complex<_Tp>::operator*=(const complex<_Up>& __z)
295 
    {
296 
      const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
297 
      _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
298 
      _M_real = __r;
299 
      return *this;
300 
    }
301 
 
302 
  // 26.2.5/15
303 
  // XXX: This is a grammar school implementation.
304 
  template
305 
    template
306 
    complex<_Tp>&
307 
    complex<_Tp>::operator/=(const complex<_Up>& __z)
308 
    {
309 
      const _Tp __r =  _M_real * __z.real() + _M_imag * __z.imag();
310 
      const _Tp __n = std::norm(__z);
311 
      _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
312 
      _M_real = __r / __n;
313 
      return *this;
314 
    }
315 
 
316 
  // Operators:
317 
  //@{
318 
  ///  Return new complex value @a x plus @a y.
319 
  template
320 
    inline complex<_Tp>
321 
    operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
322 
    {
323 
      complex<_Tp> __r = __x;
324 
      __r += __y;
325 
      return __r;
326 
    }
327 
 
328 
  template
329 
    inline complex<_Tp>
330 
    operator+(const complex<_Tp>& __x, const _Tp& __y)
331 
    {
332 
      complex<_Tp> __r = __x;
333 
      __r += __y;
334 
      return __r;
335 
    }
336 
 
337 
  template
338 
    inline complex<_Tp>
339 
    operator+(const _Tp& __x, const complex<_Tp>& __y)
340 
    {
341 
      complex<_Tp> __r = __y;
342 
      __r += __x;
343 
      return __r;
344 
    }
345 
  //@}
346 
 
347 
  //@{
348 
  ///  Return new complex value @a x minus @a y.
349 
  template
350 
    inline complex<_Tp>
351 
    operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
352 
    {
353 
      complex<_Tp> __r = __x;
354 
      __r -= __y;
355 
      return __r;
356 
    }
357 
 
358 
  template
359 
    inline complex<_Tp>
360 
    operator-(const complex<_Tp>& __x, const _Tp& __y)
361 
    {
362 
      complex<_Tp> __r = __x;
363 
      __r -= __y;
364 
      return __r;
365 
    }
366 
 
367 
  template
368 
    inline complex<_Tp>
369 
    operator-(const _Tp& __x, const complex<_Tp>& __y)
370 
    {
371 
      complex<_Tp> __r(__x, -__y.imag());
372 
      __r -= __y.real();
373 
      return __r;
374 
    }
375 
  //@}
376 
 
377 
  //@{
378 
  ///  Return new complex value @a x times @a y.
379 
  template
380 
    inline complex<_Tp>
381 
    operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
382 
    {
383 
      complex<_Tp> __r = __x;
384 
      __r *= __y;
385 
      return __r;
386 
    }
387 
 
388 
  template
389 
    inline complex<_Tp>
390 
    operator*(const complex<_Tp>& __x, const _Tp& __y)
391 
    {
392 
      complex<_Tp> __r = __x;
393 
      __r *= __y;
394 
      return __r;
395 
    }
396 
 
397 
  template
398 
    inline complex<_Tp>
399 
    operator*(const _Tp& __x, const complex<_Tp>& __y)
400 
    {
401 
      complex<_Tp> __r = __y;
402 
      __r *= __x;
403 
      return __r;
404 
    }
405 
  //@}
406 
 
407 
  //@{
408 
  ///  Return new complex value @a x divided by @a y.
409 
  template
410 
    inline complex<_Tp>
411 
    operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
412 
    {
413 
      complex<_Tp> __r = __x;
414 
      __r /= __y;
415 
      return __r;
416 
    }
417 
 
418 
  template
419 
    inline complex<_Tp>
420 
    operator/(const complex<_Tp>& __x, const _Tp& __y)
421 
    {
422 
      complex<_Tp> __r = __x;
423 
      __r /= __y;
424 
      return __r;
425 
    }
426 
 
427 
  template
428 
    inline complex<_Tp>
429 
    operator/(const _Tp& __x, const complex<_Tp>& __y)
430 
    {
431 
      complex<_Tp> __r = __x;
432 
      __r /= __y;
433 
      return __r;
434 
    }
435 
  //@}
436 
 
437 
  ///  Return @a x.
438 
  template
439 
    inline complex<_Tp>
440 
    operator+(const complex<_Tp>& __x)
441 
    { return __x; }
442 
 
443 
  ///  Return complex negation of @a x.
444 
  template
445 
    inline complex<_Tp>
446 
    operator-(const complex<_Tp>& __x)
447 
    {  return complex<_Tp>(-__x.real(), -__x.imag()); }
448 
 
449 
  //@{
450 
  ///  Return true if @a x is equal to @a y.
451 
  template
452 
    inline _GLIBCXX_CONSTEXPR bool
453 
    operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
454 
    { return __x.real() == __y.real() && __x.imag() == __y.imag(); }
455 
 
456 
  template
457 
    inline _GLIBCXX_CONSTEXPR bool
458 
    operator==(const complex<_Tp>& __x, const _Tp& __y)
459 
    { return __x.real() == __y && __x.imag() == _Tp(); }
460 
 
461 
  template
462 
    inline _GLIBCXX_CONSTEXPR bool
463 
    operator==(const _Tp& __x, const complex<_Tp>& __y)
464 
    { return __x == __y.real() && _Tp() == __y.imag(); }
465 
  //@}
466 
 
467 
  //@{
468 
  ///  Return false if @a x is equal to @a y.
469 
  template
470 
    inline _GLIBCXX_CONSTEXPR bool
471 
    operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
472 
    { return __x.real() != __y.real() || __x.imag() != __y.imag(); }
473 
 
474 
  template
475 
    inline _GLIBCXX_CONSTEXPR bool
476 
    operator!=(const complex<_Tp>& __x, const _Tp& __y)
477 
    { return __x.real() != __y || __x.imag() != _Tp(); }
478 
 
479 
  template
480 
    inline _GLIBCXX_CONSTEXPR bool
481 
    operator!=(const _Tp& __x, const complex<_Tp>& __y)
482 
    { return __x != __y.real() || _Tp() != __y.imag(); }
483 
  //@}
484 
 
485 
  ///  Extraction operator for complex values.
486 
  template
487 
    basic_istream<_CharT, _Traits>&
488 
    operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
489 
    {
490 
      _Tp __re_x, __im_x;
491 
      _CharT __ch;
492 
      __is >> __ch;
493 
      if (__ch == '(')
494 
        {
495 
          __is >> __re_x >> __ch;
496 
          if (__ch == ',')
497 
            {
498 
              __is >> __im_x >> __ch;
499 
              if (__ch == ')')
500 
                __x = complex<_Tp>(__re_x, __im_x);
501 
              else
502 
                __is.setstate(ios_base::failbit);
503 
            }
504 
          else if (__ch == ')')
505 
            __x = __re_x;
506 
          else
507 
            __is.setstate(ios_base::failbit);
508 
        }
509 
      else
510 
        {
511 
          __is.putback(__ch);
512 
          __is >> __re_x;
513 
          __x = __re_x;
514 
        }
515 
      return __is;
516 
    }
517 
 
518 
  ///  Insertion operator for complex values.
519 
  template
520 
    basic_ostream<_CharT, _Traits>&
521 
    operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
522 
    {
523 
      basic_ostringstream<_CharT, _Traits> __s;
524 
      __s.flags(__os.flags());
525 
      __s.imbue(__os.getloc());
526 
      __s.precision(__os.precision());
527 
      __s << '(' << __x.real() << ',' << __x.imag() << ')';
528 
      return __os << __s.str();
529 
    }
530 
 
531 
  // Values
532 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
533 
  template
534 
    constexpr _Tp
535 
    real(const complex<_Tp>& __z)
536 
    { return __z.real(); }
537 
 
538 
  template
539 
    constexpr _Tp
540 
    imag(const complex<_Tp>& __z)
541 
    { return __z.imag(); }
542 
#else
543 
  template
544 
    inline _Tp&
545 
    real(complex<_Tp>& __z)
546 
    { return __z.real(); }
547 
 
548 
  template
549 
    inline const _Tp&
550 
    real(const complex<_Tp>& __z)
551 
    { return __z.real(); }
552 
 
553 
  template
554 
    inline _Tp&
555 
    imag(complex<_Tp>& __z)
556 
    { return __z.imag(); }
557 
 
558 
  template
559 
    inline const _Tp&
560 
    imag(const complex<_Tp>& __z)
561 
    { return __z.imag(); }
562 
#endif
563 
 
564 
  // 26.2.7/3 abs(__z):  Returns the magnitude of __z.
565 
  template
566 
    inline _Tp
567 
    __complex_abs(const complex<_Tp>& __z)
568 
    {
569 
      _Tp __x = __z.real();
570 
      _Tp __y = __z.imag();
571 
      const _Tp __s = std::max(abs(__x), abs(__y));
572 
      if (__s == _Tp())  // well ...
573 
        return __s;
574 
      __x /= __s;
575 
      __y /= __s;
576 
      return __s * sqrt(__x * __x + __y * __y);
577 
    }
578 
 
579 
#if _GLIBCXX_USE_C99_COMPLEX
580 
  inline float
581 
  __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }
582 
 
583 
  inline double
584 
  __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }
585 
 
586 
  inline long double
587 
  __complex_abs(const __complex__ long double& __z)
588 
  { return __builtin_cabsl(__z); }
589 
 
590 
  template
591 
    inline _Tp
592 
    abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
593 
#else
594 
  template
595 
    inline _Tp
596 
    abs(const complex<_Tp>& __z) { return __complex_abs(__z); }
597 
#endif
598 
 
599 
 
600 
  // 26.2.7/4: arg(__z): Returns the phase angle of __z.
601 
  template
602 
    inline _Tp
603 
    __complex_arg(const complex<_Tp>& __z)
604 
    { return  atan2(__z.imag(), __z.real()); }
605 
 
606 
#if _GLIBCXX_USE_C99_COMPLEX
607 
  inline float
608 
  __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }
609 
 
610 
  inline double
611 
  __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }
612 
 
613 
  inline long double
614 
  __complex_arg(const __complex__ long double& __z)
615 
  { return __builtin_cargl(__z); }
616 
 
617 
  template
618 
    inline _Tp
619 
    arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
620 
#else
621 
  template
622 
    inline _Tp
623 
    arg(const complex<_Tp>& __z) { return __complex_arg(__z); }
624 
#endif
625 
 
626 
  // 26.2.7/5: norm(__z) returns the squared magnitude of __z.
627 
  //     As defined, norm() is -not- a norm is the common mathematical
628 
  //     sens used in numerics.  The helper class _Norm_helper<> tries to
629 
  //     distinguish between builtin floating point and the rest, so as
630 
  //     to deliver an answer as close as possible to the real value.
631 
  template
632 
    struct _Norm_helper
633 
    {
634 
      template
635 
        static inline _Tp _S_do_it(const complex<_Tp>& __z)
636 
        {
637 
          const _Tp __x = __z.real();
638 
          const _Tp __y = __z.imag();
639 
          return __x * __x + __y * __y;
640 
        }
641 
    };
642 
 
643 
  template<>
644 
    struct _Norm_helper
645 
    {
646 
      template
647 
        static inline _Tp _S_do_it(const complex<_Tp>& __z)
648 
        {
649 
          _Tp __res = std::abs(__z);
650 
          return __res * __res;
651 
        }
652 
    };
653 
 
654 
  template
655 
    inline _Tp
656 
    norm(const complex<_Tp>& __z)
657 
    {
658 
      return _Norm_helper<__is_floating<_Tp>::__value
659 
        && !_GLIBCXX_FAST_MATH>::_S_do_it(__z);
660 
    }
661 
 
662 
  template
663 
    inline complex<_Tp>
664 
    polar(const _Tp& __rho, const _Tp& __theta)
665 
    { return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); }
666 
 
667 
  template
668 
    inline complex<_Tp>
669 
    conj(const complex<_Tp>& __z)
670 
    { return complex<_Tp>(__z.real(), -__z.imag()); }
671 
 
672 
  // Transcendentals
673 
 
674 
  // 26.2.8/1 cos(__z):  Returns the cosine of __z.
675 
  template
676 
    inline complex<_Tp>
677 
    __complex_cos(const complex<_Tp>& __z)
678 
    {
679 
      const _Tp __x = __z.real();
680 
      const _Tp __y = __z.imag();
681 
      return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
682 
    }
683 
 
684 
#if _GLIBCXX_USE_C99_COMPLEX
685 
  inline __complex__ float
686 
  __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }
687 
 
688 
  inline __complex__ double
689 
  __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }
690 
 
691 
  inline __complex__ long double
692 
  __complex_cos(const __complex__ long double& __z)
693 
  { return __builtin_ccosl(__z); }
694 
 
695 
  template
696 
    inline complex<_Tp>
697 
    cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }
698 
#else
699 
  template
700 
    inline complex<_Tp>
701 
    cos(const complex<_Tp>& __z) { return __complex_cos(__z); }
702 
#endif
703 
 
704 
  // 26.2.8/2 cosh(__z): Returns the hyperbolic cosine of __z.
705 
  template
706 
    inline complex<_Tp>
707 
    __complex_cosh(const complex<_Tp>& __z)
708 
    {
709 
      const _Tp __x = __z.real();
710 
      const _Tp __y = __z.imag();
711 
      return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
712 
    }
713 
 
714 
#if _GLIBCXX_USE_C99_COMPLEX
715 
  inline __complex__ float
716 
  __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }
717 
 
718 
  inline __complex__ double
719 
  __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }
720 
 
721 
  inline __complex__ long double
722 
  __complex_cosh(const __complex__ long double& __z)
723 
  { return __builtin_ccoshl(__z); }
724 
 
725 
  template
726 
    inline complex<_Tp>
727 
    cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }
728 
#else
729 
  template
730 
    inline complex<_Tp>
731 
    cosh(const complex<_Tp>& __z) { return __complex_cosh(__z); }
732 
#endif
733 
 
734 
  // 26.2.8/3 exp(__z): Returns the complex base e exponential of x
735 
  template
736 
    inline complex<_Tp>
737 
    __complex_exp(const complex<_Tp>& __z)
738 
    { return std::polar(exp(__z.real()), __z.imag()); }
739 
 
740 
#if _GLIBCXX_USE_C99_COMPLEX
741 
  inline __complex__ float
742 
  __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }
743 
 
744 
  inline __complex__ double
745 
  __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }
746 
 
747 
  inline __complex__ long double
748 
  __complex_exp(const __complex__ long double& __z)
749 
  { return __builtin_cexpl(__z); }
750 
 
751 
  template
752 
    inline complex<_Tp>
753 
    exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
754 
#else
755 
  template
756 
    inline complex<_Tp>
757 
    exp(const complex<_Tp>& __z) { return __complex_exp(__z); }
758 
#endif
759 
 
760 
  // 26.2.8/5 log(__z): Returns the natural complex logarithm of __z.
761 
  //                    The branch cut is along the negative axis.
762 
  template
763 
    inline complex<_Tp>
764 
    __complex_log(const complex<_Tp>& __z)
765 
    { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
766 
 
767 
#if _GLIBCXX_USE_C99_COMPLEX
768 
  inline __complex__ float
769 
  __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }
770 
 
771 
  inline __complex__ double
772 
  __complex_log(__complex__ double __z) { return __builtin_clog(__z); }
773 
 
774 
  inline __complex__ long double
775 
  __complex_log(const __complex__ long double& __z)
776 
  { return __builtin_clogl(__z); }
777 
 
778 
  template
779 
    inline complex<_Tp>
780 
    log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }
781 
#else
782 
  template
783 
    inline complex<_Tp>
784 
    log(const complex<_Tp>& __z) { return __complex_log(__z); }
785 
#endif
786 
 
787 
  template
788 
    inline complex<_Tp>
789 
    log10(const complex<_Tp>& __z)
790 
    { return std::log(__z) / log(_Tp(10.0)); }
791 
 
792 
  // 26.2.8/10 sin(__z): Returns the sine of __z.
793 
  template
794 
    inline complex<_Tp>
795 
    __complex_sin(const complex<_Tp>& __z)
796 
    {
797 
      const _Tp __x = __z.real();
798 
      const _Tp __y = __z.imag();
799 
      return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
800 
    }
801 
 
802 
#if _GLIBCXX_USE_C99_COMPLEX
803 
  inline __complex__ float
804 
  __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }
805 
 
806 
  inline __complex__ double
807 
  __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }
808 
 
809 
  inline __complex__ long double
810 
  __complex_sin(const __complex__ long double& __z)
811 
  { return __builtin_csinl(__z); }
812 
 
813 
  template
814 
    inline complex<_Tp>
815 
    sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }
816 
#else
817 
  template
818 
    inline complex<_Tp>
819 
    sin(const complex<_Tp>& __z) { return __complex_sin(__z); }
820 
#endif
821 
 
822 
  // 26.2.8/11 sinh(__z): Returns the hyperbolic sine of __z.
823 
  template
824 
    inline complex<_Tp>
825 
    __complex_sinh(const complex<_Tp>& __z)
826 
    {
827 
      const _Tp __x = __z.real();
828 
      const _Tp  __y = __z.imag();
829 
      return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
830 
    }
831 
 
832 
#if _GLIBCXX_USE_C99_COMPLEX
833 
  inline __complex__ float
834 
  __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
835 
 
836 
  inline __complex__ double
837 
  __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }
838 
 
839 
  inline __complex__ long double
840 
  __complex_sinh(const __complex__ long double& __z)
841 
  { return __builtin_csinhl(__z); }
842 
 
843 
  template
844 
    inline complex<_Tp>
845 
    sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
846 
#else
847 
  template
848 
    inline complex<_Tp>
849 
    sinh(const complex<_Tp>& __z) { return __complex_sinh(__z); }
850 
#endif
851 
 
852 
  // 26.2.8/13 sqrt(__z): Returns the complex square root of __z.
853 
  //                     The branch cut is on the negative axis.
854 
  template
855 
    complex<_Tp>
856 
    __complex_sqrt(const complex<_Tp>& __z)
857 
    {
858 
      _Tp __x = __z.real();
859 
      _Tp __y = __z.imag();
860 
 
861 
      if (__x == _Tp())
862 
        {
863 
          _Tp __t = sqrt(abs(__y) / 2);
864 
          return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
865 
        }
866 
      else
867 
        {
868 
          _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
869 
          _Tp __u = __t / 2;
870 
          return __x > _Tp()
871 
            ? complex<_Tp>(__u, __y / __t)
872 
            : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
873 
        }
874 
    }
875 
 
876 
#if _GLIBCXX_USE_C99_COMPLEX
877 
  inline __complex__ float
878 
  __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }
879 
 
880 
  inline __complex__ double
881 
  __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }
882 
 
883 
  inline __complex__ long double
884 
  __complex_sqrt(const __complex__ long double& __z)
885 
  { return __builtin_csqrtl(__z); }
886 
 
887 
  template
888 
    inline complex<_Tp>
889 
    sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
890 
#else
891 
  template
892 
    inline complex<_Tp>
893 
    sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z); }
894 
#endif
895 
 
896 
  // 26.2.8/14 tan(__z):  Return the complex tangent of __z.
897 
 
898 
  template
899 
    inline complex<_Tp>
900 
    __complex_tan(const complex<_Tp>& __z)
901 
    { return std::sin(__z) / std::cos(__z); }
902 
 
903 
#if _GLIBCXX_USE_C99_COMPLEX
904 
  inline __complex__ float
905 
  __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }
906 
 
907 
  inline __complex__ double
908 
  __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }
909 
 
910 
  inline __complex__ long double
911 
  __complex_tan(const __complex__ long double& __z)
912 
  { return __builtin_ctanl(__z); }
913 
 
914 
  template
915 
    inline complex<_Tp>
916 
    tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
917 
#else
918 
  template
919 
    inline complex<_Tp>
920 
    tan(const complex<_Tp>& __z) { return __complex_tan(__z); }
921 
#endif
922 
 
923 
 
924 
  // 26.2.8/15 tanh(__z):  Returns the hyperbolic tangent of __z.
925 
 
926 
  template
927 
    inline complex<_Tp>
928 
    __complex_tanh(const complex<_Tp>& __z)
929 
    { return std::sinh(__z) / std::cosh(__z); }
930 
 
931 
#if _GLIBCXX_USE_C99_COMPLEX
932 
  inline __complex__ float
933 
  __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }
934 
 
935 
  inline __complex__ double
936 
  __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }
937 
 
938 
  inline __complex__ long double
939 
  __complex_tanh(const __complex__ long double& __z)
940 
  { return __builtin_ctanhl(__z); }
941 
 
942 
  template
943 
    inline complex<_Tp>
944 
    tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
945 
#else
946 
  template
947 
    inline complex<_Tp>
948 
    tanh(const complex<_Tp>& __z) { return __complex_tanh(__z); }
949 
#endif
950 
 
951 
 
952 
  // 26.2.8/9  pow(__x, __y): Returns the complex power base of __x
953 
  //                          raised to the __y-th power.  The branch
954 
  //                          cut is on the negative axis.
955 
#ifndef __GXX_EXPERIMENTAL_CXX0X__
956 
  template
957 
    complex<_Tp>
958 
    __complex_pow_unsigned(complex<_Tp> __x, unsigned __n)
959 
    {
960 
      complex<_Tp> __y = __n % 2 ? __x : complex<_Tp>(1);
961 
 
962 
      while (__n >>= 1)
963 
        {
964 
          __x *= __x;
965 
          if (__n % 2)
966 
            __y *= __x;
967 
        }
968 
 
969 
      return __y;
970 
    }
971 
 
972 
  // _GLIBCXX_RESOLVE_LIB_DEFECTS
973 
  // DR 844. complex pow return type is ambiguous.
974 
  template
975 
    inline complex<_Tp>
976 
    pow(const complex<_Tp>& __z, int __n)
977 
    {
978 
      return __n < 0
979 
        ? complex<_Tp>(1) / std::__complex_pow_unsigned(__z, -__n)
980 
        : std::__complex_pow_unsigned(__z, __n);
981 
    }
982 
#endif
983 
 
984 
  template
985 
    complex<_Tp>
986 
    pow(const complex<_Tp>& __x, const _Tp& __y)
987 
    {
988 
#ifndef _GLIBCXX_USE_C99_COMPLEX
989 
      if (__x == _Tp())
990 
        return _Tp();
991 
#endif
992 
      if (__x.imag() == _Tp() && __x.real() > _Tp())
993 
        return pow(__x.real(), __y);
994 
 
995 
      complex<_Tp> __t = std::log(__x);
996 
      return std::polar(exp(__y * __t.real()), __y * __t.imag());
997 
    }
998 
 
999 
  template
1000 
    inline complex<_Tp>
1001 
    __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1002 
    { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
1003 
 
1004 
#if _GLIBCXX_USE_C99_COMPLEX
1005 
  inline __complex__ float
1006 
  __complex_pow(__complex__ float __x, __complex__ float __y)
1007 
  { return __builtin_cpowf(__x, __y); }
1008 
 
1009 
  inline __complex__ double
1010 
  __complex_pow(__complex__ double __x, __complex__ double __y)
1011 
  { return __builtin_cpow(__x, __y); }
1012 
 
1013 
  inline __complex__ long double
1014 
  __complex_pow(const __complex__ long double& __x,
1015 
                const __complex__ long double& __y)
1016 
  { return __builtin_cpowl(__x, __y); }
1017 
 
1018 
  template
1019 
    inline complex<_Tp>
1020 
    pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1021 
    { return __complex_pow(__x.__rep(), __y.__rep()); }
1022 
#else
1023 
  template
1024 
    inline complex<_Tp>
1025 
    pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
1026 
    { return __complex_pow(__x, __y); }
1027 
#endif
1028 
 
1029 
  template
1030 
    inline complex<_Tp>
1031 
    pow(const _Tp& __x, const complex<_Tp>& __y)
1032 
    {
1033 
      return __x > _Tp() ? std::polar(pow(__x, __y.real()),
1034 
                                      __y.imag() * log(__x))
1035 
                         : std::pow(complex<_Tp>(__x), __y);
1036 
    }
1037 
 
1038 
  /// 26.2.3  complex specializations
1039 
  /// complex specialization
1040 
  template<>
1041 
    struct complex
1042 
    {
1043 
      typedef float value_type;
1044 
      typedef __complex__ float _ComplexT;
1045 
 
1046 
      _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1047 
 
1048 
      _GLIBCXX_CONSTEXPR complex(float __r = 0.0f, float __i = 0.0f)
1049 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
1050 
      : _M_value{ __r, __i } { }
1051 
#else
1052 
      {
1053 
        __real__ _M_value = __r;
1054 
        __imag__ _M_value = __i;
1055 
      }
1056 
#endif
1057 
 
1058 
      explicit _GLIBCXX_CONSTEXPR complex(const complex&);
1059 
      explicit _GLIBCXX_CONSTEXPR complex(const complex&);
1060 
 
1061 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
1062 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
1063 
      // DR 387. std::complex over-encapsulated.
1064 
      constexpr float
1065 
      real() { return __real__ _M_value; }
1066 
 
1067 
      constexpr float
1068 
      imag() { return __imag__ _M_value; }
1069 
#else
1070 
      float&
1071 
      real() { return __real__ _M_value; }
1072 
 
1073 
      const float&
1074 
      real() const { return __real__ _M_value; }
1075 
 
1076 
      float&
1077 
      imag() { return __imag__ _M_value; }
1078 
 
1079 
      const float&
1080 
      imag() const { return __imag__ _M_value; }
1081 
#endif
1082 
 
1083 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
1084 
      // DR 387. std::complex over-encapsulated.
1085 
      void
1086 
      real(float __val) { __real__ _M_value = __val; }
1087 
 
1088 
      void
1089 
      imag(float __val) { __imag__ _M_value = __val; }
1090 
 
1091 
      complex&
1092 
      operator=(float __f)
1093 
      {
1094 
        _M_value = __f;
1095 
        return *this;
1096 
      }
1097 
 
1098 
      complex&
1099 
      operator+=(float __f)
1100 
      {
1101 
        _M_value += __f;
1102 
        return *this;
1103 
      }
1104 
 
1105 
      complex&
1106 
      operator-=(float __f)
1107 
      {
1108 
        _M_value -= __f;
1109 
        return *this;
1110 
      }
1111 
 
1112 
      complex&
1113 
      operator*=(float __f)
1114 
      {
1115 
        _M_value *= __f;
1116 
        return *this;
1117 
      }
1118 
 
1119 
      complex&
1120 
      operator/=(float __f)
1121 
      {
1122 
        _M_value /= __f;
1123 
        return *this;
1124 
      }
1125 
 
1126 
      // Let the compiler synthesize the copy and assignment
1127 
      // operator.  It always does a pretty good job.
1128 
      // complex& operator=(const complex&);
1129 
 
1130 
      template
1131 
        complex&
1132 
        operator=(const complex<_Tp>&  __z)
1133 
        {
1134 
          __real__ _M_value = __z.real();
1135 
          __imag__ _M_value = __z.imag();
1136 
          return *this;
1137 
        }
1138 
 
1139 
      template
1140 
        complex&
1141 
        operator+=(const complex<_Tp>& __z)
1142 
        {
1143 
          __real__ _M_value += __z.real();
1144 
          __imag__ _M_value += __z.imag();
1145 
          return *this;
1146 
        }
1147 
 
1148 
      template
1149 
        complex&
1150 
        operator-=(const complex<_Tp>& __z)
1151 
        {
1152 
          __real__ _M_value -= __z.real();
1153 
          __imag__ _M_value -= __z.imag();
1154 
          return *this;
1155 
        }
1156 
 
1157 
      template
1158 
        complex&
1159 
        operator*=(const complex<_Tp>& __z)
1160 
        {
1161 
          _ComplexT __t;
1162 
          __real__ __t = __z.real();
1163 
          __imag__ __t = __z.imag();
1164 
          _M_value *= __t;
1165 
          return *this;
1166 
        }
1167 
 
1168 
      template
1169 
        complex&
1170 
        operator/=(const complex<_Tp>& __z)
1171 
        {
1172 
          _ComplexT __t;
1173 
          __real__ __t = __z.real();
1174 
          __imag__ __t = __z.imag();
1175 
          _M_value /= __t;
1176 
          return *this;
1177 
        }
1178 
 
1179 
      _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1180 
 
1181 
    private:
1182 
      _ComplexT _M_value;
1183 
    };
1184 
 
1185 
  /// 26.2.3  complex specializations
1186 
  /// complex specialization
1187 
  template<>
1188 
    struct complex
1189 
    {
1190 
      typedef double value_type;
1191 
      typedef __complex__ double _ComplexT;
1192 
 
1193 
      _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1194 
 
1195 
      _GLIBCXX_CONSTEXPR complex(double __r = 0.0, double __i = 0.0)
1196 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
1197 
      : _M_value{ __r, __i } { }
1198 
#else
1199 
      {
1200 
        __real__ _M_value = __r;
1201 
        __imag__ _M_value = __i;
1202 
      }
1203 
#endif
1204 
 
1205 
      _GLIBCXX_CONSTEXPR complex(const complex& __z)
1206 
      : _M_value(__z.__rep()) { }
1207 
 
1208 
      explicit _GLIBCXX_CONSTEXPR complex(const complex&);
1209 
 
1210 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
1211 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
1212 
      // DR 387. std::complex over-encapsulated.
1213 
      constexpr double
1214 
      real() { return __real__ _M_value; }
1215 
 
1216 
      constexpr double
1217 
      imag() { return __imag__ _M_value; }
1218 
#else
1219 
      double&
1220 
      real() { return __real__ _M_value; }
1221 
 
1222 
      const double&
1223 
      real() const { return __real__ _M_value; }
1224 
 
1225 
      double&
1226 
      imag() { return __imag__ _M_value; }
1227 
 
1228 
      const double&
1229 
      imag() const { return __imag__ _M_value; }
1230 
#endif
1231 
 
1232 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
1233 
      // DR 387. std::complex over-encapsulated.
1234 
      void
1235 
      real(double __val) { __real__ _M_value = __val; }
1236 
 
1237 
      void
1238 
      imag(double __val) { __imag__ _M_value = __val; }
1239 
 
1240 
      complex&
1241 
      operator=(double __d)
1242 
      {
1243 
        _M_value = __d;
1244 
        return *this;
1245 
      }
1246 
 
1247 
      complex&
1248 
      operator+=(double __d)
1249 
      {
1250 
        _M_value += __d;
1251 
        return *this;
1252 
      }
1253 
 
1254 
      complex&
1255 
      operator-=(double __d)
1256 
      {
1257 
        _M_value -= __d;
1258 
        return *this;
1259 
      }
1260 
 
1261 
      complex&
1262 
      operator*=(double __d)
1263 
      {
1264 
        _M_value *= __d;
1265 
        return *this;
1266 
      }
1267 
 
1268 
      complex&
1269 
      operator/=(double __d)
1270 
      {
1271 
        _M_value /= __d;
1272 
        return *this;
1273 
      }
1274 
 
1275 
      // The compiler will synthesize this, efficiently.
1276 
      // complex& operator=(const complex&);
1277 
 
1278 
      template
1279 
        complex&
1280 
        operator=(const complex<_Tp>& __z)
1281 
        {
1282 
          __real__ _M_value = __z.real();
1283 
          __imag__ _M_value = __z.imag();
1284 
          return *this;
1285 
        }
1286 
 
1287 
      template
1288 
        complex&
1289 
        operator+=(const complex<_Tp>& __z)
1290 
        {
1291 
          __real__ _M_value += __z.real();
1292 
          __imag__ _M_value += __z.imag();
1293 
          return *this;
1294 
        }
1295 
 
1296 
      template
1297 
        complex&
1298 
        operator-=(const complex<_Tp>& __z)
1299 
        {
1300 
          __real__ _M_value -= __z.real();
1301 
          __imag__ _M_value -= __z.imag();
1302 
          return *this;
1303 
        }
1304 
 
1305 
      template
1306 
        complex&
1307 
        operator*=(const complex<_Tp>& __z)
1308 
        {
1309 
          _ComplexT __t;
1310 
          __real__ __t = __z.real();
1311 
          __imag__ __t = __z.imag();
1312 
          _M_value *= __t;
1313 
          return *this;
1314 
        }
1315 
 
1316 
      template
1317 
        complex&
1318 
        operator/=(const complex<_Tp>& __z)
1319 
        {
1320 
          _ComplexT __t;
1321 
          __real__ __t = __z.real();
1322 
          __imag__ __t = __z.imag();
1323 
          _M_value /= __t;
1324 
          return *this;
1325 
        }
1326 
 
1327 
      _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1328 
 
1329 
    private:
1330 
      _ComplexT _M_value;
1331 
    };
1332 
 
1333 
  /// 26.2.3  complex specializations
1334 
  /// complex specialization
1335 
  template<>
1336 
    struct complex
1337 
    {
1338 
      typedef long double value_type;
1339 
      typedef __complex__ long double _ComplexT;
1340 
 
1341 
      _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { }
1342 
 
1343 
      _GLIBCXX_CONSTEXPR complex(long double __r = 0.0L,
1344 
                                 long double __i = 0.0L)
1345 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
1346 
      : _M_value{ __r, __i } { }
1347 
#else
1348 
      {
1349 
        __real__ _M_value = __r;
1350 
        __imag__ _M_value = __i;
1351 
      }
1352 
#endif
1353 
 
1354 
      _GLIBCXX_CONSTEXPR complex(const complex& __z)
1355 
      : _M_value(__z.__rep()) { }
1356 
 
1357 
      _GLIBCXX_CONSTEXPR complex(const complex& __z)
1358 
      : _M_value(__z.__rep()) { }
1359 
 
1360 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
1361 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
1362 
      // DR 387. std::complex over-encapsulated.
1363 
      constexpr long double
1364 
      real() { return __real__ _M_value; }
1365 
 
1366 
      constexpr long double
1367 
      imag() { return __imag__ _M_value; }
1368 
#else
1369 
      long double&
1370 
      real() { return __real__ _M_value; }
1371 
 
1372 
      const long double&
1373 
      real() const { return __real__ _M_value; }
1374 
 
1375 
      long double&
1376 
      imag() { return __imag__ _M_value; }
1377 
 
1378 
      const long double&
1379 
      imag() const { return __imag__ _M_value; }
1380 
#endif
1381 
 
1382 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
1383 
      // DR 387. std::complex over-encapsulated.
1384 
      void
1385 
      real(long double __val) { __real__ _M_value = __val; }
1386 
 
1387 
      void
1388 
      imag(long double __val) { __imag__ _M_value = __val; }
1389 
 
1390 
      complex&
1391 
      operator=(long double __r)
1392 
      {
1393 
        _M_value = __r;
1394 
        return *this;
1395 
      }
1396 
 
1397 
      complex&
1398 
      operator+=(long double __r)
1399 
      {
1400 
        _M_value += __r;
1401 
        return *this;
1402 
      }
1403 
 
1404 
      complex&
1405 
      operator-=(long double __r)
1406 
      {
1407 
        _M_value -= __r;
1408 
        return *this;
1409 
      }
1410 
 
1411 
      complex&
1412 
      operator*=(long double __r)
1413 
      {
1414 
        _M_value *= __r;
1415 
        return *this;
1416 
      }
1417 
 
1418 
      complex&
1419 
      operator/=(long double __r)
1420 
      {
1421 
        _M_value /= __r;
1422 
        return *this;
1423 
      }
1424 
 
1425 
      // The compiler knows how to do this efficiently
1426 
      // complex& operator=(const complex&);
1427 
 
1428 
      template
1429 
        complex&
1430 
        operator=(const complex<_Tp>& __z)
1431 
        {
1432 
          __real__ _M_value = __z.real();
1433 
          __imag__ _M_value = __z.imag();
1434 
          return *this;
1435 
        }
1436 
 
1437 
      template
1438 
        complex&
1439 
        operator+=(const complex<_Tp>& __z)
1440 
        {
1441 
          __real__ _M_value += __z.real();
1442 
          __imag__ _M_value += __z.imag();
1443 
          return *this;
1444 
        }
1445 
 
1446 
      template
1447 
        complex&
1448 
        operator-=(const complex<_Tp>& __z)
1449 
        {
1450 
          __real__ _M_value -= __z.real();
1451 
          __imag__ _M_value -= __z.imag();
1452 
          return *this;
1453 
        }
1454 
 
1455 
      template
1456 
        complex&
1457 
        operator*=(const complex<_Tp>& __z)
1458 
        {
1459 
          _ComplexT __t;
1460 
          __real__ __t = __z.real();
1461 
          __imag__ __t = __z.imag();
1462 
          _M_value *= __t;
1463 
          return *this;
1464 
        }
1465 
 
1466 
      template
1467 
        complex&
1468 
        operator/=(const complex<_Tp>& __z)
1469 
        {
1470 
          _ComplexT __t;
1471 
          __real__ __t = __z.real();
1472 
          __imag__ __t = __z.imag();
1473 
          _M_value /= __t;
1474 
          return *this;
1475 
        }
1476 
 
1477 
      _GLIBCXX_USE_CONSTEXPR _ComplexT __rep() const { return _M_value; }
1478 
 
1479 
    private:
1480 
      _ComplexT _M_value;
1481 
    };
1482 
 
1483 
  // These bits have to be at the end of this file, so that the
1484 
  // specializations have all been defined.
1485 
  inline _GLIBCXX_CONSTEXPR
1486 
  complex::complex(const complex& __z)
1487 
  : _M_value(__z.__rep()) { }
1488 
 
1489 
  inline _GLIBCXX_CONSTEXPR
1490 
  complex::complex(const complex& __z)
1491 
  : _M_value(__z.__rep()) { }
1492 
 
1493 
  inline _GLIBCXX_CONSTEXPR
1494 
  complex::complex(const complex& __z)
1495 
  : _M_value(__z.__rep()) { }
1496 
 
1497 
  // Inhibit implicit instantiations for required instantiations,
1498 
  // which are defined via explicit instantiations elsewhere.
1499 
  // NB:  This syntax is a GNU extension.
1500 
#if _GLIBCXX_EXTERN_TEMPLATE
1501 
  extern template istream& operator>>(istream&, complex&);
1502 
  extern template ostream& operator<<(ostream&, const complex&);
1503 
  extern template istream& operator>>(istream&, complex&);
1504 
  extern template ostream& operator<<(ostream&, const complex&);
1505 
  extern template istream& operator>>(istream&, complex&);
1506 
  extern template ostream& operator<<(ostream&, const complex&);
1507 
 
1508 
#ifdef _GLIBCXX_USE_WCHAR_T
1509 
  extern template wistream& operator>>(wistream&, complex&);
1510 
  extern template wostream& operator<<(wostream&, const complex&);
1511 
  extern template wistream& operator>>(wistream&, complex&);
1512 
  extern template wostream& operator<<(wostream&, const complex&);
1513 
  extern template wistream& operator>>(wistream&, complex&);
1514 
  extern template wostream& operator<<(wostream&, const complex&);
1515 
#endif
1516 
#endif
1517 
 
1518 
  // @} group complex_numbers
1519 
 
1520 
_GLIBCXX_END_NAMESPACE_VERSION
1521 
} // namespace
1522 
 
1523 
namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
1524 
{
1525 
_GLIBCXX_BEGIN_NAMESPACE_VERSION
1526 
 
1527 
  // See ext/type_traits.h for the primary template.
1528 
  template
1529 
    struct __promote_2, _Up>
1530 
    {
1531 
    public:
1532 
      typedef std::complex::__type> __type;
1533 
    };
1534 
 
1535 
  template
1536 
    struct __promote_2<_Tp, std::complex<_Up> >
1537 
    {
1538 
    public:
1539 
      typedef std::complex::__type> __type;
1540 
    };
1541 
 
1542 
  template
1543 
    struct __promote_2, std::complex<_Up> >
1544 
    {
1545 
    public:
1546 
      typedef std::complex::__type> __type;
1547 
    };
1548 
 
1549 
_GLIBCXX_END_NAMESPACE_VERSION
1550 
} // namespace
1551 
 
1552 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
1553 
 
1554 
namespace std _GLIBCXX_VISIBILITY(default)
1555 
{
1556 
_GLIBCXX_BEGIN_NAMESPACE_VERSION
1557 
 
1558 
  // Forward declarations.
1559 
  template std::complex<_Tp> acos(const std::complex<_Tp>&);
1560 
  template std::complex<_Tp> asin(const std::complex<_Tp>&);
1561 
  template std::complex<_Tp> atan(const std::complex<_Tp>&);
1562 
 
1563 
  template std::complex<_Tp> acosh(const std::complex<_Tp>&);
1564 
  template std::complex<_Tp> asinh(const std::complex<_Tp>&);
1565 
  template std::complex<_Tp> atanh(const std::complex<_Tp>&);
1566 
  // DR 595.
1567 
  template _Tp               fabs(const std::complex<_Tp>&);
1568 
 
1569 
  template
1570 
    inline std::complex<_Tp>
1571 
    __complex_acos(const std::complex<_Tp>& __z)
1572 
    {
1573 
      const std::complex<_Tp> __t = std::asin(__z);
1574 
      const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
1575 
      return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
1576 
    }
1577 
 
1578 
#if _GLIBCXX_USE_C99_COMPLEX_TR1
1579 
  inline __complex__ float
1580 
  __complex_acos(__complex__ float __z)
1581 
  { return __builtin_cacosf(__z); }
1582 
 
1583 
  inline __complex__ double
1584 
  __complex_acos(__complex__ double __z)
1585 
  { return __builtin_cacos(__z); }
1586 
 
1587 
  inline __complex__ long double
1588 
  __complex_acos(const __complex__ long double& __z)
1589 
  { return __builtin_cacosl(__z); }
1590 
 
1591 
  template
1592 
    inline std::complex<_Tp>
1593 
    acos(const std::complex<_Tp>& __z)
1594 
    { return __complex_acos(__z.__rep()); }
1595 
#else
1596 
  /// acos(__z) [8.1.2].
1597 
  //  Effects:  Behaves the same as C99 function cacos, defined
1598 
  //            in subclause 7.3.5.1.
1599 
  template
1600 
    inline std::complex<_Tp>
1601 
    acos(const std::complex<_Tp>& __z)
1602 
    { return __complex_acos(__z); }
1603 
#endif
1604 
 
1605 
  template
1606 
    inline std::complex<_Tp>
1607 
    __complex_asin(const std::complex<_Tp>& __z)
1608 
    {
1609 
      std::complex<_Tp> __t(-__z.imag(), __z.real());
1610 
      __t = std::asinh(__t);
1611 
      return std::complex<_Tp>(__t.imag(), -__t.real());
1612 
    }
1613 
 
1614 
#if _GLIBCXX_USE_C99_COMPLEX_TR1
1615 
  inline __complex__ float
1616 
  __complex_asin(__complex__ float __z)
1617 
  { return __builtin_casinf(__z); }
1618 
 
1619 
  inline __complex__ double
1620 
  __complex_asin(__complex__ double __z)
1621 
  { return __builtin_casin(__z); }
1622 
 
1623 
  inline __complex__ long double
1624 
  __complex_asin(const __complex__ long double& __z)
1625 
  { return __builtin_casinl(__z); }
1626 
 
1627 
  template
1628 
    inline std::complex<_Tp>
1629 
    asin(const std::complex<_Tp>& __z)
1630 
    { return __complex_asin(__z.__rep()); }
1631 
#else
1632 
  /// asin(__z) [8.1.3].
1633 
  //  Effects:  Behaves the same as C99 function casin, defined
1634 
  //            in subclause 7.3.5.2.
1635 
  template
1636 
    inline std::complex<_Tp>
1637 
    asin(const std::complex<_Tp>& __z)
1638 
    { return __complex_asin(__z); }
1639 
#endif
1640 
 
1641 
  template
1642 
    std::complex<_Tp>
1643 
    __complex_atan(const std::complex<_Tp>& __z)
1644 
    {
1645 
      const _Tp __r2 = __z.real() * __z.real();
1646 
      const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
1647 
 
1648 
      _Tp __num = __z.imag() + _Tp(1.0);
1649 
      _Tp __den = __z.imag() - _Tp(1.0);
1650 
 
1651 
      __num = __r2 + __num * __num;
1652 
      __den = __r2 + __den * __den;
1653 
 
1654 
      return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
1655 
                               _Tp(0.25) * log(__num / __den));
1656 
    }
1657 
 
1658 
#if _GLIBCXX_USE_C99_COMPLEX_TR1
1659 
  inline __complex__ float
1660 
  __complex_atan(__complex__ float __z)
1661 
  { return __builtin_catanf(__z); }
1662 
 
1663 
  inline __complex__ double
1664 
  __complex_atan(__complex__ double __z)
1665 
  { return __builtin_catan(__z); }
1666 
 
1667 
  inline __complex__ long double
1668 
  __complex_atan(const __complex__ long double& __z)
1669 
  { return __builtin_catanl(__z); }
1670 
 
1671 
  template
1672 
    inline std::complex<_Tp>
1673 
    atan(const std::complex<_Tp>& __z)
1674 
    { return __complex_atan(__z.__rep()); }
1675 
#else
1676 
  /// atan(__z) [8.1.4].
1677 
  //  Effects:  Behaves the same as C99 function catan, defined
1678 
  //            in subclause 7.3.5.3.
1679 
  template
1680 
    inline std::complex<_Tp>
1681 
    atan(const std::complex<_Tp>& __z)
1682 
    { return __complex_atan(__z); }
1683 
#endif
1684 
 
1685 
  template
1686 
    std::complex<_Tp>
1687 
    __complex_acosh(const std::complex<_Tp>& __z)
1688 
    {
1689 
      // Kahan's formula.
1690 
      return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0)))
1691 
                                 + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0))));
1692 
    }
1693 
 
1694 
#if _GLIBCXX_USE_C99_COMPLEX_TR1
1695 
  inline __complex__ float
1696 
  __complex_acosh(__complex__ float __z)
1697 
  { return __builtin_cacoshf(__z); }
1698 
 
1699 
  inline __complex__ double
1700 
  __complex_acosh(__complex__ double __z)
1701 
  { return __builtin_cacosh(__z); }
1702 
 
1703 
  inline __complex__ long double
1704 
  __complex_acosh(const __complex__ long double& __z)
1705 
  { return __builtin_cacoshl(__z); }
1706 
 
1707 
  template
1708 
    inline std::complex<_Tp>
1709 
    acosh(const std::complex<_Tp>& __z)
1710 
    { return __complex_acosh(__z.__rep()); }
1711 
#else
1712 
  /// acosh(__z) [8.1.5].
1713 
  //  Effects:  Behaves the same as C99 function cacosh, defined
1714 
  //            in subclause 7.3.6.1.
1715 
  template
1716 
    inline std::complex<_Tp>
1717 
    acosh(const std::complex<_Tp>& __z)
1718 
    { return __complex_acosh(__z); }
1719 
#endif
1720 
 
1721 
  template
1722 
    std::complex<_Tp>
1723 
    __complex_asinh(const std::complex<_Tp>& __z)
1724 
    {
1725 
      std::complex<_Tp> __t((__z.real() - __z.imag())
1726 
                            * (__z.real() + __z.imag()) + _Tp(1.0),
1727 
                            _Tp(2.0) * __z.real() * __z.imag());
1728 
      __t = std::sqrt(__t);
1729 
 
1730 
      return std::log(__t + __z);
1731 
    }
1732 
 
1733 
#if _GLIBCXX_USE_C99_COMPLEX_TR1
1734 
  inline __complex__ float
1735 
  __complex_asinh(__complex__ float __z)
1736 
  { return __builtin_casinhf(__z); }
1737 
 
1738 
  inline __complex__ double
1739 
  __complex_asinh(__complex__ double __z)
1740 
  { return __builtin_casinh(__z); }
1741 
 
1742 
  inline __complex__ long double
1743 
  __complex_asinh(const __complex__ long double& __z)
1744 
  { return __builtin_casinhl(__z); }
1745 
 
1746 
  template
1747 
    inline std::complex<_Tp>
1748 
    asinh(const std::complex<_Tp>& __z)
1749 
    { return __complex_asinh(__z.__rep()); }
1750 
#else
1751 
  /// asinh(__z) [8.1.6].
1752 
  //  Effects:  Behaves the same as C99 function casin, defined
1753 
  //            in subclause 7.3.6.2.
1754 
  template
1755 
    inline std::complex<_Tp>
1756 
    asinh(const std::complex<_Tp>& __z)
1757 
    { return __complex_asinh(__z); }
1758 
#endif
1759 
 
1760 
  template
1761 
    std::complex<_Tp>
1762 
    __complex_atanh(const std::complex<_Tp>& __z)
1763 
    {
1764 
      const _Tp __i2 = __z.imag() * __z.imag();
1765 
      const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
1766 
 
1767 
      _Tp __num = _Tp(1.0) + __z.real();
1768 
      _Tp __den = _Tp(1.0) - __z.real();
1769 
 
1770 
      __num = __i2 + __num * __num;
1771 
      __den = __i2 + __den * __den;
1772 
 
1773 
      return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
1774 
                               _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
1775 
    }
1776 
 
1777 
#if _GLIBCXX_USE_C99_COMPLEX_TR1
1778 
  inline __complex__ float
1779 
  __complex_atanh(__complex__ float __z)
1780 
  { return __builtin_catanhf(__z); }
1781 
 
1782 
  inline __complex__ double
1783 
  __complex_atanh(__complex__ double __z)
1784 
  { return __builtin_catanh(__z); }
1785 
 
1786 
  inline __complex__ long double
1787 
  __complex_atanh(const __complex__ long double& __z)
1788 
  { return __builtin_catanhl(__z); }
1789 
 
1790 
  template
1791 
    inline std::complex<_Tp>
1792 
    atanh(const std::complex<_Tp>& __z)
1793 
    { return __complex_atanh(__z.__rep()); }
1794 
#else
1795 
  /// atanh(__z) [8.1.7].
1796 
  //  Effects:  Behaves the same as C99 function catanh, defined
1797 
  //            in subclause 7.3.6.3.
1798 
  template
1799 
    inline std::complex<_Tp>
1800 
    atanh(const std::complex<_Tp>& __z)
1801 
    { return __complex_atanh(__z); }
1802 
#endif
1803 
 
1804 
  template
1805 
    inline _Tp
1806 
    /// fabs(__z) [8.1.8].
1807 
    //  Effects:  Behaves the same as C99 function cabs, defined
1808 
    //            in subclause 7.3.8.1.
1809 
    fabs(const std::complex<_Tp>& __z)
1810 
    { return std::abs(__z); }
1811 
 
1812 
  /// Additional overloads [8.1.9].
1813 
  template
1814 
    inline typename __gnu_cxx::__promote<_Tp>::__type
1815 
    arg(_Tp __x)
1816 
    {
1817 
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1818 
#if (_GLIBCXX_USE_C99_MATH && !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC)
1819 
      return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L)
1820 
                               : __type();
1821 
#else
1822 
      return std::arg(std::complex<__type>(__x));
1823 
#endif
1824 
    }
1825 
 
1826 
  template
1827 
    inline typename __gnu_cxx::__promote<_Tp>::__type
1828 
    imag(_Tp)
1829 
    { return _Tp(); }
1830 
 
1831 
  template
1832 
    inline typename __gnu_cxx::__promote<_Tp>::__type
1833 
    norm(_Tp __x)
1834 
    {
1835 
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1836 
      return __type(__x) * __type(__x);
1837 
    }
1838 
 
1839 
  template
1840 
    inline typename __gnu_cxx::__promote<_Tp>::__type
1841 
    real(_Tp __x)
1842 
    { return __x; }
1843 
 
1844 
  template
1845 
    inline std::complex::__type>
1846 
    pow(const std::complex<_Tp>& __x, const _Up& __y)
1847 
    {
1848 
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1849 
      return std::pow(std::complex<__type>(__x), __type(__y));
1850 
    }
1851 
 
1852 
  template
1853 
    inline std::complex::__type>
1854 
    pow(const _Tp& __x, const std::complex<_Up>& __y)
1855 
    {
1856 
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1857 
      return std::pow(__type(__x), std::complex<__type>(__y));
1858 
    }
1859 
 
1860 
  template
1861 
    inline std::complex::__type>
1862 
    pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
1863 
    {
1864 
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1865 
      return std::pow(std::complex<__type>(__x),
1866 
                      std::complex<__type>(__y));
1867 
    }
1868 
 
1869 
  // Forward declarations.
1870 
  // DR 781.
1871 
  template std::complex<_Tp> proj(const std::complex<_Tp>&);
1872 
 
1873 
  template
1874 
    std::complex<_Tp>
1875 
    __complex_proj(const std::complex<_Tp>& __z)
1876 
    {
1877 
      const _Tp __den = (__z.real() * __z.real()
1878 
                         + __z.imag() * __z.imag() + _Tp(1.0));
1879 
 
1880 
      return std::complex<_Tp>((_Tp(2.0) * __z.real()) / __den,
1881 
                               (_Tp(2.0) * __z.imag()) / __den);
1882 
    }
1883 
 
1884 
#if _GLIBCXX_USE_C99_COMPLEX
1885 
  inline __complex__ float
1886 
  __complex_proj(__complex__ float __z)
1887 
  { return __builtin_cprojf(__z); }
1888 
 
1889 
  inline __complex__ double
1890 
  __complex_proj(__complex__ double __z)
1891 
  { return __builtin_cproj(__z); }
1892 
 
1893 
  inline __complex__ long double
1894 
  __complex_proj(const __complex__ long double& __z)
1895 
  { return __builtin_cprojl(__z); }
1896 
 
1897 
  template
1898 
    inline std::complex<_Tp>
1899 
    proj(const std::complex<_Tp>& __z)
1900 
    { return __complex_proj(__z.__rep()); }
1901 
#else
1902 
  template
1903 
    inline std::complex<_Tp>
1904 
    proj(const std::complex<_Tp>& __z)
1905 
    { return __complex_proj(__z); }
1906 
#endif
1907 
 
1908 
  // DR 1137.
1909 
  template
1910 
    inline typename __gnu_cxx::__promote<_Tp>::__type
1911 
    proj(_Tp __x)
1912 
    { return __x; }
1913 
 
1914 
  template
1915 
    inline typename __gnu_cxx::__promote<_Tp>::__type
1916 
    conj(_Tp __x)
1917 
    { return __x; }
1918 
 
1919 
_GLIBCXX_END_NAMESPACE_VERSION
1920 
} // namespace
1921 
 
1922 
#endif  // __GXX_EXPERIMENTAL_CXX0X__
1923 
 
1924 
#endif  /* _GLIBCXX_COMPLEX */

powered by: WebSVN 2.1.0

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