矩阵的求逆

求行列式取自  C++递归方法计算n阶行列式_n阶行列式c++-CSDN博客

//求行列式
double det(int n, double *aa)//n为阶数，aa为矩阵,求行列式
{
    if (n == 1)
        return aa[0];
    double *bb = new double[(n - 1)*(n - 1)];//创建n-1阶的代数余子式阵bb
    int mov = 0;//判断行是否移动
    double sum = 0.0;//sum为行列式的值
    for (int arow = 0; arow<n; arow++) // a的行数把矩阵a(nn)赋值到b(n-1)
    {
        for (int brow = 0; brow<n - 1; brow++)//把aa阵第一列各元素的代数余子式存到bb
        {
            mov = arow > brow ? 0 : 1; //bb中小于arow的行，同行赋值，等于的错过，大于的加一
            for (int j = 0; j<n - 1; j++)  //从aa的第二列赋值到第n列
            {
                bb[brow*(n - 1) + j] = aa[(brow + mov)*n + j + 1];
            }
        }
        int flag = (arow % 2 == 0 ? 1: -1);//因为列数为0，所以行数是偶数时候，代数余子式为1.
        sum += flag* aa[arow*n] * det(n - 1, bb);//aa第一列各元素与其代数余子式积的和即为行列式
    }
    delete[]bb;
    return sum;
}
//矩阵乘法
QVector<QVector<double>> matrix_multiplication(QVector<QVector<double>> a, QVector<QVector<double>> b)
{
    int acols = a[0].size();
    int arows = a.size();
    int bcols = b[0].size();
    int brows = b.size();

    QVector<double> col(bcols,0);//构造一个初始大小为cols元素的向量。每个元素都用0值初始化。
    QVector<QVector<double>> ret(arows,col);//构造一个初始大小为rows元素的向量。每个元素都用col值初始化。
    if(acols != brows)
    {
        qDebug() << "矩阵无法相乘,返回空矩阵";
        ret.clear();
        return ret;
    }

    for(int i = 0; i < arows; i++)
    {
        for(int j = 0; j < bcols; j++)
        {
            double t = 0;
            for(int k = 0; k < acols; k++)
            {
                t = t + (a[i][k] * b[k][j]);
            }
            ret[i][j] = t;
        }
    }

    return ret;
}

//矩阵转置
QVector<QVector<double>> matrix_transpose(QVector<QVector<double>> &a)
{
    int cols = a[0].size();
    int rows = a.size();

    QVector<double> row(rows,0);//构造一个初始大小为cols元素的向量。每个元素都用0值初始化。
    QVector<QVector<double>> temp(cols,row);//构造一个初始大小为rows元素的向量。每个元素都用col值初始化。


    for(int i = 0; i < cols; i++)
    {
        for(int j = 0; j < rows; j++)
        {
            temp[i][j] = a[j][i];
        }
    }
    return temp;
}

//求逆矩阵
QVector<QVector<double>> Matrix_inverse(QVector<QVector<double>> &A)
{
    qDebug() << A;
    qDebug() << "__________________________________________";

    int cols = A[0].size();
    int rows = A.size();
    QVector<double> col(cols,0);//构造一个初始大小为cols元素的向量。每个元素都用0值初始化。
    QVector<QVector<double>> res(rows,col);//构造一个初始大小为rows元素的向量。每个元素都用col值初始化。
    if(cols==1 && rows==1)
    {
        res[0][0] = 1/A[0][0];
        return res;
    }
    int i,j,k,l,m,n;
//    double temp,temp2;
    double temp[cols*rows];
    double temp2[(cols-1)*(rows-1)];
    QVector<double> var;
    var.clear();
//    qDebug() << "var内有多少元素：" << var.length();

    //求代数余子式
//    qDebug() << "rows:" << rows;
    for (i = 0; i < rows; i++)
    {
        for (j = 0; j < rows; j++)
        {
            for (k = 0; k < rows; k++)
            {
                for (l = 0; l < rows; l++)
                {
                    if(k != i && l != j)
                    {
//                        qDebug() << "A的值" << A[k][l];
                        var.append(A[k][l]);
                    }
                }
            }
//            qDebug() << "var内有多少元素：" << var.length();
            for(m = 0; m < var.length(); m++)
            {
                temp2[m] = var[m];
            }
            var.clear();
//            qDebug() << "det(cols-1,temp2):" << det(cols-1,temp2);
            res[i][j] = pow(-1,i+j)*det(cols-1,temp2);
        }
    }
    //矩阵转置
    res = matrix_transpose(res);
    //求逆矩阵
    //求A的行列式
    for(m = 0; m < rows; m++)
    {
        for(n = 0; n < cols; n++)
        {
            temp[m*cols+n] = A[m][n];
        }
    }
//    qDebug() << "det(cols,temp):" << det(cols,temp);
    double determinant = det(cols,temp);
    for(m = 0; m < rows; m++)
    {
        for(n = 0; n < cols; n++)
        {
            res[m][n] = res[m][n]/determinant;
        }
    }

    qDebug() << res;
    qDebug() << "__________________________________________";

    return res;
}