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)