Умножение квадратной матрицы на вектор - C#

Формулировка задачи:

Я не могу понят вот у меня перегруженный метод умножения матрицы на вектор:

  public static Vektor operator *(Kvadrat_mat b, Vektor a )
        {
 
            Vektor temp = new Vektor(b.GetN());
            double[] c = new double[b.GetN()];
                for (int i = 0; i < b.GetN();i++)
                   for (int j = 0; j < b.GetN(); j++)
                {
                    c[i] += b.mat[i,j] * a.GetI(j); 
                }
 
            for (int i = 0; i<b.GetN();i++)
            temp.SetI(i, c[i]);
            return temp;
        }

Вот код вызова и применения этого метода:

  Vektor temp = new Vektor(dataGridView2.RowCount);
                        
                        for (int i =0; i<dataGridView2.ColumnCount;i++)
                            for (int j = 0; j < dataGridView2.RowCount; j++)
                            {
                             a.SetI(i, j, Convert.ToDouble(dataGridView1[i, j].Value));
                            }
                        for (int i = 0; i< dataGridView2.ColumnCount; i++)
                        for (int j = 0; j < dataGridView2.RowCount; j++)
                        {
                               // MessageBox.Show("j = " + j + "  values = " + dataGridView2[i, j].Value);
                            temp.SetI(j, Convert.ToDouble(dataGridView2[i, j].Value));
                        }
                        
                        temp = a*temp;
                        dataGridView3.ColumnCount = 1;
                        dataGridView3.RowCount = temp.GetN();
 
                        for (int i = 0; i < dataGridView3.ColumnCount; i++)
                            for(int j = 0; j < dataGridView3.RowCount; j++)
                            dataGridView3[i,j].Value = temp.GetI(j);

Заранее спасибо)

Решение задачи: «Умножение квадратной матрицы на вектор»

textual
                            Листинг программы 
                        

                            // Транспонирование матрицы
        public static double[,] TransposeMatrixD(double[,] matrix)
        {
            int m = matrix.GetLength(0);
            int n = matrix.GetLength(1);
 
            double[,] matrixT = new double[n, m];
 
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < m; j++)
                {
                    matrixT[i, j] = matrix[j, i];
                }
            }
 
            return matrixT;
        }
 
        // Умножение матриц
        public static double[,] MultiplicationMatrixD(double[,] a, double[,] b)
        {
            if (a.GetLength(1) != b.GetLength(0)) { throw new Exception("Матрицы нельзя перемножить"); }
 
            int ma = a.GetLength(0);
            int mb = b.GetLength(0);
            int nb = b.GetLength(1);
 
            double[,] r = new double[ma, nb];
 
            for (int i = 0; i < a.GetLength(0); i++)
            {
                for (int j = 0; j < nb; j++)
                {
                    for (int k = 0; k < mb; k++)
                    {
                        r[i, j] += a[i, k] * b[k, j];
                    }
                }
            }
            return r;
        }
 
        // Обратная матрица
        public static double[,] InvertMatrixD(double[,] matrix)
        {
            int m = matrix.GetLength(0);
            int n = matrix.GetLength(1);
 
            double[,] res = new double[m, n];
 
            for (int i = 0; i < m; i++)
            {
                for (int j = 0; j < m; j++)
                {
                    res[i, j] = matrix[i, j];
                }
            }
 
            if (n != m)
            {
                throw new Exception("Обратной матрицы не существует");
            }
 
            int[] row = new int[n];
            int[] col = new int[n];
 
            double[] temp = new double[n];
            int hold;
            int I_pivot;
            int J_pivot;
            double pivot;
            double abs_pivot;
 
            // установиим row и column как вектор изменений.
            for (int k = 0; k < n; k++)
            {
                row[k] = k;
                col[k] = k;
            }
 
            // начало главного цикла
            for (int k = 0; k < n; k++)
            {
                // найдем наибольший элемент для основы
                pivot = res[row[k], col[k]];
                I_pivot = k;
                J_pivot = k;
                for (int i = k; i < n; i++)
                {
                    for (int j = k; j < n; j++)
                    {
                        abs_pivot = Math.Abs(pivot);
                        if (Math.Abs(res[row[i], col[j]]) > abs_pivot)
                        {
                            I_pivot = i;
                            J_pivot = j;
                            pivot = res[row[i], col[j]];
                        }
                    }
                }
 
                if (Math.Abs(pivot) < 1.0E-10)
                {
                    //System.out.println("Matrix is singular !");
                    throw new Exception("!");
                }
 
                // Перестановка к-ой строки и к-ого столбца с стобцом и строкой, содержащий основной элемент(pivot основу)
                hold = row[k];
                row[k] = row[I_pivot];
                row[I_pivot] = hold;
                hold = col[k];
                col[k] = col[J_pivot];
                col[J_pivot] = hold;
 
                // k-ую строку с учетом перестановок делим на основной элемент
                res[row[k], col[k]] = 1.0 / pivot;
 
                for (int j = 0; j < n; j++)
                {
                    if (j != k)
                    {
                        res[row[k], col[j]] = res[row[k], col[j]] * res[row[k], col[k]];
                    }
                }
 
                // Внутренний цикл
                for (int i = 0; i < n; i++)
                {
                    if (k != i)
                    {
                        for (int j = 0; j < n; j++)
                        {
                            if (k != j)
                            {
                                res[row[i], col[j]] = res[row[i], col[j]] - res[row[i], col[k]] * res[row[k], col[j]];
                            }
                        }
                        res[row[i], col[k]] = -res[row[i], col[k]] * res[row[k], col[k]];
                    }
                }
            }
 
            // Переставляем назад rows
            for (int j = 0; j < n; j++)
            {
                for (int i = 0; i < n; i++)
                {
                    temp[col[i]] = res[row[i], j];
                }
 
                for (int i = 0; i < n; i++)
                {
                    res[i, j] = temp[i];
                }
            }
 
            // Переставляем назад columns
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    temp[row[j]] = res[i, col[j]];
                }
 
                for (int j = 0; j < n; j++)
                {
                    res[i, j] = temp[j];
                }
            }
 
            return res;
        }
                        