def test_get_primal(self):
self.assertEqual(self.var.primal, None)
problem = cplex.Cplex()
problem.read(TESTMODELPATH)
model = Model(problem=problem)
model.optimize()
self.assertEqual(model.status, 'optimal')
self.assertAlmostEqual(model.objective.value, 0.8739215069684305)
print([var.primal for var in model.variables])
for i, j in zip([var.primal for var in model.variables],
[0.8739215069684306, -16.023526143167608, 16.023526143167604, -14.71613956874283,
14.71613956874283, 4.959984944574658, 4.959984944574657, 4.959984944574658,
3.1162689467973905e-29, 2.926716099010601e-29, 0.0, 0.0, -6.112235045340358e-30,
-5.6659435396316186e-30, 0.0, -4.922925402711085e-29, 0.0, 9.282532599166613, 0.0,
6.00724957535033, 6.007249575350331, 6.00724957535033, -5.064375661482091,
1.7581774441067828, 0.0, 7.477381962160285, 0.0, 0.22346172933182767, 45.514009774517454,
8.39, 0.0, 6.007249575350331, 0.0, -4.541857463865631, 0.0, 5.064375661482091, 0.0, 0.0,
2.504309470368734, 0.0, 0.0, -22.809833310204958, 22.809833310204958, 7.477381962160285,
7.477381962160285, 1.1814980932459636, 1.496983757261567, -0.0, 0.0, 4.860861146496815,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 5.064375661482091, 0.0, 5.064375661482091, 0.0, 0.0,
1.496983757261567, 10.000000000000002, -10.0, 0.0, 0.0, 0.0, 0.0, 0.0, -29.175827135565804,
43.598985311997524, 29.175827135565804, 0.0, 0.0, 0.0, -1.2332237321082153e-29,
3.2148950476847613, 38.53460965051542, 5.064375661482091, 0.0, -1.2812714099825612e-29,
-1.1331887079263237e-29, 17.530865429786694, 0.0, 0.0, 0.0, 4.765319193197458,
-4.765319193197457, 21.79949265599876, -21.79949265599876, -3.2148950476847613, 0.0,
-2.281503094067127, 2.6784818505075303, 0.0]):
self.assertAlmostEqual(i, j)
class ConstraintTestCase(unittest.TestCase):
def setUp(self):
problem = cplex.Cplex()
problem.read(TESTMODELPATH)
self.model = Model(problem=problem)
self.constraint = Constraint(Variable('chip') + Variable('chap'), name='woodchips', lb=100)
def test_get_primal(self):
self.assertEqual(self.constraint.primal, None)
self.model.optimize()
self.assertEqual(self.model.status, 'optimal')
self.assertEqual(self.model.objective.value, 0.8739215069684305)
print([constraint.primal for constraint in self.model.constraints])
for i, j in zip([constraint.primal for constraint in self.model.constraints], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.048900234729145e-15, 0.0, 0.0, 0.0, -3.55971196577979e-16, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.5546369406238147e-17, 0.0, -5.080374405378186e-29, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]):
self.assertAlmostEqual(i, j)
def test_get_dual(self):
self.assertEqual(self.constraint.dual, None)
self.model.optimize()
self.assertEqual(self.model.status, 'optimal')
self.assertEqual(self.model.objective.value, 0.8739215069684305)
print([constraint.dual for constraint in self.model.constraints])
#for i, j in zip([constraint.dual for constraint in self.model.constraints], [-0.047105494664984454, -0.042013008755256404, -0.042013008755256404, -0.09166474637510487, -0.09039162489767286, -0.02418930807120824, -0.022916186593776228, -0.034374279890664335, -0.034374279890664335, -0.028008672503504275, -0.07129480273619268, -0.029281793980936287, 0.005092485909728047, -0.06238295239416859, -0.06110983091673658, 0.010184971819456094, -0.0, -0.07129480273619268, -0.0, 0.0, -0.0, -0.0521979805747125, -0.06747543830389663, -0.0407398872778244, -0.039466765800392385, -0.09803035376226493, -0.104395961149425, 0.0, 0.0, -0.09166474637510488, -0.04837861614241646, -0.045832373187552435, -0.0521979805747125, -0.09803035376226493, -0.09166474637510488, -0.07511416716848872, -0.07002168125876067, -0.07002168125876067, -0.06874855978132866, -0.019096822161480172, -0.0, 0.0, 0.001273121477432012, 0.0, -0.07129480273619268, -0.042013008755256404, -0.04073988727782439, -0.04837861614241646, -0.045832373187552435, 0.007638728864592072, -0.0, 0.008911850342024089, -0.0, -0.0, 0.0, -0.0, 0.0, -0.042013008755256404, -0.042013008755256404, -0.001273121477432012, 0.0, -0.03564740136809635, -0.034374279890664335, 0.002546242954864024, -0.0, -0.08275289603308078, -0.08275289603308078, -0.11330781149144906, -0.050924859097280485, -0.04837861614241646, -0.054744223529576516, -0.08275289603308078]):
# self.assertAlmostEqual(i, j)
def test_change_constraint_name(self):
constraint = copy.copy(self.constraint)
self.assertEqual(constraint.name, 'woodchips')
constraint.name = 'ketchup'
self.assertEqual(constraint.name, 'ketchup')
self.assertEqual([constraint.name for constraint in self.model.constraints], ['M_13dpg_c', 'M_2pg_c', 'M_3pg_c', 'M_6pgc_c', 'M_6pgl_c', 'M_ac_c', 'M_ac_e', 'M_acald_c', 'M_acald_e', 'M_accoa_c', 'M_acon_C_c', 'M_actp_c', 'M_adp_c', 'M_akg_c', 'M_akg_e', 'M_amp_c', 'M_atp_c', 'M_cit_c', 'M_co2_c', 'M_co2_e', 'M_coa_c', 'M_dhap_c', 'M_e4p_c', 'M_etoh_c', 'M_etoh_e', 'M_f6p_c', 'M_fdp_c', 'M_for_c', 'M_for_e', 'M_fru_e', 'M_fum_c', 'M_fum_e', 'M_g3p_c', 'M_g6p_c', 'M_glc_D_e', 'M_gln_L_c', 'M_gln_L_e', 'M_glu_L_c', 'M_glu_L_e', 'M_glx_c', 'M_h2o_c', 'M_h2o_e', 'M_h_c', 'M_h_e', 'M_icit_c', 'M_lac_D_c', 'M_lac_D_e', 'M_mal_L_c', 'M_mal_L_e', 'M_nad_c', 'M_nadh_c', 'M_nadp_c', 'M_nadph_c', 'M_nh4_c', 'M_nh4_e', 'M_o2_c', 'M_o2_e', 'M_oaa_c', 'M_pep_c', 'M_pi_c', 'M_pi_e', 'M_pyr_c', 'M_pyr_e', 'M_q8_c', 'M_q8h2_c', 'M_r5p_c', 'M_ru5p_D_c', 'M_s7p_c', 'M_succ_c', 'M_succ_e', 'M_succoa_c', 'M_xu5p_D_c'])
for i, constraint in enumerate(self.model.constraints):
constraint.name = 'c'+ str(i)
self.assertEqual([constraint.name for constraint in self.model.constraints], ['c' + str(i) for i in range(0, len(self.model.constraints))])
def test_setting_lower_bound_higher_than_upper_bound_raises(self):
problem = cplex.Cplex()
problem.read(TESTMODELPATH)
model = Model(problem=problem)
print(model.constraints[0].lb)
print(model.constraints[0].ub)
self.assertRaises(ValueError, setattr, model.constraints[0], 'lb', 10000000000.)
def test_setting_nonnumerical_bounds_raises(self):
problem = cplex.Cplex()
problem.read(TESTMODELPATH)
model = Model(problem=problem)
self.assertRaises(Exception, setattr, model.constraints[0], 'lb', 'Chicken soup')
def test_setting_bounds(self):
constraint = self.model.constraints[0]
value = 42
constraint.ub = value
self.assertEqual(constraint.ub, value)
constraint.lb = value
self.assertEqual(constraint.lb, value)
self.assertEqual(self.model.problem.linear_constraints.get_senses(constraint.name), "E")
self.assertEqual(self.model.problem.linear_constraints.get_range_values(constraint.name), 0)
def test_get_dual(self):
self.assertEqual(self.var.dual, None)
problem = cplex.Cplex()
problem.read(TESTMODELPATH)
model = Model(problem=problem)
model.optimize()
self.assertEqual(model.status, 'optimal')
self.assertEqual(model.objective.value, 0.8739215069684305)
print([var.dual for var in model.variables])
def test_setting_bounds(self):
problem = cplex.Cplex()
problem.read(TESTMODELPATH)
model = Model(problem=problem)
var = model.variables[0]
var.lb = 1
self.assertEqual(var.lb, 1)
model.update()
self.assertEqual(model.problem.variables.get_lower_bounds(var.name), 1)
var.ub = 2
self.assertEqual(var.ub, 2)
model.update()
self.assertEqual(model.problem.variables.get_upper_bounds(var.name), 2)
def test_netlib(netlib_tar_path=os.path.join(os.path.dirname(__file__), 'data/netlib_lp_problems.tar.gz')):
"""
Test netlib with glpk interface
"""
tar = tarfile.open(netlib_tar_path)
model_paths_in_tar = glob.fnmatch.filter(tar.getnames(), '*.SIF')
for model_path_in_tar in model_paths_in_tar:
print(model_path_in_tar)
netlib_id = os.path.basename(model_path_in_tar).replace('.SIF', '')
# TODO: get the following problems to work
# E226 seems to be a MPS related problem, see http://lists.gnu.org/archive/html/bug-glpk/2003-01/msg00003.html
if netlib_id in ('AGG', 'E226', 'SCSD6', 'BLEND', 'DFL001', 'FORPLAN', 'GFRD-PNC', 'SIERRA'):
# def test_skip(netlib_id):
# raise SkipTest('Skipping netlib problem %s ...' % netlib_id)
# test_skip(netlib_id)
# class TestWeirdNetlibProblems(unittest.TestCase):
# @unittest.skip('Skipping netlib problem')
# def test_fail():
# pass
continue
# TODO: For now, test only models that are covered by the final netlib results
else:
if netlib_id not in THE_FINAL_NETLIB_RESULTS.keys():
continue
fhandle = tar.extractfile(model_path_in_tar)
problem = read_netlib_sif_cplex(fhandle)
model = Model(problem=problem)
model.configuration.presolve = True
# model.configuration.verbosity = 3
func = partial(check_dimensions, problem, model)
func.description = "test_netlib_check_dimensions_%s (%s)" % (netlib_id, os.path.basename(str(__file__)))
yield func
model.optimize()
if model.status == 'optimal':
model_objval = model.objective.value
else:
raise Exception('No optimal solution found for netlib model %s' % netlib_id)
func = partial(check_objval, problem, model_objval)
func.description = "test_netlib_check_objective_value_%s (%s)" % (
netlib_id, os.path.basename(str(__file__)))
yield func
func = partial(check_objval_against_the_final_netlib_results, netlib_id, model_objval)
func.description = "test_netlib_check_objective_value__against_the_final_netlib_results_%s (%s)" % (
netlib_id, os.path.basename(str(__file__)))
yield func
def test_qp_convex(self):
problem = cplex.Cplex()
problem.read(CONVEX_QP_PATH)
model = Model(problem=problem)
self.assertEqual(len(model.variables), 651)
self.assertEqual(len(model.constraints), 501)
for constraint in model.constraints:
self.assertTrue(constraint.is_Linear, "%s should be linear" % (str(constraint.expression)))
self.assertFalse(constraint.is_Quadratic, "%s should not be quadratic" % (str(constraint.expression)))
self.assertTrue(model.objective.is_Quadratic, "objective should be quadratic")
self.assertFalse(model.objective.is_Linear, "objective should not be linear")
model.optimize()
self.assertAlmostEqual(model.objective.value, 32.2291282)
def test_qp_non_convex(self):
problem = cplex.Cplex()
problem.read(NONCONVEX_QP_PATH)
model = Model(problem=problem)
self.assertEqual(len(model.variables), 31)
self.assertEqual(len(model.constraints), 1)
for constraint in model.constraints:
self.assertTrue(constraint.is_Linear, "%s should be linear" % (str(constraint.expression)))
self.assertFalse(constraint.is_Quadratic, "%s should not be quadratic" % (str(constraint.expression)))
self.assertTrue(model.objective.is_Quadratic, "objective should be quadratic")
self.assertFalse(model.objective.is_Linear, "objective should not be linear")
model.configuration.solution_target = "convex"
self.assertRaises(CplexSolverError, model.optimize)
model.configuration.solution_target = "global"
model.optimize()
self.assertAlmostEqual(model.objective.value, 2441.999999971)
def setUp(self):
problem = cplex.Cplex()
problem.read(TESTMODELPATH)
self.model = Model(problem=problem)
self.constraint = Constraint(Variable('chip') + Variable('chap'), name='woodchips', lb=100)
def setUp(self):
self.model = Model()
self.x1 = Variable("x1", lb=0)
self.x2 = Variable("x2", lb=0)
self.c1 = Constraint(self.x1 + self.x2, lb=1)
self.model.add([self.x1, self.x2, self.c1])
def setUp(self):
problem = cplex.Cplex()
problem.read(TESTMODELPATH)
self.model = Model(problem=problem)
self.obj = self.model.objective
def setUp(self):
problem = cplex.Cplex()
problem.read(TESTMODELPATH)
assert problem.variables.get_num() > 0
self.model = Model(problem=problem)
class SolverTestCase(unittest.TestCase):
def setUp(self):
problem = cplex.Cplex()
problem.read(TESTMODELPATH)
assert problem.variables.get_num() > 0
self.model = Model(problem=problem)
def test_create_empty_model(self):
model = Model()
self.assertEqual(len(model.constraints), 0)
self.assertEqual(len(model.variables), 0)
self.assertEqual(model.objective, None)
def test_copy(self):
self.model.optimize()
value = self.model.objective.value
model_copy = copy.copy(self.model)
self.assertNotEqual(id(self.model), id(model_copy))
self.assertNotEqual(id(self.model.problem), id(model_copy.problem))
model_copy.optimize()
self.assertAlmostEqual(value, model_copy.objective.value)
self.assertEqual([(var.lb, var.ub, var.name, var.type) for var in model_copy.variables.values()],
[(var.lb, var.ub, var.name, var.type) for var in self.model.variables.values()])
self.assertEqual([(constr.lb, constr.ub, constr.name) for constr in model_copy.constraints],
[(constr.lb, constr.ub, constr.name) for constr in self.model.constraints])
def test_deepcopy(self):
self.model.optimize()
value = self.model.objective.value
model_copy = copy.deepcopy(self.model)
self.assertNotEqual(id(self.model), id(model_copy))
self.assertNotEqual(id(self.model.problem), id(model_copy.problem))
model_copy.optimize()
self.assertAlmostEqual(value, model_copy.objective.value)
self.assertEqual([(var.lb, var.ub, var.name, var.type) for var in model_copy.variables.values()],
[(var.lb, var.ub, var.name, var.type) for var in self.model.variables.values()])
self.assertEqual([(constr.lb, constr.ub, constr.name) for constr in model_copy.constraints],
[(constr.lb, constr.ub, constr.name) for constr in self.model.constraints])
def test_pickle_ability(self):
self.model.optimize()
value = self.model.objective.value
pickle_string = pickle.dumps(self.model)
from_pickle = pickle.loads(pickle_string)
from_pickle.optimize()
self.assertAlmostEqual(value, from_pickle.objective.value)
self.assertEqual([(var.lb, var.ub, var.name, var.type) for var in from_pickle.variables.values()],
[(var.lb, var.ub, var.name, var.type) for var in self.model.variables.values()])
self.assertEqual([(constr.lb, constr.ub, constr.name) for constr in from_pickle.constraints],
[(constr.lb, constr.ub, constr.name) for constr in self.model.constraints])
def test_config_gets_copied_too(self):
self.assertEquals(self.model.configuration.verbosity, 0)
self.model.configuration.verbosity = 3
model_copy = copy.copy(self.model)
self.assertEquals(model_copy.configuration.verbosity, 3)
def test_pickle_empty_model(self):
model = Model()
self.assertEquals(model.objective, None)
self.assertEquals(len(model.variables), 0)
self.assertEquals(len(model.constraints), 0)
pickle_string = pickle.dumps(model)
from_pickle = pickle.loads(pickle_string)
self.assertEquals(from_pickle.objective, None)
self.assertEquals(len(from_pickle.variables), 0)
self.assertEquals(len(from_pickle.constraints), 0)
def test_init_from_existing_problem(self):
inner_prob = self.model.problem
self.assertEqual(len(self.model.variables), inner_prob.variables.get_num())
self.assertEqual(len(self.model.constraints),
inner_prob.linear_constraints.get_num() + inner_prob.quadratic_constraints.get_num())
self.assertEqual(self.model.variables.keys(), inner_prob.variables.get_names())
self.assertEqual(self.model.constraints.keys(), inner_prob.linear_constraints.get_names())
def test_add_variable(self):
var = Variable('x')
self.assertEqual(var.problem, None)
self.model.add(var)
self.assertTrue(var in self.model.variables.values())
self.assertEqual(self.model.variables['x'].problem, var.problem)
self.assertEqual(self.model.variables['x'].problem, self.model)
var = Variable('y', lb=-13)
self.model.add(var)
self.assertTrue(var in self.model.variables.values())
self.assertEqual(self.model.variables['x'].lb, None)
self.assertEqual(self.model.variables['x'].ub, None)
self.assertEqual(self.model.variables['y'].lb, -13)
self.assertEqual(self.model.variables['x'].ub, None)
def test_add_integer_var(self):
var = Variable('int_var', lb=-13, ub=499., type='integer')
self.model.add(var)
self.assertEqual(self.model.variables['int_var'].type, 'integer')
self.assertEqual(self.model.variables['int_var'].ub, 499.)
self.assertEqual(self.model.variables['int_var'].lb, -13)
def test_add_non_cplex_conform_variable(self):
var = Variable('12x!!@#5_3', lb=-666, ub=666)
self.model.add(var)
self.assertTrue(var in self.model.variables.values())
self.assertEqual(var.name, self.model.problem.variables.get_names(len(self.model.variables) - 1))
self.assertEqual(self.model.variables['12x!!@#5_3'].lb, -666)
self.assertEqual(self.model.variables['12x!!@#5_3'].ub, 666)
repickled = pickle.loads(pickle.dumps(self.model))
print(repickled.variables)
var_from_pickle = repickled.variables['12x!!@#5_3']
# self.assertEqual(var_from_pickle.name, glp_get_col_name(repickled.problem, var_from_pickle.index))
def test_remove_variable(self):
var = self.model.variables.values()[0]
self.assertEqual(var.problem, self.model)
self.model.remove(var)
self.assertNotIn(var, self.model.variables.values())
self.assertEqual(var.problem, None)
def test_add_linear_constraints(self):
x = Variable('x', type='binary')
y = Variable('y', lb=-181133.3, ub=12000., type='continuous')
z = Variable('z', lb=0., ub=3, type='integer')
constr1 = Constraint(0.3 * x + 0.4 * y + 66. * z, lb=-100, ub=0., name='test')
constr2 = Constraint(2.333 * x + y + 3.333, ub=100.33, name='test2')
constr3 = Constraint(2.333 * x + y + z, ub=100.33, lb=-300)
constr4 = Constraint(77*x, lb=10, name='Mul_constraint')
constr5 = Constraint(x, ub=-10, name='Only_var_constraint')
constr6 = Constraint(3, ub=88., name='Number_constraint')
self.model.add(constr1)
self.model.update()
self.model.add(constr2)
self.model.update()
self.model.add(constr3)
self.model.update()
self.model.add([constr4, constr5, constr6])
self.model.update()
self.assertIn(constr1.name, self.model.constraints)
self.assertIn(constr2.name, self.model.constraints)
self.assertIn(constr3.name, self.model.constraints)
self.assertIn(constr4.name, self.model.constraints)
self.assertIn(constr5.name, self.model.constraints)
self.assertIn(constr6.name, self.model.constraints)
self.assertEqual(self.model.problem.linear_constraints.get_coefficients((('test', 'y'), ('test', 'z'), ('test', 'x'))), [0.4, 66, 0.3])
self.assertEqual(self.model.problem.linear_constraints.get_coefficients((('test2', 'y'), ('test2', 'x'))), [1., 2.333])
self.assertEqual(self.model.problem.linear_constraints.get_coefficients('Mul_constraint', 'x'), 77.)
self.assertEqual(self.model.problem.linear_constraints.get_coefficients('Only_var_constraint', 'x'), 1.)
@unittest.skip
def test_add_quadratic_constraints(self):
x = Variable('x', lb=-83.3, ub=1324422., type='binary')
y = Variable('y', lb=-181133.3, ub=12000., type='continuous')
z = Variable('z', lb=0.000003, ub=0.000003, type='integer')
constr1 = Constraint(0.3 * x * y + 0.4 * y**2 + 66. * z, lb=-100, ub=0., name='test')
constr2 = Constraint(2.333 * x * x + y + 3.333, ub=100.33, name='test2')
constr3 = Constraint(2.333 * x + y**2 + z + 33, ub=100.33, lb=-300)
self.model.add(constr1)
self.model.add(constr2)
self.model.add(constr3)
self.assertIn(constr1, self.model.constraints)
self.assertIn(constr2, self.model.constraints)
self.assertIn(constr3, self.model.constraints)
cplex_lines = [line.strip() for line in str(self.model).split('\n')]
self.assertIn('test: 0.4 y + 66 z + 0.3 x - Rgtest = -100', cplex_lines)
self.assertIn('test2: y + 2.333 x <= 96.997', cplex_lines)
# Dummy_21: y + z + 2.333 x - RgDummy_21 = -300
self.assertRegexpMatches(str(self.model), '\s*Dummy_\d+:\s*y \+ z \+ 2\.333 x - .* = -300')
print(self.model)
def test_remove_constraints(self):
x = Variable('x', type='binary')
y = Variable('y', lb=-181133.3, ub=12000., type='continuous')
z = Variable('z', lb=4, ub=4, type='integer')
constr1 = Constraint(0.3 * x + 0.4 * y + 66. * z, lb=-100, ub=0., name='test')
self.assertEqual(constr1.problem, None)
self.model.add(constr1)
self.model.update()
self.assertEqual(constr1.problem, self.model)
self.assertIn(constr1, self.model.constraints)
self.model.remove(constr1.name)
self.model.update()
self.assertEqual(constr1.problem, None)
self.assertNotIn(constr1, self.model.constraints)
def test_add_nonlinear_constraint_raises(self):
x = Variable('x', type='binary')
y = Variable('y', lb=-181133.3, ub=12000., type='continuous')
z = Variable('z', lb=3, ub=3, type='integer')
constraint = Constraint(0.3 * x + 0.4 * y ** x + 66. * z, lb=-100, ub=0., name='test')
self.model.add(constraint)
self.assertRaises(ValueError, self.model.update)
def test_change_of_constraint_is_reflected_in_low_level_solver(self):
x = Variable('x', lb=-83.3, ub=1324422.)
y = Variable('y', lb=-181133.3, ub=12000.)
constraint = Constraint(0.3 * x + 0.4 * y, lb=-100, name='test')
self.model.add(constraint)
self.assertEqual(self.model.constraints['test'].__str__(), 'test: -100 <= 0.4*y + 0.3*x')
self.assertEqual(self.model.problem.linear_constraints.get_coefficients([('test', 'x'), ('test', 'y')]), [0.3, 0.4])
z = Variable('z', lb=3, ub=4, type='integer')
constraint += 77. * z
self.assertEqual(self.model.problem.linear_constraints.get_coefficients([('test', 'x'), ('test', 'y'), ('test', 'z')]), [0.3, 0.4, 77.])
self.assertEqual(self.model.constraints['test'].__str__(), 'test: -100 <= 0.4*y + 0.3*x + 77.0*z')
print(self.model)
def test_constraint_set_problem_to_None_caches_the_latest_expression_from_solver_instance(self):
x = Variable('x', lb=-83.3, ub=1324422.)
y = Variable('y', lb=-181133.3, ub=12000.)
constraint = Constraint(0.3 * x + 0.4 * y, lb=-100, name='test')
self.model.add(constraint)
z = Variable('z', lb=2, ub=5, type='integer')
constraint += 77. * z
self.model.remove(constraint)
self.assertEqual(constraint.__str__(), 'test: -100 <= 0.4*y + 0.3*x + 77.0*z')
def test_change_of_objective_is_reflected_in_low_level_solver(self):
x = Variable('x', lb=-83.3, ub=1324422.)
y = Variable('y', lb=-181133.3, ub=12000.)
objective = Objective(0.3 * x + 0.4 * y, name='obj', direction='max')
self.model.objective = objective
for variable in self.model.variables:
coeff = self.model.problem.objective.get_linear(variable.name)
if variable.name == 'x':
self.assertEqual(coeff, 0.3)
elif variable.name == 'y':
self.assertEqual(coeff, 0.4)
else:
self.assertEqual(coeff, 0.)
z = Variable('z', lb=0.000003, ub=0.000003, type='continuous')
objective += 77. * z
for variable in self.model.variables:
coeff = self.model.problem.objective.get_linear(variable.name)
if variable.name == 'x':
self.assertEqual(coeff, 0.3)
elif variable.name == 'y':
self.assertEqual(coeff, 0.4)
elif variable.name == 'z':
self.assertEqual(coeff, 77.)
else:
self.assertEqual(coeff, 0.)
def test_timeout(self):
self.model.configuration.timeout = 0
status = self.model.optimize()
self.assertEqual(status, 'time_limit')
def test_set_linear_objective_term(self):
self.model._set_linear_objective_term(self.model.variables.R_TPI, 666.)
self.assertEqual(self.model.problem.objective.get_linear(self.model.variables.R_TPI.name), 666.)
def test__set_coefficients_low_level(self):
constraint = self.model.constraints.M_atp_c
coeff_dict = constraint.expression.as_coefficients_dict()
self.assertEqual(coeff_dict[self.model.variables.R_Biomass_Ecoli_core_w_GAM], -59.8100000000000)
constraint._set_coefficients_low_level({self.model.variables.R_Biomass_Ecoli_core_w_GAM: 666.})
coeff_dict = constraint.expression.as_coefficients_dict()
self.assertEqual(coeff_dict[self.model.variables.R_Biomass_Ecoli_core_w_GAM], 666.)
def test_primal_values(self):
self.model.optimize()
for k, v in self.model.primal_values.items():
self.assertEquals(v, self.model.variables[k].primal)
def test_reduced_costs(self):
self.model.optimize()
for k, v in self.model.reduced_costs.items():
self.assertEquals(v, self.model.variables[k].dual)
def test_dual_values(self):
self.model.optimize()
for k, v in self.model.dual_values.items():
self.assertEquals(v, self.model.constraints[k].primal)
def test_shadow_prices(self):
self.model.optimize()
for k, v in self.model.shadow_prices.items():
self.assertEquals(v, self.model.constraints[k].dual)
def setUp(self):
self.model = Model()
self.x1 = Variable("x1", lb=0)
self.x2 = Variable("x2", lb=0)
self.c1 = Constraint(self.x1 + self.x2, lb=1)
self.model.add([self.x1, self.x2, self.c1])
class QuadraticProgrammingTestCase(abstract_test_cases.AbstractQuadraticProgrammingTestCase):
def setUp(self):
self.model = Model()
self.x1 = Variable("x1", lb=0)
self.x2 = Variable("x2", lb=0)
self.c1 = Constraint(self.x1 + self.x2, lb=1)
self.model.add([self.x1, self.x2, self.c1])
def test_convex_obj(self):
model = self.model
obj = Objective(self.x1 ** 2 + self.x2 ** 2, direction="min")
model.objective = obj
model.optimize()
self.assertAlmostEqual(model.objective.value, 0.5)
self.assertAlmostEqual(self.x1.primal, 0.5)
self.assertAlmostEqual(self.x2.primal, 0.5)
obj_2 = Objective(self.x1, direction="min")
model.objective = obj_2
model.optimize()
self.assertAlmostEqual(model.objective.value, 0.0)
self.assertAlmostEqual(self.x1.primal, 0.0)
self.assertGreaterEqual(self.x2.primal, 1.0)
def test_non_convex_obj(self):
model = self.model
obj = Objective(self.x1 * self.x2, direction="min")
model.objective = obj
model.configuration.solution_target = "convex"
self.assertRaises(SolverError, model.optimize)
model.configuration.solution_target = "local"
model.configuration.qp_method = "barrier"
model.optimize()
self.assertAlmostEqual(model.objective.value, 0)
model.configuration.solution_target = "global"
model.optimize()
self.assertAlmostEqual(model.objective.value, 0)
obj_2 = Objective(self.x1, direction="min")
model.objective = obj_2
model.optimize()
self.assertAlmostEqual(model.objective.value, 0.0)
self.assertAlmostEqual(self.x1.primal, 0.0)
self.assertGreaterEqual(self.x2.primal, 1.0)
@unittest.skip("")
def test_qp_convex(self):
problem = cplex.Cplex()
problem.read(CONVEX_QP_PATH)
model = Model(problem=problem)
self.assertEqual(len(model.variables), 651)
self.assertEqual(len(model.constraints), 501)
for constraint in model.constraints:
self.assertTrue(constraint.is_Linear, "%s should be linear" % (str(constraint.expression)))
self.assertFalse(constraint.is_Quadratic, "%s should not be quadratic" % (str(constraint.expression)))
self.assertTrue(model.objective.is_Quadratic, "objective should be quadratic")
self.assertFalse(model.objective.is_Linear, "objective should not be linear")
model.optimize()
self.assertAlmostEqual(model.objective.value, 32.2291282)
@unittest.skip("Solving this is slow")
def test_qp_non_convex(self):
problem = cplex.Cplex()
problem.read(NONCONVEX_QP_PATH)
model = Model(problem=problem)
self.assertEqual(len(model.variables), 31)
self.assertEqual(len(model.constraints), 1)
for constraint in model.constraints:
self.assertTrue(constraint.is_Linear, "%s should be linear" % (str(constraint.expression)))
self.assertFalse(constraint.is_Quadratic, "%s should not be quadratic" % (str(constraint.expression)))
self.assertTrue(model.objective.is_Quadratic, "objective should be quadratic")
self.assertFalse(model.objective.is_Linear, "objective should not be linear")
model.configuration.solution_target = "convex"
self.assertRaises(CplexSolverError, model.optimize)
model.configuration.solution_target = "global"
model.optimize()
self.assertAlmostEqual(model.objective.value, 2441.999999971)
def test_quadratic_objective_expression(self):
objective = Objective(self.x1 ** 2 + self.x2 ** 2, direction="min")
self.model.objective = objective
self.assertEqual((self.model.objective.expression - (self.x1 ** 2 + self.x2 ** 2)).simplify(), 0)
def setUp(self):
self.model = Model()
self.configuration = self.model.configuration
def test_netlib(netlib_tar_path=os.path.join(
os.path.dirname(__file__), 'data/netlib_lp_problems.tar.gz')):
"""
Test netlib with glpk interface
"""
tar = tarfile.open(netlib_tar_path)
model_paths_in_tar = glob.fnmatch.filter(tar.getnames(), '*.SIF')
for model_path_in_tar in model_paths_in_tar:
print(model_path_in_tar)
netlib_id = os.path.basename(model_path_in_tar).replace(
'.SIF', '')
# TODO: get the following problems to work
# E226 seems to be a MPS related problem, see http://lists.gnu.org/archive/html/bug-glpk/2003-01/msg00003.html
if netlib_id in ('AGG', 'E226', 'SCSD6', 'BLEND', 'DFL001',
'FORPLAN', 'GFRD-PNC', 'SIERRA'):
# def test_skip(netlib_id):
# raise SkipTest('Skipping netlib problem %s ...' % netlib_id)
# test_skip(netlib_id)
# class TestWeirdNetlibProblems(unittest.TestCase):
# @unittest.skip('Skipping netlib problem')
# def test_fail():
# pass
continue
# TODO: For now, test only models that are covered by the final netlib results
else:
if netlib_id not in THE_FINAL_NETLIB_RESULTS.keys():
continue
fhandle = tar.extractfile(model_path_in_tar)
problem = read_netlib_sif_cplex(fhandle)
model = Model(problem=problem)
model.configuration.presolve = True
model.configuration.verbosity = 3
func = partial(check_dimensions, problem, model)
func.description = "test_netlib_check_dimensions_%s (%s)" % (
netlib_id, os.path.basename(str(__file__)))
yield func
model.optimize()
if model.status == 'optimal':
model_objval = model.objective.value
else:
raise Exception(
'No optimal solution found for netlib model %s' %
netlib_id)
func = partial(check_objval, problem, model_objval)
func.description = "test_netlib_check_objective_value_%s (%s)" % (
netlib_id, os.path.basename(str(__file__)))
yield func
func = partial(
check_objval_against_the_final_netlib_results,
netlib_id, model_objval)
func.description = "test_netlib_check_objective_value__against_the_final_netlib_results_%s (%s)" % (
netlib_id, os.path.basename(str(__file__)))
yield func
if not os.getenv('TRAVIS', False):
# check that a cloned model also gives the correct result
model = Model.clone(model,
use_json=False,
use_lp=False)
model.optimize()
if model.status == 'optimal':
model_objval = model.objective.value
else:
raise Exception(
'No optimal solution found for netlib model %s'
% netlib_id)
func = partial(
check_objval_against_the_final_netlib_results,
netlib_id, model_objval)
func.description = "test_netlib_check_objective_value__against_the_final_netlib_results_after_cloning_%s (%s)" % (
netlib_id, os.path.basename(str(__file__)))
yield func
class QuadraticProgrammingTestCase(unittest.TestCase):
def setUp(self):
self.model = Model()
self.x1 = Variable("x1", lb=0)
self.x2 = Variable("x2", lb=0)
self.c1 = Constraint(self.x1 + self.x2, lb=1)
self.model.add([self.x1, self.x2, self.c1])
def test_convex_obj(self):
model = self.model
obj = Objective(self.x1**2 + self.x2**2, direction="min")
model.objective = obj
model.optimize()
self.assertAlmostEqual(model.objective.value, 0.5)
self.assertAlmostEqual(self.x1.primal, 0.5)
self.assertAlmostEqual(self.x2.primal, 0.5)
obj_2 = Objective(self.x1, direction="min")
model.objective = obj_2
model.optimize()
self.assertAlmostEqual(model.objective.value, 0.0)
self.assertAlmostEqual(self.x1.primal, 0.0)
self.assertGreaterEqual(self.x2.primal, 1.0)
def test_non_convex_obj(self):
model = self.model
obj = Objective(self.x1 * self.x2, direction="min")
model.objective = obj
model.configuration.solution_target = "convex"
self.assertRaises(CplexSolverError, model.optimize)
model.configuration.solution_target = "local"
model.configuration.qp_method = "barrier"
model.optimize()
self.assertAlmostEqual(model.objective.value, 0)
model.configuration.solution_target = "global"
model.optimize()
self.assertAlmostEqual(model.objective.value, 0)
obj_2 = Objective(self.x1, direction="min")
model.objective = obj_2
model.optimize()
self.assertAlmostEqual(model.objective.value, 0.0)
self.assertAlmostEqual(self.x1.primal, 0.0)
self.assertGreaterEqual(self.x2.primal, 1.0)
def test_qp_convex(self):
problem = cplex.Cplex()
problem.read(CONVEX_QP_PATH)
model = Model(problem=problem)
self.assertEqual(len(model.variables), 651)
self.assertEqual(len(model.constraints), 501)
for constraint in model.constraints:
self.assertTrue(constraint.is_Linear, "%s should be linear" % (str(constraint.expression)))
self.assertFalse(constraint.is_Quadratic, "%s should not be quadratic" % (str(constraint.expression)))
self.assertTrue(model.objective.is_Quadratic, "objective should be quadratic")
self.assertFalse(model.objective.is_Linear, "objective should not be linear")
model.optimize()
self.assertAlmostEqual(model.objective.value, 32.2291282)
@unittest.skip("Solving this is slow")
def test_qp_non_convex(self):
problem = cplex.Cplex()
problem.read(NONCONVEX_QP_PATH)
model = Model(problem=problem)
self.assertEqual(len(model.variables), 31)
self.assertEqual(len(model.constraints), 1)
for constraint in model.constraints:
self.assertTrue(constraint.is_Linear, "%s should be linear" % (str(constraint.expression)))
self.assertFalse(constraint.is_Quadratic, "%s should not be quadratic" % (str(constraint.expression)))
self.assertTrue(model.objective.is_Quadratic, "objective should be quadratic")
self.assertFalse(model.objective.is_Linear, "objective should not be linear")
model.configuration.solution_target = "convex"
self.assertRaises(CplexSolverError, model.optimize)
model.configuration.solution_target = "global"
model.optimize()
self.assertAlmostEqual(model.objective.value, 2441.999999971)
def test_changing_variable_names_is_reflected_in_the_solver(self):
model = Model(problem=cplex.Cplex(TESTMODELPATH))
for i, variable in enumerate(model.variables):
variable.name = "var" + str(i)
self.assertEqual(variable.name, "var" + str(i))
self.assertEqual(model.problem.variables.get_names(i), "var" + str(i))