cplx.h

Go to the documentation of this file.

//-------------------------------------------------------------
// by amb 24/06/97
// last modification 1997-06-24 amb
//                   1997-12-13 kg
// $Id: cplx.h,v 1.37.2.45 2022/11/03 17:28:10 garloff Exp $
//-------------------------------------------------------------


#ifndef TBCI_CPLX_H
#define TBCI_CPLX_H  

#include "tbci/basics.h"
#ifndef TBCI_CPLX_DONT_INCLUDE_CONSTANTS
# include "tbci/constants.h"
#endif

#ifdef PRAGMA_I
# pragma interface "cplx.h"
#endif


#if defined(__GNUC__) && defined (USE_BUILTIN_CPLX)
# include "tbci/builtin_cplx.h"
#endif

#ifndef CPLX
# define CPLX(t) cplx<t>
# define CPLXR(t,a,r) cplx<t> a (r)
# define CPLXRI(t,a,r,i) cplx<t> a (r,i)
# define CPLXC(t,a,c) cplx<t> a (c)
# define CPLXVRI(t,r,i) (cplx<t>(r,i))
#endif

#if !defined(NO_GD) && !defined(AUTO_DECL)
# include "tbci/cplx_gd.h"
#endif

//#include <cmath>

NAMESPACE_TBCI

// These are necessary to avoid -fguiding-decls

template <typename T> class cplx;

template <typename T>
class cplx 
{  
 protected:
#ifdef CPLX_NEED_PUBLIC
 public:
#endif   
  T re ALIGN(MIN_ALIGN), im;
  
 public:
  
  typedef T value_type;
  typedef T aligned_value_type TALIGN(MIN_ALIGN);
  typedef T cplx_base;
  typedef cplx<T> cplx_t;
  // constructors & destructors 

  cplx () {}
  cplx (const T r, const T i = (T)0) : re(r), im(i)  {}
  cplx (const cplx<T>& c) : re(c.re), im(c.im)  {}

#ifndef HAVE_PROMOTION_BUG
  // Promotion (only explicit)
# ifndef HAVE_GCC295_TMPLFRNDCLS_BUG
  template <typename U> friend class cplx;
  template <typename U> explicit cplx (const cplx<U>& c) : re(c.re), im(c.im) {}
# else
  template <typename U> explicit cplx (const cplx<U>& c) : re(c.real()), im(c.imag()) {}
# endif
#endif
  //cplx (const cplx<double>& c) : re(c.re), im(c.im) {}
  ~cplx () {}
  
  // assignment operators
  
  cplx<T>& operator = (const T r) { re = r; im = (T)0; return *this; }
  cplx<T>& operator = (const cplx<T>& c)
     { re = c.re; im = c.im; return *this; } 
   //{ CSTD__ memcpy &(this->re), &(c.re), 2 * sizeof (re)); return *this; }
     
  cplx<T>& operator += (const T);
  cplx<T>& operator += (const cplx<T>&);
  cplx<T>& operator -= (const T);
  cplx<T>& operator -= (const cplx<T>&);
  cplx<T>& operator *= (const T);
  cplx<T>& operator *= (const cplx<T>&);
  cplx<T>& operator /= (const T);
  cplx<T>& operator /= (const cplx<T>&);

  // member access
  cplx<T>& set (const T r, const T i) { re = r; im = i; return *this; }
  // ro
  T real () const { return re; }
  T imag () const { return im; }
  // rw
  T& real () { return re; }
  T& imag () { return im; }   

  // cast a cplx to a double: Don't allow silent info loss 
  //operator double () const  { return re; }
  
  // member access (read-only)
  
  // basic algebra & negation
  cplx<T> operator + (const cplx<T>&) const;
  cplx<T> operator - (const cplx<T>&) const;
  //note: first argument does not become conjugated !
  cplx<T> operator * (const cplx<T>&) const;
  //note: first argument becomes conjugated !
  friend cplx<T> /*FRIEND_TBCI2__*/ dot FGD (const cplx<T>&, const cplx<T>&);
  cplx<T> operator / (const cplx<T>&) const;
        
  //for friend cplx<T> operator + FGD (const T, const cplx<T>&);
  cplx<T> plus (const T v) const
          { return cplx<T> (v+re, im); }
  //for friend cplx<T> operator - FGD (const T, const cplx<T>&);
  cplx<T> minus (const T v) const
          { return cplx<T> (v-re, -im); }
  //for friend cplx<T> operator * FGD (const T, const cplx<T>&);
  cplx<T> mult (const T v) const
          { return cplx<T> (v*re, v*im); }
  //friend cplx<S> operator * (const T f, const cplx<S>& c);
  //for friend cplx<T> operator / FGD (const T, const cplx<T>&);
  cplx<T> div (const T a) const
  {
        REGISTER const T den ALIGN(MIN_ALIGN) = (T)1 / (re*re + im*im);
        return cplx<T> ( (a * re) * den, (- a * im) * den ); 
  }
                  
  cplx<T> operator + (const T) const;
  cplx<T> operator - (const T) const;
  cplx<T> operator * (const T) const;
  cplx<T> operator / (const T) const;
  cplx<T> operator - () const;
  cplx<T> operator ~ () const;
  
  // other functions
   
  T theta () const;
  // alias
  //friend T arg (const cplx<T>& c) { return c.theta(); }
  //friend cplx<T> /*FRIEND_TBCI2__*/ expi FGD (const T);
  //friend cplx<T> /*FRIEND_TBCI2__*/ sqr FGD (const cplx<T>&);
  
  cplx<T> conj () const  { return cplx<T> (re, -im); }
  //friend cplx<T> conj FGD (const cplx<T>&);

  //the variant that changes(!) the object 
  cplx<T>& do_conj ()  { im = -im; return *this; }

  double fabssqr () const  { return (double)(re*re + im*im); }
  double fabs () const;  //{ return MATH__ sqrt (re*re + im*im); }
  double norm () const  { return fabssqr(); }   // oops!
  T abs () const;        //{ return       sqrt (re*re + im*im); }

  cplx<T>  exp () const;
  cplx<T> sqrt () const;
        
  cplx<T> power (const double) const;
  cplx<T> power (const cplx<T>&) const;
  cplx<T> ln () const;

  cplx<T> sin () const; 
  cplx<T> cos () const; 
  cplx<T> sinh () const;        
  cplx<T> cosh () const;

  cplx<T> asin () const;
  cplx<T> acos () const;        
  cplx<T> atan () const;
  cplx<T> asinh () const;       
  cplx<T> acosh () const;       
  cplx<T> atanh () const;
  // comparison ops

  bool operator == (const cplx<T>& c) const { return (re == c.re && im == c.im); }
  bool operator != (const cplx<T>& c) const { return (re != c.re || im != c.im); }
  // mathematically undefined ... 
  bool operator >  (const cplx<T>& c) const { return fabssqr() >  c.fabssqr(); }
  bool operator >= (const cplx<T>& c) const { return fabssqr() >= c.fabssqr(); }
  bool operator <  (const cplx<T>& c) const { return fabssqr() <  c.fabssqr(); }
  bool operator <= (const cplx<T>& c) const { return fabssqr() <= c.fabssqr(); }
  

  // IO
  
  //template <typename T>
  friend  STD__ ostream& operator << FGD (STD__ ostream&, const cplx< T >&);
  //template <typename T>
  friend STD__  istream& operator >> FGD (STD__ istream&, cplx< T >&);
  
} ;


NAMESPACE_END
// Declare global functions acting on TBCI::cplx<T> numbers
NAMESPACE_CSTD
template <typename T>
inline TBCI__ cplx<T> sqrt (const TBCI__ cplx<T>& z);
NAMESPACE_CSTD_END

NAMESPACE_TBCI
        
template <typename T>
inline cplx<T>& cplx<T>::operator += (const T a)
{
  re += a; return *this;
}


template <typename T>
inline cplx<T>& cplx<T>::operator += (const cplx<T>& a)
{
  re += a.re; im += a.im; return *this;
}

template <typename T>
inline cplx<T>& cplx<T>::operator -= (const T a)
{
  re -= a; return *this;
}


template <typename T>
inline cplx<T>& cplx<T>::operator -= (const cplx<T>& a)
{
  re -= a.re; im -= a.im; return *this;
}


template <typename T>
inline cplx<T>& cplx<T>::operator *= (const T a)
{
  re *= a; im *= a; return *this;
}


template <typename T>
inline cplx<T>& cplx<T>::operator *= (const cplx<T>& a)
{
  REGISTER const T tmp ALIGN(MIN_ALIGN) = re;
  re = tmp*a.re - im*a.im;
  im = tmp*a.im + im*a.re;
  return *this;
}


template <typename T>
inline cplx<T>& cplx<T>::operator /= (const T a)
{
   re /= a; im /= a; return *this;
}

template <typename T>
inline cplx<T>& cplx<T>::operator /= (const cplx<T>& a)
{
  REGISTER const T tmp ALIGN(MIN_ALIGN) = re;
  REGISTER const T den ALIGN(MIN_ALIGN) = (a.re*a.re + a.im*a.im);
  
  re = (tmp*a.re + im*a.im) / den;
  im = (im*a.re - tmp*a.im) / den;
  return *this;
}


template <typename T>
inline cplx<T> cplx<T>::operator + (const cplx<T>& a) const
{
        return cplx<T> (re + a.re, im + a.im);
}


template <typename T>
inline cplx<T> cplx<T>::operator - (const cplx<T>& a) const
{
        return cplx<T> (re - a.re, im - a.im);
}


template <typename T>
inline cplx<T> cplx<T>::operator * (const cplx<T>& a) const
{
        return cplx<T>( re*a.re - im*a.im, im*a.re + re*a.im );
}

template <typename T>
inline cplx<T> dot (const cplx<T>& a, const cplx<T>& b)
{
   return cplx<T> (a.re*b.re + a.im*b.im, a.re*b.im - a.im*b.re);

}

template <typename T>
inline cplx<T> cplx<T>::operator / (const cplx<T>& a) const
{
        REGISTER const T den ALIGN(MIN_ALIGN) = (T)1 / (a.re*a.re + a.im*a.im);
        // T den ( (T)1 / (a.re*a.re + a.im*a.im) );
        return cplx<T>( ( re*a.re + im*a.im ) * den, ( im*a.re - re*a.im ) * den );
}


INST(template <typename T> class cplx friend cplx<T> operator + (const T, const cplx<T>&);)
template <typename T>
inline cplx<T> operator + (const T a, const cplx<T>& b)
{ return b.plus (a); }


INST(template <typename T> class cplx friend cplx<T> operator - (const T, const cplx<T>&);)
template <typename T>
inline cplx<T> operator - (const T a, const cplx<T>& b)
{ return b.minus (a); }


#if 0
template <typename T, typename U>
cplx<T> operator * (const U f, const cplx<T>& c)
{ return cplx<T> (f*c.real(), f*c.imag()); }
#endif


INST(template <typename T> class cplx friend cplx<T> operator * (const T, const cplx<T>&);)
template <typename T>
inline cplx<T> operator * (const T a, const cplx<T>& b)
{ return b.mult (a); }


INST(template <typename T> class cplx friend cplx<T> operator / (const T, const cplx<T>&);)
template <typename T>
inline cplx<T> operator / (const T a, const cplx<T>& b)
{ return b.div (a); }


template <typename T>
inline cplx<T> cplx<T>::operator + (const T b) const
{
  return cplx<T> (re + b, im);
}


template <typename T>
inline cplx<T> cplx<T>::operator - (const T b) const
{
  return cplx<T> (re - b, im);
}


template <typename T>
inline cplx<T> cplx<T>::operator * (const T b) const
{
  return cplx<T> (re * b, im * b);
}


template <typename T>
inline cplx<T> cplx<T>::operator / (const T b) const
{
  return cplx<T> (re / b, im / b);
}


template <typename T>
inline cplx<T> cplx<T>::operator - () const
{
  return cplx<T> (-re, -im);
}


template <typename T>
inline cplx<T> cplx<T>::operator ~ () const
{
  return cplx<T> (re, -im);
}


INST(template <typename T> class cplx friend double fabssqr (const cplx<T>&);)
template <typename T>
inline double fabssqr(const cplx<T>& c)
{ return c.fabssqr(); }


template <typename T>
inline double cplx<T>::fabs () const
{
        //  return sqrt (fabssqr (c));
        // numerically superior variant:
        if (UNLIKELY(im != 0)) {
                if (UNLIKELY(GLBL__ MATH__ fabs(im) > GLBL__ MATH__ fabs(re)))
                        return (GLBL__ MATH__ fabs(im) * GLBL__ MATH__ sqrt(1.0+(double)re*re/(im*im)) );
                else /*if (LIKELY(re != 0))*/
                        return (GLBL__ MATH__ fabs(re) * GLBL__ MATH__ sqrt(1.0+(double)im*im/(re*re)) );
                // else abort(); //Strange things going on!
        } else
                return (GLBL__ MATH__ fabs(re));
}


template <typename T>
inline T cplx<T>::abs () const
{
        //  return sqrt (fabssqr (c));
        // numerically superior
        if (UNLIKELY(im != 0)) {
                if (UNLIKELY(GLBL__ CSTD__ abs(im) > GLBL__ CSTD__ abs(re)))
                        return (GLBL__ CSTD__ abs(im) * GLBL__ MATH__ sqrt(1+re*re/(im*im)) );
                else /*if (LIKELY(re != 0))*/
                        return (GLBL__ CSTD__ abs(re) * GLBL__ MATH__ sqrt(1+im*im/(re*re)) );
                // else abort(); //Strange things going on!
        } else 
                return (GLBL__ CSTD__ abs(re));
}


template <typename T>
T cplx<T>::theta () const
{
        //const static double halfpi = 0.5*pi;
        if (UNLIKELY(re == 0)) {
                if (LIKELY(im > 0))
                        return  0.5*pi;
                else if (LIKELY(im < 0))
                        return -0.5*pi;
                else 
                        return 0;
        }
        
        //if (c.im >= 0) return atan2 (c.im, c.re); // no negative phases
        //else return 2*pi + atan2 (c.im, c.re);
        if (UNLIKELY(im == 0.0))
                return atan2 (0.0, re); // dirty workaround (JLT)
        else 
                return atan2 (im, re); // allow for negtive phases
}

INST(template <typename T> class TBCI__ cplx friend cplx<T> sqr (const cplx<T>&);)
template <typename T>
inline cplx<T> sqr (const cplx<T>& c)
{
        // return fabssqr (c) * expi ((T)2 * c.theta());
        REGISTER const T re(c.real()), im(c.imag());
        // FIXME: Shouldn't this work:
        // return cplx<T> (sqr(re) - sqr(im), 2*re*im);
        return cplx<T> (re*re - im*im, 2*re*im);
}

INST(template <typename T> class TBCI__ cplx friend cplx<T> expi (const T);)
template <typename T>
cplx<T> expi (const T phi)
{
        const REGISTER T tmp ALIGN(MIN_ALIGN) = MATH__ fmod (phi, 2*pi);
        return cplx<T> (MATH__ cos(tmp), MATH__ sin(tmp));
}

template <typename T>
cplx<T> cplx<T>::sqrt () const
{
        return GLBL__ MATH__ sqrt (fabs())  * TBCI__ expi ((double)(0.5) * theta());
}

template <typename T>
inline cplx<T> cplx<T>::exp () const
{
   return GLBL__ MATH__ exp ((double)(this->real()))  * TBCI__ expi(this->imag());
}

template <typename T>
inline cplx<T> cplx<T>::power (const double n) const
{ 
  return GLBL__ MATH__ pow (this->fabs(), n) * TBCI__ expi (n*this->theta());
}

template <typename T>
cplx<T> cplx<T>::power (const cplx<T>& z) const
{
        const double lnt = GLBL__ MATH__ log (fabs());
        const T phi = theta();
        return GLBL__ MATH__ exp (lnt*z.re - phi*z.im) * expi (phi*z.re + lnt*z.im);
}

template <typename T>
inline cplx<T> cplx<T>::ln () const
{ 
        return cplx<T>(GLBL__ MATH__ log (fabs()), theta());
}

template <typename T>
cplx<T> cplx<T>::sin () const
{ 
        const cplx<T> zi = cplx<T> (-im, re);
        return cplx<T>(0.0,-0.5) * (zi.exp() - (-zi).exp());
}

template <typename T>
cplx<T> cplx<T>::cos () const
{ 
        const cplx<T> zi = cplx<T> (-im, re);
        return 0.5 * (zi.exp() + (-zi).exp());
}

template <typename T>
cplx<T> cplx<T>::sinh () const
{ 
        return 0.5 * (exp() - (-(*this)).exp());
}

template <typename T>
cplx<T> cplx<T>::cosh () const
{ 
        return 0.5 * (exp() + (-(*this)).exp());
}

template <typename T>
cplx<T> cplx<T>::asin () const
{ 
        const cplx<T> arg = cplx<T>(-im, re) + GLBL__ MATH__ sqrt (1.0 - sqr(*this));
        return cplx<T>(0.0,-1.0) * arg.ln();
}

template <typename T>
cplx<T> cplx<T>::acos () const
{ 
        const cplx<T> arg = *this + GLBL__ MATH__ sqrt (sqr(*this) - 1.0);
        return cplx<T>(0.0,-1.0) * arg.ln();
}

template <typename T>
cplx<T> cplx<T>::asinh () const
{ 
        const cplx<T> arg = *this + GLBL__ MATH__ sqrt (sqr(*this) + 1.0);
        return arg.ln();
}

template <typename T>
cplx<T> cplx<T>::acosh () const
{ 
        const cplx<T> arg = *this + GLBL__ MATH__ sqrt (sqr(*this) - 1.0);
        return arg.ln();
}

template <typename T>
cplx<T> cplx<T>::atan () const
{ 
        const cplx<T> arg = (1.0 + cplx<T>(-im,re)) / ( 1.0 - cplx<T>(-im,re));
        return cplx<T>(0.0,-0.5) * arg.ln();
}

template <typename T>
cplx<T> cplx<T>::atanh () const
{ 
        const cplx<T> arg = (1.0 + *this) / (1.0 - *this);
        return 0.5 * arg.ln();
}


#ifdef TBCI_CPLX_OLD_IOFMT
template <typename T> STD__ ostream& operator << (STD__ ostream& os, const cplx<T>& c)
{
        os << "( " << c.re;
        if (c.im < 0) 
                os << " - i " << -c.im;
        else 
                os << " + i " << c.im;
        os << " )";
        return os;
}

/*
template <typename T>
STD__ ofstream& operator << (STD__ ofstream& os, const cplx<T>& c)
{
  os.operator<<(c.re);
  os << "  ";
  os.operator<<(c.im);
  return os;
}
*/

template <typename T>
STD__ istream& operator >> (STD__ istream& in, cplx<T>& c)
{
  T r, i;
  char s = '+', b = 'i', bra = '(';
  
  if (! (in >> bra))
    return in;
  if (bra != '(') in.putback(bra);
  if (! (in >> r))
    return in;
  in >> s;
  if ((s != '+') && (s != '-')) in.putback(s);
  in >> b;
  if ((b != 'i')) in.putback(b);
  if (! (in >> i))
    return in;
  c.re = r;
  if (s == '-') c.im =- i;
  else c.im = i;
  if (bra == '(') 
    {
      if (! (in >> bra))
        return in;
      if (bra != ')') in.putback(bra);
    }
  return in;
}

#else   /* TBCI_CPLX_OLD_IOFMT */

template <typename T> STD__ ostream& operator << (STD__ ostream& os, const cplx<T>& c)
{
  return os << "(" << c.re << "," << c.im << ")";
}

template <typename T>
STD__ istream& operator >> (STD__ istream& in, cplx<T>& c)
{
  T r ALIGN(MIN_ALIGN), i = (T)0;
  char bra;
  
  if (! (in >> bra))
        return in;
  if (bra != '(') { 
        in.putback(bra);
        if (in >> r) {
                c.re = r; c.im = (T)0;
        }
        return in;
  }
  if (!(in >> r))
        return in;
  in >> bra;
  c.re = r; c.im = (T)0;
  if (bra != ',')
        return in;
  if (! (in >> i))
        return in;
  c.im = i;
  in >> bra;
  if (bra != ')')
        /* error */;
  return in;
}

#endif  /* TBCI_CPLX_OLD_IOFMT */

NAMESPACE_END
NAMESPACE_CPLX

INST(template <typename T> class TBCI__ cplx friend TBCI__ cplx<T> conj (const TBCI__ cplx<T>&);)
template <typename T>
inline TBCI__ cplx<T> conj (const TBCI__ cplx<T>& c)
{ return c.conj(); }


// member access (read-only)
INST(template <typename T> class TBCI__ cplx friend T real (const TBCI__ cplx<T>&);)
INST(template <typename T> class TBCI__ cplx friend T imag (const TBCI__ cplx<T>&);)
template <typename T>
inline T real (const TBCI__ cplx<T>& z)
{ return z.real(); }
template <typename T>
inline T imag (const TBCI__ cplx<T>& z)
{ return z.imag(); }

// member access (read-write)
INST(template <typename T> class TBCI__ cplx friend T& real (TBCI__ cplx<T>&);)
INST(template <typename T> class TBCI__ cplx friend T& imag (TBCI__ cplx<T>&);)
template <typename T>
inline T& real (TBCI__ cplx<T>& z)
{ return z.real(); }
template <typename T>
inline T& imag (TBCI__ cplx<T>& z)
{ return z.imag(); }


INST(template <typename T> class TBCI__ cplx friend T arg (const TBCI__ cplx<T>&);)
template <typename T>
inline T arg (const TBCI__ cplx<T>& c) 
{ return c.theta(); }

INST(template <typename T> class TBCI__ cplx friend double norm (const TBCI__ cplx<T>&);)
template <typename T>
inline double norm (const TBCI__ cplx<T>& c)
{ return c.norm(); }

// Trouble is: polar() conflicts with the std decl

NAMESPACE_CPLX_END
NAMESPACE_TBCI

#ifndef NO_NS
INST(template <typename T> class TBCI__ cplx friend TBCI__ cplx<T> polar (const T&, const T&);)
template <typename T>
inline TBCI__ cplx<T> polar (const T& r, const T& p)
{ return r * TBCI__ expi (p); }
#else
INST(template <typename T> class TBCI__ cplx friend TBCI__ cplx<T> _polar (const T&, const T&);)
template <typename T>
inline TBCI__ cplx<T> _polar (const T& r, const T& p)
{ return r * TBCI__ expi (p); }
#endif

#if defined(__i386__) && defined(__GNUC__) && defined(USE_ASM) && defined(CPLX_ASM) && !defined(NO_DOUBLE_SPEC)
template <>
inline cplx<double> cplx<double>::operator * (const cplx<double>& a) const
{
        REGISTER double r, i;
        asm ("  fldl %3; fmull %5; fldl %2; fmull %4; fsubp %%st,%%st(1);  \n\
                fldl %2; fmull %5; fldl %3; fmull %4; faddp %%st,%%st(1);  \n"
             : "=u" (r), "=t" (i)
             : "g" (re), "g" (im), "m" (a.re), "m" (a.im)
             : "st(6)", "st(7)" );
        return cplx<double> (r, i);
}
#endif

#ifdef NEED_IMAG_UNIT
const cplx<double> Imag_unit (0.0, 1.0);
#endif

NAMESPACE_END


NAMESPACE_CSTD

// should abs be in CPLX__ rather than CSTD__ ?
INST(template <typename T> class TBCI__ cplx friend T abs (const TBCI__ cplx<T>&);)
template <typename T>
inline T abs (const TBCI__ cplx<T>& c)
{ return c.abs(); }

INST(template <typename T> class TBCI__ cplx friend double fabs (const TBCI__ cplx<T>&);)
template <typename T>
inline double fabs (const TBCI__ cplx<T>& c)
{ return c.fabs(); }

INST(template <typename T> class TBCI__ cplx friend TBCI__ cplx<T> sqrt (const TBCI__ cplx<T>&);)
template <typename T>
inline TBCI__ cplx<T> sqrt (const TBCI__ cplx<T>& z)
{ return z.sqrt(); }

INST(template <typename T> class TBCI__ cplx friend TBCI__ cplx<T>  exp (const TBCI__ cplx<T>&);)
template <typename T>
inline TBCI__ cplx<T>  exp (const TBCI__ cplx<T>& z)
{ return z.exp (); }

INST(template <typename T> class TBCI__ cplx friend TBCI__ cplx<T>  pow (const TBCI__ cplx<T>&, const double);)
template <typename T>
inline TBCI__ cplx<T>  pow (const TBCI__ cplx<T>& z, const double n)
{ return z.power (n); }

INST(template <typename T> class TBCI__ cplx friend TBCI__ cplx<T>  pow (const TBCI__ cplx<T>&, const TBCI__ cplx<T>&);)
template <typename T>
inline TBCI__ cplx<T>  pow (const TBCI__ cplx<T>& z, const TBCI__ cplx<T>& x)
{ return z.power (x); }

INST(template <typename T> class TBCI__ cplx friend TBCI__ cplx<T>  log (const TBCI__ cplx<T>&);)
template <typename T>
inline TBCI__ cplx<T>  log (const TBCI__ cplx<T>& z)
{ return z.ln(); }

INST(template <typename T> class TBCI__ cplx friend TBCI__ cplx<T>  sin (const TBCI__ cplx<T>&);)
template <typename T>
inline TBCI__ cplx<T>  sin (const TBCI__ cplx<T>& z)
{ return z.sin(); }

INST(template <typename T> class TBCI__ cplx friend TBCI__ cplx<T> sinh (const TBCI__ cplx<T>&);)
template <typename T>
inline TBCI__ cplx<T> sinh (const TBCI__ cplx<T>& z)
{ return z.sinh(); }

INST(template <typename T> class TBCI__ cplx friend TBCI__ cplx<T>  cos (const TBCI__ cplx<T>&);)
template <typename T>
inline TBCI__ cplx<T>  cos (const TBCI__ cplx<T>& z)
{ return z.cos(); }

INST(template <typename T> class TBCI__ cplx friend TBCI__ cplx<T> cosh (const TBCI__ cplx<T>&);)
template <typename T>
inline TBCI__ cplx<T> cosh (const TBCI__ cplx<T>& z)
{ return z.cosh(); }

INST(template <typename T> class TBCI__ cplx friend TBCI__ cplx<T>  tan (const TBCI__ cplx<T>&);)
template <typename T>
inline TBCI__ cplx<T>  tan (const TBCI__ cplx<T>& z)
{ return z.sin()/z.cos(); }

INST(template <typename T> class TBCI__ cplx friend TBCI__ cplx<T> tanh (const TBCI__ cplx<T>&);)
template <typename T>
inline TBCI__ cplx<T> tanh (const TBCI__ cplx<T>& z)
{ return z.sinh()/z.cosh(); }

INST(template <typename T> class TBCI__ cplx friend TBCI__ cplx<T> asin (const TBCI__ cplx<T>&);)
template <typename T>
inline TBCI__ cplx<T> asin (const TBCI__ cplx<T>& z)
{ return z.asin(); }

INST(template <typename T> class TBCI__ cplx friend TBCI__ cplx<T> asinh (const TBCI__ cplx<T>&);)
template <typename T>
inline TBCI__ cplx<T> asinh (const TBCI__ cplx<T>& z)
{ return z.asinh(); }

INST(template <typename T> class TBCI__ cplx friend TBCI__ cplx<T> acos (const TBCI__ cplx<T>&);)
template <typename T>
inline TBCI__ cplx<T> acos (const TBCI__ cplx<T>& z)
{ return z.acos(); }

INST(template <typename T> class TBCI__ cplx friend TBCI__ cplx<T> acosh (const TBCI__ cplx<T>&);)
template <typename T>
inline TBCI__ cplx<T> acosh (const TBCI__ cplx<T>& z)
{ return z.acosh(); }

INST(template <typename T> class TBCI__ cplx friend TBCI__ cplx<T> atan (const TBCI__ cplx<T>&);)
template <typename T>
inline TBCI__ cplx<T> atan (const TBCI__ cplx<T>& z)
{ return z.atan(); }

INST(template <typename T> class TBCI__ cplx friend TBCI__ cplx<T> atanh (const TBCI__ cplx<T>&);)
template <typename T>
inline TBCI__ cplx<T> atanh (const TBCI__ cplx<T>& z)
{ return z.atanh(); }

INST(template <typename T> class TBCI__ cplx friend TBCI__ cplx<T> log10 (const TBCI__ cplx<T>&);)
template <typename T>
inline TBCI__ cplx<T> log10 (const TBCI__ cplx<T>& z)
{ const static double InvLn10 = (1.0 / log(10.0));
  return z.ln()*InvLn10;
}

NAMESPACE_CSTD_END
        
/* Provide specialized memory allocators for cplx<> types */
# include "cplx_memalloc.h"

NAMESPACE_TBCI
/* If used in loops, a single copy is still cheaper than pointer
 * indirection */
SPEC_TBCI_TRAITS_LOOP_COPY(TBCI__ cplx<float>);
SPEC_TBCI_TRAITS_LOOP_COPY(TBCI__ cplx<double>);
SPEC_TBCI_TRAITS_ALWAYS_COPY(TBCI__ cplx<float>*);
SPEC_TBCI_TRAITS_ALWAYS_COPY(TBCI__ cplx<double>*);

NAMESPACE_END
        
#endif  /* TBCI_CPLX_H */