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

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

Adding a test that is used to verify that data commands can include indexed variables with astrices
in their arguments.

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