#ifndef MAT_H
#define MAT_H
//
//  mat.h - base class for dense and sparse matrices
//
//  Note that operator+ must return a matrix by value, but
//  dense matrices and sparse matrices are not the same size.
//  So mat::operator+ can't simply return a mat.  It must 
//  defer specifying the return type until we know what will
//  be returned.

#pragma warning(disable : 4786)
#include <iostream>
#include <vector>
#include <list>
//
//  T - type of data in matrix, usually double
//  U - type of matrix returned by operator+
//      depends on the type of the operational 
//      derived class
//
template <class T, class U> class mat {

  public:
    
    // constructors go here
    
    virtual U operator+(const U &v)=0;
    
    // lots of other stuff go here

};

//----< dense matrix is vector of vectors >--------------------

template <class T> class dMat : public mat<T,dMat> {

  public:
    virtual dMat<T> operator+(const dMat &dm);

  protected:
    std::vector< std::vector<T*> > array;
};

//----< addition >---------------------------------------------

template <class T> dMat<T> dMat<T>::operator+(const dMat<T> &dm) {

  std::cout << "\n  invoking dense matrix addition\n\n";
  dMat<T> sum;
  return sum;
}

//

//----< sparse matrix is list of lists >-----------------------

template <class T> class sMat : public mat<T,sMat> {

  public:
    virtual sMat<T> operator+(const sMat &sm);

  protected:
    std::list< std::list<T> > adjacList;
};

//----< addition >---------------------------------------------

template <class T> sMat<T> sMat<T>::operator+(const sMat<T> &dm) {

  std::cout << "\n  invoking sparse matrix addition\n\n";
  sMat<T> sum;
  return sum;
}


#endif