def test_expr2(self):
model = AbstractModel()
model.A = Set(initialize=[1, 2, 3])
model.B = Param(model.A,
initialize={
1: 100,
2: 200,
3: 300
},
mutable=True)
model.C = Param(model.A,
initialize={
1: 100,
2: 200,
3: 300
},
mutable=False)
model.x = Var(model.A)
model.y = Var(model.A)
instance = model.create_instance()
expr = sum_product(instance.x, instance.B, instance.y, index=[1, 3])
baseline = "B[1]*x[1]*y[1] + B[3]*x[3]*y[3]"
self.assertEqual(str(expr), baseline)
expr = sum_product(instance.x, instance.C, instance.y, index=[1, 3])
self.assertEqual(str(expr), "100*x[1]*y[1] + 300*x[3]*y[3]")
def test_abstract_index(self):
model = AbstractModel()
model.A = Set(initialize=[0])
model.B = Set(initialize=[1])
model.C = model.A | model.B
M = ConcreteModel()
M.x = Var([1,2,3])
M.c = SOSConstraint(model.C, var=M.x, sos=1, index={0:[1,2], 1:[2,3]})
def test_constr_lower(self):
model = AbstractModel()
model.A = Param(default=2.0, mutable=True)
model.B = Param(default=1.5, mutable=True)
model.C = Param(default=2.5, mutable=True)
model.X = Var()
def constr_rule(model):
return (model.A*(model.B+model.C),model.X)
model.constr = Constraint(rule=constr_rule)
instance = model.create_instance()
self.assertEqual(instance.constr.lower(),8.0)
def test_var_bounds(self):
model = AbstractModel()
model.A = Param(default=2.0, mutable=True)
model.B = Param(default=1.5, mutable=True)
model.C = Param(default=2.5)
def X_bounds_rule(model):
return (model.A*(model.B-model.C),model.A*(model.B+model.C))
model.X = Var(bounds=X_bounds_rule)
instance = model.create_instance()
self.assertEqual(instance.X.lb,-2.0)
self.assertEqual(instance.X.ub,8.0)
def test_mutable_constraint_lower(self):
model = AbstractModel()
model.Q = Param(initialize=2.0, mutable=True)
model.X = Var()
def constraint_rule(m):
return m.X >= m.Q
model.C = Constraint(rule=constraint_rule)
instance = model.create_instance()
self.assertEqual(value(instance.C.lower), 2.0)
instance.Q = 4.0
self.assertEqual(value(instance.C.lower), 4.0)
def test_expand_connector(self):
model = AbstractModel()
model.A = Set()
def _b_rule(b, id):
b.X = Var()
b.PORT = Connector()
b.PORT.add(b.X)
model.B = Block(model.A, rule=_b_rule)
def _c_rule(m, a):
return m.B[a].PORT == m.B[(a + 1) % 2].PORT
model.C = Constraint(model.A, rule=_c_rule)
instance = model.create_instance({None: {'A': {None: [0, 1]}}})
def test_mutable_constraint_both(self):
model = AbstractModel()
model.P = Param(initialize=4.0, mutable=True)
model.Q = Param(initialize=2.0, mutable=True)
model.X = Var()
def constraint_rule(m):
return (m.Q, m.X, m.P)
model.C = Constraint(rule=constraint_rule)
instance = model.create_instance()
self.assertEqual(value(instance.C.lower), 2.0)
self.assertEqual(value(instance.C.upper), 4.0)
instance.P = 8.0
instance.Q = 1.0
self.assertEqual(value(instance.C.lower), 1.0)
self.assertEqual(value(instance.C.upper), 8.0)
# ___________________________________________________________________________
#
# Pyomo: Python Optimization Modeling Objects
# Copyright (c) 2008-2022
# National Technology and Engineering Solutions of Sandia, LLC
# Under the terms of Contract DE-NA0003525 with National Technology and
# Engineering Solutions of Sandia, LLC, the U.S. Government retains certain
# rights in this software.
# This software is distributed under the 3-clause BSD License.
# ___________________________________________________________________________
from pyomo.environ import AbstractModel, Var, Constraint, value
model = AbstractModel()
model.X = Var()
def c_rule(m):
if m.X >= 10.0:
pass
if value(m.X) >= 10.0:
pass
return m.X >= 10.0
model.C = Constraint(rule=c_rule)
def test_abstract_index(self):
model = AbstractModel()
model.A = Set()
model.B = Set()
model.C = model.A | model.B
model.x = Objective(model.C)
def test_abstract_index(self):
model = AbstractModel()
model.A = Set()
model.B = Set()
model.C = model.A | model.B
model.x = Constraint(model.C)
def test_abstract_index(self):
model = AbstractModel()
model.A = Set()
model.B = Set()
model.C = model.A | model.B
model.x = Expression(model.C)
def test_abstract_index(self):
model = AbstractModel()
model.A = Set()
model.B = Set()
model.C = model.A | model.B
model.x = Constraint(model.C)
