Gauss消去法(C++)

文章目录

  • 算法描述
    • 顺序Gauss消去法
    • 列选主元Gauss消去法
    • 全选主元Gauss消去法
    • Gauss-Jordan消去法
  • 算法实现
    • 顺序Gauss消去法
    • 列选主元Gauss消去法
    • 全选主元Gauss消去法
    • 列选主元Gauss-Jordan消去法
  • 实例分析

Gauss消去法是求解线性方程组较为有效的方法, 它主要包括两个操作, 即消元和回代. 所谓消元是指将线性方程组转化为与其同解的上三角方程组; 回代是指通过上三角方程组逐个解出方程组的未知数. Gauss消去法通常有顺序Gauss消去法, 列主元Gauss消去法, 全主元Gauss消去法及Gauss-Jordan消去法.

算法描述

顺序Gauss消去法

顺序Gauss消去法是最简单的Gauss消去法, 其基本步骤如下:

  1. 将线性方程组的增广矩阵通过行变换, 化简成一个上三角矩阵. 这可以通过交换两行位置或者用一个数乘某一行加到另一行上面来实现.
  2. 从增广矩阵的最后一行开始, 依次回代, 求出解向量. 回代过程中, 需要将从上方得到的解代入下方方程进行求解.

虽然Gauss消去法可以解决线性方程组的问题, 但是它没有稳定性保证. 如果主元素比较小, 舍入误差可能会累积增大, 从而导致解的误差较大.

算法可描述为伪代码如下:

用顺序Gauss消去法求解线性方程组:

{ x + 2 y + 3 z = 1 4 x + 5 y + 6 z = 1 7 x + 8 y = 1 \begin{cases} x+2y+3z=1\\4x+5y+6z=1\\7x+8y=1 \end{cases} x+2y+3z=14x+5y+6z=17x+8y=1

利用顺序Gauss消去法得到如下消元过程:

( 1.000000 2.000000 3.000000 1 4.000000 5.000000 6.000000 1 7.000000 8.000000 0.000000 1 ) → ( 1.000000 2.000000 3.000000 1 0.000000 − 3.000000 − 6.000000 − 3 0.000000 − 6.000000 − 21.000000 − 6 ) → ( 1.000000 2.000000 3.000000 1 0.000000 − 3.000000 − 6.000000 − 3 0.000000 0.000000 − 9.000000 0 ) → ( 1.000000 2.000000 0.000000 1 0.000000 − 3.000000 0.000000 − 3 0.000000 0.000000 1.000000 0 ) → ( 1.000000 0.000000 0.000000 − 1 0.000000 1.000000 0.000000 1 0.000000 0.000000 1.000000 0 ) → ( 1.000000 0.000000 0.000000 − 1 0.000000 1.000000 0.000000 1 0.000000 0.000000 1.000000 0 ) \begin{aligned} &\begin{pmatrix} 1.000000&2.000000&3.000000& 1 \\ 4.000000&5.000000&6.000000& 1 \\ 7.000000&8.000000&0.000000& 1 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 1.000000&2.000000&3.000000& 1 \\ 0.000000&-3.000000&-6.000000& -3 \\ 0.000000&-6.000000&-21.000000& -6 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 1.000000&2.000000&3.000000& 1 \\ 0.000000&-3.000000&-6.000000& -3 \\ 0.000000&0.000000&-9.000000& 0 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 1.000000&2.000000&0.000000& 1 \\ 0.000000&-3.000000&0.000000& -3 \\ 0.000000&0.000000&1.000000& 0 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 1.000000&0.000000&0.000000& -1 \\ 0.000000&1.000000&0.000000& 1 \\ 0.000000&0.000000&1.000000& 0 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 1.000000&0.000000&0.000000& -1 \\ 0.000000&1.000000&0.000000& 1 \\ 0.000000&0.000000&1.000000& 0 \\ \end{pmatrix} \end{aligned} 1.0000004.0000007.0000002.0000005.0000008.0000003.0000006.0000000.000000111 1.0000000.0000000.0000002.0000003.0000006.0000003.0000006.00000021.000000136 1.0000000.0000000.0000002.0000003.0000000.0000003.0000006.0000009.000000130 1.0000000.0000000.0000002.0000003.0000000.0000000.0000000.0000001.000000130 1.0000000.0000000.0000000.0000001.0000000.0000000.0000000.0000001.000000110 1.0000000.0000000.0000000.0000001.0000000.0000000.0000000.0000001.000000110

列选主元Gauss消去法

在顺序Gauss消去法中, 并没有选择主元的步骤, 而是按照方程组的顺序进行消元和回代. 这种方法在某些情况下可能会因为计算的顺序而产生数值不稳定性, 导致计算结果与精确解的误差较大. 而且顺序Gauss消去法要求系数矩阵的各阶顺序主子式非零, 而这并不是方程组有解的必要条件. 在列选主元的Gauss消去法中, 每一步计算之前都会增加选择主元的步骤. 这个步骤是为了提高数值稳定性, 避免在计算过程中出现除数为零的情况. 因此, 列选主元的Gauss消去法在计算精度上通常优于顺序高斯消去法. 除此之外, 列选主元Gauss消去法只需要系数矩阵的行列式非零就可以进行计算.

算法可描述为伪代码如下:

用列选主元Gauss消去法求解上例线性方程组.

利用列选主元Gauss消去法得到如下消元过程:

( 1.000000 2.000000 3.000000 1 4.000000 5.000000 6.000000 1 7.000000 8.000000 0.000000 1 ) → ( 7.000000 8.000000 0.000000 1 4.000000 5.000000 6.000000 1 1.000000 2.000000 3.000000 1 ) → ( 7.000000 8.000000 0.000000 1 0.000000 0.428571 6.000000 0.428571 0.000000 0.857143 3.000000 0.857143 ) → ( 7.000000 8.000000 0.000000 1 0.000000 0.857143 3.000000 0.857143 0.000000 0.428571 6.000000 0.428571 ) → ( 7.000000 8.000000 0.000000 1 0.000000 0.857143 3.000000 0.857143 0.000000 0.000000 4.500000 0 ) → ( 7.000000 8.000000 0.000000 1 0.000000 0.857143 0.000000 0.857143 0.000000 0.000000 1.000000 0 ) → ( 7.000000 0.000000 0.000000 − 7 0.000000 1.000000 0.000000 1 0.000000 0.000000 1.000000 0 ) → ( 1.000000 0.000000 0.000000 − 1 0.000000 1.000000 0.000000 1 0.000000 0.000000 1.000000 0 ) \begin{aligned} &\begin{pmatrix} 1.000000&2.000000&3.000000& 1 \\ 4.000000&5.000000&6.000000& 1 \\ 7.000000&8.000000&0.000000& 1 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 7.000000&8.000000&0.000000& 1 \\ 4.000000&5.000000&6.000000& 1 \\ 1.000000&2.000000&3.000000& 1 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 7.000000&8.000000&0.000000& 1 \\ 0.000000&0.428571&6.000000& 0.428571 \\ 0.000000&0.857143&3.000000& 0.857143 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 7.000000&8.000000&0.000000& 1 \\ 0.000000&0.857143&3.000000& 0.857143 \\ 0.000000&0.428571&6.000000& 0.428571 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 7.000000&8.000000&0.000000& 1 \\ 0.000000&0.857143&3.000000& 0.857143 \\ 0.000000&0.000000&4.500000& 0 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 7.000000&8.000000&0.000000& 1 \\ 0.000000&0.857143&0.000000& 0.857143 \\ 0.000000&0.000000&1.000000& 0 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 7.000000&0.000000&0.000000& -7 \\ 0.000000&1.000000&0.000000& 1 \\ 0.000000&0.000000&1.000000& 0 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 1.000000&0.000000&0.000000& -1 \\ 0.000000&1.000000&0.000000& 1 \\ 0.000000&0.000000&1.000000& 0 \\ \end{pmatrix} \end{aligned} 1.0000004.0000007.0000002.0000005.0000008.0000003.0000006.0000000.000000111 7.0000004.0000001.0000008.0000005.0000002.0000000.0000006.0000003.000000111 7.0000000.0000000.0000008.0000000.4285710.8571430.0000006.0000003.00000010.4285710.857143 7.0000000.0000000.0000008.0000000.8571430.4285710.0000003.0000006.00000010.8571430.428571 7.0000000.0000000.0000008.0000000.8571430.0000000.0000003.0000004.50000010.8571430 7.0000000.0000000.0000008.0000000.8571430.0000000.0000000.0000001.00000010.8571430 7.0000000.0000000.0000000.0000001.0000000.0000000.0000000.0000001.000000710 1.0000000.0000000.0000000.0000001.0000000.0000000.0000000.0000001.000000110

全选主元Gauss消去法

全选主元Gauss消去法是在列选主元Gauss消去法的基础上, 进一步扩大主元的搜索区间到整个矩阵, 精度更高, 但需要更多的计算量. 全选主元法选取了矩阵中最大值的元素作为主元, 并进行列变换. 这使得在回代过程中, 未知数的位置可能发生改变, 因此需要同时对未知量的顺序进行变换, 从而增加了计算量. 实际使用时, 完全主元素消去法比列主元素消去法运算量大得多, 全选主元的计算时间大约是列选主元的两倍.

算法可描述为伪代码如下:

用全选主元Gauss消去法求解上例线性方程组.

利用全选主元Gauss消去法得到如下消元过程:

( 1.000000 2.000000 3.000000 1 4.000000 5.000000 6.000000 1 7.000000 8.000000 0.000000 1 ) → ( 8.000000 7.000000 0.000000 1 5.000000 4.000000 6.000000 1 2.000000 1.000000 3.000000 1 ) → ( 8.000000 7.000000 0.000000 1 0.000000 − 0.375000 6.000000 0.375 0.000000 − 0.750000 3.000000 0.75 ) → ( 8.000000 0.000000 7.000000 1 0.000000 6.000000 − 0.375000 0.375 0.000000 3.000000 − 0.750000 0.75 ) → ( 8.000000 0.000000 7.000000 1 0.000000 6.000000 − 0.375000 0.375 0.000000 0.000000 − 0.562500 0.5625 ) → ( 8.000000 0.000000 0.000000 8 0.000000 6.000000 0.000000 0 0.000000 0.000000 1.000000 − 1 ) → ( 8.000000 0.000000 0.000000 8 0.000000 1.000000 0.000000 0 0.000000 0.000000 1.000000 − 1 ) → ( 1.000000 0.000000 0.000000 1 0.000000 1.000000 0.000000 0 0.000000 0.000000 1.000000 − 1 ) \begin{aligned} &\begin{pmatrix} 1.000000&2.000000&3.000000& 1 \\ 4.000000&5.000000&6.000000& 1 \\ 7.000000&8.000000&0.000000& 1 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 8.000000&7.000000&0.000000& 1 \\ 5.000000&4.000000&6.000000& 1 \\ 2.000000&1.000000&3.000000& 1 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 8.000000&7.000000&0.000000& 1 \\ 0.000000&-0.375000&6.000000& 0.375 \\ 0.000000&-0.750000&3.000000& 0.75 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 8.000000&0.000000&7.000000& 1 \\ 0.000000&6.000000&-0.375000& 0.375 \\ 0.000000&3.000000&-0.750000& 0.75 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 8.000000&0.000000&7.000000& 1 \\ 0.000000&6.000000&-0.375000& 0.375 \\ 0.000000&0.000000&-0.562500& 0.5625 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 8.000000&0.000000&0.000000& 8 \\ 0.000000&6.000000&0.000000& 0 \\ 0.000000&0.000000&1.000000& -1 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 8.000000&0.000000&0.000000& 8 \\ 0.000000&1.000000&0.000000& 0 \\ 0.000000&0.000000&1.000000& -1 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 1.000000&0.000000&0.000000& 1 \\ 0.000000&1.000000&0.000000& 0 \\ 0.000000&0.000000&1.000000& -1 \\ \end{pmatrix} \end{aligned} 1.0000004.0000007.0000002.0000005.0000008.0000003.0000006.0000000.000000111 8.0000005.0000002.0000007.0000004.0000001.0000000.0000006.0000003.000000111 8.0000000.0000000.0000007.0000000.3750000.7500000.0000006.0000003.00000010.3750.75 8.0000000.0000000.0000000.0000006.0000003.0000007.0000000.3750000.75000010.3750.75 8.0000000.0000000.0000000.0000006.0000000.0000007.0000000.3750000.56250010.3750.5625 8.0000000.0000000.0000000.0000006.0000000.0000000.0000000.0000001.000000801 8.0000000.0000000.0000000.0000001.0000000.0000000.0000000.0000001.000000801 1.0000000.0000000.0000000.0000001.0000000.0000000.0000000.0000001.000000101

Gauss-Jordan消去法

Gauss-Jordan消去法是高斯消元法的另一个版本, 其方法与高斯消元法相同. 唯一相异之处是该算法产生出来的矩阵是一个简化行梯阵式, 而不是高斯消元法中的行梯阵式. 相比起高斯消元法, Gauss-Jordan消去法的效率较低, 但可以把方程组的解用矩阵一次过表示出来.

Gauss-Jordan消去法也有顺序, 列选主元和全选主元3种消去方式. 由于列主元素消去法的舍入误差一般已较小, 所以在实际计算中多用列主元素消去法. 故算法实现一般采用列选主元Gauss-Jordan消去法.

算法可描述为伪代码如下:

用列选主元Gauss消去法求解上例线性方程组.

利用列选主元Gauss-Jordan消去法得到如下消元过程:

( 1.000000 2.000000 3.000000 1 4.000000 5.000000 6.000000 1 7.000000 8.000000 0.000000 1 ) → ( 7.000000 8.000000 0.000000 1 4.000000 5.000000 6.000000 1 1.000000 2.000000 3.000000 1 ) → ( 1.000000 1.142857 0.000000 0.142857 0.000000 0.428571 6.000000 0.428571 0.000000 0.857143 3.000000 0.857143 ) → ( 1.000000 1.142857 0.000000 0.142857 0.000000 0.857143 3.000000 0.857143 0.000000 0.428571 6.000000 0.428571 ) → ( 1.000000 0.000000 − 4.000000 − 1 0.000000 1.000000 3.500000 1 0.000000 0.000000 4.500000 0 ) → ( 1.000000 0.000000 0.000000 − 1 0.000000 1.000000 0.000000 1 0.000000 0.000000 1.000000 0 ) \begin{aligned} &\begin{pmatrix} 1.000000&2.000000&3.000000& 1 \\ 4.000000&5.000000&6.000000& 1 \\ 7.000000&8.000000&0.000000& 1 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 7.000000&8.000000&0.000000& 1 \\ 4.000000&5.000000&6.000000& 1 \\ 1.000000&2.000000&3.000000& 1 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 1.000000&1.142857&0.000000& 0.142857 \\ 0.000000&0.428571&6.000000& 0.428571 \\ 0.000000&0.857143&3.000000& 0.857143 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 1.000000&1.142857&0.000000& 0.142857 \\ 0.000000&0.857143&3.000000& 0.857143 \\ 0.000000&0.428571&6.000000& 0.428571 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 1.000000&0.000000&-4.000000& -1 \\ 0.000000&1.000000&3.500000& 1 \\ 0.000000&0.000000&4.500000& 0 \\ \end{pmatrix}\\\rightarrow& \begin{pmatrix} 1.000000&0.000000&0.000000& -1 \\ 0.000000&1.000000&0.000000& 1 \\ 0.000000&0.000000&1.000000& 0 \\ \end{pmatrix} \end{aligned} 1.0000004.0000007.0000002.0000005.0000008.0000003.0000006.0000000.000000111 7.0000004.0000001.0000008.0000005.0000002.0000000.0000006.0000003.000000111 1.0000000.0000000.0000001.1428570.4285710.8571430.0000006.0000003.0000000.1428570.4285710.857143 1.0000000.0000000.0000001.1428570.8571430.4285710.0000003.0000006.0000000.1428570.8571430.428571 1.0000000.0000000.0000000.0000001.0000000.0000004.0000003.5000004.500000110 1.0000000.0000000.0000000.0000001.0000000.0000000.0000000.0000001.000000110

算法实现

首先进行预处理如下:

#include <armadillo>
#include <vector>
using namespace arma;
using namespace std;

顺序Gauss消去法

/*
 * 顺序Gauss消去法
 * A : 系数矩阵
 * b : 常数向量
 * uA: 系数矩阵消元过程
 * ub: 常数向量消元过程
 * e : 判零标准
 *
 * 返回(bool):
 *  true : 求解失败
 *  false: 求解成功
 *
 * 不检查矩阵维数是否匹配问题
 */
bool Sequential_Gauss(mat A, vec b, vector<mat> &uA, vector<vec> &ub, const double &e = 1e-6)
{
    uA.clear();
    ub.clear();
    uA.push_back(A);
    ub.push_back(b);
    unsigned n(A.n_cols - 1), m(-1);
    // 消元
    for (unsigned i(0); i != n; ++i) // arma::mat的迭代器不太好用, 最后还是用了下标形式, 效率相比迭代器低一些
    {
        if (A.at(i, i) < e && A.at(i, i) > -e)
            return true;
        for (unsigned j(i + 1); j != A.n_cols; ++j)
        {
            double t(A.at(j, i) / A.at(i, i));
            A.at(j, i) = 0;
            b.at(j) -= t * b.at(i);
            for (unsigned k(i + 2); k < A.n_cols; ++k)
                A.at(j, k) -= t * A.at(i, k);
        }
        uA.push_back(A);
        ub.push_back(b);
    }
    // 回代
    do
    {
        if (A.at(n, n) < e && A.at(n, n) > -e)
            return true;
        b.at(n) /= A.at(n, n);
        A.at(n, n) = 1;
        for (unsigned i(0); i != n; ++i)
        {
            b.at(i) -= A.at(i, n) * b.at(n);
            A.at(i, n) = 0;
        }
        uA.push_back(A);
        ub.push_back(b);
    } while (--n != m);
    return false;
}

列选主元Gauss消去法

/*
 * 列选主元Gauss消去法
 * A : 系数矩阵
 * b : 常数向量
 * uA: 系数矩阵消元过程
 * ub: 常数向量消元过程
 * e : 判零标准
 *
 * 返回(bool):
 *  true : 求解失败
 *  false: 求解成功
 *
 * 不检查矩阵维数是否匹配问题
 */
bool Col_Gauss(mat A, vec b, vector<mat> &uA, vector<vec> &ub, const double &e = 1e-6)
{
    uA.clear();
    ub.clear();
    uA.push_back(A);
    ub.push_back(b);
    unsigned n(A.n_cols - 1), m(-1);
    for (unsigned i(0); i != n; ++i) // 消元
    {
        unsigned max(i); // 选列主元
        for (unsigned j(i + 1); j != A.n_cols; ++j)
            if (abs(A.at(j, i)) > abs(A.at(max, i)))
                max = j;
        if (abs(A.at(max, i)) < e)
            return true;
        if (max != i)
        {
            for (unsigned j(i); j != A.n_cols; ++j)
            {
                double t(A.at(i, j));
                A.at(i, j) = A.at(max, j);
                A.at(max, j) = t;
            }
            double t(b.at(max));
            b.at(max) = b.at(i);
            b.at(i) = t;
            uA.push_back(A);
            ub.push_back(b);
        }
        for (unsigned j(i + 1); j != A.n_cols; ++j)
        {
            double t(A.at(j, i) / A.at(i, i));
            A.at(j, i) = 0;
            b.at(j) -= t * b.at(i);
            for (unsigned k(i + 1); k < A.n_cols; ++k)
                A.at(j, k) -= t * A.at(i, k);
        }
        uA.push_back(A);
        ub.push_back(b);
    }
    do // 回代
    {
        if (A.at(n, n) < e && A.at(n, n) > -e)
            return true;
        b.at(n) /= A.at(n, n);
        A.at(n, n) = 1;
        for (unsigned i(0); i != n; ++i)
        {
            b.at(i) -= A.at(i, n) * b.at(n);
            A.at(i, n) = 0;
        }
        uA.push_back(A);
        ub.push_back(b);
    } while (--n != m);
    return false;
}

全选主元Gauss消去法

/*
 * 全选主元Gauss消去法
 * A : 系数矩阵
 * b : 常数向量
 * uA: 系数矩阵消元过程
 * ub: 常数向量消元过程
 * r : 解向量
 * e : 判零标准
 *
 * 返回(bool):
 *  true : 求解失败
 *  false: 求解成功
 *
 * 不检查矩阵维数是否匹配问题
 */
bool All_Gauss(mat A, vec b, vector<mat> &uA, vector<vec> &ub, vec &r, const double &e = 1e-6)
{
    uA.clear();
    ub.clear();
    uA.push_back(A);
    ub.push_back(b);
    r.zeros(A.n_cols);
    unsigned n(A.n_cols - 1), m(-1), *a(new unsigned[A.n_cols]);
    for (unsigned t(0); t < A.n_rows; ++t) // 初始化排序向量
        a[t] = t;
    for (unsigned i(0); i != n; ++i) // 消元
    {
        unsigned x(i), y(i); // 选主元
        for (unsigned j(i); j != A.n_cols; ++j)
            for (unsigned k(i); k != A.n_cols; ++k)
                if (abs(A.at(j, k)) > abs(A.at(x, y)))
                {
                    x = j;
                    y = k;
                }
        if (abs(A.at(x, y)) < e)
        {
            delete[] a;
            return true;
        }
        bool flag(false);
        if (x != i)
        {
            for (unsigned j(i); j < A.n_cols; ++j)
            {
                double t(A.at(x, j));
                A.at(x, j) = A.at(i, j);
                A.at(i, j) = t;
            }
            double t(b.at(x));
            b.at(x) = b.at(i);
            b.at(i) = t;
            flag = true;
        }
        if (y != i)
        {
            for (unsigned j(0); j < A.n_cols; ++j)
            {
                double t(A.at(j, i));
                A.at(j, i) = A.at(j, y);
                A.at(j, y) = t;
            }
            flag = true;
            unsigned t(a[i]);
            a[i] = a[y];
            a[y] = t;
        }
        if (flag)
        {
            uA.push_back(A);
            ub.push_back(b);
        }
        for (unsigned j(i + 1); j != A.n_cols; ++j)
        {
            double t(A.at(j, i) / A.at(i, i));
            A.at(j, i) = 0;
            b.at(j) -= t * b.at(i);
            for (unsigned k(i + 2); k < A.n_cols; ++k)
                A.at(j, k) -= t * A.at(i, k);
        }
        uA.push_back(A);
        ub.push_back(b);
    }
    do // 回代
    {
        if (abs(A.at(n, n)) < e)
        {
            delete[] a;
            return true;
        }
        r.at(a[n]) = b.at(n) /= A.at(n, n);
        A.at(n, n) = 1;
        for (unsigned i(0); i != n; ++i)
        {
            b.at(i) -= A.at(i, n) * b.at(n);
            A.at(i, n) = 0;
        }
        uA.push_back(A);
        ub.push_back(b);
    } while (--n != m);
    delete[] a;
    return false;
}

列选主元Gauss-Jordan消去法

/*
 * 列选主元Gauss-Jordan消去法
 * A : 系数矩阵
 * b : 常数向量
 * uA: 系数矩阵消元过程
 * ub: 常数向量消元过程
 * e : 判零标准
 *
 * 返回(bool):
 *  true : 求解失败
 *  false: 求解成功
 *
 * 不检查矩阵维数是否匹配问题
 */
bool Gauss_Jordan(mat A, vec b, vector<mat> &uA, vector<vec> &ub, const double &e = 1e-6)
{
    uA.clear();
    ub.clear();
    uA.push_back(A);
    ub.push_back(b);
    unsigned n(A.n_cols - 1);
    for (unsigned i(0); i != n; ++i)
    {
        unsigned max(i); // 选列主元
        for (unsigned j(i + 1); j != A.n_cols; ++j)
            if (abs(A.at(j, i)) > abs(A.at(max, i)))
                max = j;
        if (abs(A.at(max, i)) < e)
            return true;
        if (max != i)
        {
            for (unsigned j(i); j != A.n_cols; ++j)
            {
                double t(A.at(i, j));
                A.at(i, j) = A.at(max, j);
                A.at(max, j) = t;
            }
            double t(b.at(max));
            b.at(max) = b.at(i);
            b.at(i) = t;
            uA.push_back(A);
            ub.push_back(b);
        }
        b.at(i) /= A.at(i, i);
        for (unsigned k(i + 1); k != A.n_cols; ++k)
            A.at(i, k) /= A.at(i, i);
        for (unsigned j(i + 1); j < A.n_rows; ++j)
        {
            b.at(j) -= b.at(i) * A.at(j, i);
            for (unsigned k(i + 1); k < A.n_cols; ++k)
                A.at(j, k) -= A.at(i, k) * A.at(j, i);
            A.at(j, i) = 0;
        }
        for (unsigned j(0); j != i; ++j)
        {
            b.at(j) -= b.at(i) * A.at(j, i);
            for (unsigned k(i + 1); k < A.n_cols; ++k)
                A.at(j, k) -= A.at(i, k) * A.at(j, i);
            A.at(j, i) = 0;
        }
        A.at(i, i) = 1;
        uA.push_back(A);
        ub.push_back(b);
    }
    return false;
}

实例分析

用列主元高斯消去法求解方程组

{ 0.101 x 1 + 2.304 x 2 + 3.555 x 3 = 1.183 − 1.347 x 1 + 3.712 x 2 + 4.623 x 3 = 2.137 − 2.835 x 1 + 1.072 x 2 + 5.643 x 3 = 3.035 \begin{cases} 0.101x_1+2.304x_2+3.555x_3=1.183\\ -1.347x_1+3.712x_2+4.623x_3=2.137\\ -2.835x_1+1.072x_2+5.643x_3=3.035 \end{cases} 0.101x1+2.304x2+3.555x3=1.1831.347x1+3.712x2+4.623x3=2.1372.835x1+1.072x2+5.643x3=3.035

代入程序, 求得列主元高斯消元过程如下:

( 0.101000 2.304000 3.555000 1.183 − 1.347000 3.712000 4.623000 2.137 − 2.835000 1.072000 5.643000 3.035 ) → ( − 2.835000 1.072000 5.643000 3.035 − 1.347000 3.712000 4.623000 2.137 0.101000 2.304000 3.555000 1.183 ) → ( − 2.835000 1.072000 5.643000 3.035 0.000000 3.202658 1.941829 0.694974 0.000000 2.342191 3.756038 1.29113 ) → ( − 2.835000 1.072000 5.643000 3.035 0.000000 3.202658 1.941829 0.694974 0.000000 0.000000 2.335926 0.782872 ) → ( − 2.835000 1.072000 0.000000 1.14378 0.000000 3.202658 0.000000 0.0441809 0.000000 0.000000 1.000000 0.335144 ) → ( − 2.835000 0.000000 0.000000 1.12899 0.000000 1.000000 0.000000 0.0137951 0.000000 0.000000 1.000000 0.335144 ) → ( 1.000000 0.000000 0.000000 − 0.398234 0.000000 1.000000 0.000000 0.0137951 0.000000 0.000000 1.000000 0.335144 ) \begin{aligned} \begin{pmatrix} 0.101000&2.304000&3.555000& 1.183 \\ -1.347000&3.712000&4.623000& 2.137 \\ -2.835000&1.072000&5.643000& 3.035 \\ \end{pmatrix}\\\rightarrow \begin{pmatrix} -2.835000&1.072000&5.643000& 3.035 \\ -1.347000&3.712000&4.623000& 2.137 \\ 0.101000&2.304000&3.555000& 1.183 \\ \end{pmatrix}\\\rightarrow \begin{pmatrix} -2.835000&1.072000&5.643000& 3.035 \\ 0.000000&3.202658&1.941829& 0.694974 \\ 0.000000&2.342191&3.756038& 1.29113 \\ \end{pmatrix}\\\rightarrow \begin{pmatrix} -2.835000&1.072000&5.643000& 3.035 \\ 0.000000&3.202658&1.941829& 0.694974 \\ 0.000000&0.000000&2.335926& 0.782872 \\ \end{pmatrix}\\\rightarrow \begin{pmatrix} -2.835000&1.072000&0.000000& 1.14378 \\ 0.000000&3.202658&0.000000& 0.0441809 \\ 0.000000&0.000000&1.000000& 0.335144 \\ \end{pmatrix}\\\rightarrow \begin{pmatrix} -2.835000&0.000000&0.000000& 1.12899 \\ 0.000000&1.000000&0.000000& 0.0137951 \\ 0.000000&0.000000&1.000000& 0.335144 \\ \end{pmatrix}\\\rightarrow \begin{pmatrix} 1.000000&0.000000&0.000000& -0.398234 \\ 0.000000&1.000000&0.000000& 0.0137951 \\ 0.000000&0.000000&1.000000& 0.335144 \\ \end{pmatrix} \end{aligned} 0.1010001.3470002.8350002.3040003.7120001.0720003.5550004.6230005.6430001.1832.1373.035 2.8350001.3470000.1010001.0720003.7120002.3040005.6430004.6230003.5550003.0352.1371.183 2.8350000.0000000.0000001.0720003.2026582.3421915.6430001.9418293.7560383.0350.6949741.29113 2.8350000.0000000.0000001.0720003.2026580.0000005.6430001.9418292.3359263.0350.6949740.782872 2.8350000.0000000.0000001.0720003.2026580.0000000.0000000.0000001.0000001.143780.04418090.335144 2.8350000.0000000.0000000.0000001.0000000.0000000.0000000.0000001.0000001.128990.01379510.335144 1.0000000.0000000.0000000.0000001.0000000.0000000.0000000.0000001.0000000.3982340.01379510.335144

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mfbz.cn/a/318574.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

开源云原生安全的现状

近年来&#xff0c;人们非常重视软件供应链的安全。尤其令人担忧的是开源软件发行版中固有的风险越来越多。这引发了围绕云原生开源安全的大量开发&#xff0c;其形式包括软件物料清单 (SBOM)、旨在验证 OSS 包来源的项目等。 许多组织循环使用大型开源包&#xff0c;但只使用…

NLP技术在搜索推荐场景中的应用

NLP技术在搜索推荐中的应用非常广泛&#xff0c;例如在搜索广告的CTR预估模型中&#xff0c;NLP技术可以从语义角度提取一些对CTR预测有效的信息&#xff1b;在搜索场景中&#xff0c;也经常需要使用NLP技术确定展现的物料与搜索query的相关性&#xff0c;过滤掉相关性较差的物…

设计模式——抽象工厂模式(Abstract Factory Pattern)

概述 抽象工厂模式的基本思想是将一些相关的产品组成一个“产品族”&#xff0c;由同一个工厂统一生产。在工厂方法模式中具体工厂负责生产具体的产品&#xff0c;每一个具体工厂对应一种具体产品&#xff0c;工厂方法具有唯一性&#xff0c;一般情况下&#xff0c;一个具体工厂…

YOLOv5改进 | 二次创新篇 | 结合iRMB和EMA形成全新的iEMA机制(全网独家创新)

一、本文介绍 本文给大家带来的改进机制是二次创新的机制,二次创新是我们发表论文中关键的一环,为什么这么说,从去年的三月份开始对于图像领域的论文发表其实是变难的了,在那之前大家可能搭搭积木的情况下就可以简单的发表一篇论文,但是从去年开始单纯的搭积木其实发表论…

第1课 ROS 系统介绍

1.ROS操作系统介绍 在学习ROS 系统前&#xff0c;我们需要先了解操作系统的定义。操作系统&#xff0c;顾名思义&#xff0c;即提供部分软件和硬件的接口&#xff0c;以供用户直接使用。因此&#xff0c;针对不同的平台、不同的功能&#xff0c;需要采用不同的操作系统来完成底…

Three.js 纹理贴图的实现

在线工具推荐&#xff1a; 3D数字孪生场景编辑器 - GLTF/GLB材质纹理编辑器 - 3D模型在线转换 - Three.js AI自动纹理开发包 - YOLO 虚幻合成数据生成器 - 三维模型预览图生成器 - 3D模型语义搜索引擎 纹理贴图简介 当我们创建一个网格时&#xff0c;比如我们不起眼的立…

大模型开启应用时代 数钉科技一锤定音

叮叮叮叮&#xff01;数钉智造大模型&#xff0c;“定音”强势发布&#xff01; 随着科技的飞速发展&#xff0c;大模型技术已逐渐成为推动产业变革的核心力量。在这一浪潮中&#xff0c;数钉科技凭借深厚的技术积累和敏锐的市场洞察力&#xff0c;成功利用大模型技术搭建起智能…

鸿蒙开发-UI-布局

鸿蒙开发-序言 鸿蒙开发-工具 鸿蒙开发-初体验 鸿蒙开发-运行机制 鸿蒙开发-运行机制-Stage模型 鸿蒙开发-UI 鸿蒙开发-UI-组件 鸿蒙开发-UI-组件-状态管理 鸿蒙开发-UI-应用-状态管理 鸿蒙开发-UI-渲染控制 文章目录 前言 一、布局概述 1.布局结构 2.布局元素组成 3.布局分类 …

场效应管在电路中如何控制电流大小

场效应管的概念 场效应晶体管&#xff08;FieldEffectTransistor缩写&#xff08;FET&#xff09;&#xff09;简称场效应管。主要有两种类型&#xff08;juncTIonFET—JFET&#xff09;和金属-氧化物半导体场效应管&#xff08;metal-oxidesemiconductorFET&#xff0c;简称M…

操作系统详解(5)——信号(Signal)

系列文章&#xff1a; 操作系统详解(1)——操作系统的作用 操作系统详解(2)——异常处理(Exception) 操作系统详解(3)——进程、并发和并行 操作系统详解(4)——进程控制(fork, waitpid, sleep, execve) 文章目录 概述信号的种类Hardware EventsSoftware Events 信号的原理信号…

YOLOv8改进 | 注意力篇 | 实现级联群体注意力机制CGAttention (全网首发)

一、本文介绍 本文给大家带来的改进机制是实现级联群体注意力机制CascadedGroupAttention,其主要思想为增强输入到注意力头的特征的多样性。与以前的自注意力不同,它为每个头提供不同的输入分割,并跨头级联输出特征。这种方法不仅减少了多头注意力中的计算冗余,而且通过增…

虚幻UE 特效-Niagara特效初识

虚幻的Niagara特效系统特别的强大&#xff0c;可以为开发者提供丰富的视觉效果&#xff01; 本篇笔记对Niagara系统进行初步的学习探索 文章目录 前言一、Niagara四大核心组件二、粒子发射器和粒子系统1、粒子发射器的创建2、粒子系统的创建3、Niagara系统的使用 总结 前言 在…

【SSM框架】初识Spring

初识Spring Spring家族 Spring发展到今天已经形成了一种开发的生态圈&#xff0c;Spring提供了若千个项目&#xff0c;每个项目用于完成特定的功能 ✅Spring Framework&#xff08;底层框架&#xff09;Spring Boot&#xff08;提高开发速度&#xff09;Spring Cloud&#xf…

C# 图解教程 第5版 —— 第24章 预处理指令

文章目录 24.1 什么是预处理指令24.2 基本规则24.3 符号指令&#xff08;#define、#undef &#xff09;24.4 条件编译&#xff08;#if、#else、#elif、#endif&#xff09;24.5 条件编译结构24.6 诊断指令&#xff08;#warning、#error&#xff09;24.7 行号指令&#xff08;#li…

最新域名群站开源系统:打造强大网站矩阵,引领SEO优化新潮流!

搭建步骤 第一步&#xff1a;安装PHP和MYSQL服务器环境 对于想要深入了解网站建设的人来说&#xff0c;自己动手安装PHP和MYSQL服务器环境是必不可少的步骤。这将使你能够更好地理解网站的运行机制&#xff0c;同时为后续的网站开发和优化打下坚实基础。 第二步&#xff1a;…

迅腾文化用网络集成化生态系统助力品牌之路的坚实后盾

商业竞争激烈&#xff0c;品牌不仅是企业的标志和形象&#xff0c;更是其核心价值和竞争力的体现。然而&#xff0c;企业在品牌推广过程中面临着诸多如缺乏有效的渠道管理、品牌形象模糊以及竞争激烈的市场环境等。这些阻碍着企业的品牌发展和市场占有率的提升。本文将通过企业…

[GN] nodejs16.13.0版本完美解决node-sass和sass-loader版本冲突问题

项目场景&#xff1a; npm install 运行vue项目时候 问题描述 项目场景&#xff1a;sass-loader &#xff0c;node-sass出错 ! ERESOLVE unable to resolve dependency tree npm ERR! npm ERR! While resolving: smoore-mes-web1.4.0 npm ERR! Found: webpack3.12.0 npm ER…

【计算机组成原理】高速缓冲存储器 Cache 的写策略(Writing Policy)

写策略 Writing Policy 缓存的写策略指的是确定何时将数据写入缓存或主存的策略。 写命中 Write Hit 全写法 Write Through 在全写法策略中&#xff0c;每次发生写操作时都会将数据同时写入缓存和主存。这样可以保证数据的一致性&#xff0c;但会增加主存的写入操作&#xf…

ubuntu连接xshell怎么连接

在网上找了好多办法都不行 例如 太久没打开Ubuntu可能输入命令查不到IP地址&#xff0c;解决办法也比较简单&#xff0c;首先第一步 确定自己能不能进入管理员root权限&#xff08;输入命令su&#xff09;&#xff0c;如果没有的话得重新配置&#xff0c;如下图 这是因为当前Ub…

黑马程序员JavaWeb开发|案例:tlias智能学习辅助系统(1)准备工作、部门管理

一、准备工作 1.明确需求 根据产品经理绘制的页面原型&#xff0c;对部门和员工进行相应的增删改查操作。 2.环境搭建 将使用相同配置的不同项目作为Module放入同一Project&#xff0c;以提高相同配置的复用性。 准备数据库表&#xff08;dept, emp&#xff09; 资料中包含…
最新文章