计算机求解线性方程组

0. 引言

在很多工程求解问题中，大部分的数值计算都可以归结为求解线性方程组的问题，所以求解线性方程组是数值计算中最为重要的一部分。其中还有很多其他数值计算中，其中的关键步骤都涉及到线性方程组的求解。由克莱姆法则可知，线性方程组$Ax=b$中，系数矩阵的行列式$\det (A)\ne 0$，则线性方程组具有唯一解。克莱姆法则在计算高维度情况下的矩阵运算中计算量很大，不适合求解一般情况下的线性方程组。常见的求解线性方程组的方法有两种，即直接方法和迭代方法。直接方法是指通过有限的步骤计算直接求解出方程组的精确解的方法。迭代的方法值得是用极限的过程去逐步逼近线性方程组精确解的方法。本节将实现这几种求解的方法。

1. 直接消元法

直接消元的方法是一种便捷的求解线性方程组的方法。高斯消去方法是最为古老的一种线性方程组求解的方法。通过改进高斯消去法得到更加便捷的主元素消去法、矩阵的三角分解(即Doolittle分解方法)，是用于求解低阶稠密方程组的有效方法。特点是，通过消元将一般的线性方程组求解问题转化为上三角方程组求解问题。

1.1 高斯消元法

1.1.1 顺序高斯消去法

一般地，设$n$阶线性方程组为
$$\{\begin{array}{l}{a}_{11}^{(0)}{x}_1+a_{12}^{(0)}{x}_2+...+a_{1n}^{(0)}{x}_n=b_1^{(0)}\\ a_{21}^{(0)}{x}_1+a_{22}^{(0)}{x}_2+...+a_{2n}^{(0)}{x}_n=b_2^{(0)}\\ :\\ a_{n1}^{(0)}{x}_1+a_{n2}^{(0)}{x}_2+...+a_{nn}^{(0)}{x}_n=b_n^{(0)}\end{array}$$
写成增广矩阵的方式为
$$(A^{(0)}|b^{(0)})=\left[\begin{array}{ccccc}{a}_{11}^{(0)}& a_{12}^{(0)}& ...& a_{1n}^{(0)}& b_1^{(0)}\\ a_{21}^{(0)}& a_{22}^{(0)}& ...& a_{2n}^{(0)}& b_2^{(0)}\\ :& :& :& :& :\\ a_{n1}^{(0)}& a_{n2}^{(0)}& ...& a_{nn}^{(0)}& b_n^{(0)}\end{array}\right]$$
设$l_{i1}=a_{i1}^{(0)}/a_{11}^{(0)},(i=2,3,...,n)$，将第一行的$-l_{i1}$倍加到第$i$行上，那么矩阵变为
$$(A^{(1)}|b^{(1)})\left[\begin{array}{ccccc}{a}_{11}^{(0)}& a_{12}^{(0)}& ...& a_{1n}^{(0)}& b_1^{(0)}\\ 0& a_{22}^{(1)}& ...& a_{2n}^{(1)}& b_2^{(1)}\\ :& :& :& :& :\\ a_{n1}^{(1)}& a_{n2}^{(1)}& ...& a_{nn}^{(1)}& b_n^{(1)}\end{array}\right]$$
其中，式子中
$$a_{ij}^{(1)}=a_{ij}^{(0)}-l_{i1}{a}_{1j}^{(0)},(i=2,3,...,n;j=1,2,...,n)$$

$$b_i^{(1)}=b_i^{(0)}-l_{i1}{b}_1^{(0)},(i=2,3,...,n)$$

第$k$步骤的时候，设主元素$a_{kk}^{(k-1)}\ne 0$时，设$l_{ik}=a_{ik}^{(k-1)}/a_{kk}^{(k-1)}$，并且将$(A^{(k-1)|b^{(k-1)}})$的第$k$行的$-l_{ik}$倍加到第$i$行$(i=k+1,k+2,...,n)$得到：
$$(A^{(k)}|b^{(k)})=\left[\begin{array}{cccccccc}{a}_{11}^{(0)}& a_{12}^{(0)}& ...& a_{1k}^{(0)}& a_{1(k+1)}^{(0)}& ...& a_{1n}^{(0)}& b_1^{(0)}\\ & & :& :& :& :& :& :\\ & & & a_{kk}^{(k-1)}& a_{k(k+1)}^{(0)}& ...& a_{kn}^{(k-1)}& b_k^{(k-1)}\\ & & & & a_{(k+1)(k+1)}^{(k)}& ...& a_{(k+1)n}^{(k)}& b_n^{(k)}\\ & & & & :& :& :& :\\ & & & & a_{n(k+1)}^{(k)}& ...& a_{nn}^{(k)}& b_n^{(k)}\end{array}\right]$$

式中
$$a_{ij}^{(k)}=a_{ij}^{(k-1)}-l_{ik}{a}_{kj}^{(k-1)},(i,j=k+1,k+2,...,n)$$

$$b_i^{(k)}=b_i^{(k-1)}-l_{ik}{b}_k^{(k-1)},(i=k+1,k+2,...,n)$$

所以经过$n-1$步消元之后，可以得到原方程组的同解三角形方程组$A^{(n-1)}x=b^{(n-1)}$，即
$$\left[\begin{array}{cccc}{a}_{11}^{(0)}& a_{12}^{(0)}& ...& a_{1n}^{(0)}\\ & a_{22}^{(1)}& ...& a_{2n}^{(1)}\\ & :& ...& :\\ & & & a_{nn}^{(n-1)}\end{array}\right]\left[\begin{array}{c}{x}_1\\ x_2\\ :\\ x_n\end{array}\right]=\left[\begin{array}{c}{b}_1^{(n-1)}\\ b_2^{(n-1)}\\ :\\ b_n^{(n-1)}\end{array}\right]$$

综上所述，整个方程的求解过程如下所示
对$k=1,2,...,n-1$逐次计算
$$\{\begin{array}{ll}{l}_{ik}=a_{ik}^{(k-1)}/a_{kk}^{(k-1)}& ,(i=k+1,k+2,...,n)\\ a_{ij}^{(k)}=a_{ij}^{(k-1)}-l_{ik}{a}_{kj}^{(k-1)}& ,(i,j=k+1,k+2,...,n)\\ b_i^{(k)}=b_i^{(k-1)}-l_{ik}{b}_i^{(k-1)}& ,(i=k+1,...,n)\end{array}$$

逐步回代求得原方程组的解，回代过程如下所示：
$$\{\begin{array}{ll}{x}_n=b_n^{(n-1)}/a_{nn}^{(n-1)}& \\ x_k=(b_k^{(k-1)}-\sum _{j=k+1}^n{a}_{kj}^{(k-1)}{x}_j)/a_{kk}^{(k-1)}& ,(k=n-1,n-2,...,1)\end{array}$$

一般地，如果$n$阶矩阵$A$的顺序主子式均不为零，那么高斯消去法中求解线性方程组$Ax=b$的主元素满足$a_{kk}^{(k-1)}\ne 0$
代码实现如下所示：

def GaussianSeq(Mat,Bais):
    if (Mat.shape[0]!=Mat.shape[1]) or (Mat.shape[0]!=Bais.shape[0]):
        raise ValueError("size of matrix doesn't match!")
    A = Mat.copy()
    b = Bais.copy()
    n = A.shape[0]
    # 消元过程
    for k in range(n):
        for i in range(k+1,n):
            l_ik = A[i,k]/A[k,k]
            for j in range(k,n):
                A[i, j] = A[i, j] - l_ik * A[k, j]
            b[i] = b[i] - l_ik*b[k]
    # 回代过程
    x = np.zeros((n,))
    x[n-1] = b[n-1]/A[n-1,n-1]
    for k in range(n-2,-1,-1):
        x[k] = (b[k]-np.sum(A[k,k+1:]*x[k+1:]))/A[k,k]
    return x

1.1.2 主元素高斯消去法

主元素高斯消去法主要解决的是舍入误差的扩大和传播而提出来的。事实上，从消元过程中可以看出来，当$|l_{ik}|=|a_{ik}^{(k-1)}/a_{kk}^{(k-1)}|>1$时候，若$a_{kj}^{(k\ast -1)}$有舍入误差$e_{k-1}$，则经过计算$a_{ij}^{(k)}=a_{ij}^{(k-1)}-l_{ik}{a}_{kj}^{(k-1)}$，$a_{kj}$会有比$e_{k-1}$更大的舍入误差$e_k=|l_{ik}|e_{k-1}$。解决的方法是用交换的方法或者交换未知数次序的方法，选择绝对值尽可能大的系数作为第$k$次消元过程中的主元素$a_{kk}^{(k-1)}$。所以基本的算法过程如下所示：
输入： 矩阵系数$A$和$b$

记$(A|b)$为$A_{n\times (n+1)}$

$\text{ for }k=1,2,...,n-1$

消元过程：按照第$k$列选定主元素，确定$r$使得$|a_{rk}|=\underset{k\le i\le k+1}{\max }|a_{ik}|$

• 判断$|a_{rk}|$是否等于0，如果是，则系数矩阵为奇异矩阵，退出计算过程；如果不是，则
  • 如果$r>k$，则
    • 对于$j=k+1,...,n+1$交换$r,k$两行元素：$a_{rj}\leftrightarrow a_{kj}$
  • 对于$i=k+1,k+2,...$，计算
    • $a_{ik}=a_{ik}/a_{kk}$
      • 对于$j=k+1,k+2,...,n,n+1$，计算
        • $a_{ij}=a_{ij}-a_{ik}{a}_{kj}$
          $\text{ end for }$

回代过程：$a_{nn+1}=a_{nn+1}/a_{nn}$
$\text{ for }k=1,2,...,n-1$

• 计算$a_{kn+1}=(a_{kn+1}-\sum _{j=k+1}^n{a}_{kj}{a}_{jn+1})/a_{kk}$

$\text{ end for }$
输出： 未知数方程的解$x=(a_{1n+1},a_{2n+1},...,a_{nn+1})$
用numpy实现过程为：

def GaussianMain(Mat,Bais):
    if (Mat.shape[0]!=Mat.shape[1]) or (Mat.shape[0]!=Bais.shape[0]):
        raise ValueError("size of matrix doesn't match!")
    A = Mat.copy()
    b = Bais.copy()
    n = A.shape[0]
    # 消元过程
    for k in range(n):
        # 选定主元素
        r = k
        for j in range(k,n):
            if np.abs(A[j,k])>np.abs(A[r,k]):
                r = j
        # 交换行
        A[[r, k], :] = A[[k, r], :]
        b[r],b[k] = b[k],b[r]
        if np.abs(A[k,k])< 1e-150:
            raise np.linalg.LinAlgError
        for i in range(k+1,n):
            l_ik = A[i,k]/A[k,k]
            for j in range(k,n):
                A[i, j] = A[i, j] - l_ik * A[k, j]
            b[i] = b[i] - l_ik*b[k]

    # 回代过程
    x = np.zeros((n,))
    x[n-1] = b[n-1]/A[n-1,n-1]
    for k in range(n-2,-1,-1):
        x[k] = (b[k]-np.sum(A[k,k+1:]*x[k+1:]))/A[k,k]
    return x

1.1.3 高斯-约当(Gauss-Jordan)消去法

高斯消去法是将系数矩阵$A$变为上三角矩阵。高斯约当消去法是将对角线上方和下方的元素都消去，使得系数矩阵变为单位矩阵，这样就不需要回代过程。
所以计算过程变为：
$\{\begin{array}{ll}{a}_{kj}^{(k)}=a_{kj}^{(k-1)}/a_{kk}^{(k-1)}& ,(j=k,k+1,...,n)\\ a_{ij}^{(k)}=a_{ij}^{(k-1)}-a_{ik}^{(k-1)}\times a_{kj}^{(k)}& ,(i=1,2,...,n,i\ne k,j=k,k+1,...,n)\\ b_k^{(k)}=b_k^{(k-1)}/a_{kk}^{(k-1)}& \\ b_k^{(k)}=b_k^{(k-1)}-a_{ik}^{(k-1)}\times b_k^{(k)}& \end{array}$

用numpy实现为：

def Gauss_Jordan(Mat,Bais):
    if (Mat.shape[0] != Mat.shape[1]) or (Mat.shape[0] != Bais.shape[0]):
        raise ValueError("size of matrix doesn't match!")
    A = Mat.copy()
    b = Bais.copy()
    n = A.shape[0]
    # 消元过程
    for k in range(n):
        # 选定主元素
        r = k
        for j in range(k, n):
            if np.abs(A[j, k]) > np.abs(A[r, k]):
                r = j
        # 交换行
        A[[r, k], :] = A[[k, r], :]
        b[r], b[k] = b[k], b[r]
        if np.abs(A[k, k]) < 1e-150:
            raise np.linalg.LinAlgError

        tmp = A[k, k]
        for j in range(k,n):
            A[k,j] = A[k,j]/tmp
        b[k] = b[k]/tmp
        for i in range(n):
            if i!=k:
                tmp = A[i,k]
                for j in range(k,n):
                    A[i,j] = A[i,j] - tmp *A[k,j]
                b[i] = b[i] - tmp*b[k]
    return b

1.2 三角分解方法

这种算法也称作是Doolittle分解法，或者是LU分解。一般地，任意一个矩阵不一定有LU分解。有以下定理：
定理一：对任意矩阵$A\in R^{n\times n}$，若$A$的顺序主子式均不为零，则$A$具有唯一的LU分解。
定理二：若矩阵$A\in R^{n\times n}$非奇异，并且其$LU$分解存在，则$A$的$LU$分解是唯一的。
这样，如果对于线性方程组$Ax=b$中系数矩阵$A=LU$，那么方程可以写为$(LU)x=b$。所以设
$$\{\begin{array}{l}Ux=y\\ Ly=b\end{array}$$

所以进一步我们改进这种方程的求解方法。
设
$$A=\left[\begin{array}{cccc}{a}_{11}& a_{12}& ...& a_{1n}\\ a_{21}& a_{22}& ...& a_{2n}\\ :& :& :& :\\ a_{n1}& a_{n2}& ...& a_{nn}\end{array}\right]=\left[\begin{array}{cccc}{l}_{11}& & & \\ l_{21}& l_{22}& & \\ :& :& & \\ l_{n1}& l_{n2}& ...& l_{nn}\end{array}\right]\left[\begin{array}{cccc}{u}_{11}& u_{12}& ...& u_{1n}\\ & u_{22}& ...& u_{2n}\\ & & :& :\\ & & & u_{nn}\end{array}\right]$$
我们在这里设$l_{ii}=1,(i=1,2,..,n)$
这样可以得到，对于$k=1,2,...,n$
$$\begin{gathered} u_{kj}=a_{kj}-\sum _{r=1}^{k-1}{l}_{kr}{u}_{rj},(j=k,k+1,...,n) \\ {l}_{ik}=(a_{ik}-\sum _{r=1}^{k-1}{l}_{ir}{u}_{rk})/u_{kk},(i=k+1,k+2,...,n) \end{gathered}$$
回代过程为：
$$\{\begin{array}{ll}{y}_1=b_1& \\ y_k=b_k-\sum _{j=1}^{k-1}{l}_{kj}{y}_i& ,(k=2,3,...,n)\end{array}$$

$$\{\begin{array}{ll}{x}_n=y_n/u_{nn}& \\ x_k=(y_k-\sum _{j=k+1}^n{u}_{kj}{x}_j)/u_{kk}& ,(k=n-1,n-2,...,1)\end{array}$$
用numpy实现为：

def Doolittle_LU(A):
    if A.shape[0]!=A.shape[1]:
        raise ValueError("size of matrix doesn't match!")
    L_U_mat = np.zeros(A.shape)
    n = A.shape[0]
    for k in range(n):
        for j in range(k,n):
            if k==0:
                L_U_mat[k,j] = A[k,j]
            else:
                L_U_mat[k,j] = A[k,j] - np.sum(L_U_mat[k,:k]*L_U_mat[:k,j])
        for i in range(k+1,n):
            if k==0:
                L_U_mat[i,k] = A[i,k]/L_U_mat[k,k]
            else:
                L_U_mat[i,k] = (A[i,k] -np.sum(L_U_mat[i,:k]*L_U_mat[:k,k]))/L_U_mat[k,k]
    #L = np.tril(L_U_mat,k=-1)
    #U = np.triu(L_U_mat,k=0)
    #L = L + np.diag([1.0]*n)
    return L_U_mat
def Doolittle_solve(A,b):
    if A.shape[0]!=b.shape[0]:
        raise ValueError("size of matrix doesn't match!")
    L_U_mat = Doolittle_LU(A)
    n = L_U_mat.shape[0]
    y = np.zeros((n,))
    for k in range(n):
        if k==0:
            y[k] = b[k]
        else:
            y[k] = b[k] - np.sum(L_U_mat[k,:k]*y[:k])
    x = np.zeros((n,))
    for k in range(n-1,-1,-1):
        if k == n-1:
            x[k] = y[k]/L_U_mat[k,k]
        else:
            x[k] = (y[k] - np.sum(L_U_mat[k,k+1:]*x[k+1:]))/L_U_mat[k,k]
    return x

一般地，对于对角分解方法中$A=LU$当$L$的对角线元素为$1$的时候，称为Doolittle分解；当$U$的对角线元素为$1$的时候，称为Crout分解。

1.3 解对角方程的追赶法

有一种特殊的方程被称作是系数矩阵对角占优的线性方程组，设$Ax=f$，式子中
$$A=\left[\begin{array}{cccccc}{b}_1& c_1& & & & \\ a_2& b_2& c_2& & & \\ & & :& :& :& \\ & & & a_{n-1}& b_{n-1}& c_{n-1}\\ & & & & a_n& b_n\end{array}\right],f=\left[\begin{array}{c}{f}_1\\ f_2\\ :\\ f_n\end{array}\right]$$
并且满足
$$\{\begin{array}{ll}|b_1|>|c_1|>0& \\ |b_i|\ge |a_i|+|c_i& ,|(a_i{c}_i\ne 0)\\ |b_n|>|a_n|>0& \end{array}$$

我们对矩阵$A$进行Crout分解，即
$$A=LU=\left[\begin{array}{ccccc}{l}_1& & & & \\ a_2& l_2& & & \\ & a_3& l_3& & \\ & & :& :& \\ & & & a_n& l_n\end{array}\right]\left[\begin{array}{cccccc}1& u_1& & & & \\ & 1& u_2& & & \\ & & 1& u_3& & \\ & & & :& :& \\ & & & & 1& u_n\end{array}\right]$$

这样解对角占优的方程过程如下所示：
$$\{\begin{array}{ll}{l}_1=b_1& \\ u_i=c_i/l_i& \\ l_{i+1}=b_{i+1}-a_{i+1}{u}_i& ,(i=2,...,n-1)\end{array}$$

回代过程为
$$\{\begin{array}{ll}{y}_1=f_1/l_1& \\ y_i=(f_i-a_i{y}_{i-1})/l_i& ,(i=2,...,n)\end{array}$$
$$\{\begin{array}{ll}{x}_n=y_n& \\ x_i=y_i-u_i{x}_{i+1}& ,(i=n-1,...,1)\end{array}$$

1.4 误差分析

有一种线性方程组被称作是病态方程组，这类方程组有这样的一个特点。设线性方程为$Ax=b$，那么若$A$或者$b$有微小的扰动$||\delta A||$和$||\delta b||$时候，它的解$x$扰动很大$||\delta x||$，这样的方程组被称为是病态方程组，相应的矩阵称为病态矩阵。反之，如若$||\delta x||$比很小，称方程为良态方程。一般称为$\frac{||\delta x||}{||x||}$、$\frac{||\delta A||}{||A||}$和$\frac{||\delta b||}{||b||}$为相对扰动。线性方程有扰动的时候，方程则变为
$$(A+\delta A)(x+\delta x)=b+\delta b$$

(1) $\delta A=0,\delta b\ne 0,b\ne 0$时候，则方程化为：
$$A(x+\delta x)=b+\delta b$$

由于$Ax=b$则会有
$$A\delta x=\delta b$$

由范数的定义可以得到
$$||\delta x||\le ||A^{-1}||\cdot ||\delta b||,||b||\le ||A||\cdot ||x||$$

所以得到
$$||\delta x||\cdot ||b||\le ||A||\cdot ||A^{-1}||\cdot ||x||\cdot ||\delta b||$$

从而有
$$\frac{||\delta x||}{||x||}\le ||A||\cdot ||A^{-1}||\cdot \frac{||\delta b||}{||b||}$$

(2) $\delta A\ne 0,\delta b=0,A\ne 0$时候，则方程化为
$$(A+\delta A)(x+\delta x)=b$$

所以得到
$$\delta A(x+\delta x)+A\delta x=0,\delta x=-A\delta A(x+\delta x)$$

于是又有
$$||\delta x||\le ||A^{-1}||\cdot ||\delta A||\cdot ||x+\delta x||$$

从而有
$$\frac{||\delta x||}{||x+\delta x||}\le ||A||\cdot ||A^{-1}||\cdot \frac{||\delta A||}{||A||}$$

定义条件数$\text{cond}(A)=||A||\cdot ||A^{-1}||$。一般情况下，当系数矩阵的条件数较大的时候为病态方程，较小的时候为良态方程。
解决病态方程求解方法有以下的方法：
①采用高精度的运算方法计算；
②采用预处理的方法改善系数矩阵的条件数，例如可以寻找非奇异的对角矩阵$P,Q$将方程$Ax=b$化为
$$\{\begin{array}{l}PAQy=Pb\\ y=Q^{-1}x\end{array}$$

③当矩阵$A$的元素数量级较大的时候，对于系数矩阵$A$的行或者列乘以适当的比例因子，使得矩阵$A$所有的行列按照$\infty$范数大体上有相同的长度，使得系数矩阵$A$均衡，使得$A$条件数得到基本的改善。

2. 迭代法

一般情况下，对于低维度的系数矩阵求解可以直接使用高斯消去方法求解线性方程组。但是对于高维度的线性方程矩阵，求解显得力不从心。迭代方法是一种线性方程组的近似求解方法。所以这里提出了几种矩阵求解的迭代方法。

2.1 雅克比(Jacobi)迭代法

设线性方程组$Ax=b$，将系数矩阵$A$进行分解处理：$A=D-L-U$，其中矩阵$D,L,U$如下所示
$$D=\left[\begin{array}{ccccc}{a}_{11}& & & & \\ & a_{22}& & & \\ & & a_{33}& & \\ & & & :& \\ & & & & a_{nn}\end{array}\right]$$

$$-L=\left[\begin{array}{cccccc}0& & & & & \\ a_{21}& 0& & & & \\ a_{31}& a_{32}& 0& & & \\ a_{41}& a_{42}& a_{43}& :& & \\ :& :& :& :& & \\ a_{n1}& a_{n2}& a_{n3}& ...& a_{n(n-1)}& 0\end{array}\right]$$

$$-U=\left[\begin{array}{ccccc}0& a_{12}& a_{13}& ...& a_{1n}\\ & 0& a_{23}& :& a_{2n}\\ & & :& :& :\\ & & & 0& a_{(n-1)n}\\ & & & & 0\end{array}\right]$$

则线性方程组化为$(D-L-U)x=b$，从而得到$Dx=(L+U)x+b$，于是得到
$$x=D^{-1}(L+U)x+D^{-1}b=(I-D^{-1}A)x+D^{-1}b$$

设$B_J=I-D^{-1}A,f_J=D^{-1}b$，可见通过以下的表达式进行递推可以实现方程的求解：
$$x^{(k+1)}=B_J{x}^{(k)}+f_J$$

设线性方程组为$\sum _{j=1}^n{a}_{ij}{x}_j=b_i,(i=1,2,...,n)$，假设系数矩阵$A$是非奇异矩阵，并且$a_{ii}\ne 0,(i=1,2,...,n)$,得到的等价形式：
$$x_i=\frac{1}{a_{ii}}(b_i-\sum _{j=1,j\ne i}^n{a}_{ij}{x}_j)$$

取初始向量$x^{(0)}=(x_1^{(0)},x_2^{(0)},...,x_n^{(0)}{)}^T$，使用迭代的方法可以得到迭代公式：
$$x_i^{(k+1)}=\frac{1}{a_{ii}}(-\sum _{j=1,j\ne i}^n{a}_{ij}{x}_j^{(k)}+b_i)$$

这就是雅克比迭代法。

2.2 高斯-赛德尔迭代法

雅克比迭代法是一种同步迭代的方法，它计算过程中不能够充分利用计算过程中的变量。所以对于雅克比迭代方法提出了一种改进的迭代方法，如果每一次计算出一个新的分量便立即用它取代对应的旧的变量进行迭代，可能收敛更快，故而这种方法称作高斯-赛德尔迭代方法，迭代的公式为：
$$x_i^{(k+1)}=\frac{1}{a_{ii}}(-\sum _{j=1}^{i-1}{a}_{ij}{x}_j^{(k+1)}-\sum _{j=i}^n{a}_{ij}{x}_j^{(k)}+b_i)$$

依然将系数矩阵进行分解$A=D-L-U$，将方程变为$Dx=Lx+Ux+b$。将新的分量代替旧分量，得到
$$D{x}^{(k+1)}=L{x}^{(k+1)}+U{x}^{(k)}+b$$
即
$$(D-L)x^{(k+1)}=U{x}^{(k)}+b$$

所以得到迭代表达式$x^{(k+1)}=(D-L{)}^{-1}U{x}^{(k)}+(D-L{)}^{-1}b$，设系数$B_{G-S}=(D-L{)}^{-1}U$，$f_{G-S}=(D-L{)}^{-1}b$，所以得到
$$x^{(k+1)}=B_{G-S}{x}^{(k)}+f_{G-S}$$

2.3 超松弛迭代法

逐次超松弛迭代法可以看作带参数的$\omega$的高斯-赛德尔迭代方法，是一种修正或加速，是求解大型稀疏矩阵的有效方法之一。
在高斯-赛德尔迭代方法中，由公式
$$x_i^{(k+1)}=\frac{1}{a_{ii}}(-\sum _{j=1}^{i-1}{a}_{ij}{x}_j^{(k+1)}-\sum _{j=i}^n{a}_{ij}{x}_j^{(k)}+b_i)$$

得到
$$x_i^{(k+1)}=(1-\omega )x_i^{(k)}+\omega x_i^{(k+1)}=x_i^{(k)}+\omega (x_i^{(k+1)}-x_i^{(k)})$$

其中$\omega$称作是松弛因子。
现在有两种构造超松弛迭代算法，即基于G-S迭代方法和Jacobi迭代方法：
A. 基于G-S迭代方法
$$\{\begin{array}{l}{x}_i^{(k+1)}=x_i^{(k)}+\Delta x_i\\ \Delta x_i=\omega r_i^{(k+1)}\\ r_i^{(k+1)}=\frac{1}{a_{ii}}(-\sum _{j=1}^{i-1}{a}_{ij}{x}_j^{(k+1)}-\sum _{j=i}^n{a}_{ij}{x}_j^{(k)}+b_i)\end{array}$$

显然$\omega =1$的时候，上式就是G-S迭代公式。
B. 基于Jacobi迭代方法
$$\{\begin{array}{l}{x}_i^{(k+1)}=x_i^{(k)}+\Delta x_i\\ \Delta x_i=\omega r_i^{(k+1)}\\ r_i^{(k+1)}=\frac{1}{a_{ii}}(-\sum _{j=1}^n{a}_{ij}{x}_j^{(k)}+b_i)\end{array}$$

一般地，$\omega$的取值决定着不同的松弛迭代方法：$0<\omega <1$时候称作低松弛方法；$\omega =1$时候为G-S方法或者是Jacobi方法；$1<\omega <2$时候是(渐次)超松弛方法。

2.4 迭代方法的收敛性

一般地，有迭代收敛方法的基本定理：假设有迭代方程组$x=Bx+f$，对于任意的初始向量$x^{(0)}$，迭代公式$x^{(k+1)}=B{x}^{(k)}+f$收敛的充要条件是迭代矩阵$B$的谱半径$\rho (B)<1$。
设$Ax=b$，如果$A$是严格对角占优，则Jacobi迭代法、G-S迭代法均收敛。

对于迭代方法和直接求解的方法求解过程，以上具体代码可以参见笔者的github,上面有详细的计算过程。

小结

本小结详细介绍线性方程组的求解方法，在实际应用中应当合理利用这些方法来求解线性方程组来解决实际问题。

参考文献

[1] https://wenku.baidu.com/view/e1bca4b63968011ca2009117.html
[2] 计算方法，电子工业出版社