def test_maximize_obj(self):
"""Test the extended cutting plane decomposition algorithm."""
with SolverFactory('mindtpy') as opt:
model = ProposalModel()
model.obj.sense = maximize
print('\n test maximize case to improve code coverage')
opt.solve(model,
strategy='ECP',
mip_solver=required_solvers[1],
nlp_solver=required_solvers[0])
self.assertAlmostEqual(value(model.obj.expr), 14.83, places=1)
def test_fp_Proposal(self):
"""Test the feasibility pump algorithm."""
with SolverFactory('mindtpy') as opt:
model = ProposalModel()
print('\n Solving ProposalModel using feasibility pump')
results = opt.solve(model,
strategy='FP',
mip_solver=required_solvers[1],
nlp_solver=required_solvers[0],
iteration_limit=30)
self.assertTrue(is_feasible(model, self.get_config(opt)))
def test_ECP_Proposal(self):
"""Test the extended cutting plane decomposition algorithm."""
with SolverFactory('mindtpy') as opt:
model = ProposalModel()
print('\n Solving Proposal problem with extended cutting plane')
results = opt.solve(model, strategy='ECP',
mip_solver=required_solvers[1],
nlp_solver=required_solvers[0])
self.assertIs(results.solver.termination_condition,
TerminationCondition.optimal)
self.assertAlmostEqual(value(model.obj.expr), 0.66555, places=2)
def test_maximize_obj(self):
"""Test the outer approximation decomposition algorithm."""
with SolverFactory('mindtpy') as opt:
model = ProposalModel()
model.objective.sense = maximize
opt.solve(model, strategy='OA',
mip_solver=required_solvers[1],
nlp_solver=required_solvers[0],
# mip_solver_args={'timelimit': 0.9}
)
self.assertAlmostEqual(
value(model.objective.expr), 14.83, places=1)
def test_lazy_OA_Proposal(self):
"""Test the LP/NLP decomposition algorithm."""
with SolverFactory('mindtpy') as opt:
model = ProposalModel()
print('\n Solving Proposal problem with LP/NLP')
results = opt.solve(model,
strategy='OA',
mip_solver=required_solvers[1],
nlp_solver=required_solvers[0],
single_tree=True)
self.assertIs(results.solver.termination_condition,
TerminationCondition.optimal)
self.assertAlmostEqual(value(model.obj.expr), 0.66555, places=2)
def test_FP_OA_Proposal(self):
"""Test the FP-OA algorithm."""
with SolverFactory('mindtpy') as opt:
model = ProposalModel()
print('\n Solving ProposalModel using FP-OA')
results = opt.solve(model,
strategy='OA',
init_strategy='FP',
mip_solver=required_solvers[1],
nlp_solver=required_solvers[0],
iteration_limit=30)
self.assertIs(results.solver.termination_condition,
TerminationCondition.optimal)
self.assertAlmostEqual(value(model.obj.expr), 0.66555, places=2)
def test_GOA_Proposal(self):
"""Test the global outer approximation decomposition algorithm."""
with SolverFactory('mindtpy') as opt:
model = ProposalModel()
print('\n Solving Proposal problem with Outer Approximation')
results = opt.solve(model,
strategy='GOA',
mip_solver=required_solvers[1],
nlp_solver=required_solvers[0],
add_no_good_cuts=True,
integer_to_binary=True)
self.assertIs(results.solver.termination_condition,
TerminationCondition.optimal)
self.assertAlmostEqual(value(model.obj.expr), 0.66555, places=2)
def test_OA_Proposal_with_int_cuts(self):
"""Test the outer approximation decomposition algorithm."""
with SolverFactory('mindtpy') as opt:
model = ProposalModel()
print('\n Solving problem with Outer Approximation')
results = opt.solve(
model,
strategy='OA',
mip_solver=required_solvers[1],
nlp_solver=required_solvers[0],
add_integer_cuts=True,
integer_to_binary=
True # if we use lazy callback, we cannot set integer_to_binary True
)
self.assertIs(results.solver.termination_condition,
TerminationCondition.optimal)
self.assertAlmostEqual(value(model.obj.expr), 0.66555, places=2)
def test_GOA_Proposal_with_int_cuts_tabu_list(self):
"""Test the global outer approximation decomposition algorithm."""
with SolverFactory('mindtpy') as opt:
model = ProposalModel()
print(
'\n Solving Proposal problem with Outer Approximation(no-good cuts)'
)
results = opt.solve(
model,
strategy='GOA',
mip_solver=required_solvers[1],
nlp_solver=required_solvers[0],
use_tabu_list=True,
integer_to_binary=
True, # if we use lazy callback, we cannot set integer_to_binary True
single_tree=True)
self.assertIn(
results.solver.termination_condition,
[TerminationCondition.optimal, TerminationCondition.feasible])
self.assertAlmostEqual(value(model.obj.expr), 0.66555, places=2)
def test_OA_quadratic_strategy(self):
"""Test the outer approximation decomposition algorithm."""
with SolverFactory('mindtpy') as opt:
model = ProposalModel()
if SolverFactory('cplex').available():
mip_solver = 'cplex'
elif SolverFactory('gurobi').available():
mip_solver = 'gurobi'
for quadratic_strategy in (0, 1, 2):
results = opt.solve(
model,
strategy='OA',
mip_solver=mip_solver,
nlp_solver=required_solvers[0],
quadratic_strategy=quadratic_strategy,
)
self.assertIn(results.solver.termination_condition, [
TerminationCondition.optimal, TerminationCondition.feasible
])
self.assertAlmostEqual(value(model.objective.expr),
model.optimal_value,
places=1)
from pyomo.environ import SolverFactory, value
from pyomo.opt import TerminationCondition
required_solvers = ('ipopt', 'glpk')
# required_solvers = ('gams', 'gams')
if all(SolverFactory(s).available() for s in required_solvers):
subsolvers_available = True
else:
subsolvers_available = False
model_list = [EightProcessFlowsheet(convex=True),
ConstraintQualificationExample(),
SimpleMINLP(),
SimpleMINLP2(),
SimpleMINLP3(),
ProposalModel(),
]
@unittest.skipIf(not subsolvers_available,
'Required subsolvers %s are not available'
% (required_solvers,))
class TestMindtPy(unittest.TestCase):
"""Tests for the MindtPy solver plugin."""
def test_ECP(self):
"""Test the extended cutting plane decomposition algorithm."""
with SolverFactory('mindtpy') as opt:
for model in model_list:
results = opt.solve(model, strategy='ECP',
init_strategy='rNLP',
