using System;
using System.Text;

class CustomMatrix<ELEM, MATRIX>
	where MATRIX : CustomMatrix<ELEM, MATRIX>
{
	public readonly uint sizeY, sizeX;
	public readonly ELEM[,] data;

	protected CustomMatrix(uint sizeY, uint sizeX)
	{
		this.sizeY = sizeY;
		this.sizeX = sizeX;
		data = new ELEM[sizeY, sizeX];
	}

	protected CustomMatrix(uint sizeY, uint sizeX, Func<uint, uint, ELEM> get) :
		this(sizeY, sizeX)
	{
		for (uint y = 0; y < sizeY; y++)
			for (uint x = 0; x < sizeX; x++)
				data[y, x] = get(y, x);
	}

	public MATRIX Transpose()
	{
		Func<uint, uint, ELEM> transposer = (y, x) => data[x, y];
		return (MATRIX)Activator.CreateInstance(
			typeof(MATRIX), new object[]{ sizeX, sizeY, transposer });
	}

	public ELEM this[uint y, uint x]
	{
		get { return data[y, x]; }
		set { data[y, x] = value; }
	}

	public override string ToString()
	{
		var sb = new StringBuilder();
		for (uint y = 0; y < sizeY; y++)
		{
			if (y > 0) sb.Append("\n");
			for (uint x = 0; x < sizeX; x++)
			{
				if (x > 0) sb.Append("  ");
				sb.Append(data[y, x]);
			}
		}
		return sb.ToString();
	}
}

class Matrix<ELEM> : CustomMatrix<ELEM, Matrix<ELEM>>
{
	public Matrix(uint sizeY, uint sizeX) : base(sizeY, sizeX) { }
	public Matrix(uint sizeY, uint sizeX, Func<uint, uint, ELEM> get) : base(sizeY, sizeX, get) { }

	public static explicit operator SquareMatrix<ELEM>(Matrix<ELEM> m)
	{
		return new SquareMatrix<ELEM>(m.sizeY, m.sizeX, (y, x) => m[y, x]);
	}
}

class SquareMatrix<ELEM> : CustomMatrix<ELEM, SquareMatrix<ELEM>>
{
	public SquareMatrix(uint size) : base(size, size) { }
	public SquareMatrix(uint size, Func<uint, uint, ELEM> get) : base(size, size, get) { }
	public SquareMatrix(uint sizeY, uint sizeX, Func<uint, uint, ELEM> get) : base(sizeY, sizeX, get)
	{
		if (sizeY != sizeX) throw new ArgumentException(string.Format("SquareMatrix не может быть размера {0}×{1}.", sizeY, sizeX));
	}

	public static explicit operator Matrix<ELEM>(SquareMatrix<ELEM> m)
	{
		return new Matrix<ELEM>(m.sizeY, m.sizeX, (y, x) => m[y, x]);
	}
}

public class MainClass
{
	public static void Main()
	{
		Matrix<double> m = new Matrix<double>(3, 5, (y, x) => 2*y + x);
		Console.WriteLine("m: Matrix =\n{0}", m);

		Matrix<double> m_t = m.Transpose();
		Console.WriteLine("\nm.Transpose() =\n{0}", m_t);

		string m_as_sm_s;
		try
		{
			m_as_sm_s = ((SquareMatrix<double>)m).ToString();
		} catch (ArgumentException e)
		{
			m_as_sm_s = e.Message;
		}
		Console.WriteLine("\n(SquareMatrix) m =\n{0}", m_as_sm_s);

		SquareMatrix<double> sm = new SquareMatrix<double>(5, (y, x) => 5 + (int)x - (int)y);
		Console.WriteLine("\nsm: SquareMatrix =\n{0}", sm);

		SquareMatrix<double> sm_t = sm.Transpose();
		Console.WriteLine("\nsm.Transpose() =\n{0}", sm_t);

		Matrix<double> sm_as_m = (Matrix<double>)sm;
		Console.WriteLine("\n(Matrix) sm =\n{0}", sm_as_m);

		SquareMatrix<double> sm_as_m_as_sm = (SquareMatrix<double>)sm_as_m;
		Console.WriteLine("\n(SquareMatrix) (Matrix) sm =\n{0}", sm_as_m_as_sm);
	}
}