def test_solve_LP_clp_cmd_duals_ub(self): x = optmod.VariableScalar('x') y = optmod.VariableScalar('y') c1 = 100 <= x c2 = x <= 200 c3 = 80 <= y c4 = y <= 170 c5 = y >= -x + 200 # Problem p = optmod.Problem(objective=minimize(2 * x - 5 * y), constraints=[c1, c2, c3, c4, c5]) try: info = p.solve(solver=optalg.opt_solver.OptSolverClpCMD(), parameters={'quiet': True}) except ImportError: raise unittest.SkipTest('clp cmd not available') self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 100, places=4) self.assertAlmostEqual(y.get_value(), 170, places=4) self.assertEqual(c2.get_dual(), 0.) self.assertEqual(c3.get_dual(), 0.) self.assertEqual(c5.get_dual(), 0.) self.assertEqual(2. - c1.get_dual(), 0.) self.assertEqual(-5. + c4.get_dual(), 0.)
def test_scalar_get_fast_evaluator(self): x = optmod.VariableScalar(name='x', value=2.) y = optmod.VariableScalar(name='y', value=3.) f = 3 * (x + 3) + optmod.sin(y + 4 * x) e = f.get_fast_evaluator([x, y]) self.assertTrue(isinstance(e, optmod.coptmod.Evaluator)) self.assertEqual(e.get_value(), 0.) e.eval([4., -3.]) self.assertTrue(np.isscalar(e.get_value())) self.assertEqual(e.get_value(), 3. * (4 + 3.) + np.sin(-3. + 4 * 4.)) x = np.array([2., 3.]) t0 = time.time() for i in range(50000): f.get_value() t1 = time.time() for i in range(50000): e.eval(x) t2 = time.time() self.assertGreater((t1 - t0) / (t2 - t1), 15.)
def test_solve_LP(self): x = optmod.VariableScalar('x') y = optmod.VariableScalar('y') # Problem p = optmod.Problem( objective=maximize(-2 * x + 5 * y), constraints=[100 <= x, x <= 200, 80 <= y, y <= 170, y >= -x + 200]) # std prob std_prob = p.__get_std_problem__() self.assertListEqual(std_prob.properties, ['linear', 'continuous', 'optimization']) info = p.solve(parameters={'quiet': True}) self.assertTrue('iterations' in info) self.assertTrue('time_transformation' in info) self.assertTrue('time_solver' in info) self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 100, places=4) self.assertAlmostEqual(y.get_value(), 170, places=4) info = p.solve(solver=optalg.opt_solver.OptSolverAugL(), parameters={'quiet': True}) self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 100, places=4) self.assertAlmostEqual(y.get_value(), 170, places=4)
def test_solve_MILP_cbc(self): x1 = optmod.VariableScalar('x1', type='integer') x2 = optmod.VariableScalar('x2', type='integer') x3 = optmod.VariableScalar('x3') x4 = optmod.VariableScalar('x4') obj = -x1 - x2 constr = [ -2 * x1 + 2 * x2 + x3 == 1, -8 * x1 + 10 * x2 + x4 == 13, x4 >= 0, x3 <= 0 ] p = optmod.Problem(minimize(obj), constr) # std prob std_prob = p.__get_std_problem__() self.assertListEqual(std_prob.properties, ['linear', 'integer', 'optimization']) try: self.assertRaises(TypeError, p.solve, optalg.opt_solver.OptSolverIpopt(), {'quiet': True}) except ImportError: raise unittest.SkipTest('ipopt not available') self.assertRaises(TypeError, p.solve, optalg.opt_solver.OptSolverAugL(), {'quiet': True}) try: self.assertRaises(TypeError, p.solve, optalg.opt_solver.OptSolverClp(), {'quiet': True}) except ImportError: raise unittest.SkipTest('clp not available') self.assertRaises(TypeError, p.solve, optalg.opt_solver.OptSolverINLP(), {'quiet': True}) try: info = p.solve(optalg.opt_solver.OptSolverCbc(), parameters={'quiet': True}) except ImportError: raise unittest.SkipTest('cbc not available') self.assertEqual(info['status'], 'solved') self.assertEqual(x1.get_value(), 1.) self.assertEqual(x2.get_value(), 2.) x1.type = 'continuous' x2.type = 'continuous' try: info = p.solve(optalg.opt_solver.OptSolverCbc(), parameters={'quiet': True}) except ImportError: raise unittest.SkipTest('cbc not available') self.assertEqual(info['status'], 'solved') self.assertEqual(x1.get_value(), 4.) self.assertEqual(x2.get_value(), 4.5)
def test_solve_NLP_constrained(self): # Hock-Schittkowski # Problem 71 x1 = optmod.VariableScalar('x1', value=1) x2 = optmod.VariableScalar('x2', value=5) x3 = optmod.VariableScalar('x3', value=5) x4 = optmod.VariableScalar('x4', value=1) f = x1 * x4 * (x1 + x2 + x3) + x3 constraints = [ x1 * x2 * x3 * x4 >= 25, x1 * x1 + x2 * x2 + x3 * x3 + x4 * x4 == 40, 1 <= x1, x1 <= 5, 1 <= x2, x2 <= 5, 1 <= x3, x3 <= 5, 1 <= x4, x4 <= 5 ] p = optmod.Problem(minimize(f), constraints=constraints) # std prob std_prob = p.__get_std_problem__() self.assertListEqual(std_prob.properties, ['nonlinear', 'continuous', 'optimization']) try: info = p.solve(solver=optalg.opt_solver.OptSolverIpopt(), parameters={'quiet': True}, fast_evaluator=True) except ImportError: raise unittest.SkipTest('ipopt not available') self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(f.get_value(), 17.0140173, places=3) self.assertAlmostEqual(x1.get_value(), 1., places=3) self.assertAlmostEqual(x2.get_value(), 4.7429994, places=3) self.assertAlmostEqual(x3.get_value(), 3.8211503, places=3) self.assertAlmostEqual(x4.get_value(), 1.3794082, places=3) x1.set_value(1.) x2.set_value(5.) x3.set_value(5.) x4.set_value(1.) info = p.solve(solver=optalg.opt_solver.OptSolverIpopt(), parameters={'quiet': True}, fast_evaluator=False) self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(f.get_value(), 17.0140173, places=3) self.assertAlmostEqual(x1.get_value(), 1., places=3) self.assertAlmostEqual(x2.get_value(), 4.7429994, places=3) self.assertAlmostEqual(x3.get_value(), 3.8211503, places=3) self.assertAlmostEqual(x4.get_value(), 1.3794082, places=3)
def test_get_derivatives(self): x = optmod.VariableScalar(name='x', value=5.) y = optmod.VariableScalar(name='y', value=3.) z = optmod.VariableScalar(name='z', value=10.) f = 2 * x + optmod.cos(x * y) d = f.get_derivatives([x, y, z]) self.assertEqual(d[x].get_value(), 2 - np.sin(5 * 3.) * 3) self.assertEqual(d[y].get_value(), -np.sin(5 * 3.) * 5) self.assertEqual(d[z].get_value(), 0.)
def test_solve_QP(self): x = optmod.VariableScalar('x') y = optmod.VariableScalar('y') f = 3 * x * x + y * y + 2 * x * y + x + 6 * y + 2 # Problem p = optmod.Problem(objective=minimize(f)) # std prob std_prob = p.__get_std_problem__() self.assertListEqual(std_prob.properties, ['nonlinear', 'continuous', 'optimization']) info = p.solve(solver=optalg.opt_solver.OptSolverINLP(), parameters={'quiet': True}) self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 1.25, places=4) self.assertAlmostEqual(y.get_value(), -4.25, places=4) info = p.solve(solver=optalg.opt_solver.OptSolverAugL(), parameters={'quiet': True}) self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 1.25, places=4) self.assertAlmostEqual(y.get_value(), -4.25, places=4) # Problem p = optmod.Problem(objective=minimize(f), constraints=[2 * x + 3 * y >= 4, x >= 0, y >= 0]) info = p.solve(solver=optalg.opt_solver.OptSolverINLP(), parameters={'quiet': True}) self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 0.5, places=4) self.assertAlmostEqual(y.get_value(), 1, places=4) self.assertAlmostEqual(f.get_value(), 11.25, places=4) info = p.solve(solver=optalg.opt_solver.OptSolverAugL(), parameters={'quiet': True}) self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 0.5, places=4) self.assertAlmostEqual(y.get_value(), 1, places=4) self.assertAlmostEqual(f.get_value(), 11.25, places=4)
def test_solve_LP_clp_cmd_duals_A_ineq(self): x = optmod.VariableScalar('x') c = 3 * x >= 4 # -3x <= -4 p = optmod.Problem(objective=minimize(5 * x), constraints=[c]) try: info = p.solve(solver=optalg.opt_solver.OptSolverClpCMD(), parameters={'quiet': True}) except ImportError: raise unittest.SkipTest('clp cmd not available') self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 4. / 3., places=4) self.assertLess(np.abs(5. - 3 * c.get_dual()), 1e-7) c = 3 * x <= 4 p = optmod.Problem(objective=minimize(-5 * x), constraints=[c]) try: info = p.solve(solver=optalg.opt_solver.OptSolverClpCMD(), parameters={'quiet': True}) except ImportError: raise unittest.SkipTest('clp cmd not available') self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 4. / 3., places=4) self.assertLess(np.abs(-5. + 3 * c.get_dual()), 1e-7)
def test_solve_ipopt_duals_J(self): x = optmod.VariableScalar('x') c1 = optmod.cos(x) == 0.75 c2 = x >= -np.pi c3 = x <= np.pi p = optmod.Problem(objective=minimize(5 * x), constraints=[c1, c2, c3]) try: info = p.solve(solver=optalg.opt_solver.OptSolverIpopt(), parameters={'quiet': True}) except ImportError: raise unittest.SkipTest('ipopt not available') self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), -np.abs(np.arccos(0.75)), places=5) self.assertAlmostEqual(np.cos(x.get_value()), 0.75, places=5) self.assertGreater(x.get_value(), -np.pi) self.assertLess(x.get_value(), np.pi) self.assertEqual(c2.get_dual(), 0.) self.assertEqual(c3.get_dual(), 0.) self.assertLess(np.abs(5. - (-np.sin(x.get_value())) * c1.get_dual()), 1e-7)
def test_solve_LP_clp_cmd(self): x = optmod.VariableScalar('x') y = optmod.VariableScalar('y') # Problem p = optmod.Problem( objective=maximize(-2 * x + 5 * y), constraints=[100 <= x, x <= 200, 80 <= y, y <= 170, y >= -x + 200]) try: info = p.solve(solver=optalg.opt_solver.OptSolverClpCMD(), parameters={'quiet': True}) except ImportError: raise unittest.SkipTest('clp cmd not available') self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 100, places=4) self.assertAlmostEqual(y.get_value(), 170, places=4)
def test_evaluator_construct(self): x = optmod.VariableScalar(name='x', value=3.) y = optmod.VariableScalar(name='y', value=4.) f = 4 * (x + 1) + optmod.sin(-y) E = optmod.coptmod.Evaluator(2, 20) self.assertEqual(E.max_nodes, 20) self.assertEqual(E.num_nodes, 0) self.assertEqual(E.num_inputs, 2) self.assertEqual(E.num_outputs, 20) self.assertTupleEqual(E.shape, (1, 20)) self.assertFalse(E.scalar_output) f.__fill_evaluator__(E) self.assertEqual(E.max_nodes, 20) self.assertEqual(E.num_nodes, 8) self.assertEqual(E.num_inputs, 2) self.assertEqual(E.num_outputs, 20) f = 4 * x + y + 10 + 2 * (x + y) E = optmod.coptmod.Evaluator(2, 20) self.assertEqual(E.max_nodes, 20) self.assertEqual(E.num_nodes, 0) self.assertEqual(E.num_inputs, 2) self.assertEqual(E.num_outputs, 20) self.assertTupleEqual(E.shape, (1, 20)) self.assertFalse(E.scalar_output) f.__fill_evaluator__(E) self.assertEqual(E.max_nodes, 20) self.assertEqual(E.num_nodes, 9) self.assertEqual(E.num_inputs, 2) self.assertEqual(E.num_outputs, 20)
def test_get_variables(self): x = optmod.VariableMatrix(name='x', shape=(2, 3)) y = optmod.VariableScalar(name='y') f = optmod.sin(x * 3) + optmod.cos(y + 10.) * x vars = f.get_variables() self.assertEqual(len(vars), 7) self.assertSetEqual( f.get_variables(), set([x[i, j] for i in range(2) for j in range(3)] + [y]))
def test_infeasible_MILP_cplex_cmd(self): x1 = optmod.VariableScalar('x1', type='integer') x2 = optmod.VariableScalar('x2', type='integer') x3 = optmod.VariableScalar('x3') x4 = optmod.VariableScalar('x4') obj = -x1 - x2 constr = [ -2 * x1 + 2 * x2 + x3 == 1, -8 * x1 + 10 * x2 + x4 == 13, x1 >= 2, x1 <= 1, x4 >= 0, x3 <= 0 ] p = optmod.Problem(minimize(obj), constr) try: info = p.solve(optalg.opt_solver.OptSolverCplexCMD(), parameters={'quiet': True}) except ImportError: raise unittest.SkipTest('cplex cmd not available') self.assertEqual(info['status'], 'error')
def test_evaluator_dynamic_resize(self): x = optmod.VariableScalar(name='x', value=3.) y = optmod.VariableScalar(name='y', value=4.) f = 4 * (x + 1) + optmod.sin(-y) E = optmod.coptmod.Evaluator(2, 5) self.assertEqual(E.max_nodes, 5) self.assertEqual(E.num_nodes, 0) self.assertEqual(E.num_inputs, 2) self.assertEqual(E.num_outputs, 5) self.assertTupleEqual(E.shape, (1, 5)) self.assertFalse(E.scalar_output) f.__fill_evaluator__(E) self.assertEqual(E.max_nodes, 10) self.assertEqual(E.num_nodes, 8) self.assertEqual(E.num_inputs, 2) self.assertEqual(E.num_outputs, 5)
def test_evaluator_eval_multi_output(self): x = optmod.VariableScalar(name='x', value=3.) y = optmod.VariableScalar(name='y', value=4.) # var f1 = 3 * (x + optmod.sin(y)) f2 = optmod.sum([x, y]) e = optmod.coptmod.Evaluator(2, 2) f1.__fill_evaluator__(e) f2.__fill_evaluator__(e) e.set_input_var(0, id(x)) e.set_input_var(1, id(y)) e.set_output_node(0, id(f1)) e.set_output_node(1, id(f2)) val = e.get_value() self.assertTupleEqual(val.shape, (1, 2)) self.assertTrue(isinstance(val, np.matrix)) e.eval([5., 8.]) val = e.get_value() self.assertAlmostEqual(val[0, 0], 3. * (5. + np.sin(8.))) self.assertAlmostEqual(val[0, 1], 5. + 8.)
def test_construction(self): x = optmod.variable.VariableScalar() self.assertEqual(x.name, 'var') self.assertEqual(x.get_value(), 0.) self.assertTrue(isinstance(x.id, int)) saved_id = x.id x = optmod.variable.VariableScalar(name='x', value=3) self.assertEqual(x.name, 'x') self.assertEqual(x.get_value(), 3.) self.assertTrue(isinstance(x.get_value(), np.float64)) self.assertTrue(isinstance(x.id, int)) self.assertEqual(x.id, saved_id + 1) x = optmod.VariableScalar() self.assertTrue(isinstance(x, optmod.variable.VariableScalar)) self.assertEqual(x.name, 'var') self.assertEqual(x.get_value(), 0.) self.assertEqual(x.type, 'continuous') x = optmod.VariableScalar(name='x', value=2., type='integer') self.assertTrue(isinstance(x, optmod.variable.VariableScalar)) self.assertEqual(x.name, 'x') self.assertEqual(x.get_value(), 2.) self.assertEqual(x.type, 'integer') self.assertTrue(x.is_integer()) x = optmod.VariableScalar(type='integer') self.assertEqual(x.get_value(), 0.) self.assertEqual(x.name, 'var') self.assertTrue(x.is_integer()) self.assertFalse(x.is_continuous()) self.assertRaises(ValueError, optmod.VariableScalar, 'x', np.random.randn(2, 3))
def test_solve_feasibility(self): x = optmod.VariableScalar('x', value=1.) constr = [x * optmod.cos(x) - x * x == 0] p = optmod.Problem(EmptyObjective(), constr) # std prob std_prob = p.__get_std_problem__() self.assertListEqual(std_prob.properties, ['nonlinear', 'continuous', 'feasibility']) try: self.assertRaises(TypeError, p.solve, optalg.opt_solver.OptSolverClp(), {'quiet': True}) except ImportError: raise unittest.SkipTest('clp not available') try: self.assertRaises(TypeError, p.solve, optalg.opt_solver.OptSolverCbc(), {'quiet': True}) except ImportError: raise unittest.SkipTest('cbc not available') info = p.solve(optalg.opt_solver.OptSolverNR(), parameters={ 'quiet': True, 'feastol': 1e-10 }) self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 0.739085133215161, places=7) x.value = 1. self.assertNotAlmostEqual(x.get_value(), 0.739085133215161, places=7) info = p.solve(optalg.opt_solver.OptSolverNR(), parameters={ 'quiet': True, 'feastol': 1e-10 }, fast_evaluator=False) self.assertEqual(info['status'], 'solved') self.assertAlmostEqual(x.get_value(), 0.739085133215161, places=7)
def test_bad_array_construction(self): x = optmod.VariableMatrix('x', np.random.randn(4, 3)) y = optmod.VariableScalar('y', 5) c0 = x == 1 c1 = y == 0 c = optmod.constraint.ConstraintArray(c0) c = optmod.constraint.ConstraintArray(c1) c = optmod.constraint.ConstraintArray([c1]) self.assertRaises(TypeError, optmod.constraint.ConstraintArray, [x, y]) self.assertRaises(TypeError, optmod.constraint.ConstraintArray, [c0, c1]) self.assertRaises(TypeError, optmod.constraint.ConstraintArray, ['foo'])
def test_matrix_get_fast_evaluator(self): xval = np.random.randn(4, 3) x = optmod.VariableMatrix(name='x', value=xval) y = optmod.VariableScalar(name='y', value=10.) self.assertTupleEqual(x.shape, (4, 3)) f = optmod.sin(3 * x + 10.) * optmod.cos(y - optmod.sum(x * y)) self.assertTupleEqual(f.shape, (4, 3)) variables = list(f.get_variables()) self.assertEqual(len(variables), 13) e = f.get_fast_evaluator(variables) val = e.get_value() self.assertTrue(isinstance(val, np.matrix)) self.assertTupleEqual(val.shape, (4, 3)) self.assertTrue(np.all(val == 0)) e.eval(np.array([x.get_value() for x in variables])) val = e.get_value() val1 = np.sin(3 * xval + 10.) * np.cos(10. - np.sum(xval * 10.)) self.assertTupleEqual(val.shape, (4, 3)) self.assertLess(np.linalg.norm(val - val1), 1e-10) x = np.array([v.get_value() for v in variables]) e.eval(x) self.assertLess(np.max(np.abs(e.get_value() - f.get_value())), 1e-10) t0 = time.time() for i in range(500): f.get_value() t1 = time.time() for i in range(500): e.eval(x) t2 = time.time() self.assertGreater((t1 - t0) / (t2 - t1), 400.)
def test_sum(self): r = np.random.randn(3, 2) x = optmod.VariableScalar('x', value=4.) y = optmod.VariableMatrix('y', value=r) self.assertTupleEqual(y.shape, (3, 2)) self.assertTrue(np.all(y.get_value() == r)) # scalar f = optmod.sum(x) self.assertTrue(f is x) self.assertTrue(optmod.sum(x, axis=0) is x) self.assertRaises(Exception, optmod.sum, x, 1) # matrix f = optmod.sum(y) self.assertTrue(isinstance(f, optmod.expression.Expression)) self.assertTrue(f.is_function()) self.assertEqual(len(f.arguments), 6) self.assertEqual( str(f), 'y[0,0] + y[0,1] + y[1,0] + y[1,1] + y[2,0] + y[2,1]') # matrix axis f = optmod.sum(y, axis=0) self.assertTrue(isinstance(f, optmod.expression.ExpressionMatrix)) self.assertTupleEqual(f.shape, (1, 2)) self.assertEqual(str(f), ('[[ y[0,0] + y[1,0] + y[2,0],' + ' y[0,1] + y[1,1] + y[2,1] ]]\n')) # matrix axis f = optmod.sum(y, axis=1) self.assertTrue(isinstance(f, optmod.expression.ExpressionMatrix)) self.assertTupleEqual(f.shape, (3, 1)) self.assertEqual( str(f), ('[[ y[0,0] + y[0,1] ],\n' + ' [ y[1,0] + y[1,1] ],\n' + ' [ y[2,0] + y[2,1] ]]\n')) self.assertRaises(Exception, optmod.sum, x, 2)
def test_evaluator_eval_single_output(self): x = optmod.VariableScalar(name='x', value=3.) y = optmod.VariableScalar(name='y', value=4.) # var f = x e = optmod.coptmod.Evaluator(1, 1, scalar_output=True) f.__fill_evaluator__(e) e.set_input_var(0, id(x)) e.set_output_node(0, id(f)) self.assertEqual(e.get_value(), 0.) e.eval([5.]) self.assertEqual(e.get_value(), 5.) # constant f = optmod.constant.Constant(11.) e = optmod.coptmod.Evaluator(1, 1, scalar_output=True) f.__fill_evaluator__(e) e.set_input_var(0, id(x)) e.set_output_node(0, id(f)) self.assertEqual(e.get_value(), 0.) e.eval([5.]) self.assertEqual(e.get_value(), 11.) # add f = x + 3 e = optmod.coptmod.Evaluator(1, 1, scalar_output=True) f.__fill_evaluator__(e) e.set_input_var(0, id(x)) e.set_output_node(0, id(f)) self.assertEqual(e.get_value(), 0.) e.eval([9.]) self.assertEqual(e.get_value(), 12.) # sub f = x - 3 e = optmod.coptmod.Evaluator(1, 1, scalar_output=True) f.__fill_evaluator__(e) e.set_input_var(0, id(x)) e.set_output_node(0, id(f)) self.assertEqual(e.get_value(), 0.) e.eval([9.]) self.assertEqual(e.get_value(), 6.) # negate f = -(x + 10.) e = optmod.coptmod.Evaluator(1, 1, scalar_output=True) f.__fill_evaluator__(e) e.set_input_var(0, id(x)) e.set_output_node(0, id(f)) self.assertEqual(e.get_value(), 0.) e.eval([9.]) self.assertEqual(e.get_value(), -19.) # multiply f = y * (x + 3) e = optmod.coptmod.Evaluator(2, 1, scalar_output=True) f.__fill_evaluator__(e) e.set_input_var(0, id(x)) e.set_input_var(1, id(y)) e.set_output_node(0, id(f)) self.assertEqual(e.get_value(), 0.) e.eval([9., -20.]) self.assertEqual(e.get_value(), -20. * (9. + 3.)) # sin f = optmod.sin(x + 3) e = optmod.coptmod.Evaluator(1, 1, scalar_output=True) f.__fill_evaluator__(e) e.set_input_var(0, id(x)) e.set_output_node(0, id(f)) self.assertEqual(e.get_value(), 0.) e.eval([9.]) self.assertEqual(e.get_value(), np.sin(12.)) # cos f = optmod.cos(3 * y) e = optmod.coptmod.Evaluator(1, 1, scalar_output=True) f.__fill_evaluator__(e) e.set_input_var(0, id(y)) e.set_output_node(0, id(f)) self.assertEqual(e.get_value(), 0.) e.eval([5.]) self.assertEqual(e.get_value(), np.cos(15.))
def test_get_variables(self): x = optmod.VariableScalar(name='x') self.assertSetEqual(x.get_variables(), set([x]))