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