人工智能必备数学知识学习笔记8：线性系统

 线性系统与消元

 非线性：

方程式1，2，3  将                                                                                                                          

第一组：方程式2 - 方程式1 *3 =得出第二组 y-10z = -32；                                                                     

第二组：方程式3-方程式1=得出第三组-y-5z=-13；                                                                             

第三组：方程式2+方程式3=得出-15z =-45

  

此时：下图第三组方程式3：-15z = -45 得出第四组：方程式3：z=3

 

根据第三组方程式3：z=3，将z=3带入方程式2：y-10z =-32 得出第四组方程式2：y= -2;

根据第四组 y=-2、z=3带入方程式1：x+2y+4z=7 得出第五组方程式1：x=-1

 

---

---

• 高斯消元法

 增广矩阵：将第一组的系数与等号右侧的值直接组成一个新的矩阵：从而进行消元

 

 

 高斯消元法是根据增光矩阵的角度：等价于线性方程组的消元法

且有N个未知数就会有N行矩阵（n个方程）

 此时：主源不能为0，需要将矩阵进行位置调换（调换原则为与主源值最大的进行矩阵行的进行交换位置<可以尽量小的避免误差-涉及数值分析方面的内容>）

---

---

• 高斯-约旦消元
   
  

将增广矩阵的第二组中的 方程3*10 + 方程2 得出将方程2的第三个元素消成0，从而得出方程2的第二个元素的值 

高斯-约旦消元法：

1.前向过程指的是从上到下找到主源将其划为1，直至将最后一个方程的未知数数量变为一个

2.后项过程指的是从下到上找到主源将非组源位置划归为0，直至第一个方程

高斯-约旦消元法说明：

前向过程：将主源对应列自上而下全部归为0（每行主源元素会归为1）

后向过程：反过来将主源对应列自下而上全部归为0

前向后向过程会根据主源形成对称轴（此时主源均为1），前向操作将对称轴的左侧全部划归为0，后向操作将对称轴右侧全部划归为0

下面代码实现会根据上图以及此注释进行代码编写

代码实现：

 

 1. 在Vector.py编写代码：返回当前向量的底层列表 underlying_list

#向量类
#__values() 与 _values()区别更多体现在继承上，如果是在类的内部使用时官方建议使用_values()发方法
from ._global import EPSILON
import math


class Vector:

    def __init__(self,lst):
        self._values = list(lst)#将数组赋值给向量类中(注：使用list方法将列表lst复制一份保证他的不被外界调用时修改)

    #零向量类方法：参数1：为当前的类(cls) 参数2：维度(dim)  返回dim维的零向量
    @classmethod
    def zero(cls,dim):
        return cls([0] * dim)

    #返回向量的模(向量长度):
    def norm(self):
        return math.sqrt(sum(e**2 for e in self))#sqrt()方法为开平方根，sum()求和方法，e**2 e的平方

    #返回向量的单位向量
    def normalize(self):
        if self.norm() < EPSILON:  #此处判断一个精度范围(该精度范围调用内部自定义全局变量文件 _global.py)（由于浮点数计算机含有误差所以无法使用 == 0 的操作）
            raise ZeroDivisionError("Normalize error! norm is zero.") #考虑零向量时报此处异常即可
        #方案一：return Vector(1/self.norm() * [e for e in self])#循环遍历向量中的每个元素分别除以该向量的模即为单位向量
        #方案二：return 1/self.norm() * Vector(self._values)#当前向量除以模即为单位向量
        return Vector(self._values) / self.norm()

    #返回当前向量的底层列表 TODO:2020-08-12 17：04：00
    def underlying_list(self):
        return self._values[:]#此时为返回该列表的一个副本

    #向量加法，返回结果向量
    def __add__(self, another):
        # assert判断传入的向量维度是否相等
        assert len(self) == len(another),
              "Error in adding. Length of vectors must be same."
        return Vector([a+b for a,b in zip(self,another)])#使用zip()方法将两个向量取出来

    # 向量减法
    def __sub__(self, another):
        #判断维度相等
        assert len(self) == len(another), 
            "Error in adding. Length of vectors must be same."
        return Vector([a - b for a, b in zip(self, another)])

    #向量点乘(向量之间相乘)：返回结果标量
    def dot(self,another):
        #判断维度相等
        assert len(self) == len(another), 
            "Error in dot product. Length of vectors must be same."
        return sum(a * b for a,b in zip(self,another))# 方法zip()将两组向量配成对应位置的数据对

    # 向量数量乘法(数乘数组)，返回数量乘法的结果向量：self * k
    def __mul__(self, k):
        return Vector([k * e for e in self])

    # 向量数量乘法(数组乘数)，返回数量乘法的结果向量：k * self
    def __rmul__(k, self):
        return k * self #此处直接调用的是上方的乘法函数

    # 向量除法:返回数量除法的结果向量 self / k
    def __truediv__(self, k):
        return (1 / k) * self

    #返回向量取正的结果向量
    def __pos__(self):
        return 1 * self

    # 返回向量取负的结果向量
    def __neg__(self):
        return -1 * self

    #返回向量迭代器（当有迭代器时，zip()方法中就不用再次传入两个向量数组，直接传入向量对象即可<zip(self._values,another._values)>）
    def __iter__(self):
        return self._values.__iter__()

    #取向量的index个元素
    def __getitem__(self, index):
        return self._values[index]

    #返回向量的长度（有多少个元素）
    def __len__(self):
        return len(self._values)

    # 向量展示（系统调用）
    def __repr__(self):
        return "Vector({})".format(self._values)

    # 向量展示（用户调用）
    def __str__(self):
        return "({})".format(", ".join(str(e) for e in self._values))#通过遍历 self.__values 将e转成字符串通过逗号加空格来链接放入大括号中

# u = Vector([5,2])
# print(u)

2. 在LinearSystem.py编写代码：

from.Matrix import Matrix
from.Vector import Vector


#线性系统
class LinearSystem:

    #初始化函数：参数A：增广矩阵的等号左边的系数 参数b：增广矩阵的等号右边的值（方程右边的结果）
    def __init__(self,A,b):
        #判断矩阵A的行数是否等于b的列数
        assert A.row_num() == len(b),
            "row number of A must be equal to the length of b"
        self._m = A.row_num()#行数
        self._n = A.col_num()#列数

        #判断矩阵A的行数是否等于列数
        assert self._m == self._n #TODO: no this restriction 将来要解除该限制

        #增广矩阵
        self.Ab = [Vector(A.row_vector(i).underlying_list() + [b[i]])
                   for i in range(self._m)]

    #寻找最大主源系数
    def _max_row(self,index,n):
        best, ret = self.Ab[index][index], index #存储第index行index列的元素值与当前index的值
        for i in range(index + 1, n): #从index+1开始一直遍历到n
            if self.Ab[i][index] < best:
                best, ret = self.Ab[i][index], i
        return ret

    #高斯—约旦消元法-前向过程
    def _forward(self):
        n = self._m #行数
        for i in range(n):
            #Ab[i][i]为主源
            max_row = self._max_row(i,n)#寻找最大主源系数的行数
            self.Ab[i], self.Ab[max_row] = self.Ab[max_row],self.Ab[i]

            #将主源归为一
            self.Ab[i] = self.Ab[i] / self.Ab[i][i] #TODO: self.Ab[i][i] == 0 时会报错
            #将当前主源下的所有行对应主源列的元素全部归为0 ：也就是第一次循环会将该主源下的所有对应列变为0，第二次循环会将第二次主源列下的所有对应列变为0
            for j in range(i + 1, n):
                self.Ab[j] =self.Ab[j] -self.Ab[j][i] * self.Ab[i]#该主源行下的所有行减去主源行

    #高斯-约旦消元法-后向过程
    def _backward(self):
        n = self._m #行数
        for i in range(n-1, -1, -1): #反向遍历且 从参数1的位置遍历到参数2的位置，也就是从倒数第一个位置遍历到第一个位置，参数3为步长（遍历的方向及单位）
            #Ab[i][i]为主源
            for j in range(i-1, -1, -1):
                self.Ab[j] = self.Ab[j] - self.Ab[j][i] * self.Ab[i]#该主源行上的所有行减去主源行

    #高斯-约旦消元法
    def gauss_jordan_elimination(self):
        # 高斯—约旦消元法-前向过程
        self._forward()
        # 高斯-约旦消元法-后向过程
        self._backward()

    # 打印结果（求每个未知数的值）
    def fancy_print(self):
        for i in range(self._m):
            print(" ".join(str(self.Ab[i][j]) for j in range(self._n)),end=" ")
            print("|",self.Ab[i][-1])

3.在main_linear_system.py编写代码：

from playLA.Matrix import Matrix
from playLA.Vector import Vector
from playLA.LinearSystem import LinearSystem

if __name__ == "__main__":

    # 高斯—约旦消元法
    A = Matrix([[1,2,4],[3,7,2],[2,3,3]])
    b = Vector([7,-11,1])
    ls = LinearSystem(A,b) #线性系统赋值成一个增广矩阵
    ls.gauss_jordan_elimination() #高斯—约旦消元
    ls.fancy_print() #打印出结果（求每个未知数的值）
    print("*" * 50)#分隔线

    # 高斯—约旦消元法
    A2 = Matrix([[1, -3, 5], [2, -1, -3], [3, 1, 4]])
    b2 = Vector([-9, 19, 13])
    ls2 = LinearSystem(A2, b2)  # 线性系统赋值成一个增广矩阵
    ls2.gauss_jordan_elimination()  # 高斯—约旦消元
    ls2.fancy_print()  # 打印出结果（求每个未知数的值）
    print("*" * 50)  # 分隔线

    # 高斯—约旦消元法
    A3 = Matrix([[1, 2, -2], [2, -3, 1], [3, -1, 3]])
    b3 = Vector([6, -10, -16])
    ls3 = LinearSystem(A3, b3)  # 线性系统赋值成一个增广矩阵
    ls3.gauss_jordan_elimination()  # 高斯—约旦消元
    ls3.fancy_print()  # 打印出结果（求每个未知数的值）
    print("*" * 50)  # 分隔线

    # 高斯—约旦消元法
    A4 = Matrix([[3, 1, -2], [5, -3, 10], [7, 4, 16]])
    b4 = Vector([4, 32, 13])
    ls4 = LinearSystem(A4, b4)  # 线性系统赋值成一个增广矩阵
    ls4.gauss_jordan_elimination()  # 高斯—约旦消元
    ls4.fancy_print()  # 打印出结果（求每个未知数的值）
    print("*" * 50)  # 分隔线

    # 高斯—约旦消元法
    A5 = Matrix([[6, -3, 2], [5, 1, 12], [8, 5, 1]])
    b5 = Vector([31, 36, 11])
    ls5 = LinearSystem(A5, b5)  # 线性系统赋值成一个增广矩阵
    ls5.gauss_jordan_elimination()  # 高斯—约旦消元
    ls5.fancy_print()  # 打印出结果（求每个未知数的值）
    print("*" * 50)  # 分隔线

    # 高斯—约旦消元法
    A6 = Matrix([[1, 1, 1], [1, -1, -1], [2, 1, 5]])
    b6 = Vector([3, -1, 8])
    ls6 = LinearSystem(A6, b6)  # 线性系统赋值成一个增广矩阵
    ls6.gauss_jordan_elimination()  # 高斯—约旦消元
    ls6.fancy_print()  # 打印出结果（求每个未知数的值）
    print("*" * 50)  # 分隔线

4.运行main_linear_system.py 结果为：

/Users/liuxiaoming/PycharmProjects/LinearAlgebra/venv/bin/python /Users/liuxiaoming/PycharmProjects/LinearAlgebra/main_linear_system.py
1.0 0.0 0.0 | -1.0
0.0 1.0 0.0 | -2.0
-0.0 -0.0 1.0 | 3.0
**************************************************
1.0 0.0 0.0 | 6.853333333333333
0.0 1.0 0.0 | 1.5066666666666668
0.0 0.0 1.0 | -2.2666666666666666
**************************************************
1.0 0.0 0.0 | -2.0
0.0 1.0 0.0 | 1.0000000000000009
0.0 0.0 1.0 | -2.999999999999999
**************************************************
1.0 0.0 3.7007434154171876e-17 | 3.0
0.0 1.0 -4.440892098500626e-16 | -4.000000000000001
0.0 0.0 0.9999999999999999 | 0.5000000000000001
**************************************************
1.0 0.0 0.0 | 2.9999999999999996
0.0 1.0 0.0 | -3.0
-0.0 -0.0 1.0 | 2.0
**************************************************
1.0 0.0 0.0 | 1.0
-0.0 1.0 0.0 | 1.0
0.0 0.0 1.0 | 1.0
**************************************************

Process finished with exit code 0

---

---

• 行最简形式和线性方程组解的结构

 

 

 

 

 

 

 

 

 

---

---

• 直观理解线性方程组解的结构

 

 

 

 

 

 

 

 

 三根直线重合，此时该方程组有无数解

 

 

 

 

 

---

---

• 更一般化的高斯-约旦消元法

 

 

 

 

 

 

 代码实现：

 1. 在 文件 _global.py 中编写代码： is_zero(x)、is_equal(a,b)

#包内部使用的全局变量

EPSILON = 1e-8 #精度范围为 1除以10的八次方


#判断x的绝对值是否小于精度范围（EPSILON）
def is_zero(x):
    return abs(x) < EPSILON 


#判断a和b两个浮点值是否相等
def is_equal(a,b):
    return abs(a - b) < EPSILON #判断差值的绝对值是否在精度范围内

2.在 文件 Vector.py 中编写代码：修改第24行判断形式 is_zero()

#向量类
#__values() 与 _values()区别更多体现在继承上，如果是在类的内部使用时官方建议使用_values()发方法
from ._global import is_zero
import math



class Vector:

    def __init__(self,lst):
        self._values = list(lst)#将数组赋值给向量类中(注：使用list方法将列表lst复制一份保证他的不被外界调用时修改)

    #零向量类方法：参数1：为当前的类(cls) 参数2：维度(dim)  返回dim维的零向量
    @classmethod
    def zero(cls,dim):
        return cls([0] * dim)

    #返回向量的模(向量长度):
    def norm(self):
        return math.sqrt(sum(e**2 for e in self))#sqrt()方法为开平方根，sum()求和方法，e**2 e的平方

    #返回向量的单位向量
    def normalize(self):
        if is_zero(self.norm()): #此处判断一个精度范围(该精度范围调用内部自定义全局变量文件 _global.py)（由于浮点数计算机含有误差所以无法使用 == 0 的操作）
            raise ZeroDivisionError("Normalize error! norm is zero.") #考虑零向量时报此处异常即可
        #方案一：return Vector(1/self.norm() * [e for e in self])#循环遍历向量中的每个元素分别除以该向量的模即为单位向量
        #方案二：return 1/self.norm() * Vector(self._values)#当前向量除以模即为单位向量
        return Vector(self._values) / self.norm()

    #返回当前向量的底层列表 TODO:2020-08-12 17：04：00
    def underlying_list(self):
        return self._values[:]#此时为返回该列表的一个副本

    #向量加法，返回结果向量
    def __add__(self, another):
        # assert判断传入的向量维度是否相等
        assert len(self) == len(another),
              "Error in adding. Length of vectors must be same."
        return Vector([a+b for a,b in zip(self,another)])#使用zip()方法将两个向量取出来

    # 向量减法
    def __sub__(self, another):
        #判断维度相等
        assert len(self) == len(another), 
            "Error in adding. Length of vectors must be same."
        return Vector([a - b for a, b in zip(self, another)])

    #向量点乘(向量之间相乘)：返回结果标量
    def dot(self,another):
        #判断维度相等
        assert len(self) == len(another), 
            "Error in dot product. Length of vectors must be same."
        return sum(a * b for a,b in zip(self,another))# 方法zip()将两组向量配成对应位置的数据对

    # 向量数量乘法(数乘数组)，返回数量乘法的结果向量：self * k
    def __mul__(self, k):
        return Vector([k * e for e in self])

    # 向量数量乘法(数组乘数)，返回数量乘法的结果向量：k * self
    def __rmul__(k, self):
        return k * self #此处直接调用的是上方的乘法函数

    # 向量除法:返回数量除法的结果向量 self / k
    def __truediv__(self, k):
        return (1 / k) * self

    #返回向量取正的结果向量
    def __pos__(self):
        return 1 * self

    # 返回向量取负的结果向量
    def __neg__(self):
        return -1 * self

    #返回向量迭代器（当有迭代器时，zip()方法中就不用再次传入两个向量数组，直接传入向量对象即可<zip(self._values,another._values)>）
    def __iter__(self):
        return self._values.__iter__()

    #取向量的index个元素
    def __getitem__(self, index):
        return self._values[index]

    #返回向量的长度（有多少个元素）
    def __len__(self):
        return len(self._values)

    # 向量展示（系统调用）
    def __repr__(self):
        return "Vector({})".format(self._values)

    # 向量展示（用户调用）
    def __str__(self):
        return "({})".format(", ".join(str(e) for e in self._values))#通过遍历 self.__values 将e转成字符串通过逗号加空格来链接放入大括号中

# u = Vector([5,2])
# print(u)

3.在文件 LinearSystem.py 中编写代码：修改__init__、_max_row、_forward、_backward、gauss_jordan_elimination使之可以适应解决更多非唯一解的矩阵

from.Matrix import Matrix
from.Vector import Vector
from playLA._global import is_zero

#线性系统
class LinearSystem:

    #初始化函数：参数A：增广矩阵的等号左边的系数 参数b：增广矩阵的等号右边的值（方程右边的结果）
    def __init__(self, A, b):
        #判断矩阵A的行数是否等于b的列数
        assert A.row_num() == len(b),
            "row number of A must be equal to the length of b"
        self._m = A.row_num()#行数
        self._n = A.col_num()#列数

        #增广矩阵
        self.Ab = [Vector(A.row_vector(i).underlying_list() + [b[i]])
                   for i in range(self._m)]
        #主元
        self.pivots = []

    #寻找最大主源系数
    def _max_row(self, index_i, index_j, n):
        best, ret = self.Ab[index_i][index_j], index_i #存储第index行index列的元素值与当前index的值
        for i in range(index_i + 1, n): #从index+1开始一直遍历到n
            if self.Ab[i][index_j] > best:
                best, ret = self.Ab[i][index_j], i
        return ret

    #高斯—约旦消元法-前向过程
    def _forward(self):

       i,k = 0,0
       while i < self._m and k < self._n:
            #看Ab[i][k]位置是否为主元
            max_row = self._max_row(i, k, self._m)#寻找最大主源系数的行数
            self.Ab[i], self.Ab[max_row] = self.Ab[max_row],self.Ab[i] #行交换操作

            if is_zero(self.Ab[i][k]):#判断此时该值是否为0
                k += 1
            else:
                #将主元归为一
                self.Ab[i] = self.Ab[i] / self.Ab[i][k]
                #将当前主源下的所有行对应主源列的元素全部归为0 ：也就是第一次循环会将该主源下的所有对应列变为0，第二次循环会将第二次主源列下的所有对应列变为0
                for j in range(i + 1, self._m):
                    self.Ab[j] =self.Ab[j] -self.Ab[j][k] * self.Ab[i]#该主源行下的所有行减去主源行
                self.pivots.append(k)
                i += 1

    #高斯-约旦消元法-后向过程
    def _backward(self):
        n = len(self.pivots)
        #n = self._m #行数
        for i in range(n-1, -1, -1): #反向遍历且 从参数1的位置遍历到参数2的位置，也就是从倒数第一个位置遍历到第一个位置，参数3为步长（遍历的方向及单位）
            k = self.pivots[i]
            #Ab[i][k]为主源
            for j in range(i-1, -1, -1):
                self.Ab[j] = self.Ab[j] - self.Ab[j][k] * self.Ab[i]#该主源行上的所有行减去主源行

    #高斯-约旦消元法：如果有解，返回True；如果没有解，返回False
    def gauss_jordan_elimination(self):
        # 高斯—约旦消元法-前向过程
        self._forward()
        # 高斯-约旦消元法-后向过程
        self._backward()
        for i in range(len(self.pivots), self._m):#此处为最后一行的非零行下一行的全零行的结果值不为零的判断   0.0 0.0 | 5.0
            if not is_zero(self.Ab[i][-1]):
                return False
        return True



    # 打印结果（求每个未知数的值）
    def fancy_print(self):
        for i in range(self._m):
            print(" ".join(str(self.Ab[i][j]) for j in range(self._n)),end=" ")
            print("|",self.Ab[i][-1])

4.在文件 main_linear_system.py 编写代码：

from playLA.Matrix import Matrix
from playLA.Vector import Vector
from playLA.LinearSystem import LinearSystem

if __name__ == "__main__":

    # 高斯—约旦消元法
    A = Matrix([[1,2,4],[3,7,2],[2,3,3]])
    b = Vector([7,-11,1])
    ls = LinearSystem(A,b) #线性系统赋值成一个增广矩阵
    ls.gauss_jordan_elimination() #高斯—约旦消元
    ls.fancy_print() #打印出结果（求每个未知数的值）
    print("-" * 50)#分隔线

    # 高斯—约旦消元法
    A2 = Matrix([[1, -3, 5], [2, -1, -3], [3, 1, 4]])
    b2 = Vector([-9, 19, 13])
    ls2 = LinearSystem(A2, b2)  # 线性系统赋值成一个增广矩阵
    ls2.gauss_jordan_elimination()  # 高斯—约旦消元
    ls2.fancy_print()  # 打印出结果（求每个未知数的值）
    print("-" * 50)  # 分隔线

    # 高斯—约旦消元法
    A3 = Matrix([[1, 2, -2], [2, -3, 1], [3, -1, 3]])
    b3 = Vector([6, -10, -16])
    ls3 = LinearSystem(A3, b3)  # 线性系统赋值成一个增广矩阵
    ls3.gauss_jordan_elimination()  # 高斯—约旦消元
    ls3.fancy_print()  # 打印出结果（求每个未知数的值）
    print("-" * 50)  # 分隔线

    # 高斯—约旦消元法
    A4 = Matrix([[3, 1, -2], [5, -3, 10], [7, 4, 16]])
    b4 = Vector([4, 32, 13])
    ls4 = LinearSystem(A4, b4)  # 线性系统赋值成一个增广矩阵
    ls4.gauss_jordan_elimination()  # 高斯—约旦消元
    ls4.fancy_print()  # 打印出结果（求每个未知数的值）
    print("-" * 50)  # 分隔线

    # 高斯—约旦消元法
    A5 = Matrix([[6, -3, 2], [5, 1, 12], [8, 5, 1]])
    b5 = Vector([31, 36, 11])
    ls5 = LinearSystem(A5, b5)  # 线性系统赋值成一个增广矩阵
    ls5.gauss_jordan_elimination()  # 高斯—约旦消元
    ls5.fancy_print()  # 打印出结果（求每个未知数的值）
    print("-" * 50)  # 分隔线

    # 高斯—约旦消元法
    A6 = Matrix([[1, 1, 1], [1, -1, -1], [2, 1, 5]])
    b6 = Vector([3, -1, 8])
    ls6 = LinearSystem(A6, b6)  # 线性系统赋值成一个增广矩阵
    ls6.gauss_jordan_elimination()  # 高斯—约旦消元
    ls6.fancy_print()  # 打印出结果（求每个未知数的值）
    print("-" * 50)  # 分隔线

    # 高斯—约旦消元法
    A7 = Matrix([[1, -1, 2, 0, 3],
                 [-1, 1, 0, 2, -5],
                 [1, -1, 4, 2, 4],
                 [-2, 2, -5, -1, -3]])
    b7 = Vector([1, 5, 13, -1])
    ls7 = LinearSystem(A7, b7)  # 线性系统赋值成一个增广矩阵
    ls7.gauss_jordan_elimination()  # 高斯—约旦消元
    ls7.fancy_print()  # 打印出结果（求每个未知数的值）
    print("-" * 50)  # 分隔线
    print(ls7.pivots) #查看主源列数值 （从零开始算）

    # 高斯—约旦消元法
    A8 = Matrix([[2, 2],
                 [2, 1],
                 [1, 2]])
    b8 = Vector([3, 2.5, 7])
    ls8 = LinearSystem(A8, b8)  # 线性系统赋值成一个增广矩阵
    if not ls8.gauss_jordan_elimination():
        print("主元：",ls8.pivots
              ,len(ls8.pivots))  # 查看主源列数值 （从零开始算）
        print("No Solution!")

    ls8.fancy_print()  # 打印出结果（求每个未知数的值）
    print("-" * 50)  # 分隔线

5.运行文件 main_linear_system.py 结果为：

/Users/liuxiaoming/PycharmProjects/LinearAlgebra/venv/bin/python /Users/liuxiaoming/PycharmProjects/LinearAlgebra/main_linear_system.py
1.0 0.0 0.0 | -1.0
-0.0 1.0 0.0 | -2.0
-0.0 -0.0 1.0 | 3.0
--------------------------------------------------
1.0 0.0 0.0 | 6.853333333333333
-0.0 1.0 0.0 | 1.506666666666665
0.0 0.0 1.0 | -2.266666666666666
--------------------------------------------------
1.0 0.0 0.0 | -1.9999999999999998
0.0 1.0 0.0 | 1.0
-0.0 -0.0 1.0 | -3.0
--------------------------------------------------
1.0 0.0 0.0 | 2.9999999999999996
-0.0 1.0 0.0 | -3.9999999999999996
0.0 0.0 1.0 | 0.4999999999999999
--------------------------------------------------
1.0 0.0 0.0 | 3.0
-0.0 1.0 0.0 | -3.0
-0.0 -0.0 1.0 | 2.0
--------------------------------------------------
1.0 0.0 0.0 | 1.0
0.0 1.0 0.0 | 1.0
-0.0 -0.0 1.0 | 1.0
--------------------------------------------------
1.0 -1.0 0.0 -2.0 0.0 | -15.0
0.0 0.0 1.0 1.0 0.0 | 5.0
0.0 0.0 0.0 0.0 1.0 | 2.0
0.0 0.0 0.0 0.0 0.0 | 0.0
--------------------------------------------------
[0, 2, 4]
2 5.0
主元： [0, 1] 2
No Solution!
1.0 0.0 | -4.0
0.0 1.0 | 5.5
0.0 0.0 | 5.0
--------------------------------------------------

Process finished with exit code 0

---

---

• 齐次线性方程组

 

 

 由于其次线性方程组等号右边全部为0所以不需要使用增广矩阵