Changeset 2025


Ignore:
Timestamp:
Dec 22, 2009 1:23:57 AM (10 years ago)
Author:
wehart
Message:

Reworking how components interact with models. Now, components can
only be initialized using data from the model that they are associated with.
Thus, models and components are tightly coupled. This allows the following
syntax:

model.x = Param(model.A)
model.construct()

The construction process uses the model data that is associated with the
parameter. Also, this commmit allows models to be components of another
model:

m1=Model()
m2=Model()
m2.m1 = m1

Note, however, that model construct is required to be done separately. When
model m2 is constructed, the m1 component is not constructed.

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

Legend:

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

    r2021 r2025  
    3434
    3535
    36 class Model(object):
     36class Model(Component):
    3737    """
    3838    The MINLP model that will be analyzed by the user.
     
    4444    def __init__(self):
    4545        """Constructor"""
     46        Component.__init__(self, ctype=Model)
    4647        #
    4748        # Define component dictionary: component type -> instance
     
    194195        val.name=name
    195196        self._add_temporary_set(val)
    196         val.model=self
    197197        self._component[val.type()][name]=val
    198198        self._declarations.append(val)
    199199        self.__dict__[name]=val
     200        if not val.type() is Model:
     201            val.model=self
    200202
    201203    def __setattr__(self,name,val):
     
    208210            # If this is a component type, then simply set it
    209211            #
    210             if isinstance(val,Component) or isinstance(val,_BaseSet):
     212            if isinstance(val,Component):
    211213                self._setattr_exec(name,val)
    212214                return
    213 
    214         #if name in self.__dict__.keys() and isinstance(self.__dict__[name],NumericValue):
    215             #tmpval = value(val)
    216             #if tmpval is None:
    217                 #raise ValueError, "Bad numeric value"
    218             #self.__dict__[name].value = tmpval
    219         #else:
    220             #self.__dict__[name]=val
    221 
    222215        #
    223216        # Try to set the value.  This may fail if the attribute does not already
     
    226219        # we raise.  Otherwise, this is an object that we need to set directly.
    227220        #
    228         #print "HERE X",name
    229221        try:
    230             #print "HERE",self.__dict__[name].name,type(self.__dict__[name]),type(val)
    231222            self.__dict__[name].set_value(val)
    232223        except ValueError, e:
     
    322313        #print "HERE _load_model_data",self._declarations
    323314        for declaration in self._declarations:
    324           tmp = declaration.name
    325           if tmp in modeldata._default.keys():
    326              if isinstance(declaration,_BaseSet):
    327                 declaration.default = self._tuplize(modeldata._default[tmp],declaration)
    328              else:
    329                 declaration.default = modeldata._default[tmp]
    330           if tmp in modeldata._data.keys():
    331              #print "HERE", declaration.name, str(declaration.dimen),modeldata._data[tmp]
    332              if isinstance(declaration,_BaseSet):
    333                 data = self._tuplize(modeldata._data[tmp],declaration)
    334              else:
    335                 data = modeldata._data[tmp]
    336           else:
    337              data = None
    338           if pyomo.debug("generate"):           #pragma:nocover
    339              print "About to generate '"+declaration.name+"' with data: "+str(data)
    340              self.pprint()
    341           declaration._construct(self,data)
    342           try:
    343             ##declaration._construct(self,data)
    344             pass
    345           except Exception, err:
    346             print "Error constructing declaration "+str(declaration.name)+" from data="+str(data)
    347             print "ERROR: "+str(err)
    348             raise err
     315            if declaration.type() is Model:
     316                continue
     317            tmp = declaration.name
     318            if tmp in modeldata._default.keys():
     319                if declaration.type() is Set:
     320                    declaration.default = self._tuplize(modeldata._default[tmp],declaration)
     321                else:
     322                    declaration.default = modeldata._default[tmp]
     323            if tmp in modeldata._data.keys():
     324                #print "HERE", declaration.name, str(declaration.dimen),modeldata._data[tmp]
     325                if declaration.type() is Set:
     326                    data = self._tuplize(modeldata._data[tmp],declaration)
     327                else:
     328                    data = modeldata._data[tmp]
     329            else:
     330                data = None
     331            if pyomo.debug("generate"):           #pragma:nocover
     332                print "About to generate '"+declaration.name+"' with data: "+str(data)
     333                self.pprint()
     334            declaration.construct(data)
     335            try:
     336                pass
     337            except Exception, err:
     338                print "Error constructing declaration "+str(declaration.name)+" from data="+str(data)
     339                print "ERROR: "+str(err)
     340                raise err
    349341
    350342    def _load_solution(self,soln, symbol_map=None):
     
    511503                CON[ndx].display(prefix="    ",ostream=ostream)
    512504
     505ComponentRegistration("Model", Model, "Model objects can be used as a component of other models.")
  • coopr.pyomo/trunk/coopr/pyomo/base/component.py

    r1994 r2025  
    55        self.active=True
    66        self._type=ctype
     7        self.model=None
    78
    89    def activate(self):
     
    1516        return self._type
    1617
     18    def construct(self, data=None):
     19        pass
     20
  • coopr.pyomo/trunk/coopr/pyomo/base/constraint.py

    r2017 r2025  
    125125        return tmp
    126126
    127     def _construct(self, model, data):
     127    def construct(self, data=None):
    128128        if self.rule is not None:
    129129           if self._ndim==0:
    130               tmp = self._apply_rule((model,),None)
     130              tmp = self._apply_rule((self.model,),None)
    131131              if not tmp is None and not (type(tmp) in [int,long,float] and tmp == 0):
    132132                 self._data[None].expr = tmp
     
    138138                else:
    139139                   tmp = [val]
    140                 tmp.append(model)
     140                tmp.append(self.model)
    141141                tmp = tuple(tmp)
    142142                tmp = self._apply_rule(tmp,val)
     
    147147        for val in self._data:
    148148            if self._data[val].expr is not None:
    149                 self._data[val].expr = self._data[val].expr.simplify(model)
     149                self._data[val].expr = self._data[val].expr.simplify(self.model)
    150150
    151151    def pprint(self, ostream=None):
     
    234234            self._data[None].name=tmpname
    235235        self.rule = tmprule
    236         self._model = None
    237236
    238237    def __call__(self, exception=True):
     
    272271        return self._data.keys().__iter__()
    273272
    274     def _construct(self, model, data):
    275         self._model = model
     273    def construct(self, data=None):
    276274
    277275        if pyomo.debug("verbose") or pyomo.debug("normal"):     #pragma:nocover
     
    289287            if pyomo.debug("verbose"):                            #pragma:nocover
    290288                print "   Constructing constraint indices with rule that returns a dictionary"
    291             constraints = _self_rule(model)
     289            constraints = _self_rule(self.model)
    292290            for val in constraints:
    293291                if val not in self._index:
    294292                    raise IndexError, "The index "+str(val)+" generated by the constructor rule is not valid"
    295293                ##constructed_indices.append(val)
    296                 self._initialize_constraint(val, constraints[val], model, _self_name)
     294                self._initialize_constraint(val, constraints[val], _self_name)
    297295        else:
    298296            for val in self._index:
     
    300298                    print "   Constructing constraint index "+str(val)
    301299                if val is None:
    302                     expr = _self_rule(model)
     300                    expr = _self_rule(self.model)
    303301                    if expr is None or (type(expr) in [int,long,float] and expr == 0):
    304302                        continue
     
    308306                    else:
    309307                        tmp=[val]
    310                     tmp.append(model)
     308                    tmp.append(self.model)
    311309                    tmp=tuple(tmp)
    312310                    expr = _self_rule(*tmp)
     
    314312                        continue
    315313                ##constructed_indices.append(val)
    316                 self._initialize_constraint(val, expr, model, _self_name)
     314                self._initialize_constraint(val, expr, _self_name)
    317315        #self._index=constructed_indices
    318316
    319     def _initialize_constraint(self, val, expr, model, _name):
     317    def _initialize_constraint(self, val, expr, _name):
    320318        # val: the constraint index (should probably be renamed)
    321319        # expr: the constraint expression
     
    493491            if not isinstance(tpl[0],Expression):
    494492                tpl[0] = _IdentityExpression(tpl[0])
    495             tpl[0] = tpl[0].simplify(model)
     493            tpl[0] = tpl[0].simplify(self.model)
    496494        if tpl[1] is not None:
    497495            if not isinstance(tpl[1],Expression):
    498496                tpl[1] = _IdentityExpression(tpl[1])
    499             tpl[1] = tpl[1].simplify(model)
     497            tpl[1] = tpl[1].simplify(self.model)
    500498        if tpl[2] is not None:
    501499            if not isinstance(tpl[2],Expression):
    502500                tpl[2] = _IdentityExpression(tpl[2])
    503             tpl[2] = tpl[2].simplify(model)
     501            tpl[2] = tpl[2].simplify(self.model)
    504502        #
    505503        # Finally, setup the data
  • coopr.pyomo/trunk/coopr/pyomo/base/param.py

    r2022 r2025  
    5757    """
    5858    def __init__(self, *args, **kwd):
    59         tkwd = {'ctype':Param}
     59        tkwd = {'ctype':Param}
    6060        IndexedComponent.__init__(self, *args, **tkwd)
    6161        tmpname="unknown"
     
    6464        self._initialize={}
    6565        self._validate=None
    66         self._model=None
    6766        defaultval=None
    6867        for key in kwd.keys():
     
    159158            raise ValueError, "Cannot set parameter "+self.name+" with invalid value: index=" + str(ndx) + " value=" + str(val)
    160159
    161     def _construct(self, model, data):
     160    def construct(self, data=None):
    162161        """ Apply the rule to construct values in this set """
    163         self._model=model
    164162        if pyomo.debug("verbose"):      #pragma:nocover
    165163           print "Constructing Param, name="+self.name+", from data="+`data`
     
    234232              # singleton
    235233              tmp = []
    236               tmp.append(model)
     234              tmp.append(self.model)
    237235              tval = self._initialize(*tmp)
    238236              self.value = tval
     
    250248                 else:
    251249                       tname=_name
    252                  tmp.append(model)
     250                 tmp.append(self.model)
    253251                 tmp = tuple(tmp)
    254252                 tval = self._initialize(*tmp)
     
    263261           if index is not None:
    264262              tmp = tmp + list(index)
    265            tmp.append(self._model)
     263           tmp.append(self.model)
    266264           tmp = tuple(tmp)
    267265           if self._validate(*tmp):
  • coopr.pyomo/trunk/coopr/pyomo/base/rangeset.py

    r2001 r2025  
    5555           self._step=args[2]
    5656
    57     def _construct(self, model=None, values=None):
     57    def construct(self, values=None):
    5858        if isinstance(self._start,expr.Expression):
    5959           self._start_val = self._start()
  • coopr.pyomo/trunk/coopr/pyomo/base/sets.py

    r2011 r2025  
    5858        self.name="_unknown_"
    5959        self.validate=None
    60         self.model=None
    6160        self.ordered=False
    6261        self.order=[]
     
    176175        _BaseSet.__init__(self,**kwds)
    177176
    178     def _construct(self, model=None, values=None):
     177    def construct(self, values=None):
    179178        """ Apply the rule to construct values in this set """
    180179        log.debug("Constructing _SetContainer, name="+self.name+", from data="+repr(values))
     
    205204        #
    206205        elif type(self.initialize) is types.FunctionType:
    207            if model is None:
     206           if self.model is None:
    208207              raise ValueError, "Must pass a model in to initialize with a function"
    209208           if self.initialize.func_code.co_argcount == 1:
     
    211210              # Using a rule of the form f(model) -> iterator
    212211              #
    213               tmp = self.initialize(model)
     212              tmp = self.initialize(self.model)
    214213              for val in tmp:
    215214                if self.dimen is None:
     
    224223              #
    225224              ctr=0
    226               val = self.initialize(ctr,model)
     225              val = self.initialize(ctr,self.model)
    227226              if self.dimen is None:
    228227                   if type(val) in [tuple,list]:
     
    233232                self.add(val)
    234233                ctr += 1
    235                 val = self.initialize(ctr,model)
     234                val = self.initialize(ctr,self.model)
    236235           #
    237236           # We should be verifying as part of the add() method
     
    545544        if self.dimen != other.dimen:
    546545           raise ValueError, "Cannot perform set operation with sets "+self.name+" and "+other.name+" that have different element dimensions: "+str(self.dimen)+" "+str(other.dimen)
    547         def SetSymmetricDifferenceRule(model):
    548             Set1 = getattr(model,SetSymmetricDifferenceRule.Set1)
    549             Set2 = getattr(model,SetSymmetricDifferenceRule.Set2)
     546        def SetSymmetricDifferenceRule(M):
     547            Set1 = getattr(M,SetSymmetricDifferenceRule.Set1)
     548            Set2 = getattr(M,SetSymmetricDifferenceRule.Set2)
    550549            data = set()
    551550            for val in Set1:
     
    649648        else:
    650649           self.value[key] = Set(initialize=val,within=self.domain,validate=self.validate,ordered=self.ordered,name=self.name+"["+str(key)+"]",dimen=self.dimen)
    651            self.value[key]._construct(self.model)
     650           self.value[key].construct()
    652651
    653652    def __len__(self):
     
    695694          print >>ostream, "\t",self.name+"["+str(val)+"]\t",ttmp
    696695
    697     def _construct(self, model=None, values=None):
     696    def construct(self, values=None):
    698697        """ Apply the rule to construct values in each set"""
    699         self.model=model
    700698        log.debug("Constructing _SetArray, name="+self.name+", from data="+repr(values))
    701699        if self.virtual:                                #pragma:nocover
     
    713711                raise KeyError, "Cannot set index "+str(tmpkey)+" in array set "+self.name
    714712             self.value[tmpkey] = Set(initialize=values[key],within=self.domain,validate=self.validate,ordered=self.ordered,name=self.name+"["+str(tmpkey)+"]",dimen=self.dimen)
    715              self.value[tmpkey].model = model
    716              self.value[tmpkey]._construct(model)
     713             self.value[tmpkey].model = self.model
     714             self.value[tmpkey].construct()
    717715        #
    718716        # Construct using the rule
    719717        #
    720718        elif type(self.initialize) is types.FunctionType:
    721            if model is None:
     719           if self.model is None:
    722720              raise ValueError, "Need model to construct a set array with a function"
    723721           if self._index is None:
     
    729727                tmp = [key]
    730728             if self.initialize.func_code.co_argcount == len(tmp)+1:
    731                 tmp.append(model)
     729                tmp.append(self.model)
    732730                tmp = tuple(tmp)
    733731                rule_list = list(self.initialize(*tmp))
     
    735733                rule_list=[]
    736734                ctr=0
    737                 args = tuple(tmp+[ctr,model])
     735                args = tuple(tmp+[ctr,self.model])
    738736                val = self.initialize(*args)
    739737                while val is not None:
    740738                  rule_list.append(val)
    741739                  ctr += 1
    742                   args = tuple(tmp+[ctr,model])
     740                  args = tuple(tmp+[ctr,self.model])
    743741                  val = self.initialize(*args)
    744742             if self.dimen is None and len(rule_list) > 0:
     
    748746                        self.dimen=1
    749747             self.value[key] = Set(initialize=rule_list,within=self.domain,validate=self.validate,ordered=self.ordered,name=self.name+"["+str(key)+"]",dimen=self.dimen)
    750              self.value[key].model = model
    751              self.value[key]._construct(model)
     748             self.value[key].model = self.model
     749             self.value[key].construct()
    752750        #
    753751        # Construct using the default values
     
    758756                 for key in self._index:
    759757                   self.value[key] = Set(initialize=self.initialize,within=self.domain,validate=self.validate,ordered=self.ordered,name=self.name+"["+str(key)+"]",dimen=self.dimen)
    760                    self.value[key].model = model
    761                    self.value[key]._construct(model)
     758                   self.value[key].model = self.model
     759                   self.value[key].construct()
    762760              else:
    763761                 for key in self.initialize:
    764762                   self.value[key] = Set(initialize=self.initialize[key],within=self.domain,validate=self.validate,ordered=self.ordered,name=self.name+"["+str(key)+"]",dimen=self.dimen)
    765                    self.value[key].model = model
    766                    self.value[key]._construct(model)
     763                   self.value[key].model = self.model
     764                   self.value[key].construct()
    767765
    768766
     
    831829        return True
    832830       
    833     def _construct(self, model=None, values=None):
     831    def construct(self, values=None):
    834832        """ Apply the rule to construct values in this set """
    835833        log.debug("Constructing _ProductSet, name="+self.name+", from data="+repr(values))
     
    851849        #
    852850        elif type(self.initialize) is types.FunctionType:
    853            for val in self.initialize(model):
     851           for val in self.initialize(self.model):
    854852             self.add(val)
    855853        #
  • coopr.pyomo/trunk/coopr/pyomo/base/var.py

    r2017 r2025  
    169169        self.domain = tmpdomain
    170170        self.bounds=tmpbounds
    171         self._model=None
    172171
    173172    def as_numeric(self):
     
    219218        return self
    220219
    221     def _construct(self, model, data):
    222         self._model = model
     220    def construct(self, data=None):
    223221        #
    224222        # Construct _VarValue() objects for all index values
     
    257255             else:
    258256                tmp = [key]
    259              tmp.append(model)
     257             tmp.append(self.model)
    260258             tmp = tuple(tmp)
    261259             self._varval[key].value = None
     
    281279               else:
    282280                  tmp = [key]
    283                tmp.append(model)
     281               tmp.append(self.model)
    284282               tmp = tuple(tmp)
    285283               (lb, ub) = self.bounds(*tmp)
  • coopr.pyomo/trunk/coopr/pyomo/components/action.py

    r1999 r2025  
    3434        tmpname="unknown"
    3535        self.domain=None
    36         self._model=None
    3736        self._rule=None
    3837        for key in kwd.keys():
     
    5150        print >>ostream, "  ",self.name,":",
    5251
    53     def _construct(self, model, data):
     52    def construct(self, data=None):
    5453        """ Apply the rule to construct values in this set """
    55         self._model=model
    5654        if pyomo.debug("verbose"):      #pragma:nocover
    5755           print "Constructing Param, name="+self._name+", from data="+`data`
     
    6765              else:
    6866                 tmp = [val]
    69               tmp.append(model)
     67              tmp.append(self.model)
    7068              tmp = tuple(tmp)
    7169              self._rule(*tmp)
  • coopr.pyomo/trunk/coopr/pyomo/components/check.py

    r1999 r2025  
    3434        tmpname="unknown"
    3535        self.domain=None
    36         self._model=None
    3736        self._rule=None
    3837        for key in kwd.keys():
     
    5150        print >>ostream, "  ",self.name,":",
    5251
    53     def _construct(self, model, data):
     52    def construct(self, data=None):
    5453        """ Apply the rule to construct values in this set """
    55         self._model=model
    5654        if pyomo.debug("verbose"):      #pragma:nocover
    5755           print "Constructing Param, name="+self._name+", from data="+`data`
     
    6765              else:
    6866                 tmp = [val]
    69               tmp.append(model)
     67              tmp.append(self.model)
    7068              tmp = tuple(tmp)
    7169              res = self._rule(*tmp)
  • coopr.pyomo/trunk/coopr/pyomo/tests/examples/test6.txt

    r2005 r2025  
    1717 Constraint
    1818    Constraint expressions a model.
     19
     20 Model
     21    Model objects can be used as a component of other models.
    1922
    2023 Objective
  • coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_expr.py

    r1992 r2025  
    601601            #pass
    602602        try:
    603             model.a._construct(model,None)
     603            model.a.construct()
    604604            self.fail("Can't construct a parameter without data")
    605605        except ValueError:
  • coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_model.py

    r1994 r2025  
    203203        self.failUnlessFileEqualsBaseline(currdir+"solve1.out",currdir+"solve1.txt")
    204204
     205    def Xtest_solve5(self):
     206        """ A draft test for the option to select an objective """
     207        if not pyutilib.services.registered_executable("glpsol"):
     208            return
     209        self.model.A = RangeSet(1,4)
     210        self.model.x = Var(self.model.A, bounds=(-1,1))
     211        def obj1_rule(model):
     212          expr = 0
     213          for i in model.A:
     214            expr += model.x[i]
     215          return expr
     216        self.model.obj1 = Objective(rule=obj1_rule)
     217        def obj2_rule(model):
     218          expr = 0
     219          tmp=-1
     220          for i in model.A:
     221            expr += tmp*i*model.x[i]
     222            tmp *= -1
     223          return expr
     224        self.model.obj2 = Objective(rule=obj2_rule)
     225        self.instance = self.model.create()
     226        opt = SolverFactory('glpk', keepfiles=True)
     227        solutions = opt.solve(self.instance, objective='obj2')
     228        self.instance.load(solutions.solution())
     229        self.instance.display(currdir+"solve5.out")
     230        self.failUnlessFileEqualsBaseline(currdir+"solve5.out",currdir+"solve5a.txt")
     231
    205232if __name__ == "__main__":
    206233   unittest.main()
  • coopr.pyomo/trunk/coopr/pyomo/tests/unit/test_set.py

    r2015 r2025  
    230230        """Check that set union works"""
    231231        self.instance.tmp = self.instance.A | self.instance.tmpset3
    232         self.instance.tmp._construct(self.instance)
     232        self.instance.tmp.construct()
    233233        self.failUnlessEqual( self.instance.tmp == self.instance.setunion, True)
    234234
     
    236236        """Check that set intersection works"""
    237237        self.instance.tmp = self.instance.A & self.instance.tmpset3
    238         self.instance.tmp._construct(self.instance)
     238        self.instance.tmp.construct()
    239239        self.failUnlessEqual( self.instance.tmp == self.instance.setintersection, True)
    240240
    241241    def test_xor(self):
    242242        """Check that set exclusive or works"""
    243         self.tmp = self.instance.A ^ self.instance.tmpset3
    244         self.tmp._construct(self.instance)
    245         self.failUnlessEqual( self.tmp == self.instance.setxor, True)
     243        self.instance.tmp = self.instance.A ^ self.instance.tmpset3
     244        self.instance.tmp.construct()
     245        self.failUnlessEqual( self.instance.tmp == self.instance.setxor, True)
    246246
    247247    def test_diff(self):
    248248        """Check that set difference works"""
    249         self.tmp = self.instance.A - self.instance.tmpset3
    250         self.tmp._construct(self.instance)
    251         self.failUnlessEqual( self.tmp == self.instance.setdiff, True)
     249        self.instance.tmp = self.instance.A - self.instance.tmpset3
     250        self.instance.tmp.construct()
     251        self.failUnlessEqual( self.instance.tmp == self.instance.setdiff, True)
    252252
    253253    def test_mul(self):
    254254        """Check that set cross-product works"""
    255255        self.instance.tmp = self.instance.A * self.instance.tmpset3
    256         self.instance.tmp._construct(self.instance)
     256        self.instance.tmp.construct()
    257257        self.failUnlessEqual( self.instance.tmp == self.instance.setmul, True)
    258258
     
    462462    def test_constructor1(self):
    463463        a=RangeSet(10)
    464         a._construct()
     464        a.construct()
    465465        tmp=[]
    466466        for i in a:
     
    472472    def test_constructor2(self):
    473473        a=RangeSet(1,10,2)
    474         a._construct()
     474        a.construct()
    475475        tmp=[]
    476476        for i in a:
     
    20912091        a = Set(initialize={})
    20922092        try:
    2093             a._construct()
     2093            a.construct()
    20942094            self.fail("test_construct - expected failure constructing with a dictionary")
    20952095        except ValueError:
     
    20982098        a = Set(initialize=init_fn)
    20992099        try:
    2100             a._construct()
     2100            a.construct()
    21012101            self.fail("test_construct - expected exception due to None model")
    21022102        except ValueError:
     
    21232123    def test_eq(self):
    21242124        a=Set(dimen=1,name="a",initialize=[1,2])
    2125         a._construct()
     2125        a.construct()
    21262126        b=Set(dimen=2)
    21272127        self.failUnlessEqual(a==b,False)
     
    21312131    def test_neq(self):
    21322132        a=Set(dimen=1,initialize=[1,2])
    2133         a._construct()
     2133        a.construct()
    21342134        b=Set(dimen=2)
    21352135        self.failUnlessEqual(a!=b,True)
     
    21392139    def test_contains(self):
    21402140        a=Set(initialize=[1,3,5,7])
    2141         a._construct()
     2141        a.construct()
    21422142        b=Set(initialize=[1,3])
    2143         b._construct()
     2143        b.construct()
    21442144        self.failUnlessEqual(b in a, True)
    21452145        self.failUnlessEqual(a in b, False)
     
    21702170            pass
    21712171        a=Set(initialize=[1,3,5,7])
    2172         a._construct()
     2172        a.construct()
    21732173        b=Set(initialize=[1,3])
    2174         b._construct()
     2174        b.construct()
    21752175        self.failUnlessEqual(Reals >= b, True)
    21762176        self.failUnlessEqual(Reals >= [1,3,7], True)
     
    21852185            pass
    21862186        a=Set(initialize=[1,3,5,7])
    2187         a._construct()
     2187        a.construct()
    21882188        try:
    21892189            a < Reals
     
    21922192            pass
    21932193        b=Set(initialize=[1,3,5])
    2194         b._construct()
     2194        b.construct()
    21952195        self.failUnlessEqual(a<a,False)
    21962196        self.failUnlessEqual(b<a,True)
    21972197        c=Set(initialize=[(1,2)])
    2198         c._construct()
     2198        c.construct()
    21992199        try:
    22002200            a<c
     
    22052205    def test_gt(self):
    22062206        a=Set(initialize=[1,3,5,7])
    2207         a._construct()
     2207        a.construct()
    22082208        c=Set(initialize=[(1,2)])
    2209         c._construct()
     2209        c.construct()
    22102210        try:
    22112211            a>c
     
    22172217        a=Set(initialize=[1,2,3])
    22182218        c=Set(initialize=[(1,2)])
    2219         c._construct()
     2219        c.construct()
    22202220        try:
    22212221            Reals | Integers
     
    22372237        a=Set(initialize=[1,2,3])
    22382238        c=Set(initialize=[(1,2)])
    2239         c._construct()
     2239        c.construct()
    22402240        try:
    22412241            Reals & Integers
     
    22572257        a=Set(initialize=[1,2,3])
    22582258        c=Set(initialize=[(1,2)])
    2259         c._construct()
     2259        c.construct()
    22602260        try:
    22612261            Reals ^ Integers
     
    22772277        a=Set(initialize=[1,2,3])
    22782278        c=Set(initialize=[(1,2)])
    2279         c._construct()
     2279        c.construct()
    22802280        try:
    22812281            Reals - Integers
     
    22972297        a=Set(initialize=[1,2,3])
    22982298        c=Set(initialize=[(1,2)])
    2299         c._construct()
     2299        c.construct()
    23002300        try:
    23012301            Reals * Integers
     
    23172317    def test_arrayset_construct(self):
    23182318        a=Set(initialize=[1,2,3])
    2319         a._construct()
     2319        a.construct()
    23202320        b=Set(a, initialize=tmp_constructor)
    23212321        try:
    2322             b._construct(None,{4:None})
     2322            b.construct({4:None})
    23232323            self.fail("test_arrayset_construct - expected KeyError")
    23242324        except KeyError:
    23252325            pass
    23262326        try:
    2327             b._construct()
     2327            b.construct()
    23282328            self.fail("test_arrayset_construct - expected ValueError")
    23292329        except ValueError:
     
    23332333          self.failUnlessEqual(i in a, True)
    23342334        try:
    2335             b._construct(self.model)
     2335            b.construct()
    23362336            self.fail("test_arrayset_construct - expected ValueError")
    23372337        except ValueError:
     
    23402340    def test_prodset(self):
    23412341        a=Set(initialize=[1,2])
    2342         a._construct()
     2342        a.construct()
    23432343        b=Set(initialize=[6,7])
    2344         b._construct()
     2344        b.construct()
    23452345        c=a*b
    2346         c._construct()
     2346        c.construct()
    23472347        self.failUnlessEqual((6,2) in c, False)
    23482348        c=coopr.pyomo.base.sets._ProductSet(a,b)
     
    23522352        c=coopr.pyomo.base.sets._ProductSet()
    23532353        c.virtual=True
    2354         c._construct()
     2354        c.construct()
    23552355        c=coopr.pyomo.base.sets._ProductSet(a,b,initialize={(1,7):None,(2,6):None})
    2356         c._construct()
     2356        c.construct()
    23572357        c=coopr.pyomo.base.sets._ProductSet(a,b,initialize=(1,7))
    2358         c._construct()
     2358        c.construct()
    23592359
    23602360def virt_constructor(y,model):
     
    23652365    def test_construct(self):
    23662366        a=Set(initialize=[1,2,3])
    2367         a._construct()
     2367        a.construct()
    23682368        b=Set(a, initialize=virt_constructor)
    2369         #b._construct()
     2369        #b.construct()
    23702370
    23712371if __name__ == "__main__":
Note: See TracChangeset for help on using the changeset viewer.