def test_dense_param(self):
#
# Create model instance
#
model = AbstractModel()
model.Z = Set(initialize=[1,3])
model.A = Param(model.Z, initialize=1.3, mutable=True)
model.action2 = BuildAction(model.Z, rule=action2_fn)
instance = model.create_instance()
#
self.assertEqual( instance.A[1].value, 2.3)
self.assertEqual( value(instance.A[3]), 4.3)
#
buf = StringIO()
instance.pprint(ostream=buf)
self.assertEqual(buf.getvalue(),"""1 Set Declarations
Z : Size=1, Index=None, Ordered=Insertion
Key : Dimen : Domain : Size : Members
None : 1 : Any : 2 : {1, 3}
1 Param Declarations
A : Size=2, Index=Z, Domain=Any, Default=None, Mutable=True
Key : Value
1 : 2.3
3 : 4.3
1 BuildAction Declarations
action2 : Size=0, Index=Z, Active=True
3 Declarations: Z A action2
""")
def test_pickle_abstract_model_virtual_set(self):
model = AbstractModel()
model._a = Set(initialize=[1,2,3])
model.A = model._a * model._a
str = pickle.dumps(model)
tmodel = pickle.loads(str)
self.verifyModel(model, tmodel)
def test_pickle_abstract_model_constraint(self):
model = AbstractModel()
model.x = Var()
model.A = Constraint(expr=model.x <= 0)
str = pickle.dumps(model)
tmodel = pickle.loads(str)
self.verifyModel(model, tmodel)
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_pickle_abstract_model_indexed_constraint(self):
model = AbstractModel()
model.x = Var()
model.A = Constraint([1,2,3], rule=simple_con_rule)
str = pickle.dumps(model)
tmodel = pickle.loads(str)
self.verifyModel(model, tmodel)
def test_create_from_dict(self):
model = AbstractModel()
model.A = RangeSet(2)
def _b_rule(b, id):
b.S = Set()
b.P = Param()
b.Q = Param(b.S)
model.B = Block(model.A, rule=_b_rule)
instance = model.create_instance( {None:{'B': \
{1:{'S':{None:['a','b','c']}, \
'P':{None:4}, \
'Q':{('a',):1,('b',):2,('c',):3}}, \
2:{'S':{None:[]}, \
'P':{None:3}} \
} \
}} )
self.assertEqual(set(instance.B[1].S), set(['a', 'b', 'c']))
self.assertEqual(value(instance.B[1].P), 4)
self.assertEqual(value(instance.B[1].Q['a']), 1)
self.assertEqual(value(instance.B[1].Q['b']), 2)
self.assertEqual(value(instance.B[1].Q['c']), 3)
self.assertEqual(value(instance.B[2].P), 3)
def test_pickle3(self):
def rule1(model):
return (1,model.x+model.y[1],2)
def rule2(model, i):
return (1,model.x+model.y[1]+i,2)
model = AbstractModel()
model.a = Set(initialize=[1,2,3])
model.A = Param(initialize=1, mutable=True)
model.B = Param(model.a, mutable=True)
model.x = Var(initialize=1,within=Reals)
model.y = Var(model.a, initialize=1,within=Reals)
model.obj = Objective(rule=lambda model: model.x+model.y[1])
model.obj2 = Objective(model.a,rule=lambda model,i: i+model.x+model.y[1])
model.con = Constraint(rule=rule1)
model.con2 = Constraint(model.a, rule=rule2)
instance = model.create_instance()
if using_pypy:
str_ = pickle.dumps(instance)
tmp_ = pickle.loads(str_)
else:
with self.assertRaises((pickle.PicklingError,
TypeError,
AttributeError)):
pickle.dumps(instance)
def test_pickle_abstract_model_objective(self):
model = AbstractModel()
model.x = Var()
model.A = Objective(expr=model.x <= 0)
str = pickle.dumps(model)
tmodel = pickle.loads(str)
self.verifyModel(model, tmodel)
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 setUp(self):
#
# Create model instance
#
model = AbstractModel()
model.A = Param(initialize=3.3, mutable=True)
model.action1 = BuildAction(rule=action1_fn)
self.instance = model.create_instance()
def Xtest_label1(self):
model = AbstractModel()
model.A = Set(initialize=[1, 2, 3])
model.B = Param(model.A, initialize={1: 100, 2: 200, 3: 300})
model.x = Var(model.A)
model.y = Var(model.A)
instance = model.create_instance()
instance.preprocess()
self.assertEqual(instance.num_used_variables(), 0)
def test_expr4(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.x = Var(model.A)
model.y = Var(model.A)
instance=model.create_instance()
expr = sum_product(denom=[instance.y,instance.x])
baseline = "1/(y[1]*x[1]) + 1/(y[2]*x[2]) + 1/(y[3]*x[3])"
self.assertEqual( str(expr), baseline )
def test_summation_error3(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.x = Var(model.A)
instance=model.create_instance()
try:
expr = sum_product(denom=(instance.x,instance.B))
self.fail("Expected ValueError")
except ValueError:
pass
def test_indexed_block_immutable_param(self):
model = AbstractModel()
model.A = RangeSet(2)
def _b_rule(b, id):
b.A = Param(initialize=id)
model.B = Block(model.A, rule=_b_rule)
instance = model.create_instance()
self.assertEqual(value(instance.B[1].A), 1)
self.assertEqual(value(instance.B[2].A), 2)
def Xtest_label2(self):
model = AbstractModel()
model.A = Set(initialize=[1, 2, 3])
model.B = Param(model.A, initialize={1: 100, 2: 200, 3: 300})
model.x = Var(model.A)
model.y = Var(model.A)
model.obj = Objective(rule=lambda inst: inst.x[1])
instance = model.create_instance()
instance.preprocess()
self.assertEqual(instance.num_used_variables(), 1)
self.assertEqual(instance.x[1].label, "x(1)")
self.assertEqual(instance.x[2].label, "x(2)")
self.assertEqual(instance.y[1].label, "y(1)")
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_sparse_param_default(self):
#
# Create model instance
#
model = AbstractModel()
model.Z = Set(initialize=[1,3])
model.A = Param(model.Z, initialize={1:1.3}, default=0, mutable=True)
model.action2 = BuildAction(model.Z, rule=action2_fn)
instance = model.create_instance()
tmp = value(instance.A[1])
self.assertEqual( type(tmp), float)
self.assertEqual( tmp, 2.3 )
def test_pickle2(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.x = Var(model.A)
model.y = Var(model.A)
model.obj = Objective(rule=obj_rule)
model.constr = Constraint(model.A,rule=constr_rule)
tmp=model.create_instance()
pickle_str = pickle.dumps(tmp)
instance = pickle.loads(pickle_str)
expr = sum_product(instance.x,instance.B,instance.y)
baseline = "B[1]*x[1]*y[1] + B[2]*x[2]*y[2] + B[3]*x[3]*y[3]"
self.assertEqual( str(expr), baseline )
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_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_io(self):
model = AbstractModel()
model.c1 = BuildCheck(rule=lambda M: True)
model.A = Set(initialize=[1,2,3])
model.c2 = BuildCheck(model.A, rule=lambda M,i: True)
instance = model.create_instance()
#
buf = StringIO()
instance.pprint(ostream=buf)
self.assertEqual(buf.getvalue(),"""1 Set Declarations
A : Size=1, Index=None, Ordered=Insertion
Key : Dimen : Domain : Size : Members
None : 1 : Any : 3 : {1, 2, 3}
2 BuildCheck Declarations
c1 :
c2 :
3 Declarations: c1 A c2
""")
def test_pickle_abstract_model_mutable_param(self):
model = AbstractModel()
model.A = Param(initialize=1, mutable=True)
str = pickle.dumps(model)
tmodel = pickle.loads(str)
self.verifyModel(model, tmodel)
def test_pickle_abstract_model_indexed_param(self):
model = AbstractModel()
model.A = Param([1,2,3], initialize={1:100,2:200,3:300})
str = pickle.dumps(model)
tmodel = pickle.loads(str)
self.verifyModel(model, tmodel)
def test_abstract_index(self):
model = AbstractModel()
model.A = Set()
model.B = Set()
model.C = model.A | model.B
model.x = Constraint(model.C)
# ___________________________________________________________________________
#
# 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, RangeSet, Var, Objective, sum_product
model = AbstractModel()
model.A = RangeSet(1,4)
model.x = Var(model.A)
def obj_rule(model):
return sum_product(model.x)
model.obj = Objective(rule=obj_rule)
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)
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_pickle_abstract_model_constant_objective(self):
model = AbstractModel()
model.A = Objective(expr=1)
str = pickle.dumps(model)
tmodel = pickle.loads(str)
self.verifyModel(model, tmodel)
def test_pickle_abstract_model_var(self):
model = AbstractModel()
model.A = Var(initialize=1)
str = pickle.dumps(model)
tmodel = pickle.loads(str)
self.verifyModel(model, tmodel)
