using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication5
{
    public class SomeClass
    {
        public class Vector : IEnumerable, IEquatable<Vector>
        {
            public List<int> vector = new List<int>();
            public int this[int index]
            {
                set
                {
                    vector[index] = value;
                }

                get
                {
                    return vector[index];
                }
            }
            private class VectorEnum : IEnumerator
            {
                public List<int> vector;
                int position = -1;
                public VectorEnum(List<int> vector)
                {
                    this.vector = vector;
                }

                public bool MoveNext()
                {
                    position++;
                    return (position < vector.Count);
                }

                public void Reset()
                {
                    position = -1;
                }

                object IEnumerator.Current
                {
                    get { return Current; }
                }


                public int Current
                {
                    get { return vector[position]; }
                }
            }


            public IEnumerator GetEnumerator()
            {
                return new VectorEnum(vector);
            }


            public override String ToString()
            {
                return string.Join(",", vector.ToArray());

            }

            public Vector(params int[] values)
            {
                foreach (int a in values)
                {
                    vector.Add(a);
                }
            }

            public void Add(params int[] values)
            {
                foreach (int a in values)
                {
                    vector.Add(a);
                }
            }
            public int Count
            {
                get { return vector.Count; }
            }

            public bool Search(int a)
            {
                foreach (int value in vector)
                    if (value == a)
                        return true;
                return false;
            }
            public bool Equals(Vector a)
            {
                if (a.Count != this.Count)
                    return false;
                for (int i = 0; i < a.Count; i++)
                {
                    if (a[i] == this[i])
                        continue;
                    else
                        return false;
                }
                return true;
            }


        }

        public class Matrix : IEnumerable, IEquatable<Matrix>
        {
            List<Vector> matrix = new List<Vector>();
            public int Length
            {
                get;
                set;
            }
            public int Height
            {
                get
                {
                    return matrix.Count;
                }
            }
            public Vector this[int index]
            {
                set
                {
                    matrix[index] = value;
                }

                get
                {
                    return matrix[index];
                }
            }
            public int this[int index, int index2]
            {
                set
                {
                    matrix[index][index2] = value;
                }

                get
                {
                    return matrix[index][index2];
                }
            }
            public int Count
            {
                get { return matrix.Count; }
            }

            public Matrix(params Vector[] vectors)
            {
                try {
                    this.Length = vectors[0].Count;
                }
                catch {
                    this.Length = 0;
                }
                    foreach (Vector vector in vectors)
                        if (vector.Count == this.Length)
                            matrix.Add(vector);
                        else throw new ArgumentException("Matrix is not MxN");


            }

            public Matrix(int a, int b)
            {
                this.Length = a;
                for (int i = 0; i < a; i++)
                {
                    matrix.Add(new Vector());
                }
                for (int i = 0; i < a; i++)
                {
                    for (int j = 0; j < b; j++)
                    {
                        matrix[i].Add(0);
                    }
                }
            }

            public void Add(params Vector[] vectors)
            {

                foreach (Vector vector in vectors)
                {
                    if (vector.Count == this.Length)
                        matrix.Add(vector);
                    else
                        throw new ArgumentException("Vector length is greater or lesser than matrix length");
                }
            }

            public override String ToString()
            {
                String a = "";
                foreach (Vector vector in matrix)
                {
                    a = a + vector.ToString() + "\n";

                }
                return a;
            }
            public bool Search(Vector a)
            {
                int flag = 1;
                foreach (Vector b in matrix)
                {
                    if (a.Count != b.Count)
                        continue;
                    flag = 0;
                    for (int i = 0; i < a.Count; i++)
                    {
                        if (a[i] != b[i])
                            return false;
                        return true;
                    }
                }
                if (flag == 0)
                    return true;
                else
                    return false;
            }

            public bool Equals(Matrix a)
            {
                if (a.Count != this.Count)
                    return false;
                for (int i = 0; i < a.Count; i++)
                {
                    if (a[i].Equals(this[i]))
                        continue;
                    else
                        return false;
                }
                return true;
            }
            public bool isSquare()
            {
                if (this.Height == this.Length)
                    return true;
                return false;

            }
            public bool isEqualSize(Matrix a)
            {
                if ((this.Height == a.Height) && (this.Length == a.Length))
                    return true;
                return false;

            }
            public Matrix MultiplyByNumber(int a)
            {
                int vecCount = 0;
                Matrix rezult = new Matrix();
                foreach (Vector vec in matrix)
                {
                    rezult.Add(new Vector());
                    for (int i = 0; i < vec.Count; i++)
                        rezult[vecCount].Add(0);
                    for (int i = 0; i < vec.Count; i++)
                        rezult[vecCount][i] = a * vec[i];
                    vecCount += 1;
                }
                return rezult;
            }

            public Matrix AddMatrix(Matrix a)
            {
                Matrix rezult = new Matrix();
                int vecCount = 0;
                if (this.isEqualSize(a))
                {
                    foreach (Vector vec in matrix)
                    {
                        rezult.Add(new Vector());
                        for (int i = 0; i < vec.Count; i++)
                            rezult[vecCount].Add(0);
                        for (int i = 0; i < vec.Count; i++)
                            rezult[vecCount][i] = a[vecCount][i] + vec[i];
                        vecCount += 1;
                    }
                }
                else throw new ArgumentException("Matrices must have equal size");
                return rezult;
            }
            public Matrix MultiplyByMatrix(Matrix a)
            {
                Matrix rezult = new Matrix(this.Height, a.Length);
                if (this.Length == a.Height)
                {
                    int sum = 0;
                    for (int c = 0; c < this.Height; c++)
                    {
                        for (int d = 0; d < a.Length; d++)
                        {
                            for (int k = 0; k < a.Height; k++)
                            {
                                sum = sum + this[c][k] * a[k][d];
                            }

                            rezult[c][d] = sum;
                            sum = 0;
                        }
                    }
                    return rezult;
                }
                else throw new ArgumentException("Number of columns in M1 must be equal to the number of rows in D");
            }

            public Matrix Transpose()
            {
                int t;

                Matrix a = new Matrix(this.Length,this.Height);
                for (int c = 0; c < this.Height; c++)
                    for( int d = 0 ; d < this.Length ; d++ )
                         a[d][c] = matrix[c][d];

                return a;
            }

            public static Matrix operator *(Matrix mat, int num)
            {
                return mat.MultiplyByNumber(num);
            }
            public static Matrix operator *(Matrix mat, Matrix mat2)
            {
                return mat.MultiplyByMatrix(mat2);
            }
            public static Matrix operator +(Matrix mat, Matrix mat2)
            {
                return mat.AddMatrix(mat2);
            }

            private class MatrixEnum : IEnumerator
            {
                public List<Vector> matrix;
                int position = -1;
                public MatrixEnum(List<Vector> matrix)
                {
                    this.matrix = matrix;
                }
                public bool MoveNext()
                {
                    position++;
                    return (position < matrix.Count);
                }
                public void Reset()
                {
                    position = -1;
                }
                object IEnumerator.Current
                {
                    get { return Current; }
                }
                public Vector Current
                {
                    get { return matrix[position]; }
                }
            }
            public IEnumerator GetEnumerator()
            {
                return new MatrixEnum(matrix);
            }

        }
        public static int Main()
        {
            Matrix mat = new Matrix(
                new Vector(1, 2, 3),
                new Vector(4, 5, 6),
                new Vector(2, 3, 4));

            Console.WriteLine(mat);
            Console.WriteLine(mat + mat);
            Console.WriteLine(mat * 3);

            Matrix mat1 = new Matrix(
                new Vector(1, 2, 0),
                new Vector(3, 1, -1));
            Matrix mat2 = new Matrix(
                new Vector(1),
                new Vector(2),
                new Vector(3));

            Console.WriteLine(mat2.Transpose());
            Console.WriteLine(mat);

            Matrix mat3 = new Matrix(
                new Vector(1, 2),
                new Vector(3, 1));
            Console.WriteLine(mat3.isSquare());
            Console.WriteLine(mat1.isSquare());
            Console.WriteLine(mat3.Search(new Vector(1, 2)));
            Console.WriteLine(mat3.Search(new Vector(3)));

            Matrix mat4 = new Matrix(
                new Vector(1, 2),
                new Vector(3, 1));
            Console.WriteLine(mat3.Equals(mat4));
            Console.WriteLine(mat3.Equals(mat1));
            Console.ReadLine();
            return 0;
        }
    }
}