test: epoc32/include/tools/stlport/stl/

     1 /*

     2  * Copyright (c) 1999

     3  * Silicon Graphics Computer Systems, Inc.

     4  *

     5  * Copyright (c) 1999

     6  * Boris Fomitchev

     7  *

     8  * This material is provided "as is", with absolutely no warranty expressed

     9  * or implied. Any use is at your own risk.

    10  *

    11  * Permission to use or copy this software for any purpose is hereby granted

    12  * without fee, provided the above notices are retained on all copies.

    13  * Permission to modify the code and to distribute modified code is granted,

    14  * provided the above notices are retained, and a notice that the code was

    15  * modified is included with the above copyright notice.

    16  *

    17  */

    18 #ifndef _STLP_INTERNAL_COMPLEX

    19 #define _STLP_INTERNAL_COMPLEX

    21 // This header declares the template class complex, as described in

    22 // in the draft C++ standard.  Single-precision complex numbers

    23 // are complex<float>, double-precision are complex<double>, and

    24 // quad precision are complex<long double>.

    26 // Note that the template class complex is declared within namespace

    27 // std, as called for by the draft C++ standard.

    29 #ifndef _STLP_INTERNAL_CMATH

    30 #  include <stl/_cmath.h>

    31 #endif

    33 _STLP_BEGIN_NAMESPACE

    35 #if !defined (_STLP_NO_COMPLEX_SPECIALIZATIONS)    //*TY 02/25/2000 - added for MPW compiler workaround

    37 template <class _Tp> struct complex;

    39 _STLP_TEMPLATE_NULL struct _STLP_CLASS_DECLSPEC complex<float>;

    40 _STLP_TEMPLATE_NULL struct _STLP_CLASS_DECLSPEC complex<double>;

    41 #  if !defined (_STLP_NO_LONG_DOUBLE)

    42 _STLP_TEMPLATE_NULL struct _STLP_CLASS_DECLSPEC complex<long double>;

    43 #  endif

    44 #endif /* _STLP_NO_COMPLEX_SPECIALIZATIONS */

    46 template <class _Tp>

    47 struct complex {

    48   typedef _Tp value_type;

    49   typedef complex<_Tp> _Self;

    51   // Constructors, destructor, assignment operator.

    52   complex() : _M_re(0), _M_im(0) {}

    53   complex(const value_type& __x)

    54     : _M_re(__x), _M_im(0) {}

    55   complex(const value_type& __x, const value_type& __y)

    56     : _M_re(__x), _M_im(__y) {}

    57   complex(const _Self& __z)

    58     : _M_re(__z._M_re), _M_im(__z._M_im) {}

    60   _Self& operator=(const _Self& __z) {

    61     _M_re = __z._M_re;

    62     _M_im = __z._M_im;

    63     return *this;

    64   }

    66 #if defined (_STLP_MEMBER_TEMPLATES) && (defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER) || defined(_STLP_NO_COMPLEX_SPECIALIZATIONS))

    67   template <class _Tp2>

    68   explicit complex(const complex<_Tp2>& __z)

    69     : _M_re(__z._M_re), _M_im(__z._M_im) {}

    71   template <class _Tp2>

    72   _Self& operator=(const complex<_Tp2>& __z) {

    73     _M_re = __z._M_re;

    74     _M_im = __z._M_im;

    75     return *this;

    76   }

    77 #endif /* _STLP_MEMBER_TEMPLATES */

    79   // Element access.

    80   value_type real() const { return _M_re; }

    81   value_type imag() const { return _M_im; }

    83   // Arithmetic op= operations involving one real argument.

    85   _Self& operator= (const value_type& __x) {

    86     _M_re = __x;

    87     _M_im = 0;

    88     return *this;

    89   }

    90   _Self& operator+= (const value_type& __x) {

    91     _M_re += __x;

    92     return *this;

    93   }

    94   _Self& operator-= (const value_type& __x) {

    95     _M_re -= __x;

    96     return *this;

    97   }

    98   _Self& operator*= (const value_type& __x) {

    99     _M_re *= __x;

   100     _M_im *= __x;

   101     return *this;

   102   }

   103   _Self& operator/= (const value_type& __x) {

   104     _M_re /= __x;

   105     _M_im /= __x;

   106     return *this;

   107   }

   109   // Arithmetic op= operations involving two complex arguments.

   111   static void  _STLP_CALL _div(const value_type& __z1_r, const value_type& __z1_i,

   112                                const value_type& __z2_r, const value_type& __z2_i,

   113                                value_type& __res_r, value_type& __res_i);

   115   static void _STLP_CALL _div(const value_type& __z1_r,

   116                               const value_type& __z2_r, const value_type& __z2_i,

   117                               value_type& __res_r, value_type& __res_i);

   119 #if defined (_STLP_MEMBER_TEMPLATES) // && defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)

   121   template <class _Tp2> _Self& operator+= (const complex<_Tp2>& __z) {

   122     _M_re += __z._M_re;

   123     _M_im += __z._M_im;

   124     return *this;

   125   }

   127   template <class _Tp2> _Self& operator-= (const complex<_Tp2>& __z) {

   128     _M_re -= __z._M_re;

   129     _M_im -= __z._M_im;

   130     return *this;

   131   }

   133   template <class _Tp2> _Self& operator*= (const complex<_Tp2>& __z) {

   134     value_type __r = _M_re * __z._M_re - _M_im * __z._M_im;

   135     value_type __i = _M_re * __z._M_im + _M_im * __z._M_re;

   136     _M_re = __r;

   137     _M_im = __i;

   138     return *this;

   139   }

   141   template <class _Tp2> _Self& operator/= (const complex<_Tp2>& __z) {

   142     value_type __r;

   143     value_type __i;

   144     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);

   145     _M_re = __r;

   146     _M_im = __i;

   147     return *this;

   148   }

   149 #endif /* _STLP_MEMBER_TEMPLATES */

   151   _Self& operator+= (const _Self& __z) {

   152     _M_re += __z._M_re;

   153     _M_im += __z._M_im;

   154     return *this;

   155   }

   157   _Self& operator-= (const _Self& __z) {

   158     _M_re -= __z._M_re;

   159     _M_im -= __z._M_im;

   160     return *this;

   161   }

   163   _Self& operator*= (const _Self& __z) {

   164     value_type __r = _M_re * __z._M_re - _M_im * __z._M_im;

   165     value_type __i = _M_re * __z._M_im + _M_im * __z._M_re;

   166     _M_re = __r;

   167     _M_im = __i;

   168     return *this;

   169   }

   171   _Self& operator/= (const _Self& __z) {

   172     value_type __r;

   173     value_type __i;

   174     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);

   175     _M_re = __r;

   176     _M_im = __i;

   177     return *this;

   178   }

   180   // Data members.

   181   value_type _M_re;

   182   value_type _M_im;

   183 };

   185 #if !defined (_STLP_NO_COMPLEX_SPECIALIZATIONS)    //*TY 02/25/2000 - added for MPW compiler workaround

   186 // Explicit specializations for float, double, long double.  The only

   187 // reason for these specializations is to enable automatic conversions

   188 // from complex<float> to complex<double>, and complex<double> to

   189 // complex<long double>.

   191 _STLP_TEMPLATE_NULL

   192 struct _STLP_CLASS_DECLSPEC complex<float> {

   193   typedef float value_type;

   194   typedef complex<float> _Self;

   195   // Constructors, destructor, assignment operator.

   197   complex(value_type __x = 0.0f, value_type __y = 0.0f)

   198     : _M_re(__x), _M_im(__y) {}

   200   complex(const complex<float>& __z)    : _M_re(__z._M_re), _M_im(__z._M_im) {}

   202   inline explicit complex(const complex<double>& __z);

   203 #  ifndef _STLP_NO_LONG_DOUBLE

   204   inline explicit complex(const complex<long double>& __z);

   205 #  endif

   206   // Element access.

   207   value_type real() const { return _M_re; }

   208   value_type imag() const { return _M_im; }

   210   // Arithmetic op= operations involving one real argument.

   212   _Self& operator= (value_type __x) {

   213     _M_re = __x;

   214     _M_im = 0.0f;

   215     return *this;

   216   }

   217   _Self& operator+= (value_type __x) {

   218     _M_re += __x;

   219     return *this;

   220   }

   221   _Self& operator-= (value_type __x) {

   222     _M_re -= __x;

   223     return *this;

   224   }

   225   _Self& operator*= (value_type __x) {

   226     _M_re *= __x;

   227     _M_im *= __x;

   228     return *this;

   229   }

   230   _Self& operator/= (value_type __x) {

   231     _M_re /= __x;

   232     _M_im /= __x;

   233     return *this;

   234   }

   236   // Arithmetic op= operations involving two complex arguments.

   238   static void _STLP_CALL _div(const float& __z1_r, const float& __z1_i,

   239                               const float& __z2_r, const float& __z2_i,

   240                               float& __res_r, float& __res_i);

   242   static void _STLP_CALL _div(const float& __z1_r,

   243                               const float& __z2_r, const float& __z2_i,

   244                               float& __res_r, float& __res_i);

   246 #  if defined (_STLP_MEMBER_TEMPLATES)

   247   template <class _Tp2>

   248   complex<float>& operator=(const complex<_Tp2>& __z) {

   249     _M_re = __z._M_re;

   250     _M_im = __z._M_im;

   251     return *this;

   252   }

   254   template <class _Tp2>

   255   complex<float>& operator+= (const complex<_Tp2>& __z) {

   256     _M_re += __z._M_re;

   257     _M_im += __z._M_im;

   258     return *this;

   259   }

   261   template <class _Tp2>

   262   complex<float>& operator-= (const complex<_Tp2>& __z) {

   263     _M_re -= __z._M_re;

   264     _M_im -= __z._M_im;

   265     return *this;

   266   }

   268   template <class _Tp2>

   269   complex<float>& operator*= (const complex<_Tp2>& __z) {

   270     float __r = _M_re * __z._M_re - _M_im * __z._M_im;

   271     float __i = _M_re * __z._M_im + _M_im * __z._M_re;

   272     _M_re = __r;

   273     _M_im = __i;

   274     return *this;

   275   }

   277   template <class _Tp2>

   278   complex<float>& operator/= (const complex<_Tp2>& __z) {

   279     float __r;

   280     float __i;

   281     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);

   282     _M_re = __r;

   283     _M_im = __i;

   284     return *this;

   285   }

   287 #  endif /* _STLP_MEMBER_TEMPLATES */

   289   _Self& operator=(const _Self& __z) {

   290     _M_re = __z._M_re;

   291     _M_im = __z._M_im;

   292     return *this;

   293   }

   295   _Self& operator+= (const _Self& __z) {

   296     _M_re += __z._M_re;

   297     _M_im += __z._M_im;

   298     return *this;

   299   }

   301   _Self& operator-= (const _Self& __z) {

   302     _M_re -= __z._M_re;

   303     _M_im -= __z._M_im;

   304     return *this;

   305   }

   307   _Self& operator*= (const _Self& __z) {

   308     value_type __r = _M_re * __z._M_re - _M_im * __z._M_im;

   309     value_type __i = _M_re * __z._M_im + _M_im * __z._M_re;

   310     _M_re = __r;

   311     _M_im = __i;

   312     return *this;

   313   }

   315   _Self& operator/= (const _Self& __z) {

   316     value_type __r;

   317     value_type __i;

   318     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);

   319     _M_re = __r;

   320     _M_im = __i;

   321     return *this;

   322   }

   324   // Data members.

   325   value_type _M_re;

   326   value_type _M_im;

   327 };

   329 _STLP_TEMPLATE_NULL

   330 struct _STLP_CLASS_DECLSPEC complex<double> {

   331   typedef double value_type;

   332   typedef complex<double> _Self;

   334   // Constructors, destructor, assignment operator.

   336   complex(value_type __x = 0.0, value_type __y = 0.0)

   337     : _M_re(__x), _M_im(__y) {}

   339   complex(const complex<double>& __z)

   340     : _M_re(__z._M_re), _M_im(__z._M_im) {}

   341   inline complex(const complex<float>& __z);

   342 #  if !defined (_STLP_NO_LONG_DOUBLE)

   343   explicit inline complex(const complex<long double>& __z);

   344 #  endif

   345   // Element access.

   346   value_type real() const { return _M_re; }

   347   value_type imag() const { return _M_im; }

   349   // Arithmetic op= operations involving one real argument.

   351   _Self& operator= (value_type __x) {

   352     _M_re = __x;

   353     _M_im = 0.0;

   354     return *this;

   355   }

   356   _Self& operator+= (value_type __x) {

   357     _M_re += __x;

   358     return *this;

   359   }

   360   _Self& operator-= (value_type __x) {

   361     _M_re -= __x;

   362     return *this;

   363   }

   364   _Self& operator*= (value_type __x) {

   365     _M_re *= __x;

   366     _M_im *= __x;

   367     return *this;

   368   }

   369   _Self& operator/= (value_type __x) {

   370     _M_re /= __x;

   371     _M_im /= __x;

   372     return *this;

   373   }

   375   // Arithmetic op= operations involving two complex arguments.

   377   static void _STLP_CALL _div(const double& __z1_r, const double& __z1_i,

   378                               const double& __z2_r, const double& __z2_i,

   379                               double& __res_r, double& __res_i);

   380   static void _STLP_CALL _div(const double& __z1_r,

   381                               const double& __z2_r, const double& __z2_i,

   382                               double& __res_r, double& __res_i);

   384 #  if defined (_STLP_MEMBER_TEMPLATES) && defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)

   385   template <class _Tp2>

   386   complex<double>& operator=(const complex<_Tp2>& __z) {

   387     _M_re = __z._M_re;

   388     _M_im = __z._M_im;

   389     return *this;

   390   }

   392   template <class _Tp2>

   393   complex<double>& operator+= (const complex<_Tp2>& __z) {

   394     _M_re += __z._M_re;

   395     _M_im += __z._M_im;

   396     return *this;

   397   }

   399   template <class _Tp2>

   400   complex<double>& operator-= (const complex<_Tp2>& __z) {

   401     _M_re -= __z._M_re;

   402     _M_im -= __z._M_im;

   403     return *this;

   404   }

   406   template <class _Tp2>

   407   complex<double>& operator*= (const complex<_Tp2>& __z) {

   408     double __r = _M_re * __z._M_re - _M_im * __z._M_im;

   409     double __i = _M_re * __z._M_im + _M_im * __z._M_re;

   410     _M_re = __r;

   411     _M_im = __i;

   412     return *this;

   413   }

   415   template <class _Tp2>

   416   complex<double>& operator/= (const complex<_Tp2>& __z) {

   417     double __r;

   418     double __i;

   419     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);

   420     _M_re = __r;

   421     _M_im = __i;

   422     return *this;

   423   }

   425 #  endif /* _STLP_MEMBER_TEMPLATES */

   427   _Self& operator=(const _Self& __z) {

   428     _M_re = __z._M_re;

   429     _M_im = __z._M_im;

   430     return *this;

   431   }

   433   _Self& operator+= (const _Self& __z) {

   434     _M_re += __z._M_re;

   435     _M_im += __z._M_im;

   436     return *this;

   437   }

   439   _Self& operator-= (const _Self& __z) {

   440     _M_re -= __z._M_re;

   441     _M_im -= __z._M_im;

   442     return *this;

   443   }

   445   _Self& operator*= (const _Self& __z) {

   446     value_type __r = _M_re * __z._M_re - _M_im * __z._M_im;

   447     value_type __i = _M_re * __z._M_im + _M_im * __z._M_re;

   448     _M_re = __r;

   449     _M_im = __i;

   450     return *this;

   451   }

   453   _Self& operator/= (const _Self& __z) {

   454     value_type __r;

   455     value_type __i;

   456     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);

   457     _M_re = __r;

   458     _M_im = __i;

   459     return *this;

   460   }

   462   // Data members.

   463   value_type _M_re;

   464   value_type _M_im;

   465 };

   467 #  if !defined (_STLP_NO_LONG_DOUBLE)

   469 _STLP_TEMPLATE_NULL

   470 struct _STLP_CLASS_DECLSPEC complex<long double> {

   471   typedef long double value_type;

   472   typedef complex<long double> _Self;

   474   // Constructors, destructor, assignment operator.

   475   complex(value_type __x = 0.0l, value_type __y = 0.0l)

   476     : _M_re(__x), _M_im(__y) {}

   478   complex(const complex<long double>& __z)

   479     : _M_re(__z._M_re), _M_im(__z._M_im) {}

   480   inline complex(const complex<float>& __z);

   481   inline complex(const complex<double>& __z);

   483   // Element access.

   484   value_type real() const { return _M_re; }

   485   value_type imag() const { return _M_im; }

   487   // Arithmetic op= operations involving one real argument.

   489   _Self& operator= (value_type __x) {

   490     _M_re = __x;

   491     _M_im = 0.0l;

   492     return *this;

   493   }

   494   _Self& operator+= (value_type __x) {

   495     _M_re += __x;

   496     return *this;

   497   }

   498   _Self& operator-= (value_type __x) {

   499     _M_re -= __x;

   500     return *this;

   501   }

   502   _Self& operator*= (value_type __x) {

   503     _M_re *= __x;

   504     _M_im *= __x;

   505     return *this;

   506   }

   507   _Self& operator/= (value_type __x) {

   508     _M_re /= __x;

   509     _M_im /= __x;

   510     return *this;

   511   }

   513   // Arithmetic op= operations involving two complex arguments.

   515   static void _STLP_CALL _div(const long double& __z1_r, const long double& __z1_i,

   516                               const long double& __z2_r, const long double& __z2_i,

   517                               long double& __res_r, long double& __res_i);

   519   static void _STLP_CALL _div(const long double& __z1_r,

   520                               const long double& __z2_r, const long double& __z2_i,

   521                               long double& __res_r, long double& __res_i);

   523 #    if defined (_STLP_MEMBER_TEMPLATES) && defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)

   525   template <class _Tp2>

   526   complex<long double>& operator=(const complex<_Tp2>& __z) {

   527     _M_re = __z._M_re;

   528     _M_im = __z._M_im;

   529     return *this;

   530   }

   532   template <class _Tp2>

   533   complex<long double>& operator+= (const complex<_Tp2>& __z) {

   534     _M_re += __z._M_re;

   535     _M_im += __z._M_im;

   536     return *this;

   537   }

   539   template <class _Tp2>

   540   complex<long double>& operator-= (const complex<_Tp2>& __z) {

   541     _M_re -= __z._M_re;

   542     _M_im -= __z._M_im;

   543     return *this;

   544   }

   546   template <class _Tp2>

   547   complex<long double>& operator*= (const complex<_Tp2>& __z) {

   548     long double __r = _M_re * __z._M_re - _M_im * __z._M_im;

   549     long double __i = _M_re * __z._M_im + _M_im * __z._M_re;

   550     _M_re = __r;

   551     _M_im = __i;

   552     return *this;

   553   }

   555   template <class _Tp2>

   556   complex<long double>& operator/= (const complex<_Tp2>& __z) {

   557     long double __r;

   558     long double __i;

   559     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);

   560     _M_re = __r;

   561     _M_im = __i;

   562     return *this;

   563   }

   565 #    endif /* _STLP_MEMBER_TEMPLATES */

   567   _Self& operator=(const _Self& __z) {

   568     _M_re = __z._M_re;

   569     _M_im = __z._M_im;

   570     return *this;

   571   }

   573   _Self& operator+= (const _Self& __z) {

   574     _M_re += __z._M_re;

   575     _M_im += __z._M_im;

   576     return *this;

   577   }

   579   _Self& operator-= (const _Self& __z) {

   580     _M_re -= __z._M_re;

   581     _M_im -= __z._M_im;

   582     return *this;

   583   }

   585   _Self& operator*= (const _Self& __z) {

   586     value_type __r = _M_re * __z._M_re - _M_im * __z._M_im;

   587     value_type __i = _M_re * __z._M_im + _M_im * __z._M_re;

   588     _M_re = __r;

   589     _M_im = __i;

   590     return *this;

   591   }

   593   _Self& operator/= (const _Self& __z) {

   594     value_type __r;

   595     value_type __i;

   596     _div(_M_re, _M_im, __z._M_re, __z._M_im, __r, __i);

   597     _M_re = __r;

   598     _M_im = __i;

   599     return *this;

   600   }

   602   // Data members.

   603   value_type _M_re;

   604   value_type _M_im;

   605 };

   607 #  endif /* _STLP_NO_LONG_DOUBLE */

   609 // Converting constructors from one of these three specialized types

   610 // to another.

   612 inline complex<float>::complex(const complex<double>& __z)

   613   : _M_re((float)__z._M_re), _M_im((float)__z._M_im) {}

   614 inline complex<double>::complex(const complex<float>& __z)

   615   : _M_re(__z._M_re), _M_im(__z._M_im) {}

   616 #  ifndef _STLP_NO_LONG_DOUBLE

   617 inline complex<float>::complex(const complex<long double>& __z)

   618   : _M_re((float)__z._M_re), _M_im((float)__z._M_im) {}

   619 inline complex<double>::complex(const complex<long double>& __z)

   620   : _M_re((double)__z._M_re), _M_im((double)__z._M_im) {}

   621 inline complex<long double>::complex(const complex<float>& __z)

   622   : _M_re(__z._M_re), _M_im(__z._M_im) {}

   623 inline complex<long double>::complex(const complex<double>& __z)

   624   : _M_re(__z._M_re), _M_im(__z._M_im) {}

   625 #  endif

   627 #endif /* SPECIALIZATIONS */

   629 // Unary non-member arithmetic operators.

   631 template <class _Tp>

   632 inline complex<_Tp> _STLP_CALL operator+(const complex<_Tp>& __z)

   633 { return __z; }

   635 template <class _Tp>

   636 inline complex<_Tp> _STLP_CALL  operator-(const complex<_Tp>& __z)

   637 { return complex<_Tp>(-__z._M_re, -__z._M_im); }

   639 // Non-member arithmetic operations involving one real argument.

   641 template <class _Tp>

   642 inline complex<_Tp> _STLP_CALL operator+(const _Tp& __x, const complex<_Tp>& __z)

   643 { return complex<_Tp>(__x + __z._M_re, __z._M_im); }

   645 template <class _Tp>

   646 inline complex<_Tp> _STLP_CALL operator+(const complex<_Tp>& __z, const _Tp& __x)

   647 { return complex<_Tp>(__z._M_re + __x, __z._M_im); }

   649 template <class _Tp>

   650 inline complex<_Tp> _STLP_CALL operator-(const _Tp& __x, const complex<_Tp>& __z)

   651 { return complex<_Tp>(__x - __z._M_re, -__z._M_im); }

   653 template <class _Tp>

   654 inline complex<_Tp> _STLP_CALL operator-(const complex<_Tp>& __z, const _Tp& __x)

   655 { return complex<_Tp>(__z._M_re - __x, __z._M_im); }

   657 template <class _Tp>

   658 inline complex<_Tp> _STLP_CALL operator*(const _Tp& __x, const complex<_Tp>& __z)

   659 { return complex<_Tp>(__x * __z._M_re, __x * __z._M_im); }

   661 template <class _Tp>

   662 inline complex<_Tp> _STLP_CALL operator*(const complex<_Tp>& __z, const _Tp& __x)

   663 { return complex<_Tp>(__z._M_re * __x, __z._M_im * __x); }

   665 template <class _Tp>

   666 inline complex<_Tp> _STLP_CALL operator/(const _Tp& __x, const complex<_Tp>& __z) {

   667   complex<_Tp> __result;

   668   complex<_Tp>::_div(__x,

   669                      __z._M_re, __z._M_im,

   670                      __result._M_re, __result._M_im);

   671   return __result;

   672 }

   674 template <class _Tp>

   675 inline complex<_Tp> _STLP_CALL operator/(const complex<_Tp>& __z, const _Tp& __x)

   676 { return complex<_Tp>(__z._M_re / __x, __z._M_im / __x); }

   678 // Non-member arithmetic operations involving two complex arguments

   680 template <class _Tp>

   681 inline complex<_Tp> _STLP_CALL

   682 operator+(const complex<_Tp>& __z1, const complex<_Tp>& __z2)

   683 { return complex<_Tp>(__z1._M_re + __z2._M_re, __z1._M_im + __z2._M_im); }

   685 template <class _Tp>

   686 inline complex<_Tp> _STLP_CALL

   687 operator-(const complex<_Tp>& __z1, const complex<_Tp>& __z2)

   688 { return complex<_Tp>(__z1._M_re - __z2._M_re, __z1._M_im - __z2._M_im); }

   690 template <class _Tp>

   691 inline complex<_Tp> _STLP_CALL

   692 operator*(const complex<_Tp>& __z1, const complex<_Tp>& __z2) {

   693   return complex<_Tp>(__z1._M_re * __z2._M_re - __z1._M_im * __z2._M_im,

   694                       __z1._M_re * __z2._M_im + __z1._M_im * __z2._M_re);

   695 }

   697 template <class _Tp>

   698 inline complex<_Tp> _STLP_CALL

   699 operator/(const complex<_Tp>& __z1, const complex<_Tp>& __z2) {

   700   complex<_Tp> __result;

   701   complex<_Tp>::_div(__z1._M_re, __z1._M_im,

   702                      __z2._M_re, __z2._M_im,

   703                      __result._M_re, __result._M_im);

   704   return __result;

   705 }

   707 // Comparison operators.

   709 template <class _Tp>

   710 inline bool _STLP_CALL operator==(const complex<_Tp>& __z1, const complex<_Tp>& __z2)

   711 { return __z1._M_re == __z2._M_re && __z1._M_im == __z2._M_im; }

   713 template <class _Tp>

   714 inline bool _STLP_CALL operator==(const complex<_Tp>& __z, const _Tp& __x)

   715 { return __z._M_re == __x && __z._M_im == 0; }

   717 template <class _Tp>

   718 inline bool _STLP_CALL operator==(const _Tp& __x, const complex<_Tp>& __z)

   719 { return __x == __z._M_re && 0 == __z._M_im; }

   721 //04/27/04 dums: removal of this check, if it is restablish

   722 //please explain why the other operators are not macro guarded

   723 //#ifdef _STLP_FUNCTION_TMPL_PARTIAL_ORDER

   725 template <class _Tp>

   726 inline bool _STLP_CALL operator!=(const complex<_Tp>& __z1, const complex<_Tp>& __z2)

   727 { return __z1._M_re != __z2._M_re || __z1._M_im != __z2._M_im; }

   729 //#endif /* _STLP_FUNCTION_TMPL_PARTIAL_ORDER */

   731 template <class _Tp>

   732 inline bool _STLP_CALL operator!=(const complex<_Tp>& __z, const _Tp& __x)

   733 { return __z._M_re != __x || __z._M_im != 0; }

   735 template <class _Tp>

   736 inline bool _STLP_CALL operator!=(const _Tp& __x, const complex<_Tp>& __z)

   737 { return __x != __z._M_re || 0 != __z._M_im; }

   739 // Other basic arithmetic operations

   740 template <class _Tp>

   741 inline _Tp _STLP_CALL real(const complex<_Tp>& __z)

   742 { return __z._M_re; }

   744 template <class _Tp>

   745 inline _Tp _STLP_CALL imag(const complex<_Tp>& __z)

   746 { return __z._M_im; }

   748 template <class _Tp>

   749 _Tp _STLP_CALL abs(const complex<_Tp>& __z);

   751 template <class _Tp>

   752 _Tp _STLP_CALL arg(const complex<_Tp>& __z);

   754 template <class _Tp>

   755 inline _Tp _STLP_CALL norm(const complex<_Tp>& __z)

   756 { return __z._M_re * __z._M_re + __z._M_im * __z._M_im; }

   758 template <class _Tp>

   759 inline complex<_Tp> _STLP_CALL conj(const complex<_Tp>& __z)

   760 { return complex<_Tp>(__z._M_re, -__z._M_im); }

   762 template <class _Tp>

   763 complex<_Tp> _STLP_CALL polar(const _Tp& __rho)

   764 { return complex<_Tp>(__rho, 0); }

   766 template <class _Tp>

   767 complex<_Tp> _STLP_CALL polar(const _Tp& __rho, const _Tp& __phi);

   769 _STLP_TEMPLATE_NULL

   770 _STLP_DECLSPEC float _STLP_CALL abs(const complex<float>&);

   771 _STLP_TEMPLATE_NULL

   772 _STLP_DECLSPEC double _STLP_CALL abs(const complex<double>&);

   773 _STLP_TEMPLATE_NULL

   774 _STLP_DECLSPEC float _STLP_CALL arg(const complex<float>&);

   775 _STLP_TEMPLATE_NULL

   776 _STLP_DECLSPEC double _STLP_CALL arg(const complex<double>&);

   777 _STLP_TEMPLATE_NULL

   778 _STLP_DECLSPEC complex<float> _STLP_CALL polar(const float& __rho, const float& __phi);

   779 _STLP_TEMPLATE_NULL

   780 _STLP_DECLSPEC complex<double> _STLP_CALL polar(const double& __rho, const double& __phi);

   782 template <class _Tp>

   783 _Tp _STLP_CALL abs(const complex<_Tp>& __z)

   784 { return _Tp(abs(complex<double>(double(__z.real()), double(__z.imag())))); }

   786 template <class _Tp>

   787 _Tp _STLP_CALL arg(const complex<_Tp>& __z)

   788 { return _Tp(arg(complex<double>(double(__z.real()), double(__z.imag())))); }

   790 template <class _Tp>

   791 complex<_Tp> _STLP_CALL polar(const _Tp& __rho, const _Tp& __phi) {

   792   complex<double> __tmp = polar(double(__rho), double(__phi));

   793   return complex<_Tp>(_Tp(__tmp.real()), _Tp(__tmp.imag()));

   794 }

   796 #if !defined (_STLP_NO_LONG_DOUBLE)

   797 _STLP_TEMPLATE_NULL

   798 _STLP_DECLSPEC long double _STLP_CALL arg(const complex<long double>&);

   799 _STLP_TEMPLATE_NULL

   800 _STLP_DECLSPEC long double _STLP_CALL abs(const complex<long double>&);

   801 _STLP_TEMPLATE_NULL

   802 _STLP_DECLSPEC complex<long double> _STLP_CALL polar(const long double&, const long double&);

   803 #endif

   806 #if !defined (_STLP_USE_NO_IOSTREAMS)

   808 _STLP_END_NAMESPACE

   810 #  include <iosfwd>

   812 _STLP_BEGIN_NAMESPACE

   814 // Complex output, in the form (re,im).  We use a two-step process

   815 // involving stringstream so that we get the padding right.

   816 template <class _Tp, class _CharT, class _Traits>

   817 basic_ostream<_CharT, _Traits>&  _STLP_CALL

   818 operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __z);

   820 template <class _Tp, class _CharT, class _Traits>

   821 basic_istream<_CharT, _Traits>& _STLP_CALL

   822 operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __z);

   824 // Specializations for narrow characters; lets us avoid widen.

   826 _STLP_OPERATOR_TEMPLATE

   827 _STLP_DECLSPEC basic_istream<char, char_traits<char> >& _STLP_CALL

   828 operator>>(basic_istream<char, char_traits<char> >& __is, complex<float>& __z);

   830 _STLP_OPERATOR_TEMPLATE

   831 _STLP_DECLSPEC basic_istream<char, char_traits<char> >& _STLP_CALL

   832 operator>>(basic_istream<char, char_traits<char> >& __is, complex<double>& __z);

   834 _STLP_OPERATOR_TEMPLATE

   835 _STLP_DECLSPEC basic_ostream<char, char_traits<char> >& _STLP_CALL

   836 operator<<(basic_ostream<char, char_traits<char> >& __is, const complex<float>& __z);

   838 _STLP_OPERATOR_TEMPLATE

   839 _STLP_DECLSPEC basic_ostream<char, char_traits<char> >& _STLP_CALL

   840 operator<<(basic_ostream<char, char_traits<char> >& __is, const complex<double>& __z);

   842 #  if !defined (_STLP_NO_LONG_DOUBLE)

   843 _STLP_OPERATOR_TEMPLATE

   844 _STLP_DECLSPEC basic_istream<char, char_traits<char> >& _STLP_CALL

   845 operator>>(basic_istream<char, char_traits<char> >& __is, complex<long double>& __z);

   847 _STLP_OPERATOR_TEMPLATE

   848 _STLP_DECLSPEC basic_ostream<char, char_traits<char> >& _STLP_CALL

   849 operator<<(basic_ostream<char, char_traits<char> >& __is, const complex<long double>& __z);

   851 #  endif

   853 #  if defined (_STLP_USE_TEMPLATE_EXPORT) && ! defined (_STLP_NO_WCHAR_T)

   855 _STLP_EXPORT_TEMPLATE basic_istream<wchar_t, char_traits<wchar_t> >& _STLP_CALL

   856 operator>>(basic_istream<wchar_t, char_traits<wchar_t> >&, complex<double>&);

   857 _STLP_EXPORT_TEMPLATE basic_ostream<wchar_t, char_traits<wchar_t> >& _STLP_CALL

   858 operator<<(basic_ostream<wchar_t, char_traits<wchar_t> >&, const complex<double>&);

   859 _STLP_EXPORT_TEMPLATE basic_istream<wchar_t, char_traits<wchar_t> >& _STLP_CALL

   860 operator>>(basic_istream<wchar_t, char_traits<wchar_t> >&, complex<float>&);

   861 _STLP_EXPORT_TEMPLATE basic_ostream<wchar_t, char_traits<wchar_t> >& _STLP_CALL

   862 operator<<(basic_ostream<wchar_t, char_traits<wchar_t> >&, const complex<float>&);

   864 #    if !defined (_STLP_NO_LONG_DOUBLE)

   865 _STLP_EXPORT_TEMPLATE basic_istream<wchar_t, char_traits<wchar_t> >& _STLP_CALL

   866 operator>>(basic_istream<wchar_t, char_traits<wchar_t> >&, complex<long double>&);

   867 _STLP_EXPORT_TEMPLATE basic_ostream<wchar_t, char_traits<wchar_t> >& _STLP_CALL

   868 operator<<(basic_ostream<wchar_t, char_traits<wchar_t> >&, const complex<long double>&);

   869 #    endif

   870 #  endif

   871 #endif

   874 // Transcendental functions.  These are defined only for float,

   875 //  double, and long double.  (Sqrt isn't transcendental, of course,

   876 //  but it's included in this section anyway.)

   878 _STLP_DECLSPEC complex<float> _STLP_CALL sqrt(const complex<float>&);

   880 _STLP_DECLSPEC complex<float> _STLP_CALL exp(const complex<float>&);

   881 _STLP_DECLSPEC complex<float> _STLP_CALL  log(const complex<float>&);

   882 _STLP_DECLSPEC complex<float> _STLP_CALL log10(const complex<float>&);

   884 _STLP_DECLSPEC complex<float> _STLP_CALL pow(const complex<float>&, int);

   885 _STLP_DECLSPEC complex<float> _STLP_CALL pow(const complex<float>&, const float&);

   886 _STLP_DECLSPEC complex<float> _STLP_CALL pow(const float&, const complex<float>&);

   887 _STLP_DECLSPEC complex<float> _STLP_CALL pow(const complex<float>&, const complex<float>&);

   889 _STLP_DECLSPEC complex<float> _STLP_CALL sin(const complex<float>&);

   890 _STLP_DECLSPEC complex<float> _STLP_CALL cos(const complex<float>&);

   891 _STLP_DECLSPEC complex<float> _STLP_CALL tan(const complex<float>&);

   893 _STLP_DECLSPEC complex<float> _STLP_CALL sinh(const complex<float>&);

   894 _STLP_DECLSPEC complex<float> _STLP_CALL cosh(const complex<float>&);

   895 _STLP_DECLSPEC complex<float> _STLP_CALL tanh(const complex<float>&);

   897 _STLP_DECLSPEC complex<double> _STLP_CALL sqrt(const complex<double>&);

   899 _STLP_DECLSPEC complex<double> _STLP_CALL exp(const complex<double>&);

   900 _STLP_DECLSPEC complex<double> _STLP_CALL log(const complex<double>&);

   901 _STLP_DECLSPEC complex<double> _STLP_CALL log10(const complex<double>&);

   903 _STLP_DECLSPEC complex<double> _STLP_CALL pow(const complex<double>&, int);

   904 _STLP_DECLSPEC complex<double> _STLP_CALL pow(const complex<double>&, const double&);

   905 _STLP_DECLSPEC complex<double> _STLP_CALL pow(const double&, const complex<double>&);

   906 _STLP_DECLSPEC complex<double> _STLP_CALL pow(const complex<double>&, const complex<double>&);

   908 _STLP_DECLSPEC complex<double> _STLP_CALL sin(const complex<double>&);

   909 _STLP_DECLSPEC complex<double> _STLP_CALL cos(const complex<double>&);

   910 _STLP_DECLSPEC complex<double> _STLP_CALL tan(const complex<double>&);

   912 _STLP_DECLSPEC complex<double> _STLP_CALL sinh(const complex<double>&);

   913 _STLP_DECLSPEC complex<double> _STLP_CALL cosh(const complex<double>&);

   914 _STLP_DECLSPEC complex<double> _STLP_CALL tanh(const complex<double>&);

   916 #if !defined (_STLP_NO_LONG_DOUBLE)

   917 _STLP_DECLSPEC complex<long double> _STLP_CALL sqrt(const complex<long double>&);

   918 _STLP_DECLSPEC complex<long double> _STLP_CALL exp(const complex<long double>&);

   919 _STLP_DECLSPEC complex<long double> _STLP_CALL log(const complex<long double>&);

   920 _STLP_DECLSPEC complex<long double> _STLP_CALL log10(const complex<long double>&);

   922 _STLP_DECLSPEC complex<long double> _STLP_CALL pow(const complex<long double>&, int);

   923 _STLP_DECLSPEC complex<long double> _STLP_CALL pow(const complex<long double>&, const long double&);

   924 _STLP_DECLSPEC complex<long double> _STLP_CALL pow(const long double&, const complex<long double>&);

   925 _STLP_DECLSPEC complex<long double> _STLP_CALL pow(const complex<long double>&,

   926                                                    const complex<long double>&);

   928 _STLP_DECLSPEC complex<long double> _STLP_CALL sin(const complex<long double>&);

   929 _STLP_DECLSPEC complex<long double> _STLP_CALL cos(const complex<long double>&);

   930 _STLP_DECLSPEC complex<long double> _STLP_CALL tan(const complex<long double>&);

   932 _STLP_DECLSPEC complex<long double> _STLP_CALL sinh(const complex<long double>&);

   933 _STLP_DECLSPEC complex<long double> _STLP_CALL cosh(const complex<long double>&);

   934 _STLP_DECLSPEC complex<long double> _STLP_CALL tanh(const complex<long double>&);

   935 #endif

   937 _STLP_END_NAMESPACE

   939 #ifndef _STLP_LINK_TIME_INSTANTIATION

   940 #  include <stl/_complex.c>

   941 #endif

   943 #endif

   945 // Local Variables:

   946 // mode:C++

   947 // End:

author	William Roberts <williamr@symbian.org>
	Wed, 31 Mar 2010 12:33:34 +0100
branch	Symbian3
changeset 4	837f303aceeb
permissions	-rw-r--r--