高斯消去法

置换矩阵(permutaion matrix): 一个单位矩阵的行重新排列后形成的矩阵。

Lemma 2.2: 转换矩阵的性质

  1. 的意义
  2. 仍然是转换矩阵。

Alg 2.1: 高斯法求解 的流程如下:

  1. 分解
    • 为转换矩阵。
    • 为单位下三角矩阵。
    • 非奇异的上三角矩阵。
  2. .

定义 2.2:顺序主子矩阵 个顺序主子矩阵为

定理 2.4 下面的两个声明等价:

  1. 分解是唯一的。
  2. 的所有顺序主子矩阵都是非奇异的。

证明分析:

  1. 从分解唯一出发证明,对矩阵 进行分块,分出任意一个顺序主子矩阵。
  2. 从顺序主子矩阵非奇异出发,归纳法证明,假设 的矩阵可分解

定理 2.5 对于非奇异的矩阵 , 一定存在如下分解:

其中 只有一个是必须的。

证明分析: 用归纳法证明

1) 对于 矩阵 。 2) 假设对于 矩阵, 上述结论成立。 3) 下面证明对 矩阵成立,首先利用 非奇异 ,把问题转化为 的问题。

比较等式两边的系数, 可得:

  • 推出
  • 是非奇异的, 验证如下:
  • 上述转化过程实际上给出的高斯消去法的主要算法步骤。

4) 的分解假设存在

最后推出 的分解

最终得到 的分解:

推论 2.1(GEPP) 列主元高斯消去法

推论 2.2 (GECP) 完全主元高斯消去法

算法 2.2 主元 分解

算法 2.3 主元 分解,利用 的存储空间存放

讲课笔记

  • 用一个 4 阶的矩阵演示 分解的过程

Python 实现 下面给出上面算法的 Python 实现

def algorithm_2_2(A):
    n = len(A)
    P, L, U = np.eye(n), np.zeros((n, n)), np.zeros((n, n))
    for i in range(n - 1):
        m = np.argmax(np.abs(A[i:, i])) + i
        if A[m, i] == 0:
            raise ValueError("matrix is singular.")
        else:
            if m != i:
                A[[i, m], :] = A[[m, i], :]
                L[[i, m], :] = L[[m, i], :]
                P[[i, m], :] = P[[m, i], :]
            for j in range(i + 1, n):
                L[j, i] = A[j, i] / A[i, i]

            for j in range(i, n):
                U[i, j] = A[i, j]

            for j in range(i + 1, n):
                for k in range(i + 1, n):
                    A[j, k] -= L[j, i] * U[i, k]

    P = P.T
    L += np.eye(n)
    U[-1, -1] = A[-1, -1]
    return A, P, L, U
def algorithm_2_3(A):
    n = len(A)
    P = np.eye(n)
    for i in range(n - 1):
        m = np.argmax(np.abs(A[i:, i])) + i
        if A[m, i] == 0:
            raise ValueError("matrix is singular.")
        else:
            if m != i:
                A[[i, m], :] = A[[m, i], :]
                P[[i, m], :] = P[[m, i], :]

            for j in range(i + 1, n):
                A[j, i] = A[j, i] / A[i, i]

            for j in range(i + 1, n):
                for k in range(i + 1, n):
                    A[j, k] -= A[j, i] * A[i, k]

    P = P.T
    L = np.tril(A, -1) + np.eye(n)
    U = np.triu(A, 0)
    return A, P, L, U
def algorithm_2_4(A):
    n = len(A)
    P = np.eye(n)

    for i in range(n - 1):
        m = np.argmax(np.abs(A[i:, i])) + i

        if A[m, i] == 0:
            raise ValueError("matrix is singular.")
        else:
            if m != i:
                A[[i, m], :] = A[[m, i], :]
                P[[i, m], :] = P[[m, i], :]

            A[(i + 1):, i] /= A[i, i]
            A[(i + 1):, (i + 1):] -= A[(i + 1):, i].reshape(-1, 1)*A[i, (i + 1):]

    P = P.T
    L = np.tril(A, -1) + np.eye(n)
    U = np.triu(A, 0)
    return A, P, L, U

分解的算法复杂度

把上面的 for 循环用 替换,可得

实验报告

给定一个 100 阶的非奇异矩阵,比较上述几种算法的效率。

results matching ""

    No results matching ""