// nvector.h

#ifndef nvector_H
#define nvector_H

#undef  trf_info
#define trf_error

#include "array.h"

template <class T>
class nvector : public array<T> {
private:
  int _length;
  void ostr(std::ostream& stream) const;
public:
  explicit nvector(int N ) : array<T>(N) { _length = N; };
  virtual ~nvector(void) { };
  nvector<T> &operator=(const nvector<T>& vec);
  nvector(const nvector<T>& vec);
  int length() const { return _length; };
  nvector<T>& operator+=(const nvector<T>& vec);
  nvector<T>& operator-=(const nvector<T>& vec);
  nvector<T>& operator*=(const T& tval);
#if defined(DEFECT_GUIDING_DECLS)
  friend nvector<T> operator+(const nvector<T>& vec1,const nvector<T>& vec2);
  friend nvector<T> operator-(const nvector<T>& vec1,const nvector<T>& vec2);
#elif defined(DEFECT_NO_EXPLICIT_QUALIFICATION)
  template<class S>
  friend nvector<S> operator+(const nvector<S>& vec1,const nvector<S>& vec2);
  template<class S>
  friend nvector<S> operator-(const nvector<S>& vec1,const nvector<S>& vec2);
#else
  friend nvector<T> operator+ <> (const nvector<T>& vec1,const nvector<T>& vec2);
  friend nvector<T> operator- <> (const nvector<T>& vec1,const nvector<T>& vec2);
#endif
};

// copy
template <class T>
inline nvector<T>::nvector(const nvector<T>& vec)
: array<T>( vec )
{
#ifdef trf_info
  std::cout << "copying a vector\n";
#endif
  _length = vec._length;
}

// assignment
template <class T>
inline nvector<T> &nvector<T>::operator=(const nvector<T>& vec)
{
#ifdef trf_info
  std::cout << "assigning a vector\n";
#endif
  (array<T>&)*this = vec;
  return *this;
}

template <class T>
inline nvector<T> &nvector<T>::operator+=(const nvector<T>& vec)
{
  (array<T>&)*this += vec;
  return *this;
}

template <class T>
inline nvector<T> &nvector<T>::operator-=(const nvector<T>& vec)
{
  (array<T>&)*this -= vec;
  return *this;
}

template <class T>
inline nvector<T> &nvector<T>::operator*=(const T& tval)
{
  (array<T>&)*this *= tval;
  return *this;
}

template <class T>
inline nvector<T> operator*(const T& val,const nvector<T>& vec)
{
 nvector<T> lhs = vec;
 lhs *= val;
 return lhs;
}

template <class T>
inline nvector<T> operator*(const nvector<T>& vec,const T& val)
{
 nvector<T> lhs = vec;
 lhs *= val;
 return lhs;
}

template <class T>
inline nvector<T> operator+(const nvector<T>& vec1,const nvector<T>& vec2)
{
  nvector<T> sum = vec1;
  sum += vec2;
  return sum;
}

#ifndef __xlC__
#include "nvector.c"
#endif

#endif