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_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_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_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 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_nonindexed_block_immutable_param(self):
model = AbstractModel()
def _b_rule(b):
b.A = Param(initialize=2.0)
model.B = Block(rule=_b_rule)
instance = model.create_instance()
self.assertEqual(value(instance.B.A), 2.0)
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_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_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 = 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 = Constraint(model.C)