Changeset 2230


Ignore:
Timestamp:
Feb 1, 2010 4:58:05 PM (10 years ago)
Author:
wehart
Message:

Merged revisions 2208-2229 via svnmerge from
https://software.sandia.gov/svn/public/coopr/coopr.pyomo/trunk

........

r2209 | jwatson | 2010-01-30 17:01:12 -0700 (Sat, 30 Jan 2010) | 3 lines


Fix to new LP writer to output variable label, instead of name. The name has embedded quotes, which hoses all kinds of things. The label doesn't.

........

r2210 | jwatson | 2010-01-30 20:11:21 -0700 (Sat, 30 Jan 2010) | 3 lines


Additional minor fixings to make new LP writer work with PH - which it now does.

........

r2211 | jwatson | 2010-01-30 20:17:19 -0700 (Sat, 30 Jan 2010) | 3 lines


Suppressing warning for "constant constraint" when writing LP files - this happens all the time in PH and other contexts, where variable fixing is active.

........

r2213 | wehart | 2010-01-30 23:03:26 -0700 (Sat, 30 Jan 2010) | 2 lines


Adding the ability to process multiple *.dat files on the Pyomo command line

........

r2214 | wehart | 2010-01-31 14:44:12 -0700 (Sun, 31 Jan 2010) | 3 lines


Reworking the canonical expression definition to include a
dictionary from variable ID -> _VarValue object.

........

r2217 | wehart | 2010-01-31 21:48:34 -0700 (Sun, 31 Jan 2010) | 2 lines


Update to NL file writer, after recent changes in the canonical representation.

........

r2218 | wehart | 2010-01-31 22:11:59 -0700 (Sun, 31 Jan 2010) | 7 lines


Reworking the symbol_map generated for the NL file.


Fixing the use of this within PyomoModel? when loading data.


Adding logic to specify the 'solver' option when an optimization interface
is specified (e.g. asl:cplexamp).

........

r2226 | wehart | 2010-01-31 22:27:19 -0700 (Sun, 31 Jan 2010) | 2 lines


Removing some debugging IO.

........

r2227 | wehart | 2010-02-01 14:40:08 -0700 (Mon, 01 Feb 2010) | 7 lines


This is a major rework of the ModelData? logic. I've extracted the
actual operations for data loading into different plugins. These
plugins share a common code base for processing the data into a form that
Pyomo can use, but that logic is now separate from the ModelData? class itself.
This will provide a path-forward for cleaning up this code, as well as
modularizing the parsing of AMPL *.dat files.

........

r2228 | jwatson | 2010-02-01 14:49:40 -0700 (Mon, 01 Feb 2010) | 3 lines


Final fix to LP writer to (optionally) account for the models in which a variable originates - the PySP extensive form writer now passes all tests.

........

Location:
coopr.pyomo/stable/2.2
Files:
15 edited
7 copied

Legend:

Unmodified
Added
Removed
  • coopr.pyomo/stable/2.2

  • coopr.pyomo/stable/2.2/coopr/pyomo/__init__.py

    r2208 r2230  
    1717import base.pyomo as pyomo
    1818from expr import *
     19import data
    1920import io
    2021from components import *
  • coopr.pyomo/stable/2.2/coopr/pyomo/base/PyomoModel.py

    r2208 r2230  
    384384             # translate the name first if there is a variable map associated with the input solution.
    385385             if symbol_map is not None:
    386                  name = symbol_map[name]
     386                name = symbol_map[name]
    387387             if name not in self._name_varmap:
    388388                names=""
     
    417417             if name[0:2] == 'c_':
    418418                _name = name[4:-1]
     419             else:
     420                _name = name
    419421
    420422             if _name not in self._name_conmap:
  • coopr.pyomo/stable/2.2/coopr/pyomo/base/PyomoModelData.py

    r1958 r2230  
    99#  _________________________________________________________________________
    1010
    11 import re
    12 import copy
    13 import math
    14 import os
    15 from pyutilib.misc import quote_split
     11__all__ = ['ModelData']
     12
     13from plugin import *
    1614import pyomo
    17 from pyutilib.excel import ExcelSpreadsheet
    18 import coopr
    1915
    2016
     
    2218    """
    2319    An object that manages data for a model.
     20
    2421    This object contains the interface routines for importing and
    2522    exporting data from external data sources.
    2623    """
    2724
    28     def __init__(self,model=None,filename=None):
     25    def __init__(self, **kwds):
    2926        """
    3027        Constructor
    3128        """
     29        #
     30        # This is the data that is imported from various data sources
     31        #
     32        self._default={}
     33        self._data={}
     34        #
    3235        self._info=[]
    33         #self._info_dict={}
    34         self._data={}
    35         self._default={}
    36         self._model=model
    37         self._table={}
    38         if filename is not None:
    39            self.import_data_file(filename)
     36        if 'model' in kwds:
     37            self._model=kwds['model']
     38            del kwds['model']
     39        else:
     40            self._model=None
     41        if 'filename' in kwds:
     42            if not kwds['filename'] is None:
     43                filename = kwds['filename']
     44                del kwds['filename']
     45                self.add(filename, **kwds)
     46                self.read()
     47        elif len(kwds) > 0:
     48            raise ValueError, "Unknown options: %s" % str(kwds.keys())
    4049
     50    def add(self, filename, **kwds):
     51        tmp = filename.split(".")[-1]
     52        data = DataManagerFactory(tmp)
     53        data.initialize(filename, **kwds)
     54        self._info.append(data)
    4155
    42     #def add_data_file(self,filename, name=None):
    43         #if name is not None:
    44         #   self._info_dict[name] = len(self._info)
    45     def add_data_file(self,filename):
    46         self._info.append(filename)
    47 
    48 
    49     def add_table(self, filename, range=None, **kwds):
    50         """
    51         Add an Excel table
    52         """
    53         #if "name" in kwds:
    54         #   if name is not None:
    55         #      self._info_dict[kwds["name"]] = len(self._info)
    56         if filename not in self._table.keys():
    57            kwds["filename"]=filename
    58            self._table[filename] = TableData(**kwds)
    59         self._info.append((filename,range,kwds))
    60 
    61 
    62     def read(self,model=None):
     56    def read(self, model=None):
    6357        """
    6458        Read data
     
    6963           raise ValueError, "Cannot read model data without a model"
    7064        #
    71         # Open all tables
     65        # Although we want to load data in a particular order, it
     66        # may make sense to open/close all data resources all at once.
     67        # Should we do this by default, or make this a configuration option
     68        # for this class?
    7269        #
    73         for key in self._table.keys():
    74           self._table[key].open()
    75         #
    76         # For every information item, import the data or table
    77         #
    78         for item in self._info:
    79           if type(item) is str:
    80              if pyomo.debug("verbose"):         #pragma:nocover
    81                 print "Importing data from file "+item,
    82              status = self.import_data_file(item)
    83              if pyomo.debug("verbose"):         #pragma:nocover
    84                 print "... done."
    85           else:       
    86              if pyomo.debug("verbose"):         #pragma:nocover
    87                 print "Importing data from table "+item[0],
    88                 if item[1] is not None:
    89                    print "at range "+item[1],
    90              try:
    91                 status = self.import_table(self._table[item[0]], item[1], item[2])
    92              except IOError, err:
    93                 raise IOError, "Problem importing data from table "+item[0]+": "+str(err)
    94              except AttributeError, err:
    95                 raise IOError, "Problem importing data from table "+item[0]+": "+str(err)
    96              if pyomo.debug("verbose"):         #pragma:nocover
    97                 print "... done."
    98           if not status:
    99              print "Warning: status is "+str(status)+" after processing "+str(item)
    100         #
    101         # Close all tables
    102         #
    103         for key in self._table.keys():
    104           self._table[key].close()
     70        for data in self._info:
     71            if pyomo.debug("verbose"):         #pragma:nocover
     72                print "Importing data..."
     73            data.open()
     74            if not data.read():
     75                print "Warning: error occured while processing %s" % str(data)
     76            data.close()
     77            if pyomo.debug("verbose"):         #pragma:nocover
     78                print "Processing data ..."
     79            #
     80            # Update the _data and _default dictionaries with data that
     81            # was read in.
     82            #
     83            status = data.process(self._model, self._data, self._default)
     84            data.clear()
     85            if pyomo.debug("verbose"):         #pragma:nocover
     86                print "Done."
    10587
    106 
    107     def import_table(self, table, range, keywords):
    108         """
    109         Import a table
    110         """
    111         table.read(range, keywords)
    112         tmp = table.data()
    113         if pyomo.debug("reader"):               #pragma:nocover
    114            print "import_table - data: "+str(tmp)
    115         status = self._process_data(tmp)
    116         table.clear()
    117         return status
    118 
    119 
    120     def import_data_file(self, filename):
    121         """
    122         Create a table of tuples to values, based on data from a file.
    123         We assume that this data is defined in a format that is
    124         compatible with AMPL.
    125         """
    126         global Filename
    127         Filename = filename
    128         global Lineno
    129         Lineno = 0
    130         INPUT = open(filename,"r")
    131         cmd=""
    132         status=True
    133         for line in INPUT:
    134           Lineno += 1
    135           line = re.sub(":"," :",line)
    136           line = line.strip()
    137           if line == "" or line[0] == '#':
    138              continue
    139           cmd = cmd + " " + line
    140           if ';' in cmd:
    141              #
    142              # We assume that a ';' indicates an end-of-command declaration.
    143              # However, the user might have put multiple commands on a single
    144              # line, so we need to split the line based on these values.
    145              # BUT, at the end of the line we should see an 'empty' command,
    146              # which we ignore.
    147              #
    148              for item in cmd.split(';'):
    149                item = item.strip()
    150                if item != "":
    151                   status = self._process_data(quote_split("[\t ]+",item))
    152                if not status:
    153                   break
    154              cmd = ""
    155           if not status:
    156                  break
    157         if cmd != "":
    158            raise IOError, "ERROR: There was unprocessed text at the end of the data file!: \"" + cmd + "\""
    159         return status
    160 
    161 
    162     def _preprocess_data(self,cmd):
    163         """
    164         Called by _process_data() to (1) combine tokens that comprise a tuple
    165         and (2) combine the ':' token with the previous token
    166         """
    167         if pyomo.debug("reader"):               #pragma:nocover
    168            print "_preprocess_data(start)",cmd
    169         status=")"
    170         newcmd=[]
    171         for token in cmd:
    172           if type(token) in (str,unicode):
    173              token=str(token)
    174              if "(" in token and ")" in token:
    175                 newcmd.append(token)
    176                 status=")"
    177              elif "(" in token:
    178                 if status == "(":
    179                    raise ValueError, "Two '('s follow each other in data "+token
    180                 status="("
    181                 newcmd.append(token)
    182              elif ")" in token:
    183                 if status == ")":
    184                    raise ValueError, "Two ')'s follow each other in data"
    185                 status=")"
    186                 newcmd[-1] = newcmd[-1]+token
    187              elif status == "(":
    188                 newcmd[-1] = newcmd[-1]+token
    189              else:
    190                 newcmd.append(token)
    191           else:
    192              if type(token) is float and math.floor(token) == token:
    193                 token=int(token)
    194              newcmd.append(token)
    195         if pyomo.debug("reader"):               #pragma:nocover
    196            print "_preprocess_data(end)",newcmd
    197         return newcmd
    198 
    199 
    200     def _process_data(self,cmd):
    201         """
    202         Called by import_file() to (1) preprocess data and (2) call
    203         subroutines to process different types of data
    204         """
    205         global Lineno
    206         global Filename
    207         if pyomo.debug("reader"):               #pragma:nocover
    208            print "DEBUG: _process_data (start)",cmd
    209         if len(cmd) == 0:                       #pragma:nocover
    210            raise ValueError, "ERROR: Empty list passed to Model::_process_data"
    211         cmd = self._preprocess_data(cmd)
    212         if cmd[0] == "data":
    213            return True
    214         if cmd[0] == "end":
    215            return False
    216         if cmd[0][0:3] == "set":
    217            self._process_set(cmd)
    218         elif cmd[0][0:5] == "param":
    219            self._process_param(cmd)
    220         else:
    221            raise IOError, "ERROR: Trouble on line "+str(Lineno)+" of file "+Filename+": Unknown data command: "+" ".join(cmd)
    222         return True
    223 
    224 
    225     def _process_set(self,cmd):
    226         """
    227         Called by _process_data() to process a set declaration.
    228         """
    229         if pyomo.debug("reader"):               #pragma:nocover
    230            print "DEBUG: _process_set(start)",cmd
    231         #
    232         # Process a set
    233         #
    234         if "[" in cmd[1]:
    235            tokens = re.split("[\[\]]",cmd[1])
    236            ndx=tokens[1]
    237            ndx=tuple(self._data_eval(ndx.split(",")))
    238            if tokens[0] not in self._data:
    239               self._data[tokens[0]] = {}
    240            self._data[tokens[0]][ndx] = self._process_set_data(cmd[3:],tokens[0])
    241         elif cmd[2] == ":":
    242            self._data[cmd[1]] = {}
    243            self._data[cmd[1]][None] = []
    244            i=3
    245            while cmd[i] != ":=":
    246               i += 1
    247            ndx1 = cmd[3:i]
    248            i += 1
    249            while i<len(cmd):
    250               ndx=cmd[i]
    251               for j in range(0,len(ndx1)):
    252                 if cmd[i+j+1] == "+":
    253                    self._data[cmd[1]][None] += self._process_set_data(["("+str(ndx1[j])+","+str(cmd[i])+")"],cmd[1])
    254               i += len(ndx1)+1
    255         else:
    256            self._data[cmd[1]] = {}
    257            self._data[cmd[1]][None] = self._process_set_data(cmd[3:], cmd[1])
    258 
    259 
    260     def _process_set_data(self,cmd,sname):
    261         """
    262         Called by _process_set() to process set data.
    263         """
    264         if pyomo.debug("reader"):               #pragma:nocover
    265            print "DEBUG: _process_set_data(start)",cmd
    266         if len(cmd) == 0:
    267            return []
    268         sd = getattr(self._model,sname)
    269         #d = sd.dimen
    270         cmd = self._data_eval(cmd)
    271         ans=[]
    272         i=0
    273         flag=type(cmd[0]) is tuple
    274         tmp=None
    275         ndx=None
    276         while i<len(cmd):
    277           if type(cmd[i]) is not tuple:
    278             if flag:
    279                #if type(cmd[i]) is not tuple:
    280                #   raise ValueError, "Problem initializing set="+sname+" with input data="+str(cmd)+" - first element was interpreted as a tuple, but element="+str(i)+" is of type="+str(type(cmd[i]))+"; types must be consistent"
    281                tmpval=tmp
    282                tmpval[ndx] = self._data_eval([cmd[i]])[0]
    283                #
    284                # WEH - I'm not sure what the next two lines are for
    285                #        These are called when initializing a set with more than
    286                #        one dimension
    287                #if d > 1:
    288                #   tmpval = util.tuplize(tmpval,d,sname)
    289                ans.append(tuple(tmpval))
    290             else:
    291                ans.append(cmd[i])
    292           elif "*" not in cmd[i]:
    293             ans.append(cmd[i])
    294           else:
    295             j = i
    296             tmp=list(cmd[j])
    297             ndx=tmp.index("*")
    298           i += 1
    299         if pyomo.debug("reader"):               #pragma:nocover
    300            print "DEBUG: _process_set_data(end)",ans
    301         return ans
    302 
    303 
    304     def _process_param(self,cmd):
    305         """
    306         Called by _process_data to process data for a Parameter declaration
    307         """
    308         if pyomo.debug("reader"):               #pragma:nocover
    309            print "DEBUG: _process_param(start)",cmd
    310         #
    311         # Process parameters
    312         #
    313         dflt = None
    314         singledef = True
    315         cmd = cmd[1:]
    316         #print "HERE",cmd
    317         #
    318         # WEH - this is apparently not used
    319         #
    320         #if cmd[0] == "default":
    321         #   dflt = self._data_eval(cmd[1])[0]
    322         #   cmd = cmd[2:]
    323         if cmd[0] == ":":
    324            singledef = False
    325            cmd = cmd[1:]
    326         if singledef:
    327            pname = cmd[0]
    328            cmd = cmd[1:]
    329            if len(cmd) >= 2 and cmd[0] == "default":
    330               dflt = self._data_eval(cmd[1])[0]
    331               cmd = cmd[2:]
    332            if dflt != None:
    333               self._default[pname] = dflt
    334            if cmd[0] == ":=":
    335               cmd = cmd[1:]
    336            transpose = False
    337            if cmd[0] == "(tr)":
    338               transpose = True
    339               if cmd[1] == ":":
    340                  cmd = cmd[1:]
    341               else:
    342                  cmd[0] = ":"
    343            if cmd[0] != ":":
    344               if pyomo.debug("reader"):             #pragma:nocover
    345                  print "DEBUG: _process_param (singledef without :...:=)",cmd
    346               if not transpose:
    347                  if pname not in self._data:
    348                     self._data[pname] = {}
    349                  finaldata = self._process_data_list(getattr(self._model,pname).dim(), self._data_eval(cmd))
    350                  for key in finaldata:
    351                     self._data[pname][key]=finaldata[key]
    352               else:
    353                  tmp = ["param", pname, ":="]
    354                  i=1
    355                  while i < len(cmd):
    356                     i0 = i
    357                     while cmd[i] != ":=":
    358                       i=i+1
    359                     ncol = i - i0 + 1
    360                     lcmd = i
    361                     while lcmd < len(cmd) and cmd[lcmd] != ":":
    362                       lcmd += 1
    363                     j0 = i0 - 1
    364                     for j in range(1,ncol):
    365                       ii = 1 + i
    366                       kk = ii + j
    367                       while kk < lcmd:
    368                         if cmd[kk] != ".":
    369                         #if 1>0:
    370                            tmp.append(copy.copy(cmd[j+j0]))
    371                            tmp.append(copy.copy(cmd[ii]))
    372                            tmp.append(copy.copy(cmd[kk]))
    373                         ii = ii + ncol
    374                         kk = kk + ncol
    375                     i = lcmd + 1
    376                  self._process_param(tmp)
    377            else:
    378               tmp = ["param", pname, ":="]
    379               i=1
    380               if pyomo.debug("reader"):             #pragma:nocover
    381                  print "DEBUG: _process_param (singledef with :...:=)",cmd
    382               while i < len(cmd):
    383                 i0 = i
    384                 while i<len(cmd) and cmd[i] != ":=":
    385                   i=i+1
    386                 if i==len(cmd):
    387                    raise ValueError, "ERROR: Trouble on line "+str(Lineno)+" of file "+Filename
    388                 ncol = i - i0 + 1
    389                 lcmd = i
    390                 while lcmd < len(cmd) and cmd[lcmd] != ":":
    391                   lcmd += 1
    392                 j0 = i0 - 1
    393                 for j in range(1,ncol):
    394                   ii = 1 + i
    395                   kk = ii + j
    396                   while kk < lcmd:
    397                     if cmd[kk] != ".":
    398                         if transpose:
    399                            tmp.append(copy.copy(cmd[j+j0]))
    400                            tmp.append(copy.copy(cmd[ii]))
    401                         else:
    402                            tmp.append(copy.copy(cmd[ii]))
    403                            tmp.append(copy.copy(cmd[j+j0]))
    404                         tmp.append(copy.copy(cmd[kk]))
    405                     ii = ii + ncol
    406                     kk = kk + ncol
    407                 i = lcmd + 1
    408                 self._process_param(tmp)
    409 
    410         else:
    411            if pyomo.debug("reader"):                #pragma:nocover
    412               print "DEBUG: _process_param (cmd[0]=='param:')",cmd
    413            i=0
    414            nsets=0
    415            while i<len(cmd) and cmd[i] != ":=":
    416              if cmd[i] == ":":
    417                 nsets = i
    418              i += 1
    419            if i==len(cmd):
    420               raise ValueError, "Trouble on data file line "+str(Lineno)+" of file "+Filename
    421            if pyomo.debug("reader"):                #pragma:nocover
    422               print "NSets",nsets
    423            Lcmd = len(cmd)
    424            j=0
    425            d = 1
    426            #
    427            # Process sets first
    428            #
    429            while j<nsets:
    430              sname = cmd[j]
    431              d = getattr(self._model,sname).dimen
    432              np = i-1
    433              if pyomo.debug("reader"):              #pragma:nocover
    434                 print "I,J,SName,d",i,j,sname,d
    435              dnp = d + np - 1
    436              #k0 = i + d - 2
    437              ii = i + j + 1
    438              tmp = [ "set", cmd[j], ":=" ]
    439              while ii < Lcmd:
    440                for dd in range(0,d):
    441                  tmp.append(copy.copy(cmd[ii+dd]))
    442                ii += dnp
    443              self._process_set(tmp)
    444              j += 1
    445            if nsets > 0:
    446               j += 1
    447            #
    448            # Process parameters second
    449            #
    450            while j < i:
    451              pname = cmd[j]
    452              if pyomo.debug("reader"):              #pragma:nocover
    453                 print "I,J,Pname",i,j,pname
    454              #d = 1
    455              d = getattr(self._model,pname).dim()
    456              if nsets > 0:
    457                 np = i-1
    458                 dnp = d+np-1
    459                 ii = i + 1
    460                 kk = i + d + j-1
    461              else:
    462                 np = i
    463                 dnp = d + np
    464                 ii = i + 1
    465                 kk = np + 1 + d + nsets + j
    466              tmp = [ "param", pname, ":=" ]
    467              if pyomo.debug("reader"):              #pragma:nocover
    468                 print "dnp",dnp
    469                 print "np",np
    470              while kk < Lcmd:
    471                if pyomo.debug("reader"):                #pragma:nocover
    472                   print "kk,ii",kk,ii
    473                iid = ii + d
    474                while ii < iid:
    475                  tmp.append(copy.copy(cmd[ii]))
    476                  ii += 1
    477                ii += dnp-d
    478                tmp.append(copy.copy(cmd[kk]))
    479                kk += dnp
    480              self._process_param(tmp)
    481              j += 1
    482 
    483 
    484     def _process_data_list(self,dim,cmd):
    485         """
    486         Called by _process_param() to process a list of data for a
    487         Parameter.
    488         """
    489         if pyomo.debug("reader"):               #pragma:nocover
    490            print "process_data_list",dim,cmd
    491         if len(cmd) % (dim+1) != 0:
    492            raise ValueError, "Parameter data has "+str(len(cmd))+" values (" + str(cmd) + "), which is incompatible with having "+str(dim)+" dimensions"           
    493         ans={}
    494         if dim==0:
    495            ans[None]=cmd[0]
    496            return ans
    497         i=0
    498         while i<len(cmd):
    499           ndx = tuple(cmd[i:i+dim])
    500           ##print i,cmd[i:i+dim],ndx,cmd[i+dim]
    501           if cmd[i+dim] != ".":
    502                  ans[ndx] = cmd[i+dim]
    503           i += dim+1
    504         return ans
    505 
    506 
    507     def _data_eval(self, values):
    508         """
    509         Evaluate the list of values to make them bool, integer or float,
    510         or a tuple value.
    511         """
    512         if pyomo.debug("reader"):               #pragma:nocover
    513            print "DEBUG: _data_eval(start)",values
    514         ans = []
    515         for val in values:
    516           if type(val) in (bool,int,float,long):
    517              ans.append(val)
    518              continue
    519           if val in ('True','true','TRUE'):
    520              ans.append(True)
    521              continue
    522           if val in ('False','false','FALSE'):
    523              ans.append(False)
    524              continue
    525           tmp = None
    526           if "(" in val and ")" in val:
    527              vals = []
    528              tval = val[1:-1]
    529              for item in tval.split(","):
    530                tmp=self._data_eval([item])
    531                vals.append(tmp[0])
    532              ans.append(tuple(vals))
    533              continue
    534           try:
    535              tmp = int(val)
    536              ans.append(tmp)
    537           except ValueError:
    538              pass
    539           if tmp is None:
    540              try:
    541                tmp = float(val)
    542                ans.append(tmp)
    543              except ValueError:
    544                ans.append(val)
    545         if pyomo.debug("reader"):               #pragma:nocover
    546            print "DEBUG: _data_eval(end)",ans
    547         return ans
    548 
    549 
    550 
    551 class TableData(object):
    552     """
    553     An object that imports data from a table in an external data source.
    554     The initialization of this object depends on the format specified by the
    555     file:
    556  
    557                 *.tab       Simple ASCII table
    558                 *.xls       Excel spreadsheet
    559                 *.mdb       MSAccess database
    560 
    561     NOTE: it probably makes sense to migrate the table handlers to
    562     external classes, and to enable registration of table handlers.
    563     But for ValueErrornow, this is convenient.
    564     """
    565 
    566     def __init__(self,*args,**kwds):
    567         """
    568         Constructor
    569         """
    570         self._info=None
    571         #
    572         self._reinitialize(kwds)
    573 
    574 
    575     def _reinitialize(self,kwds):
    576         if kwds is None:
    577            return
    578         self._data=None
    579         self._filename=None
    580         self._range=None
    581         self._format=None
    582         self._set=None
    583         self._param=None
    584         self._index=None
    585         for key in kwds:
    586           if key not in ["set","format","index","param","data","filename","range"]:
    587              raise ValueError, "Unknown keyword '"+key+"' when initializing TableData object"
    588           setattr(self,"_"+key,kwds[key])
    589 
    590     def open(self,filename=None):
    591         """
    592         Open the table
    593         """
    594         if filename is not None:
    595            self._filename=filename
    596         if self._filename is None:
    597            raise IOError, "No filename specified"
    598         if not os.path.exists(self._filename):
    599            raise IOError, "Cannot find file: \""+self._filename+"\""
    600         tmp = self._filename.split(".")
    601         if len(tmp) == 1:
    602            raise IOError, "Unknown file type: \""+self._filename+"\""
    603         self._type=tmp[-1]
    604         if self._type == "tab":
    605            self._open_tab()
    606         elif self._type == "xls":
    607            self._open_xls()
    608         elif self._type == "mdb":       #pragma:nocover
    609            self._open_mdb()
    610         else:
    611            raise IOError, "Unknown file type: \""+self._filename+"\""
    612 
    613 
    614     def read(self,range=None, keywords=None):
    615         """
    616         Read data from the table
    617         """
    618         self._reinitialize(keywords)
    619         if range is not None:
    620            self._range=range
    621         if self._type == "tab":
    622            self._read_tab()
    623         elif self._type == "xls":
    624            self._read_xls()
    625         elif self._type == "mdb":       #pragma:nocover
    626            self._read_mdb()
    627 
    628 
    629     def close(self):
    630         """
    631         Close the table
    632         """
    633         if self._type == "tab":
    634            self._close_tab()
    635         elif self._type == "xls":
    636            self._close_xls()
    637         elif self._type == "mdb":
    638            self._close_mdb()            #pragma:nocover
    639 
    640 
    641     def _open_tab(self):
    642         self.INPUT = open(self._filename,"r")
    643 
    644     def _read_tab(self):
    645         tmp=[]
    646         for line in self.INPUT.readlines():
    647           line=line.strip()
    648           tokens = re.split("[\t ]+",line)
    649           if tokens != ['']:
    650              tmp.append(tokens)
    651         if len(tmp) == 0:
    652            raise IOError, "Empty *.tab file"
    653         elif len(tmp) == 1:
    654            self._info = ["param",self._param,":=",tmp[0][0]]
    655         else:
    656            self._set_data(tmp[0], tmp[1:])
    657 
    658     def _close_tab(self):
    659         self.INPUT.close()
    660        
    661 
    662     def _open_xls(self):
    663         self.sheet = None
    664         if self._data is not None:
    665            self.sheet = self._data
    666         else:
    667            try:
    668               self.sheet = ExcelSpreadsheet(self._filename)
    669            except pyutilib.ApplicationError:
    670               raise
    671 
    672     def _read_xls(self):
    673         if self.sheet is None:
    674            return
    675         tmp = self.sheet.get_range(self._range, raw=True)
    676         if type(tmp) in (int,long,float):
    677            self._info = ["param",self._param,":=",tmp]
    678         else:
    679            self._set_data(tmp[0], tmp[1:])
    680 
    681     def _close_xls(self):
    682         if self._data is None and not self.sheet is None:
    683            del self.sheet
    684 
    685 
    686     def _open_mdb(self):
    687         pass                #pragma:nocover
    688 
    689     def _read_mdb(self):
    690         pass                #pragma:nocover
    691 
    692     def _close_mdb(self):
    693         pass                #pragma:nocover
    694 
    695 
    696     def data(self):
    697         return self._info
    698 
    699 
    700     def clear(self):
    701         self._info = None
    702 
    703 
    704     def _set_data(self, headers, rows):
    705         if self._set is not None:
    706            if self._format is None:
    707               self._info = ["set",self._set,":="]
    708               for row in rows:
    709                 self._info = self._info + list(row)
    710            elif self._format is "array":
    711               self._info = ["set",self._set, ":"]
    712               self._info = self._info + list(headers[1:])
    713               self._info = self._info + [":="]
    714               for row in rows:
    715                 self._info = self._info + list(row)
    716            else:
    717               raise ValueError, "Unknown set format: "+self._format
    718 
    719         elif self._index is not None and self._param is None:
    720            self._info = ["param",":",self._index,":"]
    721            self._info = self._info + map(str,list(headers[1:]))
    722            self._info.append(":=")
    723            for row in rows:
    724              self._info = self._info + list(row)
    725 
    726         elif self._index is not None and self._param is not None:
    727            self._info = ["param",":",self._index,":"]
    728            if type(self._param) is str:
    729               self._info = self._info + [self._param]
    730            elif type(self._param) is tuple:
    731               self._info = self._info + list(self._param)
    732            else:
    733               self._info = self._info + self._param
    734            self._info.append(":=")
    735            for row in rows:
    736              self._info = self._info + list(row)
    737 
    738         elif self._param is not None and self._format is not None:
    739            if self._format is "transposed_array":
    740               self._info = ["param",self._param,"(tr)",":"] + map(str,list(headers[1:]))
    741            elif self._format is "array":
    742               self._info = ["param",self._param,":"] + map(str,list(headers[1:]))
    743            else:
    744               raise ValueError, "Unknown parameter format: "+self._format
    745            self._info.append(":=")
    746            for row in rows:
    747              self._info = self._info + list(row)
    748 
    749         else:
    750            if len(headers) == 1:
    751               self._info = ["set",headers[0],":="]
    752               for row in rows:
    753                 self._info = self._info + list(row)
    754            else:
    755               self._info = ["param",":"]
    756               if self._param is None:
    757                  self._info = self._info + map(str,list(headers[1:]))
    758               elif type(self._param) is str:
    759                  self._info = self._info + [self._param]
    760               else:
    761                  self._info = self._info + list(self._param)
    762               self._info.append(":=")
    763               for row in rows:
    764                 self._info = self._info + list(row)
    765 
  • coopr.pyomo/stable/2.2/coopr/pyomo/base/__init__.py

    r1414 r2230  
    1212from numtypes import *
    1313from plugin import *
     14from PyomoModelData import *
    1415#
    1516# Components
     
    2122#
    2223from set_types import *
    23 from PyomoModelData import *
    2424from misc import *
    2525from PyomoModel import *
  • coopr.pyomo/stable/2.2/coopr/pyomo/base/plugin.py

    r2208 r2230  
    1313        'ComponentFactory',
    1414        'IPyomoPresolver', 'IPyomoPresolveAction',
     15        'DataManagerRegistration',
     16        'DataManagerFactory',
    1517        'IModelTransformation',
    1618        'apply_transformation']
     
    130132
    131133
     134class IDataManager(Interface):
     135
     136    def type(self):
     137        """Return the type of the data manager"""
     138
     139    def cls(self):
     140        """Return the class type of this data manager"""
     141
     142    def create(self):
     143        """Create an instance of this data manager"""
     144
     145
     146class DataManagerRegistration(Plugin):
     147
     148    implements(IDataManager)
     149
     150    def __init__(self, type, cls, doc=""):
     151        Plugin.__init__(self, name=type)
     152        self._type = type
     153        self._cls = cls
     154        self.doc=doc
     155
     156    def type(self):
     157        return self._type
     158
     159    def cls(self):
     160        return self._cls
     161
     162    def create(self):
     163        return self._cls()
     164
     165
     166def DataManagerFactory(name=None, args=[]):
     167    ep = ExtensionPoint(IDataManager)
     168    if name is None:
     169        return map(lambda x:x.name, ep())
     170    return ep.service(name).create()
     171
     172
     173
    132174class IModelTransformation(Interface):
    133175
  • coopr.pyomo/stable/2.2/coopr/pyomo/expr/canonical_repn.py

    r2208 r2230  
    3232
    3333
    34 def as_expr(rep, model, ignore_other=False):
     34def as_expr(rep, vars=None, model=None, ignore_other=False):
    3535    """ Convert a canonical representation into an expression. """
    3636    if isinstance(model, Model):
    3737        vars = model._var
    3838        id_offset=0
    39     else:
    40         vars = model
     39    elif not vars is None:
    4140        id_offset=1
    4241    expr = 0.0
     
    4544            if not ignore_other:
    4645                expr += rep[d]
     46            continue
     47        if d is -1:
    4748            continue
    4849        for v in rep[d]:
     
    5354            for id in v:
    5455                for i in xrange(v[id]):
    55                     e *= vars[id+id_offset]
     56                    if vars is None:
     57                        e *= rep[-1][id]
     58                    else:
     59                        e *= vars[id[1]+id_offset]
    5660            expr += e
    5761    return expr
     
    6670                rep[d] = r2[d]
    6771            continue
     72        if d < 0:
     73            continue
    6874        if not d in rep:
    6975            rep[d] = {}
    7076        for var in r2[d]:
    7177            rep[d][var] = coef*r2[d][var] + rep[d].get(var,0.0)
     78    #
     79    # Merge the VarValue maps
     80    #
     81    if -1 in r2:
     82        if -1 in rep:
     83            rep[-1].update(r2[-1])
     84        else:
     85            rep[-1] = r2[-1]
    7286    return rep
    7387
    7488
    75 def repn_mult(r1, r2, model, coef=1.0):
     89def repn_mult(r1, r2, coef=1.0):
    7690    rep = {}
    7791    for d1 in r1:
    7892        for d2 in r2:
    79             if d1 == None or d2 == None:
     93            if d1 == None or d2 == None or d1 < 0 or d2 < 0:
    8094                pass
    8195            else:
     
    105119    #
    106120    if None in r1:
    107         rep[None] = as_expr(r2, model, ignore_other=True) * copy.deepcopy(r1[None])
    108         #print "YY"
    109         #r1[None].pprint()
    110         #as_expr(r2, model, ignore_other=True).pprint()
    111         #print "YY"
     121        rep[None] = as_expr(r2, ignore_other=True) * copy.deepcopy(r1[None])
    112122        if None in r2:
    113123            rep[None] += copy.deepcopy(r1[None])*copy.deepcopy(r2[None])
    114124    if None in r2:
    115125        if None in rep:
    116             rep[None] += as_expr(r1, model, ignore_other=True) * copy.deepcopy(r2[None])
    117         else:
    118             rep[None]  = as_expr(r1, model, ignore_other=True) * copy.deepcopy(r2[None])
     126            rep[None] += as_expr(r1, ignore_other=True) * copy.deepcopy(r2[None])
     127        else:
     128            rep[None]  = as_expr(r1, ignore_other=True) * copy.deepcopy(r2[None])
     129    #
     130    # Merge the VarValue maps
     131    #
     132    if -1 in r1:
     133        rep[-1] = r1[-1]
     134    if -1 in r2:
     135        if -1 in rep:
     136            rep[-1].update(r2[-1])
     137        else:
     138            rep[-1] = r2[-1]
    119139    #
    120140    # Return the canonical repn
     
    134154# called recursively.
    135155#
    136 def collect_canonical_repn(exp, model):
     156def collect_canonical_repn(exp):
    137157    global temp_const
    138158    global temp_var
     
    156176                repn = {}
    157177            for i in range(len(exp._args)):
    158                 repn = repn_add(repn, collect_canonical_repn(exp._args[i], model), coef=exp._coef[i] )
     178                repn = repn_add(repn, collect_canonical_repn(exp._args[i]), coef=exp._coef[i] )
    159179            return repn
    160180        #
     
    186206            #print "Y",exp.coef/denom
    187207            for e in exp._numerator:
    188                 repn = repn_mult(repn, collect_canonical_repn(e, model), model)
     208                repn = repn_mult(repn, collect_canonical_repn(e))
    189209            return repn
    190210        #
     
    203223    #
    204224    elif type(exp) is _VarValue or exp.type() is Var:
    205         temp_var = { 1: {frozendict({exp.id:1}):1.0} }   
     225        if type(exp) is _VarValue:
     226            mid = id(exp.var.model)
     227        else:
     228            mid = id(exp.model)
     229        temp_var = { -1: {(mid,exp.id):exp}, 1: {frozendict({(mid,exp.id):1}):1.0} }   
    206230        return temp_var
    207231    #
     
    232256# log(y[1]) + x[1]*x[1]         {2:{{0:2}:1.0}, None:log(y[1])}
    233257#
    234 def generate_canonical_repn(expr, model):
    235     return collect_canonical_repn(expr, model)
     258def generate_canonical_repn(expr):
     259    return collect_canonical_repn(expr)
    236260
    237261def is_constant(repn):
    238262    """Return True if the canonical representation is a constant expression"""
    239     return (0 in repn) and (len(repn) == 1)
     263    for key in repn:
     264        if key is None or key > 0:
     265            return False
     266    return True
    240267
    241268def is_nonlinear(repn):
    242269    """Return True if the canonical representation is a nonlinear expression"""
    243270    for key in repn:
    244         if not key in [0,1]:
     271        if not key in [-1,0,1]:
    245272            return True
    246273    return False
  • coopr.pyomo/stable/2.2/coopr/pyomo/io/ampl.py

    r2194 r2230  
    4444           return None
    4545
    46     def _print_model_NL(self,model, OUTPUT, verbose=False):
     46    def _print_model_NL(self, model, OUTPUT, verbose=False):
    4747
    4848        # maps NL variables to the "real" variable names in the problem.
     
    5858        Obj = model.active_components(Objective)
    5959        Con = model.active_components(Constraint)
    60         Vars = model.active_components(Var)
     60        Var = {}   # Dictionary of all variables used in all expressions in this model
    6161        #
    6262        # Count number of objectives
     
    6767            for i in Obj[obj]:
    6868                if not is_constant(Obj[obj][i].repn):
     69                    # Merge variables from this expression
     70                    Var.update( Obj[obj][i].repn[-1] )
    6971                    no += 1
    7072        #
     
    7880                if is_constant(C[i].repn):
    7981                    continue
     82                # Merge variables from this expression
     83                Var.update( C[i].repn[-1] )
    8084                nc += 1
    8185                if C[i].lower is not None:
     
    9195                    nrange += 1
    9296        #
    93         icv = 0
     97        niv = nbv = 0
    9498        Ilist = []
    9599        Blist = []
    96100        Vlist = []
    97         for var in Vars.values():
    98                 Vv = var._varval
    99                 if isinstance(var.domain, IntegerSet):
    100                   # print "Domain of", var._name, "= Integers"
    101                   for ndx in Vv:
    102                            if Vv[ndx].id >= 0:
    103                                     Ilist.append((var,ndx))
    104                 elif isinstance(var.domain, BooleanSet):
    105                   # print "Domain of", var._name, "= Boolean"
    106                   for ndx in Vv:
    107                            if Vv[ndx].id >= 0:
    108                               L = Vv[ndx].lb
    109                               U = Vv[ndx].ub
    110                               if L is not None and value(L) == 0 \
    111                                  and U is not None and value(U) == 1:
    112                                         Blist.append((var,ndx))
    113                               else:
    114                                         Ilist.append((var,ndx))
    115                 else:
    116                   # print "Domain of", var_.name, "is not discrete."
    117                   for ndx in Vv:
    118                            Vi = Vv[ndx]
    119                            if Vi.id >= 0:
    120                                     Vi.id = icv
    121                                     icv += 1
    122                                     Vlist.append((var,ndx))
    123         for x in Blist:
    124                 x[0][x[1]].id = icv
    125                 icv += 1
    126                 Vlist.append((x[0],x[1]))
    127         for x in Ilist:
    128                 x[0]._varval[x[1]].id = icv
    129                 icv += 1
    130                 Vlist.append((x[0],x[1]))
     101        keys = Var.keys()
     102        keys.sort()
     103        for ndx in keys:
     104            var = Var[ndx].var
     105            if isinstance(var.domain, IntegerSet):
     106                Ilist.append(ndx)
     107            elif isinstance(var.domain, BooleanSet):
     108                L = Var[ndx].lb
     109                U = Var[ndx].ub
     110                if L is not None and value(L) == 0 \
     111                    and U is not None and value(U) == 1:
     112                    Blist.append(ndx)
     113                else:
     114                    Ilist.append(ndx)
     115            else:
     116                Vlist.append(ndx)
     117        for ndx in Blist:
     118            nbv += 1
     119            Vlist.append(ndx)
     120        for ndxx in Ilist:
     121            niv += 1
     122            Vlist.append(ndx)
     123        #
     124        vctr=0
     125        var_id = {}
     126        for ndx in Vlist:
     127            var_id[ndx] = vctr
     128            vctr += 1
    131129        #
    132130        # Print Header
     
    138136        # LINE 2
    139137        #
    140         print >>OUTPUT, " " + str(model.statistics.number_of_variables), nc, no, nrange, str(neqn) +\
     138        print >>OUTPUT, " ",len(Var), nc, no, nrange, str(neqn) +\
    141139                "\t# vars, constraints, objectives, ranges, eqns"
    142140        #
     
    159157        # LINE 7
    160158        #
    161         niv = nbv = 0
    162         for var in Vars.values():
    163                 Vv = var._varval
    164                 if isinstance(var.domain, IntegerSet):
    165                   for i in Vv.keys():
    166                            if Vv[i].id >= 0:
    167                                     niv += 1
    168                 elif isinstance(var.domain, BooleanSet):
    169                   for i in Vv.keys():
    170                            if Vv[i].id >= 0:
    171                                     nbv += 1
    172159        print >>OUTPUT, " " + str(nbv), niv, 0, 0,\
    173160                "0\t# discrete variables: binary, integer, nonlinear (b,c,o)"
     
    175162        # LINE 8
    176163        #
    177         nsno = model.statistics.number_of_variables
     164        nsno = len(Var)
    178165        ngc = ngo = 0
    179166        # Compute # of nonzeros in gradient
     
    186173        cu = {}
    187174        for i in xrange(nsno):
    188                 cu[i] = 0
     175            cu[i] = 0
    189176        for key in Con:
    190177            C = Con[key]
     
    194181                for d in C[cndx].repn.get(1,{}):
    195182                    ngc += 1
    196                     cu[d.keys()[0]] += 1
    197                   #LT = C._linterm[cndx]
    198                   #print "HERE",LT.keys()
    199                   #for i in LT:
    200                            #print "HERE",i,type(LT[i]),LT[i],type(LT[i][1]),LT[i][1]
    201                            #if i != '0':
    202                               #ngc += 1
    203                               #cu[LT[i][1].id] += 1
     183                    cu[var_id[d.keys()[0]]] += 1
    204184        print >>OUTPUT, " " + str(ngc), str(ngo) + "\t# nonzeros in Jacobian, gradients"
    205185        #
     
    272252                                    self._get_bound(C[ndx].lower)-offset,\
    273253                                    self._get_bound(C[ndx].upper)-offset,
    274                 print >>OUTPUT, " # c"+ str(nc)+"  "+str(key) + "[" + str(ndx) + "]"
    275                 symbol_map["c" + str(nc)] = str(key) + "[" + str(ndx) + "]"
     254                print >>OUTPUT, " # c"+ str(nc)+"  "+C[ndx].label #str(key) + "[" + str(ndx) + "]"
     255                symbol_map["c" + str(nc)] = C[ndx].label #str(key) + "[" + str(ndx) + "]"
    276256                nc += 1
    277257        #
     
    279259        #
    280260        print >>OUTPUT, "b"
    281         nv=0
    282         for i in xrange(len(Vlist)):
    283                 vi = Vlist[i]
    284                 var = vi[0]
    285                 ndx = vi[1]
    286                 if isinstance(var.domain, BooleanSet):
    287                         print >>OUTPUT, "0 0 1",
    288                         print >>OUTPUT, " # v"+str(nv)+"  "+str(var)+"["+str(ndx)+"]"
    289                         nv += 1
    290                         continue
    291                 vv = var._varval[ndx]
    292                 L = vv.lb
    293                 U = vv.ub
    294                 if L is not None:
    295                   Lv = str(value(L))
    296                   if U is not None:
    297                            Uv = str(value(U))
    298                            if Lv == Uv:
    299                                     print >>OUTPUT, "4" , Lv,
    300                            else:
    301                                     print >>OUTPUT, "0", Lv, Uv,
    302                   else:
    303                            print >>OUTPUT, "2", Lv,
    304                 elif U is not None:
    305                   print >>OUTPUT, "1", str(value(U)),
    306                 else:
    307                   print >>OUTPUT, "3",
    308                 if ndx is not None:
    309                    print >>OUTPUT, " # v"+str(nv)+"  "+str(var)+"["+str(ndx)+"]"
    310                    symbol_map["v"+str(nv)] = (str(var)+"["+str(ndx)+"]")                   
    311                 else:
    312                    print >>OUTPUT, " # v"+str(nv)+"  "+str(var)
    313                    symbol_map["v"+str(nv)] = str(var)
    314 
    315                 nv += 1
     261        for ndx in Vlist:
     262            vv = Var[ndx]
     263            #vi = Vlist[i]
     264            var = vv.var
     265            #ndx = vi[1]
     266            if isinstance(var.domain, BooleanSet):
     267                print >>OUTPUT, "0 0 1",
     268                print >>OUTPUT, " # v"+str(var_id[ndx])+"  "+vv.label
     269                symbol_map["v"+str(var_id[ndx])] = vv.label
     270                continue
     271            L = vv.lb
     272            U = vv.ub
     273            if L is not None:
     274                Lv = str(value(L))
     275                if U is not None:
     276                    Uv = str(value(U))
     277                    if Lv == Uv:
     278                        print >>OUTPUT, "4" , Lv,
     279                    else:
     280                        print >>OUTPUT, "0", Lv, Uv,
     281                else:
     282                    print >>OUTPUT, "2", Lv,
     283            elif U is not None:
     284                print >>OUTPUT, "1", str(value(U)),
     285            else:
     286                print >>OUTPUT, "3",
     287            print >>OUTPUT, " # v"+str(var_id[ndx])+"  "+vv.label
     288            symbol_map["v"+str(var_id[ndx])] = vv.label
    316289        #
    317290        # "k" lines
    318291        #
    319         n1 = model.statistics.number_of_variables - 1
     292        n1 = len(Var) - 1
    320293        print >>OUTPUT, "k" + str(n1)
    321294        ktot = 0
     
    335308                    continue
    336309                linear = con[ndx].repn.get(1,{})
    337                 for id in linear:
    338                     print >>OUTPUT, id, linear[id]
    339                 #LT = C._linterm[cndx]
    340                 #LT_len = len(LT) - ('0' in LT)
    341                 #print >>OUTPUT, "J" + str(nc), LT_len
    342                 #nc += 1
    343                 #for x in LT:
    344                     #if x != '0':
    345                         #p = LT[x]
    346                         #print >>OUTPUT, p[1].id, p[0]
     310                print >>OUTPUT, "J" + str(nc), len(linear)
     311                nc += 1
     312
     313                for d in linear:
     314                    for id in d:
     315                        print >>OUTPUT, var_id[id], linear[d]
    347316        #
    348317        # "G" lines
     
    357326                print >>OUTPUT, "G" + str(no), len(linear)
    358327                no += 1
    359                 for id in linear:
    360                     print >>OUTPUT, id, linear[id]
    361                 #for j in OLT:
    362                     #LT = OLT[j]
    363                     #for x in LT:
    364                         #if x != '0':
    365                             #p = LT[x]
    366                             #print >>OUTPUT, p[1].id, p[0]
     328                for d in linear:
     329                    for id in d:
     330                        print >>OUTPUT, var_id[id], linear[d]
    367331
    368332        return symbol_map
  • coopr.pyomo/stable/2.2/coopr/pyomo/io/cpxlp.py

    r2194 r2230  
    8989        return a[0]
    9090
    91     def _print_expr(self, model, x, OUTPUT, print_offset=False):
     91    def _print_expr(self, x, OUTPUT, print_offset=False):
    9292        max_terms_on_line=5 # this is the line-limit hack
    9393        terms_output = 0
     
    100100            for id in keys:
    101101                coef = x[1][id]
    102                 name = convert_name(model._var[id.keys()[0]].name)
     102                prefix = ""
     103                if self._output_prefixes is True:
     104                   parent_var = x[-1][id.keys()[0]].var
     105                   prefix = convert_name(parent_var.model.name) + "_"
     106                name = prefix + convert_name(x[-1][id.keys()[0]].label)
    103107                print >>OUTPUT, ('- %f' % math.fabs(coef) if coef < 0.0 else '+ %f' % coef), name,
    104108                terms_output += 1
     
    117121                print >>OUTPUT, ('- %f' % math.fabs(coef) if coef < 0.0 else '+ %f' % coef),
    118122                for var in id:
    119                     name = convert_name(model._var[var].name)
     123                    prefix = ""
     124                    if self._output_prefixes is True:
     125                       parent_var = x[-1][var].var
     126                       prefix = convert_name(parent_var.model.name) + "_"
     127                    name = prefix + convert_name(x[-1][var].label)
    120128                    if id[var] > 1:
    121129                        print "%s^%d" % (name,id[var]),
     
    141149        return offset
    142150
     151    def _print_quadterm(self, x, is_minimizing, OUTPUT):
     152        # the LP format doesn't allow for expression of constant terms in the objective.
     153        # a work-around involves tracking the sum of constant terms in the quadratic
     154        # quadratic terms, and then writing that out with a dummy variable forced equal
     155        # to one.
     156        print >>OUTPUT, ""
     157        for arg in x._args:
     158            if isinstance(arg,expr._ProductExpression):
     159                # NOTE: we need to handle quadratics defined with the 'pow' term here.
     160                # WARNING: The following code is very specific to progressive hedging, with
     161                #          a very specific format assumed. we do need to handle more general
     162                #          expressions, but we'll worry about that at a latter time.
     163                blend = arg._numerator[0]()
     164
     165                if blend is 1:
     166
     167                   rho = arg._numerator[1]()
     168
     169                   pow_expression = arg._numerator[2]
     170               
     171                   base = pow_expression._args[0]
     172                   exponent = pow_expression._args[1]
     173
     174                   if not isinstance(base,expr._SumExpression):
     175                       raise ValueError, "Quadratic term base must be a _SumExpression"
     176                   if not isinstance(exponent,numvalue.NumericConstant):
     177                       raise ValueError, "Quadratic term exponent must be a NumericConstant"
     178                   variable = base._args[0]
     179                   offset = base._args[1]
     180                   if variable.status is not VarStatus.unused:
     181
     182                      if is_minimizing is True:
     183                         print >>OUTPUT, " + [" + str(rho) + " " + convert_name(variable.label) + "^2]/2",
     184                      else:
     185                         print >>OUTPUT, " - [" + str(rho) + " " + convert_name(variable.label) + "^2]/2",
     186
     187                      if (is_minimizing is True):
     188                         if offset.value < 0.0:
     189                            print >>OUTPUT, " + " + str(abs(rho*offset.value)) + " " + convert_name(variable.label),                   
     190                         else:
     191                            print >>OUTPUT, " - " + str(rho*offset.value) + " " + convert_name(variable.label),
     192                      else:
     193                         if offset.value < 0.0:
     194                            print >>OUTPUT, " - " + str(abs(rho*offset.value)) + " " + convert_name(variable.label),                   
     195                         else:
     196                            print >>OUTPUT, " + " + str(rho*offset.value) + " " + convert_name(variable.label),
     197
     198                      objective_offset = (rho * offset.value * offset.value / 2.0)
     199                      if is_minimizing is True:
     200                         print >>OUTPUT, " + " + str(objective_offset) + " ONE_VAR_CONSTANT"
     201                      else:
     202                         print >>OUTPUT, " - " + str(objective_offset) + " ONE_VAR_CONSTANT"
     203                     
     204            elif isinstance(arg,numvalue.NumericConstant):
     205                # this is the "0.0" element that forms the initial expression - the
     206                # quadratic sub-expressions aren't known to the presolve routines.
     207                # ideally unnecessary - hacked in for now.
     208                pass
     209
     210            else:
     211                print `arg`
     212                raise ValueError, "Unknown expression sub-type found in quadratic objective expression"   
     213   
     214
    143215    def _print_model_LP(self, model, OUTPUT):
    144216
     
    149221        #
    150222        if self._output_objectives is True:
    151            #printed_quadterm = False
     223           printed_quadterm = False
    152224           if len(_obj) == 0:
    153225              raise ValueError, "ERROR: No objectives defined for input model=" + str(model.name) + "; cannot write legal LP file"
     
    164236                if is_nonlinear(obj[key].repn) and not is_quadratic(obj[key].repn):
    165237                    raise ValueError, "Cannot write legal LP file.  Objective %s[%s] has nonlinear terms that are not quadratic." % (str(obj),str(key))
    166                 self._print_expr(model, obj[key].repn, OUTPUT, print_offset=True)
     238                self._print_expr(obj[key].repn, OUTPUT, print_offset=True)
     239           if obj._quad_subexpr is not None:
     240               self._print_quadterm(obj._quad_subexpr, (_obj[ _obj.keys()[0] ].sense == minimize), OUTPUT)
     241               printed_quadterm = True               
    167242           print >>OUTPUT, ""
    168243       
     
    200275                    # constant, in which case the "variable" of
    201276                    if is_constant(C[cndx].repn):
    202                         print "WARNING: ignoring constraint %s[%s] which is constant" % (str(C),str(cndx))
     277                        # this happens *all* the time in many applications, including PH - so suppress the warning.
     278                        #print "WARNING: ignoring constraint %s[%s] which is constant" % (str(C),str(cndx))
    203279                        continue
    204280                    if is_nonlinear(C[cndx].repn):
     
    215291                         #
    216292                         print >>OUTPUT, prefix + "c_e_" + convert_name(C._data[cndx].label) + "_: ",
    217                          offset = self._print_expr(model, C[cndx].repn, OUTPUT)
     293                         offset = self._print_expr(C[cndx].repn, OUTPUT)
    218294                         print >>OUTPUT, "=",
    219295                         self._print_bound(C._data[cndx].lower, OUTPUT, -offset)
     
    226302                         if C._data[cndx].lower is not None:
    227303                            print >>OUTPUT, prefix + "c_l_" + convert_name(C._data[cndx].label) + "_: ",
    228                             offset = self._print_expr(model, C[cndx].repn, OUTPUT)
     304                            offset = self._print_expr(C[cndx].repn, OUTPUT)
    229305                            print >>OUTPUT, ">=",
    230306                            self._print_bound(C._data[cndx].lower, OUTPUT, -offset)
     
    233309                         if C._data[cndx].upper is not None:
    234310                            print >>OUTPUT, prefix + "c_u_" + convert_name(C._data[cndx].label) + "_: ",
    235                             offset = self._print_expr(model, C[cndx].repn, OUTPUT)
     311                            offset = self._print_expr(C[cndx].repn, OUTPUT)
    236312                            print >>OUTPUT, "<=",
    237313                            self._print_bound(C._data[cndx].upper, OUTPUT, -offset)
  • coopr.pyomo/stable/2.2/coopr/pyomo/presolve/compute_canonical_repn.py

    r2208 r2230  
    5353                    raise ValueError, "No expression has been defined for objective %s" % str(key)
    5454                try:
    55                     obj._data[ondx].repn = coopr.pyomo.expr.generate_canonical_repn(obj._data[ondx].expr, model)
     55                    obj._data[ondx].repn = coopr.pyomo.expr.generate_canonical_repn(obj._data[ondx].expr)
    5656                except Exception, e:
    5757                    print "Error generating a canonical representation for objective %s (index %s)" % (str(key), str(ondx))
     
    7575                    raise ValueError, "No expression has been defined for the body of constraint %s" % str(key)
    7676                try:                 
    77                     con._data[cndx].repn = coopr.pyomo.expr.generate_canonical_repn(con._data[cndx].body, model)
     77                    con._data[cndx].repn = coopr.pyomo.expr.generate_canonical_repn(con._data[cndx].body)
    7878                except Exception, e:
    7979                    print "Error generating a canonical representation for constraint %s (index %s)" % (str(key), str(cndx))
  • coopr.pyomo/stable/2.2/coopr/pyomo/scripting/util.py

    r2194 r2230  
    162162    # Create Problem Instance
    163163    #
    164     if len(args) == 2:
     164    if len(args) > 2:
     165        #
     166        # Load a list of *.dat files
     167        #
     168        modeldata = ModelData()
     169        for file in args[1:]:
     170            suffix = (file).split(".")[-1]
     171            if suffix != "dat":
     172                raise SystemExit, "When specifying multiple data files, they must all be *.dat files: "+str(file)
     173            modeldata.add_data_file(file)
     174        modeldata.read(model)
     175        instance = model.create(modeldata)
     176         
     177    elif len(args) == 2:
     178       #
     179       # Load a *.dat file or process a *.py data file
     180       #
    165181       suffix = (args[1]).split(".")[-1]
    166182       if suffix == "dat":
     
    208224    # Create Solver and Perform Optimization
    209225    #
    210     opt = SolverFactory( options.solver )
     226    solver = options.solver
     227    subsolver=None
     228    if not solver is None and ':' in solver:
     229        solver, subsolver = solver.split(':')
     230    opt = SolverFactory( solver )
    211231    if opt is None:
    212        raise ValueError, "Problem constructing solver `"+str(options.solver)+"'"
     232       raise ValueError, "Problem constructing solver `"+str(solver)+"'"
    213233    opt.keepFiles=options.keepfiles or options.log
    214234    if options.timelimit == 0:
     
    216236    if options.solver_mipgap is not None:
    217237       opt.mipgap = options.solver_mipgap
     238    if not subsolver is None:
     239        subsolver=' solver='+subsolver
     240    else:
     241        subsolver=''
     242    opt.set_options(" ".join(options.solver_options)+subsolver)
     243    #
    218244    solver_mngr = SolverManagerFactory( options.smanager_type )
    219245    if solver_mngr is None:
    220246       raise ValueError, "Problem constructing solver manager `"+str(options.smanager_type)+"'"
    221     results = solver_mngr.solve(instance, opt=opt, tee=options.tee, timelimit=options.timelimit, options=" ".join(options.solver_options))
     247    results = solver_mngr.solve(instance, opt=opt, tee=options.tee, timelimit=options.timelimit)
    222248    if results == None:
    223249            raise ValueError, "opt.solve returned None"
  • coopr.pyomo/stable/2.2/coopr/pyomo/tests/examples/test10.txt

    r2194 r2230  
     1Importing data...
     2Processing data ...
     3Done.
    14Constructing Param, name=N, from data={None: 5}
    25Constructing Param, name=P, from data={None: 3}
     
    4346Construcing constraint num_facilities
    4447   Constructing constraint index None
    45 Writing model unknown to file '/tmp/tmp1NxKh4.pyomo.lp'  with format cpxlp
     48Writing model unknown to file '/tmp/tmpb2g1nA.pyomo.lp'  with format cpxlp
    4649
    4750# ==========================================================
  • coopr.pyomo/stable/2.2/coopr/pyomo/tests/expr/test_canonical.py

    r2208 r2230  
    6464        self.instance = self.model.create()
    6565        #self.instance.obj[None].expr.pprint()
    66         self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance), {1: {frozendict({2: 1}): 6.0, frozendict({1: 1}): 4.0, frozendict({3: 1}): 8.0, frozendict({0: 1}): 2.0}})
     66        mid=id(self.instance)
     67        rep = generate_canonical_repn(self.instance.obj[None].expr)
     68        del rep[-1]
     69        self.failUnlessEqual(rep, {1: {frozendict({(mid,2): 1}): 6.0, frozendict({(mid,1): 1}): 4.0, frozendict({(mid,3): 1}): 8.0, frozendict({(mid,0): 1}): 2.0}})
    6770
    6871    def test_expr2(self):
     
    7679        self.model.obj = Objective(rule=obj_rule)
    7780        self.instance = self.model.create()
    78         #self.instance.obj[None].expr.pprint()
    79         self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance), {1: {frozendict({2: 1}): 6.0, frozendict({1: 1}): 4.0, frozendict({3: 1}): 8.0, frozendict({0: 1}): 2.0}})
     81        mid=id(self.instance)
     82        #self.instance.obj[None].expr.pprint()
     83        rep = generate_canonical_repn(self.instance.obj[None].expr)
     84        del rep[-1]
     85        self.failUnlessEqual(rep, {1: {frozendict({(mid,2): 1}): 6.0, frozendict({(mid,1): 1}): 4.0, frozendict({(mid,3): 1}): 8.0, frozendict({(mid,0): 1}): 2.0}})
    8086
    8187    def test_expr3(self):
     
    8995        self.model.obj = Objective(rule=obj_rule)
    9096        self.instance = self.model.create()
    91         #self.instance.obj[None].expr.pprint()
    92         self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance),
    93                     {1: {frozendict({0: 1}):9.0, frozendict({1: 1}):4.0}})
     97        mid=id(self.instance)
     98        #self.instance.obj[None].expr.pprint()
     99        rep = generate_canonical_repn(self.instance.obj[None].expr)
     100        del rep[-1]
     101        self.failUnlessEqual(rep,
     102                    {1: {frozendict({(mid,0): 1}):9.0, frozendict({(mid,1): 1}):4.0}})
    94103
    95104    def test_expr4(self):
     
    103112        self.model.obj = Objective(rule=obj_rule)
    104113        self.instance = self.model.create()
    105         #self.instance.obj[None].expr.pprint()
    106         self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance), {0:frozendict({None:1.2}), 1: {frozendict({0: 1}): 5.0}})
     114        mid=id(self.instance)
     115        #self.instance.obj[None].expr.pprint()
     116        rep = generate_canonical_repn(self.instance.obj[None].expr)
     117        del rep[-1]
     118        self.failUnlessEqual(rep, {0:frozendict({None:1.2}), 1: {frozendict({(mid,0): 1}): 5.0}})
    107119
    108120    def test_expr5(self):
     
    116128        self.model.obj = Objective(rule=obj_rule)
    117129        self.instance = self.model.create()
    118         #self.instance.obj[None].expr.pprint()
    119         self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance),
    120                 {2: {frozendict({0:2}):1.0, frozendict({0:1, 1:1}):2.0}, 3:{frozendict({1:1,2:2}):3.0}})
     130        mid=id(self.instance)
     131        #self.instance.obj[None].expr.pprint()
     132        rep = generate_canonical_repn(self.instance.obj[None].expr)
     133        del rep[-1]
     134        self.failUnlessEqual(rep,
     135                {2: {frozendict({(mid,0):2}):1.0, frozendict({(mid,0):1, (mid,1):1}):2.0}, 3:{frozendict({(mid,1):1, (mid,2):2}):3.0}})
    121136
    122137    def test_expr6(self):
     
    130145        self.model.obj = Objective(rule=obj_rule)
    131146        self.instance = self.model.create()
    132         #self.instance.obj[None].expr.pprint()
    133         self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance),
    134             {0:frozendict({None:5.4}), 1: {frozendict({0: 1}): 13.0}})
     147        mid=id(self.instance)
     148        #self.instance.obj[None].expr.pprint()
     149        rep = generate_canonical_repn(self.instance.obj[None].expr)
     150        del rep[-1]
     151        self.failUnlessEqual(rep,
     152            {0:frozendict({None:5.4}), 1: {frozendict({(mid,0): 1}): 13.0}})
    135153
    136154    def test_expr7(self):
     
    144162        self.model.obj = Objective(rule=obj_rule)
    145163        self.instance = self.model.create()
    146         #self.instance.obj[None].expr.pprint()
    147         self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance),
    148             {1: {frozendict({2: 1}): 3.0, frozendict({1: 1}): 2.0, frozendict({3: 1}): 4.0, frozendict({0: 1}): 1.0}})
     164        mid=id(self.instance)
     165        #self.instance.obj[None].expr.pprint()
     166        rep = generate_canonical_repn(self.instance.obj[None].expr)
     167        del rep[-1]
     168        self.failUnlessEqual(rep,
     169            {1: {frozendict({(mid,2): 1}): 3.0, frozendict({(mid,1): 1}): 2.0, frozendict({(mid,3): 1}): 4.0, frozendict({(mid,0): 1}): 1.0}})
    149170
    150171    def test_expr8(self):
     
    161182        self.instance.y.fixed = True
    162183        self.instance.y.reset()
    163         #self.instance.obj[None].expr.pprint()
    164         self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance),
    165             {1: {frozendict({2: 1}): 3.0, frozendict({1: 1}): 2.0, frozendict({3: 1}): 4.0, frozendict({0: 1}): 1.0}})
     184        mid=id(self.instance)
     185        #self.instance.obj[None].expr.pprint()
     186        rep = generate_canonical_repn(self.instance.obj[None].expr)
     187        del rep[-1]
     188        self.failUnlessEqual(rep,
     189            {1: {frozendict({(mid,2): 1}): 3.0, frozendict({(mid,1): 1}): 2.0, frozendict({(mid,3): 1}): 4.0, frozendict({(mid,0): 1}): 1.0}})
    166190
    167191    def test_expr9(self):
     
    178202        self.instance.y.fixed = True
    179203        self.instance.y.reset()
    180         #self.instance.obj[None].expr.pprint()
    181         self.failUnlessEqual(generate_canonical_repn(self.instance.obj[None].expr, self.instance),
    182             {1: {frozendict({2: 1}): 3.0, frozendict({1: 1}): 2.0, frozendict({3: 1}): 4.0, frozendict({0: 1}): 1.0}})
     204        mid=id(self.instance)
     205        #self.instance.obj[None].expr.pprint()
     206        rep = generate_canonical_repn(self.instance.obj[None].expr)
     207        del rep[-1]
     208        self.failUnlessEqual(rep,
     209            {1: {frozendict({(mid,2): 1}): 3.0, frozendict({(mid,1): 1}): 2.0, frozendict({(mid,3): 1}): 4.0, frozendict({(mid,0): 1}): 1.0}})
    183210
    184211    def test_expr10(self):
     
    194221        self.instance = self.model.create()
    195222        #self.instance.obj[None].expr.pprint()
    196         rep = generate_canonical_repn(self.instance.obj[None].expr, self.instance)
     223        rep = generate_canonical_repn(self.instance.obj[None].expr)
    197224        self.failUnless(len(rep) == 1 and None in rep)
    198225
     
    209236        self.instance = self.model.create()
    210237        #self.instance.obj[None].expr.pprint()
    211         rep = generate_canonical_repn(self.instance.obj[None].expr, self.instance)
     238        rep = generate_canonical_repn(self.instance.obj[None].expr)
    212239        rep[None].pprint()
    213240        del rep[None]
    214         self.failUnlessEqual(rep, {0: {None: 3.0}, 1: {frozendict({1: 1}): 1.0, frozendict({0: 1}): 1.0}})
     241        del rep[-1]
     242        mid=id(self.instance)
     243        self.failUnlessEqual(rep, {0: {None: 3.0}, 1: {frozendict({(mid,1): 1}): 1.0, frozendict({(mid,0): 1}): 1.0}})
    215244
    216245    def test_expr12(self):
     
    225254        self.model.obj = Objective(rule=obj_rule)
    226255        self.instance = self.model.create()
    227         #self.instance.obj[None].expr.pprint()
    228         rep = generate_canonical_repn(self.instance.obj[None].expr, self.instance)
     256        mid=id(self.instance)
     257        #self.instance.obj[None].expr.pprint()
     258        rep = generate_canonical_repn(self.instance.obj[None].expr)
    229259        rep[None].pprint()
    230260        del rep[None]
    231         self.failUnlessEqual(rep, {0: {None: 2.0}, 1: {frozendict({1: 1}): 1.0, frozendict({0: 1}): 2.0}, 2: {frozendict({0: 1, 1: 1}): 1.0}})
     261        del rep[-1]
     262        self.failUnlessEqual(rep, {0: {None: 2.0}, 1: {frozendict({(mid,1): 1}): 1.0, frozendict({(mid,0): 1}): 2.0}, 2: {frozendict({(mid,0): 1, (mid,1): 1}): 1.0}})
    232263
    233264if __name__ == "__main__":
  • coopr.pyomo/stable/2.2/coopr/pyomo/tests/unit/test_modeldata.py

    r1448 r2230  
    172172    def test_md1(self):
    173173        md = ModelData()
    174         md.add_table(example_dir+"A.tab")
     174        md.add(example_dir+"A.tab")
    175175        try:
    176176            md.read()
     
    188188    def test_md2(self):
    189189        md = ModelData()
    190         md.add_data_file(currdir+"data1.dat")
     190        md.add(currdir+"data1.dat")
    191191        model=Model()
    192192        model.A=Set()
     
    195195    def test_md3(self):
    196196        md = ModelData()
    197         md.add_data_file(currdir+"data2.dat")
     197        md.add(currdir+"data2.dat")
    198198        model=Model()
    199199        model.A=Set()
     
    206206    def test_md4(self):
    207207        md = ModelData()
    208         md.add_data_file(currdir+"data3.dat")
     208        md.add(currdir+"data3.dat")
    209209        model=Model()
    210210        model.A=Set()
     
    215215    def test_md5(self):
    216216        md = ModelData()
    217         md.add_data_file(currdir+"data4.dat")
     217        md.add(currdir+"data4.dat")
    218218        model=Model()
    219219        model.A=Set()
     
    225225    def test_md6(self):
    226226        md = ModelData()
    227         md.add_data_file(currdir+"data5.dat")
     227        md.add(currdir+"data5.dat")
    228228        model=Model()
    229229        model.A=Set()
     
    235235    def test_md7(self):
    236236        md = ModelData()
    237         md.add_table(currdir+"data1.tab")
     237        md.add(currdir+"data1.tab")
    238238        model=Model()
    239239        try:
     
    245245    def test_md8(self):
    246246        md = ModelData()
    247         md.add_data_file(currdir+"data6.dat")
     247        md.add(currdir+"data6.dat")
    248248        model=Model()
    249249        model.A=Set()
     
    256256    def test_md9(self):
    257257        md = ModelData()
    258         md.add_data_file(currdir+"data7.dat")
     258        md.add(currdir+"data7.dat")
    259259        model=Model()
    260260        model.A=Set()
     
    264264    def test_md10(self):
    265265        md = ModelData()
    266         md.add_data_file(currdir+"data8.dat")
     266        md.add(currdir+"data8.dat")
    267267        model=Model()
    268268        model.A=Param(within=Boolean)
  • coopr.pyomo/stable/2.2/examples/pyomo/tutorials/table.py

    r909 r2230  
    108108#model.pprint()
    109109
    110 data = ModelData(model)
    111 data.add_table("tab/A.tab")
    112 data.add_table("tab/B.tab")
    113 data.add_table("tab/C.tab", set="C")
    114 data.add_table("tab/D.tab", set="D", format="array")
    115 data.add_table("tab/E.tab", set="E")
    116 data.add_table("tab/I.tab")
    117 data.add_table("tab/Z.tab", param="Z")
    118 data.add_table("tab/Y.tab")
    119 data.add_table("tab/XW.tab")
    120 data.add_table("tab/T.tab", param="T", format="transposed_array")
    121 data.add_table("tab/U.tab", param="U", format="array")
    122 data.add_table("tab/S.tab")
    123 data.add_table("tab/RQ.tab", index="H")
    124 data.add_table("tab/PO.tab", index="J", param=("P","O"))
    125 data.add_table("tab/PP.tab", param="PP")
     110data = ModelData(model=model)
     111data.add("tab/A.tab")
     112data.add("tab/B.tab")
     113data.add("tab/C.tab", set="C")
     114data.add("tab/D.tab", set="D", format="set_array")
     115data.add("tab/E.tab", set="E")
     116data.add("tab/I.tab")
     117data.add("tab/Z.tab", param="Z")
     118data.add("tab/Y.tab")
     119data.add("tab/XW.tab")
     120data.add("tab/T.tab", param="T", format="transposed_array")
     121data.add("tab/U.tab", param="U", format="array")
     122data.add("tab/S.tab")
     123data.add("tab/RQ.tab", index="H")
     124data.add("tab/PO.tab", index="J", param=("P","O"))
     125data.add("tab/PP.tab", param="PP")
    126126data.read()
    127127
Note: See TracChangeset for help on using the changeset viewer.