Python实现线性规划单纯型法

已于 2022-04-14 22:34:55 修改
阅读量782 收藏 13
点赞数 7
文章标签： python
于 2022-04-14 22:33:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44444503/article/details/124183740
版权
这段代码实现了一个简单的单纯形法类，用于将线性规划问题转化为标准形式并进行迭代优化，找到最优解。类中包含初始化、添加约束和目标函数、设置目标最大化或最小化、输出原始和标准形式问题、打印单纯形表、迭代优化以及输出最优解等功能。通过示例展示了如何使用该类解决线性规划问题。
摘要由CSDN通过智能技术生成

定义单纯型函数

import numpy as np


class Simplex:

    def __init__(self, A=np.empty([0, 0]), b=np.empty([0, 0]), c=np.empty([0, 0]), minmax="MAX"):  # 不指定默认为求MAX
        self.A = A
        self.b = b
        self.c = c
        self.x = [float(0)] * len(c)
        self.minmax = minmax
        self.printIter = True
        self.optimalValue = None
        self.transform = False  # 控制是否需要转换

    def addA(self, A):
        self.A = A

    def addB(self, b):
        self.b = b

    def addC(self, c):
        self.c = c
        self.transform = False

    def setPrintIter(self, printIter):
        self.printIter = printIter

    # 生成初始单纯性表
    def getTableau(self):
        # construct starting tableau
        # 当函数目标值为MIN时，将C值变为负值
        if self.minmax == "MIN" and self.transform == False:
            self.c[0:len(self.c)] = -1 * self.c[0:len(self.c)]
            self.transform = True

        # 构建初始单纯型表
        t1 = np.array([None, 0])  # t1
        numVar = len(self.c)  # 目标函数中原始变量数
        numSlack = len(self.A)  # 松弛变量数

        t1 = np.hstack(([None], [0], self.c, [0] * numSlack))  # hstack水平按列堆叠数组，构成初始单纯型表第一行Cj
        basis = np.array([0] * numSlack)  # 基变量，有几个松弛变量，添加几个0

        # 在原始变量的基础上增加基变量下标，便于输出基变量x……
        for i in range(0, len(basis)):
            basis[i] = numVar + i

        A = self.A

        if not ((numSlack + numVar) == len(self.A[0])):  # 创建松弛变量的基变量
            B = np.identity(numSlack)
            A = np.hstack((self.A, B))  # 将创建的基变量按列堆叠给A矩阵
        # # 测试A和b显示是否正常
        # print(A)
        # print(self.b)

        print('======================将原问题转化为标准形式如下：=============================')
        for i in range(0, len(A)):
            for j in range(0, len(A[0])):
                if j == len(A[0]) - 1:
                    print(f'{A[i, j]}*x{j + 1}', end=' = ')
                    print(self.b[i])
                else:
                    if A[i, j] >= 0:
                        print(f'{A[i, j]}*x{j + 1}', end=' + ')
                    else:
                        print(f'({A[i, j]})*x{j + 1}', end=' + ')  # x系数为“－”时，需要加上括号
        print("==========================================================================")

        t2 = np.hstack((np.transpose([basis]), np.transpose([self.b]), A))

        tableau = np.vstack((t1, t2))  # 把t1和t2按行堆叠

        tableau = np.array(tableau, dtype='float')

        # tableau[0,4] = 99

        return tableau

        # 输出标准函数式子

    def printOrigin(self):
        print('=========================原问题转化形式如下：================================')
        for i in range(0, len(self.A)):
            for j in range(0, len(self.A[0])):
                if j == len(self.A[0]) - 1:
                    print(f'{self.A[i, j]}*x{j + 1}', end=' <= ')
                    print(self.b[i])
                else:
                    if self.A[i, j] >= 0:
                        print(f'{self.A[i, j]}*x{j + 1}', end=' + ')
                    else:
                        print(f'({self.A[i, j]})*x{j + 1}', end=' + ')  # x系数为“－”时，需要加上括号
        print("==========================================================================")

    # 打印显示单纯型表
    def printTableau(self, tableau):

        print("变量\t", end="\t")
        print("最优值", end="\t\t")
        for j in range(0, len(self.c)):  # 打印初始变量
            print("x" + str(j + 1), end="\t\t\t")
        for j in range(0, (len(tableau[0]) - len(self.c) - 2)):  # 总列数-初始变量数-2（basis和c转置的列数）
            print("x" + str(j + len(self.c) + 1), end="\t\t\t")
        print()

        print('--------------------------------------------------------------------------')
        # 以下是输出tableau，按行打印
        for j in range(0, len(tableau)):  # len(tableau)为4行
            for i in range(0, len(tableau[0])):  # len(tableau[0])为7列
                if not np.isnan(tableau[j, i]):  # 判断是否是空值
                    if i == 0:
                        print(f"x{int(tableau[j, i]) + 1}", end="\t\t")  # 打印基变量所在列

                    else:

                        # # 尝试显示换入换出变量枢纽值
                        # if i == self.r and j == self.n:
                        #     print(f"[%.3f]" % tableau[j, i], end="\t\t")  # 此处添加小数位数，调整对齐
                        # else:

                        print(f"%.3f" % tableau[j, i], end="\t\t")  # 此处添加小数位数，调整对齐

                else:
                    print('σj  ', end="\t")  # 是空值时打印σj \t\t
            print()

    # 设置目标函数，求Max还是Min
    def setObj(self, minmax):
        if minmax == "MIN" or minmax == "MAX":
            self.minmax = minmax
        else:
            print("==========================================================================")
            print("          这是无效的函数目标，目标函数须是MAX或MIN，以下将默认求解MAX:")
            print("==========================================================================\n")
        self.transform = False

    # 执行优化迭代，直至生成最优解
    def optimize(self):
        # 判断目标函数，MIN与MAX相互转换（乘-1）
        if self.minmax == "MIN" and self.transform == False:
            for i in range(len(self.c)):
                self.c[i] = -1 * self.c[i]
                transform = True

        tableau = self.getTableau()
        if self.printIter:
            print("===========================初始化单纯型表如下:===============================")
            self.printTableau(tableau)

        # 当基变量不是最优时执行迭代优化
        optimal = False  # 初始基变量不是最优的，需要迭代换入换出
        iter = 1  # 便于查看每次迭代情况

        # 迭代运算，直到最优时停止迭代
        while True:

            if self.printIter:
                print("==========================================================================\n")
                print(f"============================第{iter}次迭代结果如下:===============================")
                self.printTableau(tableau)

            # 当目标函数是MAX时：检验数>0时需要旋转运算
            if self.minmax == "MAX":
                for profit in tableau[0, 2:]:  # tableau[0, 2:]为[2 3 0 0 0]
                    if profit > 0:
                        optimal = False
                        break  # 若profit>0，说明还未达到最优，break跳出该for循环，执行确定换入换出变量等后续操作
                    optimal = True

            # 当目标函数是MIN时：检验数<0时需要旋转运算
            else:
                for cost in tableau[0, 2:]:
                    if cost < 0:
                        optimal = False
                        break
                    optimal = True

            # 当所有检验数均满足条件时，即此时optimal = True，结束旋转运算
            if optimal:
                break

            # nth variable enters basis, account for tableau indexing
            # 第n个变量作为换入变量
            # index()返回指定值首次出现的位置。amax()返回数组的最大值或沿轴的最大值。
            if self.minmax == "MAX":
                # MAX：寻找检验数中的最大值作为换入变量
                n = tableau[0, 2:].tolist().index(np.amax(tableau[0, 2:])) + 2  # 2是上文的两列
            else:
                # MIN：寻找检验数中的最小值作为换入变量
                n = tableau[0, 2:].tolist().index(np.amin(tableau[0, 2:])) + 2

            # 最小比值原则确定换出变量，第r行变量作为换出变量
            minimum = 99999
            r = -1

            for i in range(1, len(tableau)):
                if tableau[i, n] > 0:  # tableau[i, n]指的是换入基那一列
                    val = tableau[i, 1] / tableau[i, n]
                    # 输出最小的比值的行，将这个值给r
                    if val < minimum:
                        minimum = val
                        r = i
            # 下面print是测试枢纽位置
            # print(r)
            # print(n)
            Simplex.r = r
            Simplex.n = n
            # 得到枢纽值为pivot
            pivot = tableau[r, n]
            print(f"换入变量位于该表格的第 {n + 1} 列")
            print(f"换出变量位于该表格的第 {r + 1} 行")
            print(f"交叉的枢纽值为[%.3f]" % pivot)

            # 转换矩阵，将基变量转换为单位阵
            # 换出变量所在行同时/pivot
            tableau[r, 1:] = tableau[r, 1:] / pivot

            # pivot other rows
            # 转换除换出变量以外的其他行
            for i in range(0, len(tableau)):
                if i != r:  # 换出变量所在行的其余行参与运算
                    mult = tableau[i, n] / tableau[r, n]
                    tableau[i, 1:] = tableau[i, 1:] - mult * tableau[r, 1:]

            # 更新基变量下标，生成新的基变量
            tableau[r, 0] = n - 2

            iter += 1

        # 输出最终计算的单纯型表
        if self.printIter:
            print("==========================================================================\n")
            print(f"========================最终单纯型表迭代{iter}次,结果如下：=========================")
            self.printTableau(tableau)
        else:
            print("问题已解决")

        # 保存问题的最优解

        # 输出最优解，生成所有变量的取值序列
        self.x = np.array([0] * (len(self.c)), dtype=float)
        # for i in range(0,len(self.c)+len(self.A)):
        #
        #
        #     print(self.x[i])

        for key in range(1, (len(tableau))):
            # 如初始变量x1,x2,下标最大2，所以只需要输出x1,x2即可,因此只需要保存初始函数变量的解就可以
            if tableau[key, 0] < len(self.c):
                self.x[int(tableau[key, 0])] = tableau[key, 1]
        #         因此只需按顺序赋值给对应的解值，就是该问题的解

        # 保存问题的最优值
        self.optimalValue = -1 * tableau[0, 1]  # 最优值*（-1）变换

    # 输出最优解和最优值
    def printSolu(self):

        print("==========================================================================")
        print(f"该问题最优解为:", end='')
        for i in range(len(self.x)):
            print(f"x%d" % (i + 1), end='')
            print(f"=%.3f" % self.x[i], end=' ')
        print(f"\n最优化目标值为:%.3f" % self.optimalValue)

测试单纯型计算结果


import numpy as np

import Simplex
model = Simplex.Simplex()
#
# import M_Simplex
# model = M_Simplex.M_Simplex()

# 测试例子1
# A = np.array([[1, -2, 4, 2], [4, 0, -1, 1], [0, 4, 1, 2], [0, 5, -6, 0]])
# b = np.array([8, 16, 12, 9])
# c = np.array([-2, 3, -3, 6])


# 测试例子2
# A = np.array([[1, 2, 4], [4, 0, 1], [0, 4, 1], [0, 5, 6]])
# b = np.array([8, 16, 12, 9])
# c = np.array([-2, 3, 3])


# 测试例子3，已验证
# A = np.array([[1, 2, 2], [2, 1, 2], [2, 2, 1]])
# b = np.array([20, 20, 20])
# c = np.array([-10, -12, -12])



# 课本上例子
A = np.array([[1, 2], [4, 0], [0, 4]])
b = np.array([8, 16, 12])
c = np.array([-2, -3])

# # M_Simplex
# A = np.array([[1, -2, 1, 0], [-4, 1, 2, -1], [-2, 0, 1, 0]])
# b = np.array([11, 3, 1])
# c = np.array([3, -1, -1, 0])

model.addA(A)
model.addB(b)
model.addC(c)
model.setObj("MIN")  # 设置目标函数值是MIN或MAX
# print("A =\n", A, "\n")
# print("b =\n", b, "\n")
# print("c =\n", c, "\n\n")
model.printOrigin()
model.optimize()
model.printSolu()
print("==========================================================================")

输出结果如下：

D:\Anaconda3\python.exe D:/Python_Studying/Simplex/test.py
=========================原问题转化形式如下：================================
1*x1 + 2*x2 <= 8
4*x1 + 0*x2 <= 16
0*x1 + 4*x2 <= 12
==========================================================================
======================将原问题转化为标准形式如下：=============================
1.0*x1 + 2.0*x2 + 1.0*x3 + 0.0*x4 + 0.0*x5 = 8
4.0*x1 + 0.0*x2 + 0.0*x3 + 1.0*x4 + 0.0*x5 = 16
0.0*x1 + 4.0*x2 + 0.0*x3 + 0.0*x4 + 1.0*x5 = 12
==========================================================================
===========================初始化单纯型表如下:===============================
变量		最优值		x1			x2			x3			x4			x5			
--------------------------------------------------------------------------
σj  	0.000		-2.000		-3.000		0.000		0.000		0.000		
x3		8.000		1.000		2.000		1.000		0.000		0.000		
x4		16.000		4.000		0.000		0.000		1.000		0.000		
x5		12.000		0.000		4.000		0.000		0.000		1.000		
==========================================================================

============================第1次迭代结果如下:===============================
变量		最优值		x1			x2			x3			x4			x5			
--------------------------------------------------------------------------
σj  	0.000		-2.000		-3.000		0.000		0.000		0.000		
x3		8.000		1.000		2.000		1.000		0.000		0.000		
x4		16.000		4.000		0.000		0.000		1.000		0.000		
x5		12.000		0.000		4.000		0.000		0.000		1.000		
换入变量位于该表格的第 4 列
换出变量位于该表格的第 4 行
交叉的枢纽值为[4.000]
==========================================================================

============================第2次迭代结果如下:===============================
变量		最优值		x1			x2			x3			x4			x5			
--------------------------------------------------------------------------
σj  	9.000		-2.000		0.000		0.000		0.000		0.750		
x3		2.000		1.000		0.000		1.000		0.000		-0.500		
x4		16.000		4.000		0.000		0.000		1.000		0.000		
x2		3.000		0.000		1.000		0.000		0.000		0.250		
换入变量位于该表格的第 3 列
换出变量位于该表格的第 2 行
交叉的枢纽值为[1.000]
==========================================================================

============================第3次迭代结果如下:===============================
变量		最优值		x1			x2			x3			x4			x5			
--------------------------------------------------------------------------
σj  	13.000		0.000		0.000		2.000		0.000		-0.250		
x1		2.000		1.000		0.000		1.000		0.000		-0.500		
x4		8.000		0.000		0.000		-4.000		1.000		2.000		
x2		3.000		0.000		1.000		0.000		0.000		0.250		
换入变量位于该表格的第 7 列
换出变量位于该表格的第 3 行
交叉的枢纽值为[2.000]
==========================================================================

============================第4次迭代结果如下:===============================
变量		最优值		x1			x2			x3			x4			x5			
--------------------------------------------------------------------------
σj  	14.000		0.000		0.000		1.500		0.125		0.000		
x1		4.000		1.000		0.000		0.000		0.250		0.000		
x5		4.000		0.000		0.000		-2.000		0.500		1.000		
x2		2.000		0.000		1.000		0.500		-0.125		0.000		
==========================================================================

========================最终单纯型表迭代4次,结果如下：=========================
变量		最优值		x1			x2			x3			x4			x5			
--------------------------------------------------------------------------
σj  	14.000		0.000		0.000		1.500		0.125		0.000		
x1		4.000		1.000		0.000		0.000		0.250		0.000		
x5		4.000		0.000		0.000		-2.000		0.500		1.000		
x2		2.000		0.000		1.000		0.500		-0.125		0.000		
==========================================================================
该问题最优解为:x1=4.000 x2=2.000 
最优化目标值为:-14.000
==========================================================================

进程已结束,退出代码0

Charonrise
关注
  • 7
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
python线性整数规划求解_优化 |运筹学线性规划单纯形法之求解
weixin_35057850的博客
12-20 956
『运筹OR帷幄』原创作者：臧永森作者：臧永森，清华大学工业工程系在读博士，研究方向：运筹优化算法的设计与应用、数据统计分析、大数据技术与应用，戚铭尧老师团队编者按此文属于电子书线性规划专题第三章单纯形法的内容。在前面的文章中，我们为引入单纯形法介绍了可行域、最优解、可行解、基解、基可行解等基础概念，也阐述了它们之间的关系(具体可见文章《在单纯形法之前》)。在明确了这些基本概念之后，这一节我们来探讨...
python单纯形法解线性规划问题
04-09
基于python的解线性规划问题程序代码，适用环境为python3.6
【线性规划】python单纯形法求解线性规划
m0_52965867的博客
10-07 839
python单纯形法求解线性规划
利用【Python】【线性规划】优化工厂生产：实现智能资源配置与利润最大化的现代解决方案
最新发布
小李很执着的博客
07-11 4037
建立线性规划模型，以解决生产优化问题。通过定义决策变量、目标函数和约束条件，使用Python的SciPy库中的linprog函数求解模型，并验证结果的合理性。最终，确定了在资源限制条件下最大化利润的最优生产方案.
python求解线性规划问题———单纯形法（一）
qq_47723068的博客
11-06 6943
单纯形法 1为什么叫单纯形法 单纯形是N 维空间中的N+1 个顶点的凸包，是一个多胞体：直线上的一个线段，平面上的一个三角形，三维空间中的一个四面体等等，都是单纯形。 已经证明线性规划问题如果存在可行域，那么可行域必然是个凸集，其最优解必然在顶点取到——单纯形。 2单纯形法怎么用 单纯形法的一般解题步骤可归纳如下： 1、把线性规划问题的约束方程组表达成典范型方程组，找出基本可行解作为初始基本可行解。 2、若基本可行解不存在，即约束条件有矛盾，则问题无解。 3、若基本可行解存在，从初始基可行解作为起点，根据最
线性规划单纯形法python实现与代码详细解读
PeterIsCoding的博客
09-16 5905
本文为大家详细解读线性规划单纯形法的原理，以及超详细的python源码解读！
Python求解线性规划问题-两阶段法实现的单纯形法
05-09
Python求解线性规划问题_两阶段法实现的单纯形法，包括.py和.ipynb两种格式，用Jupyter Notebook打开.ipynb或者用Python软件打开.py都可成功运行，压缩包中包括测试数据，代码可输出唯一解，无穷多解，无界解，无解...
对偶单纯形法python实现
07-18
在Python中，我们可以使用`scipy.optimize.linprog`函数，它内部实现了包括对偶单纯形法在内的多种线性规划算法。例如： ```python from scipy.optimize import linprog c = [-1, 2] # 目标函数系数 A = [[1,...
单纯形法讲解及Python代码实现
12-21
通过以上步骤，我们可以使用Python实现单纯形法来解决线性规划问题，无论问题规模大小，只要满足线性规划的基本假设，单纯形法都能在有限步内找到最优解，效率远高于穷举所有可能的解。需要注意的是，虽然单纯形法在...
线性规划-单纯形法-窗体实现(python)
03-27
在本项目中，"线性规划-单纯形法-窗体实现(python)"是用Python编程语言实现的一种交互式解决方案，它结合了数学概念与用户友好的图形界面。 单纯形法是线性规划的标准解法，由乔治·丹齐格在1947年提出。这种方法...
单纯形法Python实现(一)
12-21
【单纯形法】是线性规划问题的一种求解方法，由美国数学家乔治·丹齐格在1947年提出。它通过一系列迭代步骤，将初始问题转换为一系列简单的线性组合，直到找到满足所有约束条件且目标函数最优的解。在Python中，可以...
单纯形法python
04-24
单纯形法python代码，单纯形法python代码，单纯形法python代码，单纯形法python代码，单纯形法python代码，单纯形法python代码，
python中线性规划中的单纯形法、scipy库与非线性规划求解问题
12-21
单纯形法、scipy库与非线性规划求解问题单纯形法的基本定义大M法求解线性规划的原理excel求解Python调用optimize包和scipy求解线性规划Python编程实现单纯形法对比情况非线性规划 单纯形法的基本定义 单纯形法的基本定义： 一般线性规划问题中当线性方程组的变量数大于方程个数，这时会有不定数量的解，而单纯形法是求解线性规划问题的通用方法。 具体步骤是，从线性方程组找出一个个的单纯形，每一个单纯形可以求得一组解，然后再判断该解使目标函数值是增大还是变小了，决定下一步选择的单纯形。通过优化迭代，直到目标函数实现最大或最小值。 换而言之，单纯形法就是秉承“保证每一次迭代比前一次更
线性规划的单纯形法及python实现
Xiaoyao_Ma的博客
05-17 1001
文章目录1. 线性规划的解2. 线性规划的标准型3. 初级单纯形法4. 修正单纯形法5. 修正单纯形的代码实现 1. 线性规划的解 一个线性规划（LP）问题如果有最优解，必定有一个最优解出现在顶点上。 从几何上讲，线性规划的约束集合为凸面体，一个超平面（目标函数的等值面）靠近约束集合时，最先接触到的必然是凸面体的一个顶点或一条边，因此一定有一个最优解出现在顶点上。 2. 线性规划的标准型 线性规划的标准型为： min⁡ cTxs.t. Ax=b x≥0\begin{alig
用Python求解线性规划问题
热门推荐
简说Python的博客
03-12 2万+
线性规划简介及数学模型表示线性规划简介一个典型的线性规划问题线性规划模型的三要素线性规划模型的数学表示图解法和单纯形法图解法单纯形法使用python求解...
python非线性规划问题讲析_python中线性规划中的单纯形法、scipy库与非线性规划求解问题...
weixin_33140481的博客
01-14 491
单纯形法的基本定义单纯形法的基本定义：一般线性规划问题中当线性方程组的变量数大于方程个数，这时会有不定数量的解，而单纯形法是求解线性规划问题的通用方法。 具体步骤是，从线性方程组找出一个个的单纯形，每一个单纯形可以求得一组解，然后再判断该解使目标函数值是增大还是变小了，决定下一步选择的单纯形。通过优化迭代，直到目标函数实现最大或最小值。 换而言之，单纯形法就是秉承“保证每一次迭代比前一次更优”的基...
python编程求解线性规划中的单纯形法（不调用库的解法，有例题对照理解，容易理解）
mango
04-21 1613
例题： python编程求解线性规划中的单纯形法代码如下： # encoding=utf-8 import numpy as np # python 矩阵操作lib class Simplex(): def __init__(self): self._A = "" # 系数矩阵 self._b = "" #数组 self._c ...
线性规划模型单纯形法Python实现
06-21
线性规划（Linear Programming, LP）是一种优化问题，用于在有限资源下最大化或最小化目标函数，同时满足一系列线性约束。单纯形法（Simplex Method）是一种经典的求解线性规划问题的算法，尤其适用于求解极大化问题。在Python中，我们可以使用专门的库如`scipy.optimize`中的`linprog`函数，或者` pulp`库来实现。 以下是使用`scipy.optimize`实现单纯形法的一个简单示例： ```python from scipy.optimize import linprog import numpy as np # 定义线性目标函数（最大化）和约束 c = [-1, 2] # 目标函数系数（如果最小化，改为正值） A = [[-1, 1], [2, -1]] # 约束矩阵 b = [3, 1] # 约束值 # 构建线性规划问题 # 这里默认A_ub=None表示无上界约束（若有，提供A_ub和ub），b_ub=None表示非负解 res = linprog(c, A_ub=A, b_ub=b) # 输出结果 print("Optimal solution:") print("x =", res.x) print("Objective value =", res.fun) ``` 在这个例子中，我们有一个目标函数`c.T * x`（`c`是目标函数系数向量，`T`是转置），和两个约束`Ax <= b`。`linprog`函数会自动处理这些信息并返回最优解。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值