source: trunk/test/pyomo/unit/test_expr.py @ 1768

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

Rework of Coopr to use the new PyUtilib? package decomposition.

NOTE: to use Coopr with this update, we need to work with a new version of coopr_install.

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