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

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

Misc edits, which preserve some data that I was playing with to validate some
advanced parser features.

File size: 47.6 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        instance = model.create(md)
267        #self.failUnlessEqual(instance.Z.data(), set(['foo[*]' 'bar' '[' '*' ']' 'bar[1,*,a,*]' 'foo-bar' 'hello-goodbye']))
268
269    def test_md11(self):
270        cwd = os.getcwd()
271        os.chdir(currdir)
272        md = ModelData()
273        md.add(currdir+"data11.dat")
274        model=Model()
275        model.A=Set()
276        model.B=Set()
277        model.C=Set()
278        model.D=Set()
279        md.read(model)
280        os.chdir(cwd)
281
282
283class TestTextImport(unittest.TestCase):
284
285    def test_tableA1(self):
286        """Importing a single column of data"""
287        pyutilib.misc.setup_redirect(currdir+'importA1.dat')
288        print "import "+os.path.abspath(example_dir+'A.tab')+" format=set: A;"
289        pyutilib.misc.reset_redirect()
290        model=Model()
291        model.A = Set()
292        instance = model.create(currdir+'importA1.dat')
293        self.failUnlessEqual(instance.A.data(), set(['A1', 'A2', 'A3']))
294        os.remove(currdir+'importA1.dat')
295
296    def test_tableA2(self):
297        """Importing a single column of data"""
298        pyutilib.misc.setup_redirect(currdir+'importA2.dat')
299        print "import "+os.path.abspath(example_dir+'A.tab')+" ;"
300        pyutilib.misc.reset_redirect()
301        model=Model()
302        model.A = Set()
303        try:
304            instance = model.create(currdir+'importA2.dat')
305            self.fail("Should fail because no set name is specified")
306        except IOError:
307            pass
308        os.remove(currdir+'importA2.dat')
309
310    def test_tableA3(self):
311        """Importing a single column of data"""
312        pyutilib.misc.setup_redirect(currdir+'importA3.dat')
313        print "import "+os.path.abspath(example_dir+'A.tab')+" : A ;"
314        pyutilib.misc.reset_redirect()
315        model=Model()
316        model.A = Set()
317        try:
318            instance = model.create(currdir+'importA3.dat')
319            self.fail("Should fail because no index is specified")
320        except IOError:
321            pass
322        os.remove(currdir+'importA3.dat')
323
324    def test_tableB(self):
325        """Same as test_tableA"""
326        pyutilib.misc.setup_redirect(currdir+'importB.dat')
327        print "import "+os.path.abspath(example_dir+'B.tab')+" format=set:B;"
328        pyutilib.misc.reset_redirect()
329        model=Model()
330        model.B = Set()
331        instance = model.create(currdir+'importB.dat')
332        self.failUnlessEqual(instance.B.data(), set([1, 2, 3]))
333        os.remove(currdir+'importB.dat')
334
335    def test_tableC(self):
336        """Importing a multi-column table, where all columns are
337        treated as values for a set with tuple values."""
338        pyutilib.misc.setup_redirect(currdir+'importC.dat')
339        print "import "+os.path.abspath(example_dir+'C.tab')+" format=set: C ;"
340        pyutilib.misc.reset_redirect()
341        model=Model()
342        model.C = Set(dimen=2)
343        instance = model.create(currdir+'importC.dat')
344        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A1',2), ('A1',3), ('A2',1), ('A2',2), ('A2',3), ('A3',1), ('A3',2), ('A3',3)]))
345        os.remove(currdir+'importC.dat')
346
347    def test_tableD(self):
348        """Importing a 2D array of data as a set."""
349        pyutilib.misc.setup_redirect(currdir+'importD.dat')
350        print "import "+os.path.abspath(example_dir+'D.tab')+" format=set_array: C ;"
351        pyutilib.misc.reset_redirect()
352        model=Model()
353        model.C = Set(dimen=2)
354        instance = model.create(currdir+'importD.dat')
355        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A2',2), ('A3',3)]))
356        os.remove(currdir+'importD.dat')
357
358    def test_tableZ(self):
359        """Importing a single parameter"""
360        pyutilib.misc.setup_redirect(currdir+'importZ.dat')
361        print "import "+os.path.abspath(example_dir+'Z.tab')+" format=param: Z ;"
362        pyutilib.misc.reset_redirect()
363        model=Model()
364        model.Z = Param(default=99.0)
365        instance = model.create(currdir+'importZ.dat')
366        self.failUnlessEqual(instance.Z.value, 1.1)
367        os.remove(currdir+'importZ.dat')
368
369    def test_tableY(self):
370        """Same as tableXW."""
371        pyutilib.misc.setup_redirect(currdir+'importY.dat')
372        print "import "+os.path.abspath(example_dir+'Y.tab')+" : [A] Y;"
373        pyutilib.misc.reset_redirect()
374        model=Model()
375        model.A = Set(initialize=['A1','A2','A3','A4'])
376        model.Y = Param(model.A)
377        instance = model.create(currdir+'importY.dat')
378        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
379        self.failUnlessEqual(instance.Y.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
380        os.remove(currdir+'importY.dat')
381
382    def test_tableXW_1(self):
383        """Importing a table, but only reporting the values for the non-index
384        parameter columns.  The first column is assumed to represent an
385        index column."""
386        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
387        print "import "+os.path.abspath(example_dir+'XW.tab')+": [A] X W;"
388        pyutilib.misc.reset_redirect()
389        model=Model()
390        model.A = Set(initialize=['A1','A2','A3','A4'])
391        model.X = Param(model.A)
392        model.W = Param(model.A)
393        instance = model.create(currdir+'importXW.dat')
394        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
395        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
396        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
397        os.remove(currdir+'importXW.dat')
398
399    def test_tableXW_2(self):
400        """Like test_tableXW_1, except that set A is not defined."""
401        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
402        print "import "+os.path.abspath(example_dir+'XW.tab')+": [A] X W;"
403        pyutilib.misc.reset_redirect()
404        model=Model()
405        model.A = Set()
406        model.X = Param(model.A)
407        model.W = Param(model.A)
408        instance = model.create(currdir+'importXW.dat')
409        self.failUnlessEqual(instance.A.data(), set())
410        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
411        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
412        os.remove(currdir+'importXW.dat')
413
414    def test_tableXW_3(self):
415        """Like test_tableXW_1, except that set A is defined in the import statment."""
416        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
417        print "import "+os.path.abspath(example_dir+'XW.tab')+": A=[A] X W;"
418        pyutilib.misc.reset_redirect()
419        model=Model()
420        model.A = Set()
421        model.X = Param(model.A)
422        model.W = Param(model.A)
423        instance = model.create(currdir+'importXW.dat')
424        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3']))
425        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
426        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
427        os.remove(currdir+'importXW.dat')
428
429    def test_tableXW_4(self):
430        """Like test_tableXW_1, except that set A is defined in the import statment and all values are mapped."""
431        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
432        print "import "+os.path.abspath(example_dir+'XW.tab')+": B=[A] R=X S=W;"
433        pyutilib.misc.reset_redirect()
434        model=Model()
435        model.B = Set()
436        model.R = Param(model.B)
437        model.S = Param(model.B)
438        instance = model.create(currdir+'importXW.dat')
439        self.failUnlessEqual(instance.B.data(), set(['A1','A2','A3']))
440        self.failUnlessEqual(instance.R.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
441        self.failUnlessEqual(instance.S.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
442        os.remove(currdir+'importXW.dat')
443
444    def test_tableT(self):
445        """Importing a 2D array of parameters that are transposed."""
446        pyutilib.misc.setup_redirect(currdir+'importT.dat')
447        print "import "+os.path.abspath(example_dir+'T.tab')+" format=transposed_array : T;"
448        pyutilib.misc.reset_redirect()
449        model=Model()
450        model.A = Set()
451        model.B = Set()
452        model.T = Param(model.A, model.B)
453        instance = model.create(currdir+'importT.dat')
454        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})
455        os.remove(currdir+'importT.dat')
456
457    def test_tableU(self):
458        """Importing a 2D array of parameters."""
459        pyutilib.misc.setup_redirect(currdir+'importU.dat')
460        print "import "+os.path.abspath(example_dir+'U.tab')+" format=array : U;"
461        pyutilib.misc.reset_redirect()
462        model=Model()
463        model.A = Set()
464        model.B = Set()
465        model.U = Param(model.A, model.B)
466        instance = model.create(currdir+'importU.dat')
467        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})
468        os.remove(currdir+'importU.dat')
469
470    def test_tableS(self):
471        """Importing a table, but only reporting the values for the non-index
472        parameter columns.  The first column is assumed to represent an
473        index column.  A missing value is represented in the column data."""
474        pyutilib.misc.setup_redirect(currdir+'importS.dat')
475        print "import "+os.path.abspath(example_dir+'S.tab')+": [A] S ;"
476        pyutilib.misc.reset_redirect()
477        model=Model()
478        model.A = Set(initialize=['A1','A2','A3','A4'])
479        model.S = Param(model.A)
480        instance = model.create(currdir+'importS.dat')
481        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
482        self.failUnlessEqual(instance.S.data(), {'A1':3.3,'A3':3.5})
483        os.remove(currdir+'importS.dat')
484
485    def test_tablePO(self):
486        """Importing a table that has multiple indexing columns"""
487        pyutilib.misc.setup_redirect(currdir+'importPO.dat')
488        print "import "+os.path.abspath(example_dir+'PO.tab')+" : J=[A,B] P O;"
489        pyutilib.misc.reset_redirect()
490        model=Model()
491        model.J = Set(dimen=2)
492        model.P = Param(model.J)
493        model.O = Param(model.J)
494        instance = model.create(currdir+'importPO.dat')
495        self.failUnlessEqual(instance.J.data(), set([('A3', 'B3'), ('A1', 'B1'), ('A2', 'B2')]) )
496        self.failUnlessEqual(instance.P.data(), {('A3', 'B3'): 4.5, ('A1', 'B1'): 4.3, ('A2', 'B2'): 4.4} )
497        self.failUnlessEqual(instance.O.data(), {('A3', 'B3'): 5.5, ('A1', 'B1'): 5.3, ('A2', 'B2'): 5.4})
498        os.remove(currdir+'importPO.dat')
499
500
501class TestCsvImport(unittest.TestCase):
502
503    def test_tableA1(self):
504        """Importing a single column of data"""
505        pyutilib.misc.setup_redirect(currdir+'importA1.dat')
506        print "import "+os.path.abspath(csv_dir+'A.csv')+" format=set: A;"
507        pyutilib.misc.reset_redirect()
508        model=Model()
509        model.A = Set()
510        instance = model.create(currdir+'importA1.dat')
511        self.failUnlessEqual(instance.A.data(), set(['A1', 'A2', 'A3']))
512        os.remove(currdir+'importA1.dat')
513
514    def test_tableA2(self):
515        """Importing a single column of data"""
516        pyutilib.misc.setup_redirect(currdir+'importA2.dat')
517        print "import "+os.path.abspath(csv_dir+'A.csv')+" ;"
518        pyutilib.misc.reset_redirect()
519        model=Model()
520        model.A = Set()
521        try:
522            instance = model.create(currdir+'importA2.dat')
523            self.fail("Should fail because no set name is specified")
524        except IOError:
525            pass
526        os.remove(currdir+'importA2.dat')
527
528    def test_tableA3(self):
529        """Importing a single column of data"""
530        pyutilib.misc.setup_redirect(currdir+'importA3.dat')
531        print "import "+os.path.abspath(csv_dir+'A.csv')+" : A ;"
532        pyutilib.misc.reset_redirect()
533        model=Model()
534        model.A = Set()
535        try:
536            instance = model.create(currdir+'importA3.dat')
537            self.fail("Should fail because no index is specified")
538        except IOError:
539            pass
540        os.remove(currdir+'importA3.dat')
541
542    def test_tableB(self):
543        """Same as test_tableA"""
544        pyutilib.misc.setup_redirect(currdir+'importB.dat')
545        print "import "+os.path.abspath(csv_dir+'B.csv')+" format=set:B;"
546        pyutilib.misc.reset_redirect()
547        model=Model()
548        model.B = Set()
549        instance = model.create(currdir+'importB.dat')
550        self.failUnlessEqual(instance.B.data(), set([1, 2, 3]))
551        os.remove(currdir+'importB.dat')
552
553    def test_tableC(self):
554        """Importing a multi-column table, where all columns are
555        treated as values for a set with tuple values."""
556        pyutilib.misc.setup_redirect(currdir+'importC.dat')
557        print "import "+os.path.abspath(csv_dir+'C.csv')+" format=set: C ;"
558        pyutilib.misc.reset_redirect()
559        model=Model()
560        model.C = Set(dimen=2)
561        instance = model.create(currdir+'importC.dat')
562        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A1',2), ('A1',3), ('A2',1), ('A2',2), ('A2',3), ('A3',1), ('A3',2), ('A3',3)]))
563        os.remove(currdir+'importC.dat')
564
565    def test_tableD(self):
566        """Importing a 2D array of data as a set."""
567        pyutilib.misc.setup_redirect(currdir+'importD.dat')
568        print "import "+os.path.abspath(csv_dir+'D.csv')+" format=set_array: C ;"
569        pyutilib.misc.reset_redirect()
570        model=Model()
571        model.C = Set(dimen=2)
572        instance = model.create(currdir+'importD.dat')
573        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A2',2), ('A3',3)]))
574        os.remove(currdir+'importD.dat')
575
576    def test_tableZ(self):
577        """Importing a single parameter"""
578        pyutilib.misc.setup_redirect(currdir+'importZ.dat')
579        print "import "+os.path.abspath(csv_dir+'Z.csv')+" format=param: Z ;"
580        pyutilib.misc.reset_redirect()
581        model=Model()
582        model.Z = Param(default=99.0)
583        instance = model.create(currdir+'importZ.dat')
584        self.failUnlessEqual(instance.Z.value, 1.1)
585        os.remove(currdir+'importZ.dat')
586
587    def test_tableY(self):
588        """Same as tableXW."""
589        pyutilib.misc.setup_redirect(currdir+'importY.dat')
590        print "import "+os.path.abspath(csv_dir+'Y.csv')+" : [A] Y;"
591        pyutilib.misc.reset_redirect()
592        model=Model()
593        model.A = Set(initialize=['A1','A2','A3','A4'])
594        model.Y = Param(model.A)
595        instance = model.create(currdir+'importY.dat')
596        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
597        self.failUnlessEqual(instance.Y.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
598        os.remove(currdir+'importY.dat')
599
600    def test_tableXW_1(self):
601        """Importing a table, but only reporting the values for the non-index
602        parameter columns.  The first column is assumed to represent an
603        index column."""
604        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
605        print "import "+os.path.abspath(csv_dir+'XW.csv')+": [A] X W;"
606        pyutilib.misc.reset_redirect()
607        model=Model()
608        model.A = Set(initialize=['A1','A2','A3','A4'])
609        model.X = Param(model.A)
610        model.W = Param(model.A)
611        instance = model.create(currdir+'importXW.dat')
612        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
613        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
614        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
615        os.remove(currdir+'importXW.dat')
616
617    def test_tableXW_2(self):
618        """Like test_tableXW_1, except that set A is not defined."""
619        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
620        print "import "+os.path.abspath(csv_dir+'XW.csv')+": [A] X W;"
621        pyutilib.misc.reset_redirect()
622        model=Model()
623        model.A = Set()
624        model.X = Param(model.A)
625        model.W = Param(model.A)
626        instance = model.create(currdir+'importXW.dat')
627        self.failUnlessEqual(instance.A.data(), set())
628        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
629        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
630        os.remove(currdir+'importXW.dat')
631
632    def test_tableXW_3(self):
633        """Like test_tableXW_1, except that set A is defined in the import statment."""
634        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
635        print "import "+os.path.abspath(csv_dir+'XW.csv')+": A=[A] X W;"
636        pyutilib.misc.reset_redirect()
637        model=Model()
638        model.A = Set()
639        model.X = Param(model.A)
640        model.W = Param(model.A)
641        instance = model.create(currdir+'importXW.dat')
642        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3']))
643        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
644        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
645        os.remove(currdir+'importXW.dat')
646
647    def test_tableXW_4(self):
648        """Like test_tableXW_1, except that set A is defined in the import statment and all values are mapped."""
649        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
650        print "import "+os.path.abspath(csv_dir+'XW.csv')+": B=[A] R=X S=W;"
651        pyutilib.misc.reset_redirect()
652        model=Model()
653        model.B = Set()
654        model.R = Param(model.B)
655        model.S = Param(model.B)
656        instance = model.create(currdir+'importXW.dat')
657        self.failUnlessEqual(instance.B.data(), set(['A1','A2','A3']))
658        self.failUnlessEqual(instance.R.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
659        self.failUnlessEqual(instance.S.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
660        os.remove(currdir+'importXW.dat')
661
662    def test_tableT(self):
663        """Importing a 2D array of parameters that are transposed."""
664        pyutilib.misc.setup_redirect(currdir+'importT.dat')
665        print "import "+os.path.abspath(csv_dir+'T.csv')+" format=transposed_array : T;"
666        pyutilib.misc.reset_redirect()
667        model=Model()
668        model.A = Set()
669        model.B = Set()
670        model.T = Param(model.A, model.B)
671        instance = model.create(currdir+'importT.dat')
672        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})
673        os.remove(currdir+'importT.dat')
674
675    def test_tableU(self):
676        """Importing a 2D array of parameters."""
677        pyutilib.misc.setup_redirect(currdir+'importU.dat')
678        print "import "+os.path.abspath(csv_dir+'U.csv')+" format=array : U;"
679        pyutilib.misc.reset_redirect()
680        model=Model()
681        model.A = Set()
682        model.B = Set()
683        model.U = Param(model.A, model.B)
684        instance = model.create(currdir+'importU.dat')
685        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})
686        os.remove(currdir+'importU.dat')
687
688    def test_tableS(self):
689        """Importing a table, but only reporting the values for the non-index
690        parameter columns.  The first column is assumed to represent an
691        index column.  A missing value is represented in the column data."""
692        pyutilib.misc.setup_redirect(currdir+'importS.dat')
693        print "import "+os.path.abspath(csv_dir+'S.csv')+": [A] S ;"
694        pyutilib.misc.reset_redirect()
695        model=Model()
696        model.A = Set(initialize=['A1','A2','A3','A4'])
697        model.S = Param(model.A)
698        instance = model.create(currdir+'importS.dat')
699        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
700        self.failUnlessEqual(instance.S.data(), {'A1':3.3,'A3':3.5})
701        os.remove(currdir+'importS.dat')
702
703    def test_tablePO(self):
704        """Importing a table that has multiple indexing columns"""
705        pyutilib.misc.setup_redirect(currdir+'importPO.dat')
706        print "import "+os.path.abspath(csv_dir+'PO.csv')+" : J=[A,B] P O;"
707        pyutilib.misc.reset_redirect()
708        model=Model()
709        model.J = Set(dimen=2)
710        model.P = Param(model.J)
711        model.O = Param(model.J)
712        instance = model.create(currdir+'importPO.dat')
713        self.failUnlessEqual(instance.J.data(), set([('A3', 'B3'), ('A1', 'B1'), ('A2', 'B2')]) )
714        self.failUnlessEqual(instance.P.data(), {('A3', 'B3'): 4.5, ('A1', 'B1'): 4.3, ('A2', 'B2'): 4.4} )
715        self.failUnlessEqual(instance.O.data(), {('A3', 'B3'): 5.5, ('A1', 'B1'): 5.3, ('A2', 'B2'): 5.4})
716        os.remove(currdir+'importPO.dat')
717
718
719
720class TestSpreadsheet(unittest.TestCase):
721
722    def run(self, result=None):
723        """ Disable the tests if win32com is not available """
724        if not _win32com:
725           return
726        unittest.TestCase.run(self,result)
727
728    def test_tableA1(self):
729        """Importing a single column of data"""
730        pyutilib.misc.setup_redirect(currdir+'importA1.dat')
731        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Atable format=set: A;"
732        pyutilib.misc.reset_redirect()
733        model=Model()
734        model.A = Set()
735        instance = model.create(currdir+'importA1.dat')
736        self.failUnlessEqual(instance.A.data(), set(['A1', 'A2', 'A3']))
737        os.remove(currdir+'importA1.dat')
738
739    def test_tableA2(self):
740        """Importing a single column of data"""
741        pyutilib.misc.setup_redirect(currdir+'importA2.dat')
742        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Atable ;"
743        pyutilib.misc.reset_redirect()
744        model=Model()
745        model.A = Set()
746        try:
747            instance = model.create(currdir+'importA2.dat')
748            self.fail("Should fail because no set name is specified")
749        except IOError:
750            pass
751        os.remove(currdir+'importA2.dat')
752
753    def test_tableA3(self):
754        """Importing a single column of data"""
755        pyutilib.misc.setup_redirect(currdir+'importA3.dat')
756        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Atable : A ;"
757        pyutilib.misc.reset_redirect()
758        model=Model()
759        model.A = Set()
760        try:
761            instance = model.create(currdir+'importA3.dat')
762            self.fail("Should fail because no index is specified")
763        except IOError:
764            pass
765        os.remove(currdir+'importA3.dat')
766
767    def test_tableB(self):
768        """Same as test_tableA"""
769        pyutilib.misc.setup_redirect(currdir+'importB.dat')
770        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Btable format=set:B;"
771        pyutilib.misc.reset_redirect()
772        model=Model()
773        model.B = Set()
774        instance = model.create(currdir+'importB.dat')
775        self.failUnlessEqual(instance.B.data(), set([1, 2, 3]))
776        os.remove(currdir+'importB.dat')
777
778    def test_tableC(self):
779        """Importing a multi-column table, where all columns are
780        treated as values for a set with tuple values."""
781        pyutilib.misc.setup_redirect(currdir+'importC.dat')
782        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Ctable format=set: C ;"
783        pyutilib.misc.reset_redirect()
784        model=Model()
785        model.C = Set(dimen=2)
786        instance = model.create(currdir+'importC.dat')
787        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A1',2), ('A1',3), ('A2',1), ('A2',2), ('A2',3), ('A3',1), ('A3',2), ('A3',3)]))
788        os.remove(currdir+'importC.dat')
789
790    def test_tableD(self):
791        """Importing a 2D array of data as a set."""
792        pyutilib.misc.setup_redirect(currdir+'importD.dat')
793        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Dtable format=set_array: C ;"
794        pyutilib.misc.reset_redirect()
795        model=Model()
796        model.C = Set(dimen=2)
797        instance = model.create(currdir+'importD.dat')
798        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A2',2), ('A3',3)]))
799        os.remove(currdir+'importD.dat')
800
801    def test_tableZ(self):
802        """Importing a single parameter"""
803        pyutilib.misc.setup_redirect(currdir+'importZ.dat')
804        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Zparam format=param: Z ;"
805        pyutilib.misc.reset_redirect()
806        model=Model()
807        model.Z = Param(default=99.0)
808        instance = model.create(currdir+'importZ.dat')
809        self.failUnlessEqual(instance.Z.value, 1.1)
810        os.remove(currdir+'importZ.dat')
811
812    def test_tableY(self):
813        """Same as tableXW."""
814        pyutilib.misc.setup_redirect(currdir+'importY.dat')
815        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Ytable : [A] Y;"
816        pyutilib.misc.reset_redirect()
817        model=Model()
818        model.A = Set(initialize=['A1','A2','A3','A4'])
819        model.Y = Param(model.A)
820        instance = model.create(currdir+'importY.dat')
821        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
822        self.failUnlessEqual(instance.Y.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
823        os.remove(currdir+'importY.dat')
824
825    def test_tableXW_1(self):
826        """Importing a table, but only reporting the values for the non-index
827        parameter columns.  The first column is assumed to represent an
828        index column."""
829        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
830        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=XWtable : [A] X W;"
831        pyutilib.misc.reset_redirect()
832        model=Model()
833        model.A = Set(initialize=['A1','A2','A3','A4'])
834        model.X = Param(model.A)
835        model.W = Param(model.A)
836        instance = model.create(currdir+'importXW.dat')
837        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
838        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
839        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
840        os.remove(currdir+'importXW.dat')
841
842    def test_tableXW_2(self):
843        """Like test_tableXW_1, except that set A is not defined."""
844        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
845        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=XWtable : [A] X W;"
846        pyutilib.misc.reset_redirect()
847        model=Model()
848        model.A = Set()
849        model.X = Param(model.A)
850        model.W = Param(model.A)
851        instance = model.create(currdir+'importXW.dat')
852        self.failUnlessEqual(instance.A.data(), set())
853        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
854        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
855        os.remove(currdir+'importXW.dat')
856
857    def test_tableXW_3(self):
858        """Like test_tableXW_1, except that set A is defined in the import statment."""
859        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
860        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=XWtable: A=[A] X W;"
861        pyutilib.misc.reset_redirect()
862        model=Model()
863        model.A = Set()
864        model.X = Param(model.A)
865        model.W = Param(model.A)
866        instance = model.create(currdir+'importXW.dat')
867        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3']))
868        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
869        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
870        os.remove(currdir+'importXW.dat')
871
872    def test_tableXW_4(self):
873        """Like test_tableXW_1, except that set A is defined in the import statment and all values are mapped."""
874        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
875        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=XWtable: B=[A] R=X S=W;"
876        pyutilib.misc.reset_redirect()
877        model=Model()
878        model.B = Set()
879        model.R = Param(model.B)
880        model.S = Param(model.B)
881        instance = model.create(currdir+'importXW.dat')
882        self.failUnlessEqual(instance.B.data(), set(['A1','A2','A3']))
883        self.failUnlessEqual(instance.R.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
884        self.failUnlessEqual(instance.S.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
885        os.remove(currdir+'importXW.dat')
886
887    def test_tableT(self):
888        """Importing a 2D array of parameters that are transposed."""
889        pyutilib.misc.setup_redirect(currdir+'importT.dat')
890        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Ttable format=transposed_array : T;"
891        pyutilib.misc.reset_redirect()
892        model=Model()
893        model.A = Set()
894        model.B = Set()
895        model.T = Param(model.A, model.B)
896        instance = model.create(currdir+'importT.dat')
897        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})
898        os.remove(currdir+'importT.dat')
899
900    def test_tableU(self):
901        """Importing a 2D array of parameters."""
902        pyutilib.misc.setup_redirect(currdir+'importU.dat')
903        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Utable format=array : U;"
904        pyutilib.misc.reset_redirect()
905        model=Model()
906        model.A = Set()
907        model.B = Set()
908        model.U = Param(model.A, model.B)
909        instance = model.create(currdir+'importU.dat')
910        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})
911        os.remove(currdir+'importU.dat')
912
913    def test_tableS(self):
914        """Importing a table, but only reporting the values for the non-index
915        parameter columns.  The first column is assumed to represent an
916        index column.  A missing value is represented in the column data."""
917        pyutilib.misc.setup_redirect(currdir+'importS.dat')
918        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=Stable : [A] S ;"
919        pyutilib.misc.reset_redirect()
920        model=Model()
921        model.A = Set(initialize=['A1','A2','A3','A4'])
922        model.S = Param(model.A)
923        instance = model.create(currdir+'importS.dat')
924        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
925        self.failUnlessEqual(instance.S.data(), {'A1':3.3,'A3':3.5})
926        os.remove(currdir+'importS.dat')
927
928    def test_tablePO(self):
929        """Importing a table that has multiple indexing columns"""
930        pyutilib.misc.setup_redirect(currdir+'importPO.dat')
931        print "import "+os.path.abspath(tutorial_dir+'excel.xls')+" range=POtable : J=[A,B] P O;"
932        pyutilib.misc.reset_redirect()
933        model=Model()
934        model.J = Set(dimen=2)
935        model.P = Param(model.J)
936        model.O = Param(model.J)
937        instance = model.create(currdir+'importPO.dat')
938        self.failUnlessEqual(instance.J.data(), set([('A3', 'B3'), ('A1', 'B1'), ('A2', 'B2')]) )
939        self.failUnlessEqual(instance.P.data(), {('A3', 'B3'): 4.5, ('A1', 'B1'): 4.3, ('A2', 'B2'): 4.4} )
940        self.failUnlessEqual(instance.O.data(), {('A3', 'B3'): 5.5, ('A1', 'B1'): 5.3, ('A2', 'B2'): 5.4})
941        os.remove(currdir+'importPO.dat')
942
943
944class TestModelData(unittest.TestCase):
945
946    def test_tableA1(self):
947        """Importing a single column of data"""
948        md = ModelData()
949        md.add(os.path.abspath(example_dir+'A.tab'), format='set', set='A')
950        model=Model()
951        model.A = Set()
952        md.read(model)
953        instance = model.create(md)
954        self.failUnlessEqual(instance.A.data(), set(['A1', 'A2', 'A3']))
955
956    def test_tableA2(self):
957        """Importing a single column of data"""
958        md = ModelData()
959        md.add(os.path.abspath(example_dir+'A.tab'))
960        model=Model()
961        model.A = Set()
962        try:
963            md.read(model)
964            instance = model.create(md)
965            self.fail("Should fail because no set name is specified")
966        except IOError:
967            pass
968
969    def test_tableA3(self):
970        """Importing a single column of data"""
971        md = ModelData()
972        md.add(os.path.abspath(example_dir+'A.tab'), set='A')
973        model=Model()
974        model.A = Set()
975        try:
976            md.read(model)
977            instance = model.create(md)
978            self.fail("Should fail because no index is specified")
979        except IOError:
980            pass
981
982    def test_tableB(self):
983        """Same as test_tableA"""
984        md = ModelData()
985        md.add(os.path.abspath(example_dir+'B.tab'), format='set', set='B')
986        model=Model()
987        model.B = Set()
988        md.read(model)
989        instance = model.create(md)
990        self.failUnlessEqual(instance.B.data(), set([1, 2, 3]))
991
992    def test_tableC(self):
993        """Importing a multi-column table, where all columns are
994        treated as values for a set with tuple values."""
995        md = ModelData()
996        md.add(os.path.abspath(example_dir+'C.tab'), format='set', set='C')
997        model=Model()
998        model.C = Set(dimen=2)
999        md.read(model)
1000        instance = model.create(md)
1001        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A1',2), ('A1',3), ('A2',1), ('A2',2), ('A2',3), ('A3',1), ('A3',2), ('A3',3)]))
1002
1003    def test_tableD(self):
1004        """Importing a 2D array of data as a set."""
1005        md = ModelData()
1006        md.add(os.path.abspath(example_dir+'D.tab'), format='set_array', set='C')
1007        model=Model()
1008        model.C = Set(dimen=2)
1009        md.read(model)
1010        instance = model.create(md)
1011        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A2',2), ('A3',3)]))
1012
1013    def test_tableZ(self):
1014        """Importing a single parameter"""
1015        md = ModelData()
1016        md.add(os.path.abspath(example_dir+'Z.tab'), format='param', param='Z')
1017        model=Model()
1018        model.Z = Param(default=99.0)
1019        md.read(model)
1020        instance = model.create(md)
1021        self.failUnlessEqual(instance.Z.value, 1.1)
1022
1023    def test_tableY(self):
1024        """Same as tableXW."""
1025        md = ModelData()
1026        md.add(os.path.abspath(example_dir+'Y.tab'), index=['A'], param=['Y'])
1027        model=Model()
1028        model.A = Set(initialize=['A1','A2','A3','A4'])
1029        model.Y = Param(model.A)
1030        md.read(model)
1031        instance = model.create(md)
1032        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
1033        self.failUnlessEqual(instance.Y.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
1034
1035    def test_tableXW_1(self):
1036        """Importing a table, but only reporting the values for the non-index
1037        parameter columns.  The first column is assumed to represent an
1038        index column."""
1039        md = ModelData()
1040        md.add(os.path.abspath(example_dir+'XW.tab'), index=['A'], param=['X','W'])
1041        model=Model()
1042        model.A = Set(initialize=['A1','A2','A3','A4'])
1043        model.X = Param(model.A)
1044        model.W = Param(model.A)
1045        md.read(model)
1046        instance = model.create(md)
1047        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
1048        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
1049        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
1050
1051    def test_tableXW_2(self):
1052        """Like test_tableXW_1, except that set A is not defined."""
1053        md = ModelData()
1054        md.add(os.path.abspath(example_dir+'XW.tab'), index=['A'], param=['X','W'])
1055        model=Model()
1056        model.A = Set()
1057        model.X = Param(model.A)
1058        model.W = Param(model.A)
1059        md.read(model)
1060        instance = model.create(md)
1061        self.failUnlessEqual(instance.A.data(), set())
1062        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
1063        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
1064
1065    def test_tableXW_3(self):
1066        """Like test_tableXW_1, except that set A is defined in the import statment."""
1067        md = ModelData()
1068        md.add(os.path.abspath(example_dir+'XW.tab'), index_name='A', index=['A'], param=['X','W'])
1069        model=Model()
1070        model.A = Set()
1071        model.X = Param(model.A)
1072        model.W = Param(model.A)
1073        md.read(model)
1074        instance = model.create(md)
1075        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3']))
1076        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
1077        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
1078
1079    def test_tableXW_4(self):
1080        """Like test_tableXW_1, except that set A is defined in the import statment and all values are mapped."""
1081        md = ModelData()
1082        md.add(os.path.abspath(example_dir+'XW.tab'), index_name='B', index=['A'], param=['X','W'], param_name={'X':'R', 'W':'S'})
1083        model=Model()
1084        model.B = Set()
1085        model.R = Param(model.B)
1086        model.S = Param(model.B)
1087        md.read(model)
1088        instance = model.create(md)
1089        self.failUnlessEqual(instance.B.data(), set(['A1','A2','A3']))
1090        self.failUnlessEqual(instance.R.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
1091        self.failUnlessEqual(instance.S.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
1092
1093    def test_tableT(self):
1094        """Importing a 2D array of parameters that are transposed."""
1095        md = ModelData()
1096        md.add(os.path.abspath(example_dir+'T.tab'), format='transposed_array', param='T')
1097        model=Model()
1098        model.A = Set()
1099        model.B = Set()
1100        model.T = Param(model.A, model.B)
1101        md.read(model)
1102        instance = model.create(md)
1103        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})
1104
1105    def test_tableU(self):
1106        """Importing a 2D array of parameters."""
1107        md = ModelData()
1108        md.add(os.path.abspath(example_dir+'T.tab'), format='array', param='U')
1109        model=Model()
1110        model.A = Set()
1111        model.B = Set()
1112        model.U = Param(model.A, model.B)
1113        md.read(model)
1114        instance = model.create(md)
1115        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})
1116
1117    def test_tableS(self):
1118        """Importing a table, but only reporting the values for the non-index
1119        parameter columns.  The first column is assumed to represent an
1120        index column.  A missing value is represented in the column data."""
1121        md = ModelData()
1122        md.add(os.path.abspath(example_dir+'S.tab'), index=['A'], param=['S'])
1123        model=Model()
1124        model.A = Set(initialize=['A1','A2','A3','A4'])
1125        model.S = Param(model.A)
1126        md.read(model)
1127        instance = model.create(md)
1128        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
1129        self.failUnlessEqual(instance.S.data(), {'A1':3.3,'A3':3.5})
1130
1131    def test_tablePO(self):
1132        """Importing a table that has multiple indexing columns"""
1133        pyutilib.misc.setup_redirect(currdir+'importPO.dat')
1134        print "import "+os.path.abspath(example_dir+'PO.tab')+" : J=[A,B] P O;"
1135        pyutilib.misc.reset_redirect()
1136        md = ModelData()
1137        md.add(os.path.abspath(example_dir+'PO.tab'), index_name='J', index=['A','B'], param=['P','O'])
1138        model=Model()
1139        model.J = Set(dimen=2)
1140        model.P = Param(model.J)
1141        model.O = Param(model.J)
1142        md.read(model)
1143        instance = model.create(md)
1144        self.failUnlessEqual(instance.J.data(), set([('A3', 'B3'), ('A1', 'B1'), ('A2', 'B2')]) )
1145        self.failUnlessEqual(instance.P.data(), {('A3', 'B3'): 4.5, ('A1', 'B1'): 4.3, ('A2', 'B2'): 4.4} )
1146        self.failUnlessEqual(instance.O.data(), {('A3', 'B3'): 5.5, ('A1', 'B1'): 5.3, ('A2', 'B2'): 5.4})
1147
1148
1149if __name__ == "__main__":
1150   unittest.main()
1151
Note: See TracBrowser for help on using the repository browser.