source: coopr.pyomo/stable/coopr/pyomo/tests/unit/test_expr.py @ 3285

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

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

........

r3188 | jwatson | 2010-10-29 08:09:35 -0600 (Fri, 29 Oct 2010) | 3 lines


Eliminating initial domain check when constructing numeric constants and the default domain (Reals) is specified.

........

r3203 | jwatson | 2010-10-29 14:46:18 -0600 (Fri, 29 Oct 2010) | 3 lines


Fixing bugs in has_discrete_variables() method of PyomoModel?.

........

r3211 | jdsiiro | 2010-11-01 14:49:11 -0600 (Mon, 01 Nov 2010) | 4 lines


bugfixes for Blocks:

  • avoid infinite loop when adding a block to a model
  • support pretty printing of user-defined components

........

r3212 | jdsiiro | 2010-11-02 15:17:13 -0600 (Tue, 02 Nov 2010) | 5 lines


  • cleaning up the management of Block._parent_block and Component.model attributes. Adding & removing blocks now updates the model attribute on all children
  • renaming Block._setattr_exec -> Block._add_component

........

r3213 | jdsiiro | 2010-11-03 10:47:06 -0600 (Wed, 03 Nov 2010) | 2 lines


Bugfix to the PyomoLogHandler? for python 2.4 compatibility

........

r3214 | jdsiiro | 2010-11-03 15:20:47 -0600 (Wed, 03 Nov 2010) | 3 lines


There is no point logging a warning when the problem is encountered
generating a logging.info message: log the warning at the info level.

........

r3215 | wehart | 2010-11-04 23:05:17 -0600 (Thu, 04 Nov 2010) | 3 lines


Adding a simple knapsack example to illustrate the difference between
a concrete and abstract model.

........

r3216 | jwatson | 2010-11-05 09:39:19 -0600 (Fri, 05 Nov 2010) | 3 lines


Fixing error diagnostic when indexing a variable with a bad index.

........

r3219 | jwatson | 2010-11-05 16:01:23 -0600 (Fri, 05 Nov 2010) | 3 lines


Supressing a validation test with NumericConstant?. If the user specifies a value, we are (now) assuming it is actually a numeric value - otherwise, the domain check significantly inflates the run-time associated with expression tree creation. This needs to be revisited in the Coopr 2.5 re-write.

........

r3226 | wehart | 2010-11-06 21:32:59 -0600 (Sat, 06 Nov 2010) | 2 lines


Setting up example, which was never converted.

........

r3233 | wehart | 2010-11-12 15:56:28 -0700 (Fri, 12 Nov 2010) | 4 lines


Migrating OS-specific functionality into coopr.os


Adding coopr.os to the dev.ini config file.

........

r3242 | wehart | 2010-11-13 01:28:57 -0700 (Sat, 13 Nov 2010) | 4 lines


Type fix.


Updating error message.

........

r3244 | wehart | 2010-11-13 10:44:26 -0700 (Sat, 13 Nov 2010) | 2 lines


Skipping OSiL writer when not defined.

........

r3246 | wehart | 2010-11-13 10:54:15 -0700 (Sat, 13 Nov 2010) | 2 lines


bug fix.

........

r3247 | wehart | 2010-11-13 11:14:01 -0700 (Sat, 13 Nov 2010) | 2 lines


Bug fix.

........

r3248 | jwatson | 2010-11-17 13:51:47 -0700 (Wed, 17 Nov 2010) | 3 lines


Interim fixes to output of quadratic terms in LP writer - more to do, but at least the basic examples now work.

........

r3254 | jwatson | 2010-11-19 13:19:19 -0700 (Fri, 19 Nov 2010) | 3 lines


Fixed bug in LP writer involving quadratic terms involving two distinct variables. Added two new quadratic examples.

........

r3257 | jwatson | 2010-11-19 13:59:35 -0700 (Fri, 19 Nov 2010) | 3 lines


Fixing diagnostic error message when attempting to solve quadratic programs with GLPK - code for generating message was not syntatically legal.

........

r3268 | jwatson | 2010-12-01 15:08:28 -0700 (Wed, 01 Dec 2010) | 3 lines


Fixing issues with the Piecewise construct when breakpoints and slopes are generated via rules. Works now (on a sample of size 1 - the newly added example5.py) for non-indexed rules, likely broken for indexed breakpoint/slope rules.

........

r3272 | jwatson | 2010-12-02 13:53:51 -0700 (Thu, 02 Dec 2010) | 3 lines


Adding omitted pprint() method for SOS constraints - identified while debugging a piecewise issue.

........

r3274 | jwatson | 2010-12-02 16:32:29 -0700 (Thu, 02 Dec 2010) | 3 lines


Adding example of Piecewise construct using breakpoint and slope rules, as opposed to explicit/direct lists.

........

r3276 | jwatson | 2010-12-03 14:06:40 -0700 (Fri, 03 Dec 2010) | 3 lines


Some progress toward functional indexed Piecewise components.

........

File size: 31.5 KB
Line 
1#
2# Unit Tests for Expression and Related Objects
3#
4# PyomoModel        Base test class
5# TestNumericValue  Class for testing NumericValue()
6#
7
8import os
9import sys
10from os.path import abspath, dirname
11sys.path.insert(0, dirname(dirname(abspath(__file__)))+"/../..")
12currdir = dirname(abspath(__file__))+os.sep
13
14import pyutilib.th as unittest
15from coopr.pyomo import *
16from nose.tools import nottest
17
18class PyomoModel(unittest.TestCase):
19
20    def setUp(self):
21        self.model = Model()
22
23    def construct(self,filename):
24        self.instance = self.model.create(filename)
25
26
27class TestNumericValueBase(PyomoModel):
28
29    def setUp(self):
30        #
31        # Create Model
32        #
33        PyomoModel.setUp(self)
34        #
35        # Create model instance
36        #
37        self.type=NumericConstant
38
39    def tearDown(self):
40        pass
41
42    def create(self,val,domain):
43        tmp=self.type(value=val, domain=domain)
44        return tmp
45
46    @nottest
47    def equal_test(self,exp,val):
48        if isinstance(exp,Expression):
49           self.failUnlessEqual(exp(),val)
50        else:
51           self.failUnlessEqual(exp,val)
52
53    def test_valid_value(self):
54        """Check that values can be validated"""
55        a=self.create(1.3,Reals)
56        a._valid_value(a.value)
57        #b=self.create(1.3,Integers)
58        #b._valid_value(b.value)
59        #print "HERE",type(b),b,b._attr_domain
60        #print "HERE",b.domain
61        #print "HERE", b.value
62        #print "HERE", b.value in b.domain
63        try:
64          b=self.create(1.3,Integers)
65          b._valid_value(b.value)
66        except ValueError:
67          pass
68        else:
69          self.fail("test_valid_value")
70
71    def test_getattr(self):
72        """Check that attributes can be retrieved"""
73        a=self.create(1.3,Reals)
74        try:
75          a.__getattr__("_x")
76        except AttributeError:
77          pass
78        else:
79          self.fail("test_getattr")
80        try:
81          a.__getattr__("x")
82        except AttributeError:
83          pass
84        else:
85          self.fail("test_getattr")
86
87    def Xtest_setattr(self):
88        """Check that attributes can be set"""
89        a=self.create(1.3,Reals)
90        try:
91          a.x=1
92        except AttributeError:
93          pass
94        else:
95          self.fail("test_setattr")
96        a._x=1
97        tmp=a._x
98        a._standard_attr.add("x")
99        a.x=1
100
101    def test_lt(self):
102        a=self.create(1.3,Reals)
103        b=self.create(2.0,Reals)
104        self.equal_test(a<b,True)
105        self.equal_test(a<a,False)
106        self.equal_test(b<a,False)
107        self.equal_test(a<2.0,True)
108        self.equal_test(a<1.3,False)
109        self.equal_test(b<1.3,False)
110        self.equal_test(1.3<b,True)
111        self.equal_test(1.3<a,False)
112        self.equal_test(2.0<a,False)
113
114    def test_gt(self):
115        a=self.create(1.3,Reals)
116        b=self.create(2.0,Reals)
117        self.equal_test(a>b,False)
118        self.equal_test(a>a,False)
119        self.equal_test(b>a,True)
120        self.equal_test(a>2.0,False)
121        self.equal_test(a>1.3,False)
122        self.equal_test(b>1.3,True)
123        self.equal_test(1.3>b,False)
124        self.equal_test(1.3>a,False)
125        self.equal_test(2.0>a,True)
126
127    def test_eq(self):
128        a=self.create(1.3,Reals)
129        b=self.create(2.0,Reals)
130        self.equal_test(a==b,False)
131        self.equal_test(a==a,True)
132        self.equal_test(b==a,False)
133        self.equal_test(a==2.0,False)
134        self.equal_test(a==1.3,True)
135        self.equal_test(b==1.3,False)
136        self.equal_test(1.3==b,False)
137        self.equal_test(1.3==a,True)
138        self.equal_test(2.0==a,False)
139
140    def test_arith(self):
141        a=self.create(0.5,Reals)
142        b=self.create(2.0,Reals)
143        self.equal_test(a-b,-1.5)
144        self.equal_test(a+b,2.5)
145        self.equal_test(a*b,1.0)
146        self.equal_test(b/a,4.0)
147        self.equal_test(a**b,0.25)
148
149        self.equal_test(a-2.0,-1.5)
150        self.equal_test(a+2.0,2.5)
151        self.equal_test(a*2.0,1.0)
152        self.equal_test(b/(0.5),4.0)
153        self.equal_test(a**2.0,0.25)
154
155        self.equal_test(0.5-b,-1.5)
156        self.equal_test(0.5+b,2.5)
157        self.equal_test(0.5*b,1.0)
158        self.equal_test(2.0/a,4.0)
159        self.equal_test((0.5)**b,0.25)
160
161        self.equal_test(-a,-0.5)
162        self.equal_test(+a,0.5)
163        self.equal_test(abs(-a),0.5)
164
165
166
167class TestNumericConstant(TestNumericValueBase):
168
169    def setUp(self):
170        #
171        # Create Model
172        #
173        TestNumericValueBase.setUp(self)
174        #
175        # Create model instance
176        #
177        self.type=NumericConstant
178
179    #def create(self,val,domain):
180        #tmp=self.type(val, domain)
181        #tmp._domain=domain
182        #return tmp
183
184    def test_asnum(self):
185        try:
186            as_numeric(None)
187            self.fail("test_asnum - expected ValueError")
188        except ValueError:
189            pass
190
191
192class TestVarValue(TestNumericValueBase):
193
194    def setUp(self):
195        import coopr.pyomo.base.var
196        #
197        # Create Model
198        #
199        TestNumericValueBase.setUp(self)
200        #
201        # Create model instance
202        #
203        self.type=coopr.pyomo.base.var._VarValue
204
205    def create(self,val,domain):
206        tmp=self.type(name="unknown",domain=domain)
207        tmp.value=val
208        return tmp
209
210
211class TestNumericValue(pyutilib.th.TestCase):
212
213    def test_vals(self):
214        # the following aspect of this test is being removed due to the check seminatics
215        # of a numeric constant requiring far too much run-time, especially when involved
216        # in expression tree construction. if the user specifies a constant, we're assuming
217        # it is correct.
218#        try:
219#            NumericConstant(value='a')
220#            self.fail("Cannot initialize a constant with a non-numeric value")
221#        except ValueError:
222#            pass
223        a = NumericConstant(value=1.1)
224        b = float(a)
225        self.failUnlessEqual(b,1.1)
226        b = int(a)
227        self.failUnlessEqual(b,1)
228
229    def Xtest_getattr1(self):
230        a = NumericConstant(value=1.1)
231        try:
232            a.model
233            self.fail("Expected error")
234        except AttributeError:
235            pass
236
237    def test_ops(self):
238        a = NumericConstant(value=1.1)
239        b = NumericConstant(value=2.2)
240        c = NumericConstant(value=-2.2)
241        a <= b
242        self.failUnlessEqual(a() <= b(), True)
243        self.failUnlessEqual(a() >= b(), False)
244        self.failUnlessEqual(a() == b(), False)
245        self.failUnlessEqual(abs(a() + b()-3.3) <= 1e-7, True)
246        self.failUnlessEqual(abs(b() - a()-1.1) <= 1e-7, True)
247        self.failUnlessEqual(abs(b() * 3-6.6) <= 1e-7, True)
248        self.failUnlessEqual(abs(b() / 2-1.1) <= 1e-7, True)
249        self.failUnlessEqual(abs(abs(-b())-2.2) <= 1e-7, True)
250        self.failUnlessEqual(abs(c()), 2.2)
251        self.failUnlessEqual(str(c), "-2.2")
252
253    def test_expr(self):
254        model = Model()
255        model.a = Var()
256        model.b = Param(initialize=2)
257        instance=model.create()
258        expr = instance.a+1
259        expr = expr-1
260        expr = expr*instance.a
261        expr = expr/instance.a
262        expr = expr**instance.b
263        expr = 1-expr
264        expr = 1+expr
265        expr = 2*expr
266        expr = 2/expr
267        expr = 2**expr
268        expr = - expr
269        expr = + expr
270        expr = abs(expr)
271        OUTPUT=open(currdir+"expr.out","w")
272        expr.pprint(ostream=OUTPUT)
273        expr.simplify(instance)
274        expr.pprint(ostream=OUTPUT)
275        OUTPUT.close()
276        self.failUnlessFileEqualsBaseline(currdir+"expr.out",currdir+"expr.txt")
277
278
279class MiscVarTests(pyutilib.th.TestCase):
280
281    def test_error1(self):
282        a = Var(name="a")
283        try:
284            a = Var(foo=1)
285            self.fail("test_error1")
286        except ValueError:
287            pass
288
289    def test_getattr1(self):
290        """
291        Verify the behavior of non-standard suffixes with simple variable
292        """
293        model = Model()
294        model.a = Var()
295        #try:
296            #model.a.suffix = True
297            #self.fail("Expected AttributeError")
298        #except AttributeError:
299            #pass
300        model.a.declare_attribute("suffix")
301        model.a.declare_attribute("foo",default=False)
302        #try:
303            #
304            # This fails because we don't have an instance
305            #
306            #model.a.suffix = True
307            #self.fail("Expected TypeError")
308        #except TypeError:
309            #pass
310        instance = model.create()
311        self.failUnlessEqual(instance.a.suffix,None)
312        instance.a.suffix = True
313        self.failUnlessEqual(instance.a.suffix,True)
314        self.failUnlessEqual(instance.a.foo,False)
315
316    def test_getattr2(self):
317        """
318        Verify the behavior of non-standard suffixes with an array of variables
319        """
320        model = Model()
321        model.X = Set(initialize=[1,3,5])
322        model.a = Var(model.X)
323        #try:
324            #model.a.suffix = True
325            #self.fail("Expected AttributeError")
326        #except AttributeError:
327            #pass
328        model.a.declare_attribute("suffix")
329        model.a.declare_attribute("foo",default=False)
330        #try:
331            #model.a.suffix = True
332            #self.fail("Expected TypeError")
333        #except TypeError:
334            #pass
335        try:
336            self.failUnlessEqual(model.a.suffix,None)
337            self.fail("Expected AttributeError")
338        except AttributeError:
339            pass
340        instance = model.create()
341        self.failUnlessEqual(instance.a[1].suffix,None)
342        #
343        # Cannot set all suffixes simultaneously
344        #
345        instance.a.suffix = True
346        self.failUnlessEqual(instance.a[1].suffix,None)
347        self.failUnlessEqual(instance.a[3].foo,False)
348
349    def test_error2(self):
350        try:
351            model=Model()
352            model.a = Var(initialize=[1,2,3])
353            model.b = Var(model.a)
354            self.fail("test_error2")
355        except TypeError:
356            pass
357
358    def test_contains(self):
359        model=Model()
360        model.a = Set(initialize=[1,2,3])
361        model.b = Var(model.a)
362        instance = model.create()
363        self.failUnlessEqual(1 in instance.b,True)
364
365    def test_float_int(self):
366        model=Model()
367        model.a = Set(initialize=[1,2,3])
368        model.b = Var(model.a,initialize=1.1)
369        model.c = Var(initialize=2.1)
370        model.d = Var()
371        instance = model.create()
372        instance.reset()
373        self.failUnlessEqual(float(instance.b[1]),1.1)
374        self.failUnlessEqual(int(instance.b[1]),1)
375        self.failUnlessEqual(float(instance.c),2.1)
376        self.failUnlessEqual(int(instance.c),2)
377        try:
378            float(instance.d)
379            self.fail("expected ValueError")
380        except ValueError:
381            pass
382        try:
383            int(instance.d)
384            self.fail("expected ValueError")
385        except ValueError:
386            pass
387        try:
388            float(instance.b)
389            self.fail("expected TypeError")
390        except TypeError:
391            pass
392        try:
393            int(instance.b)
394            self.fail("expected TypeError")
395        except TypeError:
396            pass
397
398    def test_set_get(self):
399        model=Model()
400        model.a = Set(initialize=[1,2,3])
401        model.b = Var(model.a,initialize=1.1,within=PositiveReals)
402        model.c = Var(initialize=2.1, within=PositiveReals)
403        try:
404            model.b = 2.2
405            self.fail("can't set the value of an array variable")
406        except ValueError:
407            pass
408        instance = model.create()
409        try:
410            instance.c[1]=2.2
411            self.fail("can't use an index to set a singleton variable")
412        except KeyError:
413            pass
414        try:
415            instance.b[4]=2.2
416            self.fail("can't set an array variable with a bad index")
417        except KeyError:
418            pass
419        try:
420            instance.b[3] = -2.2
421            #print "HERE",type(instance.b[3])
422            self.fail("can't set an array variable with a bad value")
423        except ValueError:
424            pass
425        try:
426            tmp = instance.c[3]
427            self.fail("can't index a singleton variable")
428        except KeyError:
429            pass
430
431        try:
432            instance.c.set_value('a')
433            self.fail("can't set a bad value for variable c")
434        except ValueError:
435            pass
436        try:
437            instance.c.set_value(-1.0)
438            self.fail("can't set a bad value for variable c")
439        except ValueError:
440            pass
441
442        try:
443            instance.c.initial = 'a'
444            instance.c.reset()
445            self.fail("can't set a bad initial for variable c")
446        except ValueError:
447            pass
448        try:
449            instance.c.initial = -1.0
450            instance.c.reset()
451            self.fail("can't set a bad initial for variable c")
452        except ValueError:
453            pass
454       
455        #try:
456            #instance.c.ub = 'a'
457            #self.fail("can't set a bad ub for variable c")
458        #except ValueError:
459            #pass
460        #try:
461            #instance.c.ub = -1.0
462            #self.fail("can't set a bad ub for variable c")
463        #except ValueError:
464            #pass
465       
466        #try:
467            #instance.c.fixed = 'a'
468            #self.fail("can't fix a variable with a non-boolean")
469        #except ValueError:
470            #pass
471       
472    def test_pprint(self):
473        def c1_rule(model):
474            return (1.0,model.b[1],None)
475        def c2_rule(model):
476            return (None,model.b[1],0.0)
477        def c3_rule(model):
478            return (0.0,model.b[1],1.0)
479        def c4_rule(model):
480            return (3.0,model.b[1])
481        def c5_rule(i,model):
482            return (model.b[i],0.0)
483
484        def c6a_rule(model):
485            return 0.0 <= model.c
486        def c6b_rule(model):
487            return 0.0 < model.c
488        def c7a_rule(model):
489            return model.c <= 1.0
490        def c7b_rule(model):
491            return model.c < 1.0
492        def c8_rule(model):
493            return model.c == 2.0
494        def c9a_rule(model):
495            return model.A+model.A <= model.c
496        def c9b_rule(model):
497            return model.A+model.A < model.c
498        def c10a_rule(model):
499            return model.c <= model.B+model.B
500        def c10b_rule(model):
501            return model.c < model.B+model.B
502        def c11_rule(model):
503            return model.c == model.A+model.B
504        def c15a_rule(model):
505            return model.A <= model.A*model.d
506        def c15b_rule(model):
507            return model.A < model.A*model.d
508        def c16a_rule(model):
509            return model.A*model.d <= model.B
510        def c16b_rule(model):
511            return model.A*model.d < model.B
512
513        def c12_rule(model):
514            return model.c == model.d
515        def c13a_rule(model):
516            return model.c <= model.d
517        def c13b_rule(model):
518            return model.c < model.d
519        def c14a_rule(model):
520            return model.c >= model.d
521        def c14b_rule(model):
522            return model.c > model.d
523
524        #def c20_rule(model):
525            #return model.A > model.c > model.B
526        #def c21_rule(model):
527            #return model.A > model.c < model.B
528        #def c22_rule(model):
529            #return model.A < model.c > model.B
530        #def c23_rule(model):
531            #return model.A < model.c < model.B
532
533        def o2_rule(i,model):
534            return model.b[i]
535        model=Model()
536        model.a = Set(initialize=[1,2,3])
537        model.b = Var(model.a,initialize=1.1,within=PositiveReals)
538        model.c = Var(initialize=2.1, within=PositiveReals)
539        model.d = Var(initialize=3.1, within=PositiveReals)
540        model.e = Var(initialize=4.1, within=PositiveReals)
541        model.A = Param(default=-1)
542        model.B = Param(default=-2)
543        #model.o1 = Objective()
544        model.o2 = Objective(model.a,rule=o2_rule)
545        model.o3 = Objective(model.a,model.a)
546        model.c1 = Constraint(rule=c1_rule)
547        model.c2 = Constraint(rule=c2_rule)
548        model.c3 = Constraint(rule=c3_rule)
549        model.c4 = Constraint(rule=c4_rule)
550        model.c5 = Constraint(model.a,rule=c5_rule)
551
552        model.c6a = Constraint(rule=c6a_rule)
553        model.c6b = Constraint(rule=c6b_rule)
554        model.c7a = Constraint(rule=c7a_rule)
555        model.c7b = Constraint(rule=c7b_rule)
556        model.c8 = Constraint(rule=c8_rule)
557        model.c9a = Constraint(rule=c9a_rule)
558        model.c9b = Constraint(rule=c9b_rule)
559        model.c10a = Constraint(rule=c10a_rule)
560        model.c10b = Constraint(rule=c10b_rule)
561        model.c11 = Constraint(rule=c11_rule)
562        model.c15a = Constraint(rule=c15a_rule)
563        model.c15b = Constraint(rule=c15b_rule)
564        model.c16a = Constraint(rule=c16a_rule)
565        model.c16b = Constraint(rule=c16b_rule)
566
567        model.c12 = Constraint(rule=c12_rule)
568        model.c13a = Constraint(rule=c13a_rule)
569        model.c13b = Constraint(rule=c13b_rule)
570        model.c14a = Constraint(rule=c14a_rule)
571        model.c14b = Constraint(rule=c14b_rule)
572
573        #model.c20 = Constraint(rule=c20_rule)
574        #model.c21 = Constraint(rule=c21_rule)
575        #model.c22 = Constraint(rule=c22_rule)
576        #model.c23 = Constraint(rule=c23_rule)
577
578        instance=model.create()
579        OUTPUT=open(currdir+"varpprint.out","w")
580        instance.pprint(ostream=OUTPUT)
581        OUTPUT.close()
582        self.failUnlessFileEqualsBaseline(currdir+"varpprint.out",currdir+"varpprint.txt")
583
584    def test_expr_error1(self):
585        m = Model()
586        m.A = Set()
587        m.p = Param(m.A)
588        m.q = Param()
589        e = m.q*2
590        try:
591            m.p * 2
592            self.fail("Expected TypeError")
593        except TypeError:
594            pass
595
596
597
598class MiscParamTests(pyutilib.th.TestCase):
599
600    def test_constructor(self):
601        a = Param(name="a")
602        try:
603            b = Param(foo="bar")
604            self.fail("Cannot pass in 'foo' as an option to Param")
605        except ValueError:
606            pass
607        model=Model()
608        model.b = Param(initialize=[1,2,3])
609        try:
610            model.c = Param(model.b)
611            self.fail("Can't index a parameter with a parameter")
612        except TypeError:
613            pass
614        #
615        model = Model()
616        model.a = Param(initialize={None:3.3})
617        instance = model.create()
618
619    def test_get_set(self):
620        model=Model()
621        model.a = Param()
622        model.b = Set(initialize=[1,2,3])
623        model.c = Param(model.b,initialize=2, within=Reals)
624        #try:
625            #model.a.value = 3
626            #self.fail("can't set the value of an unitialized parameter")
627        #except AttributeError:
628            #pass
629        try:
630            model.a.construct()
631            self.fail("Can't construct a parameter without data")
632        except ValueError:
633            pass
634        model.a = Param(initialize=2)
635        instance=model.create()
636        instance.a.value=3
637        #try:
638            #instance.a.default='2'
639            #self.fail("can't set a bad default value")
640        #except ValueError:
641            #pass
642        self.failUnlessEqual(2 in instance.c, True)
643
644        try:
645            instance.a[1] = 3
646            self.fail("can't index a singleton parameter")
647        except KeyError:
648            pass
649        try:
650            instance.c[4] = 3
651            self.fail("can't index a parameter with a bad index")
652        except KeyError:
653            pass
654        try:
655            instance.c[3] = 'a'
656            self.fail("can't set a parameter with a bad value")
657        except ValueError:
658            pass
659
660    def test_iter(self):
661        model=Model()
662        model.b = Set(initialize=[1,2,3])
663        model.c = Param(model.b,initialize=2)
664        instance = model.create()
665        for i in instance.c:
666            self.failUnlessEqual(i in instance.c, True)
667
668    def test_valid(self):
669        def d_valid(a,model):
670            return True
671        def e_valid(a,i,j,model):
672            return True
673        model=Model()
674        model.b = Set(initialize=[1,3,5])
675        model.c = Param(initialize=2, within=None)
676        model.d = Param(initialize=(2,3), validate=d_valid)
677        model.e = Param(model.b,model.b,initialize={(1,1):(2,3)}, validate=e_valid)
678        instance = model.create()
679        instance.e.check_values()
680        #try:
681            #instance.c.value = 'b'
682            #self.fail("can't have a non-numerical parameter")
683        #except ValueError:
684            #pass
685
686    def test_expr_error1(self):
687        m = Model()
688        m.A = Set()
689        m.p = Param(m.A)
690        m.q = Param()
691        e = m.q*2
692        try:
693            m.p*2
694            self.fail("Expected TypeError")
695        except TypeError:
696            pass
697
698
699class MiscExprTests(pyutilib.th.TestCase):
700
701    def setUp(self):
702        def d_fn(model):
703            return model.c+model.c
704        self.model=Model()
705        self.model.a = Var(initialize=1.0)
706        self.model.b = Var(initialize=2.0)
707        self.model.c = Param(initialize=0)
708        self.model.d = Param(initialize=d_fn)
709        self.instance= self.model.create()
710
711    def test_lt(self):
712        expr = self.instance.a < self.instance.b
713        self.instance.reset()
714        self.failUnlessEqual(expr(),True)
715
716    def test_lte(self):
717        expr = self.instance.a <= self.instance.b
718        self.instance.reset()
719        self.failUnlessEqual(expr(),True)
720
721    def test_gt(self):
722        expr = self.instance.a > self.instance.b
723        self.instance.reset()
724        self.failUnlessEqual(expr(),False)
725
726    def test_gte(self):
727        expr = self.instance.a >= self.instance.b
728        self.instance.reset()
729        self.failUnlessEqual(expr(),False)
730
731    def test_eq(self):
732        expr = self.instance.a == self.instance.b
733        self.instance.reset()
734        self.failUnlessEqual(expr(),False)
735
736    def test_minus(self):
737        expr = self.instance.a - self.instance.b
738        self.instance.reset()
739        self.failUnlessEqual(expr(),-1)
740
741    def test_division(self):
742        expr = self.instance.a / self.instance.b
743        self.instance.reset()
744        self.failUnlessEqual(expr(),0.5)
745
746    def test_negate(self):
747        expr = - self.instance.a
748        self.instance.reset()
749        self.failUnlessEqual(expr(),-1)
750
751    def test_prod(self):
752        OUTPUT=open(currdir+"test_prod.out","w")
753        expr = self.model.a * self.model.a * self.model.a
754        expr.pprint(ostream=OUTPUT)
755        expr = expr.simplify(self.model)
756        expr.pprint(ostream=OUTPUT)
757
758        expr = expr*0
759        expr.pprint(ostream=OUTPUT)
760        expr = expr.simplify(self.model)
761        expr.pprint(ostream=OUTPUT)
762        OUTPUT.close()
763        self.failUnlessFileEqualsBaseline(currdir+"test_prod.out",currdir+"test_prod.txt")
764
765
766class MiscObjTests(pyutilib.th.TestCase):
767
768    def test_constructor(self):
769        a = Objective(name="b")
770        self.failUnlessEqual(a.name,"b")
771        try:
772            a = Objective(foo="bar")
773            self.fail("Can't specify an unexpected constructor option")
774        except ValueError:
775            pass
776
777    def test_contains(self):
778        model=Model()
779        model.a=Set(initialize=[1,2,3])
780        model.x=Var()
781        def b_rule(i,model):
782            return model.x
783        model.b=Objective(model.a, rule=b_rule)
784        instance=model.create()
785        self.failUnlessEqual(2 in instance.b,True)
786        tmp=[]
787        for i in instance.b:
788          tmp.append(i)
789        self.failUnlessEqual(len(tmp),3)
790
791    def test_set_get(self):
792        a = Objective()
793        #try:
794            #a.value = 1
795            #self.fail("Can't set value attribute")
796        #except AttributeError:
797            #pass
798        self.failUnlessEqual(a(),None)
799        #
800        model=Model()
801        model.x = Var(initialize=1)
802        model.y = Var(initialize=2)
803        model.obj = Objective()
804        model.obj._data[None].expr = model.x+model.y
805        instance = model.create()
806        instance.reset()
807        self.failUnlessEqual(instance.obj(),3)
808
809    def test_rule(self):
810        def rule1(model):
811            return None
812        model=Model()
813        model.o = Objective(rule=rule1)
814        try:
815            instance=model.create()
816            self.fail("Error generating objective")
817        except Exception:
818            pass
819        #
820        def rule1(model):
821            return 1.1
822        model=Model()
823        model.o = Objective(rule=rule1)
824        instance=model.create()
825        self.failUnlessEqual(instance.o(),1.1)
826        #
827        def rule1(i,model):
828            return 1.1
829        model=Model()
830        model.a=Set(initialize=[1,2,3])
831        model.o = Objective(model.a,rule=rule1)
832        instance=model.create()
833        try:
834            instance=model.create()
835        except Exception:
836            self.fail("Error generating objective")
837       
838
839class MiscConTests(pyutilib.th.TestCase):
840
841    def test_constructor(self):
842        a = Constraint(name="b")
843        self.failUnlessEqual(a.name,"b")
844        try:
845            a = Constraint(foo="bar")
846            self.fail("Can't specify an unexpected constructor option")
847        except ValueError:
848            pass
849
850    def test_contains(self):
851        model=Model()
852        model.a=Set(initialize=[1,2,3])
853        model.b=Constraint(model.a)
854        instance=model.create()
855        self.failUnlessEqual(2 in instance.b,False)
856        tmp=[]
857        for i in instance.b:
858          tmp.append(i)
859        self.failUnlessEqual(len(tmp),0)
860
861    def test_set_get(self):
862        a = Constraint()
863        #try:
864            #a.value = 1
865            #self.fail("Can't set value attribute")
866        #except AttributeError:
867            #pass
868        self.failUnlessEqual(a(),None)
869
870    def test_rule(self):
871        def rule1(model):
872            return None
873        model=Model()
874        model.o = Constraint(rule=rule1)
875        instance=model.create()
876        try:
877            instance=model.create()
878        except Exception, e:
879            self.fail("Failure to create empty constraint: %s" % str(e))
880        #
881        def rule1(model):
882            return (0.0,model.x,2.0)
883        model=Model()
884        model.x = Var(initialize=1.1)
885        model.o = Constraint(rule=rule1)
886        instance=model.create()
887        instance.reset()
888        self.failUnlessEqual(instance.o(),1.1)
889        #
890        def rule1(i,model):
891            return None
892        model=Model()
893        model.a=Set(initialize=[1,2,3])
894        model.o = Constraint(model.a,rule=rule1)
895        try:
896            instance=model.create()
897        except Exception:
898            self.fail("Error generating empty objective")
899        #
900        def rule1(model):
901            return (0.0,1.1,2.0,None)
902        model=Model()
903        model.o = Constraint(rule=rule1)
904        try:
905            instance=model.create()
906            self.fail("Can only return tuples of length 2 or 3")
907        except ValueError:
908            pass
909       
910    def test_constructor_coverage(self):
911        def rule1(model):
912            return (0.0,model.x)
913        model=Model()
914        model.x = Var()
915        model.y = Var()
916        model.z = Var()
917        model.o = Constraint(rule=rule1)
918        instance=model.create()
919        #
920        def rule1(model):
921            return (model.y,model.x,model.z)
922        model=Model()
923        model.x = Var()
924        model.y = Var()
925        model.z = Var()
926        model.o = Constraint(rule=rule1)
927        instance=model.create()
928        #
929        def rule1(model):
930            expr=model.x
931            expr = expr == 0.0
932            expr = expr > 1.0
933            return expr
934        model=Model()
935        model.x = Var()
936        model.y = Var()
937        model.z = Var()
938        model.o = Constraint(rule=rule1)
939        try:
940            instance=model.create()
941            self.fail("bad constraint formulation")
942        except ValueError:
943            pass
944        #
945        def rule1(model):
946            expr = model.U >= model.x
947            expr = expr >= model.L
948            return expr
949        model=Model()
950        model.x = Var()
951        model.L = Param(initialize=0)
952        model.U = Param(initialize=1)
953        model.o = Constraint(rule=rule1)
954        instance=model.create()
955        #
956        def rule1(model):
957            expr = model.x <= model.z
958            expr = expr >= model.y
959            return expr
960        model=Model()
961        model.x = Var()
962        model.y = Var()
963        model.z = Var()
964        model.o = Constraint(rule=rule1)
965        instance=model.create()
966        #
967        def rule1(model):
968            expr = model.x >= model.z
969            expr = model.y >= expr
970            return expr
971        model=Model()
972        model.x = Var()
973        model.y = Var()
974        model.z = Var()
975        model.o = Constraint(rule=rule1)
976        instance=model.create()
977        #
978        def rule1(model):
979            expr = model.y <= model.x
980            expr = model.y >= expr
981            return expr
982        model=Model()
983        model.x = Var()
984        model.y = Var()
985        model.o = Constraint(rule=rule1)
986        instance=model.create()
987        #
988        def rule1(model):
989            expr = model.x >= model.L
990            return expr
991        model=Model()
992        model.x = Var()
993        model.L = Param(initialize=0)
994        model.o = Constraint(rule=rule1)
995        instance=model.create()
996        #
997        def rule1(model):
998            expr = model.U >= model.x
999            return expr
1000        model=Model()
1001        model.x = Var()
1002        model.U = Param(initialize=0)
1003        model.o = Constraint(rule=rule1)
1004        instance=model.create()
1005
1006        #
1007        def rule1(model):
1008            expr=model.x
1009            expr = expr == 0.0
1010            expr = expr < 1.0
1011            return expr
1012        model=Model()
1013        model.x = Var()
1014        model.y = Var()
1015        model.z = Var()
1016        model.o = Constraint(rule=rule1)
1017        try:
1018            instance=model.create()
1019            self.fail("bad constraint formulation")
1020        except ValueError:
1021            pass
1022        #
1023        def rule1(model):
1024            expr = model.U <= model.x
1025            expr = expr <= model.L
1026            return expr
1027        model=Model()
1028        model.x = Var()
1029        model.L = Param(initialize=0)
1030        model.U = Param(initialize=1)
1031        model.o = Constraint(rule=rule1)
1032        instance=model.create()
1033        #
1034        def rule1(model):
1035            expr = model.x >= model.z
1036            expr = expr <= model.y
1037            return expr
1038        model=Model()
1039        model.x = Var()
1040        model.y = Var()
1041        model.z = Var()
1042        model.o = Constraint(rule=rule1)
1043        instance=model.create()
1044        #
1045        def rule1(model):
1046            expr = model.x <= model.z
1047            expr = model.y <= expr
1048            return expr
1049        model=Model()
1050        model.x = Var()
1051        model.y = Var()
1052        model.z = Var()
1053        model.o = Constraint(rule=rule1)
1054        instance=model.create()
1055        #
1056        def rule1(model):
1057            expr = model.y >= model.x
1058            expr = model.y <= expr
1059            return expr
1060        model=Model()
1061        model.x = Var()
1062        model.y = Var()
1063        model.o = Constraint(rule=rule1)
1064        instance=model.create()
1065        #
1066        def rule1(model):
1067            expr = model.x <= model.L
1068            return expr
1069        model=Model()
1070        model.x = Var()
1071        model.L = Param(initialize=0)
1072        model.o = Constraint(rule=rule1)
1073        instance=model.create()
1074        #
1075        def rule1(model):
1076            expr = model.U <= model.x
1077            return expr
1078        model=Model()
1079        model.x = Var()
1080        model.U = Param(initialize=0)
1081        model.o = Constraint(rule=rule1)
1082        instance=model.create()
1083
1084        #
1085        def rule1(model):
1086            return model.x+model.x
1087        model=Model()
1088        model.x = Var()
1089        model.o = Constraint(rule=rule1)
1090        try:
1091            instance=model.create()
1092            self.fail("Cannot return an unbounded expression")
1093        except ValueError:
1094            pass
1095        #
1096       
1097
1098if __name__ == "__main__":
1099   unittest.main()
Note: See TracBrowser for help on using the repository browser.