//clang
/* A simple matrix package to illustrate some C++11 features
 *
 * Everything is in the same file to make it simpler for the lecture.
 * However, clearly this is not good coding practice.
 * Furthermore, I've placed "using namespace std" at the top, and
 * you definitely don't want to do this in a header file
 */

#include <vector>
#include <array>
#include <iostream>

using namespace std;

template<int M, int N, typename D=double>
class simpmat {
public:
	D &operator()(int i, int j) {
		return data[i][j];
	}
	D operator()(int i, int j) const {
		return data[i][j];
	}

	D max() const {
		auto first = true;
		D ret;
		for(auto i : data)
			for(auto j : i)
				if (first || ret<j) {
					ret = j;
					first = false;
				}
		return ret;
	}
	
private:
	array<array<D,N>,M> data;
};

template<int M, int N, int P,typename D, typename D2>
auto operator*(const simpmat<M,N,D> &x1, const simpmat<N,P,D2> &x2) 
			-> simpmat<M,P,decltype(x1(0,0)*x2(0,0) + x1(0,0)*x2(0,0))> {
	// an MxN matrix times a NxP matrix produces a MxP matrix
	// code placed here for simplicity
	// not the most efficient algorithm for cache hits, etc.
	// just for illustration!
	typedef decltype(x1(0,0)*x2(0,0) + x1(0,0)*x2(0,0)) Dret;
	
	simpmat<M,P,Dret> ret;
	for(int i=0;i<M;i++) for(int j=0;j<P;j++) {
		ret(i,j) = Dret();
		for(int k=0;k<N;k++) ret(i,j) += x1(i,k) * x2(k,j);
	}
	return ret;
}


template<int M,int N,typename D>
void printmat(const simpmat<M,N,D> &m, ostream &os) {
	for(int i=0;i<M;i++) {
		for(int j=0;j<N;j++) 
			os << m(i,j) << ' ';
		os << endl;
	}
	os << "max value: " << m.max() << endl;
}

string operator*(const string &s, int i) {
	string ret;
	for(;i>0;--i) ret += s;
	return ret;
}

simpmat<1,1,double> operator"" _mat(long double val) {
	simpmat<1,1,double> ret;
	ret(0,0) = val;
	return ret;
}
	
int main(int arg, char **argv) {
	auto m = 4.5_mat;
	auto m2 = 2.0_mat;

	printmat(m*m2,cout);
	return 0;
}