source: coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_set.py @ 2359

Last change on this file since 2359 was 2359, checked in by wehart, 10 years ago
  1. Renaming the 'presolve' phase in Pyomo to 'preprocess'. We'll

eventually want an explicit presolve phase, but that will be applied
as a transformation, right before the problem is written and sent
to the solver. Currently, this preprocess phase collects data about
the model and computes the canonical representations for expressions.

  1. Created the ability to support the construction of concrete models.

The concrete_mode() method for Model objects enables this mode.
When in the concrete mode, each component added to the model has
its construct() method called immediately after the component is
added to the model. The symbolic_mode() method for Model objects
can be called to switch back to a symbolic mode (which defers the
execution of construct().

Bad things might happen if you switch back and forth between these
modes. Notably, if you ever generate components in symbolic mode,
then you need to switch back to symbolic mode before calling create().

Note that the Model.create() method is still called when the model
construction is 'done', even when done completely in concrete mode.
This basically calls the preprocessing steps, and this method returns
the current model (i.e. no cloning is done when building a concrete
model).

  1. Created an example directory for concrete models. Note that these

can still be solved with the Pyomo command line. In this
instance, the command line simply executes the script and applies
a solver.

File size: 76.2 KB
Line 
1#
2# Unit Tests for Set() Objects
3#
4# PyomoModel            Base test class
5# SimpleSetA            Testing simple set of integers
6# SimpleSetAordered     Testing simple set of ordered integers
7# TestRangeSet          Testing the RangeSet class
8# TestRangeSet1         More testing of the RangeSet class
9# SimpleSetB            Testing simple set of string values
10# SimpleSetC            Testing simple set of tuples
11# ArraySet              Testing arrays of sets
12# RealSetTests          Testing the RealSet class
13# IntegerSetTests       Testing the IntegerSet class
14# SetArgs1              Testing arguments for simple set
15# SetArgs2              Testing arguments for arrays of sets
16# Misc                  Misc tests
17# SetIO                 Testing Set IO formats
18#
19
20import unittest
21import os
22import sys
23from os.path import abspath, dirname
24sys.path.insert(0, dirname(dirname(abspath(__file__)))+"/../..")
25from coopr.pyomo import *
26import coopr.pyomo.base
27
28
29class PyomoModel(unittest.TestCase):
30
31    def setUp(self):
32        self.model = Model()
33
34    def construct(self,filename):
35        self.instance = self.model.create(filename)
36
37
38class SimpleSetA(PyomoModel):
39
40    def setUp(self):
41        #
42        # Create Model
43        #
44        PyomoModel.setUp(self)
45        #
46        # Create Set 'A' data file
47        #
48        OUTPUT=open("setA.dat","w")
49        print >>OUTPUT, "data; set A := 1 3 5 7; end;"
50        OUTPUT.close()
51        #
52        # Create model instance
53        #
54        self.model.A = Set()
55        #
56        # Misc datasets
57        #
58        self.model.tmpset1 = Set(initialize=[1,3,5,7])
59        self.model.tmpset2 = Set(initialize=[1,2,3,5,7])
60        self.model.tmpset3 = Set(initialize=[2,3,5,7,9])
61
62        self.model.setunion = Set(initialize=[1,2,3,5,7,9])
63        self.model.setintersection = Set(initialize=[3,5,7])
64        self.model.setxor = Set(initialize=[1,2,9])
65        self.model.setdiff = Set(initialize=[1])
66        self.model.setmul = Set(initialize=[(1,2), (1,3), (1,5), (1,7), (1,9),
67                                      (3,2), (3,3), (3,5), (3,7), (3,9),
68                                      (5,2), (5,3), (5,5), (5,7), (5,9),
69                                      (7,2), (7,3), (7,5), (7,7), (7,9)])
70
71        self.instance = self.model.create("setA.dat")
72
73        self.e1=1
74        self.e2=2
75        self.e3=3
76        self.e4=4
77        self.e5=5
78        self.e6=6
79
80    def tearDown(self):
81        #
82        # Remove Set 'A' data file
83        #
84        if os.path.exists("setA.dat"):
85           os.remove("setA.dat")
86
87    def test_len(self):
88        """Check that a simple set of numeric elements has the right size"""
89        self.failUnlessEqual( len(self.instance.A), 4)
90
91    def test_data(self):
92        """Check that we can access the underlying set data"""
93        self.failUnlessEqual( len(self.instance.A.data()), 4)
94
95    def test_dim(self):
96        """Check that a simple set has dimension zero for its indexing"""
97        self.failUnlessEqual( self.instance.A.dim(), 0)
98
99    def test_clear(self):
100        """Check the clear() method empties the set"""
101        self.instance.A.clear()
102        self.failUnlessEqual( len(self.instance.A), 0)
103
104    def test_virtual(self):
105        """Check if this is not a virtual set"""
106        self.failUnlessEqual( self.instance.A.virtual, False)
107
108    def test_bounds(self):
109        """Verify the bounds on this set"""
110        self.failUnlessEqual( self.instance.A.bounds(), (1,7))
111
112    def test_check_values(self):
113        """Check if the values added to this set are valid"""
114        #
115        # This should not throw an exception here
116        #
117        self.instance.A.check_values()
118
119    def test_first(self):
120        """Check that we can get the 'first' value in the set"""
121        self.tmp = self.instance.A.first()
122        self.failIfEqual( self.tmp, None )
123
124    def test_addValid(self):
125        """Check that we can add valid set elements"""
126        self.instance.A.add(self.e2,self.e4)
127        try:
128          self.instance.A.add(self.e3)
129        except ValueError:
130          pass
131        else:
132          self.fail("Should fail when adding an element that already exists in a set.")
133        self.failUnlessEqual( len(self.instance.A), 6)
134        self.failIf( self.e2 not in self.instance.A, "Cannot find new element in A")
135        self.failIf( self.e4 not in self.instance.A, "Cannot find new element in A")
136
137    def test_addInvalid(self):
138        """Check that we get an error when adding invalid set elements"""
139        #
140        # This verifies that by default, all set elements are valid.  That
141        # is, the default within is None
142        #
143        self.failUnlessEqual( self.instance.A.within, None)
144        self.instance.A.add('2','3','4')
145        self.failIf( '2' not in self.instance.A, "Found invalid new element in A")
146       
147    def test_removeValid(self):
148        """Check that we can remove a valid set element"""
149        self.instance.A.remove(self.e3)
150        self.failUnlessEqual( len(self.instance.A), 3)
151        self.failIf( 3 in self.instance.A, "Found element in A that we removed")
152
153    def test_removeInvalid(self):
154        """Check that we fail to remove an invalid set element"""
155        self.failUnlessRaises(KeyError, self.instance.A.remove, 2)
156        self.failUnlessEqual( len(self.instance.A), 4)
157
158    def test_discardValid(self):
159        """Check that we can discard a valid set element"""
160        self.instance.A.discard(self.e3)
161        self.failUnlessEqual( len(self.instance.A), 3)
162        self.failIf( 3 in self.instance.A, "Found element in A that we removed")
163
164    def test_discardInvalid(self):
165        """Check that we fail to remove an invalid set element without an exception"""
166        self.instance.A.discard(self.e2)
167        self.failUnlessEqual( len(self.instance.A), 4)
168
169    def test_iterator(self):
170        """Check that we can iterate through the set"""
171        self.tmp = set()
172        for val in self.instance.A:
173          self.tmp.add(val)
174        self.failIf( self.tmp != self.instance.A.data(), "Set values found by the iterator appear to be different from the underlying set")
175
176    def test_eq1(self):
177        """Various checks for set equality and inequality (1)"""
178        self.failUnlessEqual( self.instance.A == self.instance.tmpset1, True)
179        self.failUnlessEqual( self.instance.tmpset1 == self.instance.A, True)
180        self.failUnlessEqual( self.instance.A != self.instance.tmpset1, False)
181        self.failUnlessEqual( self.instance.tmpset1 != self.instance.A, False)
182
183    def test_eq2(self):
184        """Various checks for set equality and inequality (2)"""
185        self.failUnlessEqual( self.instance.A == self.instance.tmpset2, False)
186        self.failUnlessEqual( self.instance.tmpset2 == self.instance.A, False)
187        self.failUnlessEqual( self.instance.A != self.instance.tmpset2, True)
188        self.failUnlessEqual( self.instance.tmpset2 != self.instance.A, True)
189
190    def test_le1(self):
191        """Various checks for set subset (1)"""
192        self.failUnlessEqual( self.instance.A < self.instance.tmpset1, False)
193        self.failUnlessEqual( self.instance.A <= self.instance.tmpset1, True)
194        self.failUnlessEqual( self.instance.A > self.instance.tmpset1, False)
195        self.failUnlessEqual( self.instance.A >= self.instance.tmpset1, True)
196        self.failUnlessEqual( self.instance.tmpset1 < self.instance.A, False)
197        self.failUnlessEqual( self.instance.tmpset1 <= self.instance.A, True)
198        self.failUnlessEqual( self.instance.tmpset1 > self.instance.A, False)
199        self.failUnlessEqual( self.instance.tmpset1 >= self.instance.A, True)
200
201    def test_le2(self):
202        """Various checks for set subset (2)"""
203        self.failUnlessEqual( self.instance.A < self.instance.tmpset2, True)
204        self.failUnlessEqual( self.instance.A <= self.instance.tmpset2, True)
205        self.failUnlessEqual( self.instance.A > self.instance.tmpset2, False)
206        self.failUnlessEqual( self.instance.A >= self.instance.tmpset2, False)
207        self.failUnlessEqual( self.instance.tmpset2 < self.instance.A, False)
208        self.failUnlessEqual( self.instance.tmpset2 <= self.instance.A, False)
209        self.failUnlessEqual( self.instance.tmpset2 > self.instance.A, True)
210        self.failUnlessEqual( self.instance.tmpset2 >= self.instance.A, True)
211
212    def test_le3(self):
213        """Various checks for set subset (3)"""
214        self.failUnlessEqual( self.instance.A < self.instance.tmpset3, False)
215        self.failUnlessEqual( self.instance.A <= self.instance.tmpset3, False)
216        self.failUnlessEqual( self.instance.A > self.instance.tmpset3, False)
217        self.failUnlessEqual( self.instance.A >= self.instance.tmpset3, False)
218        self.failUnlessEqual( self.instance.tmpset3 < self.instance.A, False)
219        self.failUnlessEqual( self.instance.tmpset3 <= self.instance.A, False)
220        self.failUnlessEqual( self.instance.tmpset3 > self.instance.A, False)
221        self.failUnlessEqual( self.instance.tmpset3 >= self.instance.A, False)
222
223    def test_contains(self):
224        """Various checks for contains() method"""
225        self.failUnlessEqual( self.e1 in self.instance.A, True)
226        self.failUnlessEqual( self.e2 in self.instance.A, False)
227        self.failUnlessEqual( '2' in self.instance.A, False)
228
229    def test_or(self):
230        """Check that set union works"""
231        self.instance.tmp = self.instance.A | self.instance.tmpset3
232        self.instance.tmp.construct()
233        self.failUnlessEqual( self.instance.tmp == self.instance.setunion, True)
234
235    def test_and(self):
236        """Check that set intersection works"""
237        self.instance.tmp = self.instance.A & self.instance.tmpset3
238        self.instance.tmp.construct()
239        self.failUnlessEqual( self.instance.tmp == self.instance.setintersection, True)
240
241    def test_xor(self):
242        """Check that set exclusive or works"""
243        self.instance.tmp = self.instance.A ^ self.instance.tmpset3
244        self.instance.tmp.construct()
245        self.failUnlessEqual( self.instance.tmp == self.instance.setxor, True)
246
247    def test_diff(self):
248        """Check that set difference works"""
249        self.instance.tmp = self.instance.A - self.instance.tmpset3
250        self.instance.tmp.construct()
251        self.failUnlessEqual( self.instance.tmp == self.instance.setdiff, True)
252
253    def test_mul(self):
254        """Check that set cross-product works"""
255        self.instance.tmp = self.instance.A * self.instance.tmpset3
256        self.instance.tmp.construct()
257        self.failUnlessEqual( self.instance.tmp == self.instance.setmul, True)
258
259
260class SimpleSetAordered(SimpleSetA):
261
262    def setUp(self):
263        #
264        # Create Model
265        #
266        PyomoModel.setUp(self)
267        #
268        # Create Set 'A' data file
269        #
270        OUTPUT=open("setA.dat","w")
271        print >>OUTPUT, "data; set A := 1 3 5 7; end;"
272        OUTPUT.close()
273        #
274        # Create model instance
275        #
276        self.model.A = Set(ordered=True)
277        #
278        # Misc datasets
279        #
280        self.model.tmpset1 = Set(initialize=[1,3,5,7])
281        self.model.tmpset2 = Set(initialize=[1,2,3,5,7])
282        self.model.tmpset3 = Set(initialize=[2,3,5,7,9])
283
284        self.model.setunion = Set(initialize=[1,2,3,5,7,9])
285        self.model.setintersection = Set(initialize=[3,5,7])
286        self.model.setxor = Set(initialize=[1,2,9])
287        self.model.setdiff = Set(initialize=[1])
288        self.model.setmul = Set(initialize=[(1,2), (1,3), (1,5), (1,7), (1,9),
289                                      (3,2), (3,3), (3,5), (3,7), (3,9),
290                                      (5,2), (5,3), (5,5), (5,7), (5,9),
291                                      (7,2), (7,3), (7,5), (7,7), (7,9)])
292
293        self.instance = self.model.create("setA.dat")
294
295        self.e1=1
296        self.e2=2
297        self.e3=3
298        self.e4=4
299        self.e5=5
300        self.e6=6
301
302    def test_first(self):
303        """Check that we can get the 'first' value in the set"""
304        self.tmp = self.instance.A.first()
305        self.failIfEqual( self.tmp, None )
306        self.failUnlessEqual( self.tmp, 1 )
307
308    def test_ordered(self):
309        tmp=[]
310        for val in self.instance.A:
311          tmp.append(val)
312        self.failUnlessEqual( tmp, [1,3,5,7] )
313
314
315class TestRangeSet(SimpleSetA):
316
317    def setUp(self):
318        #
319        # Create Model
320        #
321        PyomoModel.setUp(self)
322        #
323        # Create model instance
324        #
325        self.model.A = RangeSet(1,5)
326        #
327        # Misc datasets
328        #
329        self.model.tmpset1 = Set(initialize=[1,2,3,4,5])
330        self.model.tmpset2 = Set(initialize=[1,2,3,4,5,7])
331        self.model.tmpset3 = Set(initialize=[2,3,5,7,9])
332
333        self.model.setunion = Set(initialize=[1,2,3,4,5,7,9])
334        self.model.setintersection = Set(initialize=[2,3,5])
335        self.model.setxor = Set(initialize=[1,4,7,9])
336        self.model.setdiff = Set(initialize=[1,4])
337        self.model.setmul = Set(initialize=[(1,2), (1,3), (1,5), (1,7), (1,9),
338                                      (2,2), (2,3), (2,5), (2,7), (2,9),
339                                      (3,2), (3,3), (3,5), (3,7), (3,9),
340                                      (4,2), (4,3), (4,5), (4,7), (4,9),
341                                      (5,2), (5,3), (5,5), (5,7), (5,9)])
342
343        self.instance = self.model.create()
344
345        self.e1=1
346        self.e2=2
347        self.e3=3
348        self.e4=4
349        self.e5=5
350        self.e6=6
351
352    def test_bounds(self):
353        """Verify the bounds on this set"""
354        self.failUnlessEqual( self.instance.A.bounds(), (1,5))
355
356    def test_addValid(self):
357        """Check that we can add valid set elements"""
358        try:
359          self.instance.A.add(self.e6)
360          self.instance.A.add(self.e3)
361        except ValueError:
362          pass
363        else:
364          self.fail("Should fail when adding an element that already exists in a set.")
365        self.failUnlessEqual( len(self.instance.A), 5)
366
367    def test_addInvalid(self):
368        """Check that we get an error when adding invalid set elements"""
369        #
370        # This verifies that by default, all set elements are valid.  That
371        # is, the default within is None
372        #
373        self.failUnlessEqual( self.instance.A.within, None)
374        try:
375          self.instance.A.add('2','3','4')
376        except ValueError:
377          pass
378        else:
379          self.fail("test_addInvalid")
380        self.failIf( '2' in self.instance.A, "Found invalid new element in A")
381       
382    def test_removeValid(self):
383        """Check that we can remove a valid set element"""
384        self.instance.A.remove(self.e3)
385        self.failUnlessEqual( len(self.instance.A), 4)
386        self.failIf( self.e3 in self.instance.A, "Found element in A that we removed")
387
388    def test_removeInvalid(self):
389        """Check that we fail to remove an invalid set element"""
390        self.failUnlessRaises(KeyError, self.instance.A.remove, 6)
391        self.failUnlessEqual( len(self.instance.A), 5)
392
393    def test_discardValid(self):
394        """Check that we can discard a valid set element"""
395        self.instance.A.discard(self.e3)
396        self.failUnlessEqual( len(self.instance.A), 4)
397        self.failIf( self.e3 in self.instance.A, "Found element in A that we removed")
398
399    def test_discardInvalid(self):
400        """Check that we fail to remove an invalid set element without an exception"""
401        self.instance.A.discard(self.e6)
402        self.failUnlessEqual( len(self.instance.A), 5)
403
404    def test_contains(self):
405        """Various checks for contains() method"""
406        self.failUnlessEqual( self.e1 in self.instance.A, True)
407        self.failUnlessEqual( self.e2 in self.instance.A, True)
408        self.failUnlessEqual( '2' in self.instance.A, False)
409
410    def test_len(self):
411        """Check that a simple set of numeric elements has the right size"""
412        self.failUnlessEqual( len(self.instance.A), 5)
413
414    def test_data(self):
415        """Check that we can access the underlying set data"""
416        self.failUnlessEqual( len(self.instance.A.data()), 5)
417
418
419class TestRangeSet2(TestRangeSet):
420
421    def setUp(self):
422        #
423        # Create Model
424        #
425        PyomoModel.setUp(self)
426        #
427        # Create model instance
428        #
429        def validate_fn(val,model):
430            return (val >= 1) and (val <= 5)
431
432        self.model.A = RangeSet(1,10, validate=validate_fn)
433        #
434        # Misc datasets
435        #
436        self.model.tmpset1 = Set(initialize=[1,2,3,4,5])
437        self.model.tmpset2 = Set(initialize=[1,2,3,4,5,7])
438        self.model.tmpset3 = Set(initialize=[2,3,5,7,9])
439
440        self.model.setunion = Set(initialize=[1,2,3,4,5,7,9])
441        self.model.setintersection = Set(initialize=[2,3,5])
442        self.model.setxor = Set(initialize=[1,4,7,9])
443        self.model.setdiff = Set(initialize=[1,4])
444        self.model.setmul = Set(initialize=[(1,2), (1,3), (1,5), (1,7), (1,9),
445                                      (2,2), (2,3), (2,5), (2,7), (2,9),
446                                      (3,2), (3,3), (3,5), (3,7), (3,9),
447                                      (4,2), (4,3), (4,5), (4,7), (4,9),
448                                      (5,2), (5,3), (5,5), (5,7), (5,9)])
449
450        self.instance = self.model.create()
451
452        self.e1=1
453        self.e2=2
454        self.e3=3
455        self.e4=4
456        self.e5=5
457        self.e6=6
458
459
460class TestRangeSetMisc(unittest.TestCase):
461
462    def test_constructor1(self):
463        a=RangeSet(10)
464        a.construct()
465        tmp=[]
466        for i in a:
467          tmp.append(i)
468        self.failUnlessEqual(tmp, range(1,11))
469        self.failUnlessEqual( a.bounds(), (1,10))
470
471
472    def test_constructor2(self):
473        a=RangeSet(1,10,2)
474        a.construct()
475        tmp=[]
476        for i in a:
477          tmp.append(i)
478        self.failUnlessEqual(tmp, range(1,11,2))
479        self.failUnlessEqual( a.bounds(), (1,9))
480
481    def test_constructor3(self):
482        model=Model()
483        model.a=Param(initialize=1)
484        model.b=Param(initialize=2)
485        model.c=Param(initialize=10)
486        model.d=RangeSet( model.a*model.a, model.c*model.a, model.a*model.b)
487        instance=model.create()
488        tmp=[]
489        for i in instance.d:
490          tmp.append(i)
491        self.failUnlessEqual(tmp, range(1,11,2))
492        try:
493            instance.d.add(2)
494            self.fail("Only odd values allowed")
495        except ValueError:
496            pass
497        try:
498            instance.d.add(0)
499            self.fail("Only positive values allowed")
500        except ValueError:
501            pass
502        self.failUnlessEqual( instance.d.bounds(), (1,9))
503
504class SimpleSetB(SimpleSetA):
505
506    def setUp(self):
507        #
508        # Create Model
509        #
510        PyomoModel.setUp(self)
511        #
512        # Create Set 'A' data file
513        #
514        OUTPUT=open("setA.dat","w")
515        print >>OUTPUT, "data; set A := A1 A3 A5 A7; end;"
516        OUTPUT.close()
517        #
518        # Create model instance
519        #
520        self.model.A = Set()
521        #
522        # Debugging
523        #
524        # Misc datasets
525        #
526        self.model.tmpset1 = Set(initialize=['A1','A3','A5','A7'])
527        self.model.tmpset2 = Set(initialize=['A1','A2','A3','A5','A7'])
528        self.model.tmpset3 = Set(initialize=['A2','A3','A5','A7','A9'])
529
530        self.model.setunion = Set(initialize=['A1','A2','A3','A5','A7','A9'])
531        self.model.setintersection = Set(initialize=['A3','A5','A7'])
532        self.model.setxor = Set(initialize=['A1','A2','A9'])
533        self.model.setdiff = Set(initialize=['A1'])
534        self.model.setmul = Set(initialize=[('A1','A2'), ('A1','A3'), ('A1','A5'), ('A1','A7'), ('A1','A9'),
535                                      ('A3','A2'), ('A3','A3'), ('A3','A5'), ('A3','A7'), ('A3','A9'),
536                                      ('A5','A2'), ('A5','A3'), ('A5','A5'), ('A5','A7'), ('A5','A9'),
537                                      ('A7','A2'), ('A7','A3'), ('A7','A5'), ('A7','A7'), ('A7','A9')])
538
539        self.instance = self.model.create("setA.dat")
540        self.e1='A1'
541        self.e2='A2'
542        self.e3='A3'
543        self.e4='A4'
544        self.e5='A5'
545        self.e6='A6'
546
547    def test_bounds(self):
548        self.failUnlessEqual( self.instance.A.bounds(), None)
549
550
551class SimpleSetC(SimpleSetA):
552
553    def setUp(self):
554        #
555        # Create Model
556        #
557        PyomoModel.setUp(self)
558        #
559        # Create Set 'A' data file
560        #
561        OUTPUT=open("setA.dat","w")
562        print >>OUTPUT, "data; set A := (A1,1) (A3,1) (A5,1) (A7,1); end;"
563        OUTPUT.close()
564        #
565        # Create model instance
566        #
567        self.model.A = Set(dimen=2)
568        #
569        # Debugging
570        #
571        # Misc datasets
572        #
573        self.model.tmpset1 = Set(initialize=[('A1',1), ('A3',1), ('A5',1), ('A7',1)])
574        self.model.tmpset2 = Set(initialize=[('A1',1),('A2',1),('A3',1),('A5',1),('A7',1)])
575        self.model.tmpset3 = Set(initialize=[('A2',1),('A3',1),('A5',1),('A7',1),('A9',1)])
576
577        self.model.setunion = Set(initialize=[('A1',1),('A2',1),('A3',1),('A5',1),('A7',1),('A9',1)])
578        self.model.setintersection = Set(initialize=[('A3',1),('A5',1),('A7',1)])
579        self.model.setxor = Set(initialize=[('A1',1),('A2',1),('A9',1)])
580        self.model.setdiff = Set(initialize=[('A1',1)])
581        self.model.setmul = Set(initialize=[(('A1',1,'A2',1)), (('A1',1,'A3',1)), (('A1',1,'A5',1)), (('A1',1,'A7',1)), (('A1',1,'A9',1)),
582                                      (('A3',1,'A2',1)), (('A3',1,'A3',1)), (('A3',1,'A5',1)), (('A3',1,'A7',1)), (('A3',1,'A9',1)),
583                                      (('A5',1,'A2',1)), (('A5',1,'A3',1)), (('A5',1,'A5',1)), (('A5',1,'A7',1)), (('A5',1,'A9',1)),
584                                      (('A7',1,'A2',1)), (('A7',1,'A3',1)), (('A7',1,'A5',1)), (('A7',1,'A7',1)), (('A7',1,'A9',1))])
585
586        self.instance = self.model.create("setA.dat")
587        self.e1=('A1',1)
588        self.e2=('A2',1)
589        self.e3=('A3',1)
590        self.e4=('A4',1)
591        self.e5=('A5',1)
592        self.e6=('A6',1)
593
594    def tearDown(self):
595        #
596        # Remove Set 'A' data file
597        #
598        os.remove("setA.dat")
599
600    def test_bounds(self):
601        self.failUnlessEqual( self.instance.A.bounds(), None)
602
603    def test_addInvalid(self):
604        """Check that we get an error when adding invalid set elements"""
605        #
606        # This verifies that by default, all set elements are valid.  That
607        # is, the default within is None
608        #
609        self.failUnlessEqual( self.instance.A.within, None)
610        try:
611          self.instance.A.add('2','3','4')
612        except ValueError:
613          pass
614        else:
615          self.fail("fail test_addInvalid")
616        self.failIf( '2' in self.instance.A, "Found invalid new element in A")
617        self.instance.A.add(('2','3'))
618       
619
620class ArraySet(PyomoModel):
621
622    def setUp(self):
623        #
624        # Create Model
625        #
626        PyomoModel.setUp(self)
627        #
628        # Create Set 'A' data file
629        #
630        OUTPUT=open("setA.dat","w")
631        print >>OUTPUT, "data; set Z := A C; set A[A] := 1 3 5 7; set A[C] := 3 5 7 9; end;"
632        OUTPUT.close()
633        #
634        # Create model instance
635        #
636        self.model.Z = Set()
637        self.model.A = Set(self.model.Z)
638        #
639        # Debugging
640        #
641        # Misc datasets
642        #
643        self.model.tmpset1 = Set()
644        self.model.tmpset2 = Set()
645        self.model.tmpset3 = Set()
646
647        self.instance = self.model.create("setA.dat")
648        self.e1=('A1',1)
649
650    def test_bounds(self):
651        self.failUnlessEqual( self.instance.A.bounds(), None)
652
653    def test_getitem(self):
654        """Check the access to items"""
655        try:
656          tmp=[]
657          for val in self.instance.A['A']:
658            tmp.append(val)
659          tmp.sort()
660        except:
661          self.fail("Problems getting a valid set from a set array")
662        self.failUnlessEqual( tmp, [1,3,5,7])
663        try:
664          tmp = self.instance.A['D']
665        except KeyError:
666          pass
667        else:
668          self.fail("Problems getting an invalid set from a set array")
669
670    def test_setitem(self):
671        """Check the access to items"""
672        try:
673          self.model.Z = Set(initialize=['A','C'])
674          self.model.A = Set(self.model.Z,initialize={'A':[1]})
675          self.instance = self.model.create()
676          tmp=[1,6,9]
677          self.instance.A['A'] = tmp
678          self.instance.A['C'] = tmp
679        except:
680          self.fail("Problems setting a valid set into a set array")
681        try:
682          self.instance.A['D'] = tmp
683        except KeyError:
684          pass
685        else:
686          self.fail("Problems setting an invalid set into a set array")
687
688    def test_keys(self):
689        """Check the keys for the array"""
690        tmp=self.instance.A.keys()
691        tmp.sort()
692        self.failUnlessEqual(tmp, ['A', 'C'])
693
694    def test_len(self):
695        """Check that a simple set of numeric elements has the right size"""
696        try:
697           len(self.instance.A)
698        except TypeError:
699           self.fail("fail test_len")           
700        else:
701           pass           
702
703
704    def test_data(self):
705        """Check that we can access the underlying set data"""
706        try:
707          self.instance.A.data()
708        except TypeError:
709          pass
710        else:
711          self.fail("fail test_data")
712
713    def test_dim(self):
714        """Check that a simple set has dimension zero for its indexing"""
715        self.failUnlessEqual( self.instance.A.dim(), 1)
716
717    def test_clear(self):
718        """Check the clear() method empties the set"""
719        self.instance.A.clear()
720        for key in self.instance.A:
721          self.failUnlessEqual( len(self.instance.A[key]), 0)
722
723    def test_virtual(self):
724        """Check if this is not a virtual set"""
725        self.failUnlessEqual( self.instance.A.virtual, False)
726
727    def test_check_values(self):
728        """Check if the values added to this set are valid"""
729        #
730        # This should not throw an exception here
731        #
732        self.instance.A.check_values()
733
734    def test_first(self):
735        """Check that we can get the 'first' value in the set"""
736        pass
737
738    def test_removeValid(self):
739        """Check that we can remove a valid set element"""
740        pass
741
742    def test_removeInvalid(self):
743        """Check that we fail to remove an invalid set element"""
744        pass
745
746    def test_discardValid(self):
747        """Check that we can discard a valid set element"""
748        pass
749
750    def test_discardInvalid(self):
751        """Check that we fail to remove an invalid set element without an exception"""
752        pass
753
754    def test_iterator(self):
755        """Check that we can iterate through the set"""
756        tmp = 0
757        for key in self.instance.A:
758          tmp += len(self.instance.A[key])
759        self.failUnlessEqual( tmp, 8)
760
761    def test_eq1(self):
762        """Various checks for set equality and inequality (1)"""
763        try:
764          self.failUnlessEqual( self.instance.A == self.instance.tmpset1, True)
765          self.failUnlessEqual( self.instance.tmpset1 == self.instance.A, True)
766          self.failUnlessEqual( self.instance.A != self.instance.tmpset1, False)
767          self.failUnlessEqual( self.instance.tmpset1 != self.instance.A, False)
768        except TypeError:
769          pass
770        else:
771          self.fail("fail test_eq1")
772
773    def test_eq2(self):
774        """Various checks for set equality and inequality (2)"""
775        try:
776          self.failUnlessEqual( self.instance.A == self.instance.tmpset2, False)
777          self.failUnlessEqual( self.instance.tmpset2 == self.instance.A, False)
778          self.failUnlessEqual( self.instance.A != self.instance.tmpset2, True)
779          self.failUnlessEqual( self.instance.tmpset2 != self.instance.A, True)
780        except TypeError:
781          pass
782        else:
783          self.fail("fail test_eq2")
784
785    def test_contains(self):
786        """Various checks for contains() method"""
787        tmp = self.e1 in self.instance.A
788        self.failUnlessEqual( tmp, False )
789
790    def test_or(self):
791        """Check that set union works"""
792        try:
793          self.instance.A | self.instance.tmpset3
794        except TypeError:
795          pass
796        else:
797          self.fail("fail test_or")
798
799    def test_and(self):
800        """Check that set intersection works"""
801        try:
802          self.instance.tmp = self.instance.A & self.instance.tmpset3
803        except TypeError:
804          pass
805        else:
806          self.fail("fail test_and")
807
808    def test_xor(self):
809        """Check that set exclusive or works"""
810        try:
811          self.instance.A ^ self.instance.tmpset3
812        except TypeError:
813          pass
814        else:
815          self.fail("fail test_xor")
816
817    def test_diff(self):
818        """Check that set difference works"""
819        try:
820          self.instance.A - self.instance.tmpset3
821        except TypeError:
822          pass
823        else:
824          self.fail("fail test_diff")
825
826    def test_mul(self):
827        """Check that set cross-product works"""
828        try:
829          self.instance.A * self.instance.tmpset3
830        except TypeError:
831          pass
832        else:
833          self.fail("fail test_mul")
834
835
836class ArraySet2(PyomoModel):
837
838    def setUp(self):
839        #
840        # Create Model
841        #
842        PyomoModel.setUp(self)
843        #
844        # Create Set 'A' data file
845        #
846        OUTPUT=open("setA.dat","w")
847        print >>OUTPUT, "data; set Z := A C; set Y := 1 2 ; set A[A,1] := 1 3 5 7; set A[C,2] := 3 5 7 9; end;"
848        OUTPUT.close()
849        #
850        # Create model instance
851        #
852        self.model.Z = Set()
853        self.model.Y = Set()
854        self.model.A = Set(self.model.Z,self.model.Y)
855        #
856        # Debugging
857        #
858        # Misc datasets
859        #
860        self.model.tmpset1 = Set()
861        self.model.tmpset2 = Set()
862        self.model.tmpset3 = Set()
863
864        self.instance = self.model.create("setA.dat")
865        self.e1=('A1',1)
866
867    def test_bounds(self):
868        self.failUnlessEqual( self.instance.A.bounds(), None)
869
870    def test_getitem(self):
871        """Check the access to items"""
872        try:
873          tmp=[]
874          for val in self.instance.A['A',1]:
875            tmp.append(val)
876          tmp.sort()
877        except:
878          self.fail("Problems getting a valid set from a set array")
879        self.failUnlessEqual( tmp, [1,3,5,7])
880        try:
881          tmp = self.instance.A['A',2]
882        except KeyError:
883          pass
884        else:
885          self.fail("Problems getting an invalid set from a set array")
886
887    def Xtest_setitem(self):
888        """Check the access to items"""
889        try:
890          self.model.Y = Set(initialize=[1,2])
891          self.model.Z = Set(initialize=['A','C'])
892          self.model.A = Set(self.model.Z,self.model.Y,initialize={'A':[1]})
893          self.instance = self.model.create()
894          tmp=[1,6,9]
895          self.instance.A['A'] = tmp
896          self.instance.A['C'] = tmp
897        except:
898          self.fail("Problems setting a valid set into a set array")
899        try:
900          self.instance.A['D'] = tmp
901        except KeyError:
902          pass
903        else:
904          self.fail("Problems setting an invalid set into a set array")
905
906    def Xtest_keys(self):
907        """Check the keys for the array"""
908        tmp=self.instance.A.keys()
909        tmp.sort()
910        self.failUnlessEqual(tmp, ['A', 'C'])
911
912    def Xtest_len(self):
913        """Check that a simple set of numeric elements has the right size"""
914        try:
915          len(self.instance.A)
916        except TypeError:
917          pass
918        else:
919          self.fail("fail test_len")
920
921    def Xtest_data(self):
922        """Check that we can access the underlying set data"""
923        try:
924          self.instance.A.data()
925        except TypeError:
926          pass
927        else:
928          self.fail("fail test_data")
929
930    def Xtest_dim(self):
931        """Check that a simple set has dimension zero for its indexing"""
932        self.failUnlessEqual( self.instance.A.dim(), 1)
933
934    def Xtest_clear(self):
935        """Check the clear() method empties the set"""
936        self.instance.A.clear()
937        for key in self.instance.A:
938          self.failUnlessEqual( len(self.instance.A[key]), 0)
939
940    def Xtest_virtual(self):
941        """Check if this is not a virtual set"""
942        self.failUnlessEqual( self.instance.A.virtual, False)
943
944    def Xtest_check_values(self):
945        """Check if the values added to this set are valid"""
946        #
947        # This should not throw an exception here
948        #
949        self.instance.A.check_values()
950
951    def Xtest_first(self):
952        """Check that we can get the 'first' value in the set"""
953        pass
954
955    def Xtest_removeValid(self):
956        """Check that we can remove a valid set element"""
957        pass
958
959    def Xtest_removeInvalid(self):
960        """Check that we fail to remove an invalid set element"""
961        pass
962
963    def Xtest_discardValid(self):
964        """Check that we can discard a valid set element"""
965        pass
966
967    def Xtest_discardInvalid(self):
968        """Check that we fail to remove an invalid set element without an exception"""
969        pass
970
971    def Xtest_iterator(self):
972        """Check that we can iterate through the set"""
973        tmp = 0
974        for key in self.instance.A:
975          tmp += len(self.instance.A[key])
976        self.failUnlessEqual( tmp, 8)
977
978    def Xtest_eq1(self):
979        """Various checks for set equality and inequality (1)"""
980        try:
981          self.failUnlessEqual( self.instance.A == self.instance.tmpset1, True)
982          self.failUnlessEqual( self.instance.tmpset1 == self.instance.A, True)
983          self.failUnlessEqual( self.instance.A != self.instance.tmpset1, False)
984          self.failUnlessEqual( self.instance.tmpset1 != self.instance.A, False)
985        except TypeError:
986          pass
987        else:
988          self.fail("fail test_eq1")
989
990    def Xtest_eq2(self):
991        """Various checks for set equality and inequality (2)"""
992        try:
993          self.failUnlessEqual( self.instance.A == self.instance.tmpset2, False)
994          self.failUnlessEqual( self.instance.tmpset2 == self.instance.A, False)
995          self.failUnlessEqual( self.instance.A != self.instance.tmpset2, True)
996          self.failUnlessEqual( self.instance.tmpset2 != self.instance.A, True)
997        except TypeError:
998          pass
999        else:
1000          self.fail("fail test_eq2")
1001
1002    def Xtest_contains(self):
1003        """Various checks for contains() method"""
1004        tmp = self.e1 in self.instance.A
1005        self.failUnlessEqual( tmp, False )
1006
1007    def Xtest_or(self):
1008        """Check that set union works"""
1009        try:
1010          self.instance.A | self.instance.tmpset3
1011        except TypeError:
1012          pass
1013        else:
1014          self.fail("fail test_or")
1015
1016    def Xtest_and(self):
1017        """Check that set intersection works"""
1018        try:
1019          self.instance.tmp = self.instance.A & self.instance.tmpset3
1020        except TypeError:
1021          pass
1022        else:
1023          self.fail("fail test_and")
1024
1025    def Xtest_xor(self):
1026        """Check that set exclusive or works"""
1027        try:
1028          self.instance.A ^ self.instance.tmpset3
1029        except TypeError:
1030          pass
1031        else:
1032          self.fail("fail test_xor")
1033
1034    def Xtest_diff(self):
1035        """Check that set difference works"""
1036        try:
1037          self.instance.A - self.instance.tmpset3
1038        except TypeError:
1039          pass
1040        else:
1041          self.fail("fail test_diff")
1042
1043    def Xtest_mul(self):
1044        """Check that set cross-product works"""
1045        try:
1046          self.instance.A * self.instance.tmpset3
1047        except TypeError:
1048          pass
1049        else:
1050          self.fail("fail test_mul")
1051
1052
1053class RealSetTests(SimpleSetA):
1054
1055    def setUp(self):
1056        #
1057        # Create Model
1058        #
1059        PyomoModel.setUp(self)
1060        #
1061        # Create model instance
1062        #
1063        self.model.A = Reals
1064        #
1065        # Misc datasets
1066        #
1067        self.model.tmpset1 = Set(initialize=[1.1,3.1,5.1,7.1])
1068        self.model.tmpset2 = Set(initialize=[1.1,2.1,3.1,5.1,7.1])
1069        self.model.tmpset3 = Set(initialize=[2.1,3.1,5.1,7.1,9.1])
1070
1071        self.model.setunion = Reals
1072        self.model.setintersection = Set(initialize=[1.1,3.1,5.1,7.1])
1073        self.model.setxor = Set(initialize=[])
1074        self.model.setdiff = Set(initialize=[])
1075        self.model.setmul = None
1076
1077        self.instance = self.model.create()
1078        self.e1=1.1
1079        self.e2=2.1
1080        self.e3=3.1
1081        self.e4=4.1
1082        self.e5=5.1
1083        self.e6=6.1
1084
1085    def tearDown(self):
1086        pass
1087
1088    def test_bounds(self):
1089        self.failUnlessEqual( self.instance.A.bounds(), (None,None))
1090
1091    def test_len(self):
1092        """Check that the set has the right size"""
1093        try:
1094          len(self.instance.A)
1095        except ValueError:
1096          pass
1097        else:
1098          self.fail("test_len failure")
1099
1100    def test_data(self):
1101        """Check that we can access the underlying set data"""
1102        try:
1103          self.instance.A.data()
1104        except TypeError:
1105          pass
1106        else:
1107          self.fail("test_data failure")
1108
1109    def test_clear(self):
1110        """Check that the clear() method generates an exception"""
1111        self.failUnlessRaises(TypeError, self.instance.A.clear)
1112
1113    def test_virtual(self):
1114        """Check if this is not a virtual set"""
1115        self.failUnlessEqual( self.instance.A.virtual, True)
1116
1117    def test_discardValid(self):
1118        """Check that we fail to remove an invalid set element without an exception"""
1119        self.failUnlessRaises(KeyError, self.instance.A.discard, self.e2)
1120
1121    def test_discardInvalid(self):
1122        """Check that we fail to remove an invalid set element without an exception"""
1123        pass
1124
1125    def test_removeValid(self):
1126        """Check that we can remove a valid set element"""
1127        self.failUnlessRaises(KeyError, self.instance.A.remove, self.e3)
1128
1129    def test_removeInvalid(self):
1130        pass
1131
1132    def test_addInvalid(self):
1133        """Check that we get an error when adding invalid set elements"""
1134        pass
1135       
1136    def test_first(self):
1137        """Check that we can get the 'first' value in the set"""
1138        self.failUnlessRaises(TypeError,self.instance.A.first)
1139
1140    def test_addValid(self):
1141        """Check that we can add valid set elements"""
1142        self.failUnlessEqual( self.instance.A.within, None)
1143        self.failUnlessRaises(TypeError,self.instance.A.add,2)
1144
1145    def test_iterator(self):
1146        """Check that we can iterate through the set"""
1147        try:
1148          for val in self.instance.A:
1149            tmp=val
1150        except TypeError:
1151          pass
1152        else:
1153          fail("test_iterator failure")
1154
1155    def test_eq1(self):
1156        """Various checks for set equality and inequality (1)"""
1157        self.failUnless(not(self.instance.A == self.instance.tmpset1))
1158        self.failUnless(not(self.instance.tmpset1 == self.instance.A))
1159        self.failUnless(self.instance.A != self.instance.tmpset1)
1160        self.failUnless(self.instance.tmpset1 != self.instance.A)
1161
1162
1163    def test_eq2(self):
1164        """Various checks for set equality and inequality (2)"""
1165        self.failUnless(not(self.instance.A == self.instance.tmpset2))
1166        self.failUnless(not(self.instance.tmpset2 == self.instance.A))
1167        self.failUnless(self.instance.A != self.instance.tmpset2)
1168        self.failUnless(self.instance.tmpset2 != self.instance.A)
1169
1170    def test_le1(self):
1171        """Various checks for set subset (1)"""
1172        try:
1173          self.instance.A < self.instance.tmpset1
1174          self.instance.A <= self.instance.tmpset1
1175          self.instance.A > self.instance.tmpset1
1176          self.instance.A >= self.instance.tmpset1
1177          self.instance.tmpset1 < self.instance.A
1178          self.instance.tmpset1 <= self.instance.A
1179          self.instance.tmpset1 > self.instance.A
1180          self.instance.tmpset1 >= self.instance.A
1181        except TypeError:
1182          pass
1183        else:
1184          self.fail("test_le1 failure")
1185
1186    def test_le2(self):
1187        """Various checks for set subset (2)"""
1188        try:
1189          self.instance.A < self.instance.tmpset2
1190          self.instance.A <= self.instance.tmpset2
1191          self.instance.A > self.instance.tmpset2
1192          self.instance.A >= self.instance.tmpset2
1193          self.instance.tmpset2 < self.instance.A
1194          self.instance.tmpset2 <= self.instance.A
1195          self.instance.tmpset2 > self.instance.A
1196          self.instance.tmpset2 >= self.instance.A
1197        except TypeError:
1198          pass
1199        else:
1200          self.fail("test_le2 failure")
1201
1202    def test_le3(self):
1203        """Various checks for set subset (3)"""
1204        try:
1205          self.instance.A < self.instance.tmpset3
1206          self.instance.A <= self.instance.tmpset3
1207          self.instance.A > self.instance.tmpset3
1208          self.instance.A >= self.instance.tmpset3
1209          self.instance.tmpset3 < self.instance.A
1210          self.instance.tmpset3 <= self.instance.A
1211          self.instance.tmpset3 > self.instance.A
1212          self.instance.tmpset3 >= self.instance.A
1213        except TypeError:
1214          pass
1215        else:
1216          self.fail("test_le3 failure")
1217
1218    def test_contains(self):
1219        """Various checks for contains() method"""
1220        self.failUnlessEqual( self.e1 in self.instance.A, True)
1221        self.failUnlessEqual( self.e2 in self.instance.A, True)
1222        self.failUnlessEqual( '2' in self.instance.A, False)
1223
1224    def test_or(self):
1225        """Check that set union works"""
1226        try:
1227          self.instance.tmp = self.instance.A | self.instance.tmpset3
1228        except TypeError:
1229          pass
1230        else:
1231          fail("Operator __or__ should have failed.")
1232
1233    def test_and(self):
1234        """Check that set intersection works"""
1235        try:
1236          self.instance.tmp = self.instance.A & self.instance.tmpset3
1237        except TypeError:
1238          pass
1239        else:
1240          fail("Operator __and__ should have failed.")
1241
1242    def test_xor(self):
1243        """Check that set exclusive or works"""
1244        try:
1245          self.tmp = self.instance.A ^ self.instance.tmpset3
1246        except:
1247          pass
1248        else:
1249          fail("Operator __xor__ should have failed.")
1250
1251    def test_diff(self):
1252        """Check that set difference works"""
1253        try:
1254          self.tmp = self.instance.A - self.instance.tmpset3
1255        except:
1256          pass
1257        else:
1258          fail("Operator __diff__ should have failed.")
1259
1260    def test_mul(self):
1261        """Check that set cross-product works"""
1262        try:
1263          self.instance.tmp = self.instance.A * self.instance.tmpset3
1264        except:
1265          pass
1266        else:
1267          fail("Operator __mul__ should have failed.")
1268
1269
1270class IntegerSetTests(RealSetTests):
1271
1272    def setUp(self):
1273        #
1274        # Create Model
1275        #
1276        PyomoModel.setUp(self)
1277        #
1278        # Create model instance
1279        #
1280        self.model.A = Integers
1281        #
1282        # Misc datasets
1283        #
1284        self.model.tmpset1 = Set(initialize=[1,3,5,7])
1285        self.model.tmpset2 = Set(initialize=[1,2,3,5,7])
1286        self.model.tmpset3 = Set(initialize=[2,3,5,7,9])
1287
1288        self.model.setunion = Reals
1289        self.model.setintersection = Set(initialize=[1,3,5,7])
1290        self.model.setxor = Set(initialize=[])
1291        self.model.setdiff = Set(initialize=[])
1292        self.model.setmul = None
1293
1294        self.instance = self.model.create()
1295        self.e1=1
1296        self.e2=2
1297        self.e3=3
1298        self.e4=4
1299        self.e5=5
1300        self.e6=6
1301
1302    def test_bounds(self):
1303        self.failUnlessEqual( self.instance.A.bounds(), (None,None))
1304
1305
1306class AnySetTests(RealSetTests):
1307
1308    def setUp(self):
1309        #
1310        # Create Model
1311        #
1312        PyomoModel.setUp(self)
1313        #
1314        # Create model instance
1315        #
1316        self.model.A = Any
1317        #
1318        # Misc datasets
1319        #
1320        self.model.tmpset1 = Set(initialize=[1,'3',5,7])
1321        self.model.tmpset2 = Set(initialize=[1,2,'3',5,7])
1322        self.model.tmpset3 = Set(initialize=[2,'3',5,7,9])
1323
1324        self.model.setunion = Any
1325        self.model.setintersection = Set(initialize=[1,'3',5,7])
1326        self.model.setxor = Set(initialize=[])
1327        self.model.setdiff = Set(initialize=[])
1328        self.model.setmul = None
1329
1330        self.instance = self.model.create()
1331        self.e1=1
1332        self.e2=2
1333        self.e3='3'
1334        self.e4=4
1335        self.e5=5
1336        self.e6=6
1337
1338    def test_bounds(self):
1339        self.failUnlessEqual( self.instance.A.bounds(), None)
1340
1341    def test_contains(self):
1342        """Various checks for contains() method"""
1343        self.failUnlessEqual( self.e1 in self.instance.A, True)
1344        self.failUnlessEqual( self.e2 in self.instance.A, True)
1345        self.failUnlessEqual( '2' in self.instance.A, True)
1346
1347
1348class SetArgs1(PyomoModel):
1349
1350    def setUp(self):
1351        #
1352        # Create Model
1353        #
1354        PyomoModel.setUp(self)
1355
1356    def test_initialize1(self):
1357        self.model.A = Set(initialize=[1,2,3,'A'])
1358        self.instance = self.model.create()
1359        self.failUnlessEqual(len(self.instance.A),4)
1360       
1361    def test_initialize2(self):
1362        self.model.A = Set(initialize=[(i,j) for i in range(0,3) for j in range(1,4) if (i+j)%2 == 0])
1363        self.instance = self.model.create()
1364        self.failUnlessEqual(len(self.instance.A),4)
1365
1366    def test_initialize3(self):
1367        self.model.A = Set(initialize=((i,j) for i in range(0,3) for j in range(1,4) if (i+j)%2 == 0))
1368        self.instance = self.model.create()
1369        self.failUnlessEqual(len(self.instance.A),4)
1370       
1371    def test_initialize4(self):
1372        self.model.A = Set(initialize=range(0,4))
1373        def B_index(model):
1374            return (i for i in model.A if i%2 == 0)
1375        def B_init(i,model):
1376            return range(i,2+i)
1377        self.model.B = Set(B_index, initialize=B_init)
1378        self.instance = self.model.create()
1379        #self.instance.pprint()
1380        self.failUnlessEqual(self.instance.B[0].data(),set([0,1]))
1381        self.failUnlessEqual(self.instance.B[2].data(),set([2,3]))
1382        self.failUnlessEqual(self.instance.B.keys(),[0,2])
1383
1384    def test_initialize5(self):
1385        self.model.A = Set(initialize=range(0,4))
1386        def B_index(model):
1387            for i in model.A:
1388                if i%2 == 0:
1389                    yield i
1390        def B_init(i,model):
1391            return range(i,2+i)
1392        self.model.B = Set(B_index, initialize=B_init)
1393        self.instance = self.model.create()
1394        #self.instance.pprint()
1395        self.failUnlessEqual(self.instance.B[0].data(),set([0,1]))
1396        self.failUnlessEqual(self.instance.B[2].data(),set([2,3]))
1397        self.failUnlessEqual(self.instance.B.keys(),[0,2])
1398
1399    def test_initialize6(self):
1400        self.model.A = Set(initialize=range(0,4))
1401        def B_index(model):
1402            for i in model.A:
1403                if i%2 == 0:
1404                    yield i
1405        def B_init(i,j,model):
1406            if j:
1407                return range(i,2+i)
1408            return []
1409        self.model.B = Set(B_index, [True,False], initialize=B_init)
1410        self.instance = self.model.create()
1411        #self.instance.pprint()
1412        self.failUnlessEqual(set(self.instance.B.keys()),set([(0,True),(2,True),(0,False),(2,False)]))
1413        self.failUnlessEqual(self.instance.B[0,True].data(),set([0,1]))
1414        self.failUnlessEqual(self.instance.B[2,True].data(),set([2,3]))
1415
1416    def test_initialize7(self):
1417        self.model.A = Set(initialize=range(0,3))
1418        @set_options(dimen=3)
1419        def B_index(model):
1420            return [(i,i+1,i*i) for i in model.A]
1421        def B_init(i,ii,iii,j,model):
1422            if j:
1423                return range(i,2+i)
1424            return []
1425        self.model.B = Set(B_index, [True,False], initialize=B_init)
1426        self.instance = self.model.create()
1427        #self.instance.pprint()
1428        self.failUnlessEqual(set(self.instance.B.keys()),set([(0,1,0,True),(1,2,1,True),(2,3,4,True),(0,1,0,False),(1,2,1,False),(2,3,4,False)]))
1429        self.failUnlessEqual(self.instance.B[0,1,0,True].data(),set([0,1]))
1430        self.failUnlessEqual(self.instance.B[2,3,4,True].data(),set([2,3]))
1431
1432    def test_initialize8(self):
1433        self.model.A = Set(initialize=range(0,3))
1434        def B_index(model):
1435            return [(i,i+1,i*i) for i in model.A]
1436        def B_init(i,ii,iii,j,model):
1437            if j:
1438                return range(i,2+i)
1439            return []
1440        self.model.B = Set(B_index, [True,False], initialize=B_init)
1441        try:
1442            self.instance = self.model.create()
1443            self.fail("Expected ValueError because B_index returns a tuple")
1444        except ValueError:
1445            pass
1446
1447    def test_initialize9(self):
1448        self.model.A = Set(initialize=range(0,3))
1449        @set_options(domain=Integers)
1450        def B_index(model):
1451            return [i/2.0 for i in model.A]
1452        def B_init(i,j,model):
1453            if j:
1454                return range(int(i),int(2+i))
1455            return []
1456        self.model.B = Set(B_index, [True,False], initialize=B_init)
1457        self.instance = self.model.create()
1458        try:
1459            self.instance = self.model.create()
1460            self.fail("Expected ValueError because B_index returns invalid set values")
1461        except AssertionError:
1462            pass
1463
1464    def test_dimen1(self):
1465        #
1466        # Create model instance
1467        #
1468        self.model.A = Set(initialize=[1,2,3], dimen=1)
1469        self.instance = self.model.create()
1470        #
1471        try:
1472          self.model.A = Set(initialize=[4,5,6], dimen=2)
1473          self.instance = self.model.create()
1474        except ValueError:
1475          pass
1476        else:
1477          self.fail("test_dimen")
1478        #
1479        self.model.A = Set(initialize=[(1,2), (2,3), (3,4)], dimen=2)
1480        self.instance = self.model.create()
1481        #
1482        try:
1483          self.model.A = Set(initialize=[(1,2), (2,3), (3,4)], dimen=1)
1484          self.instance = self.model.create()
1485        except ValueError:
1486          pass
1487        else:
1488          self.fail("test_dimen")
1489        #
1490        def f(model):
1491            return [(1,1), (2,2), (3,3)]
1492        self.model.A = Set(initialize=f, dimen=2)
1493        self.instance = self.model.create()
1494        #
1495        try:
1496            self.model.A = Set(initialize=f, dimen=3)
1497            self.instance = self.model.create()
1498        except ValueError:
1499          pass
1500        else:
1501          self.fail("test_dimen")
1502         
1503    def test_rule(self):
1504        #
1505        # Create model instance
1506        #
1507        OUTPUT=open("setA.dat","w")
1508        print >>OUTPUT, "data; param n := 5; end;"
1509        OUTPUT.close()
1510        def tmp_init(model):
1511            ##model.n.pprint()
1512            ##print "HERE",model.n,value(model.n)
1513            return range(0,value(model.n))
1514        self.model.n = Param()
1515        self.model.A = Set(initialize=tmp_init)
1516        self.instance = self.model.create("setA.dat")
1517        self.failUnlessEqual(len(self.instance.A),5)
1518         
1519    def test_rule2(self):
1520        #
1521        # Create model instance
1522        #
1523        OUTPUT=open("setA.dat","w")
1524        print >>OUTPUT, "data; param n := 5; end;"
1525        OUTPUT.close()
1526        def tmp_init(z,model):
1527            if z==value(model.n) or z == 10:
1528               return None
1529            return z
1530        self.model.n = Param()
1531        self.model.A = Set(initialize=tmp_init)
1532        self.instance = self.model.create("setA.dat")
1533        self.failUnlessEqual(len(self.instance.A),5)
1534         
1535    def test_within1(self):
1536        #
1537        # Create Set 'A' data file
1538        #
1539        OUTPUT=open("setA.dat","w")
1540        print >>OUTPUT, "data; set A := 1 3 5 7.5; end;"
1541        OUTPUT.close()
1542        #
1543        # Create A with an error
1544        #
1545        self.model.A = Set(within=Integers)
1546        try:
1547          self.instance = self.model.create("setA.dat")
1548        except ValueError:
1549          pass
1550        else:
1551          self.fail("fail test_within1")
1552       
1553    def test_within2(self):
1554        #
1555        # Create Set 'A' data file
1556        #
1557        OUTPUT=open("setA.dat","w")
1558        print >>OUTPUT, "data; set A := 1 3 5 7.5; end;"
1559        OUTPUT.close()
1560        #
1561        # Create A with an error
1562        #
1563        self.model.A = Set(within=Reals)
1564        try:
1565          self.instance = self.model.create("setA.dat")
1566        except ValueError:
1567          self.fail("fail test_within2")
1568        else:
1569          pass
1570       
1571    def test_validation1(self):
1572        #
1573        # Create Set 'A' data file
1574        #
1575        OUTPUT=open("setA.dat","w")
1576        print >>OUTPUT, "data; set A := 1 3 5 7.5; end;"
1577        OUTPUT.close()
1578        #
1579        # Create A with an error
1580        #
1581        self.model.A = Set(validate=lambda x,model:x<6)
1582        try:
1583          self.instance = self.model.create("setA.dat")
1584        except ValueError:
1585          pass
1586        else:
1587          self.fail("fail test_validation1")
1588       
1589    def test_validation2(self):
1590        #
1591        # Create Set 'A' data file
1592        #
1593        OUTPUT=open("setA.dat","w")
1594        print >>OUTPUT, "data; set A := 1 3 5 5.5; end;"
1595        OUTPUT.close()
1596        #
1597        # Create A with an error
1598        #
1599        self.model.A = Set(validate=lambda x,model:x<6)
1600        try:
1601          self.instance = self.model.create("setA.dat")
1602        except ValueError:
1603          self.fail("fail test_validation2")
1604        else:
1605          pass
1606       
1607    def test_other1(self):
1608        self.model.A = Set(initialize=[1,2,3,'A'], validate=lambda x,model:x in Integers)
1609        try:
1610          self.instance = self.model.create()
1611        except ValueError:
1612          pass
1613        else:
1614          self.fail("fail test_other1")
1615
1616    def test_other2(self):
1617        self.model.A = Set(initialize=[1,2,3,'A'], within=Integers)
1618        try:
1619          self.instance = self.model.create()
1620        except ValueError:
1621          pass
1622        else:
1623          self.fail("fail test_other1")
1624
1625    def test_other3(self):
1626        OUTPUT=open("setA.dat","w")
1627        print >>OUTPUT, "data; param n := 5; end;"
1628        OUTPUT.close()
1629        def tmp_init(model):
1630            tmp=[]
1631            for i in range(0,value(model.n)):
1632              tmp.append(i/2.0)
1633            return tmp
1634        self.model.n = Param()
1635        self.model.A = Set(initialize=tmp_init, validate=lambda x,model:x in Integers)
1636        try:
1637          self.instance = self.model.create("setA.dat")
1638        except ValueError:
1639          pass
1640        else:
1641          self.fail("fail test_other1")
1642
1643    def test_other4(self):
1644        OUTPUT=open("setA.dat","w")
1645        print >>OUTPUT, "data; param n := 5; end;"
1646        OUTPUT.close()
1647        def tmp_init(model):
1648            tmp=[]
1649            for i in range(0,value(model.n)):
1650              tmp.append(i/2.0)
1651            return tmp
1652        self.model.n = Param()
1653        self.model.A = Set(initialize=tmp_init, within=Integers)
1654        try:
1655          self.instance = self.model.create("setA.dat")
1656        except ValueError:
1657          pass
1658        else:
1659          self.fail("fail test_other1")
1660
1661    def tearDown(self):
1662        #
1663        # Remove Set 'A' data file
1664        #
1665        if os.path.exists("setA.dat"):
1666           os.remove("setA.dat")
1667
1668
1669class SetArgs2(PyomoModel):
1670
1671    def setUp(self):
1672        #
1673        # Create Model
1674        #
1675        PyomoModel.setUp(self)
1676
1677    def test_initialize(self):
1678        #
1679        # Create Set 'A' data file
1680        #
1681        OUTPUT=open("setA.dat","w")
1682        print >>OUTPUT, "data; set Z := A C; set A[A] := 1 3 5 7; end;"
1683        OUTPUT.close()
1684        #
1685        # Create model instance
1686        #
1687        self.model.Z = Set()
1688        self.model.A = Set(self.model.Z, initialize={'A':[1,2,3,'A']})
1689        self.instance = self.model.create()
1690        self.failUnlessEqual(len(self.instance.A['A']),4)
1691       
1692    def test_dimen(self):
1693        #
1694        # Create model instance
1695        #
1696        self.model.Z = Set(initialize=[1,2])
1697        self.model.A = Set(self.model.Z, initialize=[1,2,3], dimen=1)
1698        self.instance = self.model.create()
1699        try:
1700          self.model.A = Set(self.model.Z, initialize=[4,5,6], dimen=2)
1701          self.instance = self.model.create()
1702        except ValueError:
1703          pass
1704        else:
1705          self.fail("test_dimen")
1706        self.model.A = Set(self.model.Z, initialize=[(1,2), (2,3), (3,4)], dimen=2)
1707        self.instance = self.model.create()
1708        try:
1709          self.model.A = Set(self.model.Z, initialize=[(1,2), (2,3), (3,4)], dimen=1)
1710          self.instance = self.model.create()
1711        except ValueError:
1712          pass
1713        else:
1714          self.fail("test_dimen")
1715         
1716    def test_rule(self):
1717        #
1718        # Create Set 'A' data file
1719        #
1720        OUTPUT=open("setA.dat","w")
1721        print >>OUTPUT, "data; param n := 5; set Z := A C; end;"
1722        OUTPUT.close()
1723        def tmp_init(i,model):
1724            return range(0,value(model.n))
1725        self.model.n = Param()
1726        self.model.Z = Set()
1727        self.model.A = Set(self.model.Z, initialize=tmp_init)
1728        self.instance = self.model.create("setA.dat")
1729        self.failUnlessEqual(len(self.instance.A['A']),5)
1730         
1731    def test_rule2(self):
1732        #
1733        # Create Set 'A' data file
1734        #
1735        OUTPUT=open("setA.dat","w")
1736        print >>OUTPUT, "data; param n := 5; set Z := A C; end;"
1737        OUTPUT.close()
1738        def tmp_init(i,z,model):
1739            if z==value(model.n):
1740               return None
1741            return z
1742        self.model.n = Param()
1743        self.model.Z = Set()
1744        self.model.A = Set(self.model.Z, initialize=tmp_init)
1745        self.instance = self.model.create("setA.dat")
1746        self.failUnlessEqual(len(self.instance.A['A']),5)
1747         
1748    def test_within1(self):
1749        #
1750        # Create Set 'A' data file
1751        #
1752        OUTPUT=open("setA.dat","w")
1753        print >>OUTPUT, "data; set Z := A C; set A[A] := 1 3 5 7.5; end;"
1754        OUTPUT.close()
1755        #
1756        # Create A with an error
1757        #
1758        self.model.Z = Set()
1759        self.model.A = Set(self.model.Z, within=Integers)
1760        try:
1761          self.instance = self.model.create("setA.dat")
1762        except ValueError:
1763          pass
1764        else:
1765          self.fail("fail test_within1")
1766       
1767    def test_within2(self):
1768        #
1769        # Create Set 'A' data file
1770        #
1771        OUTPUT=open("setA.dat","w")
1772        print >>OUTPUT, "data; set Z := A C; set A[A] := 1 3 5 7.5; end;"
1773        OUTPUT.close()
1774        #
1775        # Create A with an error
1776        #
1777        self.model.Z = Set()
1778        self.model.A = Set(self.model.Z, within=Reals)
1779        try:
1780          self.instance = self.model.create("setA.dat")
1781        except ValueError:
1782          self.fail("fail test_within2")
1783        else:
1784          pass
1785       
1786    def test_validation1(self):
1787        #
1788        # Create Set 'A' data file
1789        #
1790        OUTPUT=open("setA.dat","w")
1791        print >>OUTPUT, "data; set Z := A C; set A[A] := 1 3 5 7.5; end;"
1792        OUTPUT.close()
1793        #
1794        # Create A with an error
1795        #
1796        self.model.Z = Set()
1797        self.model.A = Set(self.model.Z, validate=lambda x,model:x<6)
1798        try:
1799          self.instance = self.model.create("setA.dat")
1800        except ValueError:
1801          pass
1802        else:
1803          self.fail("fail test_within1")
1804       
1805    def test_validation2(self):
1806        #
1807        # Create Set 'A' data file
1808        #
1809        OUTPUT=open("setA.dat","w")
1810        print >>OUTPUT, "data; set Z := A C; set A[A] := 1 3 5 5.5; end;"
1811        OUTPUT.close()
1812        #
1813        # Create A with an error
1814        #
1815        self.model.Z = Set()
1816        self.model.A = Set(self.model.Z, validate=lambda x,model:x<6)
1817        try:
1818          self.instance = self.model.create("setA.dat")
1819        except ValueError:
1820          self.fail("fail test_within2")
1821        else:
1822          pass
1823       
1824    def test_other1(self):
1825        self.model.Z = Set(initialize=['A'])
1826        self.model.A = Set(self.model.Z, initialize={'A':[1,2,3,'A']}, validate=lambda x,model:x in Integers)
1827        try:
1828          self.instance = self.model.create()
1829        except ValueError:
1830          pass
1831        else:
1832          self.fail("fail test_other1")
1833
1834    def test_other2(self):
1835        self.model.Z = Set(initialize=['A'])
1836        self.model.A = Set(self.model.Z, initialize={'A':[1,2,3,'A']}, within=Integers)
1837        try:
1838          self.instance = self.model.create()
1839        except ValueError:
1840          pass
1841        else:
1842          self.fail("fail test_other1")
1843
1844    def test_other3(self):
1845        def tmp_init(i,model):
1846            tmp=[]
1847            for i in range(0,value(model.n)):
1848              tmp.append(i/2.0)
1849            return tmp
1850        self.model.n = Param(initialize=5)
1851        self.model.Z = Set(initialize=['A'])
1852        self.model.A = Set(self.model.Z,initialize=tmp_init, validate=lambda x,model:x in Integers)
1853        try:
1854          self.instance = self.model.create()
1855        except ValueError:
1856          pass
1857        else:
1858          self.fail("fail test_other1")
1859
1860    def test_other4(self):
1861        def tmp_init(i,model):
1862            tmp=[]
1863            for i in range(0,value(model.n)):
1864              tmp.append(i/2.0)
1865            return tmp
1866        self.model.n = Param(initialize=5)
1867        self.model.Z = Set(initialize=['A'])
1868        self.model.A = Set(self.model.Z, initialize=tmp_init, within=Integers)
1869        self.model.B = Set(self.model.Z, rule=tmp_init, within=Integers)
1870        try:
1871          self.instance = self.model.create()
1872        except ValueError:
1873          pass
1874        else:
1875          self.fail("fail test_other1")
1876
1877    def tearDown(self):
1878        #
1879        # Remove Set 'A' data file
1880        #
1881        if os.path.exists("setA.dat"):
1882           os.remove("setA.dat")
1883
1884
1885class Misc(PyomoModel):
1886
1887    def setUp(self):
1888        #
1889        # Create Model
1890        #
1891        PyomoModel.setUp(self)
1892        #
1893        #
1894        #
1895        self.model.A = Set(initialize=[1,2,3])
1896        self.model.B = Set(initialize=['a','b','c'])
1897        self.model.C = Set(initialize=[4,5,6])
1898
1899    def tearDown(self):
1900        #
1901        # Remove Set 'A' data file
1902        #
1903        if os.path.exists("setA.dat"):
1904           os.remove("setA.dat")
1905
1906    def test_cross_set(self):
1907         self.model.C = self.model.A * self.model.B
1908         self.instance = self.model.create()
1909         self.failUnlessEqual(len(self.instance.C),9)
1910
1911    def test_tricross_set(self):
1912         self.model.D = self.model.A * self.model.B * self.model.C
1913         self.instance = self.model.create()
1914         self.failUnlessEqual(len(self.instance.D),27)
1915
1916    def test_virtual_cross_set(self):
1917         self.model.C = self.model.A * self.model.B
1918         self.model.C.virtual = True
1919         self.instance = self.model.create()
1920         self.failUnlessEqual(len(self.instance.C),9)
1921         self.failUnlessEqual(len(self.instance.C.value),0)
1922         tmp=[]
1923         for item in self.instance.C:
1924           tmp.append(item)
1925         self.failUnlessEqual(len(tmp),9)
1926
1927
1928class SetIO(PyomoModel):
1929
1930    def setUp(self):
1931        #
1932        # Create Model
1933        #
1934        PyomoModel.setUp(self)
1935
1936    def tearDown(self):
1937        #
1938        # Remove Set 'A' data file
1939        #
1940        if os.path.exists("setA.dat"):
1941           os.remove("setA.dat")
1942
1943    def test_io1(self):
1944        OUTPUT=open("setA.dat","w")
1945        print >>OUTPUT, "data; set A := A1 A2 A3; end;"
1946        OUTPUT.close()
1947        self.model.A = Set()
1948        self.instance = self.model.create("setA.dat")
1949        self.failUnlessEqual( len(self.instance.A), 3)
1950
1951    def test_io2(self):
1952        OUTPUT=open("setA.dat","w")
1953        print >>OUTPUT, "data; set B := 1 2 3 4; end;"
1954        OUTPUT.close()
1955        self.model.B = Set()
1956        self.instance = self.model.create("setA.dat")
1957        self.failUnlessEqual( len(self.instance.B), 4)
1958
1959    def test_io3(self):
1960        OUTPUT=open("setA.dat","w")
1961        print >>OUTPUT, "data;"
1962        print >>OUTPUT, "set A := A1 A2 A3;"
1963        print >>OUTPUT, "set B := 1 2 3 4;"
1964        print >>OUTPUT, "set C := (A1,1) (A2,2) (A3,3);"
1965        print >>OUTPUT, "end;"
1966        OUTPUT.close()
1967        self.model.A = Set()
1968        self.model.B = Set()
1969        self.model.C = self.model.A * self.model.B
1970        self.instance = self.model.create("setA.dat")
1971        self.failUnlessEqual( len(self.instance.C), 3)
1972
1973    def test_io4(self):
1974        OUTPUT=open("setA.dat","w")
1975        print >>OUTPUT, "data;"
1976        print >>OUTPUT, "set A := A1 A2 A3;"
1977        print >>OUTPUT, "set B := 1 2 3 4;"
1978        print >>OUTPUT, "set D := (A1,1) (A2,2) (A3,3);"
1979        print >>OUTPUT, "end;"
1980        OUTPUT.close()
1981        self.model.A = Set()
1982        self.model.B = Set()
1983        self.model.D = Set(within=self.model.A*self.model.B)
1984        self.instance = self.model.create("setA.dat")
1985        self.failUnlessEqual( len(self.instance.D), 3)
1986
1987    def test_io5(self):
1988        OUTPUT=open("setA.dat","w")
1989        print >>OUTPUT, "data;"
1990        print >>OUTPUT, "set A := A1 A2 A3;"
1991        print >>OUTPUT, "set B := 1 2 3 4;"
1992        print >>OUTPUT, "set D : A1 A2 A3 :="
1993        print >>OUTPUT, "    1   +  -  +"
1994        print >>OUTPUT, "    2   +  -  +"
1995        print >>OUTPUT, "    3   +  -  +"
1996        print >>OUTPUT, "    4   +  -  +;"
1997        print >>OUTPUT, "end;"
1998        OUTPUT.close()
1999        self.model.A = Set()
2000        self.model.B = Set()
2001        self.model.D = Set(within=self.model.A*self.model.B)
2002        self.instance = self.model.create("setA.dat")
2003        self.failUnlessEqual( len(self.instance.D), 8)
2004
2005    def test_io6(self):
2006        OUTPUT=open("setA.dat","w")
2007        print >>OUTPUT, "data;"
2008        print >>OUTPUT, "set A := A1 A2 A3;"
2009        print >>OUTPUT, "set B := 1 2 3 4;"
2010        print >>OUTPUT, "set E :="
2011        print >>OUTPUT, "(A1,1,*) A1 A2"
2012        print >>OUTPUT, "(A2,2,*) A2 A3"
2013        print >>OUTPUT, "(A3,3,*) A1 A3 ;"
2014        print >>OUTPUT, "end;"
2015        OUTPUT.close()
2016        self.model.A = Set()
2017        self.model.B = Set()
2018        self.model.E = Set(within=self.model.A*self.model.B*self.model.A)
2019        self.instance = self.model.create("setA.dat")
2020        self.failUnlessEqual( len(self.instance.E), 6)
2021
2022    def test_io7(self):
2023        OUTPUT=open("setA.dat","w")
2024        print >>OUTPUT, "data;"
2025        print >>OUTPUT, "set A := A1 A2 A3;"
2026        print >>OUTPUT, "set B := 1 2 3 4;"
2027        print >>OUTPUT, "set F[A1] := 1 3 5;"
2028        print >>OUTPUT, "set F[A2] := 2 4 6;"
2029        print >>OUTPUT, "set F[A3] := 3 5 7;"
2030        print >>OUTPUT, "end;"
2031        OUTPUT.close()
2032        self.model.A = Set()
2033        self.model.B = Set()
2034        self.model.F = Set(self.model.A)
2035        self.instance = self.model.create("setA.dat")
2036        self.failUnlessEqual( self.instance.F.dim(), 1)
2037        self.failUnlessEqual( len(self.instance.F.keys()), 3)
2038        self.failUnlessEqual( len(self.instance.F['A1']), 3)
2039
2040
2041def init_fn(model):
2042    return []
2043
2044def tmp_constructor(index,ctr,model):
2045    if ctr == 10:
2046        return None
2047    else:
2048        return ctr
2049
2050class SetErrors(PyomoModel):
2051
2052    def test_membership(self):
2053        self.failUnlessEqual( 0 in Boolean, True)
2054        self.failUnlessEqual( 1 in Boolean, True)
2055        self.failUnlessEqual( True in Boolean, True)
2056        self.failUnlessEqual( False in Boolean, True)
2057        self.failUnlessEqual( 1.1 in Boolean, False)
2058        self.failUnlessEqual( 2 in Boolean, False)
2059
2060        self.failUnlessEqual( 0 in Integers, True)
2061        self.failUnlessEqual( 1 in Integers, True)
2062        self.failUnlessEqual( True in Integers, False)
2063        self.failUnlessEqual( False in Integers, False)
2064        self.failUnlessEqual( 1.1 in Integers, False)
2065        self.failUnlessEqual( 2 in Integers, True)
2066
2067        self.failUnlessEqual( 0 in Reals, True)
2068        self.failUnlessEqual( 1 in Reals, True)
2069        self.failUnlessEqual( True in Reals, False)
2070        self.failUnlessEqual( False in Reals, False)
2071        self.failUnlessEqual( 1.1 in Reals, True)
2072        self.failUnlessEqual( 2 in Reals, True)
2073
2074        self.failUnlessEqual( 0 in Any, True)
2075        self.failUnlessEqual( 1 in Any, True)
2076        self.failUnlessEqual( True in Any, True)
2077        self.failUnlessEqual( False in Any, True)
2078        self.failUnlessEqual( 1.1 in Any, True)
2079        self.failUnlessEqual( 2 in Any, True)
2080
2081    def test_setargs1(self):
2082        try:
2083            a=Set()
2084            c=Set(a,foo=None)
2085            self.fail("test_setargs1 - expected error because of bad argument")
2086        except ValueError:
2087            pass
2088
2089    def test_setargs2(self):
2090        try:
2091            a=Set()
2092            b=Set(a)
2093            c=Set(within=b, dimen=2)
2094            self.fail("test_setargs1 - expected error because of bad argument")
2095        except ValueError:
2096            pass
2097        a=Set()
2098        b=Set(a)
2099        c=Set(within=b, dimen=1)
2100        self.failUnlessEqual(c.within,b)
2101        c.within = a
2102        self.failUnlessEqual(c.within,a)
2103
2104    def test_setargs3(self):
2105        a=Set(dimen=2, initialize=(1,2))
2106        try:
2107            a=Set(dimen=1, initialize=(1,2))
2108            self.fail("test_setargs3 - expected error because of bad argument")
2109        except ValueError:
2110            pass
2111
2112    def test_verify(self):
2113        a=Set(initialize=[1,2,3])
2114        b=Set(within=a)
2115        try:
2116            b._verify(4)
2117            self.fail("test_verify - bad value was expected")
2118        except ValueError:
2119            pass
2120        self.failUnlessEqual(b._verify(4,False),False)
2121        #
2122        c=Set()
2123        try:
2124            c._verify( (1,2) )
2125            self.fail("test_verify - bad value was expected")
2126        except ValueError:
2127            pass
2128        self.failUnlessEqual(c._verify( (1,2),False),False)
2129        #
2130        c=Set(dimen=2)
2131        try:
2132            c._verify( (1,2,3) )
2133            self.fail("test_verify - bad value was expected")
2134        except ValueError:
2135            pass
2136        self.failUnlessEqual(c._verify( (1,2,3),False),False)
2137
2138    def test_construct(self):
2139        a = Set(initialize={})
2140        try:
2141            a.construct()
2142            self.fail("test_construct - expected failure constructing with a dictionary")
2143        except ValueError:
2144            pass
2145        #
2146        a = Set(initialize=init_fn)
2147        try:
2148            a.construct()
2149            self.fail("test_construct - expected exception due to None model")
2150        except ValueError:
2151            pass
2152
2153    def test_add(self):
2154        a=Set()
2155        a.add(1)
2156        a.add("a")
2157        try:
2158            a.add({})
2159            self.fail("test_add - expected type error because {} is unhashable")
2160        except:
2161            pass
2162
2163    def test_getitem(self):
2164        a=Set(initialize=[1,2])
2165        try:
2166            a[0]
2167            self.fail("test_getitem - cannot index an unordered set")
2168        except IndexError:
2169            pass
2170
2171    def test_eq(self):
2172        a=Set(dimen=1,name="a",initialize=[1,2])
2173        a.construct()
2174        b=Set(dimen=2)
2175        self.failUnlessEqual(a==b,False)
2176        self.failUnless(not a.__eq__(Boolean))
2177        self.failUnless(not Boolean.__eq__(a))
2178
2179    def test_neq(self):
2180        a=Set(dimen=1,initialize=[1,2])
2181        a.construct()
2182        b=Set(dimen=2)
2183        self.failUnlessEqual(a!=b,True)
2184        self.failUnless(a.__ne__(Boolean))
2185        self.failUnless(Boolean.__ne__(a))
2186
2187    def test_contains(self):
2188        a=Set(initialize=[1,3,5,7])
2189        a.construct()
2190        b=Set(initialize=[1,3])
2191        b.construct()
2192        self.failUnlessEqual(b in a, True)
2193        self.failUnlessEqual(a in b, False)
2194        self.failUnlessEqual(1 in Integers, True)
2195        self.failUnlessEqual(1 in NonNegativeIntegers, True)
2196
2197    def test_subset(self):
2198        try:
2199            Integers in Reals
2200            #Integers.issubset(Reals)
2201            self.fail("test_subset - expected TypeError")
2202        except TypeError:
2203            pass
2204        try:
2205            a=Set(dimen=1)
2206            b=Set(dimen=2)
2207            a in b
2208            self.fail("test_subset - expected ValueError")
2209        except ValueError:
2210            pass
2211
2212    def test_superset(self):
2213        try:
2214            Reals >= Integers
2215            #Integers.issubset(Reals)
2216            self.fail("test_subset - expected TypeError")
2217        except TypeError:
2218            pass
2219        a=Set(initialize=[1,3,5,7])
2220        a.construct()
2221        b=Set(initialize=[1,3])
2222        b.construct()
2223        self.failUnlessEqual(Reals >= b, True)
2224        self.failUnlessEqual(Reals >= [1,3,7], True)
2225        self.failUnlessEqual(Reals >= [1,3,7,"a"], False)
2226        self.failUnlessEqual(a >= b, True)
2227
2228    def test_lt(self):
2229        try:
2230            Integers < Reals
2231            self.fail("test_subset - expected TypeError")
2232        except TypeError:
2233            pass
2234        a=Set(initialize=[1,3,5,7])
2235        a.construct()
2236        try:
2237            a < Reals
2238            self.fail("test_subset - expected TypeError")
2239        except TypeError:
2240            pass
2241        b=Set(initialize=[1,3,5])
2242        b.construct()
2243        self.failUnlessEqual(a<a,False)
2244        self.failUnlessEqual(b<a,True)
2245        c=Set(initialize=[(1,2)])
2246        c.construct()
2247        try:
2248            a<c
2249            self.fail("test_subset - expected ValueError")
2250        except ValueError:
2251            pass
2252
2253    def test_gt(self):
2254        a=Set(initialize=[1,3,5,7])
2255        a.construct()
2256        c=Set(initialize=[(1,2)])
2257        c.construct()
2258        try:
2259            a>c
2260            self.fail("test_subset - expected ValueError")
2261        except ValueError:
2262            pass
2263           
2264    def test_or(self):
2265        a=Set(initialize=[1,2,3])
2266        c=Set(initialize=[(1,2)])
2267        c.construct()
2268        try:
2269            Reals | Integers
2270            self.fail("test_or - expected TypeError")
2271        except TypeError:
2272            pass
2273        try:
2274            a | Integers
2275            self.fail("test_or - expected TypeError")
2276        except TypeError:
2277            pass
2278        try:
2279            a | c
2280            self.fail("test_or - expected ValueError")
2281        except ValueError:
2282            pass
2283
2284    def test_and(self):
2285        a=Set(initialize=[1,2,3])
2286        c=Set(initialize=[(1,2)])
2287        c.construct()
2288        try:
2289            Reals & Integers
2290            self.fail("test_and - expected TypeError")
2291        except TypeError:
2292            pass
2293        try:
2294            a & Integers
2295            self.fail("test_and - expected TypeError")
2296        except TypeError:
2297            pass
2298        try:
2299            a & c
2300            self.fail("test_and - expected ValueError")
2301        except ValueError:
2302            pass
2303
2304    def test_xor(self):
2305        a=Set(initialize=[1,2,3])
2306        c=Set(initialize=[(1,2)])
2307        c.construct()
2308        try:
2309            Reals ^ Integers
2310            self.fail("test_xor - expected TypeError")
2311        except TypeError:
2312            pass
2313        try:
2314            a ^ Integers
2315            self.fail("test_xor - expected TypeError")
2316        except TypeError:
2317            pass
2318        try:
2319            a ^ c
2320            self.fail("test_xor - expected ValueError")
2321        except ValueError:
2322            pass
2323
2324    def test_sub(self):
2325        a=Set(initialize=[1,2,3])
2326        c=Set(initialize=[(1,2)])
2327        c.construct()
2328        try:
2329            Reals - Integers
2330            self.fail("test_sub - expected TypeError")
2331        except TypeError:
2332            pass
2333        try:
2334            a - Integers
2335            self.fail("test_sub - expected TypeError")
2336        except TypeError:
2337            pass
2338        try:
2339            a - c
2340            self.fail("test_sub - expected ValueError")
2341        except ValueError:
2342            pass
2343
2344    def test_mul(self):
2345        a=Set(initialize=[1,2,3])
2346        c=Set(initialize=[(1,2)])
2347        c.construct()
2348        try:
2349            Reals * Integers
2350            self.fail("test_mul - expected TypeError")
2351        except TypeError:
2352            pass
2353        try:
2354            a * Integers
2355            self.fail("test_mul - expected TypeError")
2356        except TypeError:
2357            pass
2358        try:
2359            a * 1
2360            self.fail("test_mul - expected TypeError")
2361        except TypeError:
2362            pass
2363        b = a * c
2364
2365    def test_arrayset_construct(self):
2366        a=Set(initialize=[1,2,3])
2367        a.construct()
2368        b=Set(a, initialize=tmp_constructor)
2369        try:
2370            b.construct({4:None})
2371            self.fail("test_arrayset_construct - expected KeyError")
2372        except KeyError:
2373            pass
2374        b._constructed=False
2375        try:
2376            b.construct()
2377            self.fail("test_arrayset_construct - expected ValueError")
2378        except ValueError:
2379            pass
2380        b=Set(a,a, initialize=tmp_constructor)
2381        for i in b:
2382          self.failUnlessEqual(i in a, True)
2383        try:
2384            b.construct()
2385            self.fail("test_arrayset_construct - expected ValueError")
2386        except ValueError:
2387            pass
2388
2389    def test_prodset(self):
2390        a=Set(initialize=[1,2])
2391        a.construct()
2392        b=Set(initialize=[6,7])
2393        b.construct()
2394        c=a*b
2395        c.construct()
2396        self.failUnlessEqual((6,2) in c, False)
2397        c=coopr.pyomo.base.sets._ProductSet(a,b)
2398        c.virtual=True
2399        self.failUnlessEqual((6,2) in c, False)
2400        self.failUnlessEqual((1,7) in c, True)
2401        c=coopr.pyomo.base.sets._ProductSet()
2402        c.virtual=True
2403        c.construct()
2404        c=coopr.pyomo.base.sets._ProductSet(a,b,initialize={(1,7):None,(2,6):None})
2405        c.construct()
2406        c=coopr.pyomo.base.sets._ProductSet(a,b,initialize=(1,7))
2407        c.construct()
2408
2409def virt_constructor(y,model):
2410    return RealSet(validate=lambda x,model: x>y)
2411
2412class ArraySetVirtual(unittest.TestCase):
2413
2414    def test_construct(self):
2415        a=Set(initialize=[1,2,3])
2416        a.construct()
2417        b=Set(a, initialize=virt_constructor)
2418        #b.construct()
2419
2420if __name__ == "__main__":
2421   unittest.main()
2422
Note: See TracBrowser for help on using the repository browser.