source: coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_modeldata.py @ 2302

Last change on this file since 2302 was 2302, checked in by wehart, 10 years ago

Adding tests for loading sets and parameters from spreadsheets.

File size: 37.3 KB
Line 
1#
2# Unit Tests for ModelData objects
3#
4
5import unittest
6import os
7import sys
8from os.path import abspath, dirname
9coopr_dir=dirname(dirname(abspath(__file__)))+os.sep+".."+os.sep+".."
10sys.path.insert(0, coopr_dir)
11from coopr.pyomo import *
12import coopr
13import pyutilib.common
14
15currdir=dirname(abspath(__file__))+os.sep
16example_dir=coopr_dir+os.sep+".."+os.sep+"examples"+os.sep+"pyomo"+os.sep+"tutorials"+os.sep+"tab"+os.sep
17tutorial_dir=coopr_dir+os.sep+".."+os.sep+"examples"+os.sep+"pyomo"+os.sep+"tutorials"+os.sep
18
19try:
20  from win32com.client.dynamic import Dispatch
21  _win32com=True
22except:
23  _win32com=False #pragma:nocover
24
25
26class PyomoTableData(unittest.TestCase):
27
28    def run(self, result=None):
29        """ Disable the tests if win32com is not available """
30        if not _win32com:
31           return
32        unittest.TestCase.run(self,result)
33
34    def setUp(self):
35        pass
36
37    def construct(self,filename):
38        pass
39
40    def test_read_set(self):
41        td = DataManagerFactory('xls')
42        td.initialize(currdir+"Book1.xls", range="TheRange", format='set', set="X")
43        try:
44           td.open()
45           td.read()
46           td.close()
47           self.failUnlessEqual( td._info, ['set', 'X', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0])
48        except pyutilib.common.ApplicationError:
49           pass
50
51    def test_read_param1(self):
52        td = DataManagerFactory('xls')
53        td.initialize(currdir+"Book1.xls", range="TheRange", index=['aa'], param=['bb','cc','dd'])
54        try:
55          td.open()
56          td.read()
57          td.close()
58          self.failUnlessEqual( td._info, ['param', ':', 'bb', 'cc', 'dd', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0])
59        except pyutilib.common.ApplicationError:
60          pass
61
62    def test_read_param2(self):
63        td = DataManagerFactory('xls')
64        td.initialize(currdir+"Book1.xls",range="TheRange", index_name="X", index=['aa'], param=['bb','cc','dd'])
65        try:
66          td.open()
67          td.read()
68          td.close()
69          self.failUnlessEqual( td._info, ['param', ':', 'X', ':', 'bb', 'cc', 'dd', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0])
70        except pyutilib.common.ApplicationError:
71          pass
72
73    def test_read_param3(self):
74        td = DataManagerFactory('xls')
75        td.initialize(currdir+"Book1.xls",range="TheRange", index_name="X", index=['aa','bb','cc'], param=["dd"], param_name={'dd':'a'})
76        try:
77          td.open()
78          td.read()
79          td.close()
80          self.failUnlessEqual( td._info, ['param', ':', 'X', ':', 'a', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0])
81        except pyutilib.common.ApplicationError:
82          pass
83
84    def test_read_param4(self):
85        td = DataManagerFactory('xls')
86        td.initialize(currdir+"Book1.xls",range="TheRange", index_name="X", index=['aa','bb'], param=['cc','dd'], param_name={'cc':'a', 'dd':'b'})
87        try:
88          td.open()
89          td.read()
90          td.close()
91          self.failUnlessEqual( td._info, ['param', ':', 'X', ':', 'a', 'b', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0])
92        except pyutilib.common.ApplicationError:
93          pass
94
95    def test_read_array1(self):
96        td = DataManagerFactory('xls')
97        td.initialize(currdir+"Book1.xls",range="TheRange", param="X", format="array")
98        try:
99          td.open()
100          td.read()
101          td.close()
102          self.failUnlessEqual( td._info, ['param', 'X', ':', 'bb', 'cc', 'dd', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0])
103        except pyutilib.common.ApplicationError:
104          pass
105
106    def test_read_array2(self):
107        td = DataManagerFactory('xls')
108        td.initialize(currdir+"Book1.xls",range="TheRange",param="X",format="transposed_array")
109        try:
110          td.open()
111          td.read()
112          td.close()
113          self.failUnlessEqual( td._info, ['param', 'X', '(tr)',':', 'bb', 'cc', 'dd', ':=', 'A1', 2.0, 3.0, 4.0, 'A5', 6.0, 7.0, 8.0, 'A9', 10.0, 11.0, 12.0, 'A13', 14.0, 15.0, 16.0])
114        except pyutilib.common.ApplicationError:
115          pass
116
117    def test_error1(self):
118        td = DataManagerFactory('xls')
119        td.initialize("bad")
120        try:
121            td.open()
122            self.fail("Expected IOError because of bad file")
123        except IOError:
124            pass
125
126    def test_error2(self):
127        td = DataManagerFactory('xls')
128        try:
129            td.open()
130            self.fail("Expected IOError because no file specified")
131        except (IOError,AttributeError):
132            pass
133
134    def test_error3(self):
135        td = DataManagerFactory('txt')
136        try:
137            td.initialize(currdir+"display.txt")
138            td.open()
139            self.fail("Expected IOError because of bad file type")
140        except (IOError, AttributeError):
141            pass
142
143    def test_error4(self):
144        td = DataManagerFactory('txt')
145        try:
146            td.initialize(filename=currdir+"dummy")
147            td.open()
148            self.fail("Expected IOError because of bad file type")
149        except (IOError, AttributeError):
150            pass
151
152    def test_error5(self):
153        td = DataManagerFactory('tab')
154        td.initialize(example_dir+"D.tab", param="D", format="foo")
155        td.open()
156        try:
157            td.read()
158            self.fail("Expected IOError because of bad format")
159        except ValueError:
160            pass
161
162
163class PyomoModelData(unittest.TestCase):
164
165    def test_md1(self):
166        md = ModelData()
167        md.add(example_dir+"A.tab")
168        try:
169            md.read()
170            self.fail("Must specify a model")
171        except ValueError:
172            pass
173        model=Model()
174        try:
175            md.read(model)
176            self.fail("Expected IOError")
177        except IOError:
178            pass
179        model.A=Set()
180
181    def test_md2(self):
182        md = ModelData()
183        md.add(currdir+"data1.dat")
184        model=Model()
185        model.A=Set()
186        md.read(model)
187
188    def test_md3(self):
189        md = ModelData()
190        md.add(currdir+"data2.dat")
191        model=Model()
192        model.A=Set()
193        try:
194            md.read(model)
195            self.fail("Expected error because of extraneous text")
196        except IOError:
197            pass
198
199    def test_md4(self):
200        md = ModelData()
201        md.add(currdir+"data3.dat")
202        model=Model()
203        model.A=Set()
204        model.B=Set()
205        model.C=Set()
206        md.read(model)
207
208    def test_md5(self):
209        md = ModelData()
210        md.add(currdir+"data4.dat")
211        model=Model()
212        model.A=Set()
213        try:
214            md.read(model)
215        except ValueError:
216            pass
217
218    def test_md6(self):
219        md = ModelData()
220        md.add(currdir+"data5.dat")
221        model=Model()
222        model.A=Set()
223        try:
224            md.read(model)
225        except ValueError:
226            pass
227
228    def test_md7(self):
229        md = ModelData()
230        md.add(currdir+"data1.tab")
231        model=Model()
232        try:
233            md.read(model)
234            self.fail("Expected IOError")
235        except IOError:
236            pass
237
238    def test_md8(self):
239        md = ModelData()
240        md.add(currdir+"data6.dat")
241        model=Model()
242        model.A=Set()
243        try:
244            md.read(model)
245            self.fail("Expected IOError")
246        except IOError:
247            pass
248
249    def test_md9(self):
250        md = ModelData()
251        md.add(currdir+"data7.dat")
252        model=Model()
253        model.A=Set()
254        model.B=Param(model.A)
255        md.read(model)
256
257    def test_md10(self):
258        md = ModelData()
259        md.add(currdir+"data8.dat")
260        model=Model()
261        model.A=Param(within=Boolean)
262        model.B=Param(within=Boolean)
263        md.read(model)
264
265    def test_md11(self):
266        cwd = os.getcwd()
267        os.chdir(currdir)
268        md = ModelData()
269        md.add(currdir+"data11.dat")
270        model=Model()
271        model.A=Set()
272        model.B=Set()
273        model.C=Set()
274        model.D=Set()
275        md.read(model)
276        os.chdir(cwd)
277
278
279class TestImport(unittest.TestCase):
280
281    def test_tableA1(self):
282        """Importing a single column of data"""
283        pyutilib.misc.setup_redirect(currdir+'importA1.dat')
284        print "import "+os.path.abspath(example_dir+'A.tab')+" format=set: A;"
285        pyutilib.misc.reset_redirect()
286        model=Model()
287        model.A = Set()
288        instance = model.create(currdir+'importA1.dat')
289        self.failUnlessEqual(instance.A.data(), set(['A1', 'A2', 'A3']))
290        os.remove(currdir+'importA1.dat')
291
292    def test_tableA2(self):
293        """Importing a single column of data"""
294        pyutilib.misc.setup_redirect(currdir+'importA2.dat')
295        print "import "+os.path.abspath(example_dir+'A.tab')+" ;"
296        pyutilib.misc.reset_redirect()
297        model=Model()
298        model.A = Set()
299        try:
300            instance = model.create(currdir+'importA2.dat')
301            self.fail("Should fail because no set name is specified")
302        except IOError:
303            pass
304        os.remove(currdir+'importA2.dat')
305
306    def test_tableA3(self):
307        """Importing a single column of data"""
308        pyutilib.misc.setup_redirect(currdir+'importA3.dat')
309        print "import "+os.path.abspath(example_dir+'A.tab')+" : A ;"
310        pyutilib.misc.reset_redirect()
311        model=Model()
312        model.A = Set()
313        try:
314            instance = model.create(currdir+'importA3.dat')
315            self.fail("Should fail because no index is specified")
316        except IOError:
317            pass
318        os.remove(currdir+'importA3.dat')
319
320    def test_tableB(self):
321        """Same as test_tableA"""
322        pyutilib.misc.setup_redirect(currdir+'importB.dat')
323        print "import "+os.path.abspath(example_dir+'B.tab')+" format=set:B;"
324        pyutilib.misc.reset_redirect()
325        model=Model()
326        model.B = Set()
327        instance = model.create(currdir+'importB.dat')
328        self.failUnlessEqual(instance.B.data(), set([1, 2, 3]))
329        os.remove(currdir+'importB.dat')
330
331    def test_tableC(self):
332        """Importing a multi-column table, where all columns are
333        treated as values for a set with tuple values."""
334        pyutilib.misc.setup_redirect(currdir+'importC.dat')
335        print "import "+os.path.abspath(example_dir+'C.tab')+" format=set: C ;"
336        pyutilib.misc.reset_redirect()
337        model=Model()
338        model.C = Set(dimen=2)
339        instance = model.create(currdir+'importC.dat')
340        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A1',2), ('A1',3), ('A2',1), ('A2',2), ('A2',3), ('A3',1), ('A3',2), ('A3',3)]))
341        os.remove(currdir+'importC.dat')
342
343    def test_tableD(self):
344        """Importing a 2D array of data as a set."""
345        pyutilib.misc.setup_redirect(currdir+'importD.dat')
346        print "import "+os.path.abspath(example_dir+'D.tab')+" format=set_array: C ;"
347        pyutilib.misc.reset_redirect()
348        model=Model()
349        model.C = Set(dimen=2)
350        instance = model.create(currdir+'importD.dat')
351        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A2',2), ('A3',3)]))
352        os.remove(currdir+'importD.dat')
353
354    def test_tableZ(self):
355        """Importing a single parameter"""
356        pyutilib.misc.setup_redirect(currdir+'importZ.dat')
357        print "import "+os.path.abspath(example_dir+'Z.tab')+" format=param: Z ;"
358        pyutilib.misc.reset_redirect()
359        model=Model()
360        model.Z = Param(default=99.0)
361        instance = model.create(currdir+'importZ.dat')
362        self.failUnlessEqual(instance.Z.value, 1.1)
363        os.remove(currdir+'importZ.dat')
364
365    def test_tableY(self):
366        """Same as tableXW."""
367        pyutilib.misc.setup_redirect(currdir+'importY.dat')
368        print "import "+os.path.abspath(example_dir+'Y.tab')+" : [A] Y;"
369        pyutilib.misc.reset_redirect()
370        model=Model()
371        model.A = Set(initialize=['A1','A2','A3','A4'])
372        model.Y = Param(model.A)
373        instance = model.create(currdir+'importY.dat')
374        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
375        self.failUnlessEqual(instance.Y.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
376        os.remove(currdir+'importY.dat')
377
378    def test_tableXW_1(self):
379        """Importing a table, but only reporting the values for the non-index
380        parameter columns.  The first column is assumed to represent an
381        index column."""
382        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
383        print "import "+os.path.abspath(example_dir+'XW.tab')+": [A] X W;"
384        pyutilib.misc.reset_redirect()
385        model=Model()
386        model.A = Set(initialize=['A1','A2','A3','A4'])
387        model.X = Param(model.A)
388        model.W = Param(model.A)
389        instance = model.create(currdir+'importXW.dat')
390        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
391        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
392        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
393        os.remove(currdir+'importXW.dat')
394
395    def test_tableXW_2(self):
396        """Like test_tableXW_1, except that set A is not defined."""
397        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
398        print "import "+os.path.abspath(example_dir+'XW.tab')+": [A] X W;"
399        pyutilib.misc.reset_redirect()
400        model=Model()
401        model.A = Set()
402        model.X = Param(model.A)
403        model.W = Param(model.A)
404        instance = model.create(currdir+'importXW.dat')
405        self.failUnlessEqual(instance.A.data(), set())
406        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
407        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
408        os.remove(currdir+'importXW.dat')
409
410    def test_tableXW_3(self):
411        """Like test_tableXW_1, except that set A is defined in the import statment."""
412        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
413        print "import "+os.path.abspath(example_dir+'XW.tab')+": A=[A] X W;"
414        pyutilib.misc.reset_redirect()
415        model=Model()
416        model.A = Set()
417        model.X = Param(model.A)
418        model.W = Param(model.A)
419        instance = model.create(currdir+'importXW.dat')
420        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3']))
421        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
422        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
423        os.remove(currdir+'importXW.dat')
424
425    def test_tableXW_4(self):
426        """Like test_tableXW_1, except that set A is defined in the import statment and all values are mapped."""
427        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
428        print "import "+os.path.abspath(example_dir+'XW.tab')+": B=[A] R=X S=W;"
429        pyutilib.misc.reset_redirect()
430        model=Model()
431        model.B = Set()
432        model.R = Param(model.B)
433        model.S = Param(model.B)
434        instance = model.create(currdir+'importXW.dat')
435        self.failUnlessEqual(instance.B.data(), set(['A1','A2','A3']))
436        self.failUnlessEqual(instance.R.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
437        self.failUnlessEqual(instance.S.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
438        os.remove(currdir+'importXW.dat')
439
440    def test_tableT(self):
441        """Importing a 2D array of parameters that are transposed."""
442        pyutilib.misc.setup_redirect(currdir+'importT.dat')
443        print "import "+os.path.abspath(example_dir+'T.tab')+" format=transposed_array : T;"
444        pyutilib.misc.reset_redirect()
445        model=Model()
446        model.A = Set()
447        model.B = Set()
448        model.T = Param(model.A, model.B)
449        instance = model.create(currdir+'importT.dat')
450        self.failUnlessEqual(instance.T.data(), {('A2', 'I1'): 2.3, ('A1', 'I2'): 1.4, ('A1', 'I3'): 1.5, ('A1', 'I4'): 1.6, ('A1', 'I1'): 1.3, ('A3', 'I4'): 3.6, ('A2', 'I4'): 2.6, ('A3', 'I1'): 3.3, ('A2', 'I3'): 2.5, ('A3', 'I2'): 3.4, ('A2', 'I2'): 2.4, ('A3', 'I3'): 3.5})
451        os.remove(currdir+'importT.dat')
452
453    def test_tableU(self):
454        """Importing a 2D array of parameters."""
455        pyutilib.misc.setup_redirect(currdir+'importU.dat')
456        print "import "+os.path.abspath(example_dir+'U.tab')+" format=array : U;"
457        pyutilib.misc.reset_redirect()
458        model=Model()
459        model.A = Set()
460        model.B = Set()
461        model.U = Param(model.A, model.B)
462        instance = model.create(currdir+'importU.dat')
463        self.failUnlessEqual(instance.U.data(), {('I2', 'A1'): 1.4, ('I3', 'A1'): 1.5, ('I3', 'A2'): 2.5, ('I4', 'A1'): 1.6, ('I3', 'A3'): 3.5, ('I1', 'A2'): 2.3, ('I4', 'A3'): 3.6, ('I1', 'A3'): 3.3, ('I4', 'A2'): 2.6, ('I2', 'A3'): 3.4, ('I1', 'A1'): 1.3, ('I2', 'A2'): 2.4})
464        os.remove(currdir+'importU.dat')
465
466    def test_tableS(self):
467        """Importing a table, but only reporting the values for the non-index
468        parameter columns.  The first column is assumed to represent an
469        index column.  A missing value is represented in the column data."""
470        pyutilib.misc.setup_redirect(currdir+'importS.dat')
471        print "import "+os.path.abspath(example_dir+'S.tab')+": [A] S ;"
472        pyutilib.misc.reset_redirect()
473        model=Model()
474        model.A = Set(initialize=['A1','A2','A3','A4'])
475        model.S = Param(model.A)
476        instance = model.create(currdir+'importS.dat')
477        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
478        self.failUnlessEqual(instance.S.data(), {'A1':3.3,'A3':3.5})
479        os.remove(currdir+'importS.dat')
480
481    def test_tablePO(self):
482        """Importing a table that has multiple indexing columns"""
483        pyutilib.misc.setup_redirect(currdir+'importPO.dat')
484        print "import "+os.path.abspath(example_dir+'PO.tab')+" : J=[A,B] P O;"
485        pyutilib.misc.reset_redirect()
486        model=Model()
487        model.J = Set(dimen=2)
488        model.P = Param(model.J)
489        model.O = Param(model.J)
490        instance = model.create(currdir+'importPO.dat')
491        self.failUnlessEqual(instance.J.data(), set([('A3', 'B3'), ('A1', 'B1'), ('A2', 'B2')]) )
492        self.failUnlessEqual(instance.P.data(), {('A3', 'B3'): 4.5, ('A1', 'B1'): 4.3, ('A2', 'B2'): 4.4} )
493        self.failUnlessEqual(instance.O.data(), {('A3', 'B3'): 5.5, ('A1', 'B1'): 5.3, ('A2', 'B2'): 5.4})
494        os.remove(currdir+'importPO.dat')
495
496
497
498class TestSpreadsheet(unittest.TestCase):
499
500    def run(self, result=None):
501        """ Disable the tests if win32com is not available """
502        if not _win32com:
503           return
504        unittest.TestCase.run(self,result)
505
506    def test_tableA1(self):
507        """Importing a single column of data"""
508        pyutilib.misc.setup_redirect(currdir+'importA1.dat')
509        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Atable format=set: A;"
510        pyutilib.misc.reset_redirect()
511        model=Model()
512        model.A = Set()
513        instance = model.create(currdir+'importA1.dat')
514        self.failUnlessEqual(instance.A.data(), set(['A1', 'A2', 'A3']))
515        os.remove(currdir+'importA1.dat')
516
517    def test_tableA2(self):
518        """Importing a single column of data"""
519        pyutilib.misc.setup_redirect(currdir+'importA2.dat')
520        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Atable ;"
521        pyutilib.misc.reset_redirect()
522        model=Model()
523        model.A = Set()
524        try:
525            instance = model.create(currdir+'importA2.dat')
526            self.fail("Should fail because no set name is specified")
527        except IOError:
528            pass
529        os.remove(currdir+'importA2.dat')
530
531    def test_tableA3(self):
532        """Importing a single column of data"""
533        pyutilib.misc.setup_redirect(currdir+'importA3.dat')
534        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Atable : A ;"
535        pyutilib.misc.reset_redirect()
536        model=Model()
537        model.A = Set()
538        try:
539            instance = model.create(currdir+'importA3.dat')
540            self.fail("Should fail because no index is specified")
541        except IOError:
542            pass
543        os.remove(currdir+'importA3.dat')
544
545    def test_tableB(self):
546        """Same as test_tableA"""
547        pyutilib.misc.setup_redirect(currdir+'importB.dat')
548        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Btable format=set:B;"
549        pyutilib.misc.reset_redirect()
550        model=Model()
551        model.B = Set()
552        instance = model.create(currdir+'importB.dat')
553        self.failUnlessEqual(instance.B.data(), set([1, 2, 3]))
554        os.remove(currdir+'importB.dat')
555
556    def test_tableC(self):
557        """Importing a multi-column table, where all columns are
558        treated as values for a set with tuple values."""
559        pyutilib.misc.setup_redirect(currdir+'importC.dat')
560        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Ctable format=set: C ;"
561        pyutilib.misc.reset_redirect()
562        model=Model()
563        model.C = Set(dimen=2)
564        instance = model.create(currdir+'importC.dat')
565        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A1',2), ('A1',3), ('A2',1), ('A2',2), ('A2',3), ('A3',1), ('A3',2), ('A3',3)]))
566        os.remove(currdir+'importC.dat')
567
568    def test_tableD(self):
569        """Importing a 2D array of data as a set."""
570        pyutilib.misc.setup_redirect(currdir+'importD.dat')
571        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Dtable format=set_array: C ;"
572        pyutilib.misc.reset_redirect()
573        model=Model()
574        model.C = Set(dimen=2)
575        instance = model.create(currdir+'importD.dat')
576        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A2',2), ('A3',3)]))
577        os.remove(currdir+'importD.dat')
578
579    def test_tableZ(self):
580        """Importing a single parameter"""
581        pyutilib.misc.setup_redirect(currdir+'importZ.dat')
582        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Zparam format=param: Z ;"
583        pyutilib.misc.reset_redirect()
584        model=Model()
585        model.Z = Param(default=99.0)
586        instance = model.create(currdir+'importZ.dat')
587        self.failUnlessEqual(instance.Z.value, 1.1)
588        os.remove(currdir+'importZ.dat')
589
590    def test_tableY(self):
591        """Same as tableXW."""
592        pyutilib.misc.setup_redirect(currdir+'importY.dat')
593        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Ytable : [A] Y;"
594        pyutilib.misc.reset_redirect()
595        model=Model()
596        model.A = Set(initialize=['A1','A2','A3','A4'])
597        model.Y = Param(model.A)
598        instance = model.create(currdir+'importY.dat')
599        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
600        self.failUnlessEqual(instance.Y.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
601        os.remove(currdir+'importY.dat')
602
603    def test_tableXW_1(self):
604        """Importing a table, but only reporting the values for the non-index
605        parameter columns.  The first column is assumed to represent an
606        index column."""
607        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
608        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=XWtable : [A] X W;"
609        pyutilib.misc.reset_redirect()
610        model=Model()
611        model.A = Set(initialize=['A1','A2','A3','A4'])
612        model.X = Param(model.A)
613        model.W = Param(model.A)
614        instance = model.create(currdir+'importXW.dat')
615        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
616        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
617        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
618        os.remove(currdir+'importXW.dat')
619
620    def test_tableXW_2(self):
621        """Like test_tableXW_1, except that set A is not defined."""
622        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
623        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=XWtable : [A] X W;"
624        pyutilib.misc.reset_redirect()
625        model=Model()
626        model.A = Set()
627        model.X = Param(model.A)
628        model.W = Param(model.A)
629        instance = model.create(currdir+'importXW.dat')
630        self.failUnlessEqual(instance.A.data(), set())
631        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
632        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
633        os.remove(currdir+'importXW.dat')
634
635    def test_tableXW_3(self):
636        """Like test_tableXW_1, except that set A is defined in the import statment."""
637        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
638        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=XWtable: A=[A] X W;"
639        pyutilib.misc.reset_redirect()
640        model=Model()
641        model.A = Set()
642        model.X = Param(model.A)
643        model.W = Param(model.A)
644        instance = model.create(currdir+'importXW.dat')
645        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3']))
646        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
647        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
648        os.remove(currdir+'importXW.dat')
649
650    def test_tableXW_4(self):
651        """Like test_tableXW_1, except that set A is defined in the import statment and all values are mapped."""
652        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
653        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=XWtable: B=[A] R=X S=W;"
654        pyutilib.misc.reset_redirect()
655        model=Model()
656        model.B = Set()
657        model.R = Param(model.B)
658        model.S = Param(model.B)
659        instance = model.create(currdir+'importXW.dat')
660        self.failUnlessEqual(instance.B.data(), set(['A1','A2','A3']))
661        self.failUnlessEqual(instance.R.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
662        self.failUnlessEqual(instance.S.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
663        os.remove(currdir+'importXW.dat')
664
665    def test_tableT(self):
666        """Importing a 2D array of parameters that are transposed."""
667        pyutilib.misc.setup_redirect(currdir+'importT.dat')
668        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Ttable format=transposed_array : T;"
669        pyutilib.misc.reset_redirect()
670        model=Model()
671        model.A = Set()
672        model.B = Set()
673        model.T = Param(model.A, model.B)
674        instance = model.create(currdir+'importT.dat')
675        self.failUnlessEqual(instance.T.data(), {('A2', 'I1'): 2.3, ('A1', 'I2'): 1.4, ('A1', 'I3'): 1.5, ('A1', 'I4'): 1.6, ('A1', 'I1'): 1.3, ('A3', 'I4'): 3.6, ('A2', 'I4'): 2.6, ('A3', 'I1'): 3.3, ('A2', 'I3'): 2.5, ('A3', 'I2'): 3.4, ('A2', 'I2'): 2.4, ('A3', 'I3'): 3.5})
676        os.remove(currdir+'importT.dat')
677
678    def test_tableU(self):
679        """Importing a 2D array of parameters."""
680        pyutilib.misc.setup_redirect(currdir+'importU.dat')
681        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Utable format=array : U;"
682        pyutilib.misc.reset_redirect()
683        model=Model()
684        model.A = Set()
685        model.B = Set()
686        model.U = Param(model.A, model.B)
687        instance = model.create(currdir+'importU.dat')
688        self.failUnlessEqual(instance.U.data(), {('I2', 'A1'): 1.4, ('I3', 'A1'): 1.5, ('I3', 'A2'): 2.5, ('I4', 'A1'): 1.6, ('I3', 'A3'): 3.5, ('I1', 'A2'): 2.3, ('I4', 'A3'): 3.6, ('I1', 'A3'): 3.3, ('I4', 'A2'): 2.6, ('I2', 'A3'): 3.4, ('I1', 'A1'): 1.3, ('I2', 'A2'): 2.4})
689        os.remove(currdir+'importU.dat')
690
691    def test_tableS(self):
692        """Importing a table, but only reporting the values for the non-index
693        parameter columns.  The first column is assumed to represent an
694        index column.  A missing value is represented in the column data."""
695        pyutilib.misc.setup_redirect(currdir+'importS.dat')
696        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Stable : [A] S ;"
697        pyutilib.misc.reset_redirect()
698        model=Model()
699        model.A = Set(initialize=['A1','A2','A3','A4'])
700        model.S = Param(model.A)
701        instance = model.create(currdir+'importS.dat')
702        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
703        self.failUnlessEqual(instance.S.data(), {'A1':3.3,'A3':3.5})
704        os.remove(currdir+'importS.dat')
705
706    def test_tablePO(self):
707        """Importing a table that has multiple indexing columns"""
708        pyutilib.misc.setup_redirect(currdir+'importPO.dat')
709        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=POtable : J=[A,B] P O;"
710        pyutilib.misc.reset_redirect()
711        model=Model()
712        model.J = Set(dimen=2)
713        model.P = Param(model.J)
714        model.O = Param(model.J)
715        instance = model.create(currdir+'importPO.dat')
716        self.failUnlessEqual(instance.J.data(), set([('A3', 'B3'), ('A1', 'B1'), ('A2', 'B2')]) )
717        self.failUnlessEqual(instance.P.data(), {('A3', 'B3'): 4.5, ('A1', 'B1'): 4.3, ('A2', 'B2'): 4.4} )
718        self.failUnlessEqual(instance.O.data(), {('A3', 'B3'): 5.5, ('A1', 'B1'): 5.3, ('A2', 'B2'): 5.4})
719        os.remove(currdir+'importPO.dat')
720
721
722class TestModelData(unittest.TestCase):
723
724    def test_tableA1(self):
725        """Importing a single column of data"""
726        md = ModelData()
727        md.add(os.path.abspath(example_dir+'A.tab'), format='set', set='A')
728        model=Model()
729        model.A = Set()
730        md.read(model)
731        instance = model.create(md)
732        self.failUnlessEqual(instance.A.data(), set(['A1', 'A2', 'A3']))
733
734    def test_tableA2(self):
735        """Importing a single column of data"""
736        md = ModelData()
737        md.add(os.path.abspath(example_dir+'A.tab'))
738        model=Model()
739        model.A = Set()
740        try:
741            md.read(model)
742            instance = model.create(md)
743            self.fail("Should fail because no set name is specified")
744        except IOError:
745            pass
746
747    def test_tableA3(self):
748        """Importing a single column of data"""
749        md = ModelData()
750        md.add(os.path.abspath(example_dir+'A.tab'), set='A')
751        model=Model()
752        model.A = Set()
753        try:
754            md.read(model)
755            instance = model.create(md)
756            self.fail("Should fail because no index is specified")
757        except IOError:
758            pass
759
760    def test_tableB(self):
761        """Same as test_tableA"""
762        md = ModelData()
763        md.add(os.path.abspath(example_dir+'B.tab'), format='set', set='B')
764        model=Model()
765        model.B = Set()
766        md.read(model)
767        instance = model.create(md)
768        self.failUnlessEqual(instance.B.data(), set([1, 2, 3]))
769
770    def test_tableC(self):
771        """Importing a multi-column table, where all columns are
772        treated as values for a set with tuple values."""
773        md = ModelData()
774        md.add(os.path.abspath(example_dir+'C.tab'), format='set', set='C')
775        model=Model()
776        model.C = Set(dimen=2)
777        md.read(model)
778        instance = model.create(md)
779        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A1',2), ('A1',3), ('A2',1), ('A2',2), ('A2',3), ('A3',1), ('A3',2), ('A3',3)]))
780
781    def test_tableD(self):
782        """Importing a 2D array of data as a set."""
783        md = ModelData()
784        md.add(os.path.abspath(example_dir+'D.tab'), format='set_array', set='C')
785        model=Model()
786        model.C = Set(dimen=2)
787        md.read(model)
788        instance = model.create(md)
789        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A2',2), ('A3',3)]))
790
791    def test_tableZ(self):
792        """Importing a single parameter"""
793        md = ModelData()
794        md.add(os.path.abspath(example_dir+'Z.tab'), format='param', param='Z')
795        model=Model()
796        model.Z = Param(default=99.0)
797        md.read(model)
798        instance = model.create(md)
799        self.failUnlessEqual(instance.Z.value, 1.1)
800
801    def test_tableY(self):
802        """Same as tableXW."""
803        md = ModelData()
804        md.add(os.path.abspath(example_dir+'Y.tab'), index=['A'], param=['Y'])
805        model=Model()
806        model.A = Set(initialize=['A1','A2','A3','A4'])
807        model.Y = Param(model.A)
808        md.read(model)
809        instance = model.create(md)
810        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
811        self.failUnlessEqual(instance.Y.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
812
813    def test_tableXW_1(self):
814        """Importing a table, but only reporting the values for the non-index
815        parameter columns.  The first column is assumed to represent an
816        index column."""
817        md = ModelData()
818        md.add(os.path.abspath(example_dir+'XW.tab'), index=['A'], param=['X','W'])
819        model=Model()
820        model.A = Set(initialize=['A1','A2','A3','A4'])
821        model.X = Param(model.A)
822        model.W = Param(model.A)
823        md.read(model)
824        instance = model.create(md)
825        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
826        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
827        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
828
829    def test_tableXW_2(self):
830        """Like test_tableXW_1, except that set A is not defined."""
831        md = ModelData()
832        md.add(os.path.abspath(example_dir+'XW.tab'), index=['A'], param=['X','W'])
833        model=Model()
834        model.A = Set()
835        model.X = Param(model.A)
836        model.W = Param(model.A)
837        md.read(model)
838        instance = model.create(md)
839        self.failUnlessEqual(instance.A.data(), set())
840        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
841        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
842
843    def test_tableXW_3(self):
844        """Like test_tableXW_1, except that set A is defined in the import statment."""
845        md = ModelData()
846        md.add(os.path.abspath(example_dir+'XW.tab'), index_name='A', index=['A'], param=['X','W'])
847        model=Model()
848        model.A = Set()
849        model.X = Param(model.A)
850        model.W = Param(model.A)
851        md.read(model)
852        instance = model.create(md)
853        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3']))
854        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
855        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
856
857    def test_tableXW_4(self):
858        """Like test_tableXW_1, except that set A is defined in the import statment and all values are mapped."""
859        md = ModelData()
860        md.add(os.path.abspath(example_dir+'XW.tab'), index_name='B', index=['A'], param=['X','W'], param_name={'X':'R', 'W':'S'})
861        model=Model()
862        model.B = Set()
863        model.R = Param(model.B)
864        model.S = Param(model.B)
865        md.read(model)
866        instance = model.create(md)
867        self.failUnlessEqual(instance.B.data(), set(['A1','A2','A3']))
868        self.failUnlessEqual(instance.R.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
869        self.failUnlessEqual(instance.S.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
870
871    def test_tableT(self):
872        """Importing a 2D array of parameters that are transposed."""
873        md = ModelData()
874        md.add(os.path.abspath(example_dir+'T.tab'), format='transposed_array', param='T')
875        model=Model()
876        model.A = Set()
877        model.B = Set()
878        model.T = Param(model.A, model.B)
879        md.read(model)
880        instance = model.create(md)
881        self.failUnlessEqual(instance.T.data(), {('A2', 'I1'): 2.3, ('A1', 'I2'): 1.4, ('A1', 'I3'): 1.5, ('A1', 'I4'): 1.6, ('A1', 'I1'): 1.3, ('A3', 'I4'): 3.6, ('A2', 'I4'): 2.6, ('A3', 'I1'): 3.3, ('A2', 'I3'): 2.5, ('A3', 'I2'): 3.4, ('A2', 'I2'): 2.4, ('A3', 'I3'): 3.5})
882
883    def test_tableU(self):
884        """Importing a 2D array of parameters."""
885        md = ModelData()
886        md.add(os.path.abspath(example_dir+'T.tab'), format='array', param='U')
887        model=Model()
888        model.A = Set()
889        model.B = Set()
890        model.U = Param(model.A, model.B)
891        md.read(model)
892        instance = model.create(md)
893        self.failUnlessEqual(instance.U.data(), {('I2', 'A1'): 1.4, ('I3', 'A1'): 1.5, ('I3', 'A2'): 2.5, ('I4', 'A1'): 1.6, ('I3', 'A3'): 3.5, ('I1', 'A2'): 2.3, ('I4', 'A3'): 3.6, ('I1', 'A3'): 3.3, ('I4', 'A2'): 2.6, ('I2', 'A3'): 3.4, ('I1', 'A1'): 1.3, ('I2', 'A2'): 2.4})
894
895    def test_tableS(self):
896        """Importing a table, but only reporting the values for the non-index
897        parameter columns.  The first column is assumed to represent an
898        index column.  A missing value is represented in the column data."""
899        md = ModelData()
900        md.add(os.path.abspath(example_dir+'S.tab'), index=['A'], param=['S'])
901        model=Model()
902        model.A = Set(initialize=['A1','A2','A3','A4'])
903        model.S = Param(model.A)
904        md.read(model)
905        instance = model.create(md)
906        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
907        self.failUnlessEqual(instance.S.data(), {'A1':3.3,'A3':3.5})
908
909    def test_tablePO(self):
910        """Importing a table that has multiple indexing columns"""
911        pyutilib.misc.setup_redirect(currdir+'importPO.dat')
912        print "import "+os.path.abspath(example_dir+'PO.tab')+" : J=[A,B] P O;"
913        pyutilib.misc.reset_redirect()
914        md = ModelData()
915        md.add(os.path.abspath(example_dir+'PO.tab'), index_name='J', index=['A','B'], param=['P','O'])
916        model=Model()
917        model.J = Set(dimen=2)
918        model.P = Param(model.J)
919        model.O = Param(model.J)
920        md.read(model)
921        instance = model.create(md)
922        self.failUnlessEqual(instance.J.data(), set([('A3', 'B3'), ('A1', 'B1'), ('A2', 'B2')]) )
923        self.failUnlessEqual(instance.P.data(), {('A3', 'B3'): 4.5, ('A1', 'B1'): 4.3, ('A2', 'B2'): 4.4} )
924        self.failUnlessEqual(instance.O.data(), {('A3', 'B3'): 5.5, ('A1', 'B1'): 5.3, ('A2', 'B2'): 5.4})
925
926
927if __name__ == "__main__":
928   unittest.main()
929
Note: See TracBrowser for help on using the repository browser.