Solving Linear Programming Problems: A Step-by-Step Guide

Solving Linear Programming Problems: A Step-by-Step Guide

Introduction

In this article, we will discuss how to solve linear programming problems using a simple example. We will walk you through the entire process, from defining the model to using a solver.

Why Linear Programming?

Linear programming is a powerful mathematical optimization technique used to optimize complex systems subject to constraints. It helps in making decisions by maximizing or minimizing an objective function under certain conditions.

Example Problem

Let's consider a problem where we have two decision variables, x1 and x2, and coefficients c1=7 and c2=12 for these variables. We also have a matrix A, specified as follows:markdown
3x1 + 4x2 > 4
2x1 + 5x2 > 2This is a linear programming problem with two decision variables and two constraints.

Define the Model

To solve this problem, we first need to define the model. Here's how you can do it:
```python
from pyomo.environ import *

model = AbstractModel()

n = Set(within=range(1,3)) # number of decision variables
m = Set(within=range(1,3)) # number of constraints
c = Param(domain=RangeSet(1,2), within=NonNegativeReals)
a = Param((m,n), domain=NonNegativeReals)
b = Param(domain=RangeSet(1,2), within=NonNegativeReals)
x = Var(within=NonNegativeReals, domain=n)

Constraints

def con_rule(model, m):
return sum(a[m,i]*x[i] for i in n) >= b[m]

con = ConstraintList()
for m in m:
con.add(con_rule(model, m))

Objective Function

obj = Objective(expr=sum(c[i]*x[i] for i in n), sense=minimize)
```

Define the Input Data

To define the input data, we need to create another file with the appropriate extension. In this file, we will specify the sets and parameters of the model.

Solve the Model

After defining the model and input data, we can now solve the problem using a solver. Here's how you can do it:python
x[1], x[2] = 1, 0 # initial values for decision variables
opt = SolverFactory('glpk')
instance = model()
instance.set_values(c=param_dict({i: c[i] for i in n}), a=param_dict((m, i): a[m, i] for m, i in product(m, n)), b=param_dict({m: b[m] for m in m}))
instance.solve()
x[1], x[2] = instance.x[1], instance.x[2] # updated values for decision variables after solving

Results

After solving the model, we can access the results as follows:python
x1, x2 = instance.x[1], instance.x[2]
print(f'x1: {x1}
x2: {x2}')