当前位置: 首页 > news >正文

单纯形法的补充与代码实现

线性规划中,我们介绍了三种求解算法——单纯形法、对偶理论和内点法。

传送门:线性规划之单纯形法 线性规划的对偶理论 线性规划之内点法

其中单纯形法要建立在标准型上,并且开始迭代要求有一个基本可行解。如果系数矩阵A规模较大,有时候比较难找到初始可行解。这时候需要用人工手段增加变量,来找到初始可行解。具体方法为:

通过从每个约束行中选取系数在对应列向量中唯一非零,而且系数符号与右边项一致的变量作为基变量,可以构造单纯形法的初始基。如果标准型中没有满足条件的变量,可以引入人工变量。此时目标函数为求人工变量之和最小化的问题,即目标函数除人工变量系数为1外,其余变量系数均为0.

我们举一个例子,对于下面的标准型LP问题,引入人工变量找到初始可行集:

fa89b67d9f40c91bbb8232967fe45997.png

首先看第一个约束,变量x4系数在列向量中唯一非零,但其系数为负,而对应的右边项系数为正,因此需要引入人工变量x6;第二个约束,变量x5系数在列向量中唯一非零,且符号与右边项一致,因此x5可作为初始基。第三第四个约束均没有满足条件的向量,引入人工变量x7和x8。

此时要求解的目标函数变为:

2f696826052c88d0ccf80754dbe97628.png

最后四列即可新LP问题的初始可行解,通过单纯形法可以求解最优解。最后还需要检验该问题最优解是否为原模型的可行解。判断标准为:

如果人工变量之和最小值大于0,则原模型无可行解,计算到此为止,否则人工模型最后的基作为求解原模型的初始可行基

我们用python开发完整的单纯形法代码,包含人工模型的(阶段一)以及求解原模型(阶段二)的过程。考虑到有些场景可以直接找到原模型初始可行解,因此阶段一不一定用得上,因此用python的装饰器实现。

import numpy as np
import pandas as pd
from numpy.linalg import det,inv #求解矩阵的秩和逆矩阵


class Simplex(object):
    '''
    单纯形法求解最值问题,这里固化为求最小值,要是遇到求最大值,将目标系数向量取负号即可
    '''


    def __init__(self, A, b, c, B_x):


        '''


        :param A: 系数矩阵
        :param b: 常数向量
        :param c: 目标函数系数向量
        :param B_x: 初始基变量索引列表
        '''
        self.A = A
        self.b = b
        self.c = c
        self.B_x = B_x


    def __call__(self, *args, **kwargs):


        print('单纯形法第二阶段...')
        x = self.phaseII(self.A, self.b, self.c, self.B_x)
        return x


    @classmethod
    def phaseI(cls, manual_n, A_, b, c, B_x_):


        '''
        单纯形法第一阶段,确定初始可行基
        这里人工变量排在矩阵后面
        :param manual_n: 人工变量的个数
        :param A_: 添加人工变量后的系数矩阵
        :param b: 常数向量
        :param c: 目标函数系数向量
        :param B_x_: 初始可行基
        :return:
        '''


        print('单纯形法第一阶段......')
        c_ = [0 for i in range(len(c))] + [1 for i in range(manual_n)]  # 添加人工变量后的目标函数系数向量, 人工变量系数为1,其余均为0
        c_ = np.array(c_)
        x_ = cls.phaseII(A_, b, c_, B_x_)
        a = np.dot(c_, np.array(x_))


        if a > 0:
            print('原模型无可行解')
        else:
            B_x = []
            for n, i in enumerate(x_):
                if i != 0:
                    B_x.append(n)


            return cls(A_[:, :-manual_n], b, c, B_x)


    @staticmethod
    def phaseII(A, b, c, B_x):
        '''


        :param n: 列向量个数
        :param B_x: 初始基变量索引列表
        :return:
        '''


        n = A.shape[1]  # 列向量个数
        N_x = list(filter(lambda x: 0 if x in B_x else 1, [i for i in range(n)]))  # 初始非基变量索引
        init_B = A[:, B_x]  # 基矩阵
        x_0 = np.dot(inv(init_B), b)  # t=0的解
        for i in N_x:
            x_0 = np.insert(x_0, i, 0)


        t, dim = 0, n - len(N_x)
        while True:


            if t >= 100:
                break


            # print('t={}时刻**********'.format(t))
            print('t={}时刻目标函数取值{}:'.format(t, np.dot(c, x_0)))
            # print('入基变量索引:', B_x)
            # print('出基变量索引:', N_x)
            # print('基矩阵:', init_B)
            # print('唯一解:', x_0)


            v = np.dot(c[B_x], inv(init_B))  # 定价向量
            # print('定价向量:', v)
            delta_c = dict(zip([c[i] - np.dot(v, A[:, i]) for i in N_x], N_x))
            # print('非基变量目标函数变化值:', delta_c)


            if min(delta_c) < 0:
                p = delta_c[min(delta_c)]
            else:
                p = -1
                print('计算结束,最优解为:', x_0)
                break


            delta_x = np.dot(-inv(init_B), A[:, p])
            # print('入基变量索引p={},此时单纯性方向为:{}'.format(p, delta_x))


            if min(delta_x) < 0:
                di = {}
                for i in range(dim):
                    if delta_x[i] < 0:
                        di[B_x[i]] = -x_0[B_x[i]] / delta_x[i]
                lam = min(di.values())
                r = min(di, key=di.get)
            else:
                r = -1
                print('单纯性方向所有元素非负,模型无界')
                break
            # print('出基变量索引r={},此时lamda取值为{}'.format(r,lam))


            E = np.identity(dim)
            E[:, B_x.index(r)] = [
                -1 / delta_x[B_x.index(r)] if i == B_x.index(r) else -delta_x[i] / delta_x[B_x.index(r)]
                for i in range(dim)]
            init_B = inv(np.dot(E, inv(init_B)))


            d = dict(zip(B_x, delta_x))
            delta_x = np.array(list(dict(sorted(d.items(), key=lambda x: x[0])).values()))
            for i in N_x:
                delta_x = np.insert(delta_x, i, 0)
            delta_x[p] = 1


            B_x[B_x.index(r)] = p  # 更新入基变量索引
            N_x = list(filter(lambda x: 0 if x in B_x else 1, [i for i in range(n)]))  # 更新出基变量索引
            x_0 = [x_0[i] + lam * delta_x[i] for i in range(n)]  # 更新解
            t += 1
        #print('###########################################')


        return x_0

下面是应用单纯形法求灵敏度分析的过程:

import itertools as it
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False


def plot(di):


    li1 = list(di.keys())
    li2 = list(di.values())
    plt.scatter([li1[i] for i in [0,80,84,100,199,291,318,355]],[li2[i] for i in [0,80,84,100,199,291,318,355]],c='r')
    # plt.text(5, 9900, s='斜率8.57', verticalalignment='bottom')
    # plt.text(11, 9970, s='斜率36.73', verticalalignment='bottom')
    # plt.text(10, 10020, s='斜率50.11', verticalalignment='bottom')
    plt.plot(di.keys(),di.values())
    # plt.xlim(-1,13)
    plt.xlabel('目标函数系数')
    plt.ylabel('最优值')
    plt.title('废料4成本对目标最优值影响')
    plt.show()




if __name__ == '__main__':
    # 系数矩阵
    A = np.array(
        [[1.000, 1.000, 1.0000, 1.000, 1, 1, 1,  0, 0,  0, 0,  0, 0,  0, 0, 0, 0],
         [0.008, 0.007, 0.0085, 0.004, 0, 0, 0, -1, 0,  0, 0,  0, 0,  0, 0, 0, 0],
         [0.008, 0.007, 0.0085, 0.004, 0, 0, 0,  0, 1,  0, 0,  0, 0,  0, 0, 0, 0],
         [0.180, 0.032, 0.0000, 0.000, 1, 0, 0,  0, 0, -1, 0,  0, 0,  0, 0, 0, 0],
         [0.180, 0.032, 0.0000, 0.000, 1, 0, 0,  0, 0,  0, 1,  0, 0,  0, 0, 0, 0],
         [0.120, 0.011, 0.0000, 0.000, 0, 1, 0,  0, 0,  0, 0, -1, 0,  0, 0, 0, 0],
         [0.120, 0.011, 0.0000, 0.000, 0, 1, 0,  0, 0,  0, 0,  0, 1,  0, 0, 0, 0],
         [0.000, 0.001, 0.0000, 0.000, 0, 0, 1,  0, 0,  0, 0,  0, 0, -1, 0, 0, 0],
         [0.000, 0.001, 0.0000, 0.000, 0, 0, 1,  0, 0,  0, 0,  0, 0,  0, 1, 0, 0],
         [1.000, 0.000, 0.0000, 0.000, 0, 0, 0,  0, 0,  0, 0,  0, 0,  0, 0, 1, 0],
         [0.000, 1.000, 0.0000, 0.000, 0, 0, 0,  0, 0,  0, 0,  0, 0,  0, 0, 0, 1],
         ])


    di = dict()
    for coef in np.linspace(0, 50, 501):
        b = np.array([1000, 6.5, 7.5, 30, 35, 10, 12, 11, 13, 75, 250])  # 常数项
        c = np.array([16, 10, 8, coef, 48, 60, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])  # 目标函数系数
        B_x = [2, 3, 4, 5, 6, 7, 10, 12, 14, 15, 16]
        # B_x = [1,7,8,9,10,11,12,13,14,15,16]
        # print(det(A[:,B_x]))
        # print(A.shape,b.shape,c.shape)
        model = Simplex(A,b,c,B_x)
        x_0 = model()
        di[coef] = np.dot(c,np.array(x_0))


    pd.DataFrame([di.keys(),di.values()]).to_csv(r'RHS.csv',index=False)
    plot(di)

相关文章:

  • C++ —— 模拟实现list
  • K-means聚类算法及Python代码实现
  • python -- PyQt5(designer)中文详细教程(一)Qt的基本功能
  • ARM 汇编编写 LED 灯
  • 22个Vue 源码中的工具函数
  • Java并发编程—锁升级
  • [解题报告] CSDN竞赛第11期
  • 【软件工程】白盒测试:基本路径测试
  • 【1774. 最接近目标价格的甜点成本】
  • Part4_场景_第60章 阿利亚加第61章 基于MATSim的新住户效用函数检验:以保定市为例
  • Android自定义视图
  • QT+OSG/osgEarth编译之五十四:osgUI+Qt编译(一套代码、一套框架,跨平台编译,版本:OSG-3.6.5工具库osgUI)
  • Linux开发常用ps命令选项详解
  • 【云原生】一文带你吃透FlexManager数据传入华为云IOT
  • Redis配置与优化
  • 基于STM32单片机的温度报警器(数码管)(Proteus仿真+程序)
  • Rook Ceph浅谈
  • Kafka - 13 Java 客户端实现消费者消费消息
  • Pariatur sint mollitia odit eveniet.Dazu Name tragen.
  • 微信小程序自动化测试实践(附 Python 源码)| 实战系列
  • SAP ARFCSTATE ARFCSDATA TRFCQOUT
  • 两种形式的import
  • 什么是DCMM认证,企业为什么要做DCMM
  • 《自己动手写CPU》学习记录(1)——第1章
  • java计算机毕业设计农产品供销服务系统源程序+mysql+系统+lw文档+远程调试
  • 第4季6:图像sensor的寄存器操作
  • 汽车电子之功能安全介绍
  • 【viper】go 配置管理神器viper使用详解
  • 170-本地WIFI测试环境配置IP
  • 【面试宝典】Mysql面试题大全
  • 湖南2021本科批(普通类历史类)第一次征集志愿投档分数线
  • 2022年甘肃高考482分能报什么大学 482分能上哪些院校
  • 2022年全国各大高校在山东招生计划及分数
  • 浙江有哪些师范大学,年浙江师范类大学分数线排名一览表
  • 武汉设计工程学院是几本
  • 2022感恩节放假吗 中国有哪些节日会放假
  • 12种新高考3+1+2选科组合分析 怎么选科好
  • 0基础艺考最容易过的专业有哪些 通过率最高的专业是什么
  • 体育高水平怎么报名
  • 浙江2022普通类第二段平行投档分数线是多少