Rinat_lovi

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

namespace Zharkova_OOP_1
{
    class Matrix
    {
        private double[,] array;
        private int array_str;
        private int array_stolb;

        public Matrix(int i, int j) // инициализация и ввод матрицы
        {
            array_str = i;
            array_stolb = j;
            array = new double[i, j];

            Console.WriteLine("Введине значения для матрицы " + i + "x" + j);
            for (i = 0; i < array_str; i++)
            {
                for (j = 0; j < array_stolb; j++)
                {
                    array[i, j] = Double.Parse(Console.ReadLine());
                }
            }
        }
        public Matrix(int i, int j, bool flag) // инициализация нулевой матрицы
        {
            array_str = i;
            array_stolb = j;
            array = new double[i, j];

            for (i = 0; i < array_str; i++)
            {
                for (j = 0; j < array_stolb; j++)
                {
                    array[i, j] = 0;
                }
            }
        }
        // перегрузка операторов
        #region
        public double Determinant(Matrix op2)//Нахождение определителя матрицы
        {
            double sum = 0;
            int flag = 1;
            for (int j = 0; j < op2.array_stolb; j++)
            {
                sum += op2.array[0, j] * Opredelit(op2.array, 0, j, op2.array_stolb) * flag;
                flag *= -1;
            }
            if (sum == 0)
                throw new Exception("Определитель матрицы равен 0 , найти обратную матрицу невозможно");
            return sum;
        }
        public double Opredelit(double[,] array, int error_i, int error_j, int n)//Нахождение определителя подматрицы
        {
            double answer = 0;
            double[,] array_ans = new double[n - 1, n - 1];
            int k = 0;
            int m = 0;

            for (int i = 0; i < n; i++)
            {
                if (i == error_i)
                    continue;
                for (int j = 0; j < n; j++)
                {
                    if (j == error_j)
                        continue;
                    array_ans[m, k++] = array[i, j];
                }
                k = 0;
                m++;
            }
            double sum1 = 1;
            double sum2 = 1;

            if (n - 2 == 0)
            {
                answer = array_ans[0, 0];
            }
            else
            {
                for (int i = n - 1 - 1, j = 0; i > -1; i--, j++)
                {
                    sum1 *= array_ans[i, i];
                    sum2 *= array_ans[j, i];
                }
                answer = sum1 - sum2;
            }
            return answer;
        }
        public double Morma(Matrix op1)//Нахождение Нормы матрицы
        {
            double sum = 0;
            for (int i = 0; i < op1.array_str; i++)
            {
                for (int j = i + 1; j < op1.array_stolb; j++)
                {
                    sum += Math.Pow(op1.array[i, j], 2);
                }
            }
            return Math.Sqrt(sum);
        }
        public Matrix Obr_matrix(Matrix op1)//Нахождение обратной матрицы
        {
            Matrix result = new Matrix(op1.array_str, op1.array_stolb, true);
            double sum = 0;
            int flag = 1;

            //Находим определитель
            try
            {
                sum = Determinant(op1);
            }
            catch(Exception e)
            {
                throw e;
            }
            Console.WriteLine("Obrata9 matrica = " + sum);
            //матрица алгебраических дополнений
            for (int i = 0; i < op1.array_str; i++)
            {
                if (i % 2 == 0)
                    flag = 1;
                else
                    flag = -1;
                for (int j = 0; j < op1.array_stolb; j++)
                {
                    result.array[i, j] = Opredelit(op1.array, i, j, op1.array_stolb) * flag;
                    flag *= -1;
                }
            }
            Console.WriteLine("Матрица алгебраических дорполнений");
            op1.Print();
            //транспонированная матрица алгебраических дополнений
            double buf;
            for (int i = 0; i < op1.array_str; i++)
            {
                for (int j = i + 1; j < op1.array_stolb; j++)
                {
                    buf = result.array[i, j];
                    result.array[i, j] = result.array[j, i];
                    result.array[j, i] = buf;
                }
            }
            Console.WriteLine(" транспонированная Матрица алгебраических дорполнений");
            op1.Print();
            result = result * (1 / sum);
            return result;

        }
        public Matrix Transonir(Matrix op1)// нахождение Транспонированная матрицы
        {
            Matrix result = new Matrix(op1.array_str, op1.array_stolb, true);
            double buf;
            for (int i = 0; i < op1.array_str; i++)
            {
                for (int j = 0; j < op1.array_stolb; j++)
                {
                    result.array[j, i] = op1.array[i, j];
                }
            }
            return result;
        }

        public static Matrix operator +(Matrix op1, Matrix op2) // перегрузка оператора сложение
        {
            Matrix result = new Matrix(op1.array_str, op1.array_stolb, true);

            for (int i = 0; i < op1.array_str; i++)
            {
                for (int j = 0; j < op1.array_stolb; j++)
                {
                    result.array[i, j] = op1.array[i, j] + op2.array[i, j];
                }
            }
            return result;
        }
        public static Matrix operator -(Matrix op1, Matrix op2) // перегрузка оператора вычитания
        {
            Matrix result = new Matrix(op1.array_str, op1.array_stolb, true);

            for (int i = 0; i < op1.array_str; i++)
            {
                for (int j = 0; j < op1.array_stolb; j++)
                {
                    result.array[i, j] = op1.array[i, j] - op2.array[i, j];
                }
            }
            return result;
        }
        public static Matrix operator *(Matrix op1, Matrix op2) // перегрузка оператора умножения
        {
            Matrix result = new Matrix(op1.array_str, op2.array_stolb, true);
            result.Print();
            double sum = 0;
            if (op1.array_stolb != op2.array_str)
                throw new Exception("Нельзя умножить матрицы");
            for (int i = 0; i < op1.array_str; i++)
            {
                for (int k = 0; k < op2.array_stolb; k++)
                {
                    for (int j = 0; j < op2.array_str; j++)
                    {
                        sum += op1.array[i, j] * op2.array[j, k];
                        Console.WriteLine("Summa" + sum);
                    }
                    result.array[i, k] = sum;
                    sum = 0;
                }
            }
            return result;
        }
        public static Matrix operator *(Matrix op1, double op2) // перегрузка оператора умножения с числом
        {
            Matrix result = new Matrix(op1.array_str, op1.array_stolb, true);

            for (int i = 0; i < op1.array_str; i++)
            {
                for (int k = 0; k < op1.array_stolb; k++)
                {
                    result.array[i, k] = op1.array[i, k] * op2;
                }
            }
            return result;
        }
        public static Matrix operator /(Matrix op1, Matrix op2) // перегрузка оператора деления
        {
            Matrix result = new Matrix(op1.array_str, op1.array_stolb, true);
            if (op1.array_str != op1.array_stolb || op1.array_stolb != op2.array_stolb || op2.array_str != op2.array_stolb)
                throw new Exception("Невозможно умножить эти матрицы так-как они не подходящих размеров");

            result = result.Obr_matrix(op2);//Нахождение обратной матрицы
            result *= op1;
            return result;
        }
        public static Matrix operator /(Matrix op1, double op2) // перегрузка оператора деления с числом
        {
            Matrix result = new Matrix(op1.array_str, op1.array_stolb, true);

            for (int i = 0; i < op1.array_str; i++)
            {
                for (int k = 0; k < op1.array_stolb; k++)
                {
                    result.array[i, k] = op1.array[i, k] * 1 / op2;
                }
            }
            return result;
        }
        public static bool operator >(Matrix op1, Matrix op2) // перегрузка оператора сравнения >
        {
            Matrix result = new Matrix(op1.array_str, op1.array_stolb, true);

            bool flag = true;
            for (int i = 0; flag && i < op1.array_str; i++)
            {
                for (int j = 0; flag && j < op1.array_stolb; j++)
                {
                    if (op1.array[i, j] > op2.array[i, j])
                        continue;
                    else
                        return (flag = false);
                }
            }
            return flag;
        }
        public static bool operator <(Matrix op1, Matrix op2) // перегрузка оператора сравнения <
        {
            Matrix result = new Matrix(op1.array_str, op1.array_stolb, true);

            bool flag = true;
            for (int i = 0; flag && i < op1.array_str; i++)
            {
                for (int j = 0; flag && j < op1.array_stolb; j++)
                {
                    if (op1.array[i, j] < op2.array[i, j])
                        continue;
                    else
                        return (flag = false);
                }
            }
            return flag;
        }
        public static bool operator ==(Matrix op1, Matrix op2) // перегрузка оператора сравнения <
        {
            Matrix result = new Matrix(op1.array_str, op1.array_stolb, true);

            bool flag = true;
            for (int i = 0; flag && i < op1.array_str; i++)
            {
                for (int j = 0; flag && j < op1.array_stolb; j++)
                {
                    if (op1.array[i, j] != op2.array[i, j])
                        return false;
                }
            }
            return flag;
        }
        public static bool operator !=(Matrix op1, Matrix op2) // перегрузка оператора сравнения <
        {
            Matrix result = new Matrix(op1.array_str, op1.array_stolb, true);

            bool flag = true;
            for (int i = 0; flag && i < op1.array_str; i++)
            {
                for (int j = 0; flag && j < op1.array_stolb; j++)
                {
                    if (op1.array[i, j] == op2.array[i, j])
                        return  false;
                }
            }
            return flag;
        }
        public static Matrix operator ^(Matrix op1, int degree)//перегрузка оператора степени ^
        {
            Matrix result = new Matrix(op1.array_str, op1.array_stolb, true);
            result = result + op1;
            int i = 1;
            while (i < degree)
            {
                result = result * op1;
                i++;
            }
            return result;
        }
        #endregion
        public void Print() // вывод матрицы на экран
        {
            for (int i = 0; i < array_str; i++)
            {
                for (int j = 0; j < array_stolb; j++)
                {
                    Console.Write(array[i, j] + "\t");
                }
                Console.WriteLine();
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            List<Matrix> list_matrix = new List<Matrix>();
            bool flag = true;
            while (flag)
            {
                Console.WriteLine("Выберите вариант работы с матрицей :\n1=Работа с одной матрицей \n2=Работа с двумя матрицами ");
                Console.WriteLine("Введите 0 чтобы выйти");

                int flag_ = int.Parse(Console.ReadLine());
                if (flag_ == 1)
                {
                    while (flag)
                    {
                        Console.WriteLine("Введите 1 чтобы добавить матрицу");
                        Console.WriteLine("Введите 2 чтобы вывести матрицы");
                        Console.WriteLine("Введите 3 чтобы вывести обратную матрицу");
                        Console.WriteLine("Введите 4 чтобы вывести транспонированную матрицу");
                        Console.WriteLine("Введите 5 чтобы возвести матрицу в степень");
                        Console.WriteLine("Введите 0 чтобы вернуться назад");
                        flag_ = int.Parse(Console.ReadLine());
                        //вызов действий
                        #region
                        if (flag_ == 0)
                            flag = false;
                        if (flag_ == 1)
                        {
                            Console.WriteLine("Введите колличество строк в матрице ");
                            int i = int.Parse(Console.ReadLine());
                            Console.WriteLine("Введите колличество столбцов в матрице ");
                            int j = int.Parse(Console.ReadLine());
                            list_matrix.Add(new Matrix(i, j));
                        }
                        if (flag_ == 2)
                        {
                            if (list_matrix.Count == 0)
                            {
                                Console.WriteLine("Пожалуйста, добавьте матрицу прежде чем выводить.\n");
                            }
                            else
                            {
                                for (int i = 0; i < list_matrix.Count; i++)
                                {
                                    Console.WriteLine("Матрица номер " + (i + 1));
                                    list_matrix[i].Print();
                                    Console.WriteLine();
                                }
                            }
                        }
                        if (flag_ == 3)
                        {
                            Console.WriteLine("Выберите номер матрицы для данной операции");
                            int matr = int.Parse(Console.ReadLine());
                            try
                            {
                                (list_matrix[matr - 1].Obr_matrix(list_matrix[matr - 1])).Print();
                            }
                            catch(Exception e)
                            {
                                Console.WriteLine("Для данной матрицы невозможно выполнить это действие\n");
                                flag = false;
                            }
                        }
                        if (flag_ == 4)
                        {
                            Console.WriteLine("Выберите номер матрицы для данной операции");
                            int matr = int.Parse(Console.ReadLine());
                            (list_matrix[matr - 1].Transonir(list_matrix[matr - 1])).Print();
                        }
                        if (flag_ == 5)
                        {
                            Console.WriteLine("Выберите номер матрицы для данной операции");
                            int matr = int.Parse(Console.ReadLine());
                            Console.WriteLine("Введите в какую степень возвести матирцу");
                            int stepen = int.Parse(Console.ReadLine());
                            (list_matrix[matr - 1] ^ stepen).Print();
                        }
                        #endregion
                    }
                    flag = true;
                }
                else if (flag_ == 2)
                {
                    while (flag)
                    {
                        Console.WriteLine("Введите 1 чтобы добавить матрицу");
                        Console.WriteLine("Введите 2 чтобы вывести матрицы");
                        Console.WriteLine("Введите 3 чтобы сложить 2 матрицы");
                        Console.WriteLine("Введите 4 чтобы умножить 2 матрицы");
                        Console.WriteLine("Введите 5 чтобы поделить 2 матрицы");
                        Console.WriteLine("Введите 6 чтобы вычесть 2 матрицы");
                        Console.WriteLine("Введите 7 чтобы сравнить 2 матрицы");
                        Console.WriteLine("Введите 0 чтобы вернуться назад");
                        flag_ = int.Parse(Console.ReadLine());
                        //вызов действий
                        #region
                        if (flag_ == 0)
                            flag = false;
                        if (flag_ == 1)
                        {
                            Console.WriteLine("Введите колличество строк в матрице ");
                            int i = int.Parse(Console.ReadLine());
                            Console.WriteLine("Введите колличество столбцов в матрице ");
                            int j = int.Parse(Console.ReadLine());
                            list_matrix.Add(new Matrix(i, j));
                        }

                        if (flag_ == 2)
                        {
                            if (list_matrix.Count == 0)
                            {
                                Console.WriteLine("Пожалуйста, добавьте матрицу прежде чем выводить.\n");
                            }
                            else
                            {
                                for (int i = 0; i < list_matrix.Count; i++)
                                {
                                    Console.WriteLine("Матрица номер " + (i + 1));
                                    list_matrix[i].Print();
                                    Console.WriteLine();
                                }
                            }
                        }
                        if (flag_ == 3)
                        {
                            Console.WriteLine("Выберите матрицы для данной операции\n матрица 1 :");
                            int matr1 = int.Parse(Console.ReadLine());
                            Console.WriteLine("матрица 2 :");
                            int matr2 = int.Parse(Console.ReadLine());
                            Console.WriteLine("Сложение");
                            (list_matrix[matr1 - 1] + list_matrix[matr2 - 1]).Print();
                        }
                        if (flag_ == 4)
                        {
                            Console.WriteLine("Выберите матрицы для данной операции\n матрица 1 :");
                            int matr1 = int.Parse(Console.ReadLine());
                            Console.WriteLine("матрица 2 :");
                            int matr2 = int.Parse(Console.ReadLine());
                            try
                            {
                                Console.WriteLine("Умножение");
                                (list_matrix[matr1 - 1] * list_matrix[matr2 - 1]).Print();
                            }
                            catch (Exception e)
                            {
                                Console.WriteLine(e.Message);
                            }
                        }
                        if (flag_ == 5)
                        {
                            Console.WriteLine("Выберите матрицы для данной операции\n матрица 1 :");
                            int matr1 = int.Parse(Console.ReadLine());
                            Console.WriteLine("матрица 2 :");
                            int matr2 = int.Parse(Console.ReadLine());
                            try
                            {
                                Console.WriteLine("Деление");
                                (list_matrix[matr1 - 1] / list_matrix[matr2 - 1]).Print();
                            }
                            catch (Exception e)
                            {
                                Console.WriteLine(e.Message);
                            }
                        }
                        if (flag_ == 6)
                        {
                            Console.WriteLine("Выберите матрицы для данной операции\n матрица 1 :");
                            int matr1 = int.Parse(Console.ReadLine());
                            Console.WriteLine("матрица 2 :");
                            int matr2 = int.Parse(Console.ReadLine());
                            Console.WriteLine("Разность");
                            (list_matrix[matr1 - 1] - list_matrix[matr2 - 1]).Print();
                        }
                        if (flag_ == 7)
                        {
                            Console.WriteLine("Выберите матрицы для данной операции\n матрица 1 :");
                            int matr1 = int.Parse(Console.ReadLine());
                            Console.WriteLine("матрица 2 :");
                            int matr2 = int.Parse(Console.ReadLine());
                            Console.WriteLine("Сравнение");
                            if (list_matrix[matr1 - 1] > list_matrix[matr2 - 1])
                                Console.WriteLine("Матрица " + matr1 + " больше чем матрица" + matr2);
                            else if (list_matrix[matr1 - 1] < list_matrix[matr2 - 1])
                                Console.WriteLine("Матрица " + matr1 + " меньше чем матрица" + matr2);
                            else if (list_matrix[matr1 - 1] == list_matrix[matr2 - 1])
                                Console.WriteLine("Матрица " + matr1 + " равна матрице " + matr2);
                            else
                                Console.WriteLine("Матрица " + matr1 + " не  равна матрице " + matr2);
                        }
                        #endregion
                    }
                    flag = true;
                }
                else
                    flag = false;
            }
        }
    }
}