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

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gcc/] [gcc-4.1.1/] [libstdc++-v3/] [include/] [std/] [std_complex.h] - Blame information for rev 17

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 17 jlechner 
// The template and inlines for the -*- C++ -*- complex number classes.
2 
 
3 
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
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 2, 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 
// You should have received a copy of the GNU General Public License along
18 
// with this library; see the file COPYING.  If not, write to the Free
19 
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
20 
// USA.
21 
 
22 
// As a special exception, you may use this file as part of a free software
23 
// library without restriction.  Specifically, if other files instantiate
24 
// templates or use macros or inline functions from this file, or you compile
25 
// this file and link it with other files to produce an executable, this
26 
// file does not by itself cause the resulting executable to be covered by
27 
// the GNU General Public License.  This exception does not however
28 
// invalidate any other reasons why the executable file might be covered by
29 
// the GNU General Public License.
30 
 
31 
//
32 
// ISO C++ 14882: 26.2  Complex Numbers
33 
// Note: this is not a conforming implementation.
34 
// Initially implemented by Ulrich Drepper <drepper@cygnus.com>
35 
// Improved by Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr>
36 
//
37 
 
38 
/** @file complex
39 
 *  This is a Standard C++ Library header.
40 
 */
41 
 
42 
#ifndef _GLIBCXX_COMPLEX
43 
#define _GLIBCXX_COMPLEX 1
44 
 
45 
#pragma GCC system_header
46 
 
47 
#include <bits/c++config.h>
48 
#include <bits/cpp_type_traits.h>
49 
#include <cmath>
50 
#include <sstream>
51 
 
52 
namespace std
53 
{
54 
  // Forward declarations.
55 
  template<typename _Tp> class complex;
56 
  template<> class complex<float>;
57 
  template<> class complex<double>;
58 
  template<> class complex<long double>;
59 
 
60 
  ///  Return magnitude of @a z.
61 
  template<typename _Tp> _Tp abs(const complex<_Tp>&);
62 
  ///  Return phase angle of @a z.
63 
  template<typename _Tp> _Tp arg(const complex<_Tp>&);
64 
  ///  Return @a z magnitude squared.
65 
  template<typename _Tp> _Tp norm(const complex<_Tp>&);
66 
 
67 
  ///  Return complex conjugate of @a z.
68 
  template<typename _Tp> complex<_Tp> conj(const complex<_Tp>&);
69 
  ///  Return complex with magnitude @a rho and angle @a theta.
70 
  template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);
71 
 
72 
  // Transcendentals:
73 
  /// Return complex cosine of @a z.
74 
  template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);
75 
  /// Return complex hyperbolic cosine of @a z.
76 
  template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);
77 
  /// Return complex base e exponential of @a z.
78 
  template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);
79 
  /// Return complex natural logarithm of @a z.
80 
  template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);
81 
  /// Return complex base 10 logarithm of @a z.
82 
  template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);
83 
  /// Return complex cosine of @a z.
84 
  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);
85 
  /// Return @a x to the @a y'th power.
86 
  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
87 
  /// Return @a x to the @a y'th power.
88 
  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
89 
                                          const complex<_Tp>&);
90 
  /// Return @a x to the @a y'th power.
91 
  template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
92 
  /// Return complex sine of @a z.
93 
  template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);
94 
  /// Return complex hyperbolic sine of @a z.
95 
  template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);
96 
  /// Return complex square root of @a z.
97 
  template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);
98 
  /// Return complex tangent of @a z.
99 
  template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);
100 
  /// Return complex hyperbolic tangent of @a z.
101 
  template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
102 
  //@}
103 
 
104 
 
105 
  // 26.2.2  Primary template class complex
106 
  /**
107 
   *  Template to represent complex numbers.
108 
   *
109 
   *  Specializations for float, double, and long double are part of the
110 
   *  library.  Results with any other type are not guaranteed.
111 
   *
112 
   *  @param  Tp  Type of real and imaginary values.
113 
  */
114 
  template<typename _Tp>
115 
    struct complex
116 
    {
117 
      /// Value typedef.
118 
      typedef _Tp value_type;
119 
 
120 
      ///  Default constructor.  First parameter is x, second parameter is y.
121 
      ///  Unspecified parameters default to 0.
122 
      complex(const _Tp& = _Tp(), const _Tp & = _Tp());
123 
 
124 
      // Lets the compiler synthesize the copy constructor
125 
      // complex (const complex<_Tp>&);
126 
      ///  Copy constructor.
127 
      template<typename _Up>
128 
        complex(const complex<_Up>&);
129 
 
130 
      ///  Return real part of complex number.
131 
      _Tp& real();
132 
      ///  Return real part of complex number.
133 
      const _Tp& real() const;
134 
      ///  Return imaginary part of complex number.
135 
      _Tp& imag();
136 
      ///  Return imaginary part of complex number.
137 
      const _Tp& imag() const;
138 
 
139 
      /// Assign this complex number to scalar @a t.
140 
      complex<_Tp>& operator=(const _Tp&);
141 
      /// Add @a t to this complex number.
142 
      complex<_Tp>& operator+=(const _Tp&);
143 
      /// Subtract @a t from this complex number.
144 
      complex<_Tp>& operator-=(const _Tp&);
145 
      /// Multiply this complex number by @a t.
146 
      complex<_Tp>& operator*=(const _Tp&);
147 
      /// Divide this complex number by @a t.
148 
      complex<_Tp>& operator/=(const _Tp&);
149 
 
150 
      // Lets the compiler synthesize the
151 
      // copy and assignment operator
152 
      // complex<_Tp>& operator= (const complex<_Tp>&);
153 
      /// Assign this complex number to complex @a z.
154 
      template<typename _Up>
155 
        complex<_Tp>& operator=(const complex<_Up>&);
156 
      /// Add @a z to this complex number.
157 
      template<typename _Up>
158 
        complex<_Tp>& operator+=(const complex<_Up>&);
159 
      /// Subtract @a z from this complex number.
160 
      template<typename _Up>
161 
        complex<_Tp>& operator-=(const complex<_Up>&);
162 
      /// Multiply this complex number by @a z.
163 
      template<typename _Up>
164 
        complex<_Tp>& operator*=(const complex<_Up>&);
165 
      /// Divide this complex number by @a z.
166 
      template<typename _Up>
167 
        complex<_Tp>& operator/=(const complex<_Up>&);
168 
 
169 
      const complex& __rep() const;
170 
 
171 
    private:
172 
      _Tp _M_real;
173 
      _Tp _M_imag;
174 
    };
175 
 
176 
  template<typename _Tp>
177 
    inline _Tp&
178 
    complex<_Tp>::real() { return _M_real; }
179 
 
180 
  template<typename _Tp>
181 
    inline const _Tp&
182 
    complex<_Tp>::real() const { return _M_real; }
183 
 
184 
  template<typename _Tp>
185 
    inline _Tp&
186 
    complex<_Tp>::imag() { return _M_imag; }
187 
 
188 
  template<typename _Tp>
189 
    inline const _Tp&
190 
    complex<_Tp>::imag() const { return _M_imag; }
191 
 
192 
  template<typename _Tp>
193 
    inline
194 
    complex<_Tp>::complex(const _Tp& __r, const _Tp& __i)
195 
    : _M_real(__r), _M_imag(__i) { }
196 
 
197 
  template<typename _Tp>
198 
    template<typename _Up>
199 
    inline
200 
    complex<_Tp>::complex(const complex<_Up>& __z)
201 
    : _M_real(__z.real()), _M_imag(__z.imag()) { }
202 
 
203 
  template<typename _Tp>
204 
    complex<_Tp>&
205 
    complex<_Tp>::operator=(const _Tp& __t)
206 
    {
207 
     _M_real = __t;
208 
     _M_imag = _Tp();
209 
     return *this;
210 
    }
211 
 
212 
  // 26.2.5/1
213 
  template<typename _Tp>
214 
    inline complex<_Tp>&
215 
    complex<_Tp>::operator+=(const _Tp& __t)
216 
    {
217 
      _M_real += __t;
218 
      return *this;
219 
    }
220 
 
221 
  // 26.2.5/3
222 
  template<typename _Tp>
223 
    inline complex<_Tp>&
224 
    complex<_Tp>::operator-=(const _Tp& __t)
225 
    {
226 
      _M_real -= __t;
227 
      return *this;
228 
    }
229 
 
230 
  // 26.2.5/5
231 
  template<typename _Tp>
232 
    complex<_Tp>&
233 
    complex<_Tp>::operator*=(const _Tp& __t)
234 
    {
235 
      _M_real *= __t;
236 
      _M_imag *= __t;
237 
      return *this;
238 
    }
239 
 
240 
  // 26.2.5/7
241 
  template<typename _Tp>
242 
    complex<_Tp>&
243 
    complex<_Tp>::operator/=(const _Tp& __t)
244 
    {
245 
      _M_real /= __t;
246 
      _M_imag /= __t;
247 
      return *this;
248 
    }
249 
 
250 
  template<typename _Tp>
251 
    template<typename _Up>
252 
    complex<_Tp>&
253 
    complex<_Tp>::operator=(const complex<_Up>& __z)
254 
    {
255 
      _M_real = __z.real();
256 
      _M_imag = __z.imag();
257 
      return *this;
258 
    }
259 
 
260 
  // 26.2.5/9
261 
  template<typename _Tp>
262 
    template<typename _Up>
263 
    complex<_Tp>&
264 
    complex<_Tp>::operator+=(const complex<_Up>& __z)
265 
    {
266 
      _M_real += __z.real();
267 
      _M_imag += __z.imag();
268 
      return *this;
269 
    }
270 
 
271 
  // 26.2.5/11
272 
  template<typename _Tp>
273 
    template<typename _Up>
274 
    complex<_Tp>&
275 
    complex<_Tp>::operator-=(const complex<_Up>& __z)
276 
    {
277 
      _M_real -= __z.real();
278 
      _M_imag -= __z.imag();
279 
      return *this;
280 
    }
281 
 
282 
  // 26.2.5/13
283 
  // XXX: This is a grammar school implementation.
284 
  template<typename _Tp>
285 
    template<typename _Up>
286 
    complex<_Tp>&
287 
    complex<_Tp>::operator*=(const complex<_Up>& __z)
288 
    {
289 
      const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
290 
      _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
291 
      _M_real = __r;
292 
      return *this;
293 
    }
294 
 
295 
  // 26.2.5/15
296 
  // XXX: This is a grammar school implementation.
297 
  template<typename _Tp>
298 
    template<typename _Up>
299 
    complex<_Tp>&
300 
    complex<_Tp>::operator/=(const complex<_Up>& __z)
301 
    {
302 
      const _Tp __r =  _M_real * __z.real() + _M_imag * __z.imag();
303 
      const _Tp __n = std::norm(__z);
304 
      _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
305 
      _M_real = __r / __n;
306 
      return *this;
307 
    }
308 
 
309 
  template<typename _Tp>
310 
    inline const complex<_Tp>&
311 
    complex<_Tp>::__rep() const { return *this; }
312 
 
313 
  // Operators:
314 
  //@{
315 
  ///  Return new complex value @a x plus @a y.
316 
  template<typename _Tp>
317 
    inline complex<_Tp>
318 
    operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
319 
    {
320 
      complex<_Tp> __r = __x;
321 
      __r += __y;
322 
      return __r;
323 
    }
324 
 
325 
  template<typename _Tp>
326 
    inline complex<_Tp>
327 
    operator+(const complex<_Tp>& __x, const _Tp& __y)
328 
    {
329 
      complex<_Tp> __r = __x;
330 
      __r.real() += __y;
331 
      return __r;
332 
    }
333 
 
334 
  template<typename _Tp>
335 
    inline complex<_Tp>
336 
    operator+(const _Tp& __x, const complex<_Tp>& __y)
337 
    {
338 
      complex<_Tp> __r = __y;
339 
      __r.real() += __x;
340 
      return __r;
341 
    }
342 
  //@}
343 
 
344 
  //@{
345 
  ///  Return new complex value @a x minus @a y.
346 
  template<typename _Tp>
347 
    inline complex<_Tp>
348 
    operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
349 
    {
350 
      complex<_Tp> __r = __x;
351 
      __r -= __y;
352 
      return __r;
353 
    }
354 
 
355 
  template<typename _Tp>
356 
    inline complex<_Tp>
357 
    operator-(const complex<_Tp>& __x, const _Tp& __y)
358 
    {
359 
      complex<_Tp> __r = __x;
360 
      __r.real() -= __y;
361 
      return __r;
362 
    }
363 
 
364 
  template<typename _Tp>
365 
    inline complex<_Tp>
366 
    operator-(const _Tp& __x, const complex<_Tp>& __y)
367 
    {
368 
      complex<_Tp> __r(__x, -__y.imag());
369 
      __r.real() -= __y.real();
370 
      return __r;
371 
    }
372 
  //@}
373 
 
374 
  //@{
375 
  ///  Return new complex value @a x times @a y.
376 
  template<typename _Tp>
377 
    inline complex<_Tp>
378 
    operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
379 
    {
380 
      complex<_Tp> __r = __x;
381 
      __r *= __y;
382 
      return __r;
383 
    }
384 
 
385 
  template<typename _Tp>
386 
    inline complex<_Tp>
387 
    operator*(const complex<_Tp>& __x, const _Tp& __y)
388 
    {
389 
      complex<_Tp> __r = __x;
390 
      __r *= __y;
391 
      return __r;
392 
    }
393 
 
394 
  template<typename _Tp>
395 
    inline complex<_Tp>
396 
    operator*(const _Tp& __x, const complex<_Tp>& __y)
397 
    {
398 
      complex<_Tp> __r = __y;
399 
      __r *= __x;
400 
      return __r;
401 
    }
402 
  //@}
403 
 
404 
  //@{
405 
  ///  Return new complex value @a x divided by @a y.
406 
  template<typename _Tp>
407 
    inline complex<_Tp>
408 
    operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
409 
    {
410 
      complex<_Tp> __r = __x;
411 
      __r /= __y;
412 
      return __r;
413 
    }
414 
 
415 
  template<typename _Tp>
416 
    inline complex<_Tp>
417 
    operator/(const complex<_Tp>& __x, const _Tp& __y)
418 
    {
419 
      complex<_Tp> __r = __x;
420 
      __r /= __y;
421 
      return __r;
422 
    }
423 
 
424 
  template<typename _Tp>
425 
    inline complex<_Tp>
426 
    operator/(const _Tp& __x, const complex<_Tp>& __y)
427 
    {
428 
      complex<_Tp> __r = __x;
429 
      __r /= __y;
430 
      return __r;
431 
    }
432 
  //@}
433 
 
434 
  ///  Return @a x.
435 
  template<typename _Tp>
436 
    inline complex<_Tp>
437 
    operator+(const complex<_Tp>& __x)
438 
    { return __x; }
439 
 
440 
  ///  Return complex negation of @a x.
441 
  template<typename _Tp>
442 
    inline complex<_Tp>
443 
    operator-(const complex<_Tp>& __x)
444 
    {  return complex<_Tp>(-__x.real(), -__x.imag()); }
445 
 
446 
  //@{
447 
  ///  Return true if @a x is equal to @a y.
448 
  template<typename _Tp>
449 
    inline bool
450 
    operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
451 
    { return __x.real() == __y.real() && __x.imag() == __y.imag(); }
452 
 
453 
  template<typename _Tp>
454 
    inline bool
455 
    operator==(const complex<_Tp>& __x, const _Tp& __y)
456 
    { return __x.real() == __y && __x.imag() == _Tp(); }
457 
 
458 
  template<typename _Tp>
459 
    inline bool
460 
    operator==(const _Tp& __x, const complex<_Tp>& __y)
461 
    { return __x == __y.real() && _Tp() == __y.imag(); }
462 
  //@}
463 
 
464 
  //@{
465 
  ///  Return false if @a x is equal to @a y.
466 
  template<typename _Tp>
467 
    inline bool
468 
    operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
469 
    { return __x.real() != __y.real() || __x.imag() != __y.imag(); }
470 
 
471 
  template<typename _Tp>
472 
    inline bool
473 
    operator!=(const complex<_Tp>& __x, const _Tp& __y)
474 
    { return __x.real() != __y || __x.imag() != _Tp(); }
475 
 
476 
  template<typename _Tp>
477 
    inline bool
478 
    operator!=(const _Tp& __x, const complex<_Tp>& __y)
479 
    { return __x != __y.real() || _Tp() != __y.imag(); }
480 
  //@}
481 
 
482 
  ///  Extraction operator for complex values.
483 
  template<typename _Tp, typename _CharT, class _Traits>
484 
    basic_istream<_CharT, _Traits>&
485 
    operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
486 
    {
487 
      _Tp __re_x, __im_x;
488 
      _CharT __ch;
489 
      __is >> __ch;
490 
      if (__ch == '(')
491 
        {
492 
          __is >> __re_x >> __ch;
493 
          if (__ch == ',')
494 
            {
495 
              __is >> __im_x >> __ch;
496 
              if (__ch == ')')
497 
                __x = complex<_Tp>(__re_x, __im_x);
498 
              else
499 
                __is.setstate(ios_base::failbit);
500 
            }
501 
          else if (__ch == ')')
502 
            __x = __re_x;
503 
          else
504 
            __is.setstate(ios_base::failbit);
505 
        }
506 
      else
507 
        {
508 
          __is.putback(__ch);
509 
          __is >> __re_x;
510 
          __x = __re_x;
511 
        }
512 
      return __is;
513 
    }
514 
 
515 
  ///  Insertion operator for complex values.
516 
  template<typename _Tp, typename _CharT, class _Traits>
517 
    basic_ostream<_CharT, _Traits>&
518 
    operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
519 
    {
520 
      basic_ostringstream<_CharT, _Traits> __s;
521 
      __s.flags(__os.flags());
522 
      __s.imbue(__os.getloc());
523 
      __s.precision(__os.precision());
524 
      __s << '(' << __x.real() << ',' << __x.imag() << ')';
525 
      return __os << __s.str();
526 
    }
527 
 
528 
  // Values
529 
  template<typename _Tp>
530 
    inline _Tp&
531 
    real(complex<_Tp>& __z)
532 
    { return __z.real(); }
533 
 
534 
  template<typename _Tp>
535 
    inline const _Tp&
536 
    real(const complex<_Tp>& __z)
537 
    { return __z.real(); }
538 
 
539 
  template<typename _Tp>
540 
    inline _Tp&
541 
    imag(complex<_Tp>& __z)
542 
    { return __z.imag(); }
543 
 
544 
  template<typename _Tp>
545 
    inline const _Tp&
546 
    imag(const complex<_Tp>& __z)
547 
    { return __z.imag(); }
548 
 
549 
  // 26.2.7/3 abs(__z):  Returns the magnitude of __z.
550 
  template<typename _Tp>
551 
    inline _Tp
552 
    __complex_abs(const complex<_Tp>& __z)
553 
    {
554 
      _Tp __x = __z.real();
555 
      _Tp __y = __z.imag();
556 
      const _Tp __s = std::max(abs(__x), abs(__y));
557 
      if (__s == _Tp())  // well ...
558 
        return __s;
559 
      __x /= __s;
560 
      __y /= __s;
561 
      return __s * sqrt(__x * __x + __y * __y);
562 
    }
563 
 
564 
#if _GLIBCXX_USE_C99_COMPLEX
565 
  inline float
566 
  __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }
567 
 
568 
  inline double
569 
  __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }
570 
 
571 
  inline long double
572 
  __complex_abs(const __complex__ long double& __z)
573 
  { return __builtin_cabsl(__z); }
574 
 
575 
  template<typename _Tp>
576 
    inline _Tp
577 
    abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
578 
#else
579 
  template<typename _Tp>
580 
    inline _Tp
581 
    abs(const complex<_Tp>& __z) { return __complex_abs(__z); }
582 
#endif
583 
 
584 
 
585 
  // 26.2.7/4: arg(__z): Returns the phase angle of __z.
586 
  template<typename _Tp>
587 
    inline _Tp
588 
    __complex_arg(const complex<_Tp>& __z)
589 
    { return  atan2(__z.imag(), __z.real()); }
590 
 
591 
#if _GLIBCXX_USE_C99_COMPLEX
592 
  inline float
593 
  __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }
594 
 
595 
  inline double
596 
  __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }
597 
 
598 
  inline long double
599 
  __complex_arg(const __complex__ long double& __z)
600 
  { return __builtin_cargl(__z); }
601 
 
602 
  template<typename _Tp>
603 
    inline _Tp
604 
    arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
605 
#else
606 
  template<typename _Tp>
607 
    inline _Tp
608 
    arg(const complex<_Tp>& __z) { return __complex_arg(__z); }
609 
#endif
610 
 
611 
  // 26.2.7/5: norm(__z) returns the squared magintude of __z.
612 
  //     As defined, norm() is -not- a norm is the common mathematical
613 
  //     sens used in numerics.  The helper class _Norm_helper<> tries to
614 
  //     distinguish between builtin floating point and the rest, so as
615 
  //     to deliver an answer as close as possible to the real value.
616 
  template<bool>
617 
    struct _Norm_helper
618 
    {
619 
      template<typename _Tp>
620 
        static inline _Tp _S_do_it(const complex<_Tp>& __z)
621 
        {
622 
          const _Tp __x = __z.real();
623 
          const _Tp __y = __z.imag();
624 
          return __x * __x + __y * __y;
625 
        }
626 
    };
627 
 
628 
  template<>
629 
    struct _Norm_helper<true>
630 
    {
631 
      template<typename _Tp>
632 
        static inline _Tp _S_do_it(const complex<_Tp>& __z)
633 
        {
634 
          _Tp __res = std::abs(__z);
635 
          return __res * __res;
636 
        }
637 
    };
638 
 
639 
  template<typename _Tp>
640 
    inline _Tp
641 
    norm(const complex<_Tp>& __z)
642 
    {
643 
      return _Norm_helper<__is_floating<_Tp>::__value
644 
        && !_GLIBCXX_FAST_MATH>::_S_do_it(__z);
645 
    }
646 
 
647 
  template<typename _Tp>
648 
    inline complex<_Tp>
649 
    polar(const _Tp& __rho, const _Tp& __theta)
650 
    { return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); }
651 
 
652 
  template<typename _Tp>
653 
    inline complex<_Tp>
654 
    conj(const complex<_Tp>& __z)
655 
    { return complex<_Tp>(__z.real(), -__z.imag()); }
656 
 
657 
  // Transcendentals
658 
 
659 
  // 26.2.8/1 cos(__z):  Returns the cosine of __z.
660 
  template<typename _Tp>
661 
    inline complex<_Tp>
662 
    __complex_cos(const complex<_Tp>& __z)
663 
    {
664 
      const _Tp __x = __z.real();
665 
      const _Tp __y = __z.imag();
666 
      return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
667 
    }
668 
 
669 
#if _GLIBCXX_USE_C99_COMPLEX
670 
  inline __complex__ float
671 
  __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }
672 
 
673 
  inline __complex__ double
674 
  __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }
675 
 
676 
  inline __complex__ long double
677 
  __complex_cos(const __complex__ long double& __z)
678 
  { return __builtin_ccosl(__z); }
679 
 
680 
  template<typename _Tp>
681 
    inline complex<_Tp>
682 
    cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }
683 
#else
684 
  template<typename _Tp>
685 
    inline complex<_Tp>
686 
    cos(const complex<_Tp>& __z) { return __complex_cos(__z); }
687 
#endif
688 
 
689 
  // 26.2.8/2 cosh(__z): Returns the hyperbolic cosine of __z.
690 
  template<typename _Tp>
691 
    inline complex<_Tp>
692 
    __complex_cosh(const complex<_Tp>& __z)
693 
    {
694 
      const _Tp __x = __z.real();
695 
      const _Tp __y = __z.imag();
696 
      return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
697 
    }
698 
 
699 
#if _GLIBCXX_USE_C99_COMPLEX
700 
  inline __complex__ float
701 
  __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }
702 
 
703 
  inline __complex__ double
704 
  __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }
705 
 
706 
  inline __complex__ long double
707 
  __complex_cosh(const __complex__ long double& __z)
708 
  { return __builtin_ccoshl(__z); }
709 
 
710 
  template<typename _Tp>
711 
    inline complex<_Tp>
712 
    cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }
713 
#else
714 
  template<typename _Tp>
715 
    inline complex<_Tp>
716 
    cosh(const complex<_Tp>& __z) { return __complex_cosh(__z); }
717 
#endif
718 
 
719 
  // 26.2.8/3 exp(__z): Returns the complex base e exponential of x
720 
  template<typename _Tp>
721 
    inline complex<_Tp>
722 
    __complex_exp(const complex<_Tp>& __z)
723 
    { return std::polar(exp(__z.real()), __z.imag()); }
724 
 
725 
#if _GLIBCXX_USE_C99_COMPLEX
726 
  inline __complex__ float
727 
  __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }
728 
 
729 
  inline __complex__ double
730 
  __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }
731 
 
732 
  inline __complex__ long double
733 
  __complex_exp(const __complex__ long double& __z)
734 
  { return __builtin_cexpl(__z); }
735 
 
736 
  template<typename _Tp>
737 
    inline complex<_Tp>
738 
    exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
739 
#else
740 
  template<typename _Tp>
741 
    inline complex<_Tp>
742 
    exp(const complex<_Tp>& __z) { return __complex_exp(__z); }
743 
#endif
744 
 
745 
  // 26.2.8/5 log(__z): Reurns the natural complex logaritm of __z.
746 
  //                    The branch cut is along the negative axis.
747 
  template<typename _Tp>
748 
    inline complex<_Tp>
749 
    __complex_log(const complex<_Tp>& __z)
750 
    { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
751 
 
752 
#if _GLIBCXX_USE_C99_COMPLEX
753 
  inline __complex__ float
754 
  __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }
755 
 
756 
  inline __complex__ double
757 
  __complex_log(__complex__ double __z) { return __builtin_clog(__z); }
758 
 
759 
  inline __complex__ long double
760 
  __complex_log(const __complex__ long double& __z)
761 
  { return __builtin_clogl(__z); }
762 
 
763 
  template<typename _Tp>
764 
    inline complex<_Tp>
765 
    log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }
766 
#else
767 
  template<typename _Tp>
768 
    inline complex<_Tp>
769 
    log(const complex<_Tp>& __z) { return __complex_log(__z); }
770 
#endif
771 
 
772 
  template<typename _Tp>
773 
    inline complex<_Tp>
774 
    log10(const complex<_Tp>& __z)
775 
    { return std::log(__z) / log(_Tp(10.0)); }
776 
 
777 
  // 26.2.8/10 sin(__z): Returns the sine of __z.
778 
  template<typename _Tp>
779 
    inline complex<_Tp>
780 
    __complex_sin(const complex<_Tp>& __z)
781 
    {
782 
      const _Tp __x = __z.real();
783 
      const _Tp __y = __z.imag();
784 
      return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
785 
    }
786 
 
787 
#if _GLIBCXX_USE_C99_COMPLEX
788 
  inline __complex__ float
789 
  __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }
790 
 
791 
  inline __complex__ double
792 
  __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }
793 
 
794 
  inline __complex__ long double
795 
  __complex_sin(const __complex__ long double& __z)
796 
  { return __builtin_csinl(__z); }
797 
 
798 
  template<typename _Tp>
799 
    inline complex<_Tp>
800 
    sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }
801 
#else
802 
  template<typename _Tp>
803 
    inline complex<_Tp>
804 
    sin(const complex<_Tp>& __z) { return __complex_sin(__z); }
805 
#endif
806 
 
807 
  // 26.2.8/11 sinh(__z): Returns the hyperbolic sine of __z.
808 
  template<typename _Tp>
809 
    inline complex<_Tp>
810 
    __complex_sinh(const complex<_Tp>& __z)
811 
    {
812 
      const _Tp __x = __z.real();
813 
      const _Tp  __y = __z.imag();
814 
      return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
815 
    }
816 
 
817 
#if _GLIBCXX_USE_C99_COMPLEX
818 
  inline __complex__ float
819 
  __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
820 
 
821 
  inline __complex__ double
822 
  __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }
823 
 
824 
  inline __complex__ long double
825 
  __complex_sinh(const __complex__ long double& __z)
826 
  { return __builtin_csinhl(__z); }
827 
 
828 
  template<typename _Tp>
829 
    inline complex<_Tp>
830 
    sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
831 
#else
832 
  template<typename _Tp>
833 
    inline complex<_Tp>
834 
    sinh(const complex<_Tp>& __z) { return __complex_sinh(__z); }
835 
#endif
836 
 
837 
  // 26.2.8/13 sqrt(__z): Returns the complex square root of __z.
838 
  //                     The branch cut is on the negative axis.
839 
  template<typename _Tp>
840 
    complex<_Tp>
841 
    __complex_sqrt(const complex<_Tp>& __z)
842 
    {
843 
      _Tp __x = __z.real();
844 
      _Tp __y = __z.imag();
845 
 
846 
      if (__x == _Tp())
847 
        {
848 
          _Tp __t = sqrt(abs(__y) / 2);
849 
          return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
850 
        }
851 
      else
852 
        {
853 
          _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
854 
          _Tp __u = __t / 2;
855 
          return __x > _Tp()
856 
            ? complex<_Tp>(__u, __y / __t)
857 
            : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
858 
        }
859 
    }
860 
 
861 
#if _GLIBCXX_USE_C99_COMPLEX
862 
  inline __complex__ float
863 
  __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }
864 
 
865 
  inline __complex__ double
866 
  __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }
867 
 
868 
  inline __complex__ long double
869 
  __complex_sqrt(const __complex__ long double& __z)
870 
  { return __builtin_csqrtl(__z); }
871 
 
872 
  template<typename _Tp>
873 
    inline complex<_Tp>
874 
    sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
875 
#else
876 
  template<typename _Tp>
877 
    inline complex<_Tp>
878 
    sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z); }
879 
#endif
880 
 
881 
  // 26.2.8/14 tan(__z):  Return the complex tangent of __z.
882 
 
883 
  template<typename _Tp>
884 
    inline complex<_Tp>
885 
    __complex_tan(const complex<_Tp>& __z)
886 
    { return std::sin(__z) / std::cos(__z); }
887 
 
888 
#if _GLIBCXX_USE_C99_COMPLEX
889 
  inline __complex__ float
890 
  __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }
891 
 
892 
  inline __complex__ double
893 
  __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }
894 
 
895 
  inline __complex__ long double
896 
  __complex_tan(const __complex__ long double& __z)
897 
  { return __builtin_ctanl(__z); }
898 
 
899 
  template<typename _Tp>
900 
    inline complex<_Tp>
901 
    tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
902 
#else
903 
  template<typename _Tp>
904 
    inline complex<_Tp>
905 
    tan(const complex<_Tp>& __z) { return __complex_tan(__z); }
906 
#endif
907 
 
908 
 
909 
  // 26.2.8/15 tanh(__z):  Returns the hyperbolic tangent of __z.
910 
 
911 
  template<typename _Tp>
912 
    inline complex<_Tp>
913 
    __complex_tanh(const complex<_Tp>& __z)
914 
    { return std::sinh(__z) / std::cosh(__z); }
915 
 
916 
#if _GLIBCXX_USE_C99_COMPLEX
917 
  inline __complex__ float
918 
  __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }
919 
 
920 
  inline __complex__ double
921 
  __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }
922 
 
923 
  inline __complex__ long double
924 
  __complex_tanh(const __complex__ long double& __z)
925 
  { return __builtin_ctanhl(__z); }
926 
 
927 
  template<typename _Tp>
928 
    inline complex<_Tp>
929 
    tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
930 
#else
931 
  template<typename _Tp>
932 
    inline complex<_Tp>
933 
    tanh(const complex<_Tp>& __z) { return __complex_tanh(__z); }
934 
#endif
935 
 
936 
 
937 
  // 26.2.8/9  pow(__x, __y): Returns the complex power base of __x
938 
  //                          raised to the __y-th power.  The branch
939 
  //                          cut is on the negative axis.
940 
  template<typename _Tp>
941 
    inline complex<_Tp>
942 
    pow(const complex<_Tp>& __z, int __n)
943 
    { return std::__pow_helper(__z, __n); }
944 
 
945 
  template<typename _Tp>
946 
    complex<_Tp>
947 
    pow(const complex<_Tp>& __x, const _Tp& __y)
948 
    {
949 
#ifndef _GLIBCXX_USE_C99_COMPLEX
950 
      if (__x == _Tp())
951 
        return _Tp();
952 
#endif
953 
      if (__x.imag() == _Tp() && __x.real() > _Tp())
954 
        return pow(__x.real(), __y);
955 
 
956 
      complex<_Tp> __t = std::log(__x);
957 
      return std::polar(exp(__y * __t.real()), __y * __t.imag());
958 
    }
959 
 
960 
  template<typename _Tp>
961 
    inline complex<_Tp>
962 
    __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
963 
    { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
964 
 
965 
#if _GLIBCXX_USE_C99_COMPLEX
966 
  inline __complex__ float
967 
  __complex_pow(__complex__ float __x, __complex__ float __y)
968 
  { return __builtin_cpowf(__x, __y); }
969 
 
970 
  inline __complex__ double
971 
  __complex_pow(__complex__ double __x, __complex__ double __y)
972 
  { return __builtin_cpow(__x, __y); }
973 
 
974 
  inline __complex__ long double
975 
  __complex_pow(const __complex__ long double& __x,
976 
                const __complex__ long double& __y)
977 
  { return __builtin_cpowl(__x, __y); }
978 
 
979 
  template<typename _Tp>
980 
    inline complex<_Tp>
981 
    pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
982 
    { return __complex_pow(__x.__rep(), __y.__rep()); }
983 
#else
984 
  template<typename _Tp>
985 
    inline complex<_Tp>
986 
    pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
987 
    { return __complex_pow(__x, __y); }
988 
#endif
989 
 
990 
  template<typename _Tp>
991 
    inline complex<_Tp>
992 
    pow(const _Tp& __x, const complex<_Tp>& __y)
993 
    {
994 
      return __x > _Tp() ? std::polar(pow(__x, __y.real()),
995 
                                      __y.imag() * log(__x))
996 
                         : std::pow(complex<_Tp>(__x, _Tp()), __y);
997 
    }
998 
 
999 
  // 26.2.3  complex specializations
1000 
  // complex<float> specialization
1001 
  template<>
1002 
    struct complex<float>
1003 
    {
1004 
      typedef float value_type;
1005 
      typedef __complex__ float _ComplexT;
1006 
 
1007 
      complex(_ComplexT __z) : _M_value(__z) { }
1008 
 
1009 
      complex(float = 0.0f, float = 0.0f);
1010 
 
1011 
      explicit complex(const complex<double>&);
1012 
      explicit complex(const complex<long double>&);
1013 
 
1014 
      float& real();
1015 
      const float& real() const;
1016 
      float& imag();
1017 
      const float& imag() const;
1018 
 
1019 
      complex<float>& operator=(float);
1020 
      complex<float>& operator+=(float);
1021 
      complex<float>& operator-=(float);
1022 
      complex<float>& operator*=(float);
1023 
      complex<float>& operator/=(float);
1024 
 
1025 
      // Let's the compiler synthetize the copy and assignment
1026 
      // operator.  It always does a pretty good job.
1027 
      // complex& operator= (const complex&);
1028 
      template<typename _Tp>
1029 
        complex<float>&operator=(const complex<_Tp>&);
1030 
      template<typename _Tp>
1031 
        complex<float>& operator+=(const complex<_Tp>&);
1032 
      template<class _Tp>
1033 
        complex<float>& operator-=(const complex<_Tp>&);
1034 
      template<class _Tp>
1035 
        complex<float>& operator*=(const complex<_Tp>&);
1036 
      template<class _Tp>
1037 
        complex<float>&operator/=(const complex<_Tp>&);
1038 
 
1039 
      const _ComplexT& __rep() const { return _M_value; }
1040 
 
1041 
    private:
1042 
      _ComplexT _M_value;
1043 
    };
1044 
 
1045 
  inline float&
1046 
  complex<float>::real()
1047 
  { return __real__ _M_value; }
1048 
 
1049 
  inline const float&
1050 
  complex<float>::real() const
1051 
  { return __real__ _M_value; }
1052 
 
1053 
  inline float&
1054 
  complex<float>::imag()
1055 
  { return __imag__ _M_value; }
1056 
 
1057 
  inline const float&
1058 
  complex<float>::imag() const
1059 
  { return __imag__ _M_value; }
1060 
 
1061 
  inline
1062 
  complex<float>::complex(float r, float i)
1063 
  {
1064 
    __real__ _M_value = r;
1065 
    __imag__ _M_value = i;
1066 
  }
1067 
 
1068 
  inline complex<float>&
1069 
  complex<float>::operator=(float __f)
1070 
  {
1071 
    __real__ _M_value = __f;
1072 
    __imag__ _M_value = 0.0f;
1073 
    return *this;
1074 
  }
1075 
 
1076 
  inline complex<float>&
1077 
  complex<float>::operator+=(float __f)
1078 
  {
1079 
    __real__ _M_value += __f;
1080 
    return *this;
1081 
  }
1082 
 
1083 
  inline complex<float>&
1084 
  complex<float>::operator-=(float __f)
1085 
  {
1086 
    __real__ _M_value -= __f;
1087 
    return *this;
1088 
  }
1089 
 
1090 
  inline complex<float>&
1091 
  complex<float>::operator*=(float __f)
1092 
  {
1093 
    _M_value *= __f;
1094 
    return *this;
1095 
  }
1096 
 
1097 
  inline complex<float>&
1098 
  complex<float>::operator/=(float __f)
1099 
  {
1100 
    _M_value /= __f;
1101 
    return *this;
1102 
  }
1103 
 
1104 
  template<typename _Tp>
1105 
  inline complex<float>&
1106 
  complex<float>::operator=(const complex<_Tp>& __z)
1107 
  {
1108 
    __real__ _M_value = __z.real();
1109 
    __imag__ _M_value = __z.imag();
1110 
    return *this;
1111 
  }
1112 
 
1113 
  template<typename _Tp>
1114 
  inline complex<float>&
1115 
  complex<float>::operator+=(const complex<_Tp>& __z)
1116 
  {
1117 
    __real__ _M_value += __z.real();
1118 
    __imag__ _M_value += __z.imag();
1119 
    return *this;
1120 
  }
1121 
 
1122 
  template<typename _Tp>
1123 
    inline complex<float>&
1124 
    complex<float>::operator-=(const complex<_Tp>& __z)
1125 
    {
1126 
     __real__ _M_value -= __z.real();
1127 
     __imag__ _M_value -= __z.imag();
1128 
     return *this;
1129 
    }
1130 
 
1131 
  template<typename _Tp>
1132 
    inline complex<float>&
1133 
    complex<float>::operator*=(const complex<_Tp>& __z)
1134 
    {
1135 
      _ComplexT __t;
1136 
      __real__ __t = __z.real();
1137 
      __imag__ __t = __z.imag();
1138 
      _M_value *= __t;
1139 
      return *this;
1140 
    }
1141 
 
1142 
  template<typename _Tp>
1143 
    inline complex<float>&
1144 
    complex<float>::operator/=(const complex<_Tp>& __z)
1145 
    {
1146 
      _ComplexT __t;
1147 
      __real__ __t = __z.real();
1148 
      __imag__ __t = __z.imag();
1149 
      _M_value /= __t;
1150 
      return *this;
1151 
    }
1152 
 
1153 
  // 26.2.3  complex specializations
1154 
  // complex<double> specialization
1155 
  template<>
1156 
    struct complex<double>
1157 
    {
1158 
      typedef double value_type;
1159 
      typedef __complex__ double _ComplexT;
1160 
 
1161 
      complex(_ComplexT __z) : _M_value(__z) { }
1162 
 
1163 
      complex(double = 0.0, double = 0.0);
1164 
 
1165 
      complex(const complex<float>&);
1166 
      explicit complex(const complex<long double>&);
1167 
 
1168 
      double& real();
1169 
      const double& real() const;
1170 
      double& imag();
1171 
      const double& imag() const;
1172 
 
1173 
      complex<double>& operator=(double);
1174 
      complex<double>& operator+=(double);
1175 
      complex<double>& operator-=(double);
1176 
      complex<double>& operator*=(double);
1177 
      complex<double>& operator/=(double);
1178 
 
1179 
      // The compiler will synthetize this, efficiently.
1180 
      // complex& operator= (const complex&);
1181 
      template<typename _Tp>
1182 
        complex<double>& operator=(const complex<_Tp>&);
1183 
      template<typename _Tp>
1184 
        complex<double>& operator+=(const complex<_Tp>&);
1185 
      template<typename _Tp>
1186 
        complex<double>& operator-=(const complex<_Tp>&);
1187 
      template<typename _Tp>
1188 
        complex<double>& operator*=(const complex<_Tp>&);
1189 
      template<typename _Tp>
1190 
        complex<double>& operator/=(const complex<_Tp>&);
1191 
 
1192 
      const _ComplexT& __rep() const { return _M_value; }
1193 
 
1194 
    private:
1195 
      _ComplexT _M_value;
1196 
    };
1197 
 
1198 
  inline double&
1199 
  complex<double>::real()
1200 
  { return __real__ _M_value; }
1201 
 
1202 
  inline const double&
1203 
  complex<double>::real() const
1204 
  { return __real__ _M_value; }
1205 
 
1206 
  inline double&
1207 
  complex<double>::imag()
1208 
  { return __imag__ _M_value; }
1209 
 
1210 
  inline const double&
1211 
  complex<double>::imag() const
1212 
  { return __imag__ _M_value; }
1213 
 
1214 
  inline
1215 
  complex<double>::complex(double __r, double __i)
1216 
  {
1217 
    __real__ _M_value = __r;
1218 
    __imag__ _M_value = __i;
1219 
  }
1220 
 
1221 
  inline complex<double>&
1222 
  complex<double>::operator=(double __d)
1223 
  {
1224 
    __real__ _M_value = __d;
1225 
    __imag__ _M_value = 0.0;
1226 
    return *this;
1227 
  }
1228 
 
1229 
  inline complex<double>&
1230 
  complex<double>::operator+=(double __d)
1231 
  {
1232 
    __real__ _M_value += __d;
1233 
    return *this;
1234 
  }
1235 
 
1236 
  inline complex<double>&
1237 
  complex<double>::operator-=(double __d)
1238 
  {
1239 
    __real__ _M_value -= __d;
1240 
    return *this;
1241 
  }
1242 
 
1243 
  inline complex<double>&
1244 
  complex<double>::operator*=(double __d)
1245 
  {
1246 
    _M_value *= __d;
1247 
    return *this;
1248 
  }
1249 
 
1250 
  inline complex<double>&
1251 
  complex<double>::operator/=(double __d)
1252 
  {
1253 
    _M_value /= __d;
1254 
    return *this;
1255 
  }
1256 
 
1257 
  template<typename _Tp>
1258 
    inline complex<double>&
1259 
    complex<double>::operator=(const complex<_Tp>& __z)
1260 
    {
1261 
      __real__ _M_value = __z.real();
1262 
      __imag__ _M_value = __z.imag();
1263 
      return *this;
1264 
    }
1265 
 
1266 
  template<typename _Tp>
1267 
    inline complex<double>&
1268 
    complex<double>::operator+=(const complex<_Tp>& __z)
1269 
    {
1270 
      __real__ _M_value += __z.real();
1271 
      __imag__ _M_value += __z.imag();
1272 
      return *this;
1273 
    }
1274 
 
1275 
  template<typename _Tp>
1276 
    inline complex<double>&
1277 
    complex<double>::operator-=(const complex<_Tp>& __z)
1278 
    {
1279 
      __real__ _M_value -= __z.real();
1280 
      __imag__ _M_value -= __z.imag();
1281 
      return *this;
1282 
    }
1283 
 
1284 
  template<typename _Tp>
1285 
    inline complex<double>&
1286 
    complex<double>::operator*=(const complex<_Tp>& __z)
1287 
    {
1288 
      _ComplexT __t;
1289 
      __real__ __t = __z.real();
1290 
      __imag__ __t = __z.imag();
1291 
      _M_value *= __t;
1292 
      return *this;
1293 
    }
1294 
 
1295 
  template<typename _Tp>
1296 
    inline complex<double>&
1297 
    complex<double>::operator/=(const complex<_Tp>& __z)
1298 
    {
1299 
      _ComplexT __t;
1300 
      __real__ __t = __z.real();
1301 
      __imag__ __t = __z.imag();
1302 
      _M_value /= __t;
1303 
      return *this;
1304 
    }
1305 
 
1306 
  // 26.2.3  complex specializations
1307 
  // complex<long double> specialization
1308 
  template<>
1309 
    struct complex<long double>
1310 
    {
1311 
      typedef long double value_type;
1312 
      typedef __complex__ long double _ComplexT;
1313 
 
1314 
      complex(_ComplexT __z) : _M_value(__z) { }
1315 
 
1316 
      complex(long double = 0.0L, long double = 0.0L);
1317 
 
1318 
      complex(const complex<float>&);
1319 
      complex(const complex<double>&);
1320 
 
1321 
      long double& real();
1322 
      const long double& real() const;
1323 
      long double& imag();
1324 
      const long double& imag() const;
1325 
 
1326 
      complex<long double>& operator= (long double);
1327 
      complex<long double>& operator+= (long double);
1328 
      complex<long double>& operator-= (long double);
1329 
      complex<long double>& operator*= (long double);
1330 
      complex<long double>& operator/= (long double);
1331 
 
1332 
      // The compiler knows how to do this efficiently
1333 
      // complex& operator= (const complex&);
1334 
      template<typename _Tp>
1335 
        complex<long double>& operator=(const complex<_Tp>&);
1336 
      template<typename _Tp>
1337 
        complex<long double>& operator+=(const complex<_Tp>&);
1338 
      template<typename _Tp>
1339 
        complex<long double>& operator-=(const complex<_Tp>&);
1340 
      template<typename _Tp>
1341 
        complex<long double>& operator*=(const complex<_Tp>&);
1342 
      template<typename _Tp>
1343 
        complex<long double>& operator/=(const complex<_Tp>&);
1344 
 
1345 
      const _ComplexT& __rep() const { return _M_value; }
1346 
 
1347 
    private:
1348 
      _ComplexT _M_value;
1349 
    };
1350 
 
1351 
  inline
1352 
  complex<long double>::complex(long double __r, long double __i)
1353 
  {
1354 
    __real__ _M_value = __r;
1355 
    __imag__ _M_value = __i;
1356 
  }
1357 
 
1358 
  inline long double&
1359 
  complex<long double>::real()
1360 
  { return __real__ _M_value; }
1361 
 
1362 
  inline const long double&
1363 
  complex<long double>::real() const
1364 
  { return __real__ _M_value; }
1365 
 
1366 
  inline long double&
1367 
  complex<long double>::imag()
1368 
  { return __imag__ _M_value; }
1369 
 
1370 
  inline const long double&
1371 
  complex<long double>::imag() const
1372 
  { return __imag__ _M_value; }
1373 
 
1374 
  inline complex<long double>&
1375 
  complex<long double>::operator=(long double __r)
1376 
  {
1377 
    __real__ _M_value = __r;
1378 
    __imag__ _M_value = 0.0L;
1379 
    return *this;
1380 
  }
1381 
 
1382 
  inline complex<long double>&
1383 
  complex<long double>::operator+=(long double __r)
1384 
  {
1385 
    __real__ _M_value += __r;
1386 
    return *this;
1387 
  }
1388 
 
1389 
  inline complex<long double>&
1390 
  complex<long double>::operator-=(long double __r)
1391 
  {
1392 
    __real__ _M_value -= __r;
1393 
    return *this;
1394 
  }
1395 
 
1396 
  inline complex<long double>&
1397 
  complex<long double>::operator*=(long double __r)
1398 
  {
1399 
    _M_value *= __r;
1400 
    return *this;
1401 
  }
1402 
 
1403 
  inline complex<long double>&
1404 
  complex<long double>::operator/=(long double __r)
1405 
  {
1406 
    _M_value /= __r;
1407 
    return *this;
1408 
  }
1409 
 
1410 
  template<typename _Tp>
1411 
    inline complex<long double>&
1412 
    complex<long double>::operator=(const complex<_Tp>& __z)
1413 
    {
1414 
      __real__ _M_value = __z.real();
1415 
      __imag__ _M_value = __z.imag();
1416 
      return *this;
1417 
    }
1418 
 
1419 
  template<typename _Tp>
1420 
    inline complex<long double>&
1421 
    complex<long double>::operator+=(const complex<_Tp>& __z)
1422 
    {
1423 
      __real__ _M_value += __z.real();
1424 
      __imag__ _M_value += __z.imag();
1425 
      return *this;
1426 
    }
1427 
 
1428 
  template<typename _Tp>
1429 
    inline complex<long double>&
1430 
    complex<long double>::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<typename _Tp>
1438 
    inline complex<long double>&
1439 
    complex<long double>::operator*=(const complex<_Tp>& __z)
1440 
    {
1441 
      _ComplexT __t;
1442 
      __real__ __t = __z.real();
1443 
      __imag__ __t = __z.imag();
1444 
      _M_value *= __t;
1445 
      return *this;
1446 
    }
1447 
 
1448 
  template<typename _Tp>
1449 
    inline complex<long double>&
1450 
    complex<long double>::operator/=(const complex<_Tp>& __z)
1451 
    {
1452 
      _ComplexT __t;
1453 
      __real__ __t = __z.real();
1454 
      __imag__ __t = __z.imag();
1455 
      _M_value /= __t;
1456 
      return *this;
1457 
    }
1458 
 
1459 
  // These bits have to be at the end of this file, so that the
1460 
  // specializations have all been defined.
1461 
  // ??? No, they have to be there because of compiler limitation at
1462 
  // inlining.  It suffices that class specializations be defined.
1463 
  inline
1464 
  complex<float>::complex(const complex<double>& __z)
1465 
  : _M_value(__z.__rep()) { }
1466 
 
1467 
  inline
1468 
  complex<float>::complex(const complex<long double>& __z)
1469 
  : _M_value(__z.__rep()) { }
1470 
 
1471 
  inline
1472 
  complex<double>::complex(const complex<float>& __z)
1473 
  : _M_value(__z.__rep()) { }
1474 
 
1475 
  inline
1476 
  complex<double>::complex(const complex<long double>& __z)
1477 
    : _M_value(__z.__rep()) { }
1478 
 
1479 
  inline
1480 
  complex<long double>::complex(const complex<float>& __z)
1481 
  : _M_value(__z.__rep()) { }
1482 
 
1483 
  inline
1484 
  complex<long double>::complex(const complex<double>& __z)
1485 
  : _M_value(__z.__rep()) { }
1486 
} // namespace std
1487 
 
1488 
#endif  /* _GLIBCXX_COMPLEX */

powered by: WebSVN 2.1.0

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