精华内容
下载资源
问答
  • Python高斯消去求线性方程的解

    千次阅读 2018-08-17 13:24:33
    高斯消去求线性方程的解 ''' 高斯消去法 通过消元过程把一般方程组化成三角方程组 再通过回代过程求出方程组的解 ''' def GaussianElimination(A,B): N = len(A) for i in range(1,N): for j in range(i,N): ...

    #Python高斯消去求线性方程的解

    '''
    高斯消去法
    通过消元过程把一般方程组化成三角方程组
    再通过回代过程求出方程组的解
    '''
    def GaussianElimination(A,B):
        N = len(A)
        for i in range(1,N):
            for j in range(i,N):
                # 计算消元因子delta
                delta = A[j][i-1]/A[i-1][i-1]
                # 从第i-1行开始消元
                for k in range(i-1,N):
                    # 对A进行消元
                    A[j][k] = A[j][k] - A[i-1][k]*delta
                # 对B进行消元
                B[j] = B[j]-B[i-1]*delta
        # 进行回代,直接将方程的解保留在B中
        B[N-1] = B[N-1]/A[N-1][N-1]
        for i in range(N-2,-1,-1):
            for j in range(N-1,i,-1):
                B[i] = B[i]- A[i][j]*B[j]
            B[i] = B[i]/A[i][i]
        # 返回所有解的列表
        return B
    
    matrixA = [[1,3,3],[-2,3,-5],[2,5,6]]
    matrixB = [4,0,1]
    print('方程的解为',GaussianElimination(matrixA, matrixB))
    

    输出的结果:

    方程的解为 [148.0, 7.0, -55.0]
    
    展开全文
  • 高斯消去法的python实现

    千次阅读 2020-03-23 10:10:34
    数值分析中,高斯消去法的原理和python代码 高斯消去法(Gauss)的原理如下: 下面是python代码 import numpy as np #首先确保python安装了numpy包 def gauss(a, b): #自己定义一个函数,自变量是a,b cout = 0...

    数值分析中,高斯消去法的原理和python代码

    原理

    高斯消去法(Gauss)的原理如下:在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    python代码

    import numpy as np #首先确保python安装了numpy包
    
    
    def gauss(a, b):   #自己定义一个函数,自变量是a,b
        cout = 0           #定义计算次数
        m, n = a.shape   #矩阵a的行数和列数
        if ( m < n ):
            print("There is a 解空间。")#保证方程个数大于未知数个数
        else:
            l = np.zeros((n,n))
            for i in range(n):
                # 限制条件
                if (a[i][i] == 0):
                    print("no answer")
    
    
            # j表示列
            for k in range(n - 1):          # k表示第一层循环,(0,n-1)for i in range(k + 1, n):   # i表示第二层循环,(k+1,n),计算该行消元的系数
                    l[i][k] = a[i][k] / a[k][k]     #计算l
                    cout += 1               #计算次数加一
                    for j in range(m):      # j表示列,对每一列进行运算
                        a[i][j] = a[i][j] - l[i][k] * a[k][j]
                        cout += 1
                    b[i] = b[i] - l[i][k] * b[k]
            # 回代求出方程解
            x = np.zeros(n)                       #先将解赋值为零,再一一计算
            x[n - 1] = b[n - 1] / a[n - 1][n - 1] #先算最后一位的x解
    
            for i in range(n - 2, -1, -1):      #依次回代倒着算每一个解
                for j in range(i + 1, n):
                    b[i] -= a[i][j] * x[j]       #自增自减
                x[i] = b[i] / a[i][i]
            for i in range(n):
                print("x" + str(i + 1) + " = ", x[i])
            print("x" " = ", x)
            print("计算次数", "=", cout)
    
    #---------------以上是主程序,以下是输入程序
    
    if __name__ == '__main__':      #当模块被直接运行时,以下代码块将被运行,当模块是被导入时,代码块不被运行。
        a = np.array([[0.5, 1.1, 3.1], [2.0, 4.5, 0.36], [5.0, 0.96, 6.5]])    #输入的系数矩阵
        b = np.array([-6.0, 0.020, 0.96])                                      #增广的一列矩阵
        gauss(a, b)                                                          #进行函数guassin运算
    
    
    
    展开全文
  • PYthon 高斯列主元消去法求增广矩阵/方程组的解 Numpy模块“对 A * X = B” 矩阵的阶数不限模块导入直接上代码 “对 A * X = B” 矩阵的阶数不限 可通过修改 a 的值来改变A a = np.array([[2, 1, 1], [3, 1, 2], [1,...

    PYthon 高斯列主元消去法求增广矩阵/方程组的解 Numpy模块

    “对 A * X = B” 矩阵的阶数不限

    可通过修改 a 的值来改变A

    a = np.array([[2, 1, 1], [3, 1, 2], [1, 2, 2]],dtype=float)
    

    可通过修改 b 的值来修改B

    b = np.array([[4],[6],[5]],dtype=float)
    

    模块导入

    import numpy as np
    

    直接上代码

    # 导入 numpy 模块
    import numpy as np
    
    
    # 行交换
    def swap_row(matrix, i, j):
        m, n = matrix.shape
        if i >= m or j >= m:
            print('错误! : 行交换超出范围 ...')
        else:
            matrix[i],matrix[j] = matrix[j].copy(),matrix[i].copy()
        return matrix
    
    
    # 变成阶梯矩阵
    def matrix_change(matrix):
        m, n = matrix.shape
        main_factor = []
        main_col = main_row = 0
        while main_row < m and main_col < n:
            # 选择进行下一次主元查找的列
            main_row = len(main_factor)
            # 寻找列中非零的元素
            not_zeros = np.where(abs(matrix[main_row:,main_col]) > 0)[0]
            # 如果该列向下全部数据为零,则直接跳过列
            if len(not_zeros) == 0:
                main_col += 1
                continue
            else:
                # 将主元列号保存在列表中
                main_factor.append(main_col)
                # 将第一个非零行交换至最前
                if not_zeros[0] != [0]:
                    matrix = swap_row(matrix,main_row,main_row+not_zeros[0])
                # 将该列主元下方所有元素变为零
                if main_row < m-1:
                    for k in range(main_row+1,m):
                        a = float(matrix[k, main_col] / matrix[main_row, main_col])
                        matrix[k] = matrix[k] - matrix[main_row] * matrix[k, main_col] / matrix[main_row, main_col]
                main_col += 1
        return matrix,main_factor
    
    
    # 回代求解
    def back_solve(matrix, main_factor):
        # 判断是否有解
        if len(main_factor) == 0:
            print('主元错误,无主元! ...')
            return None
        m, n = matrix.shape
        if main_factor[-1] == n - 1:
            print('无解! ...')
            return None
        # 把所有的主元元素上方的元素变成0
        for i in range(len(main_factor) - 1, -1, -1):
            factor = matrix[i, main_factor[i]]
            matrix[i] = matrix[i] / float(factor)
            for j in range(i):
                times = matrix[j, main_factor[i]]
                matrix[j] = matrix[j] - float(times) * matrix[i]
        # 先看看结果对不对
        return matrix
    
    
    # 结果打印
    def print_result(matrix, main_factor):
        if matrix is None:
            print('阶梯矩阵为空! ...')
            return
        m, n = matrix.shape
        result = [''] * (n - 1)
        main_factor = list(main_factor)
        for i in range(n - 1):
            # 如果不是主元列,则为自由变量
            if i not in main_factor:
                result[i] = 'x_' + str(i + 1) + '(free var)'
            # 否则是主元变量,从对应的行,将主元变量表示成非主元变量的线性组合
            else:
                # row_of_main表示该主元所在的行
                row_of_main = main_factor.index(i)
                result[i] = str(matrix[row_of_main, -1])
                for j in range(i + 1, n - 1):
                    ratio = matrix[row_of_main, j]
                    if ratio > 0:
                        result[i] = result[i] + '-' + str(ratio) + 'x_' + str(j + 1)
                    if ratio < 0:
                        result[i] = result[i] + '+' + str(-ratio) + 'x_' + str(j + 1)
        print('方程的通解是:', )
        for i in range(n - 1):
            print('x_' + str(i + 1), '=', result[i])
    
    
    # 得到简化的阶梯矩阵和主元列
    def Handle(matrix_a, matrix_b):
        # 拼接成增广矩阵
        matrix_01 = np.hstack([matrix_a, matrix_b])
        print('增广矩阵为:')
        print(matrix_01)
        matrix_01, main_factor = matrix_change(matrix_01)
        print('阶梯矩阵为:')
        print(matrix_01)
        matrix_01 = back_solve(matrix_01, main_factor)
        print('方程的简化阶梯矩阵:')
        print(matrix_01)
        print('方程的主元列为:')
        print(main_factor)
        print_result(matrix_01, main_factor)
        return matrix_01, main_factor
    
    
    if __name__ == '__main__':
        #a = np.array([[0, 1, 1], [0, 1, 0], [1, 0, 0]])
        a = np.array([[2, 1, 1], [3, 1, 2], [1, 2, 2]],dtype=float)
        b = np.array([[4],[6],[5]],dtype=float)
        Handle(a, b)
        print('*' * 20)
    
    
    展开全文
  • Python实现列主元高斯消去法与LU分解法 数值分析:Python实现列主元高斯消去法与LU分解法求解线性方程组 一、矩阵形式的线性代数方程组 二、高斯消去法 三、高斯列主元消去法 四、矩阵三角分解法(LU分解) 这里...

    Python实现列主元高斯消去法与LU分解法

    数值分析:Python实现列主元高斯消去法与LU分解法求解线性方程组

    一、矩阵形式的线性代数方程组

    在这里插入图片描述

    二、高斯消去法

    在这里插入图片描述
    在这里插入图片描述

    三、高斯列主元消去法

    在这里插入图片描述

    四、矩阵三角分解法(LU分解)

    这里只简单介绍Doolittle分解法。
    在这里插入图片描述
    在这里插入图片描述

    题目:编写列主元高斯消去法与LU分解法解线性方程组Ax=b。

    在这里插入图片描述
    列主元消去法代码实现:

    import math
    import numpy as np
    #目的:熟悉列主元消去法,以及三角分解法等直接求解线性方程组的算法
    #列主元消元法
    def CME(a,b,x):
    
        isdet0 = 0
        m, n = a.shape                  #矩阵a的行数和列数
        # j表示列
        for k in range(n - 1):          # k表示第一层循环,(0,n-1)行
                #在每次计算前,找到最大主元,进行换行
                ans = np.fabs(a[k][k])
                ik = k
                for i in range(k+1, n):
                    if ans < np.fabs(a[i][k]):  # fabs是绝对值,将a中绝
    对值最大的找出来
                        ik = i
                        ans = np.fabs(a[i][k])
    
                if np.fabs(ans) < 1e-10:
                    isdet0 = 1
                    break
                if ik != k :
                    for i in range(k,m):
                        temp = a[k][i]
                        a[k][i] = a[ik][i]
                        a[ik][i] = temp
                    temp = b[k]
                    b[k] = b[ik]
                    b[ik] = temp
    
                for i in range(k + 1, n):   # i表示第二层循环,(k+1,n)行,
    计算该行消元的系数
                    temp = a[i][k] / a[k][k]     #计算
    
                    for j in range(k,m):      # j表示列,对每一列进行运算
                        a[i][j] = a[i][j] - temp * a[k][j]
    
                    b[i] = b[i] - temp * b[k]
        # 回代求出方程解
        if np.fabs(a[n-1][n-1]) < 1e-10 :
            isdet0 = 1
        if isdet0 == 0:
               # x = np.zeros(n)
                x[n - 1] = b[n - 1] / a[n - 1][n - 1] #先算最后一位的x解
                for i in range(n - 2, -1, -1):    #依次回代倒着算每一个解
                    temp = 0
                    for j in range(n - 1, i,-1):
                        temp = temp + a[i][j]*x[j]
    
                    x[i] = (b[i]-temp) / a[i][i]
                for i in range(n):
                    print("x" + str(i + 1) + " = ", x[i])
                print("x" " = ", x)
    if __name__ == '__main__':      #当模块被直接运行时,以下代码块将被运行,当模块是被导入时,代码块不被运行。
        a = np.array([[3.01, 6.03, 1.99], [1.27, 4.16, -1.23], [0.987, -4.81, 9.34]])
        b = np.array([1.0, 1.0, 1.0])
        m,n = a.shape
        x = np.zeros(n)
        B = np.zeros((n, n))
        for i in range(n):
            for j in range(n):
                B[i][j] = a[i][j]
        CME(a,b,x)
        #验证
        for i in range(0, n):
            temp = 0
            for j in range(0, n):
                temp = temp + B[i][j] * x[j]
            print("%f ", temp)
    
    if __name__ == '__main__':
    main()
    
    

    LU分解法代码实现:

    import math
    import numpy as np
    #目的:熟悉列主元消去法,以及三角分解法等直接求解线性方程组的算法
    #列主元消元法
    def CME(a,b,x):
    
        isdet0 = 0
        m, n = a.shape                  #矩阵a的行数和列数
        # j表示列
        for k in range(n - 1):          # k表示第一层循环,(0,n-1)行
                #在每次计算前,找到最大主元,进行换行
                ans = np.fabs(a[k][k])
                ik = k
                for i in range(k+1, n):
                    if ans < np.fabs(a[i][k]):  # fabs是绝对值,将a中绝对值最大的找出来
                        ik = i
                        ans = np.fabs(a[i][k])
    
                if np.fabs(ans) < 1e-10:
                    isdet0 = 1
                    break
                if ik != k :
                    for i in range(k,m):
                        temp = a[k][i]
                        a[k][i] = a[ik][i]
                        a[ik][i] = temp
                    temp = b[k]
                    b[k] = b[ik]
                    b[ik] = temp
    
                for i in range(k + 1, n):   # i表示第二层循环,(k+1,n)行,计算该行消元的系数
                    temp = a[i][k] / a[k][k]     #计算
    
                    for j in range(k,m):      # j表示列,对每一列进行运算
                        a[i][j] = a[i][j] - temp * a[k][j]
    
                    b[i] = b[i] - temp * b[k]
        # 回代求出方程解
        if np.fabs(a[n-1][n-1]) < 1e-10 :
            isdet0 = 1
        if isdet0 == 0:
               # x = np.zeros(n)
                x[n - 1] = b[n - 1] / a[n - 1][n - 1] #先算最后一位的x解
                for i in range(n - 2, -1, -1):      #依次回代倒着算每一个解
                    temp = 0
                    for j in range(n - 1, i,-1):
                        temp = temp + a[i][j]*x[j]
    
                    x[i] = (b[i]-temp) / a[i][i]
                for i in range(n):
                    print("x" + str(i + 1) + " = ", x[i])
                print("x" " = ", x)
    #三角消元法
    def LU(a,b,x):
        m, n = a.shape  # 矩阵a的行数和列数
        y = np.array([0.0, 0.0, 0.0])
        for j in range(1,n):# L的第0列
            a[j][0] = a[j][0] / a[0][0]
        for i in range(1,n-1):# 求U的第i行 L的第i行
            for j in range(i,n):#求U的第i行的第j个元素
                sum = 0.0 #求和
                for s in range(0,i):
                    sum = sum +a[i][s] * a[s][j]
                a[i][j] = a[i][j] - sum
            #求L的第i列的第j个元素  在j行i列
            for j in range(i+1,n):
                sum = 0.0
                for s in range(0,i):
                    sum = sum + a[j][s] * a[s][i]
                a[j][i] = ( a[j][i] - sum ) / a[i][i]
        #求U[n-1][n-1]
        sum = 0.0 #求和
        for s in range(0,n-1):
            sum = sum + a[n-1][s] * a[s][n-1]
        a[n-1][n-1] = a[n-1][n-1] - sum
        y[0] = b[0]
        for i in range(1,n):
            sum = 0.0
            for j in range(0,i):
                sum = sum + a[i][j] * y[j]
            y[i] = b[i] - sum
        x[n-1] = y[n-1] / a[n-1][n-1]
        for i in range(n-2,-1,-1):#求x[i]
            sum = 0.0
            for j in range(n-1,i,-1):
                sum = sum + a[i][j] * x[j]
            x[i] = ( y[i] - sum ) / a[i][i]
        for i in range(n):
            print("x" + str(i + 1) + " = ", x[i])
        print("x" " = ", x)
    
    if __name__ == '__main__':      #当模块被直接运行时,以下代码块将被运行,当模块是被导入时,代码块不被运行。
        a = np.array([[3.01, 6.03, 1.99], [1.27, 4.16, -1.23], [0.987, -4.81, 9.34]])
        b = np.array([1.0, 1.0, 1.0])
        m,n = a.shape
        x = np.zeros(n)
        B = np.zeros((n, n))
        for i in range(n):
            for j in range(n):
                B[i][j] = a[i][j]
       # CME(a,b,x)
        LU(a,b,x)
        #验证
        for i in range(0, n):
            temp = 0
            for j in range(0, n):
                temp = temp + B[i][j] * x[j]
            print("%f ", temp)
    
    
    展开全文
  • 高斯消去法(Gauss)的python实现

    千次阅读 2020-03-23 09:10:50
    高斯消去法(Gauss)的python实现具体代码和注释如下 Guass消去法的算法原理如下图 具体代码和注释如下 import numpy as np #首先确保python安装了numpy包 def gauss(a, b): #自己定义一个函数,自变量是a,b ...
  • 谈谈高斯消去法的 Python 实现

    千次阅读 2019-03-26 23:49:57
    一、开头语 每次写博客都要有一点仪式感,来个片头语先。因为这学期开设了《计算方法》这门课,所以我又捡起了已经许久没有使用的 Python ,从开学到现在...首先,什么是 " 高斯消去法 " ?这里我就直接引用百度上...
  • Python高斯消除矩阵

    2020-09-19 18:42:50
    今天小编就为大家分享一篇关于Python高斯消除矩阵,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • 基于python高斯列主元消去法,此程序是为了解决列主元素消去法而编写的。 此程序可以解决nxn阶行列式问题。 经过自我审查发现本程序的算法思想上应该没有逻辑错误,算法效率上应该还有很大的优化空间。 请大家...
  • Julia的map和python类似,第一个参数为表达式,第二个参数为对象 高斯消去高斯消去法是用来求解线性方程组的经典解法,其基本思路是对增广矩阵做行变换化为上三角矩阵后再回代求得方程组的解。以下均假设方程组...
  • 高斯列主元消去法的python实现

    千次阅读 2020-03-23 10:37:36
    首先要了解高斯消去法的原理和代码,高斯消去法的原理和python实现,高斯列主元消去法是高斯消去法的改进。 高斯列主元消去法的python代码 import numpy as np def swap(a, b, k, n): # 找到主元并交换,这仅是一...
  • 列主元高斯消去

    2012-12-16 14:35:23
    1.掌握列主元消去法的基本思路和迭代步骤 2.并能够利用列主元的高斯消去法解任意阶数的线性方程组;
  • 题目 代码 import numpy as np # 行列式的维度 n = int(input("请输入行列式的维度:")) # 要求解的行列式 x = np.empty([n, n]) print("请输入行列式:") for i in range(n): x[i] = np.array(list(map(float, ...
  • 线性方程组的直接解法:高斯消去法 书本上的流程图如下: 这里也是使用的文件录入数据 文件如下: 代码如下: #coding=gbk; import numpy as np; def GaussEliminate(datas,x): rows=datas.shape[0]; #这个行数...
  • 高斯消去

    千次阅读 2018-06-03 20:31:27
    考虑n阶线性方程组:高斯消去pythonimport numpy as np def gaussin(a, b): m, n = a.shape c = np.zeros(n) for i in range(n): #限制条件 if (a[i][i] == 0): print("no answer") #k...
  • python程序实现的高斯循序消去法程序。 可以用来求解一般的线性方程组。
  • 高斯消去法_解线性方程组的直接解法
  • 基于Python并行性,实现了布尔矩阵的四个高斯消去法,并将其中的最好结果作为最终结果 我的工作 /pyzx/scripts/my_experiment.py中的主要功能 在/pyzx/routing/cnot-mapper.py中已添加和修改了一些函数和类。
  • 为求解一个线性方程组,首先构造增广矩阵[A|B],采用偏序选主元策略的高斯消去法变换成上三角矩阵,再执行回代过程得到解。 输入形式 在屏幕上依次输入方阵阶数n,系数矩阵A和常数矩阵B。 输出形式 首先输出上三角...
  • 相比于普通的高斯消去法,多了一个交换的函数和判断条件 mt = [[0,5,1,2],[2,1,-1,1],[4,-1,1,0]] def trans(a,b): #交换矩阵某两行nxl for i in range(len(a)): temp = a[i] a[i] = b[i] b[i] = temp m = ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 522
精华内容 208
关键字:

python高斯消去

python 订阅