def test_add_constraint_fails(self):
"""Test Model.add_constraint asserts."""
model = lp.Model(['x1', 'x2'])
self.assertRaises(AssertionError, model.add_constraint, [1], lp.EQ, 1)
self.assertRaises(AssertionError, model.add_constraint, [1, 2, 3],
lp.EQ, 1)
self.assertRaises(AssertionError, model.add_constraint, [1, 2], None,
1)
def test_add_cost_function_fails(self):
"""Test Model.add_cost_function asserts."""
model = lp.Model(['x1', 'x2'])
self.assertRaises(AssertionError, model.add_cost_function, None,
[1, 2], 1)
self.assertRaises(AssertionError, model.add_cost_function, lp.MINIMIZE,
[1], 1)
self.assertRaises(AssertionError, model.add_cost_function, lp.MINIMIZE,
[1, 2, 3], 1)
def test__convert_to_standard_form_standard(self):
"""Test Model._convert_to_standard_form when in standard form."""
model = lp.Model(['x1', 'x2', 'x3'])
model.add_constraint([30, 100, 85], lp.EQ, 2500)
model.add_constraint([6, 2, 3], lp.EQ, 90)
model.add_cost_function(lp.MINIMIZE, [3, 2, 4], 0)
model._convert_to_standard_form()
self.assertEqual(model._slack_variables, [])
self.assertEqual(model._standard_constraints, [([30, 100, 85], 2500),
([6, 2, 3], 90)])
self.assertEqual(model._standard_cost_function, ([3, 2, 4], 0))
def test__convert_to_standard_form_gte(self):
"""Test Model._convert_to_standard_form when constraint is GTE."""
model = lp.Model(["x1", "x2", "x3"])
model.add_constraint([30, 100, 85], lp.GTE, 2500)
model.add_constraint([6, 2, 3], lp.EQ, 90)
model.add_cost_function(lp.MINIMIZE, [3, 2, 4], 0)
model._convert_to_standard_form()
self.assertEqual(model._slack_variables, [3])
self.assertEqual(model._standard_constraints,
[([30, 100, 85, -1], 2500), ([6, 2, 3, 0], 90)])
self.assertEqual(model._standard_cost_function, ([3, 2, 4, 0], 0))
def test__convert_to_standard_form_maximize(self):
"""Test Model._convert_to_standard_form when maximizing."""
model = lp.Model(["x1", "x2", "x3"])
model.add_constraint([30, 100, 85], lp.EQ, 2500)
model.add_constraint([6, 2, 3], lp.EQ, 90)
model.add_cost_function(lp.MAXIMIZE, [3, 2, 4], 0)
model._convert_to_standard_form()
self.assertEqual(model._slack_variables, [])
self.assertEqual(model._standard_constraints, [([30, 100, 85], 2500),
([6, 2, 3], 90)])
self.assertEqual(model._standard_cost_function, ([-3, -2, -4], 0))
def test__convert_to_standard_form_lte_gte(self):
"""Test Model._convert_to_standard_form for LTE/GTE constraints."""
model = lp.Model(['x1', 'x2', 'x3'])
model.add_constraint([30, 100, 85], lp.LTE, 2500)
model.add_constraint([6, 2, 3], lp.GTE, 90)
model.add_cost_function(lp.MINIMIZE, [3, 2, 4], 0)
model._convert_to_standard_form()
self.assertEqual(model._slack_variables, [3, 4])
self.assertEqual(model._standard_constraints,
[([30, 100, 85, 1, 0], 2500), ([6, 2, 3, 0, -1], 90)])
self.assertEqual(model._standard_cost_function, ([3, 2, 4, 0, 0], 0))
def test_simplex(self):
"""Test Model.simplex method."""
model = lp.Model(['x1', 'x2', 'x3', 'x4', 'x5'])
model.add_constraint([-6, 0, 1, -2, 2], lp.EQ, 6)
model.add_constraint([-3, 1, 0, 6, 3], lp.EQ, 15)
model.add_cost_function(lp.MINIMIZE, [5, 0, 0, 3, -2], -21)
self.assertEqual(model.simplex(), {
'x1': 1.0,
'x2': 0.0,
'x3': 0.0,
'x4': 0.0,
'x5': 6.0
})
def test__build_tableau_canonical_form(self):
"""Test Model._build_tableau_canonical_form method."""
model = lp.Model(['x1', 'x2', 'x3', 'x4'])
model.add_constraint([1, -2, -3, -2], lp.EQ, 3)
model.add_constraint([1, -1, 2, 1], lp.EQ, 11)
model.add_cost_function(lp.MINIMIZE, [2, -3, 1, 1], 0)
model._convert_to_standard_form()
model._convert_to_canonical_form()
tableau = model._build_tableau_canonical_form()
self.assertEqual(tableau._basic_variables, [4, 5])
self.assertEqual(tableau._tableau,
[[1, -2, -3, -2, 1, 0, 3], [1, -1, 2, 1, 0, 1, 11],
[2, -3, 1, 1, 0, 0, 0], [-2, 3, 1, 1, 0, 0, -14]])
def test_simplex(self):
"""Test Model.simplex method."""
model = lp.Model(["x1", "x2", "x3", "x4", "x5"])
model.add_constraint([-6, 0, 1, -2, 2], lp.EQ, 6)
model.add_constraint([-3, 1, 0, 6, 3], lp.EQ, 15)
model.add_cost_function(lp.MINIMIZE, [5, 0, 0, 3, -2], -21)
self.assertEqual(model.simplex(), {
"x1": 1.0,
"x2": 0.0,
"x3": 0.0,
"x4": 0.0,
"x5": 6.0
})
def test___str__(self):
"""Test Model.__str__ method."""
model = lp.Model(['x1', 'x2', 'x3', 'x4', 'x5'])
model.add_constraint([-6, 0, 1, -2, 2], lp.LTE, 6)
model.add_constraint([-3, 1, 0, 6, 3], lp.EQ, 15)
model.add_cost_function(lp.MINIMIZE, [5, 0, 0, 3, -2], -21)
self.assertEqual(
model.__str__(), """Minimize:
5 x1 + 0 x2 + 0 x3 + 3 x4 - 2 x5 - 21
Subject to:
-6 x1 + 0 x2 + 1 x3 - 2 x4 + 2 x5 <= 6
-3 x1 + 1 x2 + 0 x3 + 6 x4 + 3 x5 = 15
x1, x2, x3, x4, x5 >= 0""")
def test__convert_to_canonical_form_neg_free_term(self):
"""Test Model._convert_to_standard_form when in standard form."""
model = lp.Model(['x1', 'x2', 'x3'])
model.add_constraint([30, 100, 85], lp.EQ, -2500)
model.add_constraint([6, 2, 3], lp.EQ, 90)
model.add_cost_function(lp.MINIMIZE, [3, 2, 4], 0)
model._convert_to_standard_form()
model._convert_to_canonical_form()
self.assertEqual(model._canonical_constraints,
[([-30, -100, -85, 1, 0], 2500),
([6, 2, 3, 0, 1], 90)])
self.assertEqual(model._canonical_cost_function, ([3, 2, 4, 0, 0], 0))
self.assertEqual(model._canonical_artificial_function,
([24, 98, 82, 0, 0], -2590))
def test__convert_to_canonical_form_artificial(self):
"""Test Model._convert_to_canonical_form when not in standard form."""
model = lp.Model(['x1', 'x2', 'x3', 'x4'])
model.add_constraint([1, -2, -3, -2], lp.LTE, 3)
model.add_constraint([1, -1, 2, 1], lp.GTE, 11)
model.add_cost_function(lp.MAXIMIZE, [2, -3, 1, 1], 10)
model._convert_to_standard_form()
model._convert_to_canonical_form()
self.assertEqual(model._canonical_constraints,
[([1, -2, -3, -2, 1, 0, 1, 0], 3),
([1, -1, 2, 1, 0, -1, 0, 1], 11)])
self.assertEqual(model._canonical_cost_function,
([-2, 3, -1, -1, 0, 0, 0, 0], -10))
self.assertEqual(model._canonical_artificial_function,
([-2, 3, 1, 1, -1, 1, 0, 0], -14))
def test__convert_to_canonical_form(self):
"""Test Model._convert_to_canonical_form when in standard form."""
model = lp.Model(["x1", "x2", "x3", "x4"])
model.add_constraint([1, -2, -3, -2], lp.EQ, 3)
model.add_constraint([1, -1, 2, 1], lp.EQ, 11)
model.add_cost_function(lp.MINIMIZE, [2, -3, 1, 1], 0)
model._convert_to_standard_form()
model._convert_to_canonical_form()
self.assertEqual(
model._canonical_constraints,
[([1, -2, -3, -2, 1, 0], 3), ([1, -1, 2, 1, 0, 1], 11)],
)
self.assertEqual(model._canonical_cost_function,
([2, -3, 1, 1, 0, 0], 0))
self.assertEqual(model._canonical_artificial_function,
([-2, 3, 1, 1, 0, 0], -14))
def test_add_cost_function_named(self):
"""Test Model.add_cost_function success."""
model = lp.Model(['x1', 'x2'])
model.add_cost_function_named(lp.MINIMIZE, {'x1': 1, 'x2': 2}, 1)
self.assertEqual((lp.MINIMIZE, [1, 2], 1), model._cost_function)
def test_add_constraint_named(self):
"""Test Model.add_constraint_named success."""
model = lp.Model(['x1', 'x2'])
model.add_constraint_named({'x1': 1, 'x2': 2}, lp.EQ, 1)
self.assertTrue(([1, 2], lp.EQ, 1) in model._constraints)
def test__coeff(self):
"""Test model._coeff method."""
model = lp.Model(['x1', 'x2'])
self.assertEqual(model._coeff({'x1': 1}), [1, 0])
self.assertEqual(model._coeff({'x2': 1}), [0, 1])
self.assertEqual(model._coeff({'x1': 1, 'x2': 2}), [1, 2])
def test__coeff(self):
"""Test model._coeff method."""
model = lp.Model(["x1", "x2"])
self.assertEqual(model._coeff({"x1": 1}), [1, 0])
self.assertEqual(model._coeff({"x2": 1}), [0, 1])
self.assertEqual(model._coeff({"x1": 1, "x2": 2}), [1, 2])
def test_add_cost_function_named(self):
"""Test Model.add_cost_function success."""
model = lp.Model(["x1", "x2"])
model.add_cost_function_named(lp.MINIMIZE, {"x1": 1, "x2": 2}, 1)
self.assertEqual((lp.MINIMIZE, [1, 2], 1), model._cost_function)
def test_add_constraint_named(self):
"""Test Model.add_constraint_named success."""
model = lp.Model(["x1", "x2"])
model.add_constraint_named({"x1": 1, "x2": 2}, lp.EQ, 1)
self.assertTrue(([1, 2], lp.EQ, 1) in model._constraints)
