Подсчет обратной матрицы

              if (Math.Abs(alpha) < eps)

                        return null;

              else

                  {

                        ColumnVector z = new ColumnVector(N);

                        ColumnVector d = new ColumnVector(N);

                  z = B_i.Multiplication(C_j);

                        for (int i = 0; i < N; i++)

                        {

                       if (i == K - 1)

                           d[i] = -1 / z[K - 1] * (-1);

                              else

                           d[i] = -1 / z[K - 1] * z[i];

                        }

                        for (int i = 0; i < N; i++)

                        {

                       res.matrix[i, i] = 1;

                       res.matrix[i, K - 1] = d[i];

                        }

                 res = res.Multiplication(B_i);

                  }

                  return res;

            }

    }

static void Main(string[] args)

{

            const double eps = 0.000000001;

            int n = 8;

            int[] s = new int[n];

            //Вектор индексов J

            List<int> J = new List<int>();

            for (int i = 0; i < n; i++)

                J.Add(i + 1);

            //Создаем матрицы B,C

            SquarteMatrix B = new SquarteMatrix(n);

            SquarteMatrix C = new SquarteMatrix(n);

            for (int i = 0; i < n; i++)

            {

                B[i, i] = 1;

                C[i, i] = 1;

            }

            SquarteMatrix A = new SquarteMatrix(n, new double[8, 8] {

                                                                {0, 0, 0, 0, 0, 0, 0, 1},

                                                                {0, 0, 0, 0, 0, 0, 2, 0},

                                                                {0, 0, 0, 0, 0, 3, 0, 0},

                                                                {0, 0, 0, 0, 4, 0, 0, 0},

                                                                {0, 0, 0, 5, 0, 0, 0, 0},

                                                                {0, 0, 6, 0, 0, 0, 0, 0},

                                                                {0, 7, 0, 0, 0, 0, 0, 0},

                                                                {8, 0, 0, 0, 0, 0, 0, 0}

                                                                   });

            //Итерации метода

            for (int i = 0; i < n; i++)

            {

                int index = 0;

                foreach (int j in J)

                {

                    //создание и инициализация единичного n-вектора

                    RowVector e = new RowVector(n);

                    e[i] = 1;

                    //разбивка исходной матрицы на столбцы

                    ColumnVector c_j = new ColumnVector(n);

                    for (int q = 0; q < n; q++)

                        c_j[q] = A[q, j - 1];

                    //вычисление коэффициента альфа

                    e = e.Multiplication(B);

                    double alpha = e.Multiplication(c_j);

                    //проверка точности

                    if (Math.Abs(alpha) > eps)

                    {

                        index = j;

                        break;

                    }

                }

                if (index == 0)

                {

              Console.WriteLine("Данная матрица вырожденная => обратной не существует.");

                    Console.ReadLine();

                    return;

                }

                else

                {

                    ColumnVector invC = new ColumnVector(n);

                    for (int q = 0; q < n; q++)

                    {

                        C[q, i] = A[q, index - 1];

                        invC[q] = A[q, index - 1];

                    }

                    J.Remove(index);

                    s[index - 1] = i + 1;

                    GetReverseMatrix gerRM = new GetReverseMatrix(n, i + 1, B, invC);

                    B = gerRM.Find();

                    if (B == null)

                    {

              Console.WriteLine("Данная матрица вырожденная => обратной не существует.");

                        return;

                    }

                }

            }

            SquarteMatrix reverseMatrix = new SquarteMatrix(n);

            for (int i = 0; i < n; i++)

            {

                for (int j = 0; j < n; j++)

                    reverseMatrix[i, j] = B[s[i] - 1, j];

            }

            Console.WriteLine("Исходная матрица: \n");

            for (int i = 0; i < n; i++)

            {

                for (int j = 0; j < n; j++)

                    Console.Write(A[i, j]  + " ");

                Console.WriteLine();

            }

            Console.WriteLine("\nОбратная матрица: \n");

            for (int i = 0; i < n; i++)

            {

                for (int j = 0; j < n; j++)

                    Console.Write(reverseMatrix[i, j] + " ");

                Console.WriteLine();

            }

            SquarteMatrix checkResult = new SquarteMatrix(n);

            checkResult = A.Multiplication(reverseMatrix);

            Console.WriteLine("\nПроверка результата:");

            for (int i = 0; i < n; i++)

            {

                for (int j = 0; j < n; j++)

                    Console.Write(checkResult[i, j] + " ");

                Console.WriteLine();