// *** output commands inserted in the definition of *

#ifndef Matrix_
#define Matrix_

#include "xcept.h"

template<class T>
class Matrix {
   friend ostream& operator<<(ostream&, const Matrix<T>&);
// friend istream& operator>>(istream&, const Matrix<T>&);
   friend istream& operator>>(istream&,       Matrix<T>&); // *** hw 4; another way at end
   public:
      Matrix(int r = 0, int c = 0);
      Matrix(const Matrix<T>& m); // copy constructor
      ~Matrix() {delete [] element;}
      int Rows() const {return rows;}
      int Columns() const {return cols;}
      T& operator()(int i, int j) const;
      Matrix<T>& operator=(const Matrix<T>& m);
      Matrix<T> operator+() const; // unary +
      Matrix<T> operator+(const Matrix<T>& m) const;
      Matrix<T> operator-() const; // unary minus
      Matrix<T> operator-(const Matrix<T>& m) const;
      Matrix<T> operator*(const Matrix<T>& m) const;
      Matrix<T>& operator+=(const T& x);
   private:
       int rows, cols; // matrix dimensions
       T *element;     // element array
};  

template<class T>
Matrix<T>::Matrix(int r, int c)
{// Matrix constructor.
   // validate r and c
   if (r < 0 || c < 0) throw BadInitializers();
   if ((!r || !c) && (r || c))
   	throw BadInitializers();

   // create the matrix
   rows = r; cols = c;
   element = new T [r * c];
}

template<class T>
Matrix<T>::Matrix(const Matrix<T>& m)
{// Copy constructor for matrices.
   // create matrix
   rows = m.rows; cols = m.cols;
   element = new T [rows * cols];

   // copy each element of m
   for (int i = 0; i < rows * cols; i++)
      element[i] = m.element[i];
}

template<class T>
Matrix<T>& Matrix<T>::operator=(const Matrix<T>& m)
{// Assignment. (*this) = m.
   if (this != &m) {// do not copy to self
            delete [] element;
            rows = m.rows; cols = m.cols;
            element = new T [rows * cols];
            // copy each element
            for (int i = 0; i < rows * cols; i++)
               element[i] = m.element[i];
               }
   return *this;
}

template<class T>
T& Matrix<T>::operator()(int i, int j) const
{// Return a reference to element (i,j).
   if (i < 1 || i > rows || j < 1
             || j > cols) throw OutOfBounds();
   return element[(i - 1) * cols + j - 1];
}

template<class T>
Matrix<T> Matrix<T>::
          operator+(const Matrix<T>& m) const
{// Return w = (*this) + m.
   if (rows != m.rows || cols != m.cols)
      throw SizeMismatch();

   // create result matrix w
   Matrix<T> w(rows, cols);
   for (int i = 0; i < rows * cols; i++)
      w.element[i] = element[i] + m.element[i];

   return w;
}

template<class T>
Matrix<T> Matrix<T>::
          operator-(const Matrix<T>& m) const
{// Return (*this) - m.
   if (rows != m.rows || cols != m.cols)
      throw SizeMismatch();

   // create result matrix w
   Matrix<T> w(rows, cols);
   for (int i = 0; i < rows * cols; i++)
      w.element[i] = element[i] - m.element[i];

   return w;
}

template<class T>
Matrix<T> Matrix<T>::operator-() const
{// Return w = -(*this).

   // create result matrix w
   Matrix<T> w(rows, cols);
   for (int i = 0; i < rows * cols; i++)
      w.element[i] = -element[i];
   return w;

}

template<class T>
Matrix<T> Matrix<T>::
          operator*(const Matrix<T>& m) const
{// Matrix multiply.  Return w = (*this) * m.
   if (cols != m.rows) throw SizeMismatch();

   Matrix<T> w(rows, m.cols);  // result matrix

   // define cursors for *this, m, and w
   // and initialize to location of (1,1)
   int ct = 0, cm = 0, cw = 0;

// ************** output into a file
// File output just like standard i/o:

ofstream out("hw4.out");  // write
assert(out);

out << "A = " << endl;
out << *this << endl;
out << "B = " << endl;
out << m << endl;



   // compute w(i,j) for all i and j
   for (int i = 1; i <= rows; i++) {

      // compute row i of result
      for (int j = 1; j <= m.cols; j++) {
out << "ct = " << ct << "   cm = " << cm << endl;
         // compute first term of w(i,j)
         T sum =  element[ct] * m.element[cm];
         // add in remaining terms
         for (int k = 2; k <= cols; k++) {
            ct++;  // next term in row i of *this
            cm += m.cols;  // next in column j of m
            sum += element[ct] * m.element[cm];
            }
out << "ct = " << ct << "   cm = " << cm << "  sum = " << sum << endl;
out << endl;
         w.element[cw++] = sum;  // save w(i,j)

         // reset to start of row and next column
         ct -= cols - 1;
         cm = j;
         }

      // reset to start of next row and first column
      ct += cols;
      cm = 0;
      }
out << "W = A * B = " << endl;
out << w << endl;
   return w;
}

template<class T>
Matrix<T>& Matrix<T>::operator+=(const T& x)
{// Increment all elements of *this by x.
   for (int i = 0; i < rows * cols; i++)
       element[i] += x;
   return *this;
}

template<class T>
ostream& operator<<(ostream& out,
                    const Matrix<T>& x)
{// Put matrix x into the stream out.
 // One row per line.
   int k = 0;  // index into element array
   for (int i = 0; i < x.rows; i++) {

      // do row i
      for (int j = 0; j < x.cols; j++)
         out << x.element[k++] << "  ";

      // row i finished
      out << endl;}

   return out;
}

template<class T>
istream& operator>>(istream& in, Matrix<T>& x)         // memory for x allocated 
{// put matrix into stream in                          // through main()
    cout << "enter the next matrix rowwise" << endl;
    cout << "size of matrix is " << x.rows << " x " << x.cols << endl;
    for (int k=0; k <x.rows * x.cols; k++)
        in >> x.element[k];
    return in;
}

#endif


/******************************* another way to overload/implement operator >>
void Input(istream& in);  // declared within the class LowerMatrix


template<class T>
void Matrix<T>::Input(istream& in)
{
	cout<<"Enter the number of rows: ";
	in >> rows;
	cout<<"Enter the number of columns: ";
	in >> cols;

	if (rows <= 0 || cols <= 0)
		throw BadInitializers();

    element = new T [rows * cols];

	cout<<"Enter the elements one row at a time."<<endl;
	cout<<"w11 w12...w1n"<<endl;
	cout<<"w21 w22...w2n"<<endl;
	cout<<"wm1 wm2...wmn"<<endl;
	
	for (int i = 0; i < cols*rows; i++)
		in >> element[i];
}



template<class T>
istream& operator>>(istream& in, Matrix<T>& x)
{
	x.Input(in);
	return in;
}
*****************************************/