1.高斯消元法

        高斯消元法是求解线性方程组的一种基本方法，它的主要思路是通过矩阵变换将原始的系数矩阵转化为一个上三角矩阵或者下三角矩阵，然后通过回代等方法求得线性方程组的解。

        具体来说，高斯消元法有以下步骤：

1. 构造增广矩阵：将系数矩阵和常数向量合并成一个增广矩阵。

2. 前向消元：通过一系列初等行变换将增广矩阵转化为上三角矩阵或下三角矩阵，过程中主要操作为加减消元，即利用第 ii 行的倍数加到第 jj 行（i<ji<j）上，消去第 jj 行的第 ii 个元素。

3. 回代求解：从最后一行开始，依次求出未知数的值。

        需要注意的是，如果在前向消元的过程中出现了某一行的所有元素都为 00 的情况，则无法进行消元操作。此时需要进行行交换操作，使得该行不为 00。

        高斯消元法的优点是简单易懂，容易实现，而且能够处理一般的线性方程组。但是也存在一些问题，由于操作过程中会产生舍入误差和零元素的影响，因此对于病态矩阵或系数矩阵较大的线性方程组，可能出现计算结果不稳定的情况。

"""
@Time ： 2023/10/19 0019 17:11
@Auth ： yeqc
"""
import numpy as np


def gaussian_elimination(A, b):
    """
    高斯消元法解线性方程组 Ax = b

    参数：
    A: 系数矩阵，形状为 (n, n)
    b: 右侧常数向量，形状为 (n,)

    返回：
    x: 解向量，形状为 (n,)
    """
    n = len(b)

    # 将系数矩阵和右侧常数合并
    Ab = np.column_stack((A.astype(float), b.astype(float)))

    # 前向消元
    for i in range(n - 1):
        for j in range(i + 1, n):
            factor = Ab[j, i] / Ab[i, i]
            Ab[j, i:] -= factor * Ab[i, i:]

    # 回代求解
    x = np.zeros(n)
    for i in range(n - 1, -1, -1):
        x[i] = (Ab[i, n] - np.dot(Ab[i, i:n], x[i:n])) / Ab[i, i]

    return x


# 示例用法
A = np.array([[9,-1,-1],[-1,8,0],[-1,0,9]])

b = np.array([7,7,8])

x = gaussian_elimination(A, b)
print("解 x =", x)

2.列主元消元法

        列主元消元法（Column Principal Pivot Elimination Method），也称为列主消去法，是解线性方程组的一种方法。它是高斯-约旦消元法的改进版本，用于将增广矩阵变换为行最简形式。

        列主元消元法的基本思路是选择每一列的主元素（也称为列主元），并通过行交换操作将主元素放置在对应的列的顶部位置，然后通过一系列的行操作将其他元素消去。

具体步骤如下：

1. 构造增广矩阵：将系数矩阵和常数向量合并成一个增广矩阵。

2. 选取列主元：对于每一列，在当前剩余的行中选择该列中绝对值最大的元素作为主元素，并将其所在行与当前处理的行进行交换。

3. 前向消元：通过一系列初等行变换将增广矩阵转化为行最简形式，即使主元素所在列的其他元素变为0。

4. 回代求解：从最后一行开始，依次求出未知数的值。

        使用列主元消元法可以避免在高斯消元法中可能出现的数值不稳定性问题，而且可以得到更精确的解。然而，相比于高斯消元法，列主元消元法的计算量较大，因为需要在每一步中选择最大的主元素进行行交换，增加了计算的复杂性。但对于某些特殊的线性方程组，列主元消元法可能会更加有效。

"""
@Time ： 2023/10/19 0019 17:11
@Auth ： yeqc
"""
import numpy as np


def gaussian_elimination(A, b):
    n = len(A)

    # 将数组的数据类型转换为float64
    A = A.astype(np.float64)
    b = b.astype(np.float64)

    # 高斯消元
    for i in range(n - 1):
        max_idx = i

        # 选取列主元
        for j in range(i + 1, n):
            if abs(A[j][i]) > abs(A[max_idx][i]):
                max_idx = j

        # 交换行
        A[[i, max_idx]] = A[[max_idx, i]]
        b[[i, max_idx]] = b[[max_idx, i]]

        for j in range(i + 1, n):
            # 计算倍数
            multiplier = A[j][i] / A[i][i]

            # 更新矩阵
            A[j][i:] -= multiplier * A[i][i:]
            b[j] -= multiplier * b[i]

    # 回代求解
    x = np.zeros(n)
    for i in range(n - 1, -1, -1):
        x[i] = (b[i] - np.dot(A[i][i + 1:], x[i + 1:])) / A[i][i]

    return x


# 示例
A = np.array([[9, -1, -1], [-1, 8, 0], [-1, 0, 9]])

b = np.array([7, 7, 8])

x = gaussian_elimination(A, b)
print("解：", x)

3.高斯约旦消元法（Gauss-Jordan）

        高斯-约旦消元法（Gauss-Jordan Elimination Method）是解线性方程组的一种基本方法。它通过一系列初等行变换将增广矩阵转化为行最简形式，从而得到线性方程组的解。

具体步骤如下：

1. 构造增广矩阵：将系数矩阵和常数向量合并成一个增广矩阵。

2. 前向消元：通过一系列初等行变换将增广矩阵转化为上三角形式，即系数矩阵的左下角全部为0的形式。

3. 反向消元：通过一系列初等行变换将增广矩阵进一步转化为对角线形式，即系数矩阵除了对角线以外的所有元素都为0的形式。过程中主要操作为再次利用加减消元，使每个未知量的系数为1，同时把其他行的系数消为0。

4. 求解方程组：根据对角线形式的增广矩阵，可以很容易地求出线性方程组的解。

        需要注意的是，在转化为上三角形式的过程中，可能会存在主元素为0或较小的数值情况，导致算法出现数值不稳定的问题。因此，在高斯-约旦消元法中，需要加强对数值精度的控制，避免出现异常结果。

"""
@Time ： 2023/10/19 0019 17:11
@Auth ： yeqc
"""
import numpy as np


def gaussian_jordan_elimination(A, b):
    n = len(A)

    # 构造增广矩阵
    augmented_matrix = np.column_stack((A.astype(float), b.astype(float)))

    # 高斯约旦消元
    for i in range(n):
        pivot = augmented_matrix[i][i]

        # 将主元归一化为1
        augmented_matrix[i] /= pivot

        # 更新其他行
        for j in range(n):
            if j != i:
                multiplier = augmented_matrix[j][i]
                augmented_matrix[j] -= multiplier * augmented_matrix[i]

    # 提取解
    x = augmented_matrix[:, n]

    return x


# 示例
A = np.array([[9, -1, -1], [-1, 8, 0], [-1, 0, 9]])

b = np.array([7, 7, 8])

x = gaussian_jordan_elimination(A, b)
print("解：", x)