matrix csharp

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

namespace ConsoleApp2
{
    class Program
    {
        class Matrix
        {
            // Скрытые поля
            private int _n;
            private int[,] _mass;

            // Создаем конструкторы матрицы
            public Matrix() { }
            public int N
            {
                get { return _n; }
                set { if (value > 0) _n = value; }
            }

            // Задаем аксессоры для работы с полями вне класса Matrix
            public Matrix(int n)
            {
                this._n = n;
                _mass = new int[this._n, this._n];
            }

            public int this[int i, int j]
            {
                get
                {
                    return _mass[i, j];
                }
                set
                {
                    _mass[i, j] = value;
                }
            }

            // Ввод матрицы с клавиатуры
            public void Write()
            {
                for (int i = 0; i < _n; i++)
                {
                    for (int j = 0; j < _n; j++)
                    {
                        Console.WriteLine("Введите элемент матрицы {0}:{1}", i + 1, j + 1);
                        _mass[i, j] = Convert.ToInt32(Console.ReadLine());
                    }
                }
            }

            // Ввод матрицы рандомно
            public void WriteRand()
            {
                Random rnd = new Random(777);
                for (int i = 0; i < _n; i++)
                {
                    for (int j = 0; j < _n; j++)
                    {
                        _mass[i, j] = rnd.Next(0, 10);
                    }
                }
            }



            // Вывод матрицы с клавиатуры
            public void Print()
            {
                for (int i = 0; i < _n; i++)
                {
                    for (int j = 0; j < _n; j++)
                    {
                        Console.Write(_mass[i, j] + "\t");
                    }
                    Console.WriteLine();
                }
            }


            // Сложение элементов матрицы с числом
            public static Matrix addch(Matrix a, int ch)
            {
                Matrix resMass = new Matrix(a.N);
                for (int i = 0; i < a.N; i++)
                {
                    for (int j = 0; j < a.N; j++)
                    {
                        resMass[i, j] = a[i, j] + ch;
                    }
                }
                return resMass;
            }


            // Вычитание из матрицы числа
            public static Matrix subch(Matrix a, int ch)
            {
                Matrix resMass = new Matrix(a.N);
                for (int i = 0; i < a.N; i++)
                {
                    for (int j = 0; j < a.N; j++)
                    {
                        resMass[i, j] = a[i, j] - ch;
                    }
                }
                return resMass;
            }





            // Метод вычитания матрицы Б из матрицы А
            public static Matrix razn(Matrix a, Matrix b)
            {
                Matrix resMass = new Matrix(a.N);
                for (int i = 0; i < a.N; i++)
                {
                    for (int j = 0; j < b.N; j++)
                    {
                        resMass[i, j] = a[i, j] - b[i, j];
                    }
                }
                return resMass;
            }

            // транспонированная матрица
            public Matrix transpose()
            {
                Matrix resMass = new Matrix(N);
                for (int i = 0; i < N; i++)
                {
                    for (int j = 0; j < N; j++)
                    {
                        resMass[i, j] = _mass[j, i];
                    }
                }
                return resMass;
            }



            // Перегрузка оператора вычитания
            public static Matrix operator -(Matrix a, Matrix b)
            {
                return razn(a, b);
            }


            public static Matrix operator -(Matrix a, int b)
            {
                return subch(a, b);
            }

            public static Matrix Sum(Matrix a, Matrix b)
            {
                Matrix resMass = new Matrix(a.N);
                for (int i = 0; i < a.N; i++)
                {
                    for (int j = 0; j < b.N; j++)
                    {
                        resMass[i, j] = a[i, j] + b[i, j];
                    }
                }
                return resMass;
            }
            // Перегрузка сложения
            public static Matrix operator +(Matrix a, Matrix b)
            {
                return Sum(a, b);
            }

            public static Matrix operator +(Matrix a, int b)
            {
                return addch(a, b);
            }

            public static bool equals(Matrix a, Matrix b)
            {
                bool equals = true;
                for (int i = 0; i < a.N; i++)
                {
                    for (int j = 0; j < b.N; j++)
                    {
                        if (a[i, j] != b[i, j])
                        {
                            equals = false;
                            break;
                        }
                    }
                }
                return equals;
            }

            public static bool operator ==(Matrix a, Matrix b)
            {
                return equals(a,b);
            }

            public static bool operator !=(Matrix a, Matrix b)
            {
                return !equals(a, b);
            }

            // детерминант 2х2 матрицы
            public double Det2X2()
            {
                double det;
                det = _mass[0, 0] * _mass[1, 1] - _mass[0, 1] * _mass[1, 0];

                return det;
            }
            // Минор матрицы
            public Matrix Minor(int a, int b)
            {
                int i, j, p, q;
                Matrix MEN = new Matrix(_n - 1);
                for (j = 0, q = 0; q < MEN.N; j++, q++)
                for (i = 0, p = 0; p < MEN.N; i++, p++)
                {
                    if (i == a) i++;
                    if (j == b) j++;
                    MEN._mass[p, q] = _mass[i, j];
                }
                return MEN;
            }

            // Вычисление определителя

            public static double Det(Matrix a)
            {
                int n;
                int signo;
                double det = 0;
                if (a.N == 1)
                    return a._mass[0, 0];
                if (a.N == 2)
                {
                    return a.Det2X2();
                }
                else
                {
                    for (n = 0; n < a.N; n++)
                    {
                        if ((n & 1) == 0)
                        {
                            signo = 1;
                        }
                        else
                        {
                            signo = -1;
                        }

                        det += signo * a._mass[0, n] * Det(a.Minor(0, n));
                    }
                }


                return det;
            }




            // Деструктор Matrix
            ~Matrix()
            {
                Console.WriteLine("Очистка");
            }



            static void Main(string[] args)
            {
                Matrix mass1 = new Matrix(2);
                Matrix mass2 = new Matrix(2);
                Console.WriteLine("ввод Матрица А: ");
                mass1.Write();
                Console.WriteLine("ввод Матрица B: ");
                mass2.Write();
                Console.WriteLine("Матрица А: ");
                mass1.Print();
                Console.WriteLine("Матрица B: ");
                mass2.Print();
                Console.WriteLine("Равенство двух матриц");
                Console.WriteLine(mass1 == mass2);

                Console.WriteLine("Определитель М1 = {0}, M2 = {1}", Det(mass1), Det(mass2));
                Console.WriteLine("транспонированная матрица A");
                mass1.transpose().Print();
            }
        }
    }
}