#include <vector>
#include <functional>

#ifndef WHOOM
#define WHOOM

template<class T>
class Matrix;

template<class T>
Matrix<T> operator* (Matrix<T> const& left, Matrix<T> const& right);
template<class T>
Matrix<T> operator+ (Matrix<T> const& left, Matrix<T> const& right);
template<class T>
Matrix<T>&& operator+ (Matrix<T>&& left, Matrix<T> const& right);
template<class T>
Matrix<T> operator- (Matrix<T> const& left, Matrix<T> const& right);
template<class T>
Matrix<T>&& operator- (Matrix<T>&& left, Matrix<T> const& right);
template<class T>
Matrix<T> operator* (Matrix<T> const& left, T const& right);
template<class T>
Matrix<T>&& operator* (Matrix<T>&& left, T const& right);
template<class T>
Matrix<T> operator/ (Matrix<T> const& left, T const& right);
template<class T>
Matrix<T>&& operator/ (Matrix<T>&& left, T const& right);


template<class T>
class Matrix
{
  std::vector<T> data;
  unsigned int siz;

public:
  Matrix(unsigned int N)
  {
    this->data = std::vector<T>(N*N,
			 static_cast<T>(0));
    this->siz = N;
  }
  
  Matrix(Matrix<T> const& cpy)
  {
    siz = cpy.siz;
    data = cpy.data;
  }
  
  Matrix(Matrix<T>&& mv)
  {
    siz = mv.siz;
    std::swap(data, mv.data);
  }
  
  Matrix(std::function<T(unsigned int)> f, unsigned int N)
  {
    data = std::vector<T>(N*N);
    siz = N;
    for(unsigned int k=0; k < (N*N); k++)
      {
	data[k] = f(k);
      }
  }

  Matrix(std::function<T(unsigned int, unsigned int)> f, unsigned int N)
  {
    data = std::vector<T>(N*N);
    siz = N;
    for(unsigned int k = 0; k < N; k++)
      {
	for(unsigned int l = 0; l < N; l++)
	  {
	    data[k + N * l] = f(k, l);
	  }
      }
  }
  
  Matrix<T>& operator=(Matrix<T> const& cpy);
  Matrix<T>&& operator=(Matrix<T>&& mv);
  
  //~Matrix();
  
  
  T& operator[](int index)
  {
    return data[index];
  }
  T const& operator[](int index) const
  {
    return data[index];
  }
  
  T& operator()(unsigned int x, unsigned int y)
  {
    return data[x + this->siz * y];
  }
  T operator()(unsigned int x, unsigned int y) const
  {
    return data[x + this->siz * y];
  }

  unsigned int size() const
  {
    return siz;
  }
  
  friend Matrix operator* <>(Matrix const& left, Matrix const& right);
    
  friend Matrix operator+ <>(Matrix const& left, Matrix const& right);
  friend Matrix&& operator+ <>(Matrix&& left, Matrix const& right);
  Matrix<T>& operator+=(const Matrix<T>&);
  
  friend Matrix operator- <>(Matrix const& left, Matrix const& right);
  friend Matrix&& operator- <>(Matrix&& left, Matrix const& right);
  Matrix<T>& operator-=(const Matrix<T>&);

  // scalar products
  friend Matrix operator* <>(Matrix const& left, T const& right);
  friend Matrix&& operator* <>(Matrix&& left, T const& right);
  Matrix<T>& operator*=(T const&);
  
  friend Matrix operator/ <>(Matrix const& left, T const& right);
  friend Matrix&& operator/ <>(Matrix&& left, T const& right);
  Matrix<T>& operator/=(T const&);

};
#endif