C# 求方矩阵的行列式和逆矩阵算法编程

using m_type = System.Single;
//方矩阵乘法运算
    m_type[,] MatMultiply(m_type[,] A, m_type[,] B)
    {
        m_type[,] D = new m_type[A.GetLength(0), A.GetLength(1)];
        for (int i = 0; i < dimen; i++)
            for (int j = 0; j < dimen; j++)
                for (int k = 0; k < dimen; k++)
                    D[i, j] += A[i, k] * B[k, j];
        return D;
    }
    //方矩阵求逆运算
    m_type[,] MatInverse(m_type[,] Array)
    {
        int m = 0;
        int n = 0;
        m = Array.GetLength(0);
        n = Array.GetLength(1);
        if (m != n || m == 1) return Array;//是否为方阵；1行1列矩阵的逆矩阵是它自身
        //由行列式判断是否可逆
        if (Determinant(Array) == 0) return Array;
        //计算逆矩阵
        m_type[,] array = new m_type[2 * m + 1, 2 * n + 1];
        for (int k = 0; k < 2 * m + 1; k++)  //初始化数组
            for (int t = 0; t < 2 * n + 1; t++)
                array[k, t] = 0.00000000f;

        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++)
                array[i, j] = Array[i, j];

        for (int k = 0; k < m; k++)
            for (int t = n; t <= 2 * n; t++)
            {
                if ((t - k) == m) array[k, t] = 1.0f;
                else array[k, t] = 0;
            }
        //得到逆矩阵
        for (int k = 0; k < m; k++)
        {
            if (array[k, k] != 1)
            {
                m_type bs = array[k, k];
                array[k, k] = 1;
                for (int p = k + 1; p < 2 * n; p++)
                    array[k, p] /= bs;
            }
            for (int q = 0; q < m; q++)
            {
                if (q != k)
                {
                    m_type bs = array[q, k];
                    for (int p = 0; p < 2 * n; p++)
                        array[q, p] -= bs * array[k, p];
                }
                else continue;
            }
        }
        m_type[,] NI = new m_type[m, n];
        for (int x = 0; x < m; x++)
            for (int y = n; y < 2 * n; y++)
                NI[x, y - n] = array[x, y];
        return NI;
    }
    //计算行列式
    m_type Determinant(m_type[,] A)
    {
        int m = A.GetLength(0);
        int n = A.GetLength(1);
        if (m != n) return 0;//是否为方阵
        if (m == 1) return A[0, 0];//1行1列矩阵的逆矩阵是它自身

        m_type det = 0;
        m_type[,] Aij = new m_type[m - 1, n - 1];
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < m - 1; j++)
                for (int k = 0; k < n - 1; k++)
                    Aij[j, k] = A[j + 1, k >= i ? k + 1 : k];
            det += A[0, i] * Mathf.Pow(-1, 1 + i + 1) * Determinant(Aij);
        }
        return det;
    }