#include <iostream>
#include <boost\progress.hpp>

template <class Type, std::size_t Size>
class array_addition;

template <class Type, std::size_t Size>
class array_multiplication;

template <class Type, std::size_t Size>
class array_scalar_multiplication;


template <class Type, std::size_t Size>
class array
{
public:
	typedef Type* iterator;
	typedef Type value_type;

	array (const Type& arg = Type()) 
	{
		std::fill_n (&v_[0],Size,arg);
	}
	const std::size_t size (void) const { return Size; }

	Type& operator [] (std::size_t i) { return v_[i]; }	
	const Type operator [] (std::size_t i) const { return v_[i]; }

	array (const array_addition<Type,Size>& arg)
	{
		for (int i = 0; i < size(); ++i)
			v_[i] = arg[i];
	}
	array (const array_multiplication<Type,Size>& arg)
	{
		for (int i = 0; i < size(); ++i)
			v_[i] = arg[i];
	}
	array (const array_scalar_multiplication<Type,Size>& arg)
	{
		for (int i = 0; i < size(); ++i)
			v_[i] = arg[i];
	}
	
	iterator begin () { return v_; }
	iterator end () { return &v_[Size]; }
	
private:
	Type v_[Size];
};

template <class Type, std::size_t Size>
class array_addition
{
public:
	array_addition (const array<Type,Size>& a, const array<Type,Size>& b) : a_(a), b_(b) {}
	const Type operator [] (const std::size_t i) const { return a_[i] + b_[i]; }
private:
	const array<Type,Size>& a_;
	const array<Type,Size>& b_;
};

template <class Type, std::size_t Size>
class array_multiplication
{
public:
	array_multiplication (const array<Type,Size>& a, const array<Type,Size>& b) : a_(a), b_(b) {}
	const Type operator [] (std::size_t i) const { return a_[i] * b_[i]; }
private:
	const array<Type,Size>& a_;
	const array<Type,Size>& b_;
};

template <class Type, std::size_t Size>
class array_scalar_multiplication
{
public:
	array_scalar_multiplication (const array<Type,Size>& a, const Type& b) : a_(a), b_(b) {}
	const Type operator [] (std::size_t i) const { return a_[i] * b_; }
private:
	const array<Type,Size>& a_;
	const Type& b_;
};

template <class Type, std::size_t Size>
inline array<Type, Size> operator + (const array<Type,Size>& a, const array<Type,Size>& b)
{
	return array<Type,Size> (array_addition<Type,Size>(a,b));
}

template <class Type, std::size_t Size>
inline array<Type, Size> operator * (const array<Type,Size>& a, const array<Type,Size>& b)
{
	return array<Type,Size> (array_multiplication<Type,Size>(a,b));
}
template <class Type, std::size_t Size>
inline array<Type, Size> operator * (const array<Type,Size>& a, const Type& b)
{
	return array<Type,Size> (array_scalar_multiplication<Type,Size>(a,b));
}
template <class Type, std::size_t Size>
inline array<Type, Size> operator * (const Type& a, const array<Type,Size>& b)
{
	return array<Type,Size> (array_scalar_multiplication<Type,Size>(b,a));
}

int dummy_array[100][100];
int dummy_array2[100][100];

int main ()
{
	array<array<int,100>,100> d(10);
	array<array<int,100>,100> e(14);

	for (int i = 0; i < 100; ++i)
		for (int i2 = 0; i2 < 100; i2++)
	{
		dummy_array[i][i2] = 10;
		dummy_array2[i][i2] = 14;
	}

	{
		boost::progress_timer a;
		for (int i = 0; i < 1000; i++)
			d + e;
	}
	std::cout << "******" << std::endl;

	{
		boost::progress_timer b;
		for (int i3 = 0; i3 < 1000; i3++)
			for (int i = 0; i < 100; ++i)
				for (int i2 = 0; i2 < 100; i2++)
			{
				dummy_array[0][0] = dummy_array[i][i2] + dummy_array2[i][i2];
			}
	}
	
	
	return 0;
}