source: coopr.pyomo/stable/2.3/coopr/pyomo/tests/unit/test_expr.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: 31.2 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        try:
215            NumericConstant(value='a')
216            self.fail("Cannot initialize a constant with a non-numeric value")
217        except ValueError:
218            pass
219        a = NumericConstant(value=1.1)
220        b = float(a)
221        self.failUnlessEqual(b,1.1)
222        b = int(a)
223        self.failUnlessEqual(b,1)
224
225    def Xtest_getattr1(self):
226        a = NumericConstant(value=1.1)
227        try:
228            a.model
229            self.fail("Expected error")
230        except AttributeError:
231            pass
232
233    def test_ops(self):
234        a = NumericConstant(value=1.1)
235        b = NumericConstant(value=2.2)
236        c = NumericConstant(value=-2.2)
237        a <= b
238        self.failUnlessEqual(a() <= b(), True)
239        self.failUnlessEqual(a() >= b(), False)
240        self.failUnlessEqual(a() == b(), False)
241        self.failUnlessEqual(abs(a() + b()-3.3) <= 1e-7, True)
242        self.failUnlessEqual(abs(b() - a()-1.1) <= 1e-7, True)
243        self.failUnlessEqual(abs(b() * 3-6.6) <= 1e-7, True)
244        self.failUnlessEqual(abs(b() / 2-1.1) <= 1e-7, True)
245        self.failUnlessEqual(abs(abs(-b())-2.2) <= 1e-7, True)
246        self.failUnlessEqual(abs(c()), 2.2)
247        self.failUnlessEqual(str(c), "-2.2")
248
249    def test_expr(self):
250        model = Model()
251        model.a = Var()
252        model.b = Param(initialize=2)
253        instance=model.create()
254        expr = instance.a+1
255        expr = expr-1
256        expr = expr*instance.a
257        expr = expr/instance.a
258        expr = expr**instance.b
259        expr = 1-expr
260        expr = 1+expr
261        expr = 2*expr
262        expr = 2/expr
263        expr = 2**expr
264        expr = - expr
265        expr = + expr
266        expr = abs(expr)
267        OUTPUT=open(currdir+"expr.out","w")
268        expr.pprint(ostream=OUTPUT)
269        expr.simplify(instance)
270        expr.pprint(ostream=OUTPUT)
271        OUTPUT.close()
272        self.failUnlessFileEqualsBaseline(currdir+"expr.out",currdir+"expr.txt")
273
274
275class MiscVarTests(pyutilib.th.TestCase):
276
277    def test_error1(self):
278        a = Var(name="a")
279        try:
280            a = Var(foo=1)
281            self.fail("test_error1")
282        except ValueError:
283            pass
284
285    def test_getattr1(self):
286        """
287        Verify the behavior of non-standard suffixes with simple variable
288        """
289        model = Model()
290        model.a = Var()
291        #try:
292            #model.a.suffix = True
293            #self.fail("Expected AttributeError")
294        #except AttributeError:
295            #pass
296        model.a.declare_attribute("suffix")
297        model.a.declare_attribute("foo",default=False)
298        #try:
299            #
300            # This fails because we don't have an instance
301            #
302            #model.a.suffix = True
303            #self.fail("Expected TypeError")
304        #except TypeError:
305            #pass
306        instance = model.create()
307        self.failUnlessEqual(instance.a.suffix,None)
308        instance.a.suffix = True
309        self.failUnlessEqual(instance.a.suffix,True)
310        self.failUnlessEqual(instance.a.foo,False)
311
312    def test_getattr2(self):
313        """
314        Verify the behavior of non-standard suffixes with an array of variables
315        """
316        model = Model()
317        model.X = Set(initialize=[1,3,5])
318        model.a = Var(model.X)
319        #try:
320            #model.a.suffix = True
321            #self.fail("Expected AttributeError")
322        #except AttributeError:
323            #pass
324        model.a.declare_attribute("suffix")
325        model.a.declare_attribute("foo",default=False)
326        #try:
327            #model.a.suffix = True
328            #self.fail("Expected TypeError")
329        #except TypeError:
330            #pass
331        try:
332            self.failUnlessEqual(model.a.suffix,None)
333            self.fail("Expected AttributeError")
334        except AttributeError:
335            pass
336        instance = model.create()
337        self.failUnlessEqual(instance.a[1].suffix,None)
338        #
339        # Cannot set all suffixes simultaneously
340        #
341        instance.a.suffix = True
342        self.failUnlessEqual(instance.a[1].suffix,None)
343        self.failUnlessEqual(instance.a[3].foo,False)
344
345    def test_error2(self):
346        try:
347            model=Model()
348            model.a = Var(initialize=[1,2,3])
349            model.b = Var(model.a)
350            self.fail("test_error2")
351        except ValueError:
352            pass
353
354    def test_contains(self):
355        model=Model()
356        model.a = Set(initialize=[1,2,3])
357        model.b = Var(model.a)
358        instance = model.create()
359        self.failUnlessEqual(1 in instance.b,True)
360
361    def test_float_int(self):
362        model=Model()
363        model.a = Set(initialize=[1,2,3])
364        model.b = Var(model.a,initialize=1.1)
365        model.c = Var(initialize=2.1)
366        model.d = Var()
367        instance = model.create()
368        instance.reset()
369        self.failUnlessEqual(float(instance.b[1]),1.1)
370        self.failUnlessEqual(int(instance.b[1]),1)
371        self.failUnlessEqual(float(instance.c),2.1)
372        self.failUnlessEqual(int(instance.c),2)
373        try:
374            float(instance.d)
375            self.fail("expected ValueError")
376        except ValueError:
377            pass
378        try:
379            int(instance.d)
380            self.fail("expected ValueError")
381        except ValueError:
382            pass
383        try:
384            float(instance.b)
385            self.fail("expected TypeError")
386        except TypeError:
387            pass
388        try:
389            int(instance.b)
390            self.fail("expected TypeError")
391        except TypeError:
392            pass
393
394    def test_set_get(self):
395        model=Model()
396        model.a = Set(initialize=[1,2,3])
397        model.b = Var(model.a,initialize=1.1,within=PositiveReals)
398        model.c = Var(initialize=2.1, within=PositiveReals)
399        try:
400            model.b = 2.2
401            self.fail("can't set the value of an array variable")
402        except ValueError:
403            pass
404        instance = model.create()
405        try:
406            instance.c[1]=2.2
407            self.fail("can't use an index to set a singleton variable")
408        except KeyError:
409            pass
410        try:
411            instance.b[4]=2.2
412            self.fail("can't set an array variable with a bad index")
413        except KeyError:
414            pass
415        try:
416            instance.b[3] = -2.2
417            #print "HERE",type(instance.b[3])
418            self.fail("can't set an array variable with a bad value")
419        except ValueError:
420            pass
421        try:
422            tmp = instance.c[3]
423            self.fail("can't index a singleton variable")
424        except KeyError:
425            pass
426
427        try:
428            instance.c.set_value('a')
429            self.fail("can't set a bad value for variable c")
430        except ValueError:
431            pass
432        try:
433            instance.c.set_value(-1.0)
434            self.fail("can't set a bad value for variable c")
435        except ValueError:
436            pass
437
438        try:
439            instance.c.initial = 'a'
440            instance.c.reset()
441            self.fail("can't set a bad initial for variable c")
442        except ValueError:
443            pass
444        try:
445            instance.c.initial = -1.0
446            instance.c.reset()
447            self.fail("can't set a bad initial for variable c")
448        except ValueError:
449            pass
450       
451        #try:
452            #instance.c.ub = 'a'
453            #self.fail("can't set a bad ub for variable c")
454        #except ValueError:
455            #pass
456        #try:
457            #instance.c.ub = -1.0
458            #self.fail("can't set a bad ub for variable c")
459        #except ValueError:
460            #pass
461       
462        #try:
463            #instance.c.fixed = 'a'
464            #self.fail("can't fix a variable with a non-boolean")
465        #except ValueError:
466            #pass
467       
468    def test_pprint(self):
469        def c1_rule(model):
470            return (1.0,model.b[1],None)
471        def c2_rule(model):
472            return (None,model.b[1],0.0)
473        def c3_rule(model):
474            return (0.0,model.b[1],1.0)
475        def c4_rule(model):
476            return (3.0,model.b[1])
477        def c5_rule(i,model):
478            return (model.b[i],0.0)
479
480        def c6a_rule(model):
481            return 0.0 <= model.c
482        def c6b_rule(model):
483            return 0.0 < model.c
484        def c7a_rule(model):
485            return model.c <= 1.0
486        def c7b_rule(model):
487            return model.c < 1.0
488        def c8_rule(model):
489            return model.c == 2.0
490        def c9a_rule(model):
491            return model.A+model.A <= model.c
492        def c9b_rule(model):
493            return model.A+model.A < model.c
494        def c10a_rule(model):
495            return model.c <= model.B+model.B
496        def c10b_rule(model):
497            return model.c < model.B+model.B
498        def c11_rule(model):
499            return model.c == model.A+model.B
500        def c15a_rule(model):
501            return model.A <= model.A*model.d
502        def c15b_rule(model):
503            return model.A < model.A*model.d
504        def c16a_rule(model):
505            return model.A*model.d <= model.B
506        def c16b_rule(model):
507            return model.A*model.d < model.B
508
509        def c12_rule(model):
510            return model.c == model.d
511        def c13a_rule(model):
512            return model.c <= model.d
513        def c13b_rule(model):
514            return model.c < model.d
515        def c14a_rule(model):
516            return model.c >= model.d
517        def c14b_rule(model):
518            return model.c > model.d
519
520        #def c20_rule(model):
521            #return model.A > model.c > model.B
522        #def c21_rule(model):
523            #return model.A > model.c < model.B
524        #def c22_rule(model):
525            #return model.A < model.c > model.B
526        #def c23_rule(model):
527            #return model.A < model.c < model.B
528
529        def o2_rule(i,model):
530            return model.b[i]
531        model=Model()
532        model.a = Set(initialize=[1,2,3])
533        model.b = Var(model.a,initialize=1.1,within=PositiveReals)
534        model.c = Var(initialize=2.1, within=PositiveReals)
535        model.d = Var(initialize=3.1, within=PositiveReals)
536        model.e = Var(initialize=4.1, within=PositiveReals)
537        model.A = Param(default=-1)
538        model.B = Param(default=-2)
539        #model.o1 = Objective()
540        model.o2 = Objective(model.a,rule=o2_rule)
541        model.o3 = Objective(model.a,model.a)
542        model.c1 = Constraint(rule=c1_rule)
543        model.c2 = Constraint(rule=c2_rule)
544        model.c3 = Constraint(rule=c3_rule)
545        model.c4 = Constraint(rule=c4_rule)
546        model.c5 = Constraint(model.a,rule=c5_rule)
547
548        model.c6a = Constraint(rule=c6a_rule)
549        model.c6b = Constraint(rule=c6b_rule)
550        model.c7a = Constraint(rule=c7a_rule)
551        model.c7b = Constraint(rule=c7b_rule)
552        model.c8 = Constraint(rule=c8_rule)
553        model.c9a = Constraint(rule=c9a_rule)
554        model.c9b = Constraint(rule=c9b_rule)
555        model.c10a = Constraint(rule=c10a_rule)
556        model.c10b = Constraint(rule=c10b_rule)
557        model.c11 = Constraint(rule=c11_rule)
558        model.c15a = Constraint(rule=c15a_rule)
559        model.c15b = Constraint(rule=c15b_rule)
560        model.c16a = Constraint(rule=c16a_rule)
561        model.c16b = Constraint(rule=c16b_rule)
562
563        model.c12 = Constraint(rule=c12_rule)
564        model.c13a = Constraint(rule=c13a_rule)
565        model.c13b = Constraint(rule=c13b_rule)
566        model.c14a = Constraint(rule=c14a_rule)
567        model.c14b = Constraint(rule=c14b_rule)
568
569        #model.c20 = Constraint(rule=c20_rule)
570        #model.c21 = Constraint(rule=c21_rule)
571        #model.c22 = Constraint(rule=c22_rule)
572        #model.c23 = Constraint(rule=c23_rule)
573
574        instance=model.create()
575        OUTPUT=open(currdir+"varpprint.out","w")
576        instance.pprint(ostream=OUTPUT)
577        OUTPUT.close()
578        self.failUnlessFileEqualsBaseline(currdir+"varpprint.out",currdir+"varpprint.txt")
579
580    def test_expr_error1(self):
581        m = Model()
582        m.A = Set()
583        m.p = Param(m.A)
584        m.q = Param()
585        e = m.q*2
586        try:
587            m.p * 2
588            self.fail("Expected TypeError")
589        except TypeError:
590            pass
591
592
593
594class MiscParamTests(pyutilib.th.TestCase):
595
596    def test_constructor(self):
597        a = Param(name="a")
598        try:
599            b = Param(foo="bar")
600            self.fail("Cannot pass in 'foo' as an option to Param")
601        except ValueError:
602            pass
603        model=Model()
604        model.b = Param(initialize=[1,2,3])
605        try:
606            model.c = Param(model.b)
607            self.fail("Can't index a parameter with a parameter")
608        except ValueError:
609            pass
610        #
611        model = Model()
612        model.a = Param(initialize={None:3.3})
613        instance = model.create()
614
615    def test_get_set(self):
616        model=Model()
617        model.a = Param()
618        model.b = Set(initialize=[1,2,3])
619        model.c = Param(model.b,initialize=2, within=Reals)
620        #try:
621            #model.a.value = 3
622            #self.fail("can't set the value of an unitialized parameter")
623        #except AttributeError:
624            #pass
625        try:
626            model.a.construct()
627            self.fail("Can't construct a parameter without data")
628        except ValueError:
629            pass
630        model.a = Param(initialize=2)
631        instance=model.create()
632        instance.a.value=3
633        #try:
634            #instance.a.default='2'
635            #self.fail("can't set a bad default value")
636        #except ValueError:
637            #pass
638        self.failUnlessEqual(2 in instance.c, True)
639
640        try:
641            instance.a[1] = 3
642            self.fail("can't index a singleton parameter")
643        except KeyError:
644            pass
645        try:
646            instance.c[4] = 3
647            self.fail("can't index a parameter with a bad index")
648        except KeyError:
649            pass
650        try:
651            instance.c[3] = 'a'
652            self.fail("can't set a parameter with a bad value")
653        except ValueError:
654            pass
655
656    def test_iter(self):
657        model=Model()
658        model.b = Set(initialize=[1,2,3])
659        model.c = Param(model.b,initialize=2)
660        instance = model.create()
661        for i in instance.c:
662            self.failUnlessEqual(i in instance.c, True)
663
664    def test_valid(self):
665        def d_valid(a,model):
666            return True
667        def e_valid(a,i,j,model):
668            return True
669        model=Model()
670        model.b = Set(initialize=[1,3,5])
671        model.c = Param(initialize=2, within=None)
672        model.d = Param(initialize=(2,3), validate=d_valid)
673        model.e = Param(model.b,model.b,initialize={(1,1):(2,3)}, validate=e_valid)
674        instance = model.create()
675        instance.e.check_values()
676        #try:
677            #instance.c.value = 'b'
678            #self.fail("can't have a non-numerical parameter")
679        #except ValueError:
680            #pass
681
682    def test_expr_error1(self):
683        m = Model()
684        m.A = Set()
685        m.p = Param(m.A)
686        m.q = Param()
687        e = m.q*2
688        try:
689            m.p*2
690            self.fail("Expected TypeError")
691        except TypeError:
692            pass
693
694
695class MiscExprTests(pyutilib.th.TestCase):
696
697    def setUp(self):
698        def d_fn(model):
699            return model.c+model.c
700        self.model=Model()
701        self.model.a = Var(initialize=1.0)
702        self.model.b = Var(initialize=2.0)
703        self.model.c = Param(initialize=0)
704        self.model.d = Param(initialize=d_fn)
705        self.instance= self.model.create()
706
707    def test_lt(self):
708        expr = self.instance.a < self.instance.b
709        self.instance.reset()
710        self.failUnlessEqual(expr(),True)
711
712    def test_lte(self):
713        expr = self.instance.a <= self.instance.b
714        self.instance.reset()
715        self.failUnlessEqual(expr(),True)
716
717    def test_gt(self):
718        expr = self.instance.a > self.instance.b
719        self.instance.reset()
720        self.failUnlessEqual(expr(),False)
721
722    def test_gte(self):
723        expr = self.instance.a >= self.instance.b
724        self.instance.reset()
725        self.failUnlessEqual(expr(),False)
726
727    def test_eq(self):
728        expr = self.instance.a == self.instance.b
729        self.instance.reset()
730        self.failUnlessEqual(expr(),False)
731
732    def test_minus(self):
733        expr = self.instance.a - self.instance.b
734        self.instance.reset()
735        self.failUnlessEqual(expr(),-1)
736
737    def test_division(self):
738        expr = self.instance.a / self.instance.b
739        self.instance.reset()
740        self.failUnlessEqual(expr(),0.5)
741
742    def test_negate(self):
743        expr = - self.instance.a
744        self.instance.reset()
745        self.failUnlessEqual(expr(),-1)
746
747    def test_prod(self):
748        OUTPUT=open(currdir+"test_prod.out","w")
749        expr = self.model.a * self.model.a * self.model.a
750        expr.pprint(ostream=OUTPUT)
751        expr = expr.simplify(self.model)
752        expr.pprint(ostream=OUTPUT)
753
754        expr = expr*0
755        expr.pprint(ostream=OUTPUT)
756        expr = expr.simplify(self.model)
757        expr.pprint(ostream=OUTPUT)
758        OUTPUT.close()
759        self.failUnlessFileEqualsBaseline(currdir+"test_prod.out",currdir+"test_prod.txt")
760
761
762class MiscObjTests(pyutilib.th.TestCase):
763
764    def test_constructor(self):
765        a = Objective(name="b")
766        self.failUnlessEqual(a.name,"b")
767        try:
768            a = Objective(foo="bar")
769            self.fail("Can't specify an unexpected constructor option")
770        except ValueError:
771            pass
772
773    def test_contains(self):
774        model=Model()
775        model.a=Set(initialize=[1,2,3])
776        model.x=Var()
777        def b_rule(i,model):
778            return model.x
779        model.b=Objective(model.a, rule=b_rule)
780        instance=model.create()
781        self.failUnlessEqual(2 in instance.b,True)
782        tmp=[]
783        for i in instance.b:
784          tmp.append(i)
785        self.failUnlessEqual(len(tmp),3)
786
787    def test_set_get(self):
788        a = Objective()
789        #try:
790            #a.value = 1
791            #self.fail("Can't set value attribute")
792        #except AttributeError:
793            #pass
794        self.failUnlessEqual(a(),None)
795        #
796        model=Model()
797        model.x = Var(initialize=1)
798        model.y = Var(initialize=2)
799        model.obj = Objective()
800        model.obj._data[None].expr = model.x+model.y
801        instance = model.create()
802        instance.reset()
803        self.failUnlessEqual(instance.obj(),3)
804
805    def test_rule(self):
806        def rule1(model):
807            return None
808        model=Model()
809        model.o = Objective(rule=rule1)
810        try:
811            instance=model.create()
812            self.fail("Error generating objective")
813        except Exception:
814            pass
815        #
816        def rule1(model):
817            return 1.1
818        model=Model()
819        model.o = Objective(rule=rule1)
820        instance=model.create()
821        self.failUnlessEqual(instance.o(),1.1)
822        #
823        def rule1(i,model):
824            return 1.1
825        model=Model()
826        model.a=Set(initialize=[1,2,3])
827        model.o = Objective(model.a,rule=rule1)
828        instance=model.create()
829        try:
830            instance=model.create()
831        except Exception:
832            self.fail("Error generating objective")
833       
834
835class MiscConTests(pyutilib.th.TestCase):
836
837    def test_constructor(self):
838        a = Constraint(name="b")
839        self.failUnlessEqual(a.name,"b")
840        try:
841            a = Constraint(foo="bar")
842            self.fail("Can't specify an unexpected constructor option")
843        except ValueError:
844            pass
845
846    def test_contains(self):
847        model=Model()
848        model.a=Set(initialize=[1,2,3])
849        model.b=Constraint(model.a)
850        instance=model.create()
851        self.failUnlessEqual(2 in instance.b,False)
852        tmp=[]
853        for i in instance.b:
854          tmp.append(i)
855        self.failUnlessEqual(len(tmp),0)
856
857    def test_set_get(self):
858        a = Constraint()
859        #try:
860            #a.value = 1
861            #self.fail("Can't set value attribute")
862        #except AttributeError:
863            #pass
864        self.failUnlessEqual(a(),None)
865
866    def test_rule(self):
867        def rule1(model):
868            return None
869        model=Model()
870        model.o = Constraint(rule=rule1)
871        instance=model.create()
872        try:
873            instance=model.create()
874        except Exception, e:
875            self.fail("Failure to create empty constraint: %s" % str(e))
876        #
877        def rule1(model):
878            return (0.0,model.x,2.0)
879        model=Model()
880        model.x = Var(initialize=1.1)
881        model.o = Constraint(rule=rule1)
882        instance=model.create()
883        instance.reset()
884        self.failUnlessEqual(instance.o(),1.1)
885        #
886        def rule1(i,model):
887            return None
888        model=Model()
889        model.a=Set(initialize=[1,2,3])
890        model.o = Constraint(model.a,rule=rule1)
891        try:
892            instance=model.create()
893        except Exception:
894            self.fail("Error generating empty objective")
895        #
896        def rule1(model):
897            return (0.0,1.1,2.0,None)
898        model=Model()
899        model.o = Constraint(rule=rule1)
900        try:
901            instance=model.create()
902            self.fail("Can only return tuples of length 2 or 3")
903        except ValueError:
904            pass
905       
906    def test_constructor_coverage(self):
907        def rule1(model):
908            return (0.0,model.x)
909        model=Model()
910        model.x = Var()
911        model.y = Var()
912        model.z = Var()
913        model.o = Constraint(rule=rule1)
914        instance=model.create()
915        #
916        def rule1(model):
917            return (model.y,model.x,model.z)
918        model=Model()
919        model.x = Var()
920        model.y = Var()
921        model.z = Var()
922        model.o = Constraint(rule=rule1)
923        instance=model.create()
924        #
925        def rule1(model):
926            expr=model.x
927            expr = expr == 0.0
928            expr = expr > 1.0
929            return expr
930        model=Model()
931        model.x = Var()
932        model.y = Var()
933        model.z = Var()
934        model.o = Constraint(rule=rule1)
935        try:
936            instance=model.create()
937            self.fail("bad constraint formulation")
938        except ValueError:
939            pass
940        #
941        def rule1(model):
942            expr = model.U >= model.x
943            expr = expr >= model.L
944            return expr
945        model=Model()
946        model.x = Var()
947        model.L = Param(initialize=0)
948        model.U = Param(initialize=1)
949        model.o = Constraint(rule=rule1)
950        instance=model.create()
951        #
952        def rule1(model):
953            expr = model.x <= model.z
954            expr = expr >= model.y
955            return expr
956        model=Model()
957        model.x = Var()
958        model.y = Var()
959        model.z = Var()
960        model.o = Constraint(rule=rule1)
961        instance=model.create()
962        #
963        def rule1(model):
964            expr = model.x >= model.z
965            expr = model.y >= expr
966            return expr
967        model=Model()
968        model.x = Var()
969        model.y = Var()
970        model.z = Var()
971        model.o = Constraint(rule=rule1)
972        instance=model.create()
973        #
974        def rule1(model):
975            expr = model.y <= model.x
976            expr = model.y >= expr
977            return expr
978        model=Model()
979        model.x = Var()
980        model.y = Var()
981        model.o = Constraint(rule=rule1)
982        instance=model.create()
983        #
984        def rule1(model):
985            expr = model.x >= model.L
986            return expr
987        model=Model()
988        model.x = Var()
989        model.L = Param(initialize=0)
990        model.o = Constraint(rule=rule1)
991        instance=model.create()
992        #
993        def rule1(model):
994            expr = model.U >= model.x
995            return expr
996        model=Model()
997        model.x = Var()
998        model.U = Param(initialize=0)
999        model.o = Constraint(rule=rule1)
1000        instance=model.create()
1001
1002        #
1003        def rule1(model):
1004            expr=model.x
1005            expr = expr == 0.0
1006            expr = expr < 1.0
1007            return expr
1008        model=Model()
1009        model.x = Var()
1010        model.y = Var()
1011        model.z = Var()
1012        model.o = Constraint(rule=rule1)
1013        try:
1014            instance=model.create()
1015            self.fail("bad constraint formulation")
1016        except ValueError:
1017            pass
1018        #
1019        def rule1(model):
1020            expr = model.U <= model.x
1021            expr = expr <= model.L
1022            return expr
1023        model=Model()
1024        model.x = Var()
1025        model.L = Param(initialize=0)
1026        model.U = Param(initialize=1)
1027        model.o = Constraint(rule=rule1)
1028        instance=model.create()
1029        #
1030        def rule1(model):
1031            expr = model.x >= model.z
1032            expr = expr <= model.y
1033            return expr
1034        model=Model()
1035        model.x = Var()
1036        model.y = Var()
1037        model.z = Var()
1038        model.o = Constraint(rule=rule1)
1039        instance=model.create()
1040        #
1041        def rule1(model):
1042            expr = model.x <= model.z
1043            expr = model.y <= expr
1044            return expr
1045        model=Model()
1046        model.x = Var()
1047        model.y = Var()
1048        model.z = Var()
1049        model.o = Constraint(rule=rule1)
1050        instance=model.create()
1051        #
1052        def rule1(model):
1053            expr = model.y >= model.x
1054            expr = model.y <= expr
1055            return expr
1056        model=Model()
1057        model.x = Var()
1058        model.y = Var()
1059        model.o = Constraint(rule=rule1)
1060        instance=model.create()
1061        #
1062        def rule1(model):
1063            expr = model.x <= model.L
1064            return expr
1065        model=Model()
1066        model.x = Var()
1067        model.L = Param(initialize=0)
1068        model.o = Constraint(rule=rule1)
1069        instance=model.create()
1070        #
1071        def rule1(model):
1072            expr = model.U <= model.x
1073            return expr
1074        model=Model()
1075        model.x = Var()
1076        model.U = Param(initialize=0)
1077        model.o = Constraint(rule=rule1)
1078        instance=model.create()
1079
1080        #
1081        def rule1(model):
1082            return model.x+model.x
1083        model=Model()
1084        model.x = Var()
1085        model.o = Constraint(rule=rule1)
1086        try:
1087            instance=model.create()
1088            self.fail("Cannot return an unbounded expression")
1089        except ValueError:
1090            pass
1091        #
1092       
1093
1094if __name__ == "__main__":
1095   unittest.main()
Note: See TracBrowser for help on using the repository browser.