Задание 1. Жерновой. Матрица

using System;

public class Matrix
{
    private int rows;
    private int columns;
    private double[,] elements;

    public int Rows
    {
        get { return rows; }
    }

    public int Columns
    {
        get { return columns; }
    }

    public Matrix(int rows, int columns)
    {
        this.rows = rows;
        this.columns = columns;
        this.elements = new double[rows, columns];
    }

    ~Matrix()
    {
        // Деструктор
    }
    // Свойство для получения количества строк матрицы
    public int RowsS
    {
        get { return rows; }
        set
        {
            if (value <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(value), "Количество строк должно быть больше нуля.");
            }

            rows = value;
            ResizeMatrix();
        }
    }
    // Свойство для получения количества столбцов матрицы
    public int ColumnsS
    {
        get { return columns; }
        set
        {
            if (value <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(value), "Количество столбцов должно быть больше нуля.");
            }

            columns = value;
            ResizeMatrix();
        }
    }
     // Приватный метод для изменения размера матрицы
     private void ResizeMatrix()
    {
        // Создание нового двумерного массива нужного размера
        double[,] newElements = new double[rows, columns];
        
        // Вычисление минимального значения для количества строк и столбцов
        int minRows = Math.Min(rows, elements.GetLength(0));
        int minColumns = Math.Min(columns, elements.GetLength(1));
          // Копирование элементов из старой матрицы в новую
        for (int i = 0; i < minRows; i++)
        {
            for (int j = 0; j < minColumns; j++)
            {
                newElements[i, j] = elements[i, j];
            }
        }
        // Присваивание новой матрицы переменной elements
        elements = newElements;
    }
    
    public void SetElement(int rowIndex, int columnIndex, double value)
    {
        if (rowIndex < 0 || rowIndex >= rows)
        {
            throw new ArgumentOutOfRangeException(nameof(rowIndex));
        }

        if (columnIndex < 0 || columnIndex >= columns)
        {
            throw new ArgumentOutOfRangeException(nameof(columnIndex));
        }

        elements[rowIndex, columnIndex] = value;
    }
    
    public void PrintMatrix()
    {
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < columns; j++)
            {
                Console.Write(elements[i, j] + " ");
            }
            Console.WriteLine();
        }
    }

    public double CalculateDeterminant()
    {
        if (rows != columns)
        {
            throw new InvalidOperationException("Матрица должна быть квадратной.");
        }

        // Реализация вычисления определителя
        if (rows == 1)
        {
            return elements[0, 0];
        }
        else if (rows == 2)
        {
            return elements[0, 0] * elements[1, 1] - elements[0, 1] * elements[1, 0];
        }
        else
        {
            double determinant = 0;
            for (int i = 0; i < columns; i++)
            {
                determinant += elements[0, i] * GetCofactor(0, i).CalculateDeterminant() * Math.Pow(-1, i);
            }
            return determinant;
        }
    }
    //Получение кофакторов
    private Matrix GetCofactor(int row, int column)
    {
        Matrix cofactor = new Matrix(rows - 1, columns - 1);
        int rowIndex = 0;
        for (int i = 0; i < rows; i++)
        {
            if (i == row)
                continue;

            int columnIndex = 0;
            for (int j = 0; j < columns; j++)
            {
                if (j == column)
                    continue;

                cofactor.elements[rowIndex, columnIndex] = elements[i, j];
                columnIndex++;
            }
            rowIndex++;
        }
        return cofactor;
    }
    // перегрузка оператора +
    public static Matrix operator +(Matrix matrix1, Matrix matrix2)
    {
        if (matrix1.Rows != matrix2.Rows || matrix1.Columns != matrix2.Columns)
        {
            throw new ArgumentException("Матрицы должны быть одинаковой размерности.");
        }

        Matrix sum = new Matrix(matrix1.Rows, matrix1.Columns);
        for (int i = 0; i < matrix1.Rows; i++)
        {
            for (int j = 0; j < matrix1.Columns; j++)
            {
                sum.elements[i, j] = matrix1.elements[i, j] + matrix2.elements[i, j];
            }
        }
        return sum;
    }
    // перегрузка оператора -
    public static Matrix operator -(Matrix matrix1, Matrix matrix2)
    {
        if (matrix1.Rows != matrix2.Rows || matrix1.Columns != matrix2.Columns)
        {
            throw new ArgumentException("Матрицы должны быть одинаковой размерности.");
        }

        Matrix difference = new Matrix(matrix1.Rows, matrix1.Columns);
        for (int i = 0; i < matrix1.Rows; i++)
        {
            for (int j = 0; j < matrix1.Columns; j++)
            {
                difference.elements[i, j] = matrix1.elements[i, j] - matrix2.elements[i, j];
            }
        }
        return difference;
    }
    // перегрузка оператора * для матрицы на число
    public static Matrix operator *(Matrix matrix, double scalar)
    {
        Matrix result = new Matrix(matrix.Rows, matrix.Columns);
        for (int i = 0; i < matrix.Rows; i++)
        {
            for (int j = 0; j < matrix.Columns; j++)
            {
                result.elements[i, j] = matrix.elements[i, j] * scalar;
            }
        }
        return result;
    }
    // перегрузка оператора * для матрицы на матрицу
    public static Matrix operator *(Matrix matrix1, Matrix matrix2)
    {
        if (matrix1.Columns != matrix2.Rows)
        {
            throw new ArgumentException("Несовместимые размерности матриц.");
        }

        Matrix product = new Matrix(matrix1.Rows, matrix2.Columns);
        for (int i = 0; i < matrix1.Rows; i++)
        {
            for (int j = 0; j < matrix2.Columns; j++)
            {
                double sum = 0;
                for (int k = 0; k < matrix1.Columns; k++)
                {
                    sum += matrix1.elements[i, k] * matrix2.elements[k, j];
                }   
                product.elements[i, j] = sum;
            }
        }
        return product;
    }

    class Program
    {
        static void Main(string[] args)
        {
            Matrix A = new Matrix(3, 3);
            // Инициализация элементов матрицы A
            A.elements[0, 0] = 2;
            A.elements[0, 1] = 0;
            A.elements[0, 2] = 0;
            A.elements[1, 0] = 0;
            A.elements[1, 1] = 2;
            A.elements[1, 2] = 0;
            A.elements[2, 0] = 0;
            A.elements[2, 1] = 0;
            A.elements[2, 2] = 2;

            Matrix B = new Matrix(3, 3);
            // Инициализация элементов матрицы B
            B.elements[0, 0] = 1;
            B.elements[0, 1] = 0;
            B.elements[0, 2] = 0;
            B.elements[1, 0] = 0;
            B.elements[1, 1] = 1;
            B.elements[1, 2] = 0;
            B.elements[2, 0] = 0;
            B.elements[2, 1] = 0;
            B.elements[2, 2] = 1;
        //операции
            Matrix C = A - B;
            C = C * 2;
            C = C * (A * A + B);
        //вывод
            C.PrintMatrix();
        //определитель и вывод
        
            double determinant = C.CalculateDeterminant();
            Console.WriteLine("Determinant: " + determinant);
        }
    }
}