/* ========================================================================
 *
 *     Filename:  main.cpp
 *  Description:  matrix algorithms
 *       Author:  Diego A. Estrada Rivera
 *      Version:  0.0.1
 *
 * ======================================================================== */

#include <iostream>
auto println(auto x){
	std::cout << x << std::endl;
}
auto print(auto x){
	std::cout << x;
}

#include <bits/stdc++.h>
#define int uint64_t
#define var auto
#define fn auto
#define let auto const
using namespace std;
typedef size_t sz;
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef vector<pair<int, int>> vii;
typedef vector<vector<int>> vvi;
template <typename T>
using vec = std::vector<T>;

template<typename T>
struct Matrix{
	Matrix(sz r,sz c):data(vec<T>(r*c)),cols(c),rows(r){}

	fn operator[](sz i)->T&{
		return data[i];
	}

	fn operator[](sz r, sz c)->T&{
		return data[r*cols+c];
	}

	fn get_row(sz r)->vec<T>{
		var ret=vec<T>(cols);
		sz i=0;
		for(var&e:ret)e=data[rows*r+i],++i;
		return ret;
	}

	fn get_col(sz c)->vec<T>{
		var ret=vec<T>(rows);
		sz i=0;
		for(var&e:ret)e=data[cols*i+c],++i;
		return ret;
	}

	void print(){
		for(sz r=0;r<rows;++r) {
			for(sz c=0;c<cols;++c)
                cout<<data[r*cols+c]<<' ';
			cout << '\n';
		}
	}

	fn operator * (Matrix const& rhs) const noexcept -> Matrix;
//	fn operator*(Matrix const&rhs)->Matrix{
//		var out=Matrix(rhs.rows, cols);
//		for(sz i=0;i<cols;++i){
//			var r=get_row(i);
//			for(sz j=0; j<rhs.rows;++j){
//				var c=rhs.get_col(j);
//				var sum=inner_product(r.begin(),r.end(),c.begin(),0);
//				out[i,j]=sum;
//			}
//		}
//		return out;
//	}

	fn operator *= (Matrix const& rhs) noexcept -> Matrix&;
//	void operator*=(Matrix const&rhs){
//		for(sz i=0;i<cols;++i){
//			var sr=get_row(i);
//			for(sz j=0;j<rhs.rows;++j){
//				var sc=rhs.get_col(j);
//				var sum=inner_product(sr.begin(),sr.end(),sc.begin(),0);
//				(*this)[i,j]=sum;
//			}
//		}
//	}

	vec<T>data;
	sz cols;
	sz rows;
};

template <typename T>
fn Matrix<T>::operator * (Matrix<T> const& rhs) const noexcept -> Matrix {
	let lhs = *this;
	var out = lhs;
	out *= rhs;
	return out;
	out = Matrix(rhs.rows, lhs.rows);
	for (sz i = 0; i < lhs.cols; ++i) {
		var r = lhs.get_row(i);
		for (sz j = 0; j < rhs.rows; ++j) {
			var c = rhs.get_col(j);
			var sum = inner_product(r.cbegin(), r.cend(), c.cbegin(), 0);
			lhs[i, j] = sum;
		}
	}
	return out;
};

template <typename T>
fn Matrix<T>::operator *= (Matrix<T> const& rhs) noexcept -> Matrix& {
	var lhs = *this;
	for (sz i = 0; i < lhs.cols; ++i) {
		var r = rhs.get_row(i);
		for (sz j = 0; j < rhs.rows; ++j) {
			var c = rhs.get_col(j);
			var sum = inner_product(r.cbegin(), r.cend(), c.cbegin(), 0);
			lhs[i, j] = sum;
		}
	}
	return lhs;
}

auto main() -> int32_t
{
	auto m = Matrix(2, 2);
	m(0, 0) = 1;
	m(0, 1) = 1;
	m(1, 0) = 1;
	auto l = Matrix(2, 1);
	l(0, 0) = 0;
	l(1, 0) = 1;
	m.print();
	cout << endl;
	auto n = 10;
	while (n--) {
		m = m * m;
		m.print();
	}

	m.print();

	return 0;
}