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)