---

ComplexVector.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_VECTOR_H_
#define _COMPLEX_VECTOR_H_

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

namespace FDDlib {

template<class T>
class ComplexVector
{
protected:
  int               len_;
  Complex<T>*       valVec_;

public:
  ComplexVector(int len);

  ComplexVector();

  void init(int len);

  ComplexVector(const ComplexVector<T>& cv);

  ~ComplexVector();

  void deallocate();

  Complex<T> val(int i) const;

  Complex<T>& val(int i);

  Complex<T> operator()(int i) const;

  Complex<T>& operator()(int i);

  void set(int ind, Complex<T>& c);

  void setReal(int ind, T real);

  void setImag(int ind, T imag);

  T getReal(int ind) const;

  T getImag(int ind) const;

  int size() const;

  ComplexVector<T>& operator=(const ComplexVector<T>& cv);

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

  ComplexVector<T>& operator+=(const ComplexVector<T>& cv);

  ComplexVector<T>& operator-=(const ComplexVector<T>& cv);

  ComplexVector<T> operator+(const ComplexVector<T>& cv) const;

  ComplexVector<T> operator-(const ComplexVector<T>& cv) const;

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

  ComplexVector<T> conjugate() const;

  Complex<T> dot(const ComplexVector<T> cv) const;

  double norm() const;

};

template<class T>
ComplexVector<T>::ComplexVector(int len)
{
  int i;

  len_ = len;
  valVec_ = new Complex<T>[len_];
  for (i = 0; i < len_; i++)
  {
    setReal(i, (T) 0);
    setImag(i, (T) 0);
  }
}

template<class T>
ComplexVector<T>::ComplexVector()
{
  len_ = 0;
  valVec_ = (Complex<T>*) NULL;
}

template<class T>
void ComplexVector<T>::init(int len)
{
  int i;

  len_ = len;

  if (valVec_ != (Complex<T>*) NULL)
    delete[] valVec_;

  valVec_ = new Complex<T>[len_];
  for (i = 0; i < len_; i++)
  {
    setReal(i, (T) 0);
    setImag(i, (T) 0);
  }
}

template<class T>
ComplexVector<T>::ComplexVector(const ComplexVector<T>& cv)
{
  int i;

  len_ = cv.size();
  valVec_ = new Complex<T>[len_];
  for (i = 0; i < len_; i++)
  {
    setReal(i, cv.getReal(i));
    setImag(i, cv.getImag(i));
  }
}

template<class T>
ComplexVector<T>::~ComplexVector()
{
  if (valVec_ != (Complex<T>*) NULL)
    delete[] valVec_;
}

template<class T>
void ComplexVector<T>::deallocate()
{
  if (valVec_ != (Complex<T>*) NULL)
    delete[] valVec_;
  len_ = 0;

  valVec_ = (Complex<T>*) NULL;
}

template<class T>
inline Complex<T> ComplexVector<T>::val(int i) const
{
  return valVec_[i];
}

template<class T>
inline Complex<T>& ComplexVector<T>::val(int i)
{
  return valVec_[i];
}

template<class T>
inline Complex<T> ComplexVector<T>::operator()(int i) const
{
  return valVec_[i];
}

template<class T>
inline Complex<T>& ComplexVector<T>::operator()(int i)
{
  return valVec_[i];
}


template<class T>
inline void ComplexVector<T>::set(int ind, Complex<T>& c)
{
  setReal(ind, c.getReal());
  setImag(ind, c.getImag());
}

template<class T>
inline void ComplexVector<T>::setReal(int ind, T real)
{
  valVec_[ind].setReal(real);
}

template<class T>
inline void ComplexVector<T>::setImag(int ind, T imag)
{
  valVec_[ind].setImag(imag);
}

template<class T>
inline T ComplexVector<T>::getReal(int ind) const
{
  return valVec_[ind].getReal();
}

template<class T>
inline T ComplexVector<T>::getImag(int ind) const
{
  return valVec_[ind].getImag();
}

template<class T>
inline int ComplexVector<T>::size() const
{
  return len_;
}

template<class T>
ComplexVector<T>& ComplexVector<T>::operator=(const ComplexVector<T>& cv)
{
  int i;

  if (cv.size() != size())
  {
    if (valVec_ != (Complex<T>*) NULL)
      delete[] valVec_;
    valVec_ = new Complex<T>[cv.size()];
    len_ = cv.size();
  }
  for (i = 0; i < len_; i++)
  {
    setReal(i, cv.getReal(i));
    setImag(i, cv.getImag(i));
  }

  return *this;
}

template<class T>
ComplexVector<T>& ComplexVector<T>::operator*=(const Complex<T>& c)
{
  int        i;
  Complex<T> tmp;

  for (i = 0; i < size(); i++)
  {
    tmp = val(i) * c;
    setReal(i, tmp.getReal());
    setImag(i, tmp.getImag());
  }

  return *this;
}

template<class T>
ComplexVector<T>& ComplexVector<T>::operator+=(const ComplexVector<T>& cv)
{
  int        i;
  Complex<T> tmp;

  for (i = 0; i < size(); i++)
  {
    tmp = val(i) + cv.val(i);
    setReal(i, tmp.getReal());
    setImag(i, tmp.getImag());
  }

  return *this;
}

template<class T>
ComplexVector<T>& ComplexVector<T>::operator-=(const ComplexVector<T>& cv)
{
  int                    i;
  Complex<T> tmp;

  for (i = 0; i < size(); i++)
  {
    tmp = val(i) - cv.val(i);
    setReal(i, tmp.getReal());
    setImag(i, tmp.getImag());
  }

  return *this;
}

template<class T>
ComplexVector<T> ComplexVector<T>::operator+(const ComplexVector<T>& cv) const
{
  ComplexVector<T> ret(size());
  int              i;

  for (i = 0; i < size(); i++)
  {
    ret.set(i, val(i)+cv.val(i));
  }

  return ret;
}

template<class T>
ComplexVector<T> ComplexVector<T>::operator-(const ComplexVector<T>& cv) const
{
  ComplexVector<T> ret(size());
  int              i;

  for (i = 0; i < size(); i++)
  {
    ret.set(i, val(i)-cv.val(i));
  }

  return ret;
}

template<class T>
ComplexVector<T> ComplexVector<T>::operator*(const Complex<T>& c) const
{
  ComplexVector<T> ret(size());
  int              i;

  for (i = 0; i < size(); i++)
  {
    ret.set(i, val(i)*c);
  }

  return ret;
}

template<class T>
ComplexVector<T> ComplexVector<T>::conjugate() const
{
  ComplexVector<T> ret(size());
  int              i;

  for (i = 0; i < size(); i++)
  {
    ret.set(i, val(i).conjugate());
  }

  return ret;
}

template<class T>
Complex<T> ComplexVector<T>::dot(const ComplexVector<T> cv) const
{
  Complex<T> ret;
  int             i;

  ret.setReal(0);
  ret.setImag(0);

  for (i = 0; i < size(); i++)
  {
    ret += val(i)*cv.val(i);
  }

  return ret;
}

template<class T>
double ComplexVector<T>::norm() const
{
  int    i;
  double ret;

  ret = 0;
  for (i = 0; i < size(); i++)
  {
    v = (double) getReal(i);
    ret += v*v;
    v = (double) getImag(i);
    ret += v*v;
  }

  ret = sqrt(ret);
  return ret;
}

} // end namespace
#endif

---