source: coopr.pyomo/trunk/coopr/pyomo/tests/expr/test_canonical.py @ 2201

Last change on this file since 2201 was 2201, checked in by wehart, 10 years ago

Update to Coopr to account for changes in PyUtilib? package names.

File size: 9.6 KB
Line 
1#
2# Test the canonical expressions
3#
4
5import unittest
6import os
7import sys
8from os.path import abspath, dirname
9sys.path.insert(0, dirname(dirname(abspath(__file__)))+os.sep+".."+os.sep+"..")
10currdir = dirname(abspath(__file__))+os.sep
11
12from coopr.pyomo import *
13from coopr.opt import *
14#from coopr.pyomo.base.var import _VarElement
15import pyutilib.th
16import pyutilib.services
17from coopr.pyomo.presolve.simple_presolver import SimplePresolver
18from pyutilib.component.core import PluginGlobals
19
20class frozendict(dict):
21    __slots__ = ('_hash',)
22    def __hash__(self):
23        rval = getattr(self, '_hash', None)
24        if rval is None:
25            rval = self._hash = hash(frozenset(self.iteritems()))
26        return rval
27
28
29class TestBase(pyutilib.th.TestCase):
30
31    def setUp(self):
32        self.model = Model()
33
34    def construct(self,filename):
35        self.instance = self.model.create(filename)
36
37
38class Test(TestBase):
39
40    def setUp(self):
41        #
42        # Create Model
43        #
44        TestBase.setUp(self)
45        #PluginGlobals.pprint()
46        self.plugin = SimplePresolver()
47        self.plugin.deactivate_action("compute_canonical_repn")
48
49    def tearDown(self):
50        if os.path.exists("unknown.lp"):
51           os.unlink("unknown.lp")
52        pyutilib.services.TempfileManager.clear_tempfiles()
53        self.plugin.activate_action("compute_canonical_repn")
54
55    def test_expr1(self):
56        self.model.A = RangeSet(1,4)
57        def p_init(i, model):
58            return 2*i
59        self.model.p = Param(self.model.A, initialize=p_init)
60        self.model.x = Var(self.model.A, bounds=(-1,1))
61        def obj_rule(model):
62            return summation(model.p, model.x)
63        self.model.obj = Objective(rule=obj_rule)
64        self.instance = self.model.create()
65        #self.instance.obj[None].expr.pprint()
66        self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance), {1: {frozendict({2: 1}): 6.0, frozendict({1: 1}): 4.0, frozendict({3: 1}): 8.0, frozendict({0: 1}): 2.0}})
67
68    def test_expr2(self):
69        self.model.A = RangeSet(1,4)
70        def p_init(i, model):
71            return 2*i
72        self.model.p = Param(self.model.A, initialize=p_init)
73        self.model.x = Var(self.model.A, bounds=(-1,1))
74        def obj_rule(model):
75            return summation(model.x, model.p)
76        self.model.obj = Objective(rule=obj_rule)
77        self.instance = self.model.create()
78        #self.instance.obj[None].expr.pprint()
79        self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance), {1: {frozendict({2: 1}): 6.0, frozendict({1: 1}): 4.0, frozendict({3: 1}): 8.0, frozendict({0: 1}): 2.0}})
80
81    def test_expr3(self):
82        self.model.A = RangeSet(1,4)
83        def p_init(i, model):
84            return 2*i
85        self.model.p = Param(self.model.A, initialize=p_init)
86        self.model.x = Var(self.model.A, bounds=(-1,1))
87        def obj_rule(model):
88            return 2*model.x[1] + 3*model.x[1] + 4*(model.x[1]+model.x[2])
89        self.model.obj = Objective(rule=obj_rule)
90        self.instance = self.model.create()
91        #self.instance.obj[None].expr.pprint()
92        self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance), 
93                    {1: {frozendict({0: 1}):9.0, frozendict({1: 1}):4.0}})
94
95    def test_expr4(self):
96        self.model.A = RangeSet(1,4)
97        def p_init(i, model):
98            return 2*i
99        self.model.p = Param(self.model.A, initialize=p_init)
100        self.model.x = Var(self.model.A, bounds=(-1,1))
101        def obj_rule(model):
102            return 1.2 + 2*model.x[1] + 3*model.x[1]
103        self.model.obj = Objective(rule=obj_rule)
104        self.instance = self.model.create()
105        #self.instance.obj[None].expr.pprint()
106        self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance), {0:frozendict({None:1.2}), 1: {frozendict({0: 1}): 5.0}})
107
108    def test_expr5(self):
109        self.model.A = RangeSet(1,4)
110        def p_init(i, model):
111            return 2*i
112        self.model.p = Param(self.model.A, initialize=p_init)
113        self.model.x = Var(self.model.A, bounds=(-1,1))
114        def obj_rule(model):
115            return model.x[1]*(model.x[1]+model.x[2]) + model.x[2]*(model.x[1]+3.0*model.x[3]*model.x[3])
116        self.model.obj = Objective(rule=obj_rule)
117        self.instance = self.model.create()
118        #self.instance.obj[None].expr.pprint()
119        self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance), 
120                {2: {frozendict({0:2}):1.0, frozendict({0:1, 1:1}):2.0}, 3:{frozendict({1:1,2:2}):3.0}})
121
122    def test_expr6(self):
123        self.model.A = RangeSet(1,4)
124        def p_init(i, model):
125            return 2*i
126        self.model.p = Param(self.model.A, initialize=p_init)
127        self.model.x = Var(self.model.A, bounds=(-1,1))
128        def obj_rule(model):
129            return 2.0*(1.2 + 2*model.x[1] + 3*model.x[1]) + 3.0*(1.0+model.x[1])
130        self.model.obj = Objective(rule=obj_rule)
131        self.instance = self.model.create()
132        #self.instance.obj[None].expr.pprint()
133        self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance), 
134            {0:frozendict({None:5.4}), 1: {frozendict({0: 1}): 13.0}})
135
136    def test_expr7(self):
137        self.model.A = RangeSet(1,4)
138        def p_init(i, model):
139            return 2*i
140        self.model.p = Param(self.model.A, initialize=p_init)
141        self.model.x = Var(self.model.A, bounds=(-1,1))
142        def obj_rule(model):
143            return summation(model.p, model.x)/2.0
144        self.model.obj = Objective(rule=obj_rule)
145        self.instance = self.model.create()
146        #self.instance.obj[None].expr.pprint()
147        self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance), 
148            {1: {frozendict({2: 1}): 3.0, frozendict({1: 1}): 2.0, frozendict({3: 1}): 4.0, frozendict({0: 1}): 1.0}})
149
150    def test_expr8(self):
151        self.model.A = RangeSet(1,4)
152        def p_init(i, model):
153            return 2*i
154        self.model.p = Param(self.model.A, initialize=p_init)
155        self.model.x = Var(self.model.A, bounds=(-1,1))
156        self.model.y = Var(initialize=2.0)
157        def obj_rule(model):
158            return summation(model.p, model.x)/model.y
159        self.model.obj = Objective(rule=obj_rule)
160        self.instance = self.model.create()
161        self.instance.y.fixed = True
162        self.instance.y.reset()
163        #self.instance.obj[None].expr.pprint()
164        self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance), 
165            {1: {frozendict({2: 1}): 3.0, frozendict({1: 1}): 2.0, frozendict({3: 1}): 4.0, frozendict({0: 1}): 1.0}})
166
167    def test_expr9(self):
168        self.model.A = RangeSet(1,4)
169        def p_init(i, model):
170            return 2*i
171        self.model.p = Param(self.model.A, initialize=p_init)
172        self.model.x = Var(self.model.A, bounds=(-1,1))
173        self.model.y = Var(initialize=1.0)
174        def obj_rule(model):
175            return summation(model.p, model.x)/(1+model.y)
176        self.model.obj = Objective(rule=obj_rule)
177        self.instance = self.model.create()
178        self.instance.y.fixed = True
179        self.instance.y.reset()
180        #self.instance.obj[None].expr.pprint()
181        self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance), 
182            {1: {frozendict({2: 1}): 3.0, frozendict({1: 1}): 2.0, frozendict({3: 1}): 4.0, frozendict({0: 1}): 1.0}})
183
184    def test_expr10(self):
185        self.model.A = RangeSet(1,4)
186        def p_init(i, model):
187            return 2*i
188        self.model.p = Param(self.model.A, initialize=p_init)
189        self.model.x = Var(self.model.A, bounds=(-1,1))
190        self.model.y = Var(initialize=1.0)
191        def obj_rule(model):
192            return summation(model.p, model.x)/(1+model.y)
193        self.model.obj = Objective(rule=obj_rule)
194        self.instance = self.model.create()
195        #self.instance.obj[None].expr.pprint()
196        rep = generate_canonical_repn(self.instance.obj[None].expr, self.instance)
197        self.failUnless(len(rep) == 1 and None in rep)
198
199    def test_expr11(self):
200        self.model.A = RangeSet(1,4)
201        def p_init(i, model):
202            return 2*i
203        self.model.p = Param(self.model.A, initialize=p_init)
204        self.model.x = Var(self.model.A, bounds=(-1,1))
205        self.model.y = Var(initialize=1.0)
206        def obj_rule(model):
207            return (1.0+model.x[1]+1/model.x[2]) + (2.0+model.x[2]+1/model.x[3])
208        self.model.obj = Objective(rule=obj_rule)
209        self.instance = self.model.create()
210        #self.instance.obj[None].expr.pprint()
211        rep = generate_canonical_repn(self.instance.obj[None].expr, self.instance)
212        rep[None].pprint()
213        del rep[None]
214        self.failUnlessEqual(rep, {0: {None: 3.0}, 1: {frozendict({1: 1}): 1.0, frozendict({0: 1}): 1.0}})
215
216    def test_expr12(self):
217        self.model.A = RangeSet(1,4)
218        def p_init(i, model):
219            return 2*i
220        self.model.p = Param(self.model.A, initialize=p_init)
221        self.model.x = Var(self.model.A, bounds=(-1,1))
222        self.model.y = Var(initialize=1.0)
223        def obj_rule(model):
224            return (1.0+model.x[1]+1/model.x[2]) * (2.0+model.x[2]+1/model.x[3])
225        self.model.obj = Objective(rule=obj_rule)
226        self.instance = self.model.create()
227        #self.instance.obj[None].expr.pprint()
228        rep = generate_canonical_repn(self.instance.obj[None].expr, self.instance)
229        rep[None].pprint()
230        del rep[None]
231        self.failUnlessEqual(rep, {0: {None: 2.0}, 1: {frozendict({1: 1}): 1.0, frozendict({0: 1}): 2.0}, 2: {frozendict({0: 1, 1: 1}): 1.0}})
232
233if __name__ == "__main__":
234   unittest.main()
235
Note: See TracBrowser for help on using the repository browser.