#ifndef MATRIX_H
#define MATRIX_H
///////////////////////////////////////////////////////////////
//  matrix.h - declares an nxm Dimensional matrix            //
//  Exam2:Q10                                                //
//  Jim Fawcett, CSE687 - Object Oriented Design, Spring 05  //
///////////////////////////////////////////////////////////////

#include <iostream>
#include <vector>
//
namespace Exam2
{
  /////////////////////////////////////////////////////
  // This is the required part of the answer

  template <typename T>
  class matrix
  {
  public:
    matrix(int m, int n, const T& t = T(0));
//  matrix(const matrix& m);                    // correct compiler generated
//  matrix<T>& operator=(const matrix<T>& m);   //    "        "       "
    T& operator()(int n, int m);                // m(1,2) = t;
    T operator()(int n, int m) const;           // t = m(3,1);
    matrix<T>& operator+=(const matrix<T>& m);  // m2 += m1;
    matrix<T>& operator-=(const matrix<T>& m);  // m2 -= m1;
    matrix<T>& operator*=(const T &t);          // m1 *= t;
    int rows() const { return data.size(); }
    int cols() const { return data[0].size(); }
  private:
    std::vector< std::vector<T> > data;
  };

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

  template <typename T>
  matrix<T> operator+(const matrix<T>& m1, const matrix<T>& m2);  // m3 = m1 + m2;
  template <typename T>
  matrix<T> operator-(const matrix<T>& m1, const matrix<T>& m2);  // m3 = m1 - m2;
  template <typename T>
  matrix<T> operator*(const matrix<T>& m1, const matrix<T>& m2);  // m3 = m1 * m2;
  template <typename T>
  matrix<T> operator*(const matrix<T>& m, const T& t);            // m2 = m1*t;
  template <typename T>
  matrix<T> operator*(const T& t, const matrix<T>& m);            // m2 = t*m1;

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

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

  template <typename T>
  void checkSize(const matrix<T>& m1, const matrix<T>& m2)
  {
    if(m1.rows() != m2.rows() || m1.cols() != m2.cols())
      throw exception("incompatible matrix sizes");
  }
  //---< construct vector with n elements >--------------------

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

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

  template <typename T>
  matrix<T> operator+(const matrix<T>& m1, const matrix<T>& m2)
  {
    checkSize(m1,m2);
    matrix<T> temp = m1;
    return (temp += m2);
  }
  //
  //----< subtractive assignment >-----------------------------

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

  template <typename T>
  matrix<T> operator-(const matrix<T>& m1, const matrix<T>& m2)
  {
    checkSize(m1,m2);
    matrix<T> temp = m1;
    return (temp -= m2);
  }
  //----< scalar multiplicative assignment >-------------------

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

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

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

  template <typename T>
  matrix<T> operator*(const matrix<T>& m1, const matrix<T>& m2)
  {
    if(m1.cols() != m2.rows())
      throw exception("matrices not comformable in multiplication");
    matrix<T> temp(m1.rows(),m2.cols());
    for(int i=0; i<m1.rows(); ++i)
    {
      T sum;
      for(int j=0; j<m2.cols(); ++j)
      {
        sum = T(0);
        for(int k=0; k<m1.cols(); ++k)
          sum += m1(i,k)*m2(k,j);
        temp(i,j) = sum;
      }
    }
    return temp;
  }
//
  //----< index operator >-------------------------------------

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

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

  template <typename T>
    void show(const matrix<T>& m, const std::string& name="")
  {
    std::cout << "\n  ";
    if(name.size() != 0)
      std::cout << "\n  " << name.c_str();
    for(int i=0; i<m.rows(); ++i)
    {
      std::cout << "\n  ";
      for(int j=0; j<m.cols(); ++j)
        std::cout << m(i,j) << " ";
    }
    std::cout << "\n";
  }
}
#endif