source: trunk/test/pyomo/unit/test_model.py @ 1663

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

Misc changes in test that reflect (a) the move of coopr.core to
coopr.opt and (b) refinement of test failure management when PICO is
available but not pico_convert.

File size: 39.2 KB
Line 
1#
2# Unit Tests for Elements of a Model
3#
4# TestSimpleVar                Class for testing single variables
5# TestArrayVar                Class for testing array of variables
6# TestSimpleObj                Class for testing single objective
7# TestArrayObj                Class for testing array of objective
8# TestSimpleCon                Class for testing single constraint
9# TestArrayCon                Class for testing array of constraint
10# TestModel             Class to test the Model class
11#
12
13import unittest
14import os
15import sys
16from os.path import abspath, dirname
17sys.path.insert(0, dirname(dirname(abspath(__file__)))+os.sep+".."+os.sep+"..")
18currdir = dirname(abspath(__file__))+os.sep
19
20from coopr.pyomo.base import IntegerSet
21from coopr.pyomo import *
22from coopr.opt import *
23from coopr.pyomo.base.var import _VarElement
24import pyutilib_th
25
26class PyomoModel(pyutilib_th.TestCase):
27
28    def setUp(self):
29        self.model = Model()
30
31    def construct(self,filename):
32        self.instance = self.model.create(filename)
33
34
35class TestSimpleVar(PyomoModel):
36
37    def setUp(self):
38        #
39        # Create Model
40        #
41        PyomoModel.setUp(self)
42
43    def tearDown(self):
44        pass
45
46    def test_fixed_attr(self):
47        """Test fixed attribute"""
48        self.model.x = Var()
49        self.instance = self.model.create()
50        self.instance.x.fixed = True
51        self.failUnlessEqual(self.instance.x.fixed, True)
52
53    def test_value_attr(self):
54        """Test value attribute"""
55        self.model.x = Var()
56        self.instance = self.model.create()
57        self.instance.x.value = 3.5
58        self.failUnlessEqual(self.instance.x.value, 3.5)
59
60    def test_initial_attr(self):
61        """Test initial attribute"""
62        self.model.x = Var()
63        self.instance = self.model.create()
64        self.instance.x.initial = 3.5
65        self.failUnlessEqual(self.instance.x.initial, 3.5)
66
67    def test_domain_attr(self):
68        """Test domain attribute"""
69        self.model.x = Var()
70        self.instance = self.model.create()
71        self.instance.x.domain = Integers
72        self.failUnlessEqual(type(self.instance.x.domain), IntegerSet)
73
74    def test_name_attr(self):
75        """Test name attribute"""
76        #
77        # A user would never need to do this, but this
78        # attribute is needed within Pyomo
79        #
80        self.model.x = Var()
81        self.model.x.name = "foo"
82        self.failUnlessEqual(self.model.x.name, "foo")
83
84    def test_lb_attr1(self):
85        """Test lb attribute"""
86        self.model.x = Var()
87        self.instance = self.model.create()
88        self.instance.x.lb = -1.0
89        self.failUnlessEqual(self.instance.x.lb, -1.0)
90
91    def test_lb_attr2(self):
92        """Test lb attribute"""
93        self.model.x = Var(within=NonNegativeReals, bounds=(-1,2))
94        self.instance = self.model.create()
95        self.failUnlessEqual(self.instance.x.lb, 0.0)
96        self.failUnlessEqual(self.instance.x.ub, 2.0)
97
98    def test_ub_attr1(self):
99        """Test ub attribute"""
100        self.model.x = Var()
101        self.instance = self.model.create()
102        self.instance.x.ub = 1.0
103        self.failUnlessEqual(self.instance.x.ub, 1.0)
104
105    def test_ub_attr2(self):
106        """Test ub attribute"""
107        self.model.x = Var(within=NonPositiveReals, bounds=(-2,1))
108        self.instance = self.model.create()
109        self.failUnlessEqual(self.instance.x.lb, -2.0)
110        self.failUnlessEqual(self.instance.x.ub, 0.0)
111
112    def test_within_option(self):
113        """Test within option"""
114        self.model.x = Var(within=Integers)
115        self.failUnlessEqual(type(self.model.x.domain), IntegerSet)
116
117    def test_initialize_option(self):
118        """Test initialize option"""
119        self.model.x = Var(initialize=1.3)
120        self.instance = self.model.create()
121        self.failUnlessEqual(self.instance.x.initial, 1.3)
122
123    def test_bounds_option1(self):
124        """Test bounds option"""
125        def x_bounds(model):
126          return (-1.0,1.0)
127        self.model.x = Var(bounds=x_bounds)
128        self.instance = self.model.create()
129        self.failUnlessEqual(self.instance.x.lb, -1.0)
130        self.failUnlessEqual(self.instance.x.ub, 1.0)
131
132    def test_bounds_option2(self):
133        """Test bounds option"""
134        self.model.x = Var(bounds=(-1.0,1.0))
135        self.instance = self.model.create()
136        self.failUnlessEqual(self.instance.x.lb, -1.0)
137        self.failUnlessEqual(self.instance.x.ub, 1.0)
138
139    def test_rule_option(self):
140        """Test rule option"""
141        def x_init(model):
142          return 1.3
143        self.model.x = Var(initialize=x_init)
144        self.instance = self.model.create()
145        self.failUnlessEqual(self.instance.x.value, None)
146        self.failUnlessEqual(self.instance.x.initial, 1.3)
147
148    def test_reset(self):
149        """Test reset method"""
150        self.model.x = Var(initialize=3)
151        self.instance = self.model.create()
152        self.failUnlessEqual(self.instance.x.initial,3)
153        self.failUnlessEqual(self.instance.x.value,None)
154        self.instance.x.reset()
155        self.failUnlessEqual(self.instance.x.initial,3)
156        self.failUnlessEqual(self.instance.x.initial,3)
157
158    def test_dim(self):
159        """Test dim method"""
160        self.model.x = Var()
161        self.instance = self.model.create()
162        self.failUnlessEqual(self.instance.x.dim(),0)
163
164    def test_keys(self):
165        """Test keys method"""
166        self.model.x = Var()
167        self.instance = self.model.create()
168        self.failUnlessEqual(self.instance.x.keys(),[None])
169
170    def test_len(self):
171        """Test len method"""
172        self.model.x = Var()
173        self.instance = self.model.create()
174        self.failUnlessEqual(len(self.instance.x),1)
175
176    def test_simplify(self):
177        """Test simplify method"""
178        self.model.x = Var()
179        self.failUnlessEqual(type(self.model.x.simplify(self.model)),_VarElement)
180
181    def test_value(self):
182        """Check the value of the variable"""
183        self.model.x = Var(initialize=3.3)
184        self.instance = self.model.create()
185        tmp = value(self.instance.x.initial)
186        self.failUnlessEqual( type(tmp), float)
187        self.failUnlessEqual( tmp, 3.3 )
188        tmp = float(self.instance.x.initial)
189        self.failUnlessEqual( type(tmp), float)
190        self.failUnlessEqual( tmp, 3.3 )
191        tmp = int(self.instance.x.initial)
192        self.failUnlessEqual( type(tmp), int)
193        self.failUnlessEqual( tmp, 3 )
194
195
196class TestArrayVar(TestSimpleVar):
197
198    def setUp(self):
199        #
200        # Create Model
201        #
202        PyomoModel.setUp(self)
203        self.model.A = Set(initialize=[1,2])
204
205    def test_fixed_attr(self):
206        """Test fixed attribute"""
207        self.model.x = Var(self.model.A)
208        self.model.y = Var(self.model.A)
209        self.instance = self.model.create()
210        self.instance.x.fixed = True
211        #try:
212          #self.instance.x.fixed
213        #except AttributeError:
214          #pass
215        #else:
216          #self.fail("test_fixed_attr")
217        self.failUnlessEqual(self.instance.x[1].fixed, False)
218        self.instance.y[1].fixed=True
219        self.failUnlessEqual(self.instance.y[1].fixed, True)
220
221    def test_value_attr(self):
222        """Test value attribute"""
223        self.model.x = Var(self.model.A)
224        self.model.y = Var(self.model.A)
225        self.instance = self.model.create()
226        try:
227            self.instance.x = 3.5
228            self.fail("Expected ValueError")
229        except ValueError:
230            pass
231        self.instance.y[1] = 3.5
232        self.failUnlessEqual(self.instance.y[1], 3.5)
233
234    #def test_initial_attr(self):
235        #"""Test initial attribute"""
236        #self.model.x = Var(self.model.A)
237        #self.instance = self.model.create()
238        #self.instance.x.initial = 3.5
239        #self.failUnlessEqual(self.instance.x[1].initial, 3.5)
240
241    #def test_lb_attr(self):
242        #"""Test lb attribute"""
243        #self.model.x = Var(self.model.A)
244        #self.instance = self.model.create()
245        #self.instance.x.lb = -1.0
246        #self.failUnlessEqual(self.instance.x[1].lb, -1.0)
247
248    #def test_ub_attr(self):
249        #"""Test ub attribute"""
250        #self.model.x = Var(self.model.A)
251        #self.instance = self.model.create()
252        #self.instance.x.ub = 1.0
253        #self.failUnlessEqual(self.instance.x[1].ub, 1.0)
254
255    def test_initialize_option(self):
256        """Test initialize option"""
257        self.model.x = Var(self.model.A,initialize={1:1.3,2:2.3})
258        self.instance = self.model.create()
259        self.failUnlessEqual(self.instance.x[1], 1.3)
260        self.failUnlessEqual(self.instance.x[2], 2.3)
261
262    def test_bounds_option1(self):
263        """Test bounds option"""
264        def x_bounds(i,model):
265          return (-1.0,1.0)
266        self.model.x = Var(self.model.A, bounds=x_bounds)
267        self.instance = self.model.create()
268        self.failUnlessEqual(self.instance.x[1].lb, -1.0)
269        self.failUnlessEqual(self.instance.x[1].ub, 1.0)
270
271    def test_bounds_option2(self):
272        """Test bounds option"""
273        self.model.x = Var(self.model.A, bounds=(-1.0,1.0))
274        self.instance = self.model.create()
275        self.failUnlessEqual(self.instance.x[1].lb, -1.0)
276        self.failUnlessEqual(self.instance.x[1].ub, 1.0)
277
278    def test_rule_option(self):
279        """Test rule option"""
280        def x_init(i,model):
281          return 1.3
282        self.model.x = Var(self.model.A, initialize=x_init)
283        self.instance = self.model.create()
284        self.failUnlessEqual(self.instance.x[1].initial, 1.3)
285
286    def test_reset(self):
287        """Test reset method"""
288        self.model.x = Var(self.model.A,initialize=3)
289        self.instance = self.model.create()
290        self.failUnlessEqual(self.instance.x[1].initial,3)
291        self.failUnlessEqual(self.instance.x[1].value,None)
292        self.instance.x.reset()
293        self.failUnlessEqual(self.instance.x[1].initial,3)
294        self.failUnlessEqual(self.instance.x[1].initial,3)
295
296    def test_dim(self):
297        """Test dim method"""
298        self.model.x = Var(self.model.A)
299        self.instance = self.model.create()
300        self.failUnlessEqual(self.instance.x.dim(),1)
301
302    def test_keys(self):
303        """Test keys method"""
304        self.model.x = Var(self.model.A)
305        self.instance = self.model.create()
306        self.failUnlessEqual(self.instance.x.keys(),[1,2])
307
308    def test_len(self):
309        """Test len method"""
310        self.model.x = Var(self.model.A)
311        self.instance = self.model.create()
312        self.failUnlessEqual(len(self.instance.x),2)
313
314    def test_value(self):
315        """Check the value of the variable"""
316        self.model.x = Var(self.model.A,initialize=3.3)
317        self.instance = self.model.create()
318        tmp = value(self.instance.x[1].initial)
319        self.failUnlessEqual( type(tmp), float)
320        self.failUnlessEqual( tmp, 3.3 )
321        tmp = float(self.instance.x[1].initial)
322        self.failUnlessEqual( type(tmp), float)
323        self.failUnlessEqual( tmp, 3.3 )
324        tmp = int(self.instance.x[1].initial)
325        self.failUnlessEqual( type(tmp), int)
326        self.failUnlessEqual( tmp, 3 )
327
328
329class Test2DArrayVar(TestSimpleVar):
330
331    def setUp(self):
332        #
333        # Create Model
334        #
335        PyomoModel.setUp(self)
336        self.model.A = Set(initialize=[1,2])
337
338    def test_fixed_attr(self):
339        """Test fixed attribute"""
340        self.model.x = Var(self.model.A,self.model.A)
341        self.model.y = Var(self.model.A,self.model.A)
342        self.instance = self.model.create()
343        self.instance.x.fixed = True
344        #try:
345          #self.instance.x.fixed
346        #except AttributeError:
347          #pass
348        #else:
349          #self.fail("test_fixed_attr")
350        self.failUnlessEqual(self.instance.x[1,2].fixed, False)
351        self.instance.y[1,2].fixed=True
352        self.failUnlessEqual(self.instance.y[1,2].fixed, True)
353
354    def test_value_attr(self):
355        """Test value attribute"""
356        self.model.x = Var(self.model.A,self.model.A)
357        self.model.y = Var(self.model.A,self.model.A)
358        self.instance = self.model.create()
359        try:
360            self.instance.x = 3.5
361            self.fail("Expected ValueError")
362        except ValueError:
363            pass
364        self.instance.y[1,2] = 3.5
365        self.failUnlessEqual(self.instance.y[1,2], 3.5)
366
367    #def test_initial_attr(self):
368        #"""Test initial attribute"""
369        #self.model.x = Var(self.model.A,self.model.A)
370        #self.instance = self.model.create()
371        #self.instance.x.initial = 3.5
372        #self.failUnlessEqual(self.instance.x[1,1].initial, 3.5)
373
374    #def test_lb_attr(self):
375        #"""Test lb attribute"""
376        #self.model.x = Var(self.model.A,self.model.A)
377        #self.instance = self.model.create()
378        #self.instance.x.lb = -1.0
379        #self.failUnlessEqual(self.instance.x[2,1].lb, -1.0)
380
381    #def test_ub_attr(self):
382        #"""Test ub attribute"""
383        #self.model.x = Var(self.model.A,self.model.A)
384        #self.instance = self.model.create()
385        #self.instance.x.ub = 1.0
386        #self.failUnlessEqual(self.instance.x[2,1].ub, 1.0)
387
388    def test_initialize_option(self):
389        """Test initialize option"""
390        self.model.x = Var(self.model.A,self.model.A,initialize={(1,1):1.3,(2,2):2.3})
391        self.instance = self.model.create()
392        self.failUnlessEqual(self.instance.x[1,1], 1.3)
393        self.failUnlessEqual(self.instance.x[2,2], 2.3)
394        try:
395            value(self.instance.x[1,2])
396            self.fail("Expected KeyError")
397        except KeyError:
398            pass
399
400    def test_bounds_option1(self):
401        """Test bounds option"""
402        def x_bounds(i,j,model):
403          return (-1.0*(i+j),1.0*(i+j))
404        self.model.x = Var(self.model.A, self.model.A, bounds=x_bounds)
405        self.instance = self.model.create()
406        self.failUnlessEqual(self.instance.x[1,1].lb, -2.0)
407        self.failUnlessEqual(self.instance.x[1,2].ub, 3.0)
408
409    def test_bounds_option2(self):
410        """Test bounds option"""
411        self.model.x = Var(self.model.A, self.model.A, bounds=(-1.0,1.0))
412        self.instance = self.model.create()
413        self.failUnlessEqual(self.instance.x[1,1].lb, -1.0)
414        self.failUnlessEqual(self.instance.x[1,1].ub, 1.0)
415
416    def test_rule_option(self):
417        """Test rule option"""
418        def x_init(i,j,model):
419          return 1.3
420        self.model.x = Var(self.model.A, self.model.A, initialize=x_init)
421        self.instance = self.model.create()
422        self.failUnlessEqual(self.instance.x[1,2].initial, 1.3)
423
424    def test_reset(self):
425        """Test reset method"""
426        self.model.x = Var(self.model.A,self.model.A, initialize=3)
427        self.instance = self.model.create()
428        self.failUnlessEqual(self.instance.x[1,1].initial,3)
429        self.failUnlessEqual(self.instance.x[1,1].value,None)
430        self.instance.x.reset()
431        self.failUnlessEqual(self.instance.x[1,1].initial,3)
432        self.failUnlessEqual(self.instance.x[1,1].initial,3)
433
434    def test_dim(self):
435        """Test dim method"""
436        self.model.x = Var(self.model.A,self.model.A)
437        self.instance = self.model.create()
438        self.failUnlessEqual(self.instance.x.dim(),2)
439
440    def test_keys(self):
441        """Test keys method"""
442        self.model.x = Var(self.model.A,self.model.A)
443        self.instance = self.model.create()
444        ans = [(1,1),(1,2),(2,1),(2,2)]
445        self.failUnlessEqual(self.instance.x.keys().sort(),ans.sort())
446
447    def test_len(self):
448        """Test len method"""
449        self.model.x = Var(self.model.A,self.model.A)
450        self.instance = self.model.create()
451        self.failUnlessEqual(len(self.instance.x),4)
452
453    def test_value(self):
454        """Check the value of the variable"""
455        self.model.x = Var(self.model.A,self.model.A,initialize=3.3)
456        self.instance = self.model.create()
457        tmp = value(self.instance.x[1,1].initial)
458        self.failUnlessEqual( type(tmp), float)
459        self.failUnlessEqual( tmp, 3.3 )
460        tmp = float(self.instance.x[1,1].initial)
461        self.failUnlessEqual( type(tmp), float)
462        self.failUnlessEqual( tmp, 3.3 )
463        tmp = int(self.instance.x[1,1].initial)
464        self.failUnlessEqual( type(tmp), int)
465        self.failUnlessEqual( tmp, 3 )
466
467
468class TestSimpleObj(PyomoModel):
469
470    def setUp(self):
471        #
472        # Create Model
473        #
474        PyomoModel.setUp(self)
475
476    def tearDown(self):
477        pass
478
479    def test_rule_option(self):
480        """Test rule option"""
481        def f(model):
482          ans=0
483          for i in model.x.keys():
484            ans = ans + model.x[i]
485          return ans
486        self.model.x = Var(RangeSet(1,4),initialize=2)
487        self.model.obj = Objective(rule=f)
488        self.instance = self.model.create()
489        try:
490          self.failUnlessEqual(self.instance.obj(), 8)
491        except ValueError:
492          pass
493        else:
494          self.fail("test_rule_option")
495        self.instance.x.reset()
496        self.failUnlessEqual(self.instance.obj(), 8)
497        self.failUnlessEqual(value(self.instance.obj), 8)
498
499    def test_sense_option(self):
500        """Test sense option"""
501        def rule(model):
502            return 1.0
503        self.model.obj = Objective(sense=maximize, rule=rule)
504        self.instance = self.model.create()
505        self.failUnlessEqual(self.instance.obj.sense, maximize)
506
507    def test_dim(self):
508        """Test dim method"""
509        def rule(model):
510            return 1
511        self.model.obj = Objective(rule=rule)
512        self.instance = self.model.create()
513        self.failUnlessEqual(self.instance.obj.dim(),0)
514
515    def test_keys(self):
516        """Test keys method"""
517        def rule(model):
518            return 1
519        self.model.obj = Objective(rule=rule)
520        self.instance = self.model.create()
521        self.failUnlessEqual(self.instance.obj.keys(),[None])
522
523    def test_len(self):
524        """Test len method"""
525        def rule(model):
526            return 1.0
527        self.model.obj = Objective(rule=rule)
528        self.instance = self.model.create()
529        self.failUnlessEqual(len(self.instance.obj),1)
530        """Test rule option"""
531        def f(model):
532          ans=0
533          for i in model.x.keys():
534            ans = ans + model.x[i]
535          return ans
536        self.model.x = Var(RangeSet(1,4),initialize=2)
537        self.model.obj = Objective(rule=f)
538        self.instance = self.model.create()
539        self.failUnlessEqual(len(self.instance.obj),1)
540
541
542class TestArrayObj(PyomoModel):
543
544    def setUp(self):
545        #
546        # Create Model
547        #
548        PyomoModel.setUp(self)
549        self.model.A = Set(initialize=[1,2])
550
551    def tearDown(self):
552        pass
553
554    def test_rule_option(self):
555        """Test rule option"""
556        def f(i,model):
557          ans=0
558          for j in model.x.keys():
559            ans = ans + model.x[j]
560          ans *= i
561          return ans
562        self.model.x = Var(RangeSet(1,4),initialize=2)
563        self.model.obj = Objective(self.model.A,rule=f)
564        self.instance = self.model.create()
565        try:
566            self.instance.obj[1]()
567            self.fail("Excepted ValueError due to uninitialized variables")
568        except ValueError:
569            pass
570        self.instance.x.reset()
571        self.failUnlessEqual(self.instance.obj[1](), 8)
572        self.failUnlessEqual(self.instance.obj[2](), 16)
573        self.failUnlessEqual(value(self.instance.obj[1]), 8)
574        self.failUnlessEqual(value(self.instance.obj[2]), 16)
575
576    def test_sense_option(self):
577        """Test sense option"""
578        self.model.obj = Objective(self.model.A,sense=maximize)
579        self.instance = self.model.create()
580        self.failUnlessEqual(self.instance.obj.sense, maximize)
581
582    def test_dim(self):
583        """Test dim method"""
584        self.model.obj = Objective(self.model.A)
585        self.instance = self.model.create()
586        self.failUnlessEqual(self.instance.obj.dim(),1)
587
588    def test_keys(self):
589        """Test keys method"""
590        self.model.obj = Objective(self.model.A)
591        self.instance = self.model.create()
592        self.failUnlessEqual(len(self.instance.obj.keys()),2)
593
594    def test_len(self):
595        """Test len method"""
596        self.model.obj = Objective(self.model.A)
597        self.instance = self.model.create()
598        self.failUnlessEqual(len(self.instance.obj),0)
599        """Test rule option"""
600        def f(model):
601          ans=0
602          for i in model.x.keys():
603            ans = ans + model.x[i]
604          return ans
605        self.model.x = Var(RangeSet(1,4),initialize=2)
606        self.model.obj = Objective(rule=f)
607        self.instance = self.model.create()
608        self.failUnlessEqual(len(self.instance.obj),1)
609
610
611class Test2DArrayObj(PyomoModel):
612
613    def setUp(self):
614        #
615        # Create Model
616        #
617        PyomoModel.setUp(self)
618        self.model.A = Set(initialize=[1,2])
619
620    def tearDown(self):
621        pass
622
623    def test_rule_option(self):
624        """Test rule option"""
625        def f(i,k,model):
626          ans=0
627          for j in model.x.keys():
628            ans = ans + model.x[j]
629          ans *= i
630          return ans
631        self.model.x = Var(RangeSet(1,4),initialize=2)
632        self.model.obj = Objective(self.model.A,self.model.A, rule=f)
633        self.instance = self.model.create()
634        try:
635            self.failUnlessEqual(self.instance.obj(),None)
636            self.fail("Expected ValueError")
637        except ValueError:
638            pass
639        self.instance.x.reset()
640        self.failUnlessEqual(self.instance.obj[1,1](), 8)
641        self.failUnlessEqual(self.instance.obj[2,1](), 16)
642        self.failUnlessEqual(value(self.instance.obj[1,1]), 8)
643        self.failUnlessEqual(value(self.instance.obj[2,1]), 16)
644
645    def test_sense_option(self):
646        """Test sense option"""
647        self.model.obj = Objective(self.model.A,self.model.A,sense=maximize)
648        self.instance = self.model.create()
649        self.failUnlessEqual(self.instance.obj.sense, maximize)
650
651    def test_dim(self):
652        """Test dim method"""
653        self.model.obj = Objective(self.model.A,self.model.A)
654        self.instance = self.model.create()
655        self.failUnlessEqual(self.instance.obj.dim(),2)
656
657    def test_keys(self):
658        """Test keys method"""
659        self.model.obj = Objective(self.model.A,self.model.A)
660        self.instance = self.model.create()
661        self.failUnlessEqual(len(self.instance.obj.keys()),4)
662
663    def test_len(self):
664        """Test len method"""
665        self.model.obj = Objective(self.model.A,self.model.A)
666        self.instance = self.model.create()
667        self.failUnlessEqual(len(self.instance.obj),0)
668        """Test rule option"""
669        def f(model):
670          ans=0
671          for i in model.x.keys():
672            ans = ans + model.x[i]
673          return ans
674        self.model.x = Var(RangeSet(1,4),initialize=2)
675        self.model.obj = Objective(rule=f)
676        self.instance = self.model.create()
677        self.failUnlessEqual(len(self.instance.obj),1)
678
679
680class TestSimpleCon(PyomoModel):
681
682    def setUp(self):
683        #
684        # Create Model
685        #
686        PyomoModel.setUp(self)
687
688    def tearDown(self):
689        pass
690
691    def test_rule1(self):
692        """Test rule option"""
693        def f(model):
694          ans=0
695          for i in model.x.keys():
696            ans = ans + model.x[i]
697          ans = ans >= 0
698          ans = ans <= 1
699          return ans
700        self.model.x = Var(RangeSet(1,4),initialize=2)
701        self.model.c = Constraint(rule=f)
702        self.instance = self.model.create()
703        try:
704          self.failUnlessEqual(self.instance.c(), 8)
705        except ValueError:
706          pass
707        else:
708          self.fail("test_rule_option")
709        self.instance.x.reset()
710        self.failUnlessEqual(self.instance.c(), 8)
711        self.failUnlessEqual(value(self.instance.c), 8)
712
713    def test_rule2(self):
714        """Test rule option"""
715        def f(model):
716          ans=0
717          for i in model.x.keys():
718            ans = ans + model.x[i]
719          return (0,ans,1)
720        self.model.x = Var(RangeSet(1,4),initialize=2)
721        self.model.c = Constraint(rule=f)
722        self.instance = self.model.create()
723        try:
724          self.failUnlessEqual(self.instance.c(), 8)
725        except ValueError:
726          pass
727        else:
728          self.fail("test_rule_option")
729        self.instance.x.reset()
730        self.failUnlessEqual(self.instance.c(), 8)
731        self.failUnlessEqual(value(self.instance.c), 8)
732
733    def test_rule3(self):
734        """Test rule option"""
735        def f(model):
736          ans=0
737          for i in model.x.keys():
738            ans = ans + model.x[i]
739          return (0,ans,None)
740        self.model.x = Var(RangeSet(1,4),initialize=2)
741        self.model.c = Constraint(rule=f)
742        self.instance = self.model.create()
743        try:
744          self.failUnlessEqual(self.instance.c(), 8)
745        except ValueError:
746          pass
747        else:
748          self.fail("test_rule_option")
749        self.instance.x.reset()
750        self.failUnlessEqual(self.instance.c(), 8)
751        self.failUnlessEqual(value(self.instance.c), 8)
752
753    def test_rule4(self):
754        """Test rule option"""
755        def f(model):
756          ans=0
757          for i in model.x.keys():
758            ans = ans + model.x[i]
759          return (None,ans,1)
760        self.model.x = Var(RangeSet(1,4),initialize=2)
761        self.model.c = Constraint(rule=f)
762        self.instance = self.model.create()
763        try:
764          self.failUnlessEqual(self.instance.c(), 8)
765        except ValueError:
766          pass
767        else:
768          self.fail("test_rule_option")
769        self.instance.x.reset()
770        self.failUnlessEqual(self.instance.c(), 8)
771        self.failUnlessEqual(value(self.instance.c), 8)
772
773    def test_rule5(self):
774        """Test rule option"""
775        def f(model):
776          ans=0
777          for i in model.x.keys():
778            ans = ans + model.x[i]
779          return (ans,1)
780        self.model.x = Var(RangeSet(1,4),initialize=2)
781        self.model.c = Constraint(rule=f)
782        self.instance = self.model.create()
783        try:
784          self.failUnlessEqual(self.instance.c(), 8)
785        except ValueError:
786          pass
787        else:
788          self.fail("test_rule_option")
789        self.instance.x.reset()
790        self.failUnlessEqual(self.instance.c(), 8)
791        self.failUnlessEqual(value(self.instance.c), 8)
792
793    def test_dim(self):
794        """Test dim method"""
795        self.model.c = Constraint()
796        self.instance = self.model.create()
797        self.failUnlessEqual(self.instance.c.dim(),0)
798
799    def test_keys(self):
800        """Test keys method"""
801        self.model.c = Constraint()
802        self.instance = self.model.create()
803        self.failUnlessEqual(self.instance.c.keys(),[])
804
805    def test_len(self):
806        """Test len method"""
807        self.model.c = Constraint()
808        self.instance = self.model.create()
809        self.failUnlessEqual(len(self.instance.c),0)
810        """Test rule option"""
811        def f(model):
812          ans=0
813          for i in model.x.keys():
814            ans = ans + model.x[i]
815          ans = ans == 0
816          return ans
817        self.model.x = Var(RangeSet(1,4),initialize=2)
818        self.model.c = Constraint(rule=f)
819        self.instance = self.model.create()
820        self.failUnlessEqual(len(self.instance.c),1)
821
822
823class TestArrayCon(PyomoModel):
824
825    def setUp(self):
826        #
827        # Create Model
828        #
829        PyomoModel.setUp(self)
830        self.model.A = Set(initialize=[1,2,3,4])
831
832    def tearDown(self):
833        pass
834
835    def test_rule_option1(self):
836        """Test rule option"""
837        def f(i,model):
838          ans=0
839          for j in model.x.keys():
840            ans = ans + model.x[j]
841          ans *= i
842          ans = ans < 0
843          ans = ans > 0
844          return ans
845        self.model.x = Var(RangeSet(1,4),initialize=2)
846        self.model.c = Constraint(self.model.A,rule=f)
847        self.instance = self.model.create()
848        try:
849            self.instance.c[1]()
850            self.fail("Expected ValueError")
851        except ValueError:
852            pass
853        self.instance.x.reset()
854        self.failUnlessEqual(self.instance.c[1](), 8)
855        self.failUnlessEqual(self.instance.c[2](), 16)
856        self.failUnlessEqual(value(self.instance.c[1]), 8)
857        self.failUnlessEqual(value(self.instance.c[2]), 16)
858        self.failUnlessEqual(len(self.instance.c), 4)
859
860    def test_rule_option2(self):
861        """Test rule option"""
862        def f(i,model):
863          if i%2 == 0:
864                return 0
865          ans=0
866          for j in model.x.keys():
867            ans = ans + model.x[j]
868          ans *= i
869          ans = ans < 0
870          ans = ans > 0
871          return ans
872        self.model.x = Var(RangeSet(1,4),initialize=2)
873        self.model.c = Constraint(self.model.A,rule=f)
874        self.instance = self.model.create()
875        try:
876            self.instance.c[1]()
877            self.fail("Expected ValueError")
878        except ValueError:
879            pass
880        self.instance.x.reset()
881        self.failUnlessEqual(self.instance.c[1](), 8)
882        self.failUnlessEqual(value(self.instance.c[1]), 8)
883        self.failUnlessEqual(len(self.instance.c), 2)
884
885    def test_rule_option3(self):
886        """Test rule option"""
887        def f(i,model):
888          if i%2 == 0:
889                return None
890          ans=0
891          for j in model.x.keys():
892            ans = ans + model.x[j]
893          ans *= i
894          ans = ans < 0
895          ans = ans > 0
896          return ans
897        self.model.x = Var(RangeSet(1,4),initialize=2)
898        self.model.c = Constraint(self.model.A,rule=f)
899        self.instance = self.model.create()
900        try:
901            self.instance.c[1]()
902            self.fail("Expected ValueError")
903        except ValueError:
904            pass
905        self.instance.x.reset()
906        self.failUnlessEqual(self.instance.c[1](), 8)
907        self.failUnlessEqual(value(self.instance.c[1]), 8)
908        self.failUnlessEqual(len(self.instance.c), 2)
909
910    def test_rule_option4(self):
911        """Test rule option"""
912        def f(model):
913          res={}
914          for i in [0,1,2]:
915                ans=0
916                for j in model.x.keys():
917                    ans = ans + model.x[j]
918                ans *= i
919                ans = ans < 0
920                ans = ans > 0
921                res[i]=ans
922          return res
923        self.model.x = Var(RangeSet(1,4),initialize=2)
924        self.model.c = Constraint(self.model.A,rule=f)
925        try:
926            self.instance = self.model.create()
927            self.fail("Expected IndexError")
928        except IndexError:
929            pass
930
931    def test_dim(self):
932        """Test dim method"""
933        self.model.c = Constraint(self.model.A)
934        self.instance = self.model.create()
935        self.failUnlessEqual(self.instance.c.dim(),1)
936
937    def test_keys(self):
938        """Test keys method"""
939        self.model.c = Constraint(self.model.A)
940        self.instance = self.model.create()
941        self.failUnlessEqual(len(self.instance.c.keys()),0)
942
943    def test_len(self):
944        """Test len method"""
945        self.model.c = Constraint(self.model.A)
946        self.instance = self.model.create()
947        self.failUnlessEqual(len(self.instance.c),0)
948        """Test rule option"""
949        def f(model):
950          ans=0
951          for i in model.x.keys():
952            ans = ans + model.x[i]
953          ans = ans==2
954          return ans
955        self.model.x = Var(RangeSet(1,4),initialize=2)
956        self.model.c = Constraint(rule=f)
957        self.instance = self.model.create()
958        self.failUnlessEqual(len(self.instance.c),1)
959
960    def test_rule_error1(self):
961        """Verify that errors in the rule dictionary are identified"""
962        def f(model):
963          res={}
964          for i in model.A:
965            if i%2 != 0:
966                ans=0
967                for j in model.x.keys():
968                    ans = ans + model.x[j]
969                ans *= i
970                ans = ans < 0
971                ans = ans > 0
972                res[i]=ans
973          return res
974        self.model.x = Var(RangeSet(1,4),initialize=2)
975        self.model.c = Constraint(self.model.A,rule=f)
976        self.instance = self.model.create()
977        try:
978            self.instance.c[1]()
979            self.fail("Expected ValueError")
980        except ValueError:
981            pass
982        self.instance.x.reset()
983        self.failUnlessEqual(self.instance.c[1](), 8)
984        self.failUnlessEqual(value(self.instance.c[1]), 8)
985        self.failUnlessEqual(len(self.instance.c), 2)
986
987
988
989class Test2DArrayCon(PyomoModel):
990
991    def setUp(self):
992        #
993        # Create Model
994        #
995        PyomoModel.setUp(self)
996        self.model.A = Set(initialize=[1,2])
997
998    def tearDown(self):
999        pass
1000
1001    def test_rule_option(self):
1002        """Test rule option"""
1003        def f(i,j,model):
1004          ans=0
1005          for j in model.x.keys():
1006            ans = ans + model.x[j]
1007          ans *= i
1008          ans = ans < 0
1009          ans = ans > 0
1010          return ans
1011        self.model.x = Var(RangeSet(1,4),initialize=2)
1012        self.model.c = Constraint(self.model.A,self.model.A,rule=f)
1013        self.instance = self.model.create()
1014        try:
1015            self.instance.c[1,1]()
1016            self.fail("Expected ValueError")
1017        except ValueError:
1018            pass
1019        self.instance.x.reset()
1020        self.failUnlessEqual(self.instance.c[1,1](), 8)
1021        self.failUnlessEqual(self.instance.c[2,1](), 16)
1022        self.failUnlessEqual(value(self.instance.c[1,1]), 8)
1023        self.failUnlessEqual(value(self.instance.c[2,1]), 16)
1024
1025    def test_dim(self):
1026        """Test dim method"""
1027        self.model.c = Constraint(self.model.A,self.model.A)
1028        self.instance = self.model.create()
1029        self.failUnlessEqual(self.instance.c.dim(),2)
1030
1031    def test_keys(self):
1032        """Test keys method"""
1033        self.model.c = Constraint(self.model.A,self.model.A)
1034        self.instance = self.model.create()
1035        self.failUnlessEqual(len(self.instance.c.keys()),0)
1036
1037    def test_len(self):
1038        """Test len method"""
1039        self.model.c = Constraint(self.model.A,self.model.A)
1040        self.instance = self.model.create()
1041        self.failUnlessEqual(len(self.instance.c),0)
1042        """Test rule option"""
1043        def f(model):
1044          ans=0
1045          for i in model.x.keys():
1046            ans = ans + model.x[i]
1047          ans = ans==2
1048          return ans
1049        self.model.x = Var(RangeSet(1,4),initialize=2)
1050        self.model.c = Constraint(rule=f)
1051        self.instance = self.model.create()
1052        self.failUnlessEqual(len(self.instance.c),1)
1053
1054
1055class TestModel(PyomoModel):
1056
1057    def setUp(self):
1058        #
1059        # Create Model
1060        #
1061        PyomoModel.setUp(self)
1062
1063    def tearDown(self):
1064        #pass
1065        if os.path.exists("unknown.lp"):
1066           os.unlink("unknown.lp")
1067
1068    def test_clear_attribute(self):
1069        """ Coverage of the _clear_attribute method """
1070        self.model.A = Set()
1071        self.failUnlessEqual(self.model.A.name,"A")
1072        self.model.A = Var()
1073        self.failUnlessEqual(self.model.A.name,"A")
1074        self.model.A = Param()
1075        self.failUnlessEqual(self.model.A.name,"A")
1076        self.model.A = Objective()
1077        self.failUnlessEqual(self.model.A.name,"A")
1078        self.model.A = Constraint()
1079        self.failUnlessEqual(self.model.A.name,"A")
1080        self.model.A = Set()
1081        self.failUnlessEqual(self.model.A.name,"A")
1082
1083    def test_set_attr(self):
1084        self.model.x = Param()
1085        self.model.x = None
1086
1087    def test_write(self):
1088        self.model.A = RangeSet(1,4)
1089        self.model.x = Var(self.model.A, bounds=(-1,1))
1090        def obj_rule(model):
1091          expr = 0
1092          for i in model.A:
1093            expr += model.x[i]
1094          return expr
1095        self.model.obj = Objective(rule=obj_rule)
1096        self.instance = self.model.create()
1097        self.instance.write()
1098
1099    def test_write2(self):
1100        self.model.A = RangeSet(1,4)
1101        self.model.x = Var(self.model.A, bounds=(-1,1))
1102        def obj_rule(model):
1103          expr = 0
1104          for i in model.A:
1105            expr += model.x[i]
1106          return expr
1107        self.model.obj = Objective(rule=obj_rule)
1108        def c_rule(model):
1109          return (1, model.x[1]+model.x[2], 2)
1110        self.model.c = Constraint(rule=c_rule)
1111        self.instance = self.model.create()
1112        self.instance.write()
1113
1114    def test_write_error(self):
1115        self.instance = self.model.create()
1116        try:
1117            self.instance.write(format=ProblemFormat.ospl)
1118            self.fail("Expected error because ospl writer is not available")
1119        except ValueError:
1120            pass
1121
1122    def test_solve1(self):
1123        self.model.A = RangeSet(1,4)
1124        self.model.x = Var(self.model.A, bounds=(-1,1))
1125        def obj_rule(model):
1126          expr = 0
1127          for i in model.A:
1128            expr += model.x[i]
1129          return expr
1130        self.model.obj = Objective(rule=obj_rule)
1131        def c_rule(model):
1132          expr = 0
1133          for i in model.A:
1134            expr += i*model.x[i]
1135          return (expr,0)
1136        self.model.c = Constraint(rule=c_rule)
1137        self.instance = self.model.create()
1138        #self.instance.pprint()
1139        if not pyutilib.registered_executable("glpsol"):
1140            return
1141        else:   
1142           opt = SolverFactory('glpk')
1143        solutions = opt.solve(self.instance, keepFiles=True)
1144        self.instance.load(solutions)
1145        self.instance.display(currdir+"solve1.out")
1146        self.failUnlessFileEqualsBaseline(currdir+"solve1.out",currdir+"solve1.txt")
1147
1148    def Xtest_solve2(self):
1149        """
1150        WEH - this is disabled because glpk appears to work fine
1151        on this example.  I'm not quite sure what has changed that has
1152        impacted this test...
1153        """
1154        self.model.A = RangeSet(1,4)
1155        self.model.x = Var(self.model.A, bounds=(-1,1))
1156        def obj_rule(model):
1157          expr = 0
1158          for i in model.A:
1159            expr += model.x[i]
1160          return expr
1161        self.model.obj = Objective(rule=obj_rule)
1162        self.instance = self.model.create()
1163        #self.instance.pprint()
1164        if not pyutilib.registered_executable("glpsol"):
1165            return
1166        else:   
1167           opt = solvers.GLPK(keepFiles=True)
1168        solutions = opt.solve(self.instance)
1169        solutions.write()
1170        sys.exit(1)
1171        try:
1172            self.instance.load(solutions)
1173            self.fail("Cannot load a solution with a bad solver status")
1174        except ValueError:
1175            pass
1176
1177    def test_solve3(self):
1178        self.model.A = RangeSet(1,4)
1179        self.model.x = Var(self.model.A, bounds=(-1,1))
1180        def obj_rule(model):
1181          expr = 0
1182          for i in model.A:
1183            expr += model.x[i]
1184          return expr
1185        self.model.obj = Objective(rule=obj_rule)
1186        self.instance = self.model.create()
1187        self.instance.display(currdir+"solve3.out")
1188        self.failUnlessFileEqualsBaseline(currdir+"solve3.out",currdir+"solve3.txt")
1189
1190    def test_solve4(self):
1191        self.model.A = RangeSet(1,4)
1192        self.model.x = Var(self.model.A, bounds=(-1,1))
1193        def obj_rule(model):
1194          expr = 0
1195          for i in model.A:
1196            expr += model.x[i]
1197          return expr
1198        self.model.obj = Objective(rule=obj_rule)
1199        def c_rule(model):
1200          expr = 0
1201          for i in model.A:
1202            expr += i*model.x[i]
1203          return (expr,0)
1204        self.model.c = Constraint(rule=c_rule)
1205        self.instance = self.model.create()
1206        #self.instance.pprint()
1207        if not pyutilib.registered_executable("glpsol"):
1208            return
1209        else:   
1210           opt = SolverFactory('glpk', keepFiles=True)
1211        solutions = opt.solve(self.instance)
1212        self.instance.load(solutions.solution(0))
1213        self.instance.display(currdir+"solve1.out")
1214        self.failUnlessFileEqualsBaseline(currdir+"solve1.out",currdir+"solve1.txt")
1215
1216if __name__ == "__main__":
1217   unittest.main()
1218
Note: See TracBrowser for help on using the repository browser.