高等代数精解【10】

线性方程组

概述

• 线性方程组是由一个或多个线性方程组成的集合，其中每个方程都是未知数的线性组合。具体来说，一个线性方程可以表示为：
  $a_1{x}_1+a_2{x}_2+\cdots +a_n{x}_n=b$
  其中，$a_1,a_2,\dots ,a_n$ 和 $b$ 是常数，$x_1,x_2,\dots ,x_n$ 是未知数。

• 系数矩阵是一个线性方程组中所有方程的系数构成的矩阵。对于方程组：
  $\{\begin{array}{l}{a}_{11}{x}_1+a_{12}{x}_2+\cdots +a_{1n}{x}_n=b_1\\ a_{21}{x}_1+a_{22}{x}_2+\cdots +a_{2n}{x}_n=b_2\\ ⋮\\ a_{m1}{x}_1+a_{m2}{x}_2+\cdots +a_{mn}{x}_n=b_m\end{array}$
  其系数矩阵为：
  $\left(\begin{array}{cccc}{a}_{11}& a_{12}& \cdots & a_{1n}\\ a_{21}& a_{22}& \cdots & a_{2n}\\ ⋮& ⋮& \ddots & ⋮\\ a_{m1}& a_{m2}& \cdots & a_{mn}\end{array}\right)$

• $$\begin{gathered} 方程组可表示为 \\ 1.a_1{x}_1+....+a_n{x}_n=b \\ b=\left[\begin{array}{c}{b}_1\\ b_2\\ ...\\ b_m\end{array}\right],a_j=\left[\begin{array}{c}{a}_{1j}\\ a_{2j}\\ ...\\ a_{mj}\end{array}\right] \\ 2.Ax=b \\ 系数矩阵A表示为:[a_1,a_2,...,a_n]，其中a_1,..,a_n是系数矩阵的列向量 \\ 未知数向量为: \\ x=\left[\begin{array}{c}{x}_1\\ x_2\\ ...\\ x_n\end{array}\right] \end{gathered}$$

增广矩阵

基础

• $增广矩阵为[A,b]=[a_1,a_2,...,a_n,b]$

• 方程组Ax=b有解，当且仅当
  $rankA=rank[A,b]$

• 线性方程组有解的条件通常与其系数矩阵和增广矩阵的秩有关。

  • 具体来说，一个线性方程组有解当且仅当其系数矩阵的秩等于增广矩阵的秩。
  • 如果系数矩阵的秩等于未知数的数量，则方程组有唯一解
  • 如果系数矩阵的秩小于未知数的数量，则方程组有无穷多解。
    此时，$Ax=b，A\in R^{m\times n},rankA=m，可通过为n-m个未知数赋予任意值并求解其他未知数来获得Ax=b的解。$

• 解是满足线性方程组中所有方程的未知数的值。对于线性方程组，解可以是唯一的、无穷多的或不存在的。解的存在性和数量由系数矩阵和增广矩阵的秩决定。

一、增广矩阵的作用

1. 集中表示：增广矩阵将线性方程组的系数和常数项集中表示在一个矩阵中，这种表示方式便于后续的矩阵运算和解方程过程。
2. 简化求解：通过对增广矩阵进行初等行变换（如交换两行、某一行乘以非零常数、某一行加上另一行的若干倍）来求解线性方程组。这些行变换可以将增广矩阵化为行最简形式或阶梯形，从而直接读出方程组的解或者判断解的情况（如唯一解、无穷多解或无解）。这种方法比传统的代入法或消元法更为直观和高效。可以将其化为行最简形或阶梯形，从而直接读出方程组的解或判断解的情况（如唯一解、无穷多解或无解）。这种方法比传统的代入法或消元法更为直观和高效。
3. 判断解的存在性：增广矩阵的秩与原系数矩阵的秩之间的关系是判断线性方程组解的存在性的重要依据。如果增广矩阵的秩大于等于系数矩阵的秩，那么原线性方程组至少有一个解；如果增广矩阵的秩小于系数矩阵的秩，则原线性方程组无解。
4. 在高斯消元法中的应用
   高斯消元法是求解线性方程组的一种常用方法，而增广矩阵是高斯消元法的基础。通过对增广矩阵进行行变换，可以逐步消去未知数前的系数，最终得到一个上三角矩阵或行最简形矩阵，从而求解出线性方程组的解。

二、增广矩阵的实际应用例题

以下是一个使用增广矩阵求解线性方程组的实际例题：

例题：求解线性方程组

$$\{\begin{array}{l}x+2y=5,\\ 2x+3y=-2,\\ 6x+7y=1.\end{array}$$

解题步骤：

1. 构造增广矩阵：
   原方程组的系数矩阵为
   $$A=\left(\begin{array}{cc}1& 2\\ 2& 3\\ 6& 7\end{array}\right),$$
   常数项向量为
   $$b=\left(\begin{array}{c}5\\ -2\\ 1\end{array}\right).$$
   将常数项向量添加到系数矩阵的右侧，得到增广矩阵
   $$\bar{A}=(A|b)=\left(\begin{array}{ccc}1& 2& 5\\ 2& 3& -2\\ 6& 7& 1\end{array}\right).$$

2. 使用初等行变换化简增广矩阵：

   • 第2行减去第1行的2倍，得
     $$\left(\begin{array}{ccc}1& 2& 5\\ 0& -1& -12\\ 6& 7& 1\end{array}\right).$$
   • 第3行减去第1行的6倍，得
     $$\left(\begin{array}{ccc}1& 2& 5\\ 0& -1& -12\\ 0& -5& -29\end{array}\right).$$
   • 第3行减去第2行的-5倍，得
     $$\left(\begin{array}{ccc}1& 2& 5\\ 0& -1& -12\\ 0& 0& 1\end{array}\right).$$
   • 通过行变换将增广矩阵化为行最简形（此处略去具体步骤，仅展示结果），得
     $$\left(\begin{array}{ccc}1& 0& 19\\ 0& 1& 12\\ 0& 0& 1\end{array}\right).$$（注意：此处的行最简形可能与原始答案不完全一致，因为行变换的方式不唯一）

3. 读取解：从行最简形增广矩阵中可以直接读出方程组的解为
   $$\{\begin{array}{l}x=19-z,\\ y=12-z,\\ z=\text{自由变量}.\end{array}$$
   由于方程组中有三个未知数但只有两个独立方程，因此有一个自由变量（这里选择$z$作为自由变量）。当给定$z$的一个值时，可以求出$x$和$y$的相应值。例如，当$z=0$时，方程组的解为$x=19,y=12$。

通过以上例题可以看出，增广矩阵在求解线性方程组时具有重要的作用和广泛的应用。

高斯消元法

基础

定义：
高斯消元法是一种用于求解线性方程组的算法。它通过对方程组的增广矩阵进行一系列初等行变换，将其化为行最简形或阶梯形，从而直接读出方程组的解或判断解的情况。

应用：
高斯消元法广泛应用于数学、计算机科学、工程学、物理学、经济学等多个领域。在这些领域中，很多问题的建模都涉及到线性方程组，而高斯消元法提供了一种有效且系统的求解方法。

例子：
考虑以下线性方程组：

$$\{\begin{array}{l}x+2y=5,\\ 2x+3y=-2.\end{array}$$

使用高斯消元法求解的步骤如下：

1. 构造增广矩阵：

$$\bar{A}=\left(\begin{array}{ccc}1& 2& 5\\ 2& 3& -2\end{array}\right).$$

2. 使用初等行变换化简增广矩阵：
   • 第2行减去第1行的2倍，得

$$\left(\begin{array}{ccc}1& 2& 5\\ 0& -1& -12\end{array}\right).$$

3. 将第2行乘以-1，得

$$\left(\begin{array}{ccc}1& 2& 5\\ 0& 1& 12\end{array}\right).$$

4. 第1行减去第2行的2倍，得

$$\left(\begin{array}{ccc}1& 0& -19\\ 0& 1& 12\end{array}\right).$$

此时，增广矩阵已经化为行最简形。

5. 读取解：从行最简形增广矩阵中可以直接读出方程组的解为 $x=-19,y=12$。

例题：
求解以下线性方程组：

$$\{\begin{array}{l}x+y+z=6,\\ 2y+5z=-4,\\ 2x+5y-z=27.\end{array}$$

解题步骤：

1. 构造增广矩阵：

$$\bar{A}=\left(\begin{array}{cccc}1& 1& 1& 6\\ 0& 2& 5& -4\\ 2& 5& -1& 27\end{array}\right).$$

2. 使用初等行变换化简增广矩阵：
   • 第3行减去第1行的2倍，得

$$\left(\begin{array}{cccc}1& 1& 1& 6\\ 0& 2& 5& -4\\ 0& 3& -3& 15\end{array}\right).$$

• 第3行减去第2行的1.5倍，得

$$\left(\begin{array}{cccc}1& 1& 1& 6\\ 0& 2& 5& -4\\ 0& 0& -10.5& 21\end{array}\right).$$

• 将第3行除以-10.5，得

$$\left(\begin{array}{cccc}1& 1& 1& 6\\ 0& 2& 5& -4\\ 0& 0& 1& -2\end{array}\right).$$

• 第2行减去第3行的5倍，得

$$\left(\begin{array}{cccc}1& 1& 1& 6\\ 0& 2& 0& 6\\ 0& 0& 1& -2\end{array}\right).$$

• 第1行减去第3行，得

$$\left(\begin{array}{cccc}1& 1& 0& 8\\ 0& 2& 0& 6\\ 0& 0& 1& -2\end{array}\right).$$

• 第1行减去第2行的0.5倍，得

$$\left(\begin{array}{cccc}1& 0& 0& 5\\ 0& 2& 0& 6\\ 0& 0& 1& -2\end{array}\right).$$

• 将第2行除以2，得

$$\left(\begin{array}{cccc}1& 0& 0& 5\\ 0& 1& 0& 3\\ 0& 0& 1& -2\end{array}\right).$$

此时，增广矩阵已经化为行最简形。

3. 读取解：从行最简形增广矩阵中可以直接读出方程组的解为 $x=5,y=3,z=-2$。

julia代码实现

在Julia中实现高斯消元法，我们可以编写一个函数，该函数接受一个增广矩阵作为输入，并通过初等行变换将其化简为行最简形，从而求解线性方程组。以下是一个简单的实现示例：

function gaussian_elimination(B)  
    A=Float64.(B)
    n = size(A, 1)  
    for k = 1:n-1  
        # 找到主元下标  
        maxindex = k  
        for i = k+1:n  
            if abs(A[i, k]) > abs(A[maxindex, k])  
                maxindex = i  
            end  
        end  
  
        # 交换行  
        if maxindex != k  
            for j = k:n+1  
                A[k, j], A[maxindex, j] = A[maxindex, j], A[k, j]  
            end  
        end  
  
        # 消元  
        for i = k+1:n  
            factor = A[i, k] / A[k, k]  
            for j = k:n+1  
                A[i, j] = A[i, j] - factor * A[k, j]  
            end  
        end  
    end  
  
    # 回代求解  
    x = zeros(n)  
    for i = n:-1:1  
        x[i] = A[i, n+1]  
        for j = i+1:n  
            x[i] = x[i] - A[i, j] * x[j]  
        end  
        x[i] = x[i] / A[i, i]  
    end  
  
    return x  
end  
  
# 示例  
A = [1 1 1 6; 0 2 5 -4; 2 5 -1 27]  
x = gaussian_elimination(A)  
println(x)

这段代码定义了一个gaussian_elimination函数，它接受一个增广矩阵A作为输入，并返回线性方程组的解x。在示例中，我们构造了一个3x4的增广矩阵A，然后调用gaussian_elimination函数求解，并打印结果。

请注意，这个实现没有进行错误处理，比如检查矩阵是否为奇异矩阵（即没有唯一解的情况）。在实际应用中，你可能需要添加这样的检查来确保算法的健壮性。

高斯消元法算法

方阵高斯消元法

是一种用于解线性方程组的数值算法，其基本思想是通过行变换将系数矩阵化为上三角矩阵，然后通过回代求解未知量。以下是高斯消元法的一般算法描述：

输入：

• 系数矩阵 $A$，大小为 $n\times n$
• 常数项向量 $b$，大小为 $n\times 1$

输出：

• 解向量 $x$，大小为 $n\times 1$

算法步骤：

1. 构造增广矩阵：

   • 将系数矩阵 $A$ 和常数项向量 $b$ 组合成一个增广矩阵 $[A|b]$。

2. 前向消元：

   • 对于 $k=1$ 到 $n-1$：
     a. 选择主元：找到第 $k$ 列中从第 $k$ 行到第 $n$ 行中绝对值最大的元素，并将其所在行与第 $k$ 行交换。
     b. 消元：对于 $i=k+1$ 到 $n$，计算乘数 $m=A[i,k]/A[k,k]$，然后更新第 $i$ 行：$A[i,j]=A[i,j]-m\times A[k,j]$，其中 $j=k$ 到 $n$。

3. 回代求解：

   • 对于 $i=n$ 到 $1$ 的逆序：
     a. 计算 $x[i]$：$x[i]=(b[i]-{\sum }_{j=i+1}^{n}A[i,j]\times x[j])/A[i,i]$。

4. 输出解向量 $x$。

注意事项：

• 在前向消元过程中，如果主元 $A[k,k]$ 为零或接近零，则算法可能会失败或导致数值不稳定。此时需要进行行交换或采用其他策略。
• 如果在消元过程中发现某一行变为全零行，并且该行对应的常数项不为零，则线性方程组无解。
• 如果在消元过程中发现某一行变为全零行，并且该行对应的常数项也为零，则线性方程组有无穷多解。在这种情况下，算法可能只能求出部分解或特解。

非方阵的情况

它同样适用于非方阵的情况，即增广矩阵（系数矩阵与常数项向量组合而成的矩阵）的行数可能不等于列数。以下是高斯消元法的一般算法描述，适用于非方阵情况：

1. 输入：增广矩阵 $A$，其中包含了系数矩阵和常数项向量。

2. 初始化：设置当前处理的行 $i=1$。

3. 主循环：当 $i\le \min (\text{行数},\text{列数})$ 时执行以下步骤：

   a. 寻找主元：在 $i$ 到 $\text{行数}$ 的范围内，找到第 $i$ 列绝对值最大的元素，并将其所在行与第 $i$ 行交换（如果已经是第 $i$ 行则无需交换）。

   b. 消元：对于 $j=i+1$ 到 $\text{行数}$ 的每一行，执行以下操作：

   • 计算乘数 $m=A[j,i]/A[i,i]$。
   • 对于 $k=i$ 到 $\text{列数}$ 的每一个元素，执行 $A[j,k]=A[j,k]-m\times A[i,k]$。

   c. 递增：$i=i+1$。

4. 回代求解：

   a. 对于 $i=\min (\text{行数},\text{列数})$ 到 $1$ 的逆序，执行以下操作：

   • 计算 $A[i,\text{列数}+1]$（即常数项）的值，通过减去之前已经求解的变量的贡献：$A[i,\text{列数}+1]=A[i,\text{列数}+1]-{\sum }_{j=i+1}^{\min (\text{行数},\text{列数})}A[i,j]\times x[j]$，其中 $x[j]$ 是之前已经求解的变量。

   • 将 $A[i,i]$ 的系数化为 $1$，即 $x[i]=A[i,\text{列数}+1]/A[i,i]$。

5. 输出：解向量 $x$，其中包含了线性方程组的解。

需要注意的是，如果矩阵的某一行在消元过程中变为全零行，并且该行对应的常数项不为零，则线性方程组无解。如果矩阵的某一行在消元过程中变为全零行，并且该行对应的常数项也为零，则线性方程组有无穷多解。在实际应用中，还需要考虑数值稳定性和精度问题。

Julia 中将整型矩阵转换为浮点型矩阵。

下面是一些常见的方法：

方法 1：使用类型转换函数

Julia 提供了 Float64、Float32 等函数来将其他类型的数值转换为浮点型。对于矩阵，你可以使用广播（broadcasting）机制来应用这种转换。

# 创建一个整型矩阵
A = [1 2; 3 4]

# 将整型矩阵转换为浮点型矩阵
B = Float64.(A)

方法 2：使用 convert 函数

convert 函数是另一种转换数据类型的方法。它同样适用于矩阵。

# 创建一个整型矩阵
A = [1 2; 3 4]

# 使用 convert 函数转换为浮点型矩阵
B = convert(Array{Float64, 2}, A)

方法 3：利用矩阵运算或函数

在某些情况下，你可能在矩阵运算中自然地得到浮点型结果，例如，当你将整型矩阵除以一个整数时。

# 创建一个整型矩阵
A = [1 2; 3 4]

# 通过运算转换为浮点型矩阵
B = A / 1.0

方法 4：使用 map 函数

map 函数可以将一个函数应用于矩阵的每个元素。通过这种方法，你也可以将整型矩阵转换为浮点型矩阵。

# 创建一个整型矩阵
A = [1 2; 3 4]

# 使用 map 函数转换为浮点型矩阵
B = map(Float64, A)

以上就是在 Julia 中将整型矩阵转换为浮点型矩阵的几种常见方法。选择哪种方法取决于你的具体需求和偏好。

参考文献

1.《最优化导论》
2.文心一言
3.chatgpt