std_complex.h (complex<_Tp>): Properly indent to follow C++STYLE.

	* include/std/std_complex.h (complex<_Tp>): Properly indent
	to follow C++STYLE.
	(complex<>::__rep): New.
	(__complex_abs): New.  Dispatch to built-ins.
	(abs): Use them.
	(__complex_arg): New. Dispatch to built-ins.
	(arg): Use it.
	(__complex_cos): New. Dispatch to built-ins.
	(cos): Use it.
	(__complex_cosh): New. Dispatch to built-ins.
	(cosh): Use it.
	(__complex_exp): New. Dispatch to built-ins.
	(exp): Use it.
	(__complex_log): New. Dispatch to built-ins.
	(log): Use it.
	(__complex_sin): New. Dispatch to built-ins.
	(sin): Use it.
	(__complex_sinh): New. Dispatch to built-ins.
	(sinh): Use it.
	(__complex_sqrt): New. Dispatch to built-ins.
	(sqrt): Use it.
	(__complex_tan): New. Dispatch to built-ins.
	(tan): Use it.
	(__complex_tanh): New. Dispatch to built-ins.
	(tanh): Use it.
	(__complex_pow): New. Dispatch to built-ins.
	(pow): Use it.

From-SVN: r82453

libstdc++-v3/ChangeLog

+2004-05-30  Gabriel Dos Reis  <gdr@integrable-solutions.net>
+
+	* include/std/std_complex.h (complex<_Tp>): Properly indent
+	to follow C++STYLE. 
+	(complex<>::__rep): New.
+	(__complex_abs): New.  Dispatch to built-ins.
+	(abs): Use them.
+	(__complex_arg): New. Dispatch to built-ins.
+	(arg): Use it.
+	(__complex_cos): New. Dispatch to built-ins.
+	(cos): Use it.
+	(__complex_cosh): New. Dispatch to built-ins.
+	(cosh): Use it.
+	(__complex_exp): New. Dispatch to built-ins.
+	(exp): Use it.
+	(__complex_log): New. Dispatch to built-ins.
+	(log): Use it.
+	(__complex_sin): New. Dispatch to built-ins.
+	(sin): Use it.
+	(__complex_sinh): New. Dispatch to built-ins.
+	(sinh): Use it.
+	(__complex_sqrt): New. Dispatch to built-ins.
+	(sqrt): Use it.
+	(__complex_tan): New. Dispatch to built-ins.
+	(tan): Use it.
+	(__complex_tanh): New. Dispatch to built-ins.
+	(tanh): Use it.
+	(__complex_pow): New. Dispatch to built-ins.
+	(pow): Use it.
+
 2004-05-29  Richard B. Kreckel  <Richard.Kreckel@Framatome-ANP.com>
             Benjamin Kosnik  <bkoz@redhat.com>
 	

libstdc++-v3/include/std/std_complex.h

@@ -113,9 +113,8 @@ namespace std
    *  @param  Tp  Type of real and imaginary values.
   */
   template<typename _Tp>
-    class complex
+    struct complex
     {
-    public:
       /// Value typedef.
       typedef _Tp value_type;
       
@@ -168,6 +167,8 @@ namespace std
       template<typename _Up>
         complex<_Tp>& operator/=(const complex<_Up>&);
 
+      const complex& __rep() const;
+
     private:
       _Tp _M_real;
       _Tp _M_imag;
@@ -306,6 +307,10 @@ namespace std
       return *this;
     }
 
+  template<typename _Tp>
+    inline const complex<_Tp>&
+    complex<_Tp>::__rep() const { return *this; }
+    
   // Operators:
   //@{
   ///  Return new complex value @a x plus @a y.
@@ -542,9 +547,10 @@ namespace std
     imag(const complex<_Tp>& __z)
     { return __z.imag(); }
 
+  // 26.2.7/3 abs(__z):  Returns the magnitude of __z.
   template<typename _Tp>
     inline _Tp
-    abs(const complex<_Tp>& __z)
+    __complex_abs(const complex<_Tp>& __z)
     {
       _Tp __x = __z.real();
       _Tp __y = __z.imag();
@@ -556,10 +562,44 @@ namespace std
           return __s * sqrt(__x * __x + __y * __y);
     }
 
+  inline float
+  __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }
+
+  inline double
+  __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }
+
+  inline long double
+  __complex_abs(const __complex__ long double& __z)
+  {
+    return __builtin_cabsl(__z);
+  }
+  
+  template<typename _Tp>
+    inline _Tp
+    abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
+
+
+  // 26.2.7/4: arg(__z): Returns the phase angle of __z.
+  template<typename _Tp>
+    inline _Tp
+    __complex_arg(const complex<_Tp>& __z)
+    {
+      return  atan2(__z.imag(), __z.real()); 
+    }
+
+  inline float
+  __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }
+
+  inline double
+  __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }
+
+  inline long double
+  __complex_arg(const __complex__ long double& __z)
+  { return __builtin_cargl(__z); }
+
   template<typename _Tp>
     inline _Tp
-    arg(const complex<_Tp>& __z)
-    { return atan2(__z.imag(), __z.real()); }
+    arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
 
   // 26.2.7/5: norm(__z) returns the squared magintude of __z.
   //     As defined, norm() is -not- a norm is the common mathematical
@@ -607,60 +647,155 @@ namespace std
     { return complex<_Tp>(__z.real(), -__z.imag()); }
   
   // Transcendentals
+
+  // 26.2.8/1 cos(__z):  Returns the cosine of __z.
   template<typename _Tp>
     inline complex<_Tp>
-    cos(const complex<_Tp>& __z)
+    __complex_cos(const complex<_Tp>& __z)
     {
       const _Tp __x = __z.real();
       const _Tp __y = __z.imag();
       return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
     }
 
+  inline __complex__ float
+  __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }
+
+  inline __complex__ double
+  __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }
+
+  inline __complex__ long double
+  __complex_cos(const __complex__ long double& __z)
+  { return __builtin_ccosl(__z); }
+  
+  template<typename _Tp>
+    inline complex<_Tp>
+    cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }
+
+  // 26.2.8/2 cosh(__z): Returns the hyperbolic cosine of __z.
   template<typename _Tp>
     inline complex<_Tp>
-    cosh(const complex<_Tp>& __z)
+    __complex_cosh(const complex<_Tp>& __z)
       {
         const _Tp __x = __z.real();
         const _Tp __y = __z.imag();
         return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
       }
 
+  inline __complex__ float
+  __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }
+
+  inline __complex__ double
+  __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }
+
+  inline __complex__ long double
+  __complex_cosh(const __complex__ long double& __z)
+  { return __builtin_ccoshl(__z); }
+
   template<typename _Tp>
     inline complex<_Tp>
-    exp(const complex<_Tp>& __z)
+    cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }
+
+  // 26.2.8/3 exp(__z): Returns the complex base e exponential of x
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_exp(const complex<_Tp>& __z)
     { return std::polar(exp(__z.real()), __z.imag()); }
 
+  inline __complex__ float
+  __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }
+
+  inline __complex__ double
+  __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }
+
+  inline __complex__ long double
+    __complex_exp(const __complex__ long double& __z)
+    { return __builtin_cexpl(__z); }
+  
   template<typename _Tp>
     inline complex<_Tp>
-    log(const complex<_Tp>& __z)
+    exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
+
+  // 26.2.8/5 log(__z): Reurns the natural complex logaritm of __z.
+  //                    The branch cut is along the negative axis.
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_log(const complex<_Tp>& __z)
     { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
 
+  /*
+  inline __complex__ float
+  __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }
+
+  inline __complex__ double
+  __complex_log(__complex__ double __z) { return __builtin_clog(__z); }
+
+  inline __complex__ long double
+  __complex_log(const __complex__ long double& __z)
+  { return __builtin_clog(__z); } */
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }
+
   template<typename _Tp>
     inline complex<_Tp>
     log10(const complex<_Tp>& __z)
     { return std::log(__z) / log(_Tp(10.0)); }
 
+  // 26.2.8/10 sin(__z): Returns the sine of __z.
   template<typename _Tp>
     inline complex<_Tp>
-    sin(const complex<_Tp>& __z)
+    __complex_sin(const complex<_Tp>& __z)
     {
       const _Tp __x = __z.real();
       const _Tp __y = __z.imag();
       return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y)); 
     }
 
+  inline __complex__ float
+  __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }
+
+  inline __complex__ double
+  __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }
+
+  inline __complex__ long double
+  __complex_sin(const __complex__ long double& __z)
+  { return __builtin_csinl(__z); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    sin(const complex<_Tp>& __z) { __complex_sin(__z.__rep()); }
+
+  // 26.2.8/11 sinh(__z): Returns the hyperbolic sine of __z.
   template<typename _Tp>
     inline complex<_Tp>
-    sinh(const complex<_Tp>& __z)
+    __complex_sinh(const complex<_Tp>& __z)
     {
       const _Tp __x = __z.real();
       const _Tp  __y = __z.imag();
       return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
     }
 
+  inline __complex__ float
+  __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }      
+
+  inline __complex__ double
+  __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }      
+
+  inline __complex__ long double
+  __complex_sinh(const __complex__ long double& __z)
+  { return __builtin_csinhl(__z); }      
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
+
+  // 26.2.8/13 sqrt(__z): Returns the complex square root of __z.
+  //                     The branch cut is on the negative axis.
   template<typename _Tp>
     complex<_Tp>
-    sqrt(const complex<_Tp>& __z)
+    __complex_sqrt(const complex<_Tp>& __z)
     {
       _Tp __x = __z.real();
       _Tp __y = __z.imag();
@@ -680,20 +815,65 @@ namespace std
         }
     }
 
+  inline __complex__ float
+  __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }
+
+  inline __complex__ double
+  __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }
+
+  inline __complex__ long double
+  __complex_sqrt(const __complex__ long double& __z)
+  { return __builtin_csqrtl(__z); }
+
   template<typename _Tp>
     inline complex<_Tp>
-    tan(const complex<_Tp>& __z)
-    {
-      return std::sin(__z) / std::cos(__z);
-    }
+    sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
+
+  // 26.2.8/14 tan(__z):  Return the complex tangent of __z.
   
   template<typename _Tp>
     inline complex<_Tp>
-    tanh(const complex<_Tp>& __z)
-    {
-      return std::sinh(__z) / std::cosh(__z);
-    }
+    __complex_tan(const complex<_Tp>& __z)
+    { return std::sin(__z) / std::cos(__z); }
+
+  inline __complex__ float
+  __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }
+
+  inline __complex__ double
+  __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }
+
+  inline __complex__ long double
+  __complex_tan(const __complex__ long double& __z)
+  { return __builtin_ctanl(__z); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
+
+  // 26.2.8/15 tanh(__z):  Returns the hyperbolic tangent of __z.
+  
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_tanh(const complex<_Tp>& __z)
+    { return std::sinh(__z) / std::cosh(__z); }
 
+  inline __complex__ float
+  __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }
+
+  inline __complex__ double
+  __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }
+
+  inline __complex__ long double
+  __complex_tanh(const __complex__ long double& __z)
+  { return __builtin_ctanhl(__z); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
+
+  // 26.2.8/9  pow(__x, __y): Returns the complex power base of __x
+  //                          raised to the __y-th power.  The branch
+  //                          cut is on the negative axis.
   template<typename _Tp>
     inline complex<_Tp>
     pow(const complex<_Tp>& __z, int __n)
@@ -714,10 +894,25 @@ namespace std
 
   template<typename _Tp>
     inline complex<_Tp>
+    __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
+
+  inline __complex__ float
+  __complex_pow(__complex__ float __x, __complex__ float __y)
+  { return __builtin_cpowf(__x, __y); }
+
+  inline __complex__ double
+  __complex_pow(__complex__ double __x, __complex__ double __y)
+  { return __builtin_cpow(__x, __y); }
+
+  inline __complex__ long double
+  __complex_pow(__complex__ long double& __x, __complex__ long double& __y)
+  { return __builtin_cpowl(__x, __y); }
+  
+  template<typename _Tp>
+    inline complex<_Tp>
     pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
-    {
-      return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x));
-    }
+    { return __complex_pow(__x, __y); }
 
   template<typename _Tp>
     inline complex<_Tp>
@@ -730,10 +925,13 @@ namespace std
 
   // 26.2.3  complex specializations
   // complex<float> specialization
-  template<> class complex<float>
+  template<>
+    struct complex<float>
     {
-  public:
       typedef float value_type;
+      typedef __complex__ float _ComplexT;
+
+      complex(_ComplexT __z) : _M_value(__z) { }
 
       complex(float = 0.0f, float = 0.0f);
 #ifdef _GLIBCXX_BUGGY_COMPLEX
@@ -767,14 +965,10 @@ namespace std
       template<class _Tp>
         complex<float>&operator/=(const complex<_Tp>&);
 
+      const _ComplexT& __rep() const { return _M_value; }
+
     private:
-    typedef __complex__ float _ComplexT;
       _ComplexT _M_value;
-
-    complex(_ComplexT __z) : _M_value(__z) { }
-        
-    friend class complex<double>;
-    friend class complex<long double>;
     };
 
   inline float&
@@ -887,12 +1081,15 @@ namespace std
 
   // 26.2.3  complex specializations
   // complex<double> specialization
-  template<> class complex<double>
+  template<>
+    struct complex<double>
     {
-  public:
       typedef double value_type;
+      typedef __complex__ double _ComplexT;
+
+      complex(_ComplexT __z) : _M_value(__z) { }
 
-    complex(double  =0.0, double =0.0);
+      complex(double  = 0.0, double = 0.0);
 #ifdef _GLIBCXX_BUGGY_COMPLEX
       complex(const complex& __z) : _M_value(__z._M_value) { }
 #endif
@@ -923,14 +1120,10 @@ namespace std
       template<typename _Tp>
         complex<double>& operator/=(const complex<_Tp>&);
 
+      const _ComplexT& __rep() const { return _M_value; }
+
     private:
-    typedef __complex__ double _ComplexT;
       _ComplexT _M_value;
-
-    complex(_ComplexT __z) : _M_value(__z) { }
-        
-    friend class complex<float>;
-    friend class complex<long double>;
     };
 
   inline double&
@@ -1043,10 +1236,13 @@ namespace std
 
   // 26.2.3  complex specializations
   // complex<long double> specialization
-  template<> class complex<long double>
+  template<>
+    struct complex<long double>
     {
-  public:
       typedef long double value_type;
+      typedef __complex__ long double _ComplexT;
+
+      complex(_ComplexT __z) : _M_value(__z) { }
 
       complex(long double = 0.0L, long double = 0.0L);
 #ifdef _GLIBCXX_BUGGY_COMPLEX
@@ -1079,14 +1275,10 @@ namespace std
       template<typename _Tp>
         complex<long double>& operator/=(const complex<_Tp>&);
 
+      const _ComplexT& __rep() const { return _M_value; }
+
     private:
-    typedef __complex__ long double _ComplexT;
       _ComplexT _M_value;
-
-    complex(_ComplexT __z) : _M_value(__z) { }
-
-    friend class complex<float>;
-    friend class complex<double>;
     };
 
   inline
@@ -1203,30 +1395,27 @@ namespace std
   // inlining.  It suffices that class specializations be defined.
   inline
   complex<float>::complex(const complex<double>& __z)
-  : _M_value(_ComplexT(__z._M_value)) { }
+  : _M_value(__z.__rep()) { }
 
   inline
   complex<float>::complex(const complex<long double>& __z)
-  : _M_value(_ComplexT(__z._M_value)) { }
+  : _M_value(__z.__rep()) { }
 
   inline
   complex<double>::complex(const complex<float>& __z) 
-  : _M_value(_ComplexT(__z._M_value)) { }
+  : _M_value(__z.__rep()) { }
 
   inline
   complex<double>::complex(const complex<long double>& __z)
-  {
-    __real__ _M_value = __z.real();
-    __imag__ _M_value = __z.imag();
-  }
+    : _M_value(__z.__rep()) { }
 
   inline
   complex<long double>::complex(const complex<float>& __z)
-  : _M_value(_ComplexT(__z._M_value)) { }
+  : _M_value(__z.__rep()) { }
 
   inline
   complex<long double>::complex(const complex<double>& __z)
-  : _M_value(_ComplexT(__z._M_value)) { }
+  : _M_value(__z.__rep()) { }
 } // namespace std
 
 #endif	/* _GLIBCXX_COMPLEX */