矩阵的乘、求转置、求逆

        /// <summary>
        /// 矩阵的乘
        /// </summary>
        public void multiplyMatrix(double[,] a, double[,] b, out double[,] c)
        {
            c = new double[a.GetLength(0), b.GetLength(1)];
            for (int i = 0; i < a.GetLength(0); i++)
            {
                for (int j = 0; j < b.GetLength(1); j++)
                {
                    c[i, j] = 0;
                    for (int k = 0; k < b.GetLength(0); k++)
                    {
                        c[i, j] += a[i, k] * b[k, j];
                    }
                }
            }

        }

        /// <summary>
        /// 矩阵的转置
        /// </summary>
        /// <param name="a">原始矩阵</param>
        /// <param name="b">转置后的矩阵</param>
        public void inverseMatrix(double[,] a, out double[,] b)
        {
            b = new double[a.GetLength(1), a.GetLength(0)];
            for (int i = 0; i < a.GetLength(1); i++)
            {
                for (int j = 0; j < a.GetLength(0); j++)
                {
                    b[i, j] = a[j, i];
                }
            }
        }

        /// <summary>
        /// 矩阵的行列式的值
        /// </summary>
        /// <param name="a">矩阵</param>
        /// <returns>行列式的值</returns>
        public double surplusMatrix(double[,] a)
        {
            int i, j, k, p, r, m, n;
            m = a.GetLength(0);
            n = a.GetLength(1);
            double X, temp = 1, temp1 = 1, s = 0, s1 = 0;


            if (n == 2)
            {
                for (i = 0; i < m; i++)
                {
                    for (j = 0; j < n; j++)
                    {
                        if ((i + j) % 2 > 0)
                        { temp1 *= a[i, j]; }
                        else
                        { temp *= a[i, j]; }
                    }
                }
                X = temp - temp1;
            }
            else
            {
                for (k = 0; k < n; k++)
                {
                    for (i = 0, j = k; i < m && j < n; i++, j++)
                    {
                        temp *= a[i, j];
                    }
                    if (m - i > 0)
                    {
                        for (p = m - i, r = m - 1; p > 0; p--, r--)
                        {
                            temp *= a[r, p - 1];
                        }
                    }
                    s += temp;
                    temp = 1;
                }
                for (k = n - 1; k >= 0; k--)
                {
                    for (i = 0, j = k; i < m && j >= 0; i++, j--)
                    {
                        temp1 *= a[i, j];
                    }
                    if (m - i > 0)
                    {
                        for (p = m - 1, r = i; r < m; p--, r++)
                        {
                            temp1 *= a[r, p];
                        }
                    }
                    s1 += temp1;
                    temp1 = 1;
                }
                X = s - s1;
            }
            return X;
        }

        /// <summary>
        /// 矩阵的逆
        /// </summary>
        /// <param name="a">矩阵</param>
        /// <param name="b">逆矩阵</param>
        public void oppMatrix(double[,] a, out double[,] b)
        {
            double X = surplusMatrix(a);
            X = 1 / X;
            double[,] B = new double[a.GetLength(0), a.GetLength(1)];
            double[,] SP = new double[a.GetLength(0), a.GetLength(1)];
            double[,] AB = new double[a.GetLength(0), a.GetLength(1)];
            for (int i = 0; i < a.GetLength(0); i++)
            {
                for (int j = 0; j < a.GetLength(1); j++)
                {
                    for (int m = 0; m < a.GetLength(0); m++)
                    {
                        for (int n = 0; n < a.GetLength(1); n++)
                        { B[m, n] = a[m, n]; }
                    }


                    for (int x = 0; x < a.GetLength(1); x++)
                    { B[i, x] = 0; }
                    for (int y = 0; y < a.GetLength(0); y++)
                    { B[y, j] = 0; }
                    B[i, j] = 1;
                    SP[i, j] = surplusMatrix(B);
                    AB[i, j] = X * SP[i, j];
                }
            }
            double[,] tmp;
            inverseMatrix(AB, out tmp);
            b = new double[tmp.GetLength(0), tmp.GetLength(1)];
            for (int i = 0; i < tmp.GetLength(0); i++)
            {
                for (int j = 0; j < tmp.GetLength(1); j++)
                {
                    b[i, j] = tmp[i, j];
                }
            }
        }

        /// <summary>
        /// 矩阵乘一维数组
        /// </summary>
        /// <param name="a">矩阵</param>
        /// <param name="b">一维数组</param>
        /// <param name="c">输出数组</param>
        public void multiply(double[,] a, double[] b, out double[] c)
        {
            c = new double[a.GetLength(0)];
            for (int i = 0; i < a.GetLength(0); i++)
            {
                for (int j = 0; j < a.GetLength(1); j++)
                {
                    c[i] += a[i, j] * b[j];
                }
            }
        }

        最后一个是赠送的，是我根据项目的具体需要改编的