Changeset 2292


Ignore:
Timestamp:
Feb 9, 2010 2:21:24 PM (10 years ago)
Author:
wehart
Message:

Rework of the 'import' semantics. This supports
a simple import semantics, such as:

import foobar.tab: [A,B] X Y Z;

as well as index/parameter renaming:

import foobar.tab: J=[A,B] R=X S=Y T=Z;

Location:
coopr.pyomo/trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • coopr.pyomo/trunk/coopr/pyomo/data/TableData.py

    r2289 r2292  
    6161
    6262    def _set_data(self, headers, rows):
    63         #print "_SET_DATA"
    64         if self.options.symbol_map is None:
     63        #print "_SET_DATA",headers,rows
     64        if self.options.param_name is None:
    6565            mapped_headers = map(str,list(headers))
    6666        else:
    67             mapped_headers = [self.options.symbol_map[tuple(header)] if tuple(header) in self.options.symbol_map else header for header in map(str,list(headers))]
    68         #print "X",mapped_headers,self.options.symbol_map,self.options.index,self.options.format
     67            mapped_headers = [self.options.param_name[header] if header in self.options.param_name else header for header in map(str,list(headers))]
     68        #print "X",mapped_headers,self.options.param_name,self.options.index,self.options.format
    6969
    70         if not self.options.set is None:
    71            if self.options.format is None:
    72               self._info = ["set",self.options.set,":="]
    73               for row in rows:
     70        if self.options.format == 'set':
     71            if self.options.set is None:
     72                raise IOError, "Must specify set name for data with the 'set' format"
     73            if not (self.options.index is None or self.options.index == []):
     74                raise IOError, "Cannot specify index for data with the 'set' format: %s" % str(self.options.index)
     75            self._info = ["set",self.options.set,":="]
     76            for row in rows:
    7477                self._info = self._info + list(row)
    75            elif self.options.format == "set_array":
    76               self._info = ["set",self.options.set, ":"]
    77               self._info = self._info + list(mapped_headers[1:])
    78               self._info = self._info + [":="]
    79               for row in rows:
     78
     79        elif self.options.format == 'set_array':
     80            if self.options.set is None:
     81                raise IOError, "Must specify set name for data with the 'set_array' format"
     82            if not (self.options.index is None or self.options.index == []):
     83                raise IOError, "Cannot specify index for data with the 'set_array' format: %s" % str(self.options.index)
     84            self._info = ["set",self.options.set, ":"]
     85            self._info = self._info + list(mapped_headers[1:])
     86            self._info = self._info + [":="]
     87            for row in rows:
    8088                self._info = self._info + list(row)
    81            else:
    82               raise ValueError, "Unknown set format: "+self.options.format
    8389
    84         elif self.options.index is not None and self.options.param is None:
    85            #print "Z1"
    86            self._info = ["param",":",self.options.index,":"]
    87            self._info = self._info + mapped_headers[self.options.nindex:]
    88            self._info.append(":=")
    89            for row in rows:
    90              self._info = self._info + list(row)
     90        elif self.options.format == 'transposed_array':
     91            self._info = ["param",self.options.param,"(tr)",":"] + mapped_headers[1:]
     92            self._info.append(":=")
     93            for row in rows:
     94                self._info = self._info + list(row)
    9195
    92         elif self.options.index is not None and self.options.param is not None:
    93            #print "Z2"
    94            self._info = ["param",":",self.options.index,":"]
    95            if type(self.options.param) is str:
    96               self._info = self._info + [self.options.param]
    97            elif type(self.options.param) is tuple:
    98               self._info = self._info + list(self.options.param)
    99            else:
    100               self._info = self._info + self.options.param
    101            self._info.append(":=")
    102            for row in rows:
    103              self._info = self._info + list(row)
     96        elif self.options.format == 'array':
     97            self._info = ["param",self.options.param,":"] + mapped_headers[1:]
     98            self._info.append(":=")
     99            for row in rows:
     100                self._info = self._info + list(row)
    104101
    105         elif self.options.param is not None and self.options.format is not None:
    106            #print "Z3"
    107            if self.options.format == "transposed_array":
    108               self._info = ["param",self.options.param,"(tr)",":"] + mapped_headers[1:]
    109            elif self.options.format == "array":
    110               self._info = ["param",self.options.param,":"] + mapped_headers[1:]
    111            else:
    112               raise ValueError, "Unknown parameter format: "+self.options.format
    113            self._info.append(":=")
    114            for row in rows:
    115              self._info = self._info + list(row)
     102        elif self.options.format == 'param':
     103            self._info = ["param",":",self.options.param,':=']
     104            for row in rows:
     105                self._info = self._info + list(row)
     106
     107        elif self.options.format == 'table' or self.options.format is None:
     108            if self.options.index is None or len(self.options.index) == 0:
     109                raise IOError, "Cannot import a relational table without specifying index values"
     110            if self.options.index_name is not None:
     111                self._info = ["param",":",self.options.index_name,":"]
     112            else:
     113                self._info = ["param",":"]
     114            for header in mapped_headers:
     115                if not header in self.options.index:
     116                    self._info.append(header)
     117            self._info.append(":=")
     118            for row in rows:
     119                self._info = self._info + list(row)
    116120
    117121        else:
    118            #print "Z4"
    119            if len(mapped_headers) == 1:
    120               self._info = ["set",mapped_headers[0],":="]
    121               for row in rows:
    122                 self._info = self._info + list(row)
    123            else:
    124               self._info = ["param",":"]
    125               if self.options.param is None:
    126                  self._info = self._info + mapped_headers[1:]
    127               elif type(self.options.param) is str:
    128                  self._info = self._info + [self.options.param]
    129               else:
    130                  self._info = self._info + list(self.options.param)
    131               self._info.append(":=")
    132               for row in rows:
    133                 self._info = self._info + list(row)
     122            raise ValueError, "Unknown parameter format: '%s'" % self.options.format
    134123
  • coopr.pyomo/trunk/coopr/pyomo/data/parse_datacmds.py

    r2289 r2292  
    161161    '''importdecl : filename import_options
    162162                  | filename
     163                  | filename import_options COLON WORD EQ indices variable_options
     164                  | filename COLON WORD EQ indices variable_options
    163165                  | filename import_options COLON indices variable_options
    164166                  | filename COLON indices variable_options
     
    168170    tmp = {'filename':p[1]}
    169171    if len(p) == 2:
    170         p[0] = [tmp, [], {}]
     172        p[0] = [tmp, (None,[]), {}]
    171173    elif len(p) == 3:
    172174        tmp.update(p[2])
    173         p[0] = [tmp, [], {}]
     175        p[0] = [tmp, (None,[]), {}]
    174176    elif len(p) == 4:
    175         p[0] = [tmp, [], p[3]]
     177        p[0] = [tmp, (None,[]), p[3]]
    176178    elif len(p) == 5:
    177179        if p[2] == ':':
    178             p[0] = [tmp, p[3], p[4]]
     180            p[0] = [tmp, (None,p[3]), p[4]]
    179181        else:
    180182            tmp.update(p[2])
    181             p[0] = [tmp, [], p[4]]
     183            p[0] = [tmp, (None,[]), p[4]]
    182184    elif len(p) == 6:
    183185        tmp.update(p[2])
    184         p[0] = [tmp, p[4], p[5]]
     186        p[0] = [tmp, (None,p[4]), p[5]]
     187    elif len(p) == 7:
     188        p[0] = [tmp, (p[3],p[5]), p[6]]
     189    elif len(p) == 8:
     190        tmp.update(p[2])
     191        p[0] = [tmp, (p[4],p[6]), p[7]]
    185192    else:
    186193        raise IOError, "Unexpected condition"
     
    195202                      | WORD EQ PARAM import_options
    196203                      | WORD EQ PARAM
     204                      | WORD EQ SET import_options
     205                      | WORD EQ SET
    197206    '''
    198207    tmp = {p[1]:p[3]}
     
    215224def p_variable(p):
    216225    '''variable : WORD
    217                 | WORD COLON WORD
    218                 | WORD COLON WORD index_list
     226                | WORD EQ WORD
    219227    '''
    220228    if len(p) == 2:
    221         p[0] = {p[1]:[p[1]]}
    222     elif len(p) == 4:
    223         p[0] = {p[1]:[p[3]]}
    224     else:
    225         p[0] = {p[1]:[p[3]]+p[4]}
     229        p[0] = {p[1]:p[1]}
     230    else:
     231        p[0] = {p[3]:p[1]}
    226232
    227233def p_indices(p):
  • coopr.pyomo/trunk/coopr/pyomo/data/process_data.py

    r2289 r2292  
    466466    # Create symbol map
    467467    #
    468     symb_map = {}
    469     index=None
    470     nindex=1
    471     for key in cmd[3]:
    472         symb_map[ tuple(cmd[3][key]) ] = key
    473     if len(cmd[2]) == 0:
    474         index=None
    475         if len(cmd[3]) == 1:
    476             set_name=cmd[3].keys()[0]
     468    symb_map = cmd[3]
     469    #for key in cmd[3]:
     470        #symb_map[ cmd[3][key] ] = key
     471    if len(symb_map) == 0:
     472        raise IOError, "Must specify at least one set or parameter name that will be imported"
     473    #
     474    # Process index data
     475    #
     476    index=cmd[2][1]
     477    index_name=cmd[2][0]
     478    #
     479    # Set the 'set name' based on the format
     480    #
     481    if options.format == 'set' or options.format == 'set_array':
     482        if len(cmd[3]) != 1:
     483            raise IOError, "A single set name must be specified when using format '%s'" % options.format
     484        set_name=cmd[3].keys()[0]
    477485    else:
    478         nindex=0
    479         tmp = []
    480         for item in cmd[2]:
    481             for key in symb_map:
    482                 if item == key[0]:
    483                     tmp.append(symb_map[key])
    484                     nindex += len(key)
    485         if len(tmp) > 0:
    486             index=' '.join(tmp)
    487         if nindex == 0:
    488             nindex = 1
    489         if len(tmp) == 0 and len(cmd[3]) == 1:
    490             set_name=cmd[3].keys()[0]
    491     if options.format == 'transposed_array' or options.format == 'array':
    492         if len(symb_map) > 1:
    493             raise IOError, "Cannot specify multiple parameter names for array data: %s" % str(symb_map)
    494         if len(symb_map) == 0:
    495             raise IOError, "Must specify a parameter name for a array data"
    496         param_name = symb_map[symb_map.keys()[0]]
    497         set_name = None
    498     data.initialize(options.filename, index=index, nindex=nindex, symbol_map=symb_map, set=set_name, format=options.format, param=param_name)
     486        set_name=None
     487    #
     488    # Set the 'param name' based on the format
     489    #
     490    if options.format == 'transposed_array' or options.format == 'array' or options.format == 'param':
     491        if len(cmd[3]) != 1:
     492            raise IOError, "A single parameter name must be specified when using format '%s'" % options.format
     493        param_name = cmd[3].keys()[0]
     494    else:
     495        param_name = None
     496    #
     497    data.initialize(options.filename, index=index, index_name=index_name, param_name=symb_map, set=set_name, param=param_name, format=options.format)
     498    #
    499499    data.open()
    500500    data.read()
  • coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_modeldata.py

    r2289 r2292  
    286286class TestImport(unittest.TestCase):
    287287
    288     def test_tableA(self):
     288    def test_tableA1(self):
    289289        """Importing a single column of data"""
    290         pyutilib.misc.setup_redirect(currdir+'importA.dat')
     290        pyutilib.misc.setup_redirect(currdir+'importA1.dat')
     291        print "import "+os.path.abspath(example_dir+'A.tab')+" format=set: A;"
     292        pyutilib.misc.reset_redirect()
     293        model=Model()
     294        model.A = Set()
     295        instance = model.create(currdir+'importA1.dat')
     296        self.failUnlessEqual(instance.A.data(), set(['A1', 'A2', 'A3']))
     297        os.remove(currdir+'importA1.dat')
     298
     299    def test_tableA2(self):
     300        """Importing a single column of data"""
     301        pyutilib.misc.setup_redirect(currdir+'importA2.dat')
    291302        print "import "+os.path.abspath(example_dir+'A.tab')+" ;"
    292303        pyutilib.misc.reset_redirect()
    293304        model=Model()
    294305        model.A = Set()
    295         instance = model.create(currdir+'importA.dat')
    296         self.failUnlessEqual(instance.A.data(), set(['A1', 'A2', 'A3']))
    297         os.remove(currdir+'importA.dat')
     306        try:
     307            instance = model.create(currdir+'importA2.dat')
     308            self.fail("Should fail because no set name is specified")
     309        except IOError:
     310            pass
     311        os.remove(currdir+'importA2.dat')
     312
     313    def test_tableA3(self):
     314        """Importing a single column of data"""
     315        pyutilib.misc.setup_redirect(currdir+'importA3.dat')
     316        print "import "+os.path.abspath(example_dir+'A.tab')+" : A ;"
     317        pyutilib.misc.reset_redirect()
     318        model=Model()
     319        model.A = Set()
     320        try:
     321            instance = model.create(currdir+'importA3.dat')
     322            self.fail("Should fail because no index is specified")
     323        except IOError:
     324            pass
     325        os.remove(currdir+'importA3.dat')
    298326
    299327    def test_tableB(self):
    300328        """Same as test_tableA"""
    301329        pyutilib.misc.setup_redirect(currdir+'importB.dat')
    302         print "import "+os.path.abspath(example_dir+'B.tab')+" ;"
     330        print "import "+os.path.abspath(example_dir+'B.tab')+" format=set:B;"
    303331        pyutilib.misc.reset_redirect()
    304332        model=Model()
     
    312340        treated as values for a set with tuple values."""
    313341        pyutilib.misc.setup_redirect(currdir+'importC.dat')
    314         print "import "+os.path.abspath(example_dir+'C.tab')+" : C ;"
     342        print "import "+os.path.abspath(example_dir+'C.tab')+" format=set: C ;"
    315343        pyutilib.misc.reset_redirect()
    316344        model=Model()
     
    345373        """Same as tableXW."""
    346374        pyutilib.misc.setup_redirect(currdir+'importY.dat')
    347         print "import "+os.path.abspath(example_dir+'Y.tab')+" ;"
     375        print "import "+os.path.abspath(example_dir+'Y.tab')+" : [A] Y;"
    348376        pyutilib.misc.reset_redirect()
    349377        model=Model()
     
    360388        index column."""
    361389        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
    362         print "import "+os.path.abspath(example_dir+'XW.tab')+" ;"
     390        print "import "+os.path.abspath(example_dir+'XW.tab')+": [A] X W;"
    363391        pyutilib.misc.reset_redirect()
    364392        model=Model()
     
    375403        """Like test_tableXW_1, except that set A is not defined."""
    376404        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
    377         print "import "+os.path.abspath(example_dir+'XW.tab')+" ;"
     405        print "import "+os.path.abspath(example_dir+'XW.tab')+": [A] X W;"
    378406        pyutilib.misc.reset_redirect()
    379407        model=Model()
     
    390418        """Like test_tableXW_1, except that set A is defined in the import statment."""
    391419        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
    392         print "import "+os.path.abspath(example_dir+'XW.tab')+" : [A] A X W;"
     420        print "import "+os.path.abspath(example_dir+'XW.tab')+": A=[A] X W;"
    393421        pyutilib.misc.reset_redirect()
    394422        model=Model()
     
    405433        """Like test_tableXW_1, except that set A is defined in the import statment and all values are mapped."""
    406434        pyutilib.misc.setup_redirect(currdir+'importXW.dat')
    407         print "import "+os.path.abspath(example_dir+'XW.tab')+" : [A] B:A R:X S:W;"
     435        print "import "+os.path.abspath(example_dir+'XW.tab')+": B=[A] R=X S=W;"
    408436        pyutilib.misc.reset_redirect()
    409437        model=Model()
     
    448476        index column.  A missing value is represented in the column data."""
    449477        pyutilib.misc.setup_redirect(currdir+'importS.dat')
    450         print "import "+os.path.abspath(example_dir+'S.tab')+" ;"
     478        print "import "+os.path.abspath(example_dir+'S.tab')+": [A] S ;"
    451479        pyutilib.misc.reset_redirect()
    452480        model=Model()
     
    461489        """Importing a table that has multiple indexing columns"""
    462490        pyutilib.misc.setup_redirect(currdir+'importPO.dat')
    463         print "import "+os.path.abspath(example_dir+'PO.tab')+" : [A,B] J:A,B P O;"
     491        print "import "+os.path.abspath(example_dir+'PO.tab')+" : J=[A,B] P O;"
    464492        pyutilib.misc.reset_redirect()
    465493        model=Model()
     
    474502
    475503
     504class TestModelData(unittest.TestCase):
     505
     506    def test_tableA1(self):
     507        """Importing a single column of data"""
     508        md = ModelData()
     509        md.add(os.path.abspath(example_dir+'A.tab'), format='set', set='A')
     510        model=Model()
     511        model.A = Set()
     512        md.read(model)
     513        instance = model.create(md)
     514        self.failUnlessEqual(instance.A.data(), set(['A1', 'A2', 'A3']))
     515
     516    def test_tableA2(self):
     517        """Importing a single column of data"""
     518        md = ModelData()
     519        md.add(os.path.abspath(example_dir+'A.tab'))
     520        model=Model()
     521        model.A = Set()
     522        try:
     523            md.read(model)
     524            instance = model.create(md)
     525            self.fail("Should fail because no set name is specified")
     526        except IOError:
     527            pass
     528
     529    def test_tableA3(self):
     530        """Importing a single column of data"""
     531        md = ModelData()
     532        md.add(os.path.abspath(example_dir+'A.tab'), set='A')
     533        model=Model()
     534        model.A = Set()
     535        try:
     536            md.read(model)
     537            instance = model.create(md)
     538            self.fail("Should fail because no index is specified")
     539        except IOError:
     540            pass
     541
     542    def test_tableB(self):
     543        """Same as test_tableA"""
     544        md = ModelData()
     545        md.add(os.path.abspath(example_dir+'B.tab'), format='set', set='B')
     546        model=Model()
     547        model.B = Set()
     548        md.read(model)
     549        instance = model.create(md)
     550        self.failUnlessEqual(instance.B.data(), set([1, 2, 3]))
     551
     552    def test_tableC(self):
     553        """Importing a multi-column table, where all columns are
     554        treated as values for a set with tuple values."""
     555        md = ModelData()
     556        md.add(os.path.abspath(example_dir+'C.tab'), format='set', set='C')
     557        model=Model()
     558        model.C = Set(dimen=2)
     559        md.read(model)
     560        instance = model.create(md)
     561        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A1',2), ('A1',3), ('A2',1), ('A2',2), ('A2',3), ('A3',1), ('A3',2), ('A3',3)]))
     562
     563    def test_tableD(self):
     564        """Importing a 2D array of data as a set."""
     565        md = ModelData()
     566        md.add(os.path.abspath(example_dir+'D.tab'), format='set_array', set='C')
     567        model=Model()
     568        model.C = Set(dimen=2)
     569        md.read(model)
     570        instance = model.create(md)
     571        self.failUnlessEqual(instance.C.data(), set([('A1',1), ('A2',2), ('A3',3)]))
     572
     573    def test_tableZ(self):
     574        """Importing a single parameter"""
     575        md = ModelData()
     576        md.add(os.path.abspath(example_dir+'Z.tab'), format='param', param='Z')
     577        model=Model()
     578        model.Z = Param(default=99.0)
     579        md.read(model)
     580        instance = model.create(md)
     581        self.failUnlessEqual(instance.Z.value, 1.1)
     582
     583    def test_tableY(self):
     584        """Same as tableXW."""
     585        md = ModelData()
     586        md.add(os.path.abspath(example_dir+'Y.tab'), index=['A'], param=['Y'])
     587        model=Model()
     588        model.A = Set(initialize=['A1','A2','A3','A4'])
     589        model.Y = Param(model.A)
     590        md.read(model)
     591        instance = model.create(md)
     592        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
     593        self.failUnlessEqual(instance.Y.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
     594
     595    def test_tableXW_1(self):
     596        """Importing a table, but only reporting the values for the non-index
     597        parameter columns.  The first column is assumed to represent an
     598        index column."""
     599        md = ModelData()
     600        md.add(os.path.abspath(example_dir+'XW.tab'), index=['A'], param=['X','W'])
     601        model=Model()
     602        model.A = Set(initialize=['A1','A2','A3','A4'])
     603        model.X = Param(model.A)
     604        model.W = Param(model.A)
     605        md.read(model)
     606        instance = model.create(md)
     607        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
     608        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
     609        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
     610
     611    def test_tableXW_2(self):
     612        """Like test_tableXW_1, except that set A is not defined."""
     613        md = ModelData()
     614        md.add(os.path.abspath(example_dir+'XW.tab'), index=['A'], param=['X','W'])
     615        model=Model()
     616        model.A = Set()
     617        model.X = Param(model.A)
     618        model.W = Param(model.A)
     619        md.read(model)
     620        instance = model.create(md)
     621        self.failUnlessEqual(instance.A.data(), set())
     622        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
     623        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
     624
     625    def test_tableXW_3(self):
     626        """Like test_tableXW_1, except that set A is defined in the import statment."""
     627        md = ModelData()
     628        md.add(os.path.abspath(example_dir+'XW.tab'), index_name='A', index=['A'], param=['X','W'])
     629        model=Model()
     630        model.A = Set()
     631        model.X = Param(model.A)
     632        model.W = Param(model.A)
     633        md.read(model)
     634        instance = model.create(md)
     635        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3']))
     636        self.failUnlessEqual(instance.X.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
     637        self.failUnlessEqual(instance.W.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
     638
     639    def test_tableXW_4(self):
     640        """Like test_tableXW_1, except that set A is defined in the import statment and all values are mapped."""
     641        md = ModelData()
     642        md.add(os.path.abspath(example_dir+'XW.tab'), index_name='B', index=['A'], param=['X','W'], param_name={'X':'R', 'W':'S'})
     643        model=Model()
     644        model.B = Set()
     645        model.R = Param(model.B)
     646        model.S = Param(model.B)
     647        md.read(model)
     648        instance = model.create(md)
     649        self.failUnlessEqual(instance.B.data(), set(['A1','A2','A3']))
     650        self.failUnlessEqual(instance.R.data(), {'A1':3.3,'A2':3.4,'A3':3.5})
     651        self.failUnlessEqual(instance.S.data(), {'A1':4.3,'A2':4.4,'A3':4.5})
     652
     653    def test_tableT(self):
     654        """Importing a 2D array of parameters that are transposed."""
     655        md = ModelData()
     656        md.add(os.path.abspath(example_dir+'T.tab'), format='transposed_array', param='T')
     657        model=Model()
     658        model.A = Set()
     659        model.B = Set()
     660        model.T = Param(model.A, model.B)
     661        md.read(model)
     662        instance = model.create(md)
     663        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})
     664
     665    def test_tableU(self):
     666        """Importing a 2D array of parameters."""
     667        md = ModelData()
     668        md.add(os.path.abspath(example_dir+'T.tab'), format='array', param='U')
     669        model=Model()
     670        model.A = Set()
     671        model.B = Set()
     672        model.U = Param(model.A, model.B)
     673        md.read(model)
     674        instance = model.create(md)
     675        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})
     676
     677    def test_tableS(self):
     678        """Importing a table, but only reporting the values for the non-index
     679        parameter columns.  The first column is assumed to represent an
     680        index column.  A missing value is represented in the column data."""
     681        md = ModelData()
     682        md.add(os.path.abspath(example_dir+'S.tab'), index=['A'], param=['S'])
     683        model=Model()
     684        model.A = Set(initialize=['A1','A2','A3','A4'])
     685        model.S = Param(model.A)
     686        md.read(model)
     687        instance = model.create(md)
     688        self.failUnlessEqual(instance.A.data(), set(['A1','A2','A3','A4']))
     689        self.failUnlessEqual(instance.S.data(), {'A1':3.3,'A3':3.5})
     690
     691    def test_tablePO(self):
     692        """Importing a table that has multiple indexing columns"""
     693        pyutilib.misc.setup_redirect(currdir+'importPO.dat')
     694        print "import "+os.path.abspath(example_dir+'PO.tab')+" : J=[A,B] P O;"
     695        pyutilib.misc.reset_redirect()
     696        md = ModelData()
     697        md.add(os.path.abspath(example_dir+'PO.tab'), index_name='J', index=['A','B'], param=['P','O'])
     698        model=Model()
     699        model.J = Set(dimen=2)
     700        model.P = Param(model.J)
     701        model.O = Param(model.J)
     702        md.read(model)
     703        instance = model.create(md)
     704        self.failUnlessEqual(instance.J.data(), set([('A3', 'B3'), ('A1', 'B1'), ('A2', 'B2')]) )
     705        self.failUnlessEqual(instance.P.data(), {('A3', 'B3'): 4.5, ('A1', 'B1'): 4.3, ('A2', 'B2'): 4.4} )
     706        self.failUnlessEqual(instance.O.data(), {('A3', 'B3'): 5.5, ('A1', 'B1'): 5.3, ('A2', 'B2'): 5.4})
     707
     708
    476709if __name__ == "__main__":
    477710   unittest.main()
  • coopr.pyomo/trunk/examples/pyomo/tutorials/table.py

    r2289 r2292  
    109109
    110110data = ModelData(model=model)
    111 data.add("tab/A.tab")
    112 data.add("tab/B.tab")
    113 data.add("tab/C.tab", set="C")
    114 data.add("tab/D.tab", set="D", format="set_array")
    115 data.add("tab/E.tab", set="E")
    116 data.add("tab/I.tab")
    117 data.add("tab/Z.tab", param="Z")
    118 data.add("tab/Y.tab")
    119 data.add("tab/XW.tab")
     111data.add("tab/A.tab", format='set', set='A')
     112data.add("tab/B.tab", format='set', set='B')
     113data.add("tab/C.tab", format='set', set="C")
     114data.add("tab/D.tab", format="set_array", set='D')
     115data.add("tab/E.tab", format='set', set="E")
     116data.add("tab/I.tab", format='set', set='I')
     117data.add("tab/Z.tab", format='param', param="Z")
     118data.add("tab/Y.tab", index=['A'], param=['Y'])
     119data.add("tab/XW.tab", index=['A'], param=['X','W'])
    120120data.add("tab/T.tab", param="T", format="transposed_array")
    121121data.add("tab/U.tab", param="U", format="array")
    122 data.add("tab/S.tab")
    123 data.add("tab/RQ.tab", index="H", param=("R","Q"))
    124 data.add("tab/PO.tab", index="J", param=("P","O"))
    125 data.add("tab/PP.tab", param="PP")
     122data.add("tab/S.tab", index=['A'], param=['S'])
     123data.add("tab/RQ.tab", index_name="H", index=['H'], param=("R","Q"))
     124data.add("tab/PO.tab", index_name="J", index=('A','B'), param=("P","O"))
     125data.add("tab/PP.tab", index=('A','B'), param="PP")
    126126data.read()
    127127
Note: See TracChangeset for help on using the changeset viewer.