---

RealVector.h

/****************************************************************************
 *                                                                          *
 *  Program: FDDlib                                                         *
 *  Version: 1.0                                                            *
 *                                                                          *
 *  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 _REAL_VECTOR_H_
#define _REAL_VECTOR_H_

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

namespace FDDlib {

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

 public:
 
  RealVector(int len);

  ~RealVector();

  void deallocate();

  RealVector();

  void init(int len);

  RealVector(const RealVector& rv);

  RealVector<T>& operator=(const RealVector<T>& rv);

  RealVector<T>& operator=(const T v);

  RealVector<T>& operator+=(const RealVector<T>& rv);

  RealVector<T>& operator-=(const RealVector<T>& rv);

  RealVector<T>& operator*=(const T v);

  RealVector<T> operator+(const RealVector<T>& rv) const;

  RealVector<T> operator-(const RealVector<T>& rv) const;

  RealVector<T> operator*(const T t) const;

  double dot(const RealVector<T>& rv) const;

  double norm() const;

  double norm1() const;

  int size() const;

  void set(int ind, T val);
  
  T val(int ind) const;
  
  T& operator()(int ind);

  T operator()(int ind) const;

  T max() const;

  T absmax() const;

  T min() const;
};



/* Added null pointer exception check 6/18/04
*/
template<class T>
RealVector<T>::RealVector(int len)
{
  int i;
  len_ = len;
  valVec_ = new T[len_];
  assert (valVec_ != NULL);             // added 6/18/04
  for (i = 0; i < len_; i++)
  {
    set(i, (T) 0);
  }
}

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

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

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

/* Added check for null pointer exception 8/25/04
*/
template<class T>
void RealVector<T>::init(int len)
{
  int i;
  len_ = len;
  if (valVec_ != (T*) NULL)
    delete[] valVec_;

  valVec_ = new T[len_];
  assert(valVec_ != NULL);      // added 8/25/04

  for (i = 0; i < len_; i++)
  {
    set(i, (T) 0);
  }
}

/* Added check for null pointer exception on allocation
   8/25/04
*/
template<class T>
RealVector<T>::RealVector(const RealVector& rv)
{
  int i;

  len_ = rv.size();
  valVec_ = new T[len_];
  assert(valVec_ != NULL);      // added 8/25/04

  for (i = 0; i < len_; i++)
  {
    set(i, rv.val(i));
  }
}

/* Added check for null pointer exception on allocation
   1/21/04
*/
template<class T>
RealVector<T>& RealVector<T>::operator=(const RealVector<T>& rv)
{
  int i;

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

  len_ = rv.size();
  valVec_ = new T[len_];
  assert(valVec_ != NULL);
  for (i = 0; i < len_; i++)
  {
    set(i, rv.val(i));
  }

  return *this;
}

/* Added check for NULL array 1/21/04 
   Original code assumed that if valVec_ is NULL,
   then len_ would be zero, thus preventing a
   runtime error at set(i,v);  The extra check prevents
   problems in the event valVec_ is NULL but len_ is
   greater than zero.   JB 1/21/04
*/
template<class T>
RealVector<T>& RealVector<T>::operator=(const T v)
{
  int i;

  if (valVec_ == (T*) NULL)     /* added 1/21/04 */
     return *this;

  for (i = 0; i < len_; i++)
  {
    set(i, v);
  }

  return *this;
}

template<class T>
RealVector<T>& RealVector<T>::operator+=(const RealVector<T>& rv)
{
  int i;
  T   v;
  const int s = size();

  for (i = 0; i < s; i++)
  {
    v = val(i) + rv.val(i);
    set(i, v);
  }

  return *this;
}

template<class T>
RealVector<T>& RealVector<T>::operator-=(const RealVector<T>& rv)
{
  int i;
  T   v;
  const int s = size();

  for (i = 0; i < s; i++)
  {
    v = val(i) - rv.val(i);
    set(i, v);
  }

  return *this;
}

template<class T>
RealVector<T>& RealVector<T>::operator*=(const T v)
{
  int i;
  const int s = size();

  for (i = 0; i < s; i++)
  {
    set(i, val(i)*v);
  }

  return *this;
}

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

template<class T>
inline void RealVector<T>::set(int ind, T val)
{
  if (ind >= 0 && ind < len_)
     valVec_[ind] = val;
}

template<class T>
inline T RealVector<T>::val(int ind) const
{
  return valVec_[ind];
}

template<class T>
inline T& RealVector<T>::operator()(int ind)
{
  return valVec_[ind];
}

template<class T>
inline T RealVector<T>::operator()(int ind) const
{
  return valVec_[ind];
}

template<class T>
inline T RealVector<T>::max() const
{
  int i;
  T   val;
  const int s = size();

  if (len_ == 0)
    return (T) -1;

  val = valVec_[0];
  maxind = 0;
  for (i = 0; i < s; i++)
  {
    if (valVec_[i] > val)
    {
      val = valVec_[i];
      maxind = i;
    }
  }

  return val;
}

template<class T>
inline T RealVector<T>::absmax() const
{
  int i;
  T   val;
  const int s = size();

  if (len_ == 0)
    return (T) -1;

  val = (T) fabs((double) valVec_[0]);
  maxind = 0;
  for (i = 0; i < s; i++)
  {
    if (fabs((double) valVec_[i]) > (double) val)
    {
      val = (T) fabs((double) valVec_[i]);
      maxind = i;
    }
  }

  return val;
}


template<class T>
inline T RealVector<T>::min() const
{
  int i;
  T   val;
  const int s = size();

  if (len_ == 0)
    return (T) -1;

  val = valVec_[0];
  minind = 0;
  for (i = 0; i < s; i++)
  {
    if (valVec_[i] < val)
    {
      val = valVec_[i];
      minind = i;
    }
  }

  return val;
}

template<class T>
RealVector<T> RealVector<T>::operator+(const RealVector<T>& rv) const
{
  const int s = size();
  RealVector<T> ret(s);
  int           i;
  T             v;

  for (i = 0; i < s; i++)
  {
    v = val(i) + rv.val(i);
    ret.set(i, v);
  }

  return ret;
}

template<class T>
RealVector<T> RealVector<T>::operator-(const RealVector<T>& rv) const
{
  const int s = size();
  RealVector<T> ret(s);
  int           i;
  T             v;

  for (i = 0; i < s; i++)
  {
    v = val(i) - rv.val(i);
    ret.set(i, v);
  }

  return ret;
}

template<class T>
RealVector<T> RealVector<T>::operator*(const T s) const
{
  const int len = size();
  RealVector<T> ret(len);
  T             v;
  int           i;

  for (i = 0; i < len; i++)
  {
    v = val(i) * s;
    ret.set(i, v);
  }

  return ret;
}

template<class T>
double RealVector<T>::dot(const RealVector<T>& rv) const
{
  int    i;
  double ret;
  const int s = size();

  ret = 0;
  for (i = 0; i < s; i++)
  {
    ret += (double) (val(i) * rv.val(i));
  }

  return ret;

}

template<class T>
double RealVector<T>::norm() const
{
  int    i;
  double ret;
  const int s = size();

  ret = 0;
  for (i = 0; i < s; i++)
  {
    ret += (double) (val(i) * val(i));
  }
  ret = sqrt(ret);

  return ret;
}

template<class T>
double RealVector<T>::norm1() const
{
  int    i;
  double ret;
  const int s = size();

  ret = 0;
  for (i = 0; i < s; i++)
  {
    ret += fabs((double) val(i));
  }

  return ret;
}

template<class T>
double dot(const RealVector<T>& a, const RealVector<T>& b)
{
  return a.dot(b);
}

template<class T>
double norm(const RealVector<T>& rv)
{
  return rv.norm();
}

template<class T>
double norm1(const RealVector<T>& rv)
{
  return rv.norm1();
}

template<class T>
RealVector<T> operator*(const T s, const RealVector<T>& rv)
{
  return rv * s;
}

} // end namespace
#endif

---