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]))
