source: coopr.pyomo/stable/2.3/coopr/pyomo/tests/expr/test_canonical.py @ 2433

Last change on this file since 2433 was 2433, checked in by wehart, 11 years ago

Merged revisions 2388-2432 via svnmerge from
https://software.sandia.gov/svn/public/coopr/coopr.pyomo/trunk

........

r2399 | wehart | 2010-02-24 11:36:56 -0700 (Wed, 24 Feb 2010) | 2 lines


Adding a work-around when pstats cannot be imported.

........

r2400 | wehart | 2010-02-24 14:51:08 -0700 (Wed, 24 Feb 2010) | 2 lines


Misc documentation updates.

........

r2408 | wehart | 2010-02-28 05:41:04 -0700 (Sun, 28 Feb 2010) | 3 lines


Allow an earlier version of Python. I'm still not sure this is a good idea,
but it's necessary for Jython.

........

r2409 | wehart | 2010-02-28 05:42:33 -0700 (Sun, 28 Feb 2010) | 7 lines


Rework of profiling imports.


Refinement of Pyomo command-line parsing, which is more
specific now.


Adding automatic import of pyomo to package.

........

r2415 | jwatson | 2010-03-08 20:53:13 -0700 (Mon, 08 Mar 2010) | 3 lines


Significantly improved performance of PyomoModel? _clear_attribute method, mainly by eliminate unnecessary calls to it through _setattr_exec_.

........

r2416 | jwatson | 2010-03-09 16:45:22 -0700 (Tue, 09 Mar 2010) | 5 lines


Modified the AMPL dat file parser to instantiate the lexer and yaccer objects only once, for the lifetime of the module.


They were being inadvertently created at each invocation, which pyomo users wouldn't notice. But PySP users, who can be creating 1K or more instances, do!

........

r2422 | wehart | 2010-03-11 16:01:09 -0700 (Thu, 11 Mar 2010) | 3 lines


Rework of unit tests to (a) import pyutilib.th as 'unittest' and
(b) employ test skipping.

........

r2430 | wehart | 2010-03-11 23:38:22 -0700 (Thu, 11 Mar 2010) | 2 lines


Reworking class decorators.

........

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