---

Complex.h

/****************************************************************************
 *                                                                          *
 *  Program: FDDlib                                                         *
 *  Version: 1.1                                                            *
 *                                                                          *
 *  Copyright (C) 2002 - 2004 by Eric Miller and Dana Brooks                *
 *  All rights reserved.                                                    *
 *                                                                          *
 *  This software is Version 1.1 of the fddlib tomography toolbox.          *
 *  It is not to be redistributed or used for any commercial purpose        *
 *  without the prior written consent of the authors and Northeastern       *
 *  University.                                                             *
 *                                                                          *
 *  This software is provided as is, and any express or implied warranties, *
 *  including but not limited to the implied warranty of merchantability    *
 *  and the implied warranty of fitness for a particular purpose, are dis-  *
 *  claimed.  In no event shall the authors or Northeastern University be   *
 *  liable for any direct, indirect, incidental, special, exemplary, or     *
 *  consequential damages (including but not limited to procurement of      * 
 *  substitute goods or services; loss of use, data, or profits; or busi-   *
 *  ness interruption) however caused and on any theory of liability,       *
 *  whether in contract, strict liability, or tort (including negligence or *
 *  otherwise) arising in any way from the use of this software, even if    *
 *  advised of the possibility of such damage.                              *
 *                                                                          *
 *  Portions of this code benefit from ideas from Kyle Guilbert, Greg       *
 *  Boverman, Derek Uluski, David Kaeli, and Jennifer Black                 *
 *                                                                          *
 ****************************************************************************/

#ifndef _COMPLEX_H_
#define _COMPLEX_H_

#include <math.h>
#include <stdlib.h>

namespace FDDlib {

template<class T>
class Complex
{
protected:
  T realPart_;
  T imagPart_;

public:
  Complex();

  ~Complex() { }

  Complex(const T realPart, const T imagPart);

  Complex(const T t);

  Complex(const Complex<T>& cn);

  Complex<T>& operator=(const Complex<T>& c);

  T getReal() const;

  T getImag() const;

  void setReal(T r);

  void setImag(T i);

  Complex<T>& operator+=(const Complex<T>& c);

  Complex<T>& operator-=(const Complex<T>& c);

  Complex<T>& operator*=(const Complex<T>& c);

  Complex<T>& operator*=(const T s);

  Complex<T>& operator/=(const Complex<T>& c);

  Complex<T>& operator/=(const T s);

  Complex<T> operator+(const Complex<T>& c) const;

  Complex<T> operator-(const Complex<T>& c) const;

  Complex<T> operator*(const Complex<T>& c) const;

  Complex<T> operator*(const T s) const;

  Complex<T> operator/(const Complex<T>& c) const;

  Complex<T> operator/(const T s) const;

  double magnitude() const;

  double squareMagnitude() const;

  Complex<T> conjugate() const;

};

template<class T>
Complex<T>::Complex()
{
  realPart_ = 0;
  imagPart_ = 0;
}

template<class T>
Complex<T>::Complex(const T realPart, const T imagPart)
{
  realPart_ = realPart;
  imagPart_ = imagPart;
}

template<class T>
Complex<T>::Complex(const T t)
{
  realPart_ = t;
  imagPart_ = 0;
}

template<class T>
Complex<T>::Complex(const Complex<T>& cn)
{
  realPart_ = cn.getReal();
  imagPart_ = cn.getImag();
}

template<class T>
Complex<T>& Complex<T>::operator=(const Complex<T>& c)
{
  realPart_ = c.getReal();
  imagPart_ = c.getImag();

  return *this;
}

template<class T>
T Complex<T>::getReal() const
{
  return realPart_;
}

template<class T>
T Complex<T>::getImag() const
{
  return imagPart_;
}

template<class T>
void Complex<T>::setReal(T r)
{
  realPart_ = r;
}

template<class T>
void Complex<T>::setImag(T i)
{
  imagPart_ = i;
}

template<class T>
Complex<T>& Complex<T>::operator+=(const Complex<T>& c)
{
  realPart_ += c.getReal();
  imagPart_ += c.getImag();

  return *this;
}

template<class T>
Complex<T>& Complex<T>::operator-=(const Complex<T>& c)
{
  realpart_ -= c.getReal();
  imagpart_ -= c.getImag();

  return *this;
}

template<class T>
Complex<T>& Complex<T>::operator*=(const Complex<T>& c)
{
  realPart_ = getReal() * c.getReal() - getImag() * c.getImag();
  imagPart_ = getReal() * c.getImag() + getImag() * c.getReal();

  return *this;
}

template<class T>
Complex<T>& Complex<T>::operator*=(const T s)
{
  realPart_ *= s;
  imagPart_ *= s;

  return *this;
}

template<class T>
Complex<T>& Complex<T>::operator/=(const Complex<T>& c)
{
  T mag;

  mag = (T) ((double) (getReal()*c.getReal() + getImag()*c.getImag()));

  if (mag == (T) 0)
    return NULL;

  realPart_ = getReal() * c.getReal() + getImag() * c.getImag();
  imagPart_ = getImag() * c.getReal() - getReal() * c.getImag();

  realPart_ /= mag;
  imagPart_ /= mag;

  return *this;
}

template<class T>
Complex<T>& Complex<T>::operator/=(const T a)
{
  realPart_ /= a;
  imagPart_ /= a;

  return *this;
}

template<class T>
Complex<T> Complex<T>::operator+(const Complex<T>& c) const
{
  Complex<T> ret;
  ret.setReal(getReal() + c.getReal());
  ret.setImag(getImag() + c.getImag());
  return ret;
}

template<class T>
Complex<T> Complex<T>::operator-(const Complex<T>& c) const
{
  Complex<T> ret;
  ret.setReal(getReal() - c.getReal());
  ret.setImag(getImag() - c.getImag());
  return ret;
}

template<class T>
Complex<T> Complex<T>::operator*(const Complex<T>& c) const
{
  Complex<T> ret;
  ret.setReal(getReal() * c.getReal() - getImag() * c.getImag());
  ret.setImag(getReal() * c.getImag() + getImag() * c.getReal());
  return ret;
}

template<class T>
Complex<T> Complex<T>::operator*(const T s) const
{
  Complex<T> ret;
  ret.setReal(getReal() * s);
  ret.setImag(getImag() * s);
  return ret;
}

template<class T>
Complex<T> Complex<T>::operator/(const Complex<T>& c) const
{
  T mag, rp, ip;
  Complex<T> ret;

  mag = (T) ((double) (getReal()*c.getReal() + getImag()*c.getImag()));

  if (mag == (T) 0)
    return NULL;

  rp = getReal() * c.getReal() + getImag() * c.getImag();
  ip = getImag() * c.getReal() - getReal() * c.getImag();

  rp /= mag;
  ip /= mag;

  ret.setReal(rp);
  ret.setImag(ip);

  return ret;
}

template<class T>
Complex<T> Complex<T>::operator/(const T s) const
{
  Complex<T> ret;
  ret.setReal(getReal() / s);
  ret.setImag(getImag() / s);
  return ret;
}

template<class T>
double Complex<T>::magnitude() const
{
  return (sqrt((double) (realPart_*realPart_ + imagPart_*imagPart_)));
}

template<class T>
double Complex<T>::squareMagnitude() const
{
  return ((double) (realPart_*realPart_ + imagPart_*imagPart_));
}

template<class T>
Complex<T> Complex<T>::conjugate() const
{
  return Complex<T>(realPart_, -1*imagPart_);
}

// end namespace
}
#endif

---