QComplex.cc

Go to the documentation of this file.

/*
* 
* Class QComplex
*
*/
 
#include "QComplex.hh"
#include "QVectorC.hh"
#include <math.h>
#include <iostream>
#include <gsl/gsl_complex_math.h>
 
QObjectImp(Diana::QComplex);
 
 
Q_BEGIN_NAMESPACE
 
QComplex::QComplex()
  : fOwner(true),
    fSize(2),
    fData(NULL)
{
  fData = new double[2];
}
QComplex::QComplex(const double Re, const double Im)
  : fOwner(true),
    fSize(2),
    fData(NULL)
{
  fData=new double[2];
  fData[0]=Re;
  fData[1]=Im;
}
QComplex::QComplex(double* other)
  : fOwner(false),
    fSize(2),
    fData(NULL)
{
  fData = other;
}
QComplex::QComplex(gsl_complex other)
  : fOwner(true),
    fSize(2),
    fData(NULL)
{
  fData=new double[2];
  fData[0]=other.dat[0];
  fData[1]=other.dat[1];
}
 
QComplex::QComplex(gsl_complex* other)
  : fOwner(false),
    fSize(2),
    fData(NULL)
{
  fData = other->dat;
}
QComplex::QComplex(const QComplex& orig)
  : fOwner(true),
    fSize(2),
    fData(NULL)
{ 
  fData=new double[2];
  fData[0]=orig.fData[0];
  fData[1]=orig.fData[1];
}
QComplex::~QComplex()
{
  if(fOwner && fData) delete [] fData;
  fData=NULL;
}
double QComplex::Re() const { return fData[0]; }
double QComplex::Im() const { return fData[1]; }
 
void QComplex::SetRe(const double Re) { fData[0]=Re; }
void QComplex::SetIm(const double Im) { fData[1]=Im; }  
 
 
void QComplex::Set(const double Re, const double Im)
{ fData[0]=Re;fData[1]=Im; }
 
void QComplex::SetPolar(const double mag, const double phase)
{ fData[0]=mag*cos(phase); fData[1]=mag*sin(phase); }
 
 
double QComplex::GetModulusSquare() const 
{
    return fData[0]*fData[0]+fData[1]*fData[1];
}
 
double QComplex::GetMagnitude() const 
{
    return sqrt(GetModulusSquare());
}
 
double QComplex::GetPhase() const 
{
    return atan2(fData[1],fData[0]);
}
 
QComplex QComplex::Conj() const
{
    return QComplex(fData[0],-fData[1]);
}
 
QComplex QComplex::operator+(const QComplex& other) const 
{
    return QComplex(fData[0]+other.fData[0],fData[1]+other.fData[1]);
}  
 
QComplex QComplex::operator-(const QComplex& other) const 
{
    return QComplex(fData[0]-other.fData[0],fData[1]-other.fData[1]);
}
 
QComplex QComplex::operator*(const QComplex& other) const 
{
    double re=fData[0]*other.fData[0]-fData[1]*other.fData[1];
    double im=fData[0]*other.fData[1]+fData[1]*other.fData[0];
    return QComplex(re,im);
}  
 
QComplex QComplex::operator/(const QComplex& other) const 
{
    double re=fData[0]*other.fData[0]+fData[1]*other.fData[1];
    double im=fData[1]*other.fData[0]-fData[0]*other.fData[1];
    double den=other.GetModulusSquare();
    return QComplex(re/den,im/den);
}
QComplex& QComplex::operator+=(const QComplex& other)
{
    fData[0]+=other.fData[0];
    fData[1]+=other.fData[1];
    return *this;
}
 
QComplex& QComplex::operator-=(const QComplex& other)
{  
    fData[0]-=other.fData[0];
    fData[1]-=other.fData[1];
    return *this;
}
 
QComplex& QComplex::operator*=(const QComplex& other)
{
    (*this)= (*this)*other;
    return *this;
}
 
QComplex& QComplex::operator/=(const QComplex& other)
{  
    (*this)= (*this)/other;
    return *this;
}
 
QComplex QComplex::operator+(const double other) const 
{
  return QComplex(fData[0]+other,fData[1]);
}  
 
QComplex QComplex::operator-(const double other) const 
{
  return QComplex(fData[0]-other,fData[1]);
}
 
QComplex QComplex::operator*(const double other) const 
{
  return QComplex(fData[0]*other,fData[1]*other);
}  
 
QComplex QComplex::operator/(const double other) const 
{
  return QComplex(fData[0]/other,fData[1]/other);
}
QComplex& QComplex::operator+=(const double other)
{
  fData[0]+=other;
  return *this;
}
 
QComplex& QComplex::operator-=(const double other)
{
  fData[0]-=other;
  return *this;
}
 
QComplex& QComplex::operator*=(const double other)
{
  fData[0]*=other;
  fData[1]*=other;
  return *this;
}
 
QComplex& QComplex::operator/=(const double other)
{
  fData[0]/=other;
  fData[1]/=other;
  return *this;
}
 
const QComplex& QComplex::operator=(const QComplex& other)
{
  //  std::cout<<"QComplex::opeator=():fData: "<<fData<<std::endl;
  fData[0]=other.fData[0];
  fData[1]=other.fData[1];
  return *this;
}
 
QVectorC QComplex::operator*(const QVectorC& vec) const
{
  return vec*(*this);
}
 
/*
void QComplex::SetMath() const
{
  if(!fMath)
    {
      fMath=(gsl_complex*) malloc(sizeof(gsl_complex));
      &(fMath->dat[0])=fData;
    }
    }*/
gsl_complex QComplex::Get_gsl_complex() const
{
  gsl_complex res; 
  res.dat[0]=fData[0];
  res.dat[1]=fData[1];
  return res;
}
 
 
/********************************************
  NON MEMBER FUNCTIONS
 *********************************************/
Q_END_NAMESPACE
 
Diana::QComplex operator*(double t, const Diana::QComplex &z){
  Diana::QComplex tmp(z);
  tmp*=t;
  return tmp;
}
Diana::QComplex operator/(double t, const Diana::QComplex &z){
  Diana::QComplex tmp(t,0);
  return tmp/z;
}
Diana::QComplex pow(const Diana::QComplex &z,double a) {
  gsl_complex iZ;
  iZ.dat[0]=z.Re();
  iZ.dat[1]=z.Im();
  gsl_complex oZ=gsl_complex_pow_real(iZ,a);
  return Diana::QComplex(oZ.dat[0],oZ.dat[1]);
}
Diana::QComplex pow(const Diana::QComplex &z,const Diana::QComplex &a) {
  gsl_complex iZ,iA;
  iZ.dat[0]=z.Re();iZ.dat[1]=z.Im();
  iA.dat[0]=a.Re();iA.dat[1]=a.Im();
  gsl_complex oZ=gsl_complex_pow(iZ,iA);
  return Diana::QComplex(oZ.dat[0],oZ.dat[1]);
}
double Re(const Diana::QComplex &z) { return z.Re(); }
 
double Im(const Diana::QComplex &z) { return z.Im(); }
 
std::ostream& operator<<(std::ostream& s,const Diana::QComplex& z)
{
  s<<"("<<z.Re();
  if(z.Im()<0)
      {
        s<<" ";
      }
    else
      {
        s<<" +";
      }
  s<<z.Im()<<"i)";
  return s;
}