scipy.optimize.linprog(c,A_ub=None,b_ub=None,A_eq=None,b_eq=None,bounds=None,method='interior-point',callback=None,options=None,x0=None)​

optimize.linprog(c,A_ub,b_ub)
optimize.linprog(c,A_ub,b_ub,Aeq,beq)
optimize.linprog(c,A_ub,b_ub,Aeq,beq,(LB,UB))

from scipy import optimize
import numpy as np

c = np.array([2,3,-5])
A_ub = np.array([[-2,5,-1],[1,3,1]])
b_ub = np.array([-10,12])
Aeq = np.array([[1,1,1]])
Beq = np.array([7])

#optimize.linprog(c,A,b,Aeq,beq,LB,UB,X0,OPTIOS)
res = optimize.linprog(-c,A_ub,b_ub,Aeq,Beq)
print(res)

prob = pulp.LpProblem('problem name', sense=pulp.LpMinimize)

x0 = pulp.LpVariable('x0', lowBound=0, upBound=None, cat=pulp.LpInteger)
x1 = pulp.LpVariable('x1', lowBound=0, upBound=None, cat=pulp.LpInteger)
x2 = pulp.LpVariable('x2', lowBound=0, upBound=None, cat=pulp.LpInteger)

prob += 2*x0-5*x1+4*x2

prob += (x0+x1-6*x2 <= 120)

prob.solve()
print(pulp.value(prob.objective))
print(pulp.value(x0))

import pulp

#目标函数的系数
z=[2,3,-5]

#约束
a=[[2,-5,1],[-1,-3,-1]]
b=[10,-12]
A_eq=[1,1,1]
b_eq=7

#确定最大化最小化问题，最小化只要把Max改成Min即可
m = pulp.LpProblem(sense=pulp.LpMaximize)

#定义三个变量放到列表中
x = [pulp.LpVariable(f'x{i}',lowBound=0) for i in [1,2,3]]

#定义目标函数，lpDot可以将两个列表的对应位相乘再加和
#相当于z[0]*x[0]+z[1]*x[0]+z[2]*x[2]
m += pulp.lpDot(z,x)

#设置约束条件
for i in range(len(a)):
    m+=(pulp.lpDot(a[i],x)>=b[i])
    m+=(pulp.lpDot(A_eq,x)==b_eq)

    
#求解
m.solve()

#输出结果
print(f'优化结果：{pulp.value(m.objective)}')
print(f'参数取值：{[pulp.value(var) for var in x]}')

import cvxpy as cp
import numpy as np

# 定义自变量
n = 6 # 有6个自变量：x1,x2,x3,x4,x5,x6
x = cp.Variable(n)

# 定义相等约束条件
A1 = np.array([[1, 0, 0, 1, 0, 0],
               [0, 1, 0, 0, 1, 0],
               [0, 0, 1, 0, 0, 1],
               ])
b1 = np.array([400, 600, 500])

#定义小于等于约束条件
A2 = np.array([[0.4, 1.1, 1, 0, 0, 0],
               [0, 0, 0, 0.5, 1.2, 1.3],
               ])
b2 = np.array([800, 900])

#定义大于等于约束条件
A3 = np.eye(n)
b3 = np.zeros(n)

#定义目标函数
c = np.array([13, 9, 10, 11, 12, 8])

# 定义问题，把三个约束条件添加上
prob = cp.Problem(cp.Minimize(c.T @ x),
                  [A1 @ x == b1, A2 @ x <= b2, A3 @ x >= b3])

# 解决问题
prob.solve()

# 输出结果
print("\n目标函数的最小值", prob.value)
print("所求的x矩阵")
print(x.value)

# 对x向量各元素取整数后再输出
for item in x.value:
    print(round(item))

from scipy import optimize
import numpy as np

x=np.array([1,2,3,4,5])

u=(abs(x)+x)/2
v=(abs(x)-x)/2
c=u-v

A_ub = np.array([[-2,5,-1,5,1],[1,3,1,4,3]])
b_ub = np.array([-10,12])

res = optimize.linprog(-c,A_ub,b_ub)
print(res)

import pulp
import numpy as np
from pprint import pprint

#运输问题解决函数
def transportation_problem(costs, x_max, y_max):

    row = len(costs)
    col = len(costs[0])

    prob = pulp.LpProblem('Transportation Problem', sense=pulp.LpMaximize)

    var = [[pulp.LpVariable(f'x{i}{j}', lowBound=0, cat=pulp.LpInteger) for j in range(col)] for i in range(row)]

    flatten = lambda x: [y for l in x for y in flatten(l)] if type(x) is list else [x]

    prob += pulp.lpDot(flatten(var), costs.flatten())

    for i in range(row):
        prob += (pulp.lpSum(var[i]) <= x_max[i])

    for j in range(col):
        prob += (pulp.lpSum([var[i][j] for i in range(row)]) <= y_max[j])

    prob.solve()

    return {'objective':pulp.value(prob.objective), 'var': [[pulp.value(var[i][j]) for j in range(col)] for i in range(row)]}

#传入数据
if __name__ == '__main__':
    costs = np.array([[500, 550, 630, 1000, 800, 700],
                       [800, 700, 600, 950, 900, 930],
                       [1000, 960, 840, 650, 600, 700],
                       [1200, 1040, 980, 860, 880, 780]])

    max_plant = [76, 88, 96, 40]
    max_cultivation = [42, 56, 44, 39, 60, 59]
    res = transportation_problem(costs, max_plant, max_cultivation)

    print(f'最大值为{res["objective"]}')
    print('各变量的取值为：')
    pprint(res['var'])

#引入包，linear_sum_assignment是专门用于解决指派问题的模块
import numpy as np
from scipy.optimize import linear_sum_assignment

#导入系数矩阵
efficiency_matrix = np.array([
    [12,7,9,7,9],
    [8,9,6,6,6],
    [7,17,12,14,12],
    [15,14,6,6,10],
    [4,10,7,10,6]])

#定义了开销矩阵（指派问题的系数矩阵）efficiency_matrix，传入linear_sum_assignment，
#结果返回的是最优指派的行和列，例如第一行选择第二列，意为：将第一个人派往第二个工作。
#而根据numpy.array的性质，传入行和列就会返回行列所对应的值，即为输出的第三列

row_index, col_index=linear_sum_assignment(efficiency_matrix)
print(row_index+1)
print(col_index+1)
print(efficiency_matrix[row_index,col_index])

#对其求和，即可得到指派问题的最小时间
print(efficiency_matrix[row_index, col_index].sum())

import pulp
import numpy as np

#先定义通用解决方法，其中的flatten是递归展开列表用的
def assignment_problem(efficiency_matrix):
    row = len(efficiency_matrix)
    col = len(efficiency_matrix[0])

    flatten = lambda x: [y for l in x for y in flatten(l)] if type(x) is list else [x]

    m = pulp.LpProblem('assignment', sense=pulp.LpMinimize)
    var_x = [[pulp.LpVariable(f'x{i}{j}', cat=pulp.LpBinary) for j in range(col)] for i in range(row)]

    m += pulp.lpDot(efficiency_matrix.flatten(), flatten(var_x))

    for i in range(row):
        m += (pulp.lpDot(var_x[i], [1]*col) == 1)

    for j in range(col):
        m += (pulp.lpDot([var_x[i][j] for i in range(row)], [1]*row) == 1)

    m.solve()

    return {'objective':pulp.value(m.objective), 'var': [[pulp.value(var_x[i][j]) for j in range(col)] for i in range(row)]}

#然后定义矩阵，输入求解
efficiency_matrix = np.array([
    [12, 7, 9, 7, 9],
    [8, 9, 6, 6, 6],
    [7, 17, 12, 14, 9],
    [15, 14, 6, 6, 10],
    [4, 10, 7, 10, 9]
])

res = assignment_problem(efficiency_matrix)
print(f'最小值{res["objective"]}')
print(res['var'])

from scipy import optimize
import numpy as np
from matplotlib import pyplot as plt

#题目给到的数据
r=0.01*np.array([5,28,21,23,25])        #平均收益率
q=0.01*np.array([0,2.5,1.5,5.5,2.6])    #交易费率
p=0.01*np.array([0,1,2,4.5,6.5])        #风险损失率
u=np.array([103,198,52,40])             #s_i的交易定额

M=1                                     #根据基本假设为了方便计算使M=1
a=0                                     #投资风险度是由用户给出的变量，暂时设初值为0
Qs=np.array([])                         #总收益的最优解集合，随a的变化而变化

#对(0,0.05)之间的a进行遍历操作
while a<0.05:
    c=r-p
    A_ub=q*np.eye(len(c))
    b_ub=a*np.ones(len(c))
    Aeq=np.array([1+p])
    beq=np.array([1])
    Q_i=optimize.linprog(-c,A_ub,b_ub,Aeq,beq)
    Qs=np.append(Qs,-Q_i.fun)
    a+=0.001

#绘图，得出结果    
plt.title("Risk & Reward") 
plt.xlabel("a") 
plt.ylabel("Q") 
plt.plot(np.arange(0,0.05,0.001),Qs,"ob") 
plt.show()

from matplotlib import pyplot as plt
import numpy as np
import cvxpy as cp 

#题目给到的数据
r=0.01*np.array([5,28,21,23,25])        #平均收益率
q=0.01*np.array([0,2.5,1.5,5.5,2.6])    #交易费率
p=0.01*np.array([0,1,2,4.5,6.5])        #风险损失率
u=np.array([103,198,52,40])             #s_i的交易定额

M=1                                     #根据基本假设为了方便计算使M=1
k=0.05                                  #期望总收益是由用户给出的变量，暂时设初值为0.05
kk=[]                                   #k的集合，自变量轴
Rs=[]                                   #总体风险的最优解集合，随k的变化而变化

x=cp.Variable(6,pos=True)               #决策向量6个，且都为正数
obj=cp.Minimize(x[5])                   #优化得目标函数（构造目标函数）

#对(0.05,0.3)之间的k进行遍历操作
while k<0.3:
    con=[cp.multiply(q[1:5],x[1:5])-x[5]<=0,(r-p)@x[:-1]>=k,(1+p)@x[:-1]==1]
    prob=cp.Problem(obj,con)
    prob.solve()
    kk.append(k)
    Rs.append(prob.value)
    k=k+0.005
    

#绘图，得出结果    
plt.figure(figsize=(20,8),dpi=80)
plt.title("Risk & Reward")
plt.xlabel("k")
plt.ylabel("R")
plt.plot(kk,Rs,"ob")
plt.show()