def test_eval_numpy(self):
m = ConcreteModel()
m.p = Param([1,2], mutable=True)
m.x = Var()
data = np.array([[0,-1,2],
[.1,.2,.3],
[4,5,6]])
cMap = ComponentMap()
cMap[m.p[1]] = data[0]
cMap[m.p[2]] = data[1]
cMap[m.x] = data[2]
npe = NumpyEvaluator(cMap)
result = npe.walk_expression(sin(m.x))
self.assertEqual(result[0], sin(4))
self.assertEqual(result[1], sin(5))
self.assertEqual(result[2], sin(6))
result = npe.walk_expression(abs(m.x * m.p[1] - m.p[2]))
self.assertEqual(result[0], .1)
self.assertEqual(result[1], -((-1*5)-.2))
self.assertEqual(result[2], (2*6-.3))
result = npe.walk_expression(atan(m.x))
self.assertEqual(result[0], atan(4))
self.assertEqual(result[1], atan(5))
self.assertEqual(result[2], atan(6))
result = npe.walk_expression(atanh(m.p[2]))
self.assertEqual(result[0], atanh(.1))
self.assertEqual(result[1], atanh(.2))
self.assertEqual(result[2], atanh(.3))
def test_eval_numpy(self):
m = ConcreteModel()
m.p = Param([1,2], mutable=True)
m.x = Var()
data = np.array([[0,-1,2],
[.1,.2,.3],
[4,5,6]])
cMap = ComponentMap()
cMap[m.p[1]] = data[0]
cMap[m.p[2]] = data[1]
cMap[m.x] = data[2]
npe = NumpyEvaluator(cMap)
result = npe.walk_expression(sin(m.x))
assert pytest.approx(result[0], rel=1e-12) == sin(4)
assert pytest.approx(result[1], rel=1e-12) == sin(5)
assert pytest.approx(result[2], rel=1e-12) == sin(6)
result = npe.walk_expression(abs(m.x * m.p[1] - m.p[2]))
assert pytest.approx(result[0], rel=1e-12) == .1
assert pytest.approx(result[1], rel=1e-12) == -((-1*5)-.2)
assert pytest.approx(result[2], rel=1e-12) == (2*6-.3)
result = npe.walk_expression(atan(m.x))
assert pytest.approx(result[0], rel=1e-12) == atan(4)
assert pytest.approx(result[1], rel=1e-12) == atan(5)
assert pytest.approx(result[2], rel=1e-12) == atan(6)
result = npe.walk_expression(atanh(m.p[2]))
assert pytest.approx(result[0], rel=1e-12) == atanh(.1)
assert pytest.approx(result[1], rel=1e-12) == atanh(.2)
assert pytest.approx(result[2], rel=1e-12) == atanh(.3)
def _relax_leaf_to_root_sin(node, values, aux_var_map, degree_map, parent_block, relaxation_side_map, counter):
arg = values[0]
degree = degree_map[arg]
if degree == 0:
res = pe.sin(arg)
degree_map[res] = 0
return res
elif (id(arg), 'sin') in aux_var_map:
_aux_var, relaxation = aux_var_map[id(arg), 'sin']
relaxation_side = relaxation_side_map[node]
if relaxation_side != relaxation.relaxation_side:
relaxation.relaxation_side = RelaxationSide.BOTH
degree_map[_aux_var] = 1
return _aux_var
else:
_aux_var = _get_aux_var(parent_block, pe.sin(arg))
arg = replace_sub_expression_with_aux_var(arg, parent_block)
relaxation_side = relaxation_side_map[node]
degree_map[_aux_var] = 1
relaxation = PWSinRelaxation()
relaxation.set_input(x=arg, aux_var=_aux_var, relaxation_side=relaxation_side)
aux_var_map[id(arg), 'sin'] = (_aux_var, relaxation)
setattr(parent_block.relaxations, 'rel'+str(counter), relaxation)
counter.increment()
return _aux_var
def power_flow_through_branch(Vi,
Vj,
delta,
branch,
bus_type="from_bus",
power_type="Reactive"):
if not (power_type == "Active" or power_type == "Reactive"):
raise ValueError(
'Power type must be "Active" (for p) or "Reactive" (for q)')
if not (bus_type == "from_bus" or bus_type == "to_bus"):
raise ValueError(
'Bus type must be "from_bus" (for f) or "to_bus" (for t)')
g = tx_calc.calculate_conductance(branch)
b = tx_calc.calculate_susceptance(branch)
if power_type == "Active":
if bus_type == "from_bus":
return Vi**2 * g - Vi * Vj * g * pe.cos(
delta) - Vi * Vj * b * pe.sin(delta)
else:
return Vj**2 * g - Vi * Vj * g * pe.cos(
delta) - Vi * Vj * b * pe.sin(delta)
else:
if bus_type == "from_bus":
return -Vi**2 * b + Vi * Vj * b * pe.cos(
delta) - Vi * Vj * g * pe.sin(delta)
else:
return -Vj**2 * b + Vi * Vj * b * pe.cos(
delta) - Vi * Vj * g * pe.sin(delta)
def get_pyomo_model():
m = aml.ConcreteModel()
m.x = aml.Var(initialize=10.0)
m.y = aml.Var(initialize=0.0)
m.c0 = aml.Constraint(expr=aml.sin(m.x) >= 0)
m.c1 = aml.Constraint(expr=aml.sin(m.y) >= 0)
m.o = aml.Objective(expr=aml.sin(m.x))
return m
def test_replacement_walker4(self):
M = ConcreteModel()
M.x = Param(mutable=True)
M.y = Var()
M.w = VarList()
e = inequality(0, sin(M.x) + M.x*M.y + 3, 1)
walker = ReplacementWalkerTest3(M)
f = walker.dfs_postorder_stack(e)
self.assertTrue(compare_expressions(inequality(0, sin(M.x) + M.x*M.y + 3, 1), e))
self.assertTrue(compare_expressions(inequality(0, sin(2*M.w[1]) + 2*M.w[1]*M.y + 3, 1), f))
def test_replacement_walker3(self):
M = ConcreteModel()
M.x = Var()
M.y = Var()
M.w = VarList()
e = sin(M.x) + M.x*M.y + 3 <= 0
walker = ReplacementWalkerTest2(M)
f = walker.dfs_postorder_stack(e)
self.assertTrue(compare_expressions(sin(M.x) + M.x*M.y + 3 <= 0, e))
self.assertTrue(compare_expressions(sin(2*M.w[1]) + 2*M.w[1]*(2*M.w[2]) + 3 <= 0, f))
def test_npv_unary(self):
m = ConcreteModel()
m.p1 = Param(mutable=True)
m.p2 = Param(mutable=True)
m.x = Var(initialize=0)
e1 = sin(m.p1)
e2 = replace_expressions(e1, {id(m.p1): m.p2})
e3 = replace_expressions(e1, {id(m.p1): m.x})
self.assertTrue(compare_expressions(e2, sin(m.p2)))
self.assertTrue(compare_expressions(e3, sin(m.x)))
def test_trig_fuctions(self):
m = ConcreteModel()
m.x = Var()
e = differentiate(sin(m.x), wrt=m.x)
self.assertTrue(e.is_expression_type())
self.assertEqual(s(e), s(cos(m.x)))
e = differentiate(cos(m.x), wrt=m.x)
self.assertTrue(e.is_expression_type())
self.assertEqual(s(e), s(-1.0*sin(m.x)))
e = differentiate(tan(m.x), wrt=m.x)
self.assertTrue(e.is_expression_type())
self.assertEqual(s(e), s(1.+tan(m.x)**2.))
e = differentiate(sinh(m.x), wrt=m.x)
self.assertTrue(e.is_expression_type())
self.assertEqual(s(e), s(cosh(m.x)))
e = differentiate(cosh(m.x), wrt=m.x)
self.assertTrue(e.is_expression_type())
self.assertEqual(s(e), s(sinh(m.x)))
e = differentiate(tanh(m.x), wrt=m.x)
self.assertTrue(e.is_expression_type())
self.assertEqual(s(e), s(1.0-tanh(m.x)**2.0))
e = differentiate(asin(m.x), wrt=m.x)
self.assertTrue(e.is_expression_type())
self.assertEqual(s(e), s((1.0 + (-1.0)*m.x**2.)**-0.5))
e = differentiate(acos(m.x), wrt=m.x)
self.assertTrue(e.is_expression_type())
self.assertEqual(s(e), s(-1.*(1.+ (-1.0)*m.x**2.)**-0.5))
e = differentiate(atan(m.x), wrt=m.x)
self.assertTrue(e.is_expression_type())
self.assertEqual(s(e), s((1.+m.x**2.)**-1.))
e = differentiate(asinh(m.x), wrt=m.x)
self.assertTrue(e.is_expression_type())
self.assertEqual(s(e), s((1.+m.x**2)**-.5))
e = differentiate(acosh(m.x), wrt=m.x)
self.assertTrue(e.is_expression_type())
self.assertEqual(s(e), s((-1.+m.x**2.)**-.5))
e = differentiate(atanh(m.x), wrt=m.x)
self.assertTrue(e.is_expression_type())
self.assertEqual(s(e), s((1.+(-1.0)*m.x**2.)**-1.))
def __init__(self, *args, **kwargs):
"""Create the problem."""
kwargs.setdefault('name', 'Feasibility_Pump2')
super(Feasibility_Pump2, self).__init__(*args, **kwargs)
m = self
m.x = Var(within=Binary)
m.y = Var(within=Reals)
m.objective = Objective(expr=-m.y, sense=minimize)
m.c1 = Constraint(expr=m.y - sin(m.x * pi * (5 / 3)) <= 0)
m.c2 = Constraint(expr=-m.y - sin(m.x * pi * (5 / 3)) <= 0)
def eq_cosine_partition(lower_bound, upper_bound, Q):
#Divides the domain [lower_bound, upper_bound] into Q pieces of equal curvature for the cosine function. Domain must be contained in (-pi/2, pi/2)
if Q == 1:
return [lower_bound, upper_bound]
total_curvature = pe.atan(pe.sin(upper_bound)) - pe.atan(
pe.sin(lower_bound))
breakpoints = [lower_bound]
for i in range(Q - 1):
breakpoints.append(
pe.asin(
pe.tan(total_curvature / Q + pe.atan(pe.sin(breakpoints[i])))))
breakpoints.append(upper_bound)
return breakpoints
def test_sin(self):
m = pe.Block(concrete=True)
m.x = pe.Var(bounds=(-math.pi/2, math.pi/2))
m.c = pe.Constraint(expr=pe.inequality(body=pe.sin(m.x), lower=-0.5, upper=0.5))
fbbt(m.c)
self.assertAlmostEqual(pe.value(m.x.lb), math.asin(-0.5))
self.assertAlmostEqual(pe.value(m.x.ub), math.asin(0.5))
m = pe.Block(concrete=True)
m.x = pe.Var()
m.c = pe.Constraint(expr=pe.inequality(body=pe.sin(m.x), lower=-0.5, upper=0.5))
fbbt(m.c)
self.assertEqual(m.x.lb, None)
self.assertEqual(m.x.ub, None)
def gas_emissivity_mul2_eqn(b, t):
X1 = (b.side_2.properties_in[t].temperature + b.side_2.properties_out[t].temperature)/2
X2 = b.mbl_mul2
X3 = b.side_2.properties_in[t].pressure
X4 = b.side_2.properties_in[t].mole_frac_comp['CO2']
X5 = b.side_2.properties_in[t].mole_frac_comp['H2O']
X6 = b.side_2.properties_in[t].mole_frac_comp['O2']
return b.gas_emissivity_mul2[t] == \
-0.000116906 * X1 \
+1.02113 * X2 \
+4.81687e-07 * X3 \
+0.922679 * X4 \
-0.0708822 * X5 \
-0.0368321 * X6 \
+0.121843 * log(X1) \
+0.0353343 * log(X2) \
+0.0346181 * log(X3) \
+0.0180859 * log(X5) \
-0.256274 * exp(X2) \
-0.674791 * exp(X4) \
-0.724802 * sin(X2) \
-0.0206726 * cos(X2) \
-9.01012e-05 * cos(X3) \
-3.09283e-05 * X1*X2 \
-5.44339e-10 * X1*X3 \
-0.000196134 * X1*X5 \
+4.54838e-05 * X1*X6 \
+7.57411e-07 * X2*X3 \
+0.0395456 * X2*X4 \
+0.726625 * X2*X5 \
-0.034842 * X2*X6 \
+4.00056e-06 * X3*X5 \
+5.71519e-09 * (X1*X2)**2 \
-1.27853 * (X2*X5)**2
def test_expr_equal(model):
assert not expr_equal(1.2, 2.3)
assert expr_equal(model.x[1], model.x[1])
assert expr_equal(model.x[1] + 1.23, model.x[1] + 1.23)
assert not expr_equal(model.x[1], model.y[1, 0])
assert not expr_equal(model.x[1], 2)
sum1 = sum(model.x[i] for i in model.I)
sum2 = sum(model.x[i] for i in model.I)
sum3 = sum((i + 1) * model.x[i] for i in model.I)
sum4 = sum(i * model.x[i] for i in model.I)
sum5 = sum((i + 1) * model.x[i] for i in model.I)
sum6 = sum(model.y[i, 0] for i in model.I)
assert expr_equal(sum1, sum2)
assert not expr_equal(sum1, sum3)
assert not expr_equal(sum1, sum4)
assert expr_equal(sum3, sum5)
assert not expr_equal(sum1, sum6)
fun1 = aml.cos(sum1)
fun2 = aml.cos(sum2)
fun3 = aml.sin(sum1)
assert expr_equal(fun1, fun2)
assert not expr_equal(fun1, fun3)
assert expr_equal(fun1 * fun3, fun2 * fun3)
assert expr_equal(fun1 / fun3, fun2 / fun3)
def test_convert(self):
u = units
m = ConcreteModel()
m.dx = Var(units=u.m, initialize=0.10188943773836046)
m.dy = Var(units=u.m, initialize=0.0)
m.vx = Var(units=u.m/u.s, initialize=0.7071067769802851)
m.vy = Var(units=u.m/u.s, initialize=0.7071067769802851)
m.t = Var(units=u.min, bounds=(1e-5,10.0), initialize=0.0024015570927624456)
m.theta = Var(bounds=(0, 0.49*3.14), initialize=0.7853981693583533, units=u.radians)
m.a = Param(initialize=-32.2, units=u.ft/u.s**2)
m.obj = Objective(expr = m.dx, sense=maximize)
m.vx_con = Constraint(expr = m.vx == 1.0*u.m/u.s*cos(m.theta))
m.vy_con = Constraint(expr = m.vy == 1.0*u.m/u.s*sin(m.theta))
m.dx_con = Constraint(expr = m.dx == m.vx*u.convert(m.t, to_units=u.s))
m.dy_con = Constraint(expr = m.dy == m.vy*u.convert(m.t, to_units=u.s)
+ 0.5*(u.convert(m.a, to_units=u.m/u.s**2))*(u.convert(m.t, to_units=u.s))**2)
m.ground = Constraint(expr = m.dy == 0)
with self.assertRaises(UnitsError):
u.convert(m.a, to_units=u.kg)
self.assertAlmostEqual(value(m.obj), 0.10188943773836046, places=5)
self.assertAlmostEqual(value(m.vx_con.body), 0.0, places=5)
self.assertAlmostEqual(value(m.vy_con.body), 0.0, places=5)
self.assertAlmostEqual(value(m.dx_con.body), 0.0, places=5)
self.assertAlmostEqual(value(m.dy_con.body), 0.0, places=5)
self.assertAlmostEqual(value(m.ground.body), 0.0, places=5)
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_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 create_nlp1():
M = pe.ConcreteModel()
A = list(range(10))
M.x = pe.Var(A, bounds=(0,None), initialize=1)
M.o = pe.Objective(expr=sum(pe.sin((i+1)*M.x[i]) for i in A))
M.c = pe.Constraint(expr=sum(M.x[i] for i in A) >= 1)
return M
def build_model():
"""Simple non-convex model with many local minima"""
model = ConcreteModel()
model.x1 = Var(initialize=1, bounds=(0, 100))
model.x2 = Var(initialize=5, bounds=(5, 6))
model.x2.fix(5)
model.objtv = Objective(expr=model.x1 * sin(model.x1), sense=maximize)
return model
def test_sin(self):
m = pyo.ConcreteModel()
m.x = pyo.Var(initialize=2.0)
e = pyo.sin(m.x)
derivs = reverse_ad(e)
symbolic = reverse_sd(e)
self.assertAlmostEqual(derivs[m.x], pyo.value(symbolic[m.x]), tol + 3)
self.assertAlmostEqual(derivs[m.x], approx_deriv(e, m.x), tol)
def create_problem():
m = aml.ConcreteModel()
m.I = range(10)
m.x = aml.Var(m.I, bounds=(-1, 2))
m.obj = aml.Objective(expr=sum(m.x[i] for i in m.I))
m.cons = aml.Constraint(
m.I[1:], rule=lambda m, i: aml.cos(m.x[0]) * aml.sin(m.x[i]) >= 0)
return problem_from_pyomo_model(m)
def test_sin(self):
m = pe.ConcreteModel()
m.x = pe.Var(initialize=2.0)
e = pe.sin(m.x)
derivs = reverse_ad(e)
symbolic = reverse_sd(e)
self.assertAlmostEqual(derivs[m.x], pe.value(symbolic[m.x]), tol+3)
self.assertAlmostEqual(derivs[m.x], approx_deriv(e, m.x), tol)
def _eval(node):
name = _tag_name(node)
cs = list(node)
if name == 'negate':
assert len(cs) == 1
return -_eval(cs[0])
elif name == 'number':
return float(node.attrib['value'])
elif name == 'variable':
c = float(node.attrib.get('coef', 1))
return c * self._v(int(node.attrib['idx']))
elif name == 'power':
assert len(cs) == 2
b = _eval(cs[0])
e = _eval(cs[1])
return b**e
elif name == 'square':
assert len(cs) == 1
return _eval(cs[0])**2
elif name == 'sqrt':
assert len(cs) == 1
return aml.sqrt(_eval(cs[0]))
elif name == 'product':
return reduce(op.mul, [_eval(c) for c in cs])
elif name == 'divide':
assert len(cs) == 2
return _eval(cs[0]) / _eval(cs[1])
elif name == 'times':
assert len(cs) == 2
return _eval(cs[0]) * _eval(cs[1])
elif name == 'plus':
assert len(cs) == 2
return _eval(cs[0]) + _eval(cs[1])
elif name == 'sum':
return sum([_eval(c) for c in cs])
elif name == 'minus':
assert len(cs) == 2
return _eval(cs[0]) - _eval(cs[1])
elif name == 'abs':
assert len(cs) == 1
return abs(_eval(cs[0]))
elif name == 'exp':
assert len(cs) == 1
return aml.exp(_eval(cs[0]))
elif name == 'ln':
assert len(cs) == 1
return aml.log(_eval(cs[0]))
elif name == 'sin':
assert len(cs) == 1
return aml.sin(_eval(cs[0]))
elif name == 'cos':
assert len(cs) == 1
return aml.cos(_eval(cs[0]))
elif name == 'log10':
assert len(cs) == 1
return aml.log10(_eval(cs[0]))
raise RuntimeError('unhandled tag {}'.format(name))
def test_problem(self):
problem = self.get_problem(
lambda m: aml.cos(m.x) * aml.sin(m.y) - m.x / (m.y * m.y + 1))
h = IntervalHessianEvaluator(problem)
h.eval_at_x(np.array([I(-1, 2), I(-1, 1)]))
print(h.jacobian[0])
print(h.hessian[0])
assert False
def _result_with_mono_bounds(self, visitor, g, mono_g, bounds_g):
mono = ComponentMap()
mono[g] = mono_g
bounds = ComponentMap()
bounds[g] = bounds_g
expr = pe.sin(g)
matched, result = visitor.visit_expression(expr, mono, bounds)
assert matched
return result
def test_collect_uncparam(self):
m = pe.ConcreteModel()
m.w = ro.UncParam()
m.u = ro.UncParam(range(2))
m.x = pe.Var()
m.c = pe.Constraint(expr=3 * m.x + 4 * m.w <= 1)
m.o = pe.Objective(expr=m.x**2 + pe.sin(m.u[0]))
self.assertIs(collect_uncparam(m.c), m.w)
self.assertIs(collect_uncparam(m.o), m.u)
def test_assert_units_consistent_equivalent(self):
u = units
m = ConcreteModel()
m.dx = Var(units=u.m, initialize=0.10188943773836046)
m.dy = Var(units=u.m, initialize=0.0)
m.vx = Var(units=u.m / u.s, initialize=0.7071067769802851)
m.vy = Var(units=u.m / u.s, initialize=0.7071067769802851)
m.t = Var(units=u.min,
bounds=(1e-5, 10.0),
initialize=0.0024015570927624456)
m.theta = Var(bounds=(0, 0.49 * 3.14),
initialize=0.7853981693583533,
units=u.radians)
m.a = Param(initialize=-32.2, units=u.ft / u.s**2)
m.x_unitless = Var()
m.obj = Objective(expr=m.dx, sense=maximize)
m.vx_con = Constraint(expr=m.vx == 1.0 * u.m / u.s * cos(m.theta))
m.vy_con = Constraint(expr=m.vy == 1.0 * u.m / u.s * sin(m.theta))
m.dx_con = Constraint(expr=m.dx == m.vx * u.convert(m.t, to_units=u.s))
m.dy_con = Constraint(
expr=m.dy == m.vy * u.convert(m.t, to_units=u.s) + 0.5 *
(u.convert(m.a, to_units=u.m / u.s**2)) *
(u.convert(m.t, to_units=u.s))**2)
m.ground = Constraint(expr=m.dy == 0)
m.unitless_con = Constraint(expr=m.x_unitless == 5.0)
assert_units_consistent(m) # check model
assert_units_consistent(m.dx) # check var - this should never fail
assert_units_consistent(
m.x_unitless) # check unitless var - this should never fail
assert_units_consistent(m.vx_con) # check constraint
assert_units_consistent(m.unitless_con) # check unitless constraint
assert_units_equivalent(m.dx, m.dy) # check var
assert_units_equivalent(m.x_unitless,
u.dimensionless) # check unitless var
assert_units_equivalent(m.x_unitless, None) # check unitless var
assert_units_equivalent(m.vx_con.body, u.m / u.s) # check constraint
assert_units_equivalent(m.unitless_con.body,
u.dimensionless) # check unitless constraint
assert_units_equivalent(m.dx, m.dy) # check var
assert_units_equivalent(m.x_unitless,
u.dimensionless) # check unitless var
assert_units_equivalent(m.x_unitless, None) # check unitless var
assert_units_equivalent(m.vx_con.body, u.m / u.s) # check constraint
m.broken = Constraint(expr=m.dy == 42.0 * u.kg)
with self.assertRaises(UnitsError):
assert_units_consistent(m)
assert_units_consistent(m.dx)
assert_units_consistent(m.vx_con)
with self.assertRaises(UnitsError):
assert_units_consistent(m.broken)
self.assertTrue(check_units_equivalent(m.dx, m.dy))
self.assertFalse(check_units_equivalent(m.dx, m.vx))
def problem():
m = aml.ConcreteModel()
m.x = aml.Var(bounds=(-2.0, 2.0))
m.y = aml.Var(bounds=(0.01, 1.5))
m.obj = aml.Objective(expr=m.x + m.y)
m.c0 = aml.Constraint(expr=m.x**2 + m.y**2 <= 1.0)
m.c1 = aml.Constraint(expr=aml.sin(m.y) >= 0.0)
return m
def test_expression_to_string(self):
M = ConcreteModel()
M.x = Var()
M.w = Var()
e = sin(M.x) + M.x*M.w + 3
self.assertEqual("sin(x) + x*w + 3", expression_to_string(e))
M.w = 2
M.w.fixed = True
self.assertEqual("sin(x) + x*2 + 3", expression_to_string(e, compute_values=True))
def get_pyomo_model():
m = aml.ConcreteModel()
m.x1 = aml.Var()
m.x2 = aml.Var(bounds=(-1.0, 1.0))
m.x3 = aml.Var(bounds=(1.0, 2.0))
m.obj = aml.Objective(expr=m.x1**2 + (m.x2 + m.x3)**4 + m.x1 * m.x3 +
m.x2 * aml.sin(m.x1 + m.x3) + m.x2)
m.c0 = aml.Constraint(expr=m.x2 >= -1)
return m
def test_replacement_walker4(self):
M = ConcreteModel()
M.x = Param(mutable=True)
M.y = Var()
M.w = VarList()
e = inequality(0, sin(M.x) + M.x * M.y + 3, 1)
walker = ReplacementWalkerTest3(M)
f = walker.dfs_postorder_stack(e)
self.assertEqual("0 <= sin(x) + x*y + 3 <= 1", str(e))
self.assertEqual("0 <= sin(2*w[1]) + 2*w[1]*y + 3 <= 1", str(f))
def test_substitute_casadi_intrinsic3(self):
m = self.m
m.y = Var()
t = IndexTemplate(m.t)
e = sin(m.dv[t] + m.v[t]) + log(m.v[t] * m.y + m.dv[t]**2)
templatemap = {}
e3 = substitute_pyomo2casadi(e, templatemap)
self.assertIs(e3.arg(0)._fcn, casadi.sin)
self.assertIs(e3.arg(1)._fcn, casadi.log)
m.del_component('y')
def test_substitute_casadi_intrinsic4(self):
m = self.m
m.y = Var()
t = IndexTemplate(m.t)
e = m.v[t] * sin(m.dv[t] + m.v[t]) * t
templatemap = {}
e3 = substitute_pyomo2casadi(e, templatemap)
self.assertIs(type(e3.arg(0).arg(0)), casadi.SX)
self.assertIs(e3.arg(0).arg(1)._fcn, casadi.sin)
self.assertIs(type(e3.arg(1)), IndexTemplate)
m.del_component('y')
def test_unary_expressions(self):
m = ConcreteModel()
m.x = Var()
m.y = Var()
m.z = Var()
m.a = Var()
m.b = Var()
m.c = Var()
m.d = Var()
m.c1 = Constraint(expr=0 <= sin(m.x))
m.c2 = Constraint(expr=0 <= cos(m.y))
m.c3 = Constraint(expr=0 <= tan(m.z))
m.c4 = Constraint(expr=0 <= asin(m.a))
m.c5 = Constraint(expr=0 <= acos(m.b))
m.c6 = Constraint(expr=0 <= atan(m.c))
m.c7 = Constraint(expr=0 <= sqrt(m.d))
m.o = Objective(expr=m.x)
self.assertTrue(satisfiable(m) is not False)
