static public rectMatrix MatrixDiffOperation(rectMatrix matrix1, rectMatrix matrix2)
        {
            rectMatrix outMatrix = new rectMatrix(matrix1.heigh, matrix1.weigth);

            try
            {
                if (matrix1.weigth != matrix2.weigth || matrix1.heigh != matrix2.heigh)
                {
                    throw new Exception("Матрицы разных размеров!\nМатематика пока такого не умеет\n¯\\_(ツ)_/¯");
                }
                else
                {
                    for (int i = 0; i < matrix1.heigh; i++)
                    {
                        for (int j = 0; j < matrix1.weigth; j++)
                        {
                            //MessageBox.Show($"элемент: ({i}, {j}) = {matrix1.matrixArr[i, j]} - {matrix2.matrixArr[i, j]}");
                            outMatrix.matrixArr[i, j] = matrix1.matrixArr[i, j] - matrix2.matrixArr[i, j];
                        }
                    }

                    return(outMatrix);
                }
            }
            finally
            {
            }
        }
        static public rectMatrix MatrixTranspOperation(rectMatrix matrix1)
        {
            rectMatrix outMatrix = new rectMatrix(matrix1.heigh, matrix1.weigth);

            try
            {
                if (matrix1.weigth != matrix1.heigh)
                {
                    throw new Exception("Матрица указанного размера не транспонируема!\n Математика пока такого не умеет :P");
                }
                else
                {
                    for (int i = 0; i < matrix1.heigh; i++)
                    {
                        for (int j = 0; j < matrix1.weigth; j++)
                        {
                            //MessageBox.Show($"элемент: ({i}, {j}) = {matrix1.matrixArr[i, j]} + {matrix2.matrixArr[i, j]}");
                            outMatrix.matrixArr[i, j] = matrix1.matrixArr[j, i];
                        }
                    }

                    return(outMatrix);
                }
            }
            finally
            {
            }
        }
        //Возвращает матрицу matrix без row-ой строки и col-того столбца, результат в newMatrix
        static public void getMatrixWithoutRowAndCol(int[,] matrixArr, int size, int row, int col, ref rectMatrix matrixOutput)
        {
            matrixOutput = new rectMatrix(size - 1, size - 1);
            int offsetRow = 0; //Смещение индекса строки в матрице
            int offsetCol = 0; //Смещение индекса столбца в матрице

            for (int i = 0; i < size - 1; i++)
            {
                //Пропустить row-ую строку
                if (i == row)
                {
                    offsetRow = 1; //Как только встретили строку, которую надо пропустить, делаем смещение для исходной матрицы
                }

                offsetCol = 0; //Обнулить смещение столбца
                for (int j = 0; j < size - 1; j++)
                {
                    //Пропустить col-ый столбец
                    if (j == col)
                    {
                        offsetCol = 1; //Встретили нужный столбец, проускаем его смещением
                    }
                    //MessageBox.Show(matrixArr[i + offsetRow, j + offsetCol].ToString());
                    matrixOutput.matrixArr[i, j] = matrixArr[i + offsetRow, j + offsetCol];
                }
            }
            //MessageBox.Show(matrixOutput.ToString());
            return;
        }
        private void reverseButton_Click(object sender, EventArgs e)
        {
            matrix1 = new rectMatrix(Convert.ToInt32(heighMatrixFirst_textBox.Text), Convert.ToInt32(weightMatrixFirst_textBox.Text));
            matrix1 = ReadMatrix(matrix1.heigh, matrix1.weigth, matrixElementList1);

            matrix2 = new rectMatrix(matrix1.heigh - 1, matrix1.weigth - 1);
            rectMatrix.getMatrixWithoutRowAndCol(matrix1.matrixArr, matrix1.heigh, 1, 1, ref matrix2);

            //AutoFilling(matrix2.heigh.ToString(), matrix2.weigth.ToString(), matrix2, panelOfElements2, ref matrixElementList2);
            //ShowMatrixOnForm(matrix2,matrixElementList2);
            int det = rectMatrix.matrixDet(matrix1.matrixArr, matrix1.heigh);

            rectMatrix reverseMatrix = rectMatrix.MatrixTranspOperation(matrix1);

            double[,] reverseArr = new double[reverseMatrix.heigh, reverseMatrix.weigth];

            rectMatrix.multScalar(rectMatrix.ToDoubleConverter(reverseMatrix.matrixArr, reverseMatrix.heigh, reverseMatrix.weigth), reverseMatrix.heigh, reverseMatrix.weigth, 1 / det);

            AutoFilling(reverseMatrix.heigh.ToString(), reverseMatrix.weigth.ToString(), reverseMatrix, panelOfElements2, ref matrixElementList2);
            ShowMatrixOnForm(reverseArr, reverseMatrix.heigh, reverseMatrix.weigth, matrixElementList2);

            MessageBox.Show(reverseMatrix.ToString());

            detTextBox.Text = det.ToString();

            rectMatrix minorsMatr = rectMatrix.MatrixTranspOperation(rectMatrix.getMinorsMatrix(matrix1));

            reverseArr = rectMatrix.multScalar(rectMatrix.ToDoubleConverter(minorsMatr.matrixArr, minorsMatr.heigh, minorsMatr.weigth), minorsMatr.heigh, minorsMatr.weigth, 1 / det);
            ShowMatrixOnForm(reverseArr, reverseMatrix.heigh, reverseMatrix.weigth, matrixElementList2);
            //MessageBox.Show();
        }
        static public rectMatrix MatrixMultOperation(rectMatrix matrix1, rectMatrix matrix2)
        {
            rectMatrix outMatrix = new rectMatrix(matrix1.heigh, matrix1.weigth);

            try
            {
                throw new Exception("Наше приложение пока такого не умеет :P");

                /*
                 * if (matrix1.weigth != matrix2.heigh)
                 * {
                 *  throw new Exception("Матрицы указанных размеров невозможно перемножать!\n Математика пока такого не умеет :P");
                 * }
                 * else
                 * {
                 *  for (int i = 0; i < matrix1.heigh; i++)
                 *  {
                 *      for (int j = 0; j < matrix1.weigth; j++)
                 *      {
                 *          //MessageBox.Show($"элемент: ({i}, {j}) = {matrix1.matrixArr[i, j]} + {matrix2.matrixArr[i, j]}");
                 *          outMatrix.matrixArr[i, j] = matrix1.matrixArr[i, j] + matrix2.matrixArr[i, j];
                 *      }
                 *  }
                 *
                 *  return outMatrix;
                 * }
                 */
            }
            finally
            {
            }
        }
        private void readButton_Click(object sender, EventArgs e)
        {
            matrix1 = new rectMatrix(Convert.ToInt32(heighMatrixFirst_textBox.Text), Convert.ToInt32(weightMatrixFirst_textBox.Text));
            matrix2 = new rectMatrix(Convert.ToInt32(heighMatrixFirst_textBox.Text), Convert.ToInt32(weightMatrixFirst_textBox.Text));

            matrix1 = ReadMatrix(matrix1.heigh, matrix1.weigth, matrixElementList1);
            matrix2 = ReadMatrix(matrix2.heigh, matrix2.weigth, matrixElementList2);
        }
        //Вычисление определителя матрицы разложение по первой строке
        static public int matrixDet(int[,] matrixArr, int size)
        {
            int det    = 0;
            int degree = 1; // (-1)^(1+j) из формулы определителя

            //Условие выхода из рекурсии
            if (size == 1)
            {
                return(matrixArr[0, 0]);
            }
            //Условие выхода из рекурсии
            else if (size == 2)
            {
                return(matrixArr[0, 0] * matrixArr[1, 1] - matrixArr[0, 1] * matrixArr[1, 0]);
            }
            else
            {
                //Матрица без строки и столбца
                rectMatrix newMatrix = new rectMatrix(size - 1, size - 1);

                //Раскладываем по 0-ой строке, цикл бежит по столбцам
                for (int j = 0; j < size; j++)
                {
                    //Удалить из матрицы i-ю строку и j-ый столбец
                    //Результат в newMatrix
                    getMatrixWithoutRowAndCol(matrixArr, size, 0, j, ref newMatrix);

                    //Рекурсивный вызов
                    //По формуле: сумма по j, (-1)^(1+j) * matrix[0][j] * minor_j (это и есть сумма из формулы)
                    //где minor_j - дополнительный минор элемента matrix[0][j]
                    // (напомню, что минор это определитель матрицы без 0-ой строки и j-го столбца)
                    det = det + (degree * matrixArr[0, j] * matrixDet(newMatrix.matrixArr, size - 1));
                    //"Накручиваем" степень множителя
                    degree = -degree;
                }

                //Чистим память на каждом шаге рекурсии(важно!)
                //for (int i = 0; i < size - 1; i++)
                //{
                //    delete[] newMatrix[i];
                //}
                //delete[] newMatrix;
            }

            return(det);
        }
        public void AutoFilling(string Height, string Weight, rectMatrix matrix, Panel panel, ref TextBox[,] textBoxesList)
        {
            if (Height != "" && Weight != "")
            {
                int height = Convert.ToInt32(Height);
                int weight = Convert.ToInt32(Weight);

                //matrix = new rectMatrix(height, weight);

                //TextBox[,] textBoxes = new TextBox[height, weight];

                textBoxesList = new TextBox[height, weight];

                panel.Controls.Clear();

                try
                {
                    for (int i = 0; i < height; i++)
                    {
                        for (int j = 0; j < weight; j++)
                        {
                            TextBox textbox1;

                            panel.Controls.Add(textbox1 = new TextBox()
                            {
                                Name     = "element [" + i.ToString() + "," + j.ToString() + "]_textBox",
                                Location = new Point(45 * (j) + 15 * (j + 1), 24 * (i) + 15 * (i + 1)),
                                Size     = new Size(55, 34),
                                Font     = new Font("", 14)
                            });

                            textBoxesList[i, j] = textbox1;
                        }
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show("Усе погано...\n" + ex.Message);
                }
            }
            else
            {
                MessageBox.Show("Поля размера заполнены некорректно!");
            }
        }
        private void readSecondButton_Click(object sender, EventArgs e)
        {
            try
            {
                matrix1   = new rectMatrix(Convert.ToInt32(heighMatrixFirst_textBox.Text), Convert.ToInt32(weightMatrixFirst_textBox.Text));
                matrix2   = new rectMatrix(Convert.ToInt32(heighMatrixSecond_textBox.Text), Convert.ToInt32(weightMatrixSecond_textBox.Text));
                outMatrix = new rectMatrix(Convert.ToInt32(heighMatrixFirst_textBox.Text), Convert.ToInt32(weightMatrixFirst_textBox.Text));

                matrix1 = ReadMatrix(matrix1.heigh, matrix1.weigth, matrixElementList1);
                matrix2 = ReadMatrix(matrix2.heigh, matrix2.weigth, matrixElementList2);

                switch (operation_ComboBox.SelectedIndex)
                {
                case -1:
                    MessageBox.Show("Необходимо выбрать операцию!");
                    break;

                case 0:
                    outMatrix = rectMatrix.MatrixDiffOperation(matrix1, matrix2);
                    MessageBox.Show(ShowArr(outMatrix.heigh, outMatrix.weigth, outMatrix.matrixArr));
                    break;

                case 1:
                    outMatrix = rectMatrix.MatrixAddOperation(matrix1, matrix2);
                    MessageBox.Show(ShowArr(outMatrix.heigh, outMatrix.weigth, outMatrix.matrixArr));
                    break;

                case 3:
                    outMatrix = rectMatrix.MatrixTranspOperation(matrix1);
                    ShowMatrixOnForm(matrix1.matrixArr, matrix1.heigh, matrix1.weigth, matrixElementList1);
                    MessageBox.Show(ShowArr(outMatrix.heigh, outMatrix.weigth, outMatrix.matrixArr));
                    break;

                case 2:
                    outMatrix = rectMatrix.MatrixMultOperation(matrix1, matrix2);
                    MessageBox.Show(ShowArr(outMatrix.heigh, outMatrix.weigth, outMatrix.matrixArr));
                    break;
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show("Error: " + ex.Message);
            }
        }
        private void transpFirstButton_Click(object sender, EventArgs e)
        {
            try
            {
                matrix1   = new rectMatrix(Convert.ToInt32(heighMatrixFirst_textBox.Text), Convert.ToInt32(weightMatrixFirst_textBox.Text));
                outMatrix = new rectMatrix(Convert.ToInt32(heighMatrixFirst_textBox.Text), Convert.ToInt32(weightMatrixFirst_textBox.Text));

                matrix1 = ReadMatrix(matrix1.heigh, matrix1.weigth, matrixElementList1);

                outMatrix = rectMatrix.MatrixTranspOperation(matrix1);
                //MessageBox.Show(ShowArr(outMatrix.heigh, outMatrix.weigth, outMatrix.matrixArr));

                ShowMatrixOnForm(outMatrix.matrixArr, outMatrix.heigh, outMatrix.weigth, matrixElementList1);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
        static public rectMatrix getMinorsMatrix(rectMatrix matrix)
        {
            rectMatrix outMatrix    = new rectMatrix(matrix.heigh, matrix.weigth);
            rectMatrix minor        = new rectMatrix(matrix.heigh - 1, matrix.weigth - 1);
            int        determinator = 0;

            for (int i = 0; i < matrix.heigh; i++)
            {
                for (int j = 0; j < matrix.weigth; j++)
                {
                    rectMatrix.getMatrixWithoutRowAndCol(matrix.matrixArr, matrix.heigh, i, j, ref minor);
                    MessageBox.Show(minor.ToString());
                    determinator = rectMatrix.matrixDet(minor.matrixArr, matrix.heigh - 1);
                    MessageBox.Show($"{determinator}");
                    outMatrix.matrixArr[i, j] = determinator;
                }
            }

            return(outMatrix);
        }
        public rectMatrix ReadMatrix(int Height, int Weight, TextBox[,] matrixElementList)
        {
            rectMatrix outMatrix = new rectMatrix(Height, Weight);

            try
            {
                for (int i = 0; i < Height; i++)
                {
                    for (int j = 0; j < Weight; j++)
                    {
                        outMatrix.matrixArr[i, j] = Convert.ToInt32(matrixElementList[i, j].Text);
                    }
                }
                //MessageBox.Show(ShowArr(Height, Weight, outMatrix.matrixArr));
                return(outMatrix);
            }
            finally
            {
            }
        }