---

CTBcomplex.icc

Go to the documentation of this file.

/*----------------------------------------------------------------------------*/
/* C Tool Box: Designed and implemented by:                                   */
/*    Walter F.J. Mueller   Gesellschaft fuer Schwerionenforschung (GSI)      */
/*                          Postfach 110552, D-64220 Darmstadt, Germany       */
/*                  Email:  W.F.J.Mueller@gsi.de                              */
/*                  WWW:    http://www-kp3.gsi.de/www/kp3/people/mueller.html */
/*------------------------------------------+---------------------------------*/

#include <math.h>

#include "CTBtraits.hxx"
#include "CTBmath.hxx"

//------------------------------------------+-----------------------------------

template <class T>
inline CTBcomplex<T>::CTBcomplex(T f_re, T f_im)
  : mf_re(f_re),
    mf_im(f_im)
{}

//------------------------------------------+-----------------------------------

template <class T>
inline T& CTBcomplex<T>::Re()
{
  return mf_re;
}

//------------------------------------------+-----------------------------------

template <class T>
inline const T& CTBcomplex<T>::Re() const
{
  return mf_re;
}

//------------------------------------------+-----------------------------------

template <class T>
inline T& CTBcomplex<T>::Im()
{
  return mf_im;
}

//------------------------------------------+-----------------------------------

template <class T>
inline const T& CTBcomplex<T>::Im() const
{
  return mf_im;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBcomplex<T>::Re(T f_re)
{
  mf_re = f_re;
  return;
}

//------------------------------------------+-----------------------------------

template <class T>
inline void CTBcomplex<T>::Im(T f_im)
{
  mf_im = f_im;
  return;
}

//------------------------------------------+-----------------------------------

template <class T>
inline T CTBcomplex<T>::Abs() const
{
  return CTBpythag(mf_re, mf_im);
}

//------------------------------------------+-----------------------------------

template <class T>
inline T CTBcomplex<T>::Arg() const
{
  return atan2(mf_im, mf_re);
}

//------------------------------------------+-----------------------------------

template <class T>
inline bool CTBcomplex<T>::IsReal() const
{
  return mf_im == 0. || fabs(mf_im) <= CTBtraits<T>::Epsilon() * fabs(mf_re);
}

//------------------------------------------+-----------------------------------

template <class T>
inline bool CTBcomplex<T>::IsImaginary() const
{
  return mf_re == 0. || fabs(mf_re) <= CTBtraits<T>::Epsilon() * fabs(mf_im);
}

//------------------------------------------+-----------------------------------

template <class T>
inline CTBcomplex<T> CTBcomplex<T>::Conj() const
{
  return CTBcomplex<T>(mf_re, -mf_im);
}

//------------------------------------------+-----------------------------------

template <class T>
inline CTBcomplex<T> CTBcomplex<T>::TimesI() const
{
  return CTBcomplex<T>(-mf_im, mf_re);
}

//------------------------------------------+-----------------------------------

template <class T>
inline CTBcomplex<T>& CTBcomplex<T>::operator=(T f_r)
{
  mf_re = f_r;
  mf_im = 0.;
  return *this;
}

//------------------------------------------+-----------------------------------

template <class T>
inline bool CTBcomplex<T>::operator!() const
{
  return (mf_re == 0. && mf_im == 0.);
}

//------------------------------------------+-----------------------------------

template <class T>
inline CTBcomplex<T>::operator void* () const
{
  return (mf_re != 0. || mf_im != 0.) ? (void*) this : 0;
}

//------------------------------------------+-----------------------------------

template <class T>
inline CTBcomplex<T> CTBcomplex<T>::operator+() const
{
  return *this;
}

//------------------------------------------+-----------------------------------

template <class T>
inline CTBcomplex<T> CTBcomplex<T>::operator-() const
{
  return CTBcomplex<T>(-mf_re, -mf_im);
}

//------------------------------------------+-----------------------------------

template <class T>
inline CTBcomplex<T>& CTBcomplex<T>::operator+=(const CTBcomplex<T>& z)
{
  mf_re += z.mf_re;
  mf_im += z.mf_im;
  return *this;
}

//------------------------------------------+-----------------------------------

template <class T>
inline CTBcomplex<T>& CTBcomplex<T>::operator+=(T f_r)
{
  mf_re += f_r;
  return *this;
}

//------------------------------------------+-----------------------------------

template <class T>
inline CTBcomplex<T>& CTBcomplex<T>::operator-=(const CTBcomplex<T>& z)
{
  mf_re -= z.mf_re;
  mf_im -= z.mf_im;
  return *this;
}

//------------------------------------------+-----------------------------------

template <class T>
inline CTBcomplex<T>& CTBcomplex<T>::operator-=(T f_r)
{
  mf_re -= f_r;
  return *this;
}

//------------------------------------------+-----------------------------------

template <class T>
inline CTBcomplex<T>& CTBcomplex<T>::operator*=(const CTBcomplex<T>& z)
{
  T f_re = mf_re * z.Re() - mf_im * z.Im();
  T f_im = mf_im * z.Re() + mf_re * z.Im();

  mf_re = f_re;
  mf_im = f_im;
  return *this;
}

//------------------------------------------+-----------------------------------

template <class T>
inline CTBcomplex<T>& CTBcomplex<T>::operator*=(T f_r)
{
  mf_re *= f_r;
  mf_im *= f_r;
  return *this;
}

//------------------------------------------+-----------------------------------

template <class T>
inline CTBcomplex<T>& CTBcomplex<T>::operator/=(const CTBcomplex<T>& z)
{
  CTBcomplex<T> zt = (*this) / z;
  (*this) = zt;
  return *this;
}

//------------------------------------------+-----------------------------------

template <class T>
inline CTBcomplex<T>& CTBcomplex<T>::operator/=(T f_r)
{
  mf_re /= f_r;
  mf_im /= f_r;
  return *this;
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> operator+(const CTBcomplex<T>& lhs,
                               const CTBcomplex<T>& rhs)
{  
  return CTBcomplex<T>(lhs.Re()+rhs.Re(), lhs.Im()+rhs.Im());
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> operator+(const CTBcomplex<T>& lhs, T f_rhs)
{  
  return CTBcomplex<T>(lhs.Re()+f_rhs, lhs.Im());
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> operator+(T f_lhs, const CTBcomplex<T>& rhs)
{  
  return CTBcomplex<T>(f_lhs+rhs.Re(), rhs.Im());
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> operator-(const CTBcomplex<T>& lhs,
                               const CTBcomplex<T>& rhs)
{  
  return CTBcomplex<T>(lhs.Re()-rhs.Re(), lhs.Im()-rhs.Im());
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> operator-(const CTBcomplex<T>& lhs, T f_rhs)
{  
  return CTBcomplex<T>(lhs.Re()-f_rhs, lhs.Im());
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> operator-(T f_lhs, const CTBcomplex<T>& rhs)
{  
  return CTBcomplex<T>(f_lhs-rhs.Re(), -rhs.Im());
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> operator*(const CTBcomplex<T>& lhs,
                               const CTBcomplex<T>& rhs)
{
  return CTBcomplex<T>(lhs.Re() * rhs.Re() - lhs.Im() * rhs.Im(),
                       lhs.Im() * rhs.Re() + lhs.Re() * rhs.Im());
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> operator*(const CTBcomplex<T>& lhs, T f_rhs)
{  
  return CTBcomplex<T>(lhs.Re()*f_rhs, lhs.Im()*f_rhs);
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> operator*(T f_lhs, const CTBcomplex<T>& rhs)
{  
  return CTBcomplex<T>(f_lhs*rhs.Re(), f_lhs*rhs.Im());
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> operator/(const CTBcomplex<T>& lhs,
                               const CTBcomplex<T>& rhs)
{
  return lhs.Divide(rhs);
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> operator/(const CTBcomplex<T>& lhs, T f_rhs)
{  
  return CTBcomplex<T>(lhs.Re()/f_rhs, lhs.Im()/f_rhs);
}

//------------------------------------------+-----------------------------------
template <class T>
CTBcomplex<T> operator/(T f_lhs, const CTBcomplex<T>& rhs)
{  
  return rhs.Invert(f_lhs);
}

//------------------------------------------+-----------------------------------
template <class T>
inline bool operator==(const CTBcomplex<T>& lhs, const CTBcomplex<T>& rhs)
{  
  return (lhs.Re() == rhs.Re() && lhs.Im() == rhs.Im());
}

//------------------------------------------+-----------------------------------
template <class T>
inline bool operator==(const CTBcomplex<T>& lhs, T f_rhs)
{  
  return (lhs.Re() == f_rhs && lhs.Im() == 0.);
}

//------------------------------------------+-----------------------------------
template <class T>
inline bool operator==(T f_lhs, const CTBcomplex<T>& rhs)
{  
  return (f_lhs == rhs.Re() && 0. == rhs.Im());
}

//------------------------------------------+-----------------------------------
template <class T>
inline ostream& operator<<(ostream& os, const CTBcomplex<T>& obj)
{
  obj.ToStream(os);
  return os;
}

//------------------------------------------+-----------------------------------
template <class T>
inline istream& operator>>(istream& is, CTBcomplex<T>& obj)
{
  obj.FromStream(is);
  return is;
}

//------------------------------------------+-----------------------------------
template <class T>
inline T CTBabs(const CTBcomplex<T>& z)
{  
  return z.Abs();
}

//------------------------------------------+-----------------------------------
template <class T>
inline T CTBabsm(const CTBcomplex<T>& z)
{  
  return CTBmax(fabs(z.Re()), fabs(z.Im()));
}

//------------------------------------------+-----------------------------------
template <class T>
inline T CTBabs2(const CTBcomplex<T>& z)
{  
  return z.Re()*z.Re() + z.Im()*z.Im();
}

//------------------------------------------+-----------------------------------
template <class T>
inline T CTBarg(const CTBcomplex<T>& z)
{  
  return z.Arg();
}

//------------------------------------------+-----------------------------------
template <class T>
inline T CTBreal(const CTBcomplex<T>& z)
{  
  return z.Re();
}

//------------------------------------------+-----------------------------------
template <class T>
inline T CTBimag(const CTBcomplex<T>& z)
{  
  return z.Im();
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> CTBconj(const CTBcomplex<T>& z)
{  
  return CTBcomplex<T>(z.Re(), -z.Im());
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> CTBtimesI(const CTBcomplex<T>& z)
{  
  return CTBcomplex<T>(-z.Im(), z.Re());
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> CTBsqrt(const CTBcomplex<T>& z)
{  
  return z.Sqrt();
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> CTBexp(const CTBcomplex<T>& z)
{  
  return z.Exp();
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> CTBlog(const CTBcomplex<T>& z)
{  
  return z.Log();
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> CTBsin(const CTBcomplex<T>& z)
{  
  return z.Sin();
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> CTBcos(const CTBcomplex<T>& z)
{  
  return z.Cos();
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> CTBtan(const CTBcomplex<T>& z)
{  
  return z.Tan();
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> CTBasin(const CTBcomplex<T>& z)
{  
  return z.Asin();
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> CTBacos(const CTBcomplex<T>& z)
{  
  return z.Acos();
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> CTBatan(const CTBcomplex<T>& z)
{  
  return z.Atan();
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> CTBsinh(const CTBcomplex<T>& z)
{  
  return z.Sinh();
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> CTBcosh(const CTBcomplex<T>& z)
{  
  return z.Cosh();
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> CTBtanh(const CTBcomplex<T>& z)
{  
  return z.Tanh();
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> CTBasinh(const CTBcomplex<T>& z)
{  
  return z.Asinh();
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> CTBacosh(const CTBcomplex<T>& z)
{  
  return z.Acosh();
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> CTBatanh(const CTBcomplex<T>& z)
{  
  return z.Atanh();
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> CTBpow(const CTBcomplex<T>& z_x, int i_y)
{  
  return z_x.Pow(i_y);
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBcomplex<T> CTBpow(const CTBcomplex<T>& z_x, const CTBcomplex<T>& z_y)
{  
  return z_x.Pow(z_y);
}

//------------------------------------------+-----------------------------------
template <class T>
inline CTBprintfS<CTBcomplex<T> > CTBprintf(CTBcomplex<T> value, 
                                            const char* c_format,
                                            int i_width, int i_precision)
{
  return CTBprintfS<CTBcomplex<T> >(value,c_format,i_width,i_precision);
}

---