def test_nested_expressions(self):
m = aml.ConcreteModel()
m.I = range(10)
m.x = aml.Var(m.I)
m.y = aml.Var(m.I)
m.c = aml.Constraint(m.I,
rule=lambda m, i: aml.sin(2 * m.x[i] - m.y[i]) /
(m.x[i] + 1) <= 100)
dag = problem_from_pyomo_model(m)
assert len(dag.constraints) == 10
for constraint in dag.constraints:
assert constraint.lower_bound == None
assert constraint.upper_bound == 100
root = constraint.root_expr
assert isinstance(root, core.DivisionExpression)
num, den = root.children
assert isinstance(num, core.SinExpression)
assert num.num_children == 1
num_inner = num.nth_children(0)
assert isinstance(num_inner, core.LinearExpression)
assert np.isclose(2.0,
num_inner.coefficient(num_inner.children[0]))
assert np.isclose(-1.0,
num_inner.coefficient(num_inner.children[1]))
assert isinstance(den, core.LinearExpression)
assert den.constant_term == 1.0
self._check_depth(root)
def test_pow(self):
m = aml.ConcreteModel()
m.I = range(10)
m.x = aml.Var(m.I)
m.c0 = aml.Constraint(expr=aml.cos(m.x[0])**2.0 >= 1)
m.c1 = aml.Constraint(expr=2**aml.sin(m.x[1]) >= 1)
dag = problem_from_pyomo_model(m)
c0 = dag.constraint('c0')
root_c0 = c0.root_expr
assert isinstance(root_c0, core.PowExpression)
assert root_c0.num_children == 2
assert isinstance(root_c0.children[0], core.CosExpression)
assert isinstance(root_c0.children[1], core.Constant)
assert root_c0.children[1].value == 2.0
c1 = dag.constraint('c1')
root_c1 = c1.root_expr
assert isinstance(root_c1, core.PowExpression)
assert root_c1.num_children == 2
assert isinstance(root_c1.children[0], core.Constant)
assert isinstance(root_c1.children[1], core.SinExpression)
self._check_depth(root_c0)
self._check_depth(root_c1)
def test_min(self):
m = aml.ConcreteModel()
m.I = range(10)
m.x = aml.Var(m.I)
m.obj = aml.Objective(expr=sum(m.x[i] for i in m.I))
dag = problem_from_pyomo_model(m)
assert dag.num_objectives == 1
obj = dag.objective
assert isinstance(obj.root_expr, core.LinearExpression)
assert obj.original_sense == core.Sense.MINIMIZE
def test_abs(self):
m = aml.ConcreteModel()
m.I = range(10)
m.x = aml.Var(m.I)
m.c = aml.Constraint(expr=abs(m.x[0]) >= 0)
dag = problem_from_pyomo_model(m)
constraint = dag.constraint('c')
root = constraint.root_expr
assert isinstance(root, core.AbsExpression)
self._check_depth(root)
def test_sum_of_quadratic_with_same_variables(self):
m = aml.ConcreteModel()
m.I = range(10)
m.x = aml.Var(m.I)
m.c = aml.Objective(expr=2 * m.x[0] * m.x[1] + 3 * m.x[1] * m.x[0])
dag = problem_from_pyomo_model(m)
root_expr = dag.objective.root_expr
assert isinstance(root_expr, core.QuadraticExpression)
assert len(root_expr.terms) == 1
term = root_expr.terms[0]
assert term.var1 == dag.variable('x[0]')
assert term.var2 == dag.variable('x[1]')
assert term.coefficient == 5.0
def test_sum_as_quadratic(self):
m = aml.ConcreteModel()
m.I = range(10)
m.x = aml.Var(m.I)
m.c = aml.Constraint(range(8),
rule=lambda m, j: sum(m.x[i] * m.x[i + 1]
for i in range(j + 2)) >= 0)
dag = problem_from_pyomo_model(m)
assert len(dag.constraints) == 8
for constraint in dag.constraints:
root = constraint.root_expr
assert isinstance(root, core.QuadraticExpression)
self._check_depth(root)
def test_sum_of_quadratic_with_same_variables2(self):
m = aml.ConcreteModel()
m.I = range(10)
m.x = aml.Var(m.I)
m.c = aml.Objective(expr=m.x[0]**2 + m.x[1]**2 + m.x[0])
dag = problem_from_pyomo_model(m)
root_expr = dag.objective.root_expr
assert isinstance(root_expr, core.SumExpression)
expr = [
ex for ex in root_expr.children
if isinstance(ex, core.QuadraticExpression)
][0]
assert len(expr.terms) == 2
for term in expr.terms:
assert term.coefficient == 1.0
def test_sum(self):
m = aml.ConcreteModel()
m.I = range(10)
m.x = aml.Var(m.I)
m.c = aml.Constraint(
range(8),
rule=lambda m, j: sum(aml.sin(m.x[i + 1])
for i in range(j + 2)) >= 0)
dag = problem_from_pyomo_model(m)
assert len(dag.constraints) == 8
for constraint in dag.constraints:
root = constraint.root_expr
assert isinstance(root, core.SumExpression)
for c in root.children:
assert isinstance(c, core.SinExpression)
self._check_depth(root)
def test_sum_of_linear_and_other(self):
m = aml.ConcreteModel()
m.I = range(10)
m.x = aml.Var(m.I)
m.c = aml.Objective(expr=m.x[0] + 2.0 * m.x[1] + aml.sin(m.x[2]) +
m.x[1])
dag = problem_from_pyomo_model(m)
root_expr = dag.objective.root_expr
assert isinstance(root_expr, core.SumExpression)
assert len(root_expr.children) == 2
linear_expr = [
ex for ex in root_expr.children
if isinstance(ex, core.LinearExpression)
][0]
assert np.isclose(1.0, linear_expr.coefficient(dag.variable('x[0]')))
assert np.isclose(3.0, linear_expr.coefficient(dag.variable('x[1]')))
def test_simple_model(self):
m = aml.ConcreteModel()
m.I = range(10)
m.x = aml.Var(m.I)
m.c = aml.Constraint(m.I, rule=lambda m, i: m.x[i] + 2 >= 0)
dag = problem_from_pyomo_model(m)
assert len(dag.constraints) == 10
for constraint in dag.constraints:
assert constraint.lower_bound == 0.0
assert constraint.upper_bound == None
root = constraint.root_expr
assert isinstance(root, core.LinearExpression)
assert root.num_children == 1
assert root.constant_term == 2.0
v = root.nth_children(0)
assert isinstance(v, core.Variable)
self._check_depth(root)
def test_product(self):
m = aml.ConcreteModel()
m.I = range(10)
m.x = aml.Var(m.I)
m.c = aml.Constraint(
range(9),
rule=lambda m, i: aml.sin(m.x[i]) * aml.cos(m.x[i + 1]) >= 0)
dag = problem_from_pyomo_model(m)
assert len(dag.constraints) == 9
for constraint in dag.constraints:
root = constraint.root_expr
assert isinstance(root, core.ProductExpression)
assert root.num_children == 2
child1, child2 = root.children
assert isinstance(child1, core.SinExpression)
assert isinstance(child2, core.CosExpression)
self._check_depth(root)
def test_sum_of_quadratic_and_other(self):
m = aml.ConcreteModel()
m.I = range(10)
m.x = aml.Var(m.I)
m.c = aml.Objective(expr=2 * m.x[0] * m.x[1] + 3 * m.x[0] * m.x[1] +
m.x[3] * m.x[4] + m.x[5] + aml.sin(m.x[6]))
dag = problem_from_pyomo_model(m)
root_expr = dag.objective.root_expr
assert isinstance(root_expr, core.SumExpression)
assert len(root_expr.children) == 3
assert len([
expr for expr in root_expr.children
if isinstance(expr, core.QuadraticExpression)
]) == 1
assert len([
expr for expr in root_expr.children
if isinstance(expr, core.SinExpression)
]) == 1
def test_product_as_quadratic(self):
m = aml.ConcreteModel()
m.I = range(10)
m.x = aml.Var(m.I)
m.c = aml.Constraint(
range(9), rule=lambda m, i: 2 * m.x[i] * 3 * m.x[i + 1] >= 0)
dag = problem_from_pyomo_model(m)
assert len(dag.constraints) == 9
for constraint in dag.constraints:
root = constraint.root_expr
assert isinstance(root, core.QuadraticExpression)
assert root.num_children == 2
assert len(root.terms) == 1
var1, var2 = root.children
assert isinstance(var1, core.Variable)
assert isinstance(var2, core.Variable)
assert np.isclose(root.coefficient(var1, var2), 6.0)
self._check_depth(root)
def create_problem():
m = pe.ConcreteModel()
m.I = range(5)
m.x = pe.Var(m.I, bounds=(-1, 2))
m.obj = pe.Objective(expr=sum(m.x[i] for i in m.I))
return problem_from_pyomo_model(m)
