pyomo

Pyomo is an open-source optimization modeling language in Python. It provides a powerful and intuitive way to formulate and solve complex optimization problems, supporting a wide range of problem types including linear, nonlinear, integer, and mixed-integer programming.

Pros

• Flexible and extensible framework for modeling optimization problems
• Supports a variety of solvers and can interface with commercial and open-source solvers
• Integrates well with other Python scientific computing libraries
• Active development and community support

Cons

• Steeper learning curve compared to some other optimization libraries
• Performance can be slower for large-scale problems compared to specialized solvers
• Documentation can be overwhelming for beginners
• Some advanced features may require additional dependencies

Code Examples

1. Simple linear programming problem:

from pyomo.environ import *

model = ConcreteModel()
model.x = Var([1,2], domain=NonNegativeReals)
model.OBJ = Objective(expr = 2*model.x[1] + 3*model.x[2])
model.Constraint1 = Constraint(expr = 3*model.x[1] + 4*model.x[2] >= 1)

solver = SolverFactory('glpk')
results = solver.solve(model)
model.display()

2. Creating a transportation problem:

from pyomo.environ import *

model = ConcreteModel()
model.i = Set(initialize=['Warehouse1', 'Warehouse2'])
model.j = Set(initialize=['Customer1', 'Customer2', 'Customer3'])
model.x = Var(model.i, model.j, bounds=(0,None))

def obj_rule(model):
    return sum(model.x[i,j] for i in model.i for j in model.j)
model.obj = Objective(rule=obj_rule, sense=minimize)

def supply_rule(model, i):
    return sum(model.x[i,j] for j in model.j) <= 100
model.supply = Constraint(model.i, rule=supply_rule)

def demand_rule(model, j):
    return sum(model.x[i,j] for i in model.i) >= 50
model.demand = Constraint(model.j, rule=demand_rule)

3. Solving a nonlinear problem:

from pyomo.environ import *

model = ConcreteModel()
model.x = Var(initialize=1.0)
model.y = Var(initialize=1.0)

def obj_rule(model):
    return model.x**2 + model.y**2
model.obj = Objective(rule=obj_rule, sense=minimize)

def con_rule(model):
    return model.x + model.y >= 1
model.con = Constraint(rule=con_rule)

solver = SolverFactory('ipopt')
results = solver.solve(model)
model.display()

Getting Started

1. Install Pyomo and a solver (e.g., GLPK):

   pip install pyomo
   pip install glpk
   

2. Create a simple model:

   from pyomo.environ import *
   
   model = ConcreteModel()
   model.x = Var(domain=NonNegativeReals)
   model.y = Var(domain=NonNegativeReals)
   model.obj = Objective(expr = model.x + 2*model.y, sense=maximize)
   model.con = Constraint(expr = 3*model.x + 4*model.y <= 12)
   
   solver = SolverFactory('glpk')
   results = solver.solve(model)
   model.display()
   

This example creates a simple linear programming model, solves it using GLPK, and displays the results.