Changeset 1967


Ignore:
Timestamp:
Dec 6, 2009 5:00:00 PM (11 years ago)
Author:
wehart
Message:

Creating the ComponentBase? class, which manages the initialization of
components. This consolidates the mechanism needed to generalize
the component indexing operations.

Location:
coopr.pyomo/trunk/coopr/pyomo
Files:
1 added
10 edited

Legend:

Unmodified
Added
Removed
  • coopr.pyomo/trunk/coopr/pyomo/base/PyomoModel.py

    r1966 r1967  
    8282    def _add_temporary_set(self,val):
    8383        if val._index_set is not None:
    84            ##print "HERE Y1"
    85            val._index = self._construct_temporary_set(val._index_set,val.name+"_index")
     84            ctr=0
     85            for tset in val._index_set:
     86                if tset.name == "_unknown_":
     87                    self._construct_temporary_set(tset,val.name+"_index_"+str(ctr))
     88                ctr+=1
     89            val._index = self._construct_temporary_set(val._index_set,val.name+"_index")
    8690        if isinstance(val._index,_SetContainer) and \
    87            val._index.name == "_unknown_":
    88            ##print "HERE Y2"
    89            self._construct_temporary_set(val._index,val.name+"_index")
     91            val._index.name == "_unknown_":
     92            self._construct_temporary_set(val._index,val.name+"_index")
    9093        if val.domain is not None and val.domain.name == "_unknown_":
    91            ##print "HERE Y3"
    92            self._construct_temporary_set(val.domain,val.name+"_domain")
     94            self._construct_temporary_set(val.domain,val.name+"_domain")
    9395
    9496
  • coopr.pyomo/trunk/coopr/pyomo/base/constraint.py

    r1959 r1967  
    1616import pyomo
    1717from var import Var, _VarValue
    18 from sets import Set, _BaseSet
     18from component import ComponentBase
     19from sets import _BaseSet
    1920import pyutilib.misc
    2021import pyutilib.math
     
    3839
    3940
    40 class Objective(NumericValue):
     41class Objective(NumericValue, ComponentBase):
    4142    """An object that defines a objective expression"""
    4243
     
    4546           expression
    4647        """
     48        ComponentBase.__init__(self, *args)
    4749        tmpname="unknown"
    4850        tmpsense = minimize
    4951        tmprule = None
    50         self._index_set=None
    5152        self._data = {}
    5253        if args == ():
    53            self._index=[None]
    5454           self._data[None] = ObjectiveData()
    55            self._ndim=0
    56         else:
    57            self._ndim=0
    58            for arg in args:
    59              self._ndim += arg.dimen
    60            if len(args) == 1:
    61               self._index=args[0]
    62            else:
    63               self._index=None
    64               self._index_set=args
    6555        self._quad_subexpr = None # this is a hack for now; we eventually want a "QuadraticObjective" class.       
    6656        for key in kwd.keys():
     
    122112
    123113    def _construct(self, model, data):
     114        #
     115        # Update the index set dimension
     116        #
     117        self._compute_dim()
    124118        ##print "HERE",self.rule,self._ndim
    125119        if self.rule is not None:
     
    195189
    196190
    197 class Constraint(NumericValue):
     191class Constraint(NumericValue, ComponentBase):
    198192    """An object that defines a objective expression"""
    199193
     
    202196           expression
    203197        """
     198        ComponentBase.__init__(self, *args)
    204199        tmpname="unknown"
    205200        tmprule=None
    206         self._index_set=None
    207201        self._data = {}
    208202        if args == ():
    209            self._index=[None]
    210203           self._data[None]=ConstraintData()
    211            self._ndim=0
    212         else:
    213            self._ndim=0
    214            for arg in args:
    215              self._ndim += arg.dimen
    216            if len(args) == 1:
    217               self._index=args[0]
    218            else:
    219               self._index=None
    220               self._index_set=args
    221204        for key in kwd.keys():
    222205          if key == "name":
     
    268251    def _construct(self, model, data):
    269252        self._model = model
    270        
     253        #
     254        # Update the index set dimension
     255        #
     256        self._compute_dim()
     257
    271258        if pyomo.debug("verbose") or pyomo.debug("normal"):     #pragma:nocover
    272259           print "Construcing constraint "+self.name
  • coopr.pyomo/trunk/coopr/pyomo/base/param.py

    r1768 r1967  
    1717import sys
    1818import types
    19 from sets import _BaseSet
     19from component import ComponentBase
    2020
    2121
     
    3737
    3838
    39 class _ParamBase(object):
     39class _ParamBase(ComponentBase):
    4040    """A parameter value, which may be defined over a index"""
    4141
     
    5555                          existing model data
    5656    """
    57     def __init__(self, **kwd):
     57    def __init__(self, *args, **kwd):
     58        ComponentBase.__init__(self, *args)
    5859        tmpname="unknown"
    5960        tmpdomain=Any
    60         self._ndim=0
    6161        self._paramval={}
    6262        self._initialize={}
     
    8080        self.domain = tmpdomain
    8181        self._default = _ParamValue(name=tmpname,domain=tmpdomain,value=value(defaultval))
    82         self._index_set=None
    8382
    8483    def pprint(self, ostream=None):
     
    161160        if pyomo.debug("verbose"):      #pragma:nocover
    162161           print "Constructing Param, name="+self.name+", from data="+`data`
     162        #
     163        # Update the index set dimension
     164        #
     165        self._compute_dim()
    163166        #
    164167        # Code optimization with local variables
     
    278281    def __init__(self, *args, **kwd):
    279282        _ParamValue.__init__(self, **kwd)
    280         _ParamBase.__init__(self, **kwd)
    281         self._index=[None]
     283        _ParamBase.__init__(self, *args, **kwd)
    282284        self._paramval[None] = self
    283285
     
    298300        return self._paramval[None].value
    299301
     302
    300303class _ParamArray(_ParamBase):
    301304
    302305    def __init__(self, *args, **kwd):
    303         _ParamBase.__init__(self, **kwd)
    304         for arg in args:
    305             if not isinstance(arg,_BaseSet):
    306                 raise ValueError, "Cannot index parameter `"+self.name+"' with object of type "+str(type(arg))
    307             self._ndim += arg.dimen
    308         if len(args) == 1:
    309             self._index=args[0]
    310         else:
    311             self._index=None
    312             self._index_set=args
     306        _ParamBase.__init__(self, *args, **kwd)
    313307
    314308    def simplify(self, model):
  • coopr.pyomo/trunk/coopr/pyomo/base/sets.py

    r1963 r1967  
    802802        ans=0
    803803        for set in self.set_tuple:
    804           if set.dimen == 1:
    805              ans += 1
    806           else:
    807              ans += set.dimen
    808         self.dimen= ans
     804            if set.dimen is None:
     805                self.dimen=None
     806                return
     807            else:
     808                ans += set.dimen
     809        self.dimen = ans
    809810
    810811    def _verify(self,element,use_exception=True):
     
    813814        to ensure that the element is in each of the underlying sets.
    814815        """
    815         #print "HERE y",element
    816816        tmp = _SetContainer._verify(self,element,use_exception)
    817         #print "HERE z",element, tmp, self.virtual
    818817        if not tmp or not self.virtual:
    819            #print "HERE z1",element, tmp, self.virtual
    820            return tmp
     818            return tmp
    821819
    822820        next_tuple_index = 0
     
    834832    def _construct(self, model=None, values=None):
    835833        """ Apply the rule to construct values in this set """
    836         #print "HERE PS construct"
    837834        log.debug("Constructing _ProductSet, name="+self.name+", from data="+repr(values))
    838835        if self.virtual:
     
    843840              for val in self.set_tuple:
    844841                self._len *= len(val)
    845            return
    846842        #
    847843        # Construct using the values list
    848844        #
    849         if values is not None:
     845        elif values is not None:
    850846           for val in values[None]:
    851847             self.add(val)
    852848        #
     849        # Construct using the rule
     850        #
     851        elif type(self.initialize) is types.FunctionType:
     852           for val in self.initialize(model):
     853             self.add(val)
     854        #
    853855        # Construct using the default values
    854856        #
    855         elif type(self.initialize) is not types.FunctionType:
     857        else:
    856858           if self.initialize is not None:
    857859              if type(self.initialize) is dict:
     
    864866                self.add(val)
    865867        #
    866         # Construct using the rule
    867         #
    868         else:
    869            tmp = self.initialize(model)
    870            for val in tmp:
    871              self.add(val)
    872         self._len=len(self.value)
     868        if not self.virtual:
     869            self._len=len(self.value)
     870        self._compute_dimen()
     871        if self.dimen is None:
     872            raise ValueError, "The product set dimension must be computeable after constructing this set!"
    873873
    874874
  • coopr.pyomo/trunk/coopr/pyomo/base/var.py

    r1959 r1967  
    1515import types
    1616from set_types import *
    17 from sets import _BaseSet
     17from component import ComponentBase
    1818import pyutilib.math
    1919import pyutilib.misc
     
    114114#
    115115
    116 class _VarBase(object):
     116class _VarBase(ComponentBase):
    117117    """A numeric variable, which may be defined over a index"""
    118118
     
    132132                          existing model data
    133133    """
    134     def __init__(self, **kwd):
     134    def __init__(self, *args, **kwd):
     135        ComponentBase.__init__(self,*args)
    135136        #
    136137        # Default keyword values
     
    139140        tmpname="unknown"
    140141        tmpdomain=Reals
    141         self._ndim=0
    142142        tmpbounds=None
    143143        self._varval={}
     
    157157        self.domain = tmpdomain
    158158        self.bounds=tmpbounds
    159         self._index_set=None
    160159        self._model=None
    161160
     
    211210        self._model = model
    212211        #
     212        # Update the index set dimension
     213        #
     214        self._compute_dim()
     215        #
    213216        # Construct _VarValue() objects for all index values
    214217        #
     
    220223                    self._varval[ndx] = _VarValue(name=self.name+"["+str(ndx)+"]",domain=self.domain)
    221224                    self._varval[ndx].var = self
    222                    
    223225        #
    224226        # Initialize values with a dictionary if provided
     
    374376    def __init__(self, *args, **kwd):
    375377        _VarValue.__init__(self, **kwd)
    376         _VarBase.__init__(self, **kwd)
    377         self._index=[None]
     378        _VarBase.__init__(self, *args, **kwd)
    378379        self._varval[None] = self
    379380        self._varval[None].var = self
     
    386387
    387388    def __init__(self, *args, **kwd):
    388         _VarBase.__init__(self, **kwd)
    389         for arg in args:
    390             if not isinstance(arg,_BaseSet):
    391                 raise ValueError, "Cannot index variable `"+self.name+"' with object of type "+str(type(arg))
    392             self._ndim += arg.dimen
    393         if len(args) == 1:
    394             self._index=args[0]
    395         else:
    396             self._index=None
    397             self._index_set=args
    398         #print "X",kwd
     389        _VarBase.__init__(self, *args, **kwd)
    399390        self._dummy_val = _VarValue(**kwd)
    400391
  • coopr.pyomo/trunk/coopr/pyomo/components/action.py

    r1338 r1967  
    1313from coopr.pyomo.base.numvalue import *
    1414from coopr.pyomo.base.plugin import ComponentRegistration
    15 from coopr.pyomo.base.sets import _BaseSet
     15from coopr.pyomo.base.component import ComponentBase
    1616import types
    1717from coopr.pyomo.base import pyomo
     
    2121
    2222
    23 class BuildAction(object):
     23class BuildAction(ComponentBase):
    2424    """A build action, which executes a rule for all valid indices"""
    2525
     
    3333    """
    3434    def __init__(self, *args, **kwd):
     35        ComponentBase.__init__(self, *args)
    3536        tmpname="unknown"
    3637        self.domain=None
     
    4445          else:
    4546             raise ValueError, "BuildAction constructor: unknown keyword - "+key
    46         self._index_set=None
    47         if args == ():
    48            self._index=[None]
    49            self._ndim=0
    50         else:
    51            self._ndim=0
    52            for arg in args:
    53              if not isinstance(arg,_BaseSet):
    54                 raise ValueError, "Cannot index parameter `"+self.name+"' with object of type "+str(type(arg))
    55              self._ndim += arg.dimen
    56            if len(args) == 1:
    57               self._index=args[0]
    58            else:
    59               self._index=None
    60               self._index_set=args
    6147        if not type(self._rule) is types.FunctionType:
    6248            raise ValueEror, "BuildAction must have an 'rule' option specified whose value is a function"
     
    7258        if pyomo.debug("verbose"):      #pragma:nocover
    7359           print "Constructing Param, name="+self._name+", from data="+`data`
     60        #
     61        # Update the index set dimension
     62        #
     63        self._compute_dim()
    7464        for val in self._index:
    7565              if isinstance(val,tuple):
  • coopr.pyomo/trunk/coopr/pyomo/components/check.py

    r1338 r1967  
    1313from coopr.pyomo.base.numvalue import *
    1414from coopr.pyomo.base.plugin import ComponentRegistration
    15 from coopr.pyomo.base.sets import _BaseSet
     15from coopr.pyomo.base.component import ComponentBase
    1616import types
    1717from coopr.pyomo.base import pyomo
    1818
    1919
    20 class BuildCheck(object):
     20class BuildCheck(ComponentBase):
    2121    """A build check, which executes a rule for all valid indices"""
    2222
     
    3030    """
    3131    def __init__(self, *args, **kwd):
     32        ComponentBase.__init__(self,*args)
    3233        tmpname="unknown"
    3334        self.domain=None
     
    4142          else:
    4243             raise ValueError, "BuildCheck constructor: unknown keyword - "+key
    43         self._index_set=None
    44         if args == ():
    45            self._index=[None]
    46            self._ndim=0
    47         else:
    48            self._ndim=0
    49            for arg in args:
    50              if not isinstance(arg,_BaseSet):
    51                 raise ValueError, "Cannot index parameter `"+self.name+"' with object of type "+str(type(arg))
    52              self._ndim += arg.dimen
    53            if len(args) == 1:
    54               self._index=args[0]
    55            else:
    56               self._index=None
    57               self._index_set=args
    5844        if not type(self._rule) is types.FunctionType:
    5945            raise ValueEror, "BuildCheck must have an 'rule' option specified whose value is a function"
     
    6955        if pyomo.debug("verbose"):      #pragma:nocover
    7056           print "Constructing Param, name="+self._name+", from data="+`data`
     57        #
     58        # Update the index set dimension
     59        #
     60        self._compute_dim()
    7161        for val in self._index:
    7262              if isinstance(val,tuple):
  • coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_model.py

    r1924 r1967  
    465465        self.failUnlessEqual( type(tmp), int)
    466466        self.failUnlessEqual( tmp, 3 )
     467
     468
     469class TestVarComplexArray(PyomoModel):
     470
     471    def test_index1(self):
     472        self.model.A = Set(initialize=range(0,4))
     473        def B_index(model):
     474            for i in model.A:
     475                if i%2 == 0:
     476                    yield i
     477        def B_init(i,j,model):
     478            if j:
     479                return 2+i
     480            return -(2+i)
     481        self.model.B = Var(B_index, [True,False], initialize=B_init)
     482        self.instance = self.model.create()
     483        #self.instance.pprint()
     484        self.failUnlessEqual(set(self.instance.B.keys()),set([(0,True),(2,True),(0,   False),(2,False)]))
     485        self.failUnlessEqual(self.instance.B[0,True],2)
     486        self.failUnlessEqual(self.instance.B[0,False],-2)
     487        self.failUnlessEqual(self.instance.B[2,True],4)
     488        self.failUnlessEqual(self.instance.B[2,False],-4)
    467489
    468490
  • coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_param.py

    r1768 r1967  
    355355
    356356
     357class ArrayParam6(PyomoModel):
     358
     359    def test_index1(self):
     360        self.model.A = Set(initialize=range(0,4))
     361        def B_index(model):
     362            for i in model.A:
     363                if i%2 == 0:
     364                    yield i
     365        def B_init(i,j,model):
     366            if j:
     367                return 2+i
     368            return -(2+i)
     369        self.model.B = Param(B_index, [True,False], initialize=B_init)
     370        self.instance = self.model.create()
     371        #self.instance.pprint()
     372        self.failUnlessEqual(set(self.instance.B.keys()),set([(0,True),(2,True),(0,   False),(2,False)]))
     373        self.failUnlessEqual(self.instance.B[0,True],2)
     374        self.failUnlessEqual(self.instance.B[0,False],-2)
     375        self.failUnlessEqual(self.instance.B[2,True],4)
     376        self.failUnlessEqual(self.instance.B[2,False],-4)
     377
     378
    357379class TestIO(PyomoModel):
    358380
  • coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_set.py

    r1964 r1967  
    13961396        self.failUnlessEqual(self.instance.B[2].data(),set([2,3]))
    13971397        self.failUnlessEqual(self.instance.B.keys(),[0,2])
     1398
     1399    def test_initialize6(self):
     1400        self.model.A = Set(initialize=range(0,4))
     1401        def B_index(model):
     1402            for i in model.A:
     1403                if i%2 == 0:
     1404                    yield i
     1405        def B_init(i,j,model):
     1406            if j:
     1407                return range(i,2+i)
     1408            return []
     1409        self.model.B = Set(B_index, [True,False], initialize=B_init)
     1410        self.instance = self.model.create()
     1411        #self.instance.pprint()
     1412        self.failUnlessEqual(set(self.instance.B.keys()),set([(0,True),(2,True),(0,False),(2,False)]))
     1413        self.failUnlessEqual(self.instance.B[0,True].data(),set([0,1]))
     1414        self.failUnlessEqual(self.instance.B[2,True].data(),set([2,3]))
    13981415
    13991416    def test_dimen(self):
Note: See TracChangeset for help on using the changeset viewer.