scipy linear programming - formulation of problem

Question

Friends - Can someone help me formulate a LP problem using scipy in python as below, sorry for this naive ask, I am not able to get started at all with this. I could do this in excel, but finding it difficult in python (am new to this library and couldn't solve) I would be very thankful if someone could help me out please:

This is the data:

This is problem formulated

import pulp as p
import numpy as np

arr = np.array([[0.1167, 2.40,   6.95], [0.1327, 3.44, 15.1], [0.1901, 3.76, 12.7]])
arr = arr.transpose()

# create a problem
Lp_prob = p.LpProblem('Problem', p.LpMinimize)

# create variables
x1 = p.LpVariable("x1", lowBound=0, upBound=np.inf)
x2 = p.LpVariable("x2", lowBound=0, upBound=np.inf)
x3 = p.LpVariable("x3", lowBound=0, upBound=np.inf)


# define problem
Lp_prob += 6.95 * x1 + 15.1 * x2 + 12.7 * x3

# define constraints
Lp_prob += x1 * 0.1167 + x2 * .1327 + x3 * 0.1901 >= 1.95
Lp_prob += x1 * 2.4 + x2 * 3.44 + x3 * 3.76 >= 0
Lp_prob += x1 >= x2
Lp_prob += x1 >= 0
Lp_prob += x2 >= 0
Lp_prob += x3 >= 0

# see the problem created
print(Lp_prob)

status = Lp_prob.solve()

PulpSolverError: Pulp: Error while executing C:\Users\FinanceProfessional\.conda\envs\spyder-env\Lib\site-packages\pulp\apis\..\solverdir\cbc\win\64\cbc.exe

Using scipy

from scipy.optimize import linprog
arr = np.array([[0.1167, 2.40,   6.95], [0.1327, 3.44, 15.1], [0.1901, 3.76, 12.7]])
arr = arr.transpose()

c = arr[-1]
A = [arr[0], arr[1], [1,1,0]]
b = [0.09, 0, 0]
    
x0_bounds = (0, None)
x1_bounds = (0, None)
x2_bounds = (0, None)    
    
result = linprog(c, A_ub=A, b_ub=b, bounds=[x0_bounds, x1_bounds, x2_bounds], method='revised simplex')   

print(result)

con: array([], dtype=float64)
     fun: 0.0
 message: 'Optimization terminated successfully.'
     nit: 0
   slack: array([0.09, 0.  , 0.  ])
  status: 0
 success: True
       x: array([0., 0., 0.])
    

Answer 1

from scipy.optimize import minimize

a1, a2, a3 = 1167,1327,1907
b1,b2,b3 = 24000, 34400, 36000
c1,c2,c3 = 69500,15100,12700

x = [10000,10000,10000] 
res = minimize(
    lambda x: c1*x[0]+c2*x[1]+c3*x[2], #what we want to minimize
    x, 
    constraints = (
        {'type':'eq','fun': lambda x: x[0]*a1-x[1]*a2}, #1st subject
        {'type':'ineq','fun': lambda x: a1*x[0]+a2*x[1]+a3*x[2]-7}, #2st subject
        {'type':'ineq','fun': lambda x: b1*x[0]+b2*x[1]+b3*x[2]-0}, #3st subject
        {'type':'eq','fun': lambda x: x[0]%5+x[1]%5+x[2]%5-0}, # x1 x2 x3 are multiple of 5

                  ),
    bounds = ((0,None),(0,None),(0,None)),
    method='SLSQP',options={'disp': True,'maxiter' : 10000})

print(res)

here the output :

> Optimization terminated successfully    (Exit mode 0)
>             Current function value: 381000000.00006175
>             Iterations: 2
>             Function evaluations: 9
>             Gradient evaluations: 2
>      fun: 381000000.00006175
>      jac: array([69500., 15100., 12700.])  message: 'Optimization terminated successfully'
>     nfev: 9
>      nit: 2
>     njev: 2   status: 0  success: True
>        x: array([    0.,     0., 30000.])

I had to multiplied all value by 10000 to avoid mode 8 as explained here

I hope this is what you needed. However you should try Or-Tools, a CP library powerful and easier than scipy.

edit: answer to comment

here is a link to a google collab as the original poster cannot run this code on his side.