#ifndef VEC_H
#define VEC_H
///////////////////////////////////////////////////////////////
//  vec.h - declares an n Dimensional vector                 //
//  Exam1:Q2                                                 //
//  Jim Fawcett, CSE687 - Object Oriented Design, Spring 05  //
///////////////////////////////////////////////////////////////

#include <vector>

namespace Exam1
{
  /////////////////////////////////////////////////////
  // This is the required part of the answer

  template <typename T>
  class vec
  {
  public:
    vec(int n, const T& t = T(0));
//  vec(const vec& v);                    // correct compiler generated
//  vec<T>& operator=(const vec<T>& v);   //    "        "       "
    T& operator[](int n);                 // v1[1] = t;
    T operator[](int n) const;            // t = v1[1];
    vec<T>& operator+=(const vec<T>& v);  // v2 += v1;
    vec<T>& operator-=(const vec<T>& v);  // v2 -= v1;
    vec<T>& operator*=(const T &t);       // v2 *= t;
    T size() const { return data.size(); }
  private:
    std::vector<T> data;
  };

  ///////////////////////////////////////////////////////
  // global operators

  template <typename T>
  vec<T> operator+(const vec<T>& v1, const vec<T>& v2);  // v3 = v1 + v2;
  template <typename T>
  vec<T> operator-(const vec<T>& v1, const vec<T>& v2);  // v3 = v1 - v2
  template <typename T>
  vec<T> operator*(const vec<T>& v, const T& t);         // v2 = v1*t;
  template <typename T>
  vec<T> operator*(const T& t, const vec<T>& v);         // v2 = t*v1;

  // end of required part of answer
  ///////////////////////////////////////////////////////

//
  //----< size validation >------------------------------------

  template <typename T>
  void checkSize(const vec<T>& v1, const vec<T>& v2)
  {
    if(v1.size() != v2.size())
      throw exception("incompatible vector sizes");
  }
  //---< construct vector with n elements >--------------------

  template <typename T>
  vec<T>::vec(int n, const T& t)
  {
    for(int i=0; i<n; ++i)
      data.push_back(t);
  }
  //---< additive assignment >---------------------------------

  template <typename T>
  vec<T>& vec<T>::operator+=(const vec<T>& v)
  {
    checkSize(*this,v);
    for(int i=0; i<size(); ++i)
      data[i] += v.data[i];
    return *this;
  }
  //----< global addition operator >---------------------------

  template <typename T>
  vec<T> operator+(const vec<T>& v1, const vec<T>& v2)
  {
    checkSize(v1,v2);
    vec<T> temp = v1;
    return (temp += v2);
  }
  //
  //----< subtractive assignment >-----------------------------

  template <typename T>
  vec<T>& vec<T>::operator-=(const vec<T>& v)
  {
    checkSize(*this,v);
    for(int i=0; i<size(); ++i)
      data[i] -= v.data[i];
    return *this;
  }
  //----< global subtraction operator >------------------------

  template <typename T>
  vec<T> operator-(const vec<T>& v1, const vec<T>& v2)
  {
    checkSize(v1,v2);
    vec<T> temp = v1;
    return (temp -= v2);
  }
  //----< scalar multiplicative assignment >-------------------

  template <typename T>
  vec<T>& vec<T>::operator*=(const T &t)
  {
    for(int i=0; i<size(); ++i)
      data[i] *= t;
    return *this;
  }
  //----< global scalar multiplication operator >--------------

  template <typename T>
  vec<T> operator*(const T &t, const vec<T>& v)
  {
    vec<T> temp = v;
    temp *= t;
    return temp;
  }
  //----< global scalar multiplication operator >--------------

  template <typename T>
  vec<T> operator*(const vec<T>& v, const T &t)
  {
    vec<T> temp = v;
    temp *= t;
    return temp;
  }
  //
  //----< index operator >-------------------------------------

  template <typename T>
  T& vec<T>::operator[](int n)
  {
    if(n<0 || size()<=n)
      throw exception("index out of range in operator[]");
    return data[n];
  }
  //----< index operator >-------------------------------------

  template <typename T>
  T vec<T>::operator[](int n) const
  {
    if(n<0 || size()<=n)
      throw exception("index out of range in operator[]");
    return data[n];
  }
  //----< global display of vector contents >------------------

  template <typename T>
    void show(const vec<T>& v, const std::string& name="")
  {
    cout << "\n  ";
    if(name.size() != 0)
      std::cout << "\n  " << name << "\n  ";
    for(int i=0; i<v.size(); ++i)
      std::cout << v[i] << " ";
  }
}
#endif